BlueGit

timfa filemanager

Files

filemanager / tests / shared-video-player.test.js

shared-video-player.test.js

64bdc46b History
shared-video-player.test.js 53.4 KiB Download Raw
1'use strict';
2
3const fs = require('fs');
4const path = require('path');
5const { JSDOM } = require('jsdom');
6
7function flushAsyncWork (window, rounds = 6)
8{
9 let chain = Promise.resolve();
10 for (let i = 0; i < rounds; i++)
11 {
12 chain = chain.then(() => new Promise((resolve) => window.setTimeout(resolve, 0)));
13 }
14 return chain;
15}
16
17function buildPlayerHarness (window)
18{
19 const registeredComponents = new Map();
20
21 class MockButton
22 {
23 constructor(player)
24 {
25 this._player = player;
26 this._el = null;
27 }
28
29 player ()
30 {
31 return this._player;
32 }
33
34 buildCSSClass ()
35 {
36 return 'vjs-control';
37 }
38
39 createEl ()
40 {
41 const el = window.document.createElement('button');
42 el.className = this.buildCSSClass();
43 return el;
44 }
45
46 el ()
47 {
48 if (!this._el) this._el = this.createEl();
49 return this._el;
50 }
51 }
52
53 registeredComponents.set('Button', MockButton);
54
55 const videojs = {
56 getComponent: (name) => registeredComponents.get(name),
57 registerComponent: (name, component) =>
58 {
59 registeredComponents.set(name, component);
60 },
61 };
62
63 const events = new Map();
64 const playerEl = window.document.createElement('div');
65 const progressControlEl = window.document.createElement('div');
66 progressControlEl.className = 'vjs-progress-control';
67 playerEl.appendChild(progressControlEl);
68 let currentTime = 0;
69 let durationSeconds = 10;
70 let bufferedEndSeconds = null;
71
72 const player = {
73 ready (cb)
74 {
75 if (typeof cb === 'function') cb();
76 },
77 on (type, fn)
78 {
79 if (!events.has(type)) events.set(type, new Set());
80 events.get(type).add(fn);
81 },
82 trigger (type)
83 {
84 const listeners = events.get(type);
85 if (!listeners) return;
86 for (const fn of Array.from(listeners)) fn();
87 },
88 currentTime ()
89 {
90 return currentTime;
91 },
92 setCurrentTime (next)
93 {
94 currentTime = Number(next);
95 },
96 duration (nextValue)
97 {
98 if (typeof nextValue === 'number')
99 {
100 durationSeconds = nextValue;
101 }
102 return durationSeconds;
103 },
104 bufferedEnd ()
105 {
106 return bufferedEndSeconds;
107 },
108 setBufferedEnd (next)
109 {
110 bufferedEndSeconds = Number.isFinite(next) ? Number(next) : null;
111 },
112 el ()
113 {
114 return playerEl;
115 },
116 getChild (name)
117 {
118 if (name !== 'controlBar') return null;
119 return {
120 addChild (componentName)
121 {
122 const Component = registeredComponents.get(componentName);
123 if (!Component) return null;
124 const instance = new Component(player);
125 playerEl.appendChild(instance.el());
126 return instance;
127 },
128 };
129 },
130 };
131
132 return { player, videojs };
133}
134
135function loadSharedVideoPlayer (window)
136{
137 const script = fs.readFileSync(path.join(__dirname, '../public/shared-video-player.js'), 'utf8');
138 window.eval(script);
139 return window.FilemanagerSharedVideoPlayer;
140}
141
142describe('shared image subtitle prefetching', () =>
143{
144 function createWindow ()
145 {
146 const dom = new JSDOM('<!doctype html><html><body></body></html>', {
147 url: 'http://localhost/',
148 runScripts: 'dangerously',
149 pretendToBeVisual: true,
150 });
151
152 dom.window.AbortController = AbortController;
153 dom.window.Response = Response;
154 dom.window.Headers = Headers;
155 dom.window.Request = Request;
156 dom.window.URL.createObjectURL = () => 'blob:subtitle';
157 dom.window.URL.revokeObjectURL = () => { };
158
159 return dom.window;
160 }
161
162 test('prefetches lookahead frames even when no subtitle is currently active', async () =>
163 {
164 const window = createWindow();
165 const helper = loadSharedVideoPlayer(window);
166 const { player, videojs } = buildPlayerHarness(window);
167 const requestedTimes = [];
168
169 window.fetch = jest.fn(async (url) =>
170 {
171 const parsed = new URL(url, 'http://localhost/');
172 requestedTimes.push(Number(parsed.searchParams.get('timeSeconds')));
173 return new Response(null, {
174 status: 204,
175 headers: { 'X-Subtitle-Frame-Status': 'none' },
176 });
177 });
178
179 helper.bindImageSubtitleOverlay(player, videojs, {}, {
180 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
181 }, {
182 lookaheadSeconds: 1,
183 buildFrameRequest: ({ currentTime, streamIndex }) => ({
184 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
185 }),
186 });
187
188 await flushAsyncWork(window);
189
190 expect(requestedTimes).toEqual(expect.arrayContaining([0, 0.5, 1]));
191
192 window.close();
193 });
194
195 test('prefetches subtitle frames through known video duration even with short lookahead', async () =>
196 {
197 const window = createWindow();
198 const helper = loadSharedVideoPlayer(window);
199 const { player, videojs } = buildPlayerHarness(window);
200 const requestedTimes = [];
201
202 player.duration(3);
203
204 window.fetch = jest.fn(async (url) =>
205 {
206 const parsed = new URL(url, 'http://localhost/');
207 requestedTimes.push(Number(parsed.searchParams.get('timeSeconds')));
208 return new Response(null, {
209 status: 204,
210 headers: { 'X-Subtitle-Frame-Status': 'none' },
211 });
212 });
213
214 helper.bindImageSubtitleOverlay(player, videojs, {}, {
215 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
216 }, {
217 lookaheadSeconds: 0.5,
218 buildFrameRequest: ({ currentTime, streamIndex }) => ({
219 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
220 }),
221 });
222
223 await flushAsyncWork(window, 18);
224
225 expect(requestedTimes).toEqual(expect.arrayContaining([0, 0.5, 1, 1.5, 2, 2.5, 3]));
226
227 window.close();
228 });
229
230 test('prefetch expands to video end when duration metadata appears later', async () =>
231 {
232 const window = createWindow();
233 const helper = loadSharedVideoPlayer(window);
234 const { player, videojs } = buildPlayerHarness(window);
235 const requestedTimes = [];
236
237 player.duration(Number.NaN);
238
239 window.fetch = jest.fn(async (url) =>
240 {
241 const parsed = new URL(url, 'http://localhost/');
242 requestedTimes.push(Number(parsed.searchParams.get('timeSeconds')));
243 return new Response(null, {
244 status: 204,
245 headers: { 'X-Subtitle-Frame-Status': 'none' },
246 });
247 });
248
249 helper.bindImageSubtitleOverlay(player, videojs, {}, {
250 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
251 }, {
252 lookaheadSeconds: 0.5,
253 initialPrefetchSeconds: 0,
254 buildFrameRequest: ({ currentTime, streamIndex }) => ({
255 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
256 }),
257 });
258
259 await flushAsyncWork(window, 6);
260 expect(requestedTimes).toContain(0);
261
262 requestedTimes.length = 0;
263 player.duration(4);
264 player.trigger('durationchange');
265 await flushAsyncWork(window, 14);
266
267 expect(requestedTimes).toEqual(expect.arrayContaining([0, 0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4]));
268
269 window.close();
270 });
271
272 test('prefetches at least through the buffered video end', async () =>
273 {
274 const window = createWindow();
275 const helper = loadSharedVideoPlayer(window);
276 const { player, videojs } = buildPlayerHarness(window);
277 const requestedTimes = [];
278
279 player.setBufferedEnd(3);
280
281 window.fetch = jest.fn(async (url) =>
282 {
283 const parsed = new URL(url, 'http://localhost/');
284 requestedTimes.push(Number(parsed.searchParams.get('timeSeconds')));
285 return new Response(null, {
286 status: 204,
287 headers: { 'X-Subtitle-Frame-Status': 'none' },
288 });
289 });
290
291 helper.bindImageSubtitleOverlay(player, videojs, {}, {
292 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
293 }, {
294 lookaheadSeconds: 0.5,
295 buildFrameRequest: ({ currentTime, streamIndex }) => ({
296 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
297 }),
298 });
299
300 await flushAsyncWork(window, 12);
301
302 expect(requestedTimes).toEqual(expect.arrayContaining([0, 0.5, 1, 1.5, 2, 2.5, 3]));
303
304 window.close();
305 });
306
307 test('prefetch respects configured larger prefetch step size', async () =>
308 {
309 const window = createWindow();
310 const helper = loadSharedVideoPlayer(window);
311 const { player, videojs } = buildPlayerHarness(window);
312 const requestedTimes = [];
313
314 player.duration(6);
315
316 window.fetch = jest.fn(async (url) =>
317 {
318 const parsed = new URL(url, 'http://localhost/');
319 requestedTimes.push(Number(parsed.searchParams.get('timeSeconds')));
320 return new Response(null, {
321 status: 204,
322 headers: { 'X-Subtitle-Frame-Status': 'none' },
323 });
324 });
325
326 helper.bindImageSubtitleOverlay(player, videojs, {}, {
327 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
328 }, {
329 lookaheadSeconds: 0,
330 initialPrefetchSeconds: 0,
331 prefetchStepSeconds: 2,
332 buildFrameRequest: ({ currentTime, streamIndex }) => ({
333 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
334 }),
335 });
336
337 await flushAsyncWork(window, 14);
338
339 expect(requestedTimes).toEqual(expect.arrayContaining([0, 2, 4, 6]));
340
341 window.close();
342 });
343
344 test('prefetch uses furthest buffered end when player.bufferedEnd under-reports', async () =>
345 {
346 const window = createWindow();
347 const helper = loadSharedVideoPlayer(window);
348 const { player, videojs } = buildPlayerHarness(window);
349 const requestedTimes = [];
350
351 player.setBufferedEnd(0);
352 player.tech = () => ({
353 el: () => ({
354 buffered: {
355 length: 1,
356 end: () => 6,
357 },
358 }),
359 });
360
361 window.fetch = jest.fn(async (url) =>
362 {
363 const parsed = new URL(url, 'http://localhost/');
364 requestedTimes.push(Number(parsed.searchParams.get('timeSeconds')));
365 return new Response(null, {
366 status: 204,
367 headers: { 'X-Subtitle-Frame-Status': 'none' },
368 });
369 });
370
371 helper.bindImageSubtitleOverlay(player, videojs, {}, {
372 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
373 }, {
374 lookaheadSeconds: 0,
375 initialPrefetchSeconds: 0,
376 buildFrameRequest: ({ currentTime, streamIndex }) => ({
377 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
378 }),
379 });
380
381 await flushAsyncWork(window, 16);
382
383 expect(requestedTimes).toEqual(expect.arrayContaining([0, 0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5, 5.5, 6]));
384
385 window.close();
386 });
387
388 test('prefetch frontier jumps to current playback time instead of replaying stale lag', async () =>
389 {
390 const window = createWindow();
391 const helper = loadSharedVideoPlayer(window);
392 const { player, videojs } = buildPlayerHarness(window);
393 const requestedTimes = [];
394
395 player.setBufferedEnd(35);
396
397 window.fetch = jest.fn(async (url) =>
398 {
399 const parsed = new URL(url, 'http://localhost/');
400 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
401 requestedTimes.push(timeSeconds);
402 return new Response(null, {
403 status: 204,
404 headers: { 'X-Subtitle-Frame-Status': 'none' },
405 });
406 });
407
408 helper.bindImageSubtitleOverlay(player, videojs, {}, {
409 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
410 }, {
411 lookaheadSeconds: 0,
412 initialPrefetchSeconds: 0,
413 buildFrameRequest: ({ currentTime, streamIndex }) => ({
414 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
415 }),
416 });
417
418 await flushAsyncWork(window, 8);
419 expect(requestedTimes).toEqual(expect.arrayContaining([0, 0.5]));
420
421 requestedTimes.length = 0;
422 player.setCurrentTime(20);
423 player.setBufferedEnd(40);
424 player.trigger('timeupdate');
425 await flushAsyncWork(window, 8);
426
427 expect(requestedTimes).toContain(20);
428 const prefetchAfterJump = requestedTimes.filter((value) => value > 20);
429 expect(prefetchAfterJump.length).toBeGreaterThan(0);
430 expect(Math.min(...prefetchAfterJump)).toBeGreaterThanOrEqual(20.5);
431
432 window.close();
433 });
434
435 test('does not restart current subtitle request while one is in flight', async () =>
436 {
437 const window = createWindow();
438 const helper = loadSharedVideoPlayer(window);
439 const { player, videojs } = buildPlayerHarness(window);
440 const pendingResolvers = [];
441 const requestTimes = [];
442
443 window.fetch = jest.fn((url, init = {}) =>
444 {
445 const parsed = new URL(url, 'http://localhost/');
446 requestTimes.push(Number(parsed.searchParams.get('timeSeconds')));
447
448 if (pendingResolvers.length === 0)
449 {
450 return new Promise((resolve) =>
451 {
452 pendingResolvers.push(() => resolve(new Response(null, {
453 status: 204,
454 headers: { 'X-Subtitle-Frame-Status': 'none' },
455 })));
456 });
457 }
458
459 expect(init.signal && init.signal.aborted).toBe(false);
460 return Promise.resolve(new Response(null, {
461 status: 204,
462 headers: { 'X-Subtitle-Frame-Status': 'none' },
463 }));
464 });
465
466 helper.bindImageSubtitleOverlay(player, videojs, {}, {
467 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
468 }, {
469 lookaheadSeconds: 0,
470 initialPrefetchSeconds: 0,
471 buildFrameRequest: ({ currentTime, streamIndex }) => ({
472 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
473 }),
474 });
475
476 await flushAsyncWork(window, 3);
477 expect(window.fetch).toHaveBeenCalledTimes(1);
478
479 player.setCurrentTime(1.5);
480 player.trigger('timeupdate');
481 player.setCurrentTime(2.25);
482 player.trigger('timeupdate');
483 await flushAsyncWork(window, 2);
484
485 expect(window.fetch).toHaveBeenCalledTimes(1);
486
487 pendingResolvers[0]();
488 await flushAsyncWork(window, 5);
489
490 expect(window.fetch.mock.calls.length).toBeGreaterThanOrEqual(2);
491 expect(requestTimes).toEqual(expect.arrayContaining([0, 2.25]));
492
493 window.close();
494 });
495
496 test('renders a prefetched frame for the current paused time without waiting for another timeupdate', async () =>
497 {
498 const window = createWindow();
499 const helper = loadSharedVideoPlayer(window);
500 const { player, videojs } = buildPlayerHarness(window);
501
502 player.duration(120);
503 player.setCurrentTime(118.95);
504
505 window.fetch = jest.fn(async (url) =>
506 {
507 const parsed = new URL(url, 'http://localhost/');
508 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
509 const headers = {
510 'Content-Type': 'image/png',
511 };
512
513 if (Math.abs(timeSeconds - 118.95) < 0.001)
514 {
515 headers['X-Subtitle-Frame-Start-Time'] = '118.90';
516 headers['X-Subtitle-Frame-End-Time'] = '119.00';
517 headers['X-Subtitle-Frame-Width'] = '640';
518 headers['X-Subtitle-Frame-Height'] = '80';
519 headers['X-Subtitle-Frame-Canvas-Width'] = '1920';
520 headers['X-Subtitle-Frame-Canvas-Height'] = '1080';
521 return new Response(new Uint8Array([137, 80, 78, 71]), { status: 200, headers });
522 }
523
524 return new Response(null, {
525 status: 204,
526 headers: { 'X-Subtitle-Frame-Status': 'none' },
527 });
528 });
529
530 helper.bindImageSubtitleOverlay(player, videojs, {}, {
531 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
532 }, {
533 currentFetchEnabled: false,
534 cacheMissFallbackEnabled: false,
535 lookaheadSeconds: 0,
536 initialPrefetchSeconds: 0,
537 buildFrameRequest: ({ currentTime, streamIndex }) => ({
538 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
539 }),
540 });
541
542 await flushAsyncWork(window, 10);
543
544 const overlay = player.el().querySelector('.video-subtitle-overlay');
545 const overlayImg = overlay && overlay.querySelector('img');
546 expect(overlay).toBeTruthy();
547 expect(overlayImg).toBeTruthy();
548 expect(overlay.style.display).toBe('block');
549 expect(overlayImg.getAttribute('src')).toBe('blob:subtitle');
550
551 window.close();
552 });
553
554 test('aborts in-flight prefetch requests when the overlay is detached', async () =>
555 {
556 const window = createWindow();
557 const helper = loadSharedVideoPlayer(window);
558 const { player, videojs } = buildPlayerHarness(window);
559 const activeSignals = [];
560
561 window.fetch = jest.fn((url, init = {}) =>
562 {
563 const parsed = new URL(url, 'http://localhost/');
564 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
565
566 if (timeSeconds === 0)
567 {
568 return Promise.resolve(new Response(null, {
569 status: 204,
570 headers: { 'X-Subtitle-Frame-Status': 'none' },
571 }));
572 }
573
574 activeSignals.push(init.signal || null);
575
576 return new Promise((resolve, reject) =>
577 {
578 if (init.signal && typeof init.signal.addEventListener === 'function')
579 {
580 init.signal.addEventListener('abort', () =>
581 {
582 reject(new DOMException('Aborted', 'AbortError'));
583 }, { once: true });
584 }
585 });
586 });
587
588 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
589 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
590 }, {
591 lookaheadSeconds: 1,
592 buildFrameRequest: ({ currentTime, streamIndex }) => ({
593 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
594 }),
595 });
596
597 await flushAsyncWork(window, 3);
598 expect(activeSignals.length).toBeGreaterThan(0);
599
600 controller.detach();
601 await flushAsyncWork(window, 2);
602
603 expect(activeSignals.every(signal => signal && signal.aborted)).toBe(true);
604
605 window.close();
606 });
607
608 test('logs current subtitle request lifecycle events and flushes them on detach', async () =>
609 {
610 const window = createWindow();
611 const helper = loadSharedVideoPlayer(window);
612 const { player, videojs } = buildPlayerHarness(window);
613 const sentBatches = [];
614
615 window.fetch = jest.fn(async () =>
616 {
617 return new Response('png-data', {
618 status: 200,
619 headers: {
620 'Content-Type': 'image/png',
621 'X-Subtitle-Frame-Status': 'ok',
622 'X-Subtitle-Request-Received-At-Ms': '1000',
623 'X-Subtitle-Response-Sent-At-Ms': '1012',
624 'X-Subtitle-Frame-Start-Time': '1.5',
625 'X-Subtitle-Frame-End-Time': '3.2',
626 'X-Subtitle-Frame-Width': '320',
627 'X-Subtitle-Frame-Height': '180',
628 'X-Subtitle-Frame-Canvas-Width': '640',
629 'X-Subtitle-Frame-Canvas-Height': '360',
630 },
631 });
632 });
633
634 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
635 sessionId: 'sess-1',
636 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
637 }, {
638 lookaheadSeconds: 0,
639 sendSubtitleLogBatch: (entries) =>
640 {
641 sentBatches.push(entries);
642 return Promise.resolve();
643 },
644 buildFrameRequest: ({ currentTime, streamIndex }) => ({
645 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
646 }),
647 });
648
649 await flushAsyncWork(window, 8);
650 controller.detach();
651 await flushAsyncWork(window, 4);
652
653 const flattened = sentBatches.flat();
654 expect(flattened.map((entry) => entry.eventType)).toEqual(expect.arrayContaining([
655 'subtitle_png_requested',
656 'subtitle_png_sent',
657 'subtitle_png_received',
658 ]));
659
660 window.close();
661 });
662
663 test('logs prefetch subtitle lifecycle events', async () =>
664 {
665 const window = createWindow();
666 const helper = loadSharedVideoPlayer(window);
667 const { player, videojs } = buildPlayerHarness(window);
668 const sentBatches = [];
669
670 window.fetch = jest.fn(async () =>
671 {
672 return new Response(null, {
673 status: 204,
674 headers: {
675 'X-Subtitle-Frame-Status': 'none',
676 'X-Subtitle-Request-Received-At-Ms': '1000',
677 'X-Subtitle-Response-Sent-At-Ms': '1010',
678 'X-Subtitle-Frame-Start-Time': '2',
679 'X-Subtitle-Frame-End-Time': '3',
680 },
681 });
682 });
683
684 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
685 sessionId: 'sess-1',
686 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
687 }, {
688 lookaheadSeconds: 1,
689 sendSubtitleLogBatch: (entries) =>
690 {
691 sentBatches.push(entries);
692 return Promise.resolve();
693 },
694 buildFrameRequest: ({ currentTime, streamIndex }) => ({
695 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
696 }),
697 });
698
699 await flushAsyncWork(window, 8);
700 controller.detach();
701 await flushAsyncWork(window, 4);
702
703 const flattened = sentBatches.flat();
704 const prefetchEvents = flattened.filter((entry) => entry.requestKind === 'prefetch').map((entry) => entry.eventType);
705 expect(prefetchEvents).toEqual(expect.arrayContaining([
706 'subtitle_png_requested',
707 'subtitle_png_sent',
708 'subtitle_png_not_available',
709 ]));
710
711 window.close();
712 });
713
714 test('cache-only current mode avoids direct current subtitle fetch requests', async () =>
715 {
716 const window = createWindow();
717 const helper = loadSharedVideoPlayer(window);
718 const { player, videojs } = buildPlayerHarness(window);
719 const sentBatches = [];
720
721 player.setCurrentTime(8);
722 window.fetch = jest.fn(async () =>
723 {
724 return new Response(null, {
725 status: 204,
726 headers: {
727 'X-Subtitle-Frame-Status': 'none',
728 'X-Subtitle-Request-Received-At-Ms': '1000',
729 'X-Subtitle-Response-Sent-At-Ms': '1010',
730 },
731 });
732 });
733
734 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
735 sessionId: 'sess-1',
736 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
737 }, {
738 currentFetchEnabled: false,
739 cacheMissFallbackEnabled: false,
740 lookaheadSeconds: 0,
741 sendSubtitleLogBatch: (entries) =>
742 {
743 sentBatches.push(entries);
744 return Promise.resolve();
745 },
746 buildFrameRequest: ({ currentTime, streamIndex }) => ({
747 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
748 }),
749 });
750
751 await flushAsyncWork(window, 8);
752 controller.detach();
753 await flushAsyncWork(window, 4);
754
755 const flattened = sentBatches.flat();
756 expect(flattened.length).toBeGreaterThan(0);
757 const requestKinds = new Set(flattened.map((entry) => entry.requestKind).filter(Boolean));
758 expect(requestKinds.has('prefetch')).toBe(true);
759 expect(requestKinds.has('current')).toBe(false);
760
761 window.close();
762 });
763
764 test('cache-only mode falls back to throttled current fetch on cache miss', async () =>
765 {
766 const window = createWindow();
767 const helper = loadSharedVideoPlayer(window);
768 const { player, videojs } = buildPlayerHarness(window);
769
770 let requestCount = 0;
771 window.fetch = jest.fn(async () =>
772 {
773 requestCount += 1;
774 if (requestCount === 1)
775 {
776 return new Response(new Uint8Array([137, 80, 78, 71]), {
777 status: 200,
778 headers: {
779 'Content-Type': 'image/png',
780 'X-Subtitle-Frame-Start-Time': '2.00',
781 'X-Subtitle-Frame-End-Time': '2.50',
782 'X-Subtitle-Frame-Width': '600',
783 'X-Subtitle-Frame-Height': '72',
784 'X-Subtitle-Frame-Canvas-Width': '1920',
785 'X-Subtitle-Frame-Canvas-Height': '1080',
786 },
787 });
788 }
789
790 return new Response(null, {
791 status: 204,
792 headers: { 'X-Subtitle-Frame-Status': 'none' },
793 });
794 });
795
796 player.setCurrentTime(2.2);
797
798 helper.bindImageSubtitleOverlay(player, videojs, {}, {
799 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
800 }, {
801 currentFetchEnabled: false,
802 cacheMissFallbackIntervalMs: 2000,
803 lookaheadSeconds: 0,
804 initialPrefetchSeconds: 0,
805 buildFrameRequest: ({ currentTime, streamIndex }) => ({
806 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
807 }),
808 });
809
810 await flushAsyncWork(window, 10);
811
812 const overlay = player.el().querySelector('.video-subtitle-overlay');
813 const overlayImg = overlay && overlay.querySelector('img');
814 expect(window.fetch).toHaveBeenCalled();
815 expect(overlay.style.display).toBe('block');
816 expect(overlayImg.getAttribute('src')).toBe('blob:subtitle');
817
818 window.close();
819 });
820
821 test('cache-miss fallback does not reset prefetch progress on repeated triggers', async () =>
822 {
823 const window = createWindow();
824 const helper = loadSharedVideoPlayer(window);
825 const { player, videojs } = buildPlayerHarness(window);
826
827 let nowMs = 1000;
828 const realNow = window.Date.now;
829 window.Date.now = () => nowMs;
830
831 let abortedCount = 0;
832 window.fetch = jest.fn((url, init = {}) =>
833 {
834 return new Promise((resolve, reject) =>
835 {
836 const signal = init && init.signal;
837 const onAbort = () =>
838 {
839 abortedCount += 1;
840 const err = new Error('aborted');
841 err.name = 'AbortError';
842 reject(err);
843 };
844
845 if (signal && typeof signal.addEventListener === 'function')
846 {
847 if (signal.aborted) return onAbort();
848 signal.addEventListener('abort', onAbort, { once: true });
849 }
850
851 window.setTimeout(() =>
852 {
853 if (signal && signal.aborted) return;
854 resolve(new Response(null, {
855 status: 204,
856 headers: { 'X-Subtitle-Frame-Status': 'none' },
857 }));
858 }, 80);
859 });
860 });
861
862 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
863 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
864 }, {
865 currentFetchEnabled: false,
866 cacheMissFallbackIntervalMs: 20,
867 lookaheadSeconds: 2,
868 initialPrefetchSeconds: 0,
869 buildFrameRequest: ({ currentTime, streamIndex }) => ({
870 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
871 }),
872 });
873
874 await flushAsyncWork(window, 4);
875
876 player.setCurrentTime(5);
877 player.trigger('timeupdate');
878 nowMs += 40;
879 player.setCurrentTime(5.5);
880 player.trigger('timeupdate');
881 nowMs += 40;
882 player.setCurrentTime(6);
883 player.trigger('timeupdate');
884
885 await flushAsyncWork(window, 12);
886 expect(abortedCount).toBe(0);
887
888 window.Date.now = realNow;
889 controller.detach();
890 window.close();
891 });
892
893 test('cache-only mode performs initial warmup prefetch window on load', async () =>
894 {
895 const window = createWindow();
896 const helper = loadSharedVideoPlayer(window);
897 const { player, videojs } = buildPlayerHarness(window);
898 const requestedTimes = [];
899
900 window.fetch = jest.fn(async (url) =>
901 {
902 const parsed = new URL(url, 'http://localhost/');
903 requestedTimes.push(Number(parsed.searchParams.get('timeSeconds')));
904 return new Response(null, {
905 status: 204,
906 headers: {
907 'X-Subtitle-Frame-Status': 'none',
908 'X-Subtitle-Request-Received-At-Ms': '1000',
909 'X-Subtitle-Response-Sent-At-Ms': '1010',
910 },
911 });
912 });
913
914 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
915 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
916 }, {
917 currentFetchEnabled: false,
918 lookaheadSeconds: 0,
919 initialPrefetchSeconds: 2,
920 buildFrameRequest: ({ currentTime, streamIndex }) => ({
921 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
922 }),
923 });
924
925 await flushAsyncWork(window, 12);
926
927 expect(requestedTimes).toEqual(expect.arrayContaining([0, 0.5, 1, 1.5, 2]));
928
929 controller.detach();
930 await flushAsyncWork(window, 2);
931 window.close();
932 });
933
934 test('renders requested and received subtitle markers on the seek bar', async () =>
935 {
936 const window = createWindow();
937 const helper = loadSharedVideoPlayer(window);
938 const { player, videojs } = buildPlayerHarness(window);
939
940 window.fetch = jest.fn(async () =>
941 {
942 return new Response('png-data', {
943 status: 200,
944 headers: {
945 'Content-Type': 'image/png',
946 'X-Subtitle-Frame-Status': 'ok',
947 'X-Subtitle-Request-Received-At-Ms': '1000',
948 'X-Subtitle-Response-Sent-At-Ms': '1012',
949 'X-Subtitle-Frame-Start-Time': '2.5',
950 'X-Subtitle-Frame-End-Time': '3.5',
951 'X-Subtitle-Frame-Width': '320',
952 'X-Subtitle-Frame-Height': '180',
953 'X-Subtitle-Frame-Canvas-Width': '640',
954 'X-Subtitle-Frame-Canvas-Height': '360',
955 },
956 });
957 });
958
959 player.duration(10);
960 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
961 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
962 }, {
963 lookaheadSeconds: 0,
964 buildFrameRequest: ({ currentTime, streamIndex }) => ({
965 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
966 }),
967 });
968
969 await flushAsyncWork(window, 8);
970
971 const requestedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-right');
972 const receivedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-left');
973 expect(requestedMarker).toBeTruthy();
974 expect(receivedMarker).toBeTruthy();
975 expect(requestedMarker.style.display).toBe('block');
976 expect(receivedMarker.style.display).toBe('block');
977 expect(requestedMarker.style.left).toBe('100.0000%');
978 expect(receivedMarker.style.left).toBe('25.0000%');
979 expect(requestedMarker.textContent).toBe(']');
980 expect(receivedMarker.textContent).toBe('[');
981
982 controller.detach();
983 await new Promise((resolve) => window.setTimeout(resolve, 300));
984 await flushAsyncWork(window, 2);
985
986 window.close();
987 });
988
989 test('advances both seek markers when subtitle request returns 204 without frame timing headers', async () =>
990 {
991 const window = createWindow();
992 const helper = loadSharedVideoPlayer(window);
993 const { player, videojs } = buildPlayerHarness(window);
994
995 player.duration(10);
996 player.setCurrentTime(4);
997 window.fetch = jest.fn(async () =>
998 {
999 return new Response(null, {
1000 status: 204,
1001 headers: {
1002 'X-Subtitle-Frame-Status': 'none',
1003 'X-Subtitle-Request-Received-At-Ms': '1000',
1004 'X-Subtitle-Response-Sent-At-Ms': '1010',
1005 },
1006 });
1007 });
1008
1009 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1010 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1011 }, {
1012 lookaheadSeconds: 0,
1013 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1014 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1015 }),
1016 });
1017
1018 await flushAsyncWork(window, 8);
1019
1020 const requestedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-right');
1021 const receivedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-left');
1022 expect(requestedMarker).toBeTruthy();
1023 expect(receivedMarker).toBeTruthy();
1024 expect(requestedMarker.style.display).toBe('block');
1025 expect(receivedMarker.style.display).toBe('block');
1026 expect(requestedMarker.style.left).toBe('100.0000%');
1027 expect(receivedMarker.style.left).toBe('100.0000%');
1028 expect(requestedMarker.textContent).toBe(']');
1029 expect(receivedMarker.textContent).toBe('[');
1030
1031 controller.detach();
1032 await flushAsyncWork(window, 2);
1033 window.close();
1034 });
1035
1036 test('keeps existing marker positions while the next request is still in flight', async () =>
1037 {
1038 const window = createWindow();
1039 const helper = loadSharedVideoPlayer(window);
1040 const { player, videojs } = buildPlayerHarness(window);
1041 let pendingResolve = null;
1042
1043 player.duration(10);
1044 window.fetch = jest.fn((url) =>
1045 {
1046 const parsed = new URL(url, 'http://localhost/');
1047 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
1048
1049 if (timeSeconds === 0)
1050 {
1051 return Promise.resolve(new Response('png-data', {
1052 status: 200,
1053 headers: {
1054 'Content-Type': 'image/png',
1055 'X-Subtitle-Frame-Status': 'ok',
1056 'X-Subtitle-Frame-Start-Time': '2',
1057 'X-Subtitle-Frame-End-Time': '3',
1058 'X-Subtitle-Frame-Width': '320',
1059 'X-Subtitle-Frame-Height': '180',
1060 'X-Subtitle-Frame-Canvas-Width': '640',
1061 'X-Subtitle-Frame-Canvas-Height': '360',
1062 },
1063 }));
1064 }
1065
1066 return new Promise((resolve) =>
1067 {
1068 pendingResolve = resolve;
1069 });
1070 });
1071
1072 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1073 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1074 }, {
1075 lookaheadSeconds: 0,
1076 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1077 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1078 }),
1079 });
1080
1081 await flushAsyncWork(window, 8);
1082
1083 const requestedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-right');
1084 const receivedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-left');
1085 expect(requestedMarker).toBeTruthy();
1086 expect(receivedMarker).toBeTruthy();
1087 expect(requestedMarker.style.left).toBe('0.0000%');
1088 expect(receivedMarker.style.left).toBe('20.0000%');
1089
1090 player.setCurrentTime(1.5);
1091 player.trigger('timeupdate');
1092 await flushAsyncWork(window, 2);
1093
1094 expect(requestedMarker.style.left).toBe('0.0000%');
1095 expect(receivedMarker.style.left).toBe('20.0000%');
1096
1097 pendingResolve(new Response(null, {
1098 status: 204,
1099 headers: {
1100 'X-Subtitle-Frame-Status': 'none',
1101 },
1102 }));
1103
1104 await flushAsyncWork(window, 8);
1105 expect(requestedMarker.style.display).toBe('block');
1106 expect(receivedMarker.style.display).toBe('block');
1107 expect(requestedMarker.style.left).toBe('15.0000%');
1108 expect(receivedMarker.style.left).toBe('20.0000%');
1109
1110 controller.detach();
1111 await flushAsyncWork(window, 2);
1112 window.close();
1113 });
1114
1115 test('keeps marker positions forward-only when later responses resolve with earlier times', async () =>
1116 {
1117 const window = createWindow();
1118 const helper = loadSharedVideoPlayer(window);
1119 const { player, videojs } = buildPlayerHarness(window);
1120 const requestedTimes = [];
1121
1122 player.duration(12);
1123 window.fetch = jest.fn(async (url) =>
1124 {
1125 const parsed = new URL(url, 'http://localhost/');
1126 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
1127 requestedTimes.push(timeSeconds);
1128
1129 if (requestedTimes.length === 1)
1130 {
1131 return new Response('png-data', {
1132 status: 200,
1133 headers: {
1134 'Content-Type': 'image/png',
1135 'X-Subtitle-Frame-Status': 'ok',
1136 'X-Subtitle-Frame-Start-Time': '4',
1137 'X-Subtitle-Frame-End-Time': '5',
1138 'X-Subtitle-Frame-Width': '320',
1139 'X-Subtitle-Frame-Height': '180',
1140 'X-Subtitle-Frame-Canvas-Width': '640',
1141 'X-Subtitle-Frame-Canvas-Height': '360',
1142 },
1143 });
1144 }
1145
1146 return new Response('png-data', {
1147 status: 200,
1148 headers: {
1149 'Content-Type': 'image/png',
1150 'X-Subtitle-Frame-Status': 'ok',
1151 'X-Subtitle-Frame-Start-Time': '2',
1152 'X-Subtitle-Frame-End-Time': '3',
1153 'X-Subtitle-Frame-Width': '320',
1154 'X-Subtitle-Frame-Height': '180',
1155 'X-Subtitle-Frame-Canvas-Width': '640',
1156 'X-Subtitle-Frame-Canvas-Height': '360',
1157 },
1158 });
1159 });
1160
1161 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1162 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1163 }, {
1164 lookaheadSeconds: 0,
1165 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1166 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1167 }),
1168 });
1169
1170 await flushAsyncWork(window, 8);
1171
1172 const requestedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-right');
1173 const receivedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-left');
1174 expect(requestedMarker).toBeTruthy();
1175 expect(receivedMarker).toBeTruthy();
1176 expect(requestedMarker.style.left).toBe('100.0000%');
1177 expect(receivedMarker.style.left).toBe('33.3333%');
1178
1179 player.setCurrentTime(1.5);
1180 player.trigger('timeupdate');
1181 await flushAsyncWork(window, 8);
1182
1183 // Second response reports an older start time, but markers stay monotonic.
1184 expect(requestedMarker.style.left).toBe('100.0000%');
1185 expect(receivedMarker.style.left).toBe('33.3333%');
1186
1187 controller.detach();
1188 await flushAsyncWork(window, 2);
1189 window.close();
1190 });
1191
1192 test('continues current subtitle refreshes after a force-seek aborts the in-flight request', async () =>
1193 {
1194 const window = createWindow();
1195 const helper = loadSharedVideoPlayer(window);
1196 const { player, videojs } = buildPlayerHarness(window);
1197 const requestedTimes = [];
1198
1199 window.fetch = jest.fn((url, init = {}) =>
1200 {
1201 const parsed = new URL(url, 'http://localhost/');
1202 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
1203 requestedTimes.push(timeSeconds);
1204
1205 if (requestedTimes.length === 1)
1206 {
1207 return new Promise((resolve, reject) =>
1208 {
1209 if (init.signal && typeof init.signal.addEventListener === 'function')
1210 {
1211 init.signal.addEventListener('abort', () =>
1212 {
1213 reject(new window.DOMException('Aborted', 'AbortError'));
1214 }, { once: true });
1215 }
1216 });
1217 }
1218
1219 return Promise.resolve(new Response(null, {
1220 status: 204,
1221 headers: {
1222 'X-Subtitle-Frame-Status': 'none',
1223 },
1224 }));
1225 });
1226
1227 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1228 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1229 }, {
1230 lookaheadSeconds: 0,
1231 currentRequestTimeoutMs: 300,
1232 logToConsole: false,
1233 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1234 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1235 }),
1236 });
1237
1238 await flushAsyncWork(window, 4);
1239 const afterInitialLoadCalls = window.fetch.mock.calls.length;
1240 expect(afterInitialLoadCalls).toBeGreaterThan(0);
1241
1242 player.setCurrentTime(5);
1243 player.trigger('seeking');
1244 await flushAsyncWork(window, 20);
1245
1246 expect(window.fetch.mock.calls.length).toBeGreaterThanOrEqual(2);
1247 expect(requestedTimes).toEqual(expect.arrayContaining([0, 5]));
1248
1249 controller.detach();
1250 await flushAsyncWork(window, 2);
1251 window.close();
1252 });
1253
1254 test('recovers when a current subtitle request hangs and times out', async () =>
1255 {
1256 const window = createWindow();
1257 const helper = loadSharedVideoPlayer(window);
1258 const { player, videojs } = buildPlayerHarness(window);
1259 const requestedTimes = [];
1260
1261 window.fetch = jest.fn((url, init = {}) =>
1262 {
1263 const parsed = new URL(url, 'http://localhost/');
1264 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
1265 requestedTimes.push(timeSeconds);
1266
1267 if (requestedTimes.length === 1)
1268 {
1269 return new Promise((resolve, reject) =>
1270 {
1271 if (init.signal && typeof init.signal.addEventListener === 'function')
1272 {
1273 init.signal.addEventListener('abort', () =>
1274 {
1275 reject(new window.DOMException('Aborted', 'AbortError'));
1276 }, { once: true });
1277 }
1278 });
1279 }
1280
1281 return Promise.resolve(new Response(null, {
1282 status: 204,
1283 headers: { 'X-Subtitle-Frame-Status': 'none' },
1284 }));
1285 });
1286
1287 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1288 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1289 }, {
1290 lookaheadSeconds: 0,
1291 currentRequestTimeoutMs: 250,
1292 logToConsole: false,
1293 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1294 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1295 }),
1296 });
1297
1298 await flushAsyncWork(window, 3);
1299
1300 player.setCurrentTime(1.5);
1301 player.trigger('timeupdate');
1302
1303 await new Promise((resolve) => window.setTimeout(resolve, 320));
1304 player.trigger('timeupdate');
1305 await new Promise((resolve) => window.setTimeout(resolve, 220));
1306 await flushAsyncWork(window, 20);
1307
1308 expect(window.fetch.mock.calls.length).toBeGreaterThanOrEqual(2);
1309 expect(requestedTimes).toEqual(expect.arrayContaining([0, 1.5]));
1310
1311 controller.detach();
1312 await new Promise((resolve) => window.setTimeout(resolve, 200));
1313 await flushAsyncWork(window, 20);
1314 window.close();
1315 });
1316
1317 test('reuses cached subtitle frames after rewinding when server no longer has older frames', async () =>
1318 {
1319 const window = createWindow();
1320 const helper = loadSharedVideoPlayer(window);
1321 const { player, videojs } = buildPlayerHarness(window);
1322
1323 player.duration(10);
1324 player.setCurrentTime(2);
1325 window.fetch = jest.fn(async (url) =>
1326 {
1327 const parsed = new URL(url, 'http://localhost/');
1328 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
1329
1330 if (Math.abs(timeSeconds - 2) < 1e-6)
1331 {
1332 return new Response('png-data', {
1333 status: 200,
1334 headers: {
1335 'Content-Type': 'image/png',
1336 'X-Subtitle-Frame-Status': 'ok',
1337 'X-Subtitle-Frame-Start-Time': '2',
1338 'X-Subtitle-Frame-End-Time': '3',
1339 'X-Subtitle-Frame-Width': '320',
1340 'X-Subtitle-Frame-Height': '180',
1341 'X-Subtitle-Frame-Canvas-Width': '640',
1342 'X-Subtitle-Frame-Canvas-Height': '360',
1343 },
1344 });
1345 }
1346
1347 return new Response(null, {
1348 status: 204,
1349 headers: {
1350 'X-Subtitle-Frame-Status': 'none',
1351 },
1352 });
1353 });
1354
1355 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1356 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1357 }, {
1358 lookaheadSeconds: 0,
1359 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1360 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1361 }),
1362 });
1363
1364 await flushAsyncWork(window, 8);
1365 const afterInitialLoadCalls = window.fetch.mock.calls.length;
1366 expect(afterInitialLoadCalls).toBeGreaterThan(0);
1367
1368 player.setCurrentTime(4);
1369 player.trigger('timeupdate');
1370 await flushAsyncWork(window, 8);
1371 const afterForwardSeekCalls = window.fetch.mock.calls.length;
1372 expect(afterForwardSeekCalls).toBeGreaterThanOrEqual(afterInitialLoadCalls);
1373
1374 const overlay = player.el().querySelector('.video-subtitle-overlay');
1375 expect(overlay).toBeTruthy();
1376 expect(overlay.style.display).toBe('none');
1377
1378 player.setCurrentTime(2.5);
1379 player.trigger('timeupdate');
1380 await flushAsyncWork(window, 8);
1381
1382 expect(window.fetch.mock.calls.length).toBe(afterForwardSeekCalls);
1383 expect(overlay.style.display).toBe('block');
1384
1385 controller.detach();
1386 await flushAsyncWork(window, 2);
1387 window.close();
1388 });
1389
1390 test('registers stream cache service worker once when supported', async () =>
1391 {
1392 const window = createWindow();
1393 const helper = loadSharedVideoPlayer(window);
1394 const register = jest.fn(async () => ({}));
1395 window.navigator.serviceWorker = { register };
1396
1397 const first = await helper.enableVideoStreamClientCache();
1398 const second = await helper.enableVideoStreamClientCache();
1399
1400 expect(first).toBe(true);
1401 expect(second).toBe(true);
1402 expect(register).toHaveBeenCalledTimes(1);
1403 expect(register).toHaveBeenCalledWith('/stream-cache-sw.js', {
1404 scope: '/',
1405 updateViaCache: 'none',
1406 });
1407
1408 window.close();
1409 });
1410
1411 test('stream-ahead prefetch follows playlists and fetches segment assets', async () =>
1412 {
1413 const window = createWindow();
1414 const helper = loadSharedVideoPlayer(window);
1415 const requestedUrls = [];
1416
1417 window.fetch = jest.fn(async (input) =>
1418 {
1419 const url = String(input && input.url ? input.url : input);
1420 requestedUrls.push(url);
1421
1422 if (url === 'http://localhost/master.m3u8')
1423 {
1424 return new Response('#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=100000\nstream_0.m3u8\n#EXT-X-ENDLIST\n', {
1425 status: 200,
1426 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1427 });
1428 }
1429
1430 if (url === 'http://localhost/stream_0.m3u8')
1431 {
1432 return new Response('#EXTM3U\n#EXTINF:4,\nseg0.ts\n#EXTINF:4,\nseg1.ts\n#EXT-X-ENDLIST\n', {
1433 status: 200,
1434 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1435 });
1436 }
1437
1438 if (url === 'http://localhost/seg0.ts' || url === 'http://localhost/seg1.ts')
1439 {
1440 return new Response(new Uint8Array([1, 2, 3, 4]), {
1441 status: 200,
1442 headers: { 'Content-Type': 'video/mp2t' },
1443 });
1444 }
1445
1446 return new Response(null, { status: 404 });
1447 });
1448
1449 const controller = helper.bindStreamAheadPrefetch({
1450 playlistUrl: 'http://localhost/master.m3u8',
1451 pollIntervalMs: 0,
1452 credentials: 'same-origin',
1453 });
1454
1455 expect(controller).toBeTruthy();
1456 await controller.done();
1457
1458 expect(requestedUrls).toEqual(expect.arrayContaining([
1459 'http://localhost/master.m3u8',
1460 'http://localhost/stream_0.m3u8',
1461 'http://localhost/seg0.ts',
1462 'http://localhost/seg1.ts',
1463 ]));
1464
1465 controller.stop();
1466 window.close();
1467 });
1468
1469 test('stream-ahead prefetch reports cached-through progress for fetched segments', async () =>
1470 {
1471 const window = createWindow();
1472 const helper = loadSharedVideoPlayer(window);
1473 const progressSamples = [];
1474
1475 window.fetch = jest.fn(async (input) =>
1476 {
1477 const url = String(input && input.url ? input.url : input);
1478
1479 if (url === 'http://localhost/master.m3u8')
1480 {
1481 return new Response('#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=100000\nstream_0.m3u8\n#EXT-X-ENDLIST\n', {
1482 status: 200,
1483 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1484 });
1485 }
1486
1487 if (url === 'http://localhost/stream_0.m3u8')
1488 {
1489 return new Response('#EXTM3U\n#EXTINF:4,\nseg0.ts\n#EXTINF:4,\nseg1.ts\n#EXT-X-ENDLIST\n', {
1490 status: 200,
1491 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1492 });
1493 }
1494
1495 if (url === 'http://localhost/seg0.ts' || url === 'http://localhost/seg1.ts')
1496 {
1497 return new Response(new Uint8Array([1, 2, 3, 4]), {
1498 status: 200,
1499 headers: { 'Content-Type': 'video/mp2t' },
1500 });
1501 }
1502
1503 return new Response(null, { status: 404 });
1504 });
1505
1506 const controller = helper.bindStreamAheadPrefetch({
1507 playlistUrl: 'http://localhost/master.m3u8',
1508 pollIntervalMs: 0,
1509 credentials: 'same-origin',
1510 });
1511
1512 expect(controller).toBeTruthy();
1513 const unsubscribe = controller.subscribe((status) =>
1514 {
1515 progressSamples.push(status && status.cachedThroughSeconds);
1516 });
1517
1518 await controller.done();
1519 unsubscribe();
1520
1521 expect(progressSamples.some((value) => Number.isFinite(value) && value >= 8)).toBe(true);
1522
1523 controller.stop();
1524 window.close();
1525 });
1526
1527 test('stream-ahead prefetch infers cached-through progress from segment filenames', async () =>
1528 {
1529 const window = createWindow();
1530 const helper = loadSharedVideoPlayer(window);
1531 const progressSamples = [];
1532
1533 window.fetch = jest.fn(async (input) =>
1534 {
1535 const url = String(input && input.url ? input.url : input);
1536
1537 if (url === 'http://localhost/master.m3u8')
1538 {
1539 return new Response('#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=100000\nstream_0.m3u8\n#EXT-X-ENDLIST\n', {
1540 status: 200,
1541 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1542 });
1543 }
1544
1545 if (url === 'http://localhost/stream_0.m3u8')
1546 {
1547 return new Response('#EXTM3U\nstream_0_segment_000000.ts\nstream_0_segment_000001.ts\n#EXT-X-ENDLIST\n', {
1548 status: 200,
1549 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1550 });
1551 }
1552
1553 if (url === 'http://localhost/stream_0_segment_000000.ts' || url === 'http://localhost/stream_0_segment_000001.ts')
1554 {
1555 return new Response(new Uint8Array([1, 2, 3, 4]), {
1556 status: 200,
1557 headers: { 'Content-Type': 'video/mp2t' },
1558 });
1559 }
1560
1561 return new Response(null, { status: 404 });
1562 });
1563
1564 const controller = helper.bindStreamAheadPrefetch({
1565 playlistUrl: 'http://localhost/master.m3u8',
1566 pollIntervalMs: 0,
1567 credentials: 'same-origin',
1568 });
1569
1570 expect(controller).toBeTruthy();
1571 const unsubscribe = controller.subscribe((status) =>
1572 {
1573 progressSamples.push(status && status.cachedThroughSeconds);
1574 });
1575
1576 await controller.done();
1577 unsubscribe();
1578
1579 expect(progressSamples.some((value) => Number.isFinite(value) && value >= 8)).toBe(true);
1580
1581 controller.stop();
1582 window.close();
1583 });
1584
1585 test('stream-ahead prefetch infers cached-through progress for m4s segment filenames', async () =>
1586 {
1587 const window = createWindow();
1588 const helper = loadSharedVideoPlayer(window);
1589 const progressSamples = [];
1590
1591 window.fetch = jest.fn(async (input) =>
1592 {
1593 const url = String(input && input.url ? input.url : input);
1594
1595 if (url === 'http://localhost/master.m3u8')
1596 {
1597 return new Response('#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=100000\nstream_0.m3u8\n#EXT-X-ENDLIST\n', {
1598 status: 200,
1599 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1600 });
1601 }
1602
1603 if (url === 'http://localhost/stream_0.m3u8')
1604 {
1605 return new Response('#EXTM3U\nstream_0_segment_000000.m4s\nstream_0_segment_000001.m4s\n#EXT-X-ENDLIST\n', {
1606 status: 200,
1607 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1608 });
1609 }
1610
1611 if (url === 'http://localhost/stream_0_segment_000000.m4s' || url === 'http://localhost/stream_0_segment_000001.m4s')
1612 {
1613 return new Response(new Uint8Array([1, 2, 3, 4]), {
1614 status: 200,
1615 headers: { 'Content-Type': 'video/mp4' },
1616 });
1617 }
1618
1619 return new Response(null, { status: 404 });
1620 });
1621
1622 const controller = helper.bindStreamAheadPrefetch({
1623 playlistUrl: 'http://localhost/master.m3u8',
1624 pollIntervalMs: 0,
1625 credentials: 'same-origin',
1626 });
1627
1628 expect(controller).toBeTruthy();
1629 const unsubscribe = controller.subscribe((status) =>
1630 {
1631 progressSamples.push(status && status.cachedThroughSeconds);
1632 });
1633
1634 await controller.done();
1635 unsubscribe();
1636
1637 expect(progressSamples.some((value) => Number.isFinite(value) && value >= 8)).toBe(true);
1638
1639 controller.stop();
1640 window.close();
1641 });
1642
1643 test('stream-ahead prefetch reports ratio progress from fetched sections when timing is unknown', async () =>
1644 {
1645 const window = createWindow();
1646 const helper = loadSharedVideoPlayer(window);
1647 const statusSamples = [];
1648
1649 window.fetch = jest.fn(async (input) =>
1650 {
1651 const url = String(input && input.url ? input.url : input);
1652
1653 if (url === 'http://localhost/master.m3u8')
1654 {
1655 return new Response('#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=100000\nstream_0.m3u8\n#EXT-X-ENDLIST\n', {
1656 status: 200,
1657 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1658 });
1659 }
1660
1661 if (url === 'http://localhost/stream_0.m3u8')
1662 {
1663 return new Response('#EXTM3U\nchunk-alpha.bin\nchunk-beta.bin\n#EXT-X-ENDLIST\n', {
1664 status: 200,
1665 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1666 });
1667 }
1668
1669 if (url === 'http://localhost/chunk-alpha.bin' || url === 'http://localhost/chunk-beta.bin')
1670 {
1671 return new Response(new Uint8Array([1, 2, 3, 4]), {
1672 status: 200,
1673 headers: { 'Content-Type': 'application/octet-stream' },
1674 });
1675 }
1676
1677 return new Response(null, { status: 404 });
1678 });
1679
1680 const controller = helper.bindStreamAheadPrefetch({
1681 playlistUrl: 'http://localhost/master.m3u8',
1682 pollIntervalMs: 0,
1683 credentials: 'same-origin',
1684 });
1685
1686 expect(controller).toBeTruthy();
1687 const unsubscribe = controller.subscribe((status) =>
1688 {
1689 statusSamples.push(status || {});
1690 });
1691
1692 await controller.done();
1693 unsubscribe();
1694
1695 const finalStatus = statusSamples[statusSamples.length - 1] || {};
1696 expect(finalStatus.totalSegmentCount).toBe(2);
1697 expect(finalStatus.fetchedSegmentCount).toBe(2);
1698 expect(finalStatus.cachedThroughRatio).toBe(1);
1699
1700 controller.stop();
1701 window.close();
1702 });
1703
1704 test('clears cached stream assets for a finished playlist session', async () =>
1705 {
1706 const window = createWindow();
1707 const helper = loadSharedVideoPlayer(window);
1708 const requests = [
1709 new window.Request('http://localhost/api/files/video-stream/sess-a/master.m3u8'),
1710 new window.Request('http://localhost/api/files/video-stream/sess-a/stream_0_segment_000001.ts'),
1711 new window.Request('http://localhost/api/files/video-stream/sess-b/master.m3u8'),
1712 ];
1713 const deleteCalls = [];
1714 const cache = {
1715 keys: jest.fn(async () => requests),
1716 delete: jest.fn(async (request) =>
1717 {
1718 deleteCalls.push(request.url);
1719 return true;
1720 }),
1721 };
1722 window.caches = {
1723 open: jest.fn(async () => cache),
1724 };
1725
1726 await helper.clearVideoStreamClientCache('http://localhost/api/files/video-stream/sess-a/master.m3u8');
1727
1728 expect(window.caches.open).toHaveBeenCalledWith('filemanager-stream-cache-v1');
1729 expect(cache.keys).toHaveBeenCalledTimes(1);
1730 expect(deleteCalls).toEqual(expect.arrayContaining([
1731 'http://localhost/api/files/video-stream/sess-a/master.m3u8',
1732 'http://localhost/api/files/video-stream/sess-a/stream_0_segment_000001.ts',
1733 ]));
1734 expect(deleteCalls).not.toContain('http://localhost/api/files/video-stream/sess-b/master.m3u8');
1735
1736 window.close();
1737 });
1738});