forked from Furumi/furumi-web
Use the shared music_dht::device_sync types instead of private copies (byte-identical for v3 content, checked against the 0.12.x types and a golden fixture) and announce protocol 4, because every v4 element is kept: - podcast operations stay in the operation log and are relayed only to peers that reported v4; their registers and the podcast snapshot sections are merged with the shared rules into an opaque relay table and returned in this server's snapshots (m_0055); - the browser bridge carries PlaybackTrack.source: items that are not library tracks keep the verbatim wire item, so podcast episodes and Jam placeholders survive the round trip; the player labels and skips them instead of dropping them; - the typed queue is persisted in queue_items_json next to queue_json, which is still written for rollback (m_0054). Peer versions come from self-reports (profile_protocol_version); relayed profiles only raise them and DeviceProfileSet no longer stores this server's constant. Invites carry the inviter's version and a DeviceProfileSet announces v4 once. Handoffs of a podcast queue to a device below v4 are refused with an update message, and its playback commands are ignored while the queue has podcast items. Jam guests see podcast items as private placeholders, which are mapped back on their commands. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
99 lines
4.8 KiB
JavaScript
99 lines
4.8 KiB
JavaScript
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);
|
|
});
|