2026-11-19 16:58:29 +02:00
|
|
|
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');
|
|
|
|
|
|
|
|
|
|
// Queue items received from trusted devices that this player cannot play.
|
|
|
|
|
const podcast = {
|
|
|
|
|
id: -11, title: 'Episode 42', unavailable: true, stream_url: '',
|
|
|
|
|
source: {kind: 'podcast_episode', episode_id: 'ep1:x'},
|
|
|
|
|
wire_track: {id: 0, title: 'Episode 42', source: {kind: 'podcast_episode', episode_id: 'ep1:x'}},
|
|
|
|
|
};
|
|
|
|
|
const privateItem = {
|
|
|
|
|
id: -12, title: 'Private item', unavailable: true, stream_url: '',
|
|
|
|
|
source: {kind: 'private'}, wire_track: {id: 0, title: 'Private item', source: {kind: 'private'}},
|
|
|
|
|
};
|
|
|
|
|
const remoteMusic = {id: -13, title: 'Remote', unavailable: true, stream_url: '', wire_track: {id: 4, title: 'Remote'}};
|
|
|
|
|
const song = id => ({id, title: `Song ${id}`, stream_url: `/api/player/stream/${id}`});
|
|
|
|
|
|
|
|
|
|
function player(queue) {
|
|
|
|
|
// Exercise the production methods with audio and store stubs.
|
|
|
|
|
const methods = template.slice(
|
|
|
|
|
template.indexOf(' _queueItemSourceKind(track)'),
|
|
|
|
|
template.indexOf(' _saveState()'),
|
|
|
|
|
);
|
|
|
|
|
const audio = {paused: false, src: 'old', pause() { this.paused = true; }, removeAttribute(name) { if (name === 'src') this.src = ''; }, load() {}};
|
|
|
|
|
const stores = {queue: Object.assign({syncCurrentIndexToTrack() {}}, queue)};
|
|
|
|
|
const context = vm.createContext({
|
|
|
|
|
audio, T: {queuePodcastUnplayable: 'Podcast · not playable', queuePrivateItem: 'Private item · hidden'},
|
|
|
|
|
Alpine: {store: name => stores[name]},
|
|
|
|
|
});
|
|
|
|
|
vm.runInContext('this.methods = {' + methods + '};', context);
|
|
|
|
|
return Object.assign(context.methods, {audio, currentTrack: null, currentTime: 0, volume: 0.5, shuffle: false, repeatMode: 'off'});
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
test('podcast and private items are labelled and never played locally', () => {
|
|
|
|
|
const p = player({tracks: [], currentIndex: 0});
|
|
|
|
|
assert.equal(p._isUnplayableQueueItem(podcast), true);
|
|
|
|
|
assert.equal(p._isUnplayableQueueItem(privateItem), true);
|
|
|
|
|
assert.equal(p._isUnplayableQueueItem(remoteMusic), false);
|
|
|
|
|
assert.equal(p._isUnplayableQueueItem(song(1)), false);
|
|
|
|
|
assert.equal(p._unplayableQueueLabel(podcast), 'Podcast · not playable');
|
|
|
|
|
assert.equal(p._unplayableQueueLabel(privateItem), 'Private item · hidden');
|
|
|
|
|
assert.equal(p._unplayableQueueLabel(song(1)), '');
|
|
|
|
|
// A browser item that only carries the verbatim wire item is recognised too.
|
|
|
|
|
assert.equal(p._isUnplayableQueueItem({id: -1, wire_track: podcast.wire_track}), true);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
test('skipping finds the next playable item in the direction of travel', () => {
|
|
|
|
|
const p = player({tracks: [], currentIndex: 0});
|
|
|
|
|
const tracks = [song(1), podcast, privateItem, song(2)];
|
|
|
|
|
assert.equal(p._playableQueueIndex(tracks, 1, 1), 3);
|
|
|
|
|
assert.equal(p._playableQueueIndex(tracks, 2, -1), 0);
|
|
|
|
|
assert.equal(p._playableQueueIndex([podcast], 0, 1), -1);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
test('showing an unplayable item stops and unloads the previous audio', () => {
|
|
|
|
|
const p = player({tracks: [podcast], currentIndex: 0});
|
|
|
|
|
p.isPlaying = true;
|
|
|
|
|
p._showUnplayableQueueItem(podcast);
|
|
|
|
|
assert.equal(p.audio.paused, true);
|
|
|
|
|
assert.equal(p.audio.src, '');
|
|
|
|
|
assert.equal(p.isPlaying, false);
|
|
|
|
|
assert.equal(p.currentTrack, podcast);
|
|
|
|
|
assert.equal(p._historyTrack, null);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
test('persisted queue keeps external items verbatim and in order', () => {
|
|
|
|
|
const tracks = [song(1), podcast, remoteMusic, {id: 'pending', federation_pending: true}, song(2)];
|
|
|
|
|
const p = player({tracks, currentIndex: 4});
|
|
|
|
|
p.currentTrack = tracks[4];
|
|
|
|
|
p.currentTime = 12.3;
|
|
|
|
|
const state = p._buildStatePayload();
|
|
|
|
|
assert.deepEqual(JSON.parse(JSON.stringify(state.queue_items)), [
|
|
|
|
|
{kind: 'library', track_id: 1},
|
|
|
|
|
{kind: 'external', track: podcast.wire_track},
|
|
|
|
|
{kind: 'external', track: remoteMusic.wire_track},
|
|
|
|
|
{kind: 'library', track_id: 2},
|
|
|
|
|
]);
|
|
|
|
|
// The pending federation entry is not persisted, as before.
|
|
|
|
|
assert.equal(state.queue_items_position, 3);
|
|
|
|
|
// The legacy id list is unchanged for rollback.
|
|
|
|
|
assert.deepEqual(JSON.parse(JSON.stringify(state.queue)), [1, -11, -13, 2]);
|
|
|
|
|
assert.equal(state.current_track_id, 2);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
test('restoring merges library tracks and external items', () => {
|
|
|
|
|
const p = player({tracks: [], currentIndex: 0});
|
|
|
|
|
const restored = p._restoredQueueTracks([
|
|
|
|
|
{kind: 'library', track_id: 1},
|
|
|
|
|
{kind: 'external', track: podcast},
|
|
|
|
|
{kind: 'library', track_id: 99},
|
|
|
|
|
{kind: 'library', track_id: 2},
|
|
|
|
|
], [song(2), song(1)]);
|
|
|
|
|
assert.deepEqual(Array.from(restored.tracks, track => track.id), [1, -11, 2]);
|
|
|
|
|
assert.equal(restored.positions[3], 2);
|
|
|
|
|
assert.equal(restored.positions[2], undefined);
|
|
|
|
|
});
|
2026-11-19 18:35:49 +02:00
|
|
|
|
|
|
|
|
// Production methods by name, for flows that span several of them.
|
|
|
|
|
function method(name) {
|
|
|
|
|
const start = template.indexOf(`\n ${name}(`);
|
|
|
|
|
assert.ok(start >= 0, `method ${name} not found`);
|
|
|
|
|
const end = template.indexOf('\n },\n', start);
|
|
|
|
|
return template.slice(start + 1, end + 11);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
function activePlayer(queueTracks, currentIndex, audioState = {}) {
|
|
|
|
|
// The browser as the active (local) playback device.
|
|
|
|
|
const names = [
|
|
|
|
|
'_executeRemoteCommand', '_applyRemotePlaybackState', '_tickRemoteProgress',
|
|
|
|
|
'_devicePlaybackStatePayload', '_remotePlaybackPayload', '_trackDuration',
|
|
|
|
|
'_pauseLocal', '_playLocal', 'resume', 'next', 'playQueueIndex', 'seek',
|
|
|
|
|
'_skipUnplayableCurrentItem', '_currentItemHasLocalAudio', '_showUnplayableQueueItem',
|
|
|
|
|
'_queueItemSourceKind', '_isUnplayableQueueItem', '_playableQueueIndex',
|
|
|
|
|
];
|
|
|
|
|
const audio = Object.assign({
|
|
|
|
|
paused: true, currentTime: 0, duration: NaN, src: '',
|
|
|
|
|
played: [],
|
|
|
|
|
pause() { this.paused = true; },
|
|
|
|
|
play() { this.paused = false; this.played.push(this.src); return Promise.resolve(); },
|
|
|
|
|
removeAttribute(name) { if (name === 'src') this.src = ''; },
|
|
|
|
|
load() { this.currentTime = 0; },
|
|
|
|
|
addEventListener() {}, removeEventListener() {},
|
|
|
|
|
}, audioState);
|
|
|
|
|
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() {}}};
|
|
|
|
|
const context = vm.createContext({audio, Alpine: {store: name => stores[name]}});
|
|
|
|
|
vm.runInContext('this.methods = {' + names.map(method).join('\n') + '};', context);
|
|
|
|
|
return Object.assign(context.methods, {
|
|
|
|
|
audio, queue,
|
|
|
|
|
currentTrack: queueTracks[currentIndex] || null, currentTime: 0, duration: 0, progress: 0,
|
|
|
|
|
isPlaying: false, shuffle: false, repeatMode: 'off', volume: 0.5,
|
|
|
|
|
_remoteStateBaseTime: 0, _remoteStateReceivedAt: 0,
|
|
|
|
|
_isLocalPlaybackDevice: () => true, _shouldSendRemote: () => false,
|
|
|
|
|
_shouldMirrorRemoteLocally: () => false,
|
|
|
|
|
_setVolumeLocal(v) { this.volume = v; }, _updateMediaSession() {}, _saveState() {},
|
|
|
|
|
_recordHistory() {}, _resetPlaybackTracking() {}, _mirrorRemoteTrack() {},
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const episode = Object.assign({}, podcast, {duration_seconds: 1800});
|
|
|
|
|
|
|
|
|
|
test('handoff of a podcast episode keeps its position for the next handoff', () => {
|
|
|
|
|
for (const audioTime of [95, 0]) {
|
|
|
|
|
// <audio> still holds a music track (95 s) or the page is fresh (0 s).
|
|
|
|
|
const p = activePlayer([song(1)], 0, {currentTime: audioTime, src: '/api/player/stream/1'});
|
|
|
|
|
p._executeRemoteCommand({command: 'transfer_state', payload: {
|
|
|
|
|
tracks: [song(1), episode], index: 1, track: episode,
|
|
|
|
|
position_seconds: 1200, duration_seconds: 1800, paused: false,
|
|
|
|
|
}});
|
|
|
|
|
assert.equal(p.currentTrack, episode);
|
|
|
|
|
assert.equal(p.currentTime, 1200);
|
|
|
|
|
assert.equal(p.isPlaying, false);
|
|
|
|
|
assert.equal(p.audio.src, '', 'the previous track is unloaded');
|
|
|
|
|
const reported = p._devicePlaybackStatePayload();
|
|
|
|
|
assert.equal(reported.position_seconds, 1200);
|
|
|
|
|
assert.equal(reported.index, 1);
|
|
|
|
|
assert.equal(reported.paused, true);
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
test('library tracks still report the audio position', () => {
|
|
|
|
|
const p = activePlayer([song(1)], 0, {currentTime: 42, src: '/api/player/stream/1'});
|
|
|
|
|
p.currentTime = 40;
|
|
|
|
|
assert.equal(p._devicePlaybackStatePayload().position_seconds, 42);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
test('resume on an unplayable item skips it, also with repeat one', () => {
|
|
|
|
|
for (const repeatMode of ['one', 'off', 'all']) {
|
|
|
|
|
const p = activePlayer([podcast], 0);
|
|
|
|
|
p.repeatMode = repeatMode;
|
|
|
|
|
p.currentTime = 30;
|
|
|
|
|
p.resume();
|
|
|
|
|
p.next();
|
|
|
|
|
assert.equal(p.currentTrack, podcast);
|
|
|
|
|
assert.equal(p.isPlaying, false);
|
|
|
|
|
assert.equal(p.currentTime, 30, 'the item keeps its position');
|
|
|
|
|
assert.deepEqual(p.audio.played, []);
|
|
|
|
|
}
|
|
|
|
|
const p = activePlayer([song(1), podcast, song(2)], 1);
|
|
|
|
|
p.repeatMode = 'one';
|
|
|
|
|
p.resume();
|
|
|
|
|
assert.equal(p.currentTrack.id, 2);
|
|
|
|
|
assert.deepEqual(p.audio.played, ['/api/player/stream/2']);
|
|
|
|
|
// Repeat all wraps around to the first playable item.
|
|
|
|
|
const wrap = activePlayer([song(1), podcast], 1);
|
|
|
|
|
wrap.repeatMode = 'all';
|
|
|
|
|
wrap.resume();
|
|
|
|
|
assert.equal(wrap.currentTrack.id, 1);
|
|
|
|
|
});
|