const assert = require('node:assert/strict'); const {readFileSync} = require('node:fs'); const {test} = require('node:test'); const vm = require('node:vm'); const template = readFileSync(`${__dirname}/../templates/player/scripts.html`, 'utf8'); // Podcast episode playback in the web player and the podcasts store, run // on the production methods with stubbed audio, fetch and timers. const BASE = 'https://furumi.test/player'; const DIRECT = 'https://cdn.example/ep42.mp3'; const PROXY = '/api/podcasts/episodes/ep1:x/audio'; function episode(extra = {}) { const source = Object.assign({ kind: 'podcast_episode', episode_id: 'ep1:x', podcast_id: 'pod1:y', feed_url: 'https://podcasts.example/feed.xml', podcast_title: 'Example Cast', episode_title: 'Episode 42', audio_url: DIRECT, duration_ms: 1800000, }, extra); return { id: -11, title: 'Episode 42', unavailable: false, stream_url: '', duration_seconds: 1800, artists: [{id: -1, name: 'Example Cast'}], source, wire_track: {id: 0, title: 'Episode 42', source}, }; } const song = id => ({id, title: `Song ${id}`, stream_url: `/api/player/stream/${id}`}); function method(name) { const start = template.indexOf(`\n ${name}(`); const asyncStart = template.indexOf(`\n async ${name}(`); const at = start >= 0 ? start : asyncStart; assert.ok(at >= 0, `method ${name} not found`); const end = template.indexOf('\n },\n', at); return template.slice(at + 1, end + 11); } const PLAYER_METHODS = [ '_executeRemoteCommand', '_devicePlaybackStatePayload', '_remotePlaybackPayload', '_trackDuration', '_pauseLocal', '_playLocal', 'pause', 'resume', 'next', 'seek', 'playQueueIndex', '_knownPosition', '_currentItemHasLocalAudio', '_showUnplayableQueueItem', '_syncLocalPlaybackState', '_queueItemSourceKind', '_isUnplayableQueueItem', '_isPodcastEpisode', '_isPrivateQueueItem', '_playableQueueIndex', '_skipUnplayableCurrentItem', '_applyRemotePlaybackState', '_tickRemoteProgress', '_jamParticipantCommandAllowed', '_episodeRef', '_newEpisodeSessionId', '_episodeRequest', '_playEpisodeLocal', '_episodeAudioUrl', '_loadEpisodeAudio', '_episodeCanSeek', '_onEpisodeAudioError', '_startEpisodeSession', '_resumeEpisode', '_seekEpisode', '_episodePosition', '_episodeTick', '_onEpisodePaused', '_reportEpisode', '_endEpisode', '_episodeReportBody', '_takeOverEpisode', '_releaseEpisodeSession', '_resumeFromRegister', '_continuePausedEpisode', '_moveEpisodeAudio', '_rewindEpisode', 'prev', '_restoreState', '_restoredQueueTracks', ]; function eventAudio(extra = {}) { const listeners = {}; let src = ''; return Object.assign({ paused: true, currentTime: 0, duration: NaN, ended: false, played: [], seekable: {length: 1, start: () => 0, end: () => 3600}, get src() { return src; }, set src(value) { src = value ? new URL(value, BASE).href : ''; }, pause() { this.paused = true; }, play() { this.paused = false; this.played.push(src); return Promise.resolve(); }, removeAttribute(name) { if (name === 'src') src = ''; }, load() { this.currentTime = 0; }, addEventListener(type, fn) { (listeners[type] ||= []).push(fn); }, removeEventListener(type, fn) { listeners[type] = (listeners[type] || []).filter(other => other !== fn); }, fire(type) { [...(listeners[type] || [])].forEach(fn => fn()); }, }, extra); } function episodePlayer(queueTracks, currentIndex, options = {}) { const audio = eventAudio(options.audio); const calls = []; const beacons = []; const progress = []; let timers = []; const env = { audio, calls, beacons, progress, local: true, runTimers() { const due = timers; timers = []; due.forEach(fn => fn && fn()); }, }; const fetch = (url, init = {}) => new Promise((resolve, reject) => { calls.push({ url, keepalive: !!init.keepalive, body: init.body ? JSON.parse(init.body) : null, respond(data, status = 200) { resolve({ok: status < 400, status, json: async () => data}); }, fail(error) { reject(error); }, }); }); const queue = { tracks: queueTracks, currentIndex, _tracksWithJamDefaults: tracks => tracks, syncCurrentIndexToTrack(track) { const index = this.tracks.indexOf(track); if (index >= 0) this.currentIndex = index; }, }; const stores = {queue, devices: {heartbeat() {}}, podcasts: {episodeProgressChanged: (id, data) => progress.push([id, data])}}; let uuid = 0; const context = vm.createContext({ audio, fetch, URL, Blob, console, GUEST: false, T: {podcastSourceFailed: 'source failed', podcastCannotSeek: 'cannot seek', podcastRequestFailed: 'request failed'}, location: {protocol: new URL(options.base || BASE).protocol, href: options.base || BASE}, navigator: {sendBeacon(url, blob) { beacons.push({url, blob}); return true; }}, setTimeout(fn) { timers.push(fn); return timers.length; }, clearTimeout(id) { if (id) timers[id - 1] = null; }, crypto: {randomUUID: () => `uuid-${++uuid}`}, Alpine: {store: name => stores[name]}, }); vm.runInContext('this.methods = {' + PLAYER_METHODS.map(method).join('\n') + '};', context); env.context = context; env.stores = stores; env.queue = queue; env.player = Object.assign(context.methods, { currentTrack: queueTracks[currentIndex] || null, currentTime: 0, duration: 0, progress: 0, isPlaying: false, shuffle: false, repeatMode: 'off', volume: 0.5, _remoteStateBaseTime: 0, _remoteStateReceivedAt: 0, _positionUnknown: false, _listenedSeconds: 0, _lastAudioTime: 0, _localSourceTrackId: null, _historyTrack: null, episodeNotice: '', episodeLoading: false, _episode: null, _episodeToken: 0, _episodeSeekTimer: null, _episodeCheckpointMs: 20000, _episodeRewindSeconds: 15, _isLocalPlaybackDevice: () => env.local, _shouldSendRemote: () => false, _shouldMirrorRemoteLocally: () => false, _setVolumeLocal(v) { this.volume = v; }, _updateMediaSession() {}, _saveState() {}, _recordHistory() {}, _resetPlaybackTracking() { this._listenedSeconds = 0; }, _mirrorRemoteTrack() {}, _sendRemote() {}, }); stores.player = env.player; return env; } // The devices store's select() (the device picker), on the same stubs. function devicesStore(env, id = 'web-a') { vm.runInContext('this.devicesMethods = {' + method('select') + '};', env.context); const devices = Object.assign(env.context.devicesMethods, { id, activeDeviceId: id, open: true, selectError: '', applied: [], isActive() { return this.activeDeviceId === this.id; }, clearJamSelection() {}, async _errorText(res) { return (await res.json()).error; }, _apply(data) { this.applied.push(data); this.activeDeviceId = data.active_device_id; }, }); env.stores.devices = Object.assign(env.stores.devices, devices); return devices; } const flush = async () => { for (let i = 0; i < 20; i++) await new Promise(resolve => setImmediate(resolve)); }; function answer(call, extra = {}) { call.respond(Object.assign({ episode_id: 'ep1:x', podcast_id: 'pod1:y', session_id: call.body.start ? call.body.session_id : null, generation: call.body.start ? 4 : null, position_ms: call.body.position_ms ?? 600000, status: 'in_progress', duration_ms: 1800000, direct_url: DIRECT, proxy_url: null, mime: 'audio/mpeg', }, extra)); } test('an episode plays from its resume position and saves progress in the background', async () => { const env = episodePlayer([song(1), episode()], 0); const p = env.player; p.playQueueIndex(1); // Nothing plays before the server sent the source and the position. assert.equal(p.currentTrack.title, 'Episode 42'); assert.equal(env.audio.src, ''); assert.equal(p._devicePlaybackStatePayload().position_unknown, true); const [prepare] = env.calls; assert.equal(prepare.url, '/api/podcasts/episodes/ep1:x/playback'); assert.equal(prepare.body.start, true); assert.match(prepare.body.session_id, /^web-/); assert.equal(prepare.body.position_ms, undefined, 'ordinary Play resumes from the register'); assert.equal(prepare.body.episode.episode_id, 'ep1:x'); assert.equal(prepare.body.episode.kind, undefined, 'the reference, not the source wrapper'); answer(prepare); await flush(); assert.equal(env.audio.src, DIRECT); assert.deepEqual(env.audio.played, [], 'the audio starts after the seek'); env.audio.duration = 1800; env.audio.fire('loadedmetadata'); assert.equal(env.audio.currentTime, 600); assert.deepEqual(env.audio.played, [DIRECT]); const state = p._devicePlaybackStatePayload(); assert.equal(state.position_seconds, 600); assert.equal(state.position_unknown, undefined); // Checkpoints every 20 s at the session generation. p.isPlaying = true; env.audio.currentTime = 630; p._listenedSeconds = 30; p._episodeTick(); assert.equal(env.calls.length, 1, 'not before the interval'); p._episode.lastWriteAt -= 20000; p._episodeTick(); await flush(); const checkpoint = env.calls[1]; assert.equal(checkpoint.url, '/api/podcasts/episodes/ep1:x/progress'); const {started_at_ms: startedAt, ...body} = checkpoint.body; assert.equal(typeof startedAt, 'number'); assert.deepEqual(body, { session_id: prepare.body.session_id, generation: 4, event: 'checkpoint', position_ms: 630000, duration_ms: 1800000, listened_ms: 30000, start_position_ms: 600000, }); checkpoint.respond({outcome: 'written', generation: 4, status: 'in_progress', position_ms: 630000}); await flush(); // A seek is an explicit action, written once the user stops dragging. p.seek(300); assert.equal(env.audio.currentTime, 300); assert.equal(env.calls.length, 2); env.runTimers(); await flush(); const seek = env.calls[2]; assert.deepEqual([seek.body.event, seek.body.position_ms, seek.body.generation], ['seek', 300000, 4]); seek.respond({outcome: 'written', generation: 5, status: 'in_progress', position_ms: 300000}); await flush(); p._episode.lastWriteAt -= 20000; p._episodeTick(); await flush(); assert.equal(env.calls[3].body.generation, 5, 'later checkpoints use the explicit generation'); // Another device wrote the episode while nothing was listened here: // no more checkpoints at the old generation; a pause still records // the listening session (the register refuses it). env.calls[3].respond({outcome: 'superseded', generation: 9, status: 'in_progress', position_ms: 1000}); await flush(); p._episode.lastWriteAt -= 20000; p._episodeTick(); await flush(); assert.equal(env.calls.length, 4); p.isPlaying = false; p._onEpisodePaused(); await flush(); assert.equal(env.calls[4].body.event, 'pause'); env.calls[4].respond({outcome: 'superseded', generation: 9, status: 'in_progress', position_ms: 1000}); await flush(); assert.equal(env.calls.length, 5, 'nothing listened here since: no takeover'); // Play here again is an ordinary Play: a new session from the register. p.resume(); await flush(); const again = env.calls[5]; assert.deepEqual([again.body.start, again.body.position_ms], [true, undefined]); assert.notEqual(again.body.session_id, prepare.body.session_id); assert.deepEqual(env.audio.played.length, 1, 'not before the answer'); answer(again, {generation: 10, position_ms: 1000}); await flush(); assert.equal(env.audio.currentTime, 1); assert.equal(p._episode.generation, 10); assert.equal(env.audio.played.length, 2); assert.deepEqual(env.progress.map(([, data]) => data.outcome), ['written', 'written', 'superseded', 'superseded']); }); test('a stale episode answer never starts playback', async () => { const env = episodePlayer([song(1), episode()], 0); env.player.playQueueIndex(1); // The user moves on before the server answered. env.player.playQueueIndex(0); assert.equal(env.audio.src, 'https://furumi.test/api/player/stream/1'); answer(env.calls[0]); await flush(); env.audio.fire('loadedmetadata'); assert.equal(env.audio.src, 'https://furumi.test/api/player/stream/1'); assert.deepEqual(env.audio.played, ['https://furumi.test/api/player/stream/1']); assert.equal(env.player._episode, null); assert.equal(env.calls.length, 1, 'no progress for a session that never started'); }); test('a handed-off episode keeps its position, pause state and generation', async () => { const handed = episode({progress_generation: 7}); const env = episodePlayer([song(1)], 0); const p = env.player; p._executeRemoteCommand({command: 'transfer_state', payload: { tracks: [song(1), handed], index: 1, track: handed, position_seconds: 1200, paused: true, }}); const [prepare] = env.calls; assert.deepEqual( [prepare.body.start, prepare.body.position_ms, prepare.body.carried_generation, prepare.body.session_id], [false, 1200000, 7, null], ); let state = p._devicePlaybackStatePayload(); assert.deepEqual([state.position_seconds, state.paused, state.index], [1200, true, 1]); assert.equal(state.position_unknown, undefined); // Play is pressed while the source is still being prepared. p.resume(); answer(prepare); await flush(); const start = env.calls[1]; assert.deepEqual( [start.body.start, start.body.position_ms, start.body.carried_generation], [true, 1200000, 7], ); env.audio.fire('loadedmetadata'); assert.equal(env.audio.currentTime, 1200); assert.equal(env.audio.played.length, 1); answer(start, {generation: 8}); await flush(); assert.equal(p._episode.generation, 8); // Handing it on writes a final checkpoint at the session generation, // even after this device stopped being the active one. p.isPlaying = true; env.audio.currentTime = 1260; env.local = false; p._reportEpisode('handoff'); await flush(); const handoff = env.calls[2]; assert.deepEqual([handoff.body.event, handoff.body.generation, handoff.body.position_ms], ['handoff', 8, 1260000]); // The device that took over writes from now on. p._episode.lastWriteAt -= 20000; p._episodeTick(); p._onEpisodePaused(); await flush(); assert.equal(env.calls.length, 3); // A play command from another browser starts at the resume position. const remote = episodePlayer([song(1)], 0); remote.player._executeRemoteCommand({command: 'play_from_index', payload: { tracks: [song(1), handed], index: 1, track: handed, position_seconds: 0, paused: false, }}); assert.equal(remote.calls[0].body.position_ms, undefined); assert.equal(remote.calls[0].body.start, true); }); test('a source the browser cannot play falls back to the proxy and keeps the position', async () => { const env = episodePlayer([episode()], 0); const p = env.player; // init() registers _onEpisodeAudioError as the audio 'error' listener. p.playQueueIndex(0); answer(env.calls[0], {proxy_url: PROXY}); await flush(); assert.equal(env.audio.src, DIRECT); p.isPlaying = true; p._onEpisodeAudioError(); assert.equal(env.audio.src, `https://furumi.test${PROXY}`); env.audio.fire('loadedmetadata'); assert.equal(env.audio.currentTime, 600); assert.equal(env.audio.played.length, 1); // The proxy fails too: the user sees it and the position stays. p._onEpisodeAudioError(); assert.equal(p.episodeNotice, 'source failed'); assert.equal(p.isPlaying, false); assert.equal(p._devicePlaybackStatePayload().position_seconds, 600); // An error of an unloaded source is not this episode's. const quiet = episodePlayer([episode()], 0); quiet.player.playQueueIndex(0); answer(quiet.calls[0], {proxy_url: PROXY}); await flush(); quiet.audio.removeAttribute('src'); quiet.player._onEpisodeAudioError(); assert.equal(quiet.player.episodeNotice, ''); // On an https page an http:// file goes through the proxy at once. const mixed = episodePlayer([episode()], 0); mixed.player.playQueueIndex(0); answer(mixed.calls[0], {direct_url: 'http://cdn.example/ep42.mp3', proxy_url: PROXY}); await flush(); assert.equal(mixed.audio.src, `https://furumi.test${PROXY}`); // Without the proxy the publisher URL is used as it is. const direct = episodePlayer([episode()], 0); direct.player.playQueueIndex(0); answer(direct.calls[0], {direct_url: 'http://cdn.example/ep42.mp3'}); await flush(); assert.equal(direct.audio.src, 'http://cdn.example/ep42.mp3'); }); test('a server that cannot seek is never reported as resumed', async () => { const env = episodePlayer([episode()], 0, {audio: {seekable: {length: 0}}}); const p = env.player; p.playQueueIndex(0); answer(env.calls[0]); await flush(); env.audio.fire('loadedmetadata'); assert.equal(p.episodeNotice, 'cannot seek'); assert.deepEqual(env.audio.played, []); assert.equal(p.isPlaying, false); assert.equal(p._devicePlaybackStatePayload().position_seconds, 600, 'the saved position, not 0'); p.isPlaying = true; p._episode.lastWriteAt -= 20000; p._episodeTick(); p._onEpisodePaused(); await flush(); assert.equal(env.calls.length, 1, 'nothing overwrites the saved position'); // Play means: listen from the start, an explicit action at 0. p.resume(); await flush(); assert.deepEqual([env.calls[1].body.start, env.calls[1].body.position_ms], [true, 0]); assert.equal(env.audio.played.length, 1); assert.equal(p.episodeNotice, ''); // A seek the server silently ignored is caught as well. const silent = episodePlayer([episode()], 0); silent.player.playQueueIndex(0); answer(silent.calls[0]); await flush(); silent.audio.fire('loadedmetadata'); silent.audio.currentTime = 0; silent.audio.fire('seeked'); assert.equal(silent.player.episodeNotice, 'cannot seek'); assert.equal(silent.player._devicePlaybackStatePayload().position_seconds, 600); }); test('pause, the end of the stream and the next item report the session', async () => { const env = episodePlayer([episode(), song(2)], 0); const p = env.player; p.playQueueIndex(0); answer(env.calls[0], {generation: 2}); await flush(); env.audio.duration = 1800; env.audio.fire('loadedmetadata'); p.isPlaying = true; env.audio.currentTime = 700; p._listenedSeconds = 95; p.pause(); p._onEpisodePaused(); await flush(); const paused = env.calls[1]; assert.deepEqual([paused.body.event, paused.body.position_ms, paused.body.listened_ms], ['pause', 700000, 95000]); assert.equal(paused.body.start_position_ms, 600000); paused.respond({outcome: 'written', generation: 2, status: 'in_progress', position_ms: 700000}); await flush(); // The end of the stream: a pause event then 'ended'; only 'ended' reports. env.audio.ended = true; env.audio.currentTime = 1800; p._onEpisodePaused(); p._reportEpisode('ended'); await flush(); assert.equal(env.calls.length, 3); assert.equal(env.calls[2].body.event, 'ended'); env.calls[2].respond({outcome: 'written', generation: 3, status: 'completed', position_ms: 1800000, completed: true}); await flush(); assert.equal(p._episode.completed, true); // Play after the end listens again: a new session from the start. p.resume(); await flush(); assert.deepEqual([env.calls[3].body.start, env.calls[3].body.position_ms], [true, 0]); answer(env.calls[3], {generation: 4}); await flush(); env.audio.ended = false; env.audio.currentTime = 20; // The next item replaces the episode: a final stop, kept alive. p.playQueueIndex(1); await flush(); const stop = env.calls[4]; assert.deepEqual([stop.body.event, stop.body.generation, stop.keepalive], ['stop', 4, true]); assert.equal(p._episode, null); assert.equal(env.audio.src, 'https://furumi.test/api/player/stream/2'); }); test('a report always carries the position of its own episode', async () => { const env = episodePlayer([episode(), song(2)], 0); const p = env.player; p.playQueueIndex(0); answer(env.calls[0], {generation: 3}); await flush(); env.audio.fire('loadedmetadata'); env.audio.currentTime = 640; p._episode.lastPosition = 640; // While this browser was not playing, it showed another device's item. const other = episode({episode_id: 'ep1:other', episode_title: 'Other'}); p.currentTrack = other; p.currentTime = 1200; p._endEpisode('stop'); await flush(); const stop = env.calls[1]; assert.deepEqual([stop.body.event, stop.body.position_ms], ['stop', 640000], 'never the other item position'); // A browser that lost the playback role ends its session silently. const quiet = episodePlayer([episode()], 0); quiet.player.playQueueIndex(0); answer(quiet.calls[0]); await flush(); quiet.local = false; quiet.player._endEpisode('stop'); await flush(); assert.equal(quiet.calls.length, 1); assert.equal(quiet.player._episode, null); }); test('a player that loses the playback role records what it listened', async () => { // Another device took playback over (a pull): the stretch listened here // is recorded with this session, at its own generation. const env = episodePlayer([episode()], 0); const p = env.player; p.playQueueIndex(0); answer(env.calls[0], {generation: 3}); await flush(); env.audio.fire('loadedmetadata'); p.isPlaying = true; env.audio.currentTime = 900; p._listenedSeconds = 300; env.local = false; p._endEpisode('stop', {final: true}); await flush(); const stop = env.calls[1]; assert.deepEqual( [stop.body.event, stop.body.generation, stop.body.position_ms, stop.body.listened_ms, stop.keepalive], ['stop', 3, 900000, 300000, true], ); // The new device's explicit start wins: no takeover from here. stop.respond({outcome: 'superseded', generation: 4, status: 'in_progress', position_ms: 905000, session_recorded: true}); await flush(); assert.equal(env.calls.length, 2); assert.equal(p._episode, null); // After a handoff from here the final position was already sent. const pushed = episodePlayer([episode()], 0); pushed.player.playQueueIndex(0); answer(pushed.calls[0], {generation: 3}); await flush(); pushed.audio.fire('loadedmetadata'); pushed.player.isPlaying = true; pushed.player._listenedSeconds = 60; pushed.player._reportEpisode('handoff'); await flush(); pushed.local = false; pushed.player._endEpisode('stop', {final: true}); await flush(); assert.deepEqual(pushed.calls.slice(1).map(call => call.body.event), ['handoff']); }); test('a reload resumes an episode from the register, not from the saved player state', async () => { const env = episodePlayer([], 0); const p = env.player; const restoring = p._restoreState(); const [state] = env.calls; assert.equal(state.url, '/api/player/state'); // This page saved 10:00; another device listened to 40:00 since. state.respond({queue_items: [{kind: 'external', track: episode()}], queue_items_position: 0, position_ms: 600000}); await restoring; await flush(); const prepare = env.calls[1]; assert.equal(prepare.url, '/api/podcasts/episodes/ep1:x/playback'); assert.deepEqual([prepare.body.start, prepare.body.position_ms], [false, undefined]); answer(prepare, {position_ms: 2400000}); await flush(); env.audio.fire('loadedmetadata'); assert.equal(env.audio.currentTime, 2400); assert.deepEqual(env.audio.played, [], 'restored paused'); // Play continues there: an ordinary Play starts from the register. p.resume(); await flush(); const start = env.calls[2]; assert.deepEqual([start.body.start, start.body.position_ms], [true, undefined]); answer(start, {generation: 8, position_ms: 2400000}); await flush(); assert.equal(env.audio.currentTime, 2400); assert.equal(env.audio.played.length, 1); // A seek before Play is the user's choice and is sent. const seeking = episodePlayer([], 0); const restoringAgain = seeking.player._restoreState(); seeking.calls[0].respond({queue_items: [{kind: 'external', track: episode()}], queue_items_position: 0, position_ms: 600000}); await restoringAgain; await flush(); answer(seeking.calls[1], {position_ms: 2400000}); await flush(); seeking.audio.fire('loadedmetadata'); seeking.player.seek(120); seeking.runTimers(); seeking.player.resume(); await flush(); assert.deepEqual([seeking.calls[2].body.start, seeking.calls[2].body.position_ms], [true, 120000]); }); test('Play after a pause continues the session only while the register is its own', async () => { const env = episodePlayer([episode()], 0); const p = env.player; p.playQueueIndex(0); const sessionId = env.calls[0].body.session_id; answer(env.calls[0], {generation: 3}); await flush(); env.audio.fire('loadedmetadata'); p.isPlaying = false; p.resume(); await flush(); const check = env.calls[1]; assert.deepEqual([check.body.start, check.body.session_id], [false, undefined]); assert.equal(env.audio.played.length, 1, 'waits for the check'); answer(check, {register_session_id: sessionId, register_generation: 3}); await flush(); assert.equal(env.audio.played.length, 2); assert.equal(env.calls.length, 2, 'same session'); // While paused, a phone listened further: Play resumes from there. p.isPlaying = false; p.resume(); await flush(); answer(env.calls[2], {register_session_id: 'phone-g7', register_generation: 7, position_ms: 1500000}); await flush(); const start = env.calls[3]; assert.deepEqual([start.body.start, start.body.position_ms], [true, undefined]); assert.notEqual(start.body.session_id, sessionId); answer(start, {generation: 8, position_ms: 1500000}); await flush(); assert.equal(env.audio.currentTime, 1500); assert.equal(p._episode.generation, 8); assert.equal(env.audio.played.length, 3); }); test('a player that keeps listening after a supersede writes again as a new session', async () => { const env = episodePlayer([episode(), song(2)], 0); const p = env.player; p.playQueueIndex(0); const first = env.calls[0].body.session_id; answer(env.calls[0], {generation: 3}); await flush(); env.audio.duration = 1800; env.audio.fire('loadedmetadata'); p.isPlaying = true; env.audio.currentTime = 640; p._listenedSeconds = 40; p._episode.lastWriteAt -= 20000; p._episodeTick(); await flush(); // An offline device's older listening synced in with a higher generation. env.calls[1].respond({outcome: 'superseded', generation: 6, status: 'in_progress', position_ms: 200000}); await flush(); assert.equal(env.calls.length, 2, 'one interval first (a handoff may be on its way)'); env.audio.currentTime = 660; p._listenedSeconds = 60; p._episode.lastWriteAt -= 20000; p._episodeTick(); await flush(); // The old session's listening is recorded, then an explicit start here. const record = env.calls[2]; assert.deepEqual([record.body.event, record.body.session_id, record.body.listened_ms], ['stop', first, 60000]); record.respond({outcome: 'superseded', generation: 6, status: 'in_progress', position_ms: 200000, session_recorded: true}); await flush(); const takeover = env.calls[3]; assert.deepEqual( [takeover.url, takeover.body.start, takeover.body.position_ms], ['/api/podcasts/episodes/ep1:x/playback', true, 660000], ); assert.notEqual(takeover.body.session_id, first); answer(takeover, {generation: 7}); await flush(); assert.equal(p._episode.sessionId, takeover.body.session_id); assert.equal(p._episode.superseded, false); // Later checkpoints use the new session. env.audio.currentTime = 700; p._listenedSeconds = 40; p._episode.lastWriteAt -= 20000; p._episodeTick(); await flush(); assert.deepEqual( [env.calls[4].body.event, env.calls[4].body.session_id, env.calls[4].body.generation], ['checkpoint', takeover.body.session_id, 7], ); env.calls[4].respond({outcome: 'written', generation: 7, status: 'in_progress', position_ms: 700000}); await flush(); // Superseded again, and the stream ends here: the end still completes. env.audio.ended = true; env.audio.currentTime = 1800; p._listenedSeconds = 1100; p._reportEpisode('ended'); await flush(); const ended = env.calls[5]; assert.equal(ended.body.event, 'ended'); ended.respond({outcome: 'superseded', generation: 9, status: 'in_progress', position_ms: 100000, session_recorded: true}); await flush(); const again = env.calls[6]; assert.deepEqual([again.body.start, again.body.position_ms], [true, 1800000]); answer(again, {generation: 10, position_ms: 1800000}); await flush(); const complete = env.calls[7]; assert.deepEqual( [complete.body.event, complete.body.session_id, complete.body.generation, complete.body.started_at_ms], ['ended', again.body.session_id, 10, undefined], 'completes without a second listening session', ); complete.respond({outcome: 'written', generation: 10, status: 'completed', position_ms: 1800000, completed: true}); await flush(); assert.equal(p._episode.completed, true); }); test('marking the playing episode played or unplayed stops its session', async () => { const env = episodePlayer([episode()], 0); const p = env.player; p.playQueueIndex(0); answer(env.calls[0], {generation: 3}); await flush(); env.audio.fire('loadedmetadata'); p.isPlaying = true; env.audio.currentTime = 700; p._listenedSeconds = 100; const devices = {isControllingRemoteJam: () => false}; const {store, calls} = podcastsStore({player: p, devices, queue: env.queue}); store.loadDetail = () => {}; const marking = store.markUnplayed({episode_id: 'ep1:x'}); await flush(); // The listening so far is saved first, then the mark is written. const stop = env.calls[1]; assert.deepEqual([stop.body.event, stop.body.position_ms], ['stop', 700000]); assert.equal(calls.length, 0); stop.respond({outcome: 'written', generation: 3, status: 'in_progress', position_ms: 700000}); await marking; assert.equal(calls[0].url, '/api/podcasts/episodes/ep1:x/unplayed'); assert.equal(env.audio.paused, true); assert.equal(p._episode.sessionId, null); assert.equal(env.audio.currentTime, 0, 'where the register now is'); // Nothing from the old session overrides the mark. p._episode.lastWriteAt -= 20000; p._episodeTick(); p._onEpisodePaused(); await flush(); assert.equal(env.calls.length, 2); // Play starts a new session from the register. p.isPlaying = false; p.resume(); await flush(); assert.deepEqual([env.calls[2].body.start, env.calls[2].body.position_ms], [true, undefined]); }); test('Prev on an episode goes back a little instead of resetting its progress', async () => { const env = episodePlayer([song(1), episode()], 1); const p = env.player; p.playQueueIndex(1); answer(env.calls[0], {generation: 3}); await flush(); env.audio.fire('loadedmetadata'); p.isPlaying = true; env.audio.currentTime = 1500; p.currentTime = 1500; p.prev(); env.runTimers(); await flush(); assert.equal(env.audio.currentTime, 1485); assert.equal(env.calls.length, 1, 'no explicit write'); p._listenedSeconds = 20; p._episode.lastWriteAt -= 20000; p._episodeTick(); await flush(); assert.deepEqual( [env.calls[1].body.event, env.calls[1].body.position_ms, env.calls[1].body.generation], ['checkpoint', 1485000, 3], ); env.calls[1].respond({outcome: 'written', generation: 3, status: 'in_progress', position_ms: 1485000}); await flush(); // Within the first seconds Prev goes to the previous item. env.audio.currentTime = 2; p.currentTime = 2; p.prev(); await flush(); assert.equal(p.currentTrack.title, 'Song 1'); assert.equal(env.calls[2].body.event, 'stop'); }); test('a seek while the episode is being prepared is not lost', async () => { // "Start over" on the current episode before its source arrived. const env = episodePlayer([episode()], 0); const p = env.player; p.playQueueIndex(0); p.seek(0); answer(env.calls[0], {generation: 3, position_ms: 600000}); await flush(); const seek = env.calls[1]; assert.deepEqual([seek.body.event, seek.body.position_ms, seek.body.generation], ['seek', 0, 3]); env.audio.fire('loadedmetadata'); assert.equal(env.audio.currentTime, 0, 'not the old resume position'); env.runTimers(); await flush(); assert.equal(env.calls.length, 2, 'written once'); // Paused preparation: the next Play starts where the user moved it. const paused = episodePlayer([episode()], 0); paused.player._playLocal(episode(), {paused: true}); paused.player.seek(100); answer(paused.calls[0], {position_ms: 600000}); await flush(); paused.audio.fire('loadedmetadata'); assert.equal(paused.audio.currentTime, 100); paused.runTimers(); paused.player.resume(); await flush(); assert.deepEqual([paused.calls[1].body.start, paused.calls[1].body.position_ms], [true, 100000]); }); test('a mirrored Jam state never plays or saves an episode', async () => { const env = episodePlayer([song(1)], 0); env.player._syncLocalPlaybackState({tracks: [song(1), episode()], index: 1, track: episode(), position_seconds: 900, paused: false}); await flush(); assert.equal(env.calls.length, 0); assert.deepEqual(env.audio.played, []); assert.equal(env.player._devicePlaybackStatePayload().position_seconds, 900); }); // --------------------------------------------------------------------------- // Podcasts store // --------------------------------------------------------------------------- function podcastsStore(stores = {}, overrides = {}) { const start = template.indexOf(" Alpine.store('podcasts', {"); assert.ok(start >= 0); const open = template.indexOf('{', start); const end = template.indexOf('\n });\n', start); const calls = []; const context = vm.createContext({ T: { podcastSavedAt: 'Saved at', podcastLeft: 'left', podcastSeason: 'Season', podcastNoSeason: 'No season', podcastEpisodes: 'episodes', podcastUnplayed: 'unplayed', podcastSeasons: 'seasons', podcastFetchError: 'Last check failed', podcastLastChecked: 'Checked', podcastNeverChecked: 'Not checked yet', podcastJamBlocked: 'jam blocked', podcastRequestFailed: 'request failed', }, URLSearchParams, GUEST: false, fetch: async (url, init = {}) => { calls.push({url, init}); if (overrides.respond) return overrides.respond(url, init); return {ok: true, json: async () => ({})}; }, Alpine: {store: name => stores[name]}, }); Object.assign(context.T, overrides.T || {}); vm.runInContext('this.store = ' + template.slice(open, end + 6) + ';', context); return {store: context.store, calls}; } test('the podcasts store formats episodes and builds list queries', () => { const {store} = podcastsStore(); assert.equal(store.formatDuration(3723000), '1:02:03'); assert.equal(store.formatDuration(65000), '1:05'); assert.equal(store.formatDuration(0), ''); const inProgress = {status: 'in_progress', position_ms: 600000, duration_ms: 1800000}; assert.ok(Math.abs(store.progressPercent(inProgress) - 100 / 3) < 1e-9); assert.equal(store.progressLabel(inProgress), 'Saved at 10:00 · 20:00 left'); assert.equal(store.progressPercent({status: 'completed'}), 100); assert.equal(store.progressLabel({status: 'not_started'}), ''); assert.equal(store.seasonLabel({season: 2}), 'Season 2'); assert.equal(store.seasonLabel({season: null}), 'No season'); assert.equal(store.seasonValue({season: null}), 'none'); assert.equal(store.episodeMeta({season: 1, episode_number: 3, duration_ms: 120000}), 'S1 · E3 · 2:00'); assert.equal(store.fetchStatus({fetch: {last_error: 'HTTP 500'}}), 'Last check failed: HTTP 500'); assert.equal(store.fetchStatus({fetch: {}}), 'Not checked yet'); assert.equal( store.podcastCounts({episode_count: 12, unplayed_count: 3, season_count: 2}), '12 episodes · 3 unplayed · 2 seasons', ); store.season = 'none'; store.played = 'in_progress'; store.query = ' interview '; store.sort = 'oldest'; assert.equal(store._episodeQuery(50), 'season=none&played=in_progress&q=interview&sort=oldest&limit=50&offset=50'); store.season = 'all'; store.played = 'all'; store.query = ''; store.sort = 'newest'; assert.equal(store._episodeQuery(0), 'limit=50&offset=0'); }); test('sharing a feed URL that looks private asks first and sends back exactly the shown URLs', async () => { const secret = 'https://members.example/feed.xml?token=8f3a9c2e7d1b4a6f'; const warnings = [{reason: 'secret_query_parameter', name: 'token'}]; const privateShare = { shared: false, pending_confirmation: false, can_share: true, card_error: null, warnings, feed_url: secret, id_feed_url: null, discovery: 'running', published: false, }; const answers = []; const {store, calls} = podcastsStore({}, { T: { podcastSharePrivate: 'private', podcastSharePublished: 'published', podcastSharePublishing: 'publishing', podcastShareDiscoveryOff: 'discovery off', podcastSharePending: 'pending', podcastShareUnavailable: 'unavailable', podcastWarningSecretQuery: 'parameter «{name}»', podcastWarningPrivateHost: 'host {host}', podcastWarningEntropyQuery: 'value «{name}»', podcastWarningEntropyPath: 'path', podcastWarningOther: 'other', }, respond: async () => answers.shift(), }); store.current = {podcast_id: 'pod1:x', title: 'Members Only', subscribed: true}; store.share = privateShare; store.loadList = () => {}; assert.equal(store.shareStatus(), 'private'); assert.equal(store.warningText(warnings[0]), 'parameter «token»'); assert.equal(store.warningText({reason: 'private_feed_host', host: 'patreon.com'}), 'host patreon.com'); assert.equal(store.warningText({reason: 'something_new'}), 'other'); // The toggle opens the dialog instead of sharing. store.toggleShare(); assert.equal(calls.length, 0); assert.deepEqual(JSON.parse(JSON.stringify(store.shareDialog)), { podcastId: 'pod1:x', title: 'Members Only', warnings, feed_url: secret, id_feed_url: null, }); store.cancelShare(); assert.equal(store.shareDialog, null); assert.equal(calls.length, 0); // The feed moved meanwhile: the server asks about the new URL. const moved = Object.assign({}, privateShare, {feed_url: secret + '&v=2', id_feed_url: secret}); answers.push({ok: false, status: 409, json: async () => ({error: 'confirm', needs_confirmation: true, share: moved})}); store.toggleShare(); await store.confirmShare(); assert.equal(calls.length, 1); assert.equal(calls[0].url, '/api/podcasts/feeds/pod1:x/share'); assert.equal(calls[0].init.headers['Content-Type'], 'application/json'); assert.deepEqual(JSON.parse(calls[0].init.body), {shared: true, confirm: {feed_url: secret, id_feed_url: null}}); assert.equal(store.shareDialog.feed_url, secret + '&v=2'); assert.equal(store.shareDialog.id_feed_url, secret); assert.equal(store.shareError, ''); const published = Object.assign({}, moved, {shared: true, published: true}); answers.push({ok: true, status: 200, json: async () => ({podcast: {podcast_id: 'pod1:x', title: 'Members Only', subscribed: true, shared: true}, share: published})}); await store.confirmShare(); assert.deepEqual(JSON.parse(calls[1].init.body), { shared: true, confirm: {feed_url: secret + '&v=2', id_feed_url: secret}, }); assert.equal(store.shareDialog, null); assert.equal(store.shareStatus(), 'published'); assert.equal(store.sharing, false); // Turning it off needs no confirmation. answers.push({ok: true, status: 200, json: async () => ({podcast: store.current, share: privateShare})}); await store.toggleShare(); assert.deepEqual(JSON.parse(calls[2].init.body), {shared: false}); assert.equal(store.shareStatus(), 'private'); // States of the status line. store.share = Object.assign({}, privateShare, {shared: true, pending_confirmation: true}); assert.equal(store.shareStatus(), 'pending'); store.share = Object.assign({}, privateShare, {shared: true, discovery: 'off'}); assert.equal(store.shareStatus(), 'discovery off'); store.share = Object.assign({}, privateShare, {shared: true}); assert.equal(store.shareStatus(), 'publishing'); // A public feed is shared directly; a failure is shown. store.share = Object.assign({}, privateShare, {warnings: []}); answers.push({ok: false, status: 409, json: async () => ({error: 'not subscribed'})}); await store.toggleShare(); assert.deepEqual(JSON.parse(calls[3].init.body), {shared: true}); assert.equal(store.shareError, 'not subscribed'); assert.equal(store.shareDialog, null); }); test('playing an episode from the list puts it next in the queue', () => { const played = []; const queue = { tracks: [song(1), song(2)], effectiveCurrentIndex: () => 0, _tracksForQueueAdd: tracks => tracks.map(track => ({...track})), playFromIndex(index) { played.push(index); }, }; const player = {currentTrack: song(1), isPlaying: true, _episodeRef: () => null}; const devices = {isControllingRemoteJam: () => false}; const {store} = podcastsStore({queue, player, devices}); const item = {episode_id: 'ep1:x', track: episode()}; store.play(item); assert.deepEqual(queue.tracks.map(track => track.title), ['Song 1', 'Episode 42', 'Song 2']); assert.deepEqual(played, [1]); // A Jam guest cannot add the host's private items, nor their own. devices.isControllingRemoteJam = () => true; store.play(item); store.addToQueue(item); assert.equal(queue.tracks.length, 3); assert.equal(store.actionError, 'jam blocked'); }); test('a handoff that does not go through still records the listening when the role is lost later', async () => { const env = episodePlayer([episode()], 0); const p = env.player; const devices = devicesStore(env); p.playQueueIndex(0); answer(env.calls[0], {generation: 3}); await flush(); env.audio.fire('loadedmetadata'); p.isPlaying = true; env.audio.currentTime = 700; p._listenedSeconds = 100; // The user picks a device that needs an update for podcast episodes. const selecting = devices.select('tui-b'); await flush(); const handoff = env.calls[1]; assert.equal(handoff.body.event, 'handoff'); handoff.respond({outcome: 'written', generation: 3, status: 'in_progress', position_ms: 700000, session_recorded: true}); await flush(); const transfer = env.calls[2]; assert.equal(transfer.url, '/api/player/devices/active'); transfer.respond({error: 'the device needs an update'}, 409); await selecting; assert.equal(devices.selectError, 'the device needs an update'); assert.equal(devices.isActive(), true, 'this tab keeps playing'); // Ten more minutes here, then another device pulls playback. env.audio.currentTime = 1300; p._listenedSeconds = 700; env.local = false; p._endEpisode('stop', {final: true}); await flush(); assert.equal(env.calls.length, 4, 'a final report after the failed handoff'); const stop = env.calls[3]; assert.deepEqual( [stop.body.event, stop.body.generation, stop.body.position_ms, stop.body.listened_ms], ['stop', 3, 1300000, 700000], ); // A network error during the transfer is the same. const lost = episodePlayer([episode()], 0); const lostDevices = devicesStore(lost); lost.player.playQueueIndex(0); answer(lost.calls[0], {generation: 3}); await flush(); lost.audio.fire('loadedmetadata'); lost.player.isPlaying = true; lost.player._listenedSeconds = 30; const failing = lostDevices.select('tui-b'); await flush(); lost.calls[1].respond({outcome: 'written', generation: 3, status: 'in_progress', position_ms: 600000}); await flush(); lost.calls[2].fail(new Error('offline')); await failing; lost.player._listenedSeconds = 90; lost.local = false; lost.player._endEpisode('stop', {final: true}); await flush(); assert.deepEqual(lost.calls.slice(1).map(call => call.body?.event ?? call.url), ['handoff', '/api/player/devices/active', 'stop']); // A transfer that goes through: the new device writes, this one is quiet. const moved = episodePlayer([episode()], 0); const movedDevices = devicesStore(moved); moved.player.playQueueIndex(0); answer(moved.calls[0], {generation: 3}); await flush(); moved.audio.fire('loadedmetadata'); moved.player.isPlaying = true; moved.player._listenedSeconds = 30; const moving = movedDevices.select('tui-b'); await flush(); moved.calls[1].respond({outcome: 'written', generation: 3, status: 'in_progress', position_ms: 600000}); await flush(); moved.calls[2].respond({active_device_id: 'tui-b', playback_state: null}); await moving; assert.equal(movedDevices.isActive(), false); moved.local = false; moved.player._endEpisode('stop', {final: true}); await flush(); assert.deepEqual(moved.calls.slice(1).map(call => call.body?.event ?? call.url), ['handoff', '/api/player/devices/active']); }); test('Play after a failed source waits for the final report and resumes where the audio stopped', async () => { const env = episodePlayer([episode()], 0); const p = env.player; p.playQueueIndex(0); answer(env.calls[0], {generation: 3}); await flush(); env.audio.fire('loadedmetadata'); p.isPlaying = true; env.audio.currentTime = 640; p._listenedSeconds = 40; p._episode.lastWriteAt -= 20000; p._episodeTick(); await flush(); env.calls[1].respond({outcome: 'written', generation: 3, status: 'in_progress', position_ms: 640000}); await flush(); // 15 s later the publisher drops the stream; the user presses Play. // (timeupdate keeps the shown position in step with the audio.) env.audio.currentTime = 655; p.currentTime = 655; p._listenedSeconds = 55; p._onEpisodeAudioError(); assert.equal(p.episodeNotice, 'source failed'); p.resume(); await flush(); const stop = env.calls[2]; assert.deepEqual([stop.body.event, stop.body.generation, stop.body.position_ms], ['stop', 3, 655000]); assert.equal(env.calls.length, 3, 'the new session waits for the final report'); stop.respond({outcome: 'written', generation: 3, status: 'in_progress', position_ms: 655000, session_recorded: true}); await flush(); const prepare = env.calls[3]; assert.equal(prepare.url, '/api/podcasts/episodes/ep1:x/playback'); assert.equal(prepare.body.start, true); assert.equal(prepare.body.position_ms, undefined, 'from the register, which now has 655 s'); answer(prepare, {position_ms: 655000, generation: 4}); await flush(); env.audio.fire('loadedmetadata'); assert.equal(env.audio.currentTime, 655); // A final report that never answers holds the new session back only briefly. const slow = episodePlayer([episode()], 0); slow.player.playQueueIndex(0); answer(slow.calls[0], {generation: 3}); await flush(); slow.audio.fire('loadedmetadata'); slow.player.isPlaying = true; slow.audio.currentTime = 700; slow.player._listenedSeconds = 100; slow.player._onEpisodeAudioError(); slow.player.resume(); await flush(); assert.equal(slow.calls.length, 2); slow.runTimers(); await flush(); assert.equal(slow.calls.length, 3); assert.equal(slow.calls[2].url, '/api/podcasts/episodes/ep1:x/playback'); // Choosing another item meanwhile: the old episode is never prepared. const other = episodePlayer([episode(), song(2)], 0); other.player.playQueueIndex(0); answer(other.calls[0], {generation: 3}); await flush(); other.audio.fire('loadedmetadata'); other.player.isPlaying = true; other.audio.currentTime = 700; other.player._onEpisodeAudioError(); other.player.resume(); other.player.playQueueIndex(1); await flush(); other.calls[1].respond({outcome: 'written', generation: 3, status: 'in_progress', position_ms: 700000}); await flush(); assert.deepEqual(other.calls.map(call => call.url.split('/').pop()), ['playback', 'progress']); });