Files
QueueCube/web/backend/test/MediaPlayerFallback.test.cjs
T

104 lines
3.9 KiB
JavaScript

const test = require("node:test");
const assert = require("node:assert/strict");
const { MediaPlayer } = require("../build/MediaPlayer");
const makePlayer = (url = "https://example.test/watch?v=abc") => {
const player = Object.create(MediaPlayer.prototype);
const starts = [];
let stops = 0;
Object.assign(player, {
eventSubscribers: [],
playbackErrors: new Map(),
currentFile: url,
lastLoadCandidate: url,
activeEntryId: 42,
currentMediaTitle: null,
currentPlaybackMetadata: {},
dataBuffer: "",
loadGeneration: 4,
fallbackCandidates: new Map([[url, 4]]),
browserUrl: null,
browserFallback: {
isRunning: false,
start: async (requestedUrl, isCurrent) => {
starts.push(requestedUrl);
if (!isCurrent()) return false;
player.browserFallback.isRunning = true;
return true;
},
stop: async () => {
stops += 1;
player.browserFallback.isRunning = false;
},
},
writeCommand: async () => ({ data: [{ id: 42, filename: url }] }),
});
return { player, starts, get stops() { return stops; } };
};
const begin = (player, entryId = 42) => player.receiveData(`${JSON.stringify({ event: "start-file", playlist_entry_id: entryId })}\n`);
const send = (player, event) => player.receiveData(`${JSON.stringify({ event: "end-file", file: player.currentFile, playlist_entry_id: player.activeEntryId, ...event })}\n`);
const settle = () => new Promise((resolve) => setImmediate(resolve));
test("successful MPV completion does not start fallback", async () => {
const { player, starts } = makePlayer();
begin(player);
send(player, { reason: "eof" });
await settle();
assert.deepEqual(starts, []);
});
test("actual MPV error opens the exact original URL and mirrors indeterminate state", async () => {
const url = "https://example.test/watch?v=x&next=1;touch%20/tmp/nope";
const { player, starts } = makePlayer(url);
begin(player);
send(player, { reason: "error", file_error: "demux failed" });
await settle();
assert.deepEqual(starts, [url]);
assert.equal(player.browserUrl, url);
assert.equal((await player.getNowPlaying()).filename, url);
assert.equal(await player.getPauseState(), false);
assert.equal(await player.getIdle(), false);
assert.equal(await player.getTimePosition(), null);
assert.equal(await player.getDuration(), null);
assert.equal(await player.getSeekable(), false);
});
test("EOF and user stop, cancel, replacement, or stale queue events do not fallback", async () => {
const eof = makePlayer();
send(eof.player, { reason: "eof" });
for (const action of ["stop", "cancel", "replacement", "shutdown"]) {
const replacementUrl = "https://example.test/replacement";
const { player, starts } = makePlayer(replacementUrl);
player.writeCommand = async () => ({});
player.fetchMetadataAndNotify = async () => undefined;
if (action === "shutdown") await player.shutdown();
else if (action === "stop") await player.stop();
else if (action === "replacement") await player.replace(replacementUrl);
else await player.cancelBrowserFallback();
begin(player);
send(player, { reason: "error" });
await settle();
assert.deepEqual(starts, [], `${action} must invalidate the callback`);
}
const stale = makePlayer();
stale.player.currentFile = "https://example.test/next";
stale.player.activeEntryId = 43;
send(stale.player, { reason: "error", playlist_entry_id: 42 });
await settle();
assert.deepEqual(stale.starts, []);
});
test("fallback startup failure leaves MPV state usable", async () => {
const { player, starts } = makePlayer();
player.browserFallback.start = async () => { throw new Error("chromium missing"); };
begin(player);
send(player, { reason: "error" });
await settle();
assert.equal(player.browserUrl, null);
assert.deepEqual(starts, []);
assert.equal(player.playbackErrors.get(player.currentFile), "Unknown playback error");
});