mirror of
https://github.com/ksyasuda/SubMiner.git
synced 2026-10-21 05:01:26 -07:00
448 lines
13 KiB
TypeScript
448 lines
13 KiB
TypeScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import {
|
|
markJellyfinRemotePlaybackLoaded,
|
|
createJellyfinRemoteReportTracker,
|
|
createReportJellyfinRemoteProgressHandler,
|
|
createReportJellyfinRemoteStoppedHandler,
|
|
secondsToJellyfinTicks,
|
|
shouldAutoLoadSecondarySubTrackForJellyfinPlayback,
|
|
} from './jellyfin-remote-playback';
|
|
import type {
|
|
ActiveJellyfinRemotePlaybackState,
|
|
JellyfinPlaybackReporterLike,
|
|
} from './jellyfin-remote-commands';
|
|
|
|
type ProgressDeps = Parameters<typeof createReportJellyfinRemoteProgressHandler>[0];
|
|
type StoppedDeps = Parameters<typeof createReportJellyfinRemoteStoppedHandler>[0];
|
|
|
|
const TICKS_PER_SECOND = 10_000_000;
|
|
|
|
const makeReporter = (
|
|
overrides: Partial<JellyfinPlaybackReporterLike> = {},
|
|
): JellyfinPlaybackReporterLike => ({
|
|
reportPlaying: async () => {},
|
|
reportProgress: async () => {},
|
|
reportStopped: async () => {},
|
|
...overrides,
|
|
});
|
|
|
|
const makePlayback = (
|
|
overrides: Partial<ActiveJellyfinRemotePlaybackState> = {},
|
|
): ActiveJellyfinRemotePlaybackState => ({
|
|
itemId: 'item-1',
|
|
playMethod: 'DirectPlay',
|
|
reporter: makeReporter(),
|
|
...overrides,
|
|
});
|
|
|
|
function makeProgressDeps(overrides: Partial<ProgressDeps> = {}): ProgressDeps {
|
|
return {
|
|
getActivePlayback: () => makePlayback(),
|
|
clearActivePlayback: () => {},
|
|
getMpvClient: () => ({ requestProperty: async () => 1 }),
|
|
getNow: () => 5000,
|
|
getLastProgressAtMs: () => 0,
|
|
setLastProgressAtMs: () => {},
|
|
progressIntervalMs: 3000,
|
|
ticksPerSecond: TICKS_PER_SECOND,
|
|
logDebug: () => {},
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
function makeStoppedDeps(overrides: Partial<StoppedDeps> = {}): StoppedDeps {
|
|
return {
|
|
getActivePlayback: () => makePlayback({ loadedMediaPath: 'https://stream.example/video.m3u8' }),
|
|
clearActivePlayback: () => {},
|
|
getMpvClient: () => ({ currentTimePos: 0 }),
|
|
ticksPerSecond: TICKS_PER_SECOND,
|
|
logDebug: () => {},
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
test('secondsToJellyfinTicks converts seconds and clamps invalid values', () => {
|
|
assert.equal(secondsToJellyfinTicks(1.25, 10_000_000), 12_500_000);
|
|
assert.equal(secondsToJellyfinTicks(-3, 10_000_000), 0);
|
|
assert.equal(secondsToJellyfinTicks(Number.NaN, 10_000_000), 0);
|
|
});
|
|
|
|
test('shouldAutoLoadSecondarySubTrackForJellyfinPlayback suppresses generic secondary autoload for active Jellyfin media', () => {
|
|
assert.equal(shouldAutoLoadSecondarySubTrackForJellyfinPlayback(null, '/tmp/local.mkv'), true);
|
|
assert.equal(
|
|
shouldAutoLoadSecondarySubTrackForJellyfinPlayback(
|
|
makePlayback({ loadedMediaPath: null }),
|
|
'http://pve-main:8096/Videos/item/stream',
|
|
),
|
|
false,
|
|
);
|
|
assert.equal(
|
|
shouldAutoLoadSecondarySubTrackForJellyfinPlayback(
|
|
makePlayback({ loadedMediaPath: 'http://pve-main:8096/Videos/item/stream' }),
|
|
'http://pve-main:8096/Videos/item/stream',
|
|
),
|
|
false,
|
|
);
|
|
assert.equal(
|
|
shouldAutoLoadSecondarySubTrackForJellyfinPlayback(
|
|
makePlayback({ loadedMediaPath: 'http://pve-main:8096/Videos/item/stream' }),
|
|
'/tmp/local.mkv',
|
|
),
|
|
true,
|
|
);
|
|
});
|
|
|
|
test('createReportJellyfinRemoteProgressHandler reports playback progress', async () => {
|
|
let lastProgressAtMs = 0;
|
|
const reportPayloads: Array<{ itemId: string; positionTicks?: number; isPaused?: boolean }> = [];
|
|
|
|
const reportProgress = createReportJellyfinRemoteProgressHandler(
|
|
makeProgressDeps({
|
|
getActivePlayback: () =>
|
|
makePlayback({
|
|
reporter: makeReporter({
|
|
reportProgress: async (payload) => {
|
|
reportPayloads.push({
|
|
itemId: payload.itemId,
|
|
positionTicks: payload.positionTicks,
|
|
isPaused: payload.isPaused,
|
|
});
|
|
},
|
|
}),
|
|
}),
|
|
getMpvClient: () => ({
|
|
requestProperty: async (name: string) => (name === 'time-pos' ? 2.5 : true),
|
|
}),
|
|
setLastProgressAtMs: (value) => {
|
|
lastProgressAtMs = value;
|
|
},
|
|
}),
|
|
);
|
|
|
|
await reportProgress(true);
|
|
|
|
assert.deepEqual(reportPayloads, [
|
|
{
|
|
itemId: 'item-1',
|
|
positionTicks: 25_000_000,
|
|
isPaused: true,
|
|
},
|
|
]);
|
|
assert.equal(lastProgressAtMs, 5000);
|
|
});
|
|
|
|
test('createReportJellyfinRemoteProgressHandler normalizes mpv pause strings', async () => {
|
|
const reportPayloads: Array<{ isPaused?: boolean }> = [];
|
|
|
|
const reportProgress = createReportJellyfinRemoteProgressHandler(
|
|
makeProgressDeps({
|
|
getActivePlayback: () =>
|
|
makePlayback({
|
|
reporter: makeReporter({
|
|
reportProgress: async (payload) => {
|
|
reportPayloads.push({ isPaused: payload.isPaused });
|
|
},
|
|
}),
|
|
}),
|
|
getMpvClient: () => ({
|
|
requestProperty: async (name: string) => (name === 'pause' ? 'yes' : 3),
|
|
}),
|
|
}),
|
|
);
|
|
|
|
await reportProgress(true);
|
|
|
|
assert.deepEqual(reportPayloads, [{ isPaused: true }]);
|
|
});
|
|
|
|
test('createReportJellyfinRemoteProgressHandler respects debounce interval', async () => {
|
|
let called = false;
|
|
const reportProgress = createReportJellyfinRemoteProgressHandler(
|
|
makeProgressDeps({
|
|
getActivePlayback: () =>
|
|
makePlayback({
|
|
reporter: makeReporter({
|
|
reportProgress: async () => {
|
|
called = true;
|
|
},
|
|
}),
|
|
}),
|
|
getNow: () => 4000,
|
|
getLastProgressAtMs: () => 3500,
|
|
}),
|
|
);
|
|
|
|
await reportProgress(false);
|
|
assert.equal(called, false);
|
|
});
|
|
|
|
test('createReportJellyfinRemoteProgressHandler reports mpv seek jumps during debounce', async () => {
|
|
let now = 5000;
|
|
let lastProgressAtMs = 0;
|
|
let position = 10;
|
|
const reportPayloads: Array<{ positionTicks?: number; eventName?: string }> = [];
|
|
|
|
const reportProgress = createReportJellyfinRemoteProgressHandler(
|
|
makeProgressDeps({
|
|
getActivePlayback: () =>
|
|
makePlayback({
|
|
reporter: makeReporter({
|
|
reportProgress: async (payload) => {
|
|
reportPayloads.push({
|
|
positionTicks: payload.positionTicks,
|
|
eventName: payload.eventName,
|
|
});
|
|
},
|
|
}),
|
|
}),
|
|
getMpvClient: () => ({
|
|
currentTimePos: position,
|
|
requestProperty: async (name: string) => (name === 'pause' ? false : position),
|
|
}),
|
|
getNow: () => now,
|
|
getLastProgressAtMs: () => lastProgressAtMs,
|
|
setLastProgressAtMs: (value) => {
|
|
lastProgressAtMs = value;
|
|
},
|
|
}),
|
|
);
|
|
|
|
await reportProgress(true);
|
|
now = 5500;
|
|
position = 90;
|
|
await reportProgress(false);
|
|
|
|
assert.deepEqual(reportPayloads, [
|
|
{ positionTicks: 100_000_000, eventName: 'TimeUpdate' },
|
|
{ positionTicks: 900_000_000, eventName: 'TimeUpdate' },
|
|
]);
|
|
assert.equal(lastProgressAtMs, 5500);
|
|
});
|
|
|
|
test('createReportJellyfinRemoteStoppedHandler reports stop and clears playback', async () => {
|
|
let cleared = false;
|
|
let stoppedPayload: {
|
|
itemId: string;
|
|
positionTicks?: number;
|
|
failed?: boolean;
|
|
} | null = null;
|
|
const reportStopped = createReportJellyfinRemoteStoppedHandler(
|
|
makeStoppedDeps({
|
|
getActivePlayback: () =>
|
|
makePlayback({
|
|
itemId: 'item-2',
|
|
playMethod: 'Transcode',
|
|
reporter: makeReporter({
|
|
reportStopped: async (payload) => {
|
|
stoppedPayload = {
|
|
itemId: payload.itemId,
|
|
positionTicks: payload.positionTicks,
|
|
failed: payload.failed,
|
|
};
|
|
},
|
|
}),
|
|
}),
|
|
clearActivePlayback: () => {
|
|
cleared = true;
|
|
},
|
|
getMpvClient: () => ({
|
|
currentTimePos: 12.5,
|
|
requestProperty: async () => {
|
|
throw new Error('unloaded');
|
|
},
|
|
}),
|
|
}),
|
|
);
|
|
|
|
await reportStopped();
|
|
assert.deepEqual(stoppedPayload, {
|
|
itemId: 'item-2',
|
|
positionTicks: 125_000_000,
|
|
failed: false,
|
|
});
|
|
assert.equal(cleared, true);
|
|
});
|
|
|
|
test('createReportJellyfinRemoteStoppedHandler clears aborted playback that never loaded', async () => {
|
|
let cleared = false;
|
|
const reportStopped = createReportJellyfinRemoteStoppedHandler(
|
|
makeStoppedDeps({
|
|
getActivePlayback: () =>
|
|
makePlayback({
|
|
loadedMediaPath: null,
|
|
reporter: makeReporter({
|
|
reportStopped: async () => {
|
|
throw new Error('should not report stopped for unloaded media');
|
|
},
|
|
}),
|
|
}),
|
|
clearActivePlayback: () => {
|
|
cleared = true;
|
|
},
|
|
getMpvClient: () => null,
|
|
}),
|
|
);
|
|
|
|
await reportStopped();
|
|
|
|
assert.equal(cleared, true);
|
|
});
|
|
|
|
test('createReportJellyfinRemoteStoppedHandler uses cached position after mpv unload reset', async () => {
|
|
let cleared = false;
|
|
const calls: Array<{ event: string; positionTicks?: number }> = [];
|
|
const reportStopped = createReportJellyfinRemoteStoppedHandler(
|
|
makeStoppedDeps({
|
|
getActivePlayback: () =>
|
|
makePlayback({
|
|
loadedMediaPath: 'https://stream.example/video.m3u8',
|
|
lastKnownPositionSeconds: 72.25,
|
|
reporter: makeReporter({
|
|
reportProgress: async (payload) => {
|
|
calls.push({ event: 'progress', positionTicks: payload.positionTicks });
|
|
},
|
|
reportStopped: async (payload) => {
|
|
calls.push({ event: 'stopped', positionTicks: payload.positionTicks });
|
|
},
|
|
}),
|
|
}),
|
|
clearActivePlayback: () => {
|
|
cleared = true;
|
|
},
|
|
}),
|
|
);
|
|
|
|
await reportStopped();
|
|
|
|
assert.deepEqual(calls, [
|
|
{ event: 'progress', positionTicks: 722_500_000 },
|
|
{ event: 'stopped', positionTicks: 722_500_000 },
|
|
]);
|
|
assert.equal(cleared, true);
|
|
});
|
|
|
|
test('createReportJellyfinRemoteProgressHandler caches last nonzero mpv position', async () => {
|
|
let position = 42;
|
|
const playback = makePlayback();
|
|
const reportProgress = createReportJellyfinRemoteProgressHandler(
|
|
makeProgressDeps({
|
|
getActivePlayback: () => playback,
|
|
getMpvClient: () => ({
|
|
currentTimePos: position,
|
|
requestProperty: async (name: string) => (name === 'pause' ? false : position),
|
|
}),
|
|
}),
|
|
);
|
|
|
|
await reportProgress(true);
|
|
position = 0;
|
|
await reportProgress(true);
|
|
|
|
assert.equal(playback.lastKnownPositionSeconds, 42);
|
|
});
|
|
|
|
test('markJellyfinRemotePlaybackLoaded preserves the loaded marker on unload paths', () => {
|
|
const playback = makePlayback({
|
|
itemId: 'item-2',
|
|
playMethod: 'Transcode',
|
|
loadedMediaPath: 'https://stream.example/video.m3u8',
|
|
});
|
|
|
|
markJellyfinRemotePlaybackLoaded(playback, '');
|
|
markJellyfinRemotePlaybackLoaded(playback, ' ');
|
|
assert.equal(playback.loadedMediaPath, 'https://stream.example/video.m3u8');
|
|
|
|
markJellyfinRemotePlaybackLoaded(playback, ' https://stream.example/next.m3u8 ');
|
|
assert.equal(playback.loadedMediaPath, 'https://stream.example/next.m3u8');
|
|
});
|
|
|
|
test('createReportJellyfinRemoteStoppedHandler ignores startup stop churn before grace expires', async () => {
|
|
let cleared = false;
|
|
let stopped = false;
|
|
const reportStopped = createReportJellyfinRemoteStoppedHandler(
|
|
makeStoppedDeps({
|
|
getActivePlayback: () =>
|
|
makePlayback({
|
|
loadedMediaPath: 'https://stream.example/video.m3u8',
|
|
stopReportsAfterMs: 20_000,
|
|
reporter: makeReporter({
|
|
reportStopped: async () => {
|
|
stopped = true;
|
|
},
|
|
}),
|
|
}),
|
|
clearActivePlayback: () => {
|
|
cleared = true;
|
|
},
|
|
getNow: () => 12_000,
|
|
}),
|
|
);
|
|
|
|
await reportStopped();
|
|
|
|
assert.equal(stopped, false);
|
|
assert.equal(cleared, false);
|
|
});
|
|
|
|
test('createReportJellyfinRemoteStoppedHandler clears playback before reporting and waits for in-flight progress', async () => {
|
|
const tracker = createJellyfinRemoteReportTracker();
|
|
const calls: string[] = [];
|
|
let releaseProgress: () => void = () => undefined;
|
|
const progressGate = new Promise<void>((resolve) => {
|
|
releaseProgress = resolve;
|
|
});
|
|
let playback: ActiveJellyfinRemotePlaybackState | null = makePlayback({
|
|
loadedMediaPath: 'http://pve-main:8096/Videos/item-1/stream',
|
|
reporter: makeReporter({
|
|
reportProgress: async ({ eventName }) => {
|
|
calls.push(`progress:${eventName}:${playback ? 'active' : 'cleared'}`);
|
|
if (calls.length === 1) await progressGate;
|
|
},
|
|
reportStopped: async () => {
|
|
calls.push(`stopped:${playback ? 'active' : 'cleared'}`);
|
|
},
|
|
}),
|
|
});
|
|
const shared = {
|
|
getActivePlayback: () => playback,
|
|
clearActivePlayback: () => {
|
|
playback = null;
|
|
},
|
|
getMpvClient: () => ({ currentTimePos: 42 }),
|
|
ticksPerSecond: 10_000_000,
|
|
logDebug: () => undefined,
|
|
reportTracker: tracker,
|
|
};
|
|
const reportProgress = createReportJellyfinRemoteProgressHandler({
|
|
...shared,
|
|
getNow: () => 10_000,
|
|
getLastProgressAtMs: () => 0,
|
|
setLastProgressAtMs: () => undefined,
|
|
progressIntervalMs: 3000,
|
|
});
|
|
const reportStopped = createReportJellyfinRemoteStoppedHandler(shared);
|
|
|
|
// A periodic tick is mid-request when the stop starts.
|
|
const tick = reportProgress(true);
|
|
await new Promise((resolve) => setTimeout(resolve, 0));
|
|
assert.deepEqual(calls, ['progress:TimeUpdate:active']);
|
|
const stop = reportStopped();
|
|
await new Promise((resolve) => setTimeout(resolve, 0));
|
|
assert.equal(playback, null);
|
|
assert.deepEqual(calls, ['progress:TimeUpdate:active']);
|
|
|
|
// A tick fired after the stop began must not report anything.
|
|
await reportProgress(true);
|
|
assert.deepEqual(calls, ['progress:TimeUpdate:active']);
|
|
|
|
releaseProgress();
|
|
await tick;
|
|
await stop;
|
|
assert.deepEqual(calls, [
|
|
'progress:TimeUpdate:active',
|
|
'progress:TimeUpdate:cleared',
|
|
'stopped:cleared',
|
|
]);
|
|
});
|