peertube-plugin-live-casting 0.0.0-stage → 1.0.2

package/test/client.test.cjs

@@ -0,0 +1,269 @@
+const assert = require('node:assert/strict')
+const fs = require('node:fs')
+const path = require('node:path')
+const test = require('node:test')
+const vm = require('node:vm')
+
+const source = fs.readFileSync(path.join(__dirname, '../client/common-client-plugin.js'), 'utf8')
+  .replace("import './style.scss'", '')
+  .replace(/export \{\s*register\s*\}/, '')
+
+function setup (ChromecastTech = class {}) {
+  const hooks = new Map()
+  const scripts = []
+  const registrations = []
+  let registeredTech = ChromecastTech
+  const videojs = {
+    getTech: () => registeredTech,
+    registerTech: (name, tech) => {
+      assert.equal(name, 'chromecast')
+      registeredTech = tech
+    }
+  }
+  const context = vm.createContext({
+    require: name => () => registrations.push(name),
+    console,
+    setInterval,
+    clearInterval,
+    window: {
+      chrome: { cast: { media: { StreamType: { LIVE: 'LIVE' } } } }
+    },
+    document: {
+      createElement: () => ({}),
+      body: { appendChild: script => scripts.push(script) }
+    }
+  })
+  vm.runInContext(source, context)
+  context.register({
+    registerHook: hook => hooks.set(hook.target, hook.handler),
+    peertubeHelpers: { getSettings: async () => ({ 'chromecast-receiver-app-id': 'receiver' }) }
+  })
+
+  return {
+    context,
+    scripts,
+    registrations,
+    videojs,
+    load: video => hooks.get('action:video-watch.video.loaded')({ videojs, video }),
+    options: () => hooks.get('filter:internal.player.videojs.options.result')({
+      plugins: { existing: {} }
+    })
+  }
+}
+
+const playlistUrl = 'https://example.com/live/master.m3u8?token=test'
+const mp4Url = 'https://example.com/videos/video.mp4'
+
+async function casting (video) {
+  const client = setup()
+  await client.load(video)
+  client.context.window.__onGCastApiAvailable(true)
+  const options = await client.options()
+  return { client, options, modify: options.chromecast.modifyLoadRequestFn }
+}
+
+function request (contentId) {
+  return {
+    media: { contentId, contentType: 'original', duration: 120, streamType: 'BUFFERED' },
+    currentTime: 42,
+    autoplay: true
+  }
+}
+
+test('live metadata selects the HLS playlist and live receiver payload', async () => {
+  const { modify, options } = await casting({
+    isLive: true,
+    files: [{ fileUrl: mp4Url }],
+    streamingPlaylists: [{ playlistUrl }]
+  })
+  const payload = request('blob:local-player-source')
+  assert.equal(modify(payload), payload)
+  assert.equal(payload.media.contentId, playlistUrl)
+  assert.equal(payload.media.contentType, 'application/x-mpegURL')
+  assert.equal(payload.media.streamType, 'LIVE')
+  assert.equal(payload.media.hlsSegmentFormat, 'ts')
+  assert.equal(payload.media.hlsVideoSegmentFormat, 'mpeg2_ts')
+  assert.equal('duration' in payload.media, false)
+  assert.equal('currentTime' in payload, false)
+  assert.equal(payload.autoplay, true)
+  assert.equal(options.plugins.chromecast.receiverAppID, 'receiver')
+  assert.ok(options.plugins.existing)
+})
+
+test('a playlist without static files is live when metadata is absent', async () => {
+  const { modify } = await casting({ streamingPlaylists: [{ playlistUrl }] })
+  const payload = modify(request('blob:local-player-source'))
+  assert.equal(payload.media.contentId, playlistUrl)
+  assert.equal(payload.media.streamType, 'LIVE')
+})
+
+test('HLS-only VOD metadata prevents false live detection', async () => {
+  const { modify } = await casting({
+    isLive: false,
+    files: [],
+    streamingPlaylists: [{ playlistUrl }]
+  })
+  const payload = modify(request(playlistUrl))
+  assert.equal(payload.media.contentType, 'application/x-mpegURL')
+  assert.equal(payload.media.hlsSegmentFormat, 'fmp4')
+  assert.equal(payload.media.hlsVideoSegmentFormat, 'fmp4')
+  assert.equal(payload.media.streamType, 'BUFFERED')
+  assert.equal(payload.currentTime, 42)
+  assert.equal(payload.media.duration, 120)
+})
+
+test('static MP4 extraction handles query strings and retains buffered playback', async () => {
+  const fileUrl = `${mp4Url}?token=test`
+  const { modify } = await casting({ files: [{ fileUrl }], isLive: false })
+  const payload = modify(request('blob:local-player-source'))
+  assert.equal(payload.media.contentId, fileUrl)
+  assert.equal(payload.media.contentType, 'video/mp4')
+  assert.equal(payload.media.streamType, 'BUFFERED')
+  assert.equal(payload.currentTime, 42)
+  assert.equal('hlsSegmentFormat' in payload.media, false)
+})
+
+test('VOD preserves the player-selected MP4 rendition', async () => {
+  const { modify } = await casting({ files: [{ fileUrl: mp4Url }], isLive: false })
+  const selected = 'https://example.com/videos/720.MP4#fragment'
+  assert.equal(modify(request(selected)).media.contentId, selected)
+})
+
+test('navigation updates casting state even after SDK initialization', async () => {
+  const { client, modify } = await casting({
+    isLive: true,
+    streamingPlaylists: [{ playlistUrl }]
+  })
+  await client.load({ isLive: false, files: [{ fileUrl: mp4Url }] })
+  const payload = modify(request(mp4Url))
+  assert.equal(payload.media.contentId, mp4Url)
+  assert.equal(payload.media.contentType, 'video/mp4')
+  assert.equal(payload.media.streamType, 'BUFFERED')
+  assert.equal(client.scripts.length, 1)
+  assert.equal(client.registrations.length, 1)
+  await client.load({ isLive: true, streamingPlaylists: [{ playlistUrl }] })
+  assert.equal(modify(request('blob:local-player-source')).media.contentId, playlistUrl)
+})
+
+test('stale live state does not hijack a VOD MP4 source', async () => {
+  const { modify } = await casting({ isLive: true, streamingPlaylists: [{ playlistUrl }] })
+  const payload = modify(request(mp4Url))
+  assert.equal(payload.media.contentId, mp4Url)
+  assert.equal(payload.media.contentType, 'video/mp4')
+  assert.equal(payload.media.streamType, 'BUFFERED')
+  assert.equal(payload.currentTime, 42)
+  assert.equal(payload.media.duration, 120)
+})
+
+test('missing video metadata preserves the source provided by the player', async () => {
+  const { modify } = await casting(undefined)
+  const payload = modify(request(mp4Url))
+  assert.equal(payload.media.contentId, mp4Url)
+  assert.equal(payload.media.contentType, 'video/mp4')
+})
+
+test('incomplete hook metadata does not throw or replace the player source', async () => {
+  const { modify } = await casting({ files: {}, streamingPlaylists: {} })
+  const payload = modify(request(mp4Url))
+  assert.equal(payload.media.contentId, mp4Url)
+  assert.equal(payload.media.contentType, 'video/mp4')
+})
+
+test('null playlist and file entries are ignored', async () => {
+  const { modify } = await casting({
+    isLive: true,
+    files: [null],
+    streamingPlaylists: [null, { playlistUrl }]
+  })
+  const payload = modify(request('blob:local-player-source'))
+  assert.equal(payload.media.contentId, playlistUrl)
+  assert.equal(payload.media.hlsSegmentFormat, 'ts')
+  assert.equal(payload.media.hlsVideoSegmentFormat, 'mpeg2_ts')
+})
+
+test('AirPlay and unavailable Chromecast keep their existing player options', async () => {
+  const client = setup()
+  client.context.window.WebKitPlaybackTargetAvailabilityEvent = function () {}
+  await client.load({ isLive: true, streamingPlaylists: [{ playlistUrl }] })
+  client.context.window.__onGCastApiAvailable(false)
+  const options = await client.options()
+  assert.ok(options.plugins.airPlay)
+  assert.ok(options.plugins.existing)
+  assert.equal(options.chromecast, undefined)
+  assert.deepEqual(client.registrations, ['@silvermine/videojs-airplay'])
+})
+
+test('Chromecast tech supports seeking queries from PeerTube play and pause handlers', async () => {
+  class ChromecastTech {
+    setCurrentTime (time) { this.currentTime = time }
+  }
+  const client = setup(ChromecastTech)
+  await client.load({ isLive: true, streamingPlaylists: [{ playlistUrl }] })
+  client.context.window.__onGCastApiAvailable(true)
+  const tech = new (client.videojs.getTech('Chromecast'))()
+  assert.equal(tech.seeking(), false)
+  tech.setCurrentTime(42)
+  assert.equal(tech.currentTime, 42)
+  assert.equal(tech.seeking(), false)
+  assert.equal(ChromecastTech.prototype.seeking, undefined)
+})
+
+test('missing videojs reference does not throw during seeking compatibility', async () => {
+  const client = setup()
+  await client.load({ files: [{ fileUrl: mp4Url }] })
+  assert.doesNotThrow(() => client.context.registerChromecastSeekingCompatibility(undefined))
+  assert.doesNotThrow(() => client.context.registerChromecastSeekingCompatibility({ getTech: () => undefined }))
+})
+
+test('an existing Chromecast seeking implementation is preserved', async () => {
+  class ChromecastTech {
+    seeking () { return true }
+  }
+  const client = setup(ChromecastTech)
+  await client.load({ files: [{ fileUrl: mp4Url }] })
+  client.context.window.__onGCastApiAvailable(true)
+  assert.equal(client.videojs.getTech('Chromecast'), ChromecastTech)
+  assert.equal(new ChromecastTech().seeking(), true)
+})
+
+test('real upstream tech retains VOD seeking and play/pause queries do not throw', () => {
+  const client = setup()
+  client.videojs.getComponent = () => class {}
+  require('@silvermine/videojs-chromecast/src/js/tech/ChromecastTech')(client.videojs)
+  const UpstreamTech = client.videojs.getTech('Chromecast')
+  client.context.registerChromecastSeekingCompatibility(client.videojs)
+  const CompatibleTech = client.videojs.getTech('Chromecast')
+  assert.equal(CompatibleTech.canPlaySource, UpstreamTech.canPlaySource)
+  assert.equal(CompatibleTech.isSupported, UpstreamTech.isSupported)
+
+  const tech = Object.create(CompatibleTech.prototype)
+  const events = []
+  let seekCommands = 0
+  tech.trigger = event => {
+    events.push(event)
+    if (event === 'play' || event === 'playing' || event === 'pause') {
+      assert.equal(tech.seeking(), false)
+    }
+  }
+  tech._remotePlayer = { duration: 120, canSeek: true, playerState: 'PLAYING' }
+  tech._hasPlayedAnyItem = true
+  tech._remotePlayerController = { seek: () => { seekCommands++ } }
+  tech.setCurrentTime(42)
+  assert.equal(tech._remotePlayer.currentTime, 42)
+  assert.equal(seekCommands, 1)
+  client.context.chrome = {
+    cast: { media: { PlayerState: { PLAYING: 'PLAYING', PAUSED: 'PAUSED' } } }
+  }
+  // Upstream code runs in Node, so supply the same SDK global for its event handler.
+  const previousChrome = global.chrome
+  global.chrome = client.context.chrome
+  try {
+    tech._onPlayerStateChanged()
+    tech._remotePlayer.playerState = 'PAUSED'
+    tech._onPlayerStateChanged()
+    assert.deepEqual(events, ['timeupdate', 'play', 'playing', 'pause'])
+  } finally {
+    if (previousChrome === undefined) delete global.chrome
+    else global.chrome = previousChrome
+  }
+})

package/test/media-session.test.cjs

@@ -0,0 +1,68 @@
+const assert = require('node:assert/strict')
+const test = require('node:test')
+const fs = require('node:fs')
+const { attachMediaSessionListener } = require('../client/media-session-listener')
+const { patchChromecastTech } = require('../scripts/chromecast-compatibility')
+
+function setup () {
+  const callbacks = []
+  const session = {}
+  const tech = {
+    mediaSession: null,
+    _eventListeners: [],
+    _getMediaSession () { return this.mediaSession },
+    _onMediaSessionStatusChanged (alive) { this.alive = alive },
+    _addEventListener (target, type, callback) {
+      this._eventListeners.push({ target, type, callback })
+    },
+    _removeEventListener (listener) {
+      assert.ok(listener)
+      this._eventListeners.splice(this._eventListeners.indexOf(listener), 1)
+    }
+  }
+  const mediaSession = { addUpdateListener: callback => callbacks.push(callback) }
+  return { tech, session, mediaSession, callbacks }
+}
+
+test('available media session gets its update listener immediately', () => {
+  const { tech, session, mediaSession, callbacks } = setup()
+  tech.mediaSession = mediaSession
+  attachMediaSessionListener(tech, session, 'MEDIA_SESSION')
+  assert.equal(callbacks.length, 1)
+  assert.equal(tech._eventListeners.length, 0)
+  callbacks[0](false)
+  assert.equal(tech.alive, false)
+})
+
+test('null session waits for SDK event and then removes the temporary listener', () => {
+  const { tech, session, mediaSession, callbacks } = setup()
+  attachMediaSessionListener(tech, session, 'MEDIA_SESSION')
+  assert.equal(callbacks.length, 0)
+  assert.equal(tech._eventListeners.length, 1)
+  const listener = tech._eventListeners[0]
+  assert.equal(listener.target, session)
+  assert.equal(listener.type, 'MEDIA_SESSION')
+  listener.callback()
+  assert.equal(tech._eventListeners.length, 1)
+  tech.mediaSession = mediaSession
+  listener.callback()
+  assert.equal(callbacks.length, 1)
+  assert.equal(tech._eventListeners.length, 0)
+})
+
+test('temporary listener participates in upstream disposal cleanup', () => {
+  const { tech, session } = setup()
+  attachMediaSessionListener(tech, session, 'MEDIA_SESSION')
+  while (tech._eventListeners.length) tech._removeEventListener(tech._eventListeners[0])
+  assert.equal(tech._eventListeners.length, 0)
+})
+
+test('build patch matches the pinned upstream tech and fails on changed code', () => {
+  const source = fs.readFileSync(
+    require.resolve('@silvermine/videojs-chromecast/src/js/tech/ChromecastTech'), 'utf8'
+  )
+  const patched = patchChromecastTech(source)
+  assert.ok(patched.includes('attachMediaSessionListener(this, castSession, cast.framework.SessionEventType.MEDIA_SESSION)'))
+  assert.ok(!patched.includes('this._getMediaSession().addUpdateListener('))
+  assert.throws(() => patchChromecastTech('changed upstream source'), /does not match/)
+})