BlueGit

timfa filemanager

Files

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

shared-video-player.test.js

Improve subtitle display timing
timfa Tim Falken · pushed by timfa · 5 months ago
34ec2083 History
shared-video-player.test.js 63.0 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('range prefetch clamps the tail window to the known video duration', async () =>
308 {
309 const window = createWindow();
310 const helper = loadSharedVideoPlayer(window);
311 const { player, videojs } = buildPlayerHarness(window);
312 const requestedRanges = [];
313
314 player.duration(10);
315 player.setCurrentTime(8.5);
316
317 window.fetch = jest.fn(async (url) =>
318 {
319 const parsed = new URL(url, 'http://localhost/');
320 requestedRanges.push({
321 start: Number(parsed.searchParams.get('startTimeSeconds')),
322 end: Number(parsed.searchParams.get('endTimeSeconds')),
323 });
324 return new Response(JSON.stringify({ status: 'ok', frames: [] }), {
325 status: 200,
326 headers: { 'Content-Type': 'application/json' },
327 });
328 });
329
330 helper.bindImageSubtitleOverlay(player, videojs, {}, {
331 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
332 }, {
333 lookaheadSeconds: 0,
334 initialPrefetchSeconds: 0,
335 currentFetchEnabled: false,
336 cacheMissFallbackEnabled: false,
337 prefetchAdaptiveStepEnabled: true,
338 prefetchStepSecondsMin: 3,
339 prefetchStepSecondsMax: 3,
340 buildFrameRequest: ({ currentTime, streamIndex }) => ({
341 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
342 }),
343 buildPrefetchRequest: ({ currentTime, endTime, streamIndex }) => ({
344 url: `/subtitle-range?streamIndex=${streamIndex}&startTimeSeconds=${currentTime}&endTimeSeconds=${endTime}`,
345 }),
346 });
347
348 player.trigger('timeupdate');
349 await flushAsyncWork(window, 10);
350
351 expect(requestedRanges.length).toBeGreaterThan(0);
352 expect(requestedRanges[0]).toEqual({ start: 8.5, end: 10 });
353 expect(requestedRanges.every((range) => range.end <= 10)).toBe(true);
354
355 window.close();
356 });
357
358 test('prefetch respects configured larger prefetch step size', async () =>
359 {
360 const window = createWindow();
361 const helper = loadSharedVideoPlayer(window);
362 const { player, videojs } = buildPlayerHarness(window);
363 const requestedTimes = [];
364
365 player.duration(6);
366
367 window.fetch = jest.fn(async (url) =>
368 {
369 const parsed = new URL(url, 'http://localhost/');
370 requestedTimes.push(Number(parsed.searchParams.get('timeSeconds')));
371 return new Response(null, {
372 status: 204,
373 headers: { 'X-Subtitle-Frame-Status': 'none' },
374 });
375 });
376
377 helper.bindImageSubtitleOverlay(player, videojs, {}, {
378 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
379 }, {
380 lookaheadSeconds: 0,
381 initialPrefetchSeconds: 0,
382 prefetchStepSeconds: 2,
383 buildFrameRequest: ({ currentTime, streamIndex }) => ({
384 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
385 }),
386 });
387
388 await flushAsyncWork(window, 14);
389
390 expect(requestedTimes).toEqual(expect.arrayContaining([0, 2, 4, 6]));
391
392 window.close();
393 });
394
395 test('adaptive prefetch step increases stride when cache lead grows', async () =>
396 {
397 const window = createWindow();
398 const helper = loadSharedVideoPlayer(window);
399 const { player, videojs } = buildPlayerHarness(window);
400 const requestedTimes = [];
401
402 player.duration(40);
403
404 window.fetch = jest.fn(async (url) =>
405 {
406 const parsed = new URL(url, 'http://localhost/');
407 requestedTimes.push(Number(parsed.searchParams.get('timeSeconds')));
408 return new Response(null, {
409 status: 204,
410 headers: { 'X-Subtitle-Frame-Status': 'none' },
411 });
412 });
413
414 helper.bindImageSubtitleOverlay(player, videojs, {}, {
415 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
416 }, {
417 lookaheadSeconds: 20,
418 initialPrefetchSeconds: 0,
419 prefetchAdaptiveStepEnabled: true,
420 prefetchStepSecondsMin: 1,
421 prefetchStepSecondsMax: 5,
422 buildFrameRequest: ({ currentTime, streamIndex }) => ({
423 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
424 }),
425 });
426
427 await flushAsyncWork(window, 20);
428
429 const strideSamples = [];
430 for (let i = 1; i < requestedTimes.length; i++)
431 {
432 const stride = requestedTimes[i] - requestedTimes[i - 1];
433 if (Number.isFinite(stride) && stride > 0) strideSamples.push(Number(stride.toFixed(3)));
434 }
435
436 expect(strideSamples.some((stride) => stride > 1.25)).toBe(true);
437
438 window.close();
439 });
440
441 test('prefetch can cache subtitle frames from a range request and render immediately', async () =>
442 {
443 const window = createWindow();
444 const helper = loadSharedVideoPlayer(window);
445 const { player, videojs } = buildPlayerHarness(window);
446 const requestedUrls = [];
447
448 player.duration(12);
449 player.setCurrentTime(2);
450
451 window.fetch = jest.fn(async (url) =>
452 {
453 const parsed = new URL(url, 'http://localhost/');
454 requestedUrls.push(parsed.pathname + parsed.search);
455
456 if (parsed.pathname === '/subtitle-range')
457 {
458 return new Response(JSON.stringify({
459 status: 'ok',
460 startTimeSeconds: Number(parsed.searchParams.get('startTimeSeconds')),
461 endTimeSeconds: Number(parsed.searchParams.get('endTimeSeconds')),
462 frames: [
463 {
464 left: 0,
465 top: 0,
466 width: 320,
467 height: 180,
468 canvasWidth: 640,
469 canvasHeight: 360,
470 startTimeSeconds: 2,
471 endTimeSeconds: 4,
472 contentType: 'image/png',
473 frameBase64: Buffer.from('png-data').toString('base64'),
474 },
475 ],
476 }), {
477 status: 200,
478 headers: { 'Content-Type': 'application/json' },
479 });
480 }
481
482 return new Response(null, {
483 status: 204,
484 headers: { 'X-Subtitle-Frame-Status': 'none' },
485 });
486 });
487
488 helper.bindImageSubtitleOverlay(player, videojs, {}, {
489 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
490 }, {
491 currentFetchEnabled: false,
492 cacheMissFallbackEnabled: false,
493 lookaheadSeconds: 0,
494 initialPrefetchSeconds: 0,
495 buildPrefetchRequest: ({ currentTime, endTime, streamIndex }) => ({
496 url: `/subtitle-range?streamIndex=${streamIndex}&startTimeSeconds=${currentTime}&endTimeSeconds=${endTime}`,
497 }),
498 buildFrameRequest: ({ currentTime, streamIndex }) => ({
499 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
500 }),
501 });
502
503 await flushAsyncWork(window, 10);
504
505 expect(requestedUrls.some((url) => url.startsWith('/subtitle-range'))).toBe(true);
506 expect(requestedUrls.some((url) => url.startsWith('/subtitle-frame'))).toBe(false);
507
508 const overlay = player.el().querySelector('.video-subtitle-overlay');
509 expect(overlay).toBeTruthy();
510 expect(overlay.style.display).toBe('block');
511
512 window.close();
513 });
514
515 test('prefetch uses furthest buffered end when player.bufferedEnd under-reports', async () =>
516 {
517 const window = createWindow();
518 const helper = loadSharedVideoPlayer(window);
519 const { player, videojs } = buildPlayerHarness(window);
520 const requestedTimes = [];
521
522 player.setBufferedEnd(0);
523 player.tech = () => ({
524 el: () => ({
525 buffered: {
526 length: 1,
527 end: () => 6,
528 },
529 }),
530 });
531
532 window.fetch = jest.fn(async (url) =>
533 {
534 const parsed = new URL(url, 'http://localhost/');
535 requestedTimes.push(Number(parsed.searchParams.get('timeSeconds')));
536 return new Response(null, {
537 status: 204,
538 headers: { 'X-Subtitle-Frame-Status': 'none' },
539 });
540 });
541
542 helper.bindImageSubtitleOverlay(player, videojs, {}, {
543 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
544 }, {
545 lookaheadSeconds: 0,
546 initialPrefetchSeconds: 0,
547 buildFrameRequest: ({ currentTime, streamIndex }) => ({
548 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
549 }),
550 });
551
552 await flushAsyncWork(window, 16);
553
554 expect(requestedTimes).toEqual(expect.arrayContaining([0, 0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5, 5.5, 6]));
555
556 window.close();
557 });
558
559 test('prefetch frontier jumps to current playback time instead of replaying stale lag', async () =>
560 {
561 const window = createWindow();
562 const helper = loadSharedVideoPlayer(window);
563 const { player, videojs } = buildPlayerHarness(window);
564 const requestedTimes = [];
565
566 player.duration(60);
567 player.setBufferedEnd(2);
568
569 window.fetch = jest.fn(async (url) =>
570 {
571 const parsed = new URL(url, 'http://localhost/');
572 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
573 requestedTimes.push(timeSeconds);
574 return new Response(null, {
575 status: 204,
576 headers: { 'X-Subtitle-Frame-Status': 'none' },
577 });
578 });
579
580 helper.bindImageSubtitleOverlay(player, videojs, {}, {
581 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
582 }, {
583 lookaheadSeconds: 0,
584 initialPrefetchSeconds: 0,
585 buildFrameRequest: ({ currentTime, streamIndex }) => ({
586 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
587 }),
588 });
589
590 await flushAsyncWork(window, 8);
591 expect(requestedTimes).toEqual(expect.arrayContaining([0, 0.5]));
592
593 requestedTimes.length = 0;
594 player.setCurrentTime(20);
595 player.setBufferedEnd(40);
596 player.trigger('timeupdate');
597 await flushAsyncWork(window, 8);
598
599 expect(requestedTimes).toContain(20);
600 expect(requestedTimes.some((value) => value < 20)).toBe(false);
601 const prefetchAfterJump = requestedTimes.filter((value) => value > 20);
602 if (prefetchAfterJump.length)
603 {
604 expect(Math.min(...prefetchAfterJump)).toBeGreaterThanOrEqual(20.5);
605 }
606
607 window.close();
608 });
609
610 test('does not restart current subtitle request while one is in flight', async () =>
611 {
612 const window = createWindow();
613 const helper = loadSharedVideoPlayer(window);
614 const { player, videojs } = buildPlayerHarness(window);
615 const pendingResolvers = [];
616 const requestTimes = [];
617
618 window.fetch = jest.fn((url, init = {}) =>
619 {
620 const parsed = new URL(url, 'http://localhost/');
621 requestTimes.push(Number(parsed.searchParams.get('timeSeconds')));
622
623 if (pendingResolvers.length === 0)
624 {
625 return new Promise((resolve) =>
626 {
627 pendingResolvers.push(() => resolve(new Response(null, {
628 status: 204,
629 headers: { 'X-Subtitle-Frame-Status': 'none' },
630 })));
631 });
632 }
633
634 expect(init.signal && init.signal.aborted).toBe(false);
635 return Promise.resolve(new Response(null, {
636 status: 204,
637 headers: { 'X-Subtitle-Frame-Status': 'none' },
638 }));
639 });
640
641 helper.bindImageSubtitleOverlay(player, videojs, {}, {
642 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
643 }, {
644 lookaheadSeconds: 0,
645 initialPrefetchSeconds: 0,
646 buildFrameRequest: ({ currentTime, streamIndex }) => ({
647 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
648 }),
649 });
650
651 await flushAsyncWork(window, 3);
652 expect(window.fetch).toHaveBeenCalledTimes(1);
653
654 player.setCurrentTime(1.5);
655 player.trigger('timeupdate');
656 player.setCurrentTime(2.25);
657 player.trigger('timeupdate');
658 await flushAsyncWork(window, 2);
659
660 expect(window.fetch).toHaveBeenCalledTimes(1);
661
662 pendingResolvers[0]();
663 await flushAsyncWork(window, 5);
664
665 expect(window.fetch.mock.calls.length).toBeGreaterThanOrEqual(2);
666 expect(requestTimes).toEqual(expect.arrayContaining([0, 2.25]));
667
668 window.close();
669 });
670
671 test('renders a prefetched frame for the current paused time without waiting for another timeupdate', async () =>
672 {
673 const window = createWindow();
674 const helper = loadSharedVideoPlayer(window);
675 const { player, videojs } = buildPlayerHarness(window);
676
677 player.duration(120);
678 player.setCurrentTime(118.95);
679
680 window.fetch = jest.fn(async (url) =>
681 {
682 const parsed = new URL(url, 'http://localhost/');
683 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
684 const headers = {
685 'Content-Type': 'image/png',
686 };
687
688 if (Math.abs(timeSeconds - 118.95) < 0.001)
689 {
690 headers['X-Subtitle-Frame-Start-Time'] = '118.90';
691 headers['X-Subtitle-Frame-End-Time'] = '119.00';
692 headers['X-Subtitle-Frame-Width'] = '640';
693 headers['X-Subtitle-Frame-Height'] = '80';
694 headers['X-Subtitle-Frame-Canvas-Width'] = '1920';
695 headers['X-Subtitle-Frame-Canvas-Height'] = '1080';
696 return new Response(new Uint8Array([137, 80, 78, 71]), { status: 200, headers });
697 }
698
699 return new Response(null, {
700 status: 204,
701 headers: { 'X-Subtitle-Frame-Status': 'none' },
702 });
703 });
704
705 helper.bindImageSubtitleOverlay(player, videojs, {}, {
706 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
707 }, {
708 currentFetchEnabled: false,
709 cacheMissFallbackEnabled: false,
710 lookaheadSeconds: 0,
711 initialPrefetchSeconds: 0,
712 buildFrameRequest: ({ currentTime, streamIndex }) => ({
713 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
714 }),
715 });
716
717 await flushAsyncWork(window, 10);
718
719 const overlay = player.el().querySelector('.video-subtitle-overlay');
720 const overlayImg = overlay && overlay.querySelector('img');
721 expect(overlay).toBeTruthy();
722 expect(overlayImg).toBeTruthy();
723 expect(overlay.style.display).toBe('block');
724 expect(overlayImg.getAttribute('src')).toBe('blob:subtitle');
725
726 window.close();
727 });
728
729 test('syncs caption visibility from cache between sparse timeupdate events', async () =>
730 {
731 const window = createWindow();
732 const helper = loadSharedVideoPlayer(window);
733 const { player, videojs } = buildPlayerHarness(window);
734
735 // JSDOM raf cadence can be inconsistent; force timeout fallback for stable checks.
736 window.requestAnimationFrame = undefined;
737 window.cancelAnimationFrame = undefined;
738
739 player.duration(20);
740
741 window.fetch = jest.fn(async () =>
742 {
743 return new Response(new Uint8Array([137, 80, 78, 71]), {
744 status: 200,
745 headers: {
746 'Content-Type': 'image/png',
747 'X-Subtitle-Frame-Start-Time': '1',
748 'X-Subtitle-Frame-End-Time': '2',
749 'X-Subtitle-Frame-Width': '640',
750 'X-Subtitle-Frame-Height': '80',
751 'X-Subtitle-Frame-Canvas-Width': '1920',
752 'X-Subtitle-Frame-Canvas-Height': '1080',
753 },
754 });
755 });
756
757 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
758 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
759 }, {
760 lookaheadSeconds: 0,
761 initialPrefetchSeconds: 0,
762 buildFrameRequest: ({ currentTime, streamIndex }) => ({
763 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
764 }),
765 });
766
767 await flushAsyncWork(window, 8);
768
769 const overlay = player.el().querySelector('.video-subtitle-overlay');
770 expect(overlay).toBeTruthy();
771
772 player.setCurrentTime(1.2);
773 player.trigger('play');
774 await new Promise((resolve) => window.setTimeout(resolve, 50));
775 await flushAsyncWork(window, 2);
776 expect(overlay.style.display).toBe('block');
777
778 player.setCurrentTime(2.2);
779 await new Promise((resolve) => window.setTimeout(resolve, 50));
780 await flushAsyncWork(window, 2);
781 expect(overlay.style.display).toBe('none');
782
783 controller.detach();
784 await flushAsyncWork(window, 2);
785 window.close();
786 });
787
788 test('aborts in-flight prefetch requests when the overlay is detached', async () =>
789 {
790 const window = createWindow();
791 const helper = loadSharedVideoPlayer(window);
792 const { player, videojs } = buildPlayerHarness(window);
793 const activeSignals = [];
794
795 window.fetch = jest.fn((url, init = {}) =>
796 {
797 const parsed = new URL(url, 'http://localhost/');
798 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
799
800 if (timeSeconds === 0)
801 {
802 return Promise.resolve(new Response(null, {
803 status: 204,
804 headers: { 'X-Subtitle-Frame-Status': 'none' },
805 }));
806 }
807
808 activeSignals.push(init.signal || null);
809
810 return new Promise((resolve, reject) =>
811 {
812 if (init.signal && typeof init.signal.addEventListener === 'function')
813 {
814 init.signal.addEventListener('abort', () =>
815 {
816 reject(new DOMException('Aborted', 'AbortError'));
817 }, { once: true });
818 }
819 });
820 });
821
822 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
823 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
824 }, {
825 lookaheadSeconds: 1,
826 buildFrameRequest: ({ currentTime, streamIndex }) => ({
827 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
828 }),
829 });
830
831 await flushAsyncWork(window, 3);
832 expect(activeSignals.length).toBeGreaterThan(0);
833
834 controller.detach();
835 await flushAsyncWork(window, 2);
836
837 expect(activeSignals.every(signal => signal && signal.aborted)).toBe(true);
838
839 window.close();
840 });
841
842 test('logs current subtitle request lifecycle events and flushes them on detach', async () =>
843 {
844 const window = createWindow();
845 const helper = loadSharedVideoPlayer(window);
846 const { player, videojs } = buildPlayerHarness(window);
847 const sentBatches = [];
848
849 window.fetch = jest.fn(async () =>
850 {
851 return new Response('png-data', {
852 status: 200,
853 headers: {
854 'Content-Type': 'image/png',
855 'X-Subtitle-Frame-Status': 'ok',
856 'X-Subtitle-Request-Received-At-Ms': '1000',
857 'X-Subtitle-Response-Sent-At-Ms': '1012',
858 'X-Subtitle-Frame-Start-Time': '1.5',
859 'X-Subtitle-Frame-End-Time': '3.2',
860 'X-Subtitle-Frame-Width': '320',
861 'X-Subtitle-Frame-Height': '180',
862 'X-Subtitle-Frame-Canvas-Width': '640',
863 'X-Subtitle-Frame-Canvas-Height': '360',
864 },
865 });
866 });
867
868 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
869 sessionId: 'sess-1',
870 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
871 }, {
872 lookaheadSeconds: 0,
873 sendSubtitleLogBatch: (entries) =>
874 {
875 sentBatches.push(entries);
876 return Promise.resolve();
877 },
878 buildFrameRequest: ({ currentTime, streamIndex }) => ({
879 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
880 }),
881 });
882
883 await flushAsyncWork(window, 8);
884 controller.detach();
885 await flushAsyncWork(window, 4);
886
887 const flattened = sentBatches.flat();
888 expect(flattened.map((entry) => entry.eventType)).toEqual(expect.arrayContaining([
889 'subtitle_png_requested',
890 'subtitle_png_sent',
891 'subtitle_png_received',
892 ]));
893
894 window.close();
895 });
896
897 test('logs prefetch subtitle lifecycle events', async () =>
898 {
899 const window = createWindow();
900 const helper = loadSharedVideoPlayer(window);
901 const { player, videojs } = buildPlayerHarness(window);
902 const sentBatches = [];
903
904 window.fetch = jest.fn(async () =>
905 {
906 return new Response(null, {
907 status: 204,
908 headers: {
909 'X-Subtitle-Frame-Status': 'none',
910 'X-Subtitle-Request-Received-At-Ms': '1000',
911 'X-Subtitle-Response-Sent-At-Ms': '1010',
912 'X-Subtitle-Frame-Start-Time': '2',
913 'X-Subtitle-Frame-End-Time': '3',
914 },
915 });
916 });
917
918 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
919 sessionId: 'sess-1',
920 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
921 }, {
922 lookaheadSeconds: 1,
923 sendSubtitleLogBatch: (entries) =>
924 {
925 sentBatches.push(entries);
926 return Promise.resolve();
927 },
928 buildFrameRequest: ({ currentTime, streamIndex }) => ({
929 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
930 }),
931 });
932
933 await flushAsyncWork(window, 8);
934 controller.detach();
935 await flushAsyncWork(window, 4);
936
937 const flattened = sentBatches.flat();
938 const prefetchEvents = flattened.filter((entry) => entry.requestKind === 'prefetch').map((entry) => entry.eventType);
939 expect(prefetchEvents).toEqual(expect.arrayContaining([
940 'subtitle_png_requested',
941 'subtitle_png_sent',
942 'subtitle_png_not_available',
943 ]));
944
945 window.close();
946 });
947
948 test('cache-only current mode avoids direct current subtitle fetch requests', async () =>
949 {
950 const window = createWindow();
951 const helper = loadSharedVideoPlayer(window);
952 const { player, videojs } = buildPlayerHarness(window);
953 const sentBatches = [];
954
955 player.setCurrentTime(8);
956 window.fetch = jest.fn(async () =>
957 {
958 return new Response(null, {
959 status: 204,
960 headers: {
961 'X-Subtitle-Frame-Status': 'none',
962 'X-Subtitle-Request-Received-At-Ms': '1000',
963 'X-Subtitle-Response-Sent-At-Ms': '1010',
964 },
965 });
966 });
967
968 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
969 sessionId: 'sess-1',
970 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
971 }, {
972 currentFetchEnabled: false,
973 cacheMissFallbackEnabled: false,
974 lookaheadSeconds: 0,
975 sendSubtitleLogBatch: (entries) =>
976 {
977 sentBatches.push(entries);
978 return Promise.resolve();
979 },
980 buildFrameRequest: ({ currentTime, streamIndex }) => ({
981 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
982 }),
983 });
984
985 await flushAsyncWork(window, 8);
986 controller.detach();
987 await flushAsyncWork(window, 4);
988
989 const flattened = sentBatches.flat();
990 expect(flattened.length).toBeGreaterThan(0);
991 const requestKinds = new Set(flattened.map((entry) => entry.requestKind).filter(Boolean));
992 expect(requestKinds.has('prefetch')).toBe(true);
993 expect(requestKinds.has('current')).toBe(false);
994
995 window.close();
996 });
997
998 test('cache-only mode falls back to throttled current fetch on cache miss', async () =>
999 {
1000 const window = createWindow();
1001 const helper = loadSharedVideoPlayer(window);
1002 const { player, videojs } = buildPlayerHarness(window);
1003
1004 let requestCount = 0;
1005 window.fetch = jest.fn(async () =>
1006 {
1007 requestCount += 1;
1008 if (requestCount === 1)
1009 {
1010 return new Response(new Uint8Array([137, 80, 78, 71]), {
1011 status: 200,
1012 headers: {
1013 'Content-Type': 'image/png',
1014 'X-Subtitle-Frame-Start-Time': '2.00',
1015 'X-Subtitle-Frame-End-Time': '2.50',
1016 'X-Subtitle-Frame-Width': '600',
1017 'X-Subtitle-Frame-Height': '72',
1018 'X-Subtitle-Frame-Canvas-Width': '1920',
1019 'X-Subtitle-Frame-Canvas-Height': '1080',
1020 },
1021 });
1022 }
1023
1024 return new Response(null, {
1025 status: 204,
1026 headers: { 'X-Subtitle-Frame-Status': 'none' },
1027 });
1028 });
1029
1030 player.setCurrentTime(2.2);
1031
1032 helper.bindImageSubtitleOverlay(player, videojs, {}, {
1033 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1034 }, {
1035 currentFetchEnabled: false,
1036 cacheMissFallbackIntervalMs: 2000,
1037 lookaheadSeconds: 0,
1038 initialPrefetchSeconds: 0,
1039 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1040 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1041 }),
1042 });
1043
1044 await flushAsyncWork(window, 10);
1045
1046 const overlay = player.el().querySelector('.video-subtitle-overlay');
1047 const overlayImg = overlay && overlay.querySelector('img');
1048 expect(window.fetch).toHaveBeenCalled();
1049 expect(overlay.style.display).toBe('block');
1050 expect(overlayImg.getAttribute('src')).toBe('blob:subtitle');
1051
1052 window.close();
1053 });
1054
1055 test('cache-miss fallback does not reset prefetch progress on repeated triggers', async () =>
1056 {
1057 const window = createWindow();
1058 const helper = loadSharedVideoPlayer(window);
1059 const { player, videojs } = buildPlayerHarness(window);
1060
1061 let nowMs = 1000;
1062 const realNow = window.Date.now;
1063 window.Date.now = () => nowMs;
1064
1065 let abortedCount = 0;
1066 window.fetch = jest.fn((url, init = {}) =>
1067 {
1068 return new Promise((resolve, reject) =>
1069 {
1070 const signal = init && init.signal;
1071 const onAbort = () =>
1072 {
1073 abortedCount += 1;
1074 const err = new Error('aborted');
1075 err.name = 'AbortError';
1076 reject(err);
1077 };
1078
1079 if (signal && typeof signal.addEventListener === 'function')
1080 {
1081 if (signal.aborted) return onAbort();
1082 signal.addEventListener('abort', onAbort, { once: true });
1083 }
1084
1085 window.setTimeout(() =>
1086 {
1087 if (signal && signal.aborted) return;
1088 resolve(new Response(null, {
1089 status: 204,
1090 headers: { 'X-Subtitle-Frame-Status': 'none' },
1091 }));
1092 }, 80);
1093 });
1094 });
1095
1096 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1097 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1098 }, {
1099 currentFetchEnabled: false,
1100 cacheMissFallbackIntervalMs: 20,
1101 lookaheadSeconds: 2,
1102 initialPrefetchSeconds: 0,
1103 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1104 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1105 }),
1106 });
1107
1108 await flushAsyncWork(window, 4);
1109
1110 player.setCurrentTime(5);
1111 player.trigger('timeupdate');
1112 nowMs += 40;
1113 player.setCurrentTime(5.5);
1114 player.trigger('timeupdate');
1115 nowMs += 40;
1116 player.setCurrentTime(6);
1117 player.trigger('timeupdate');
1118
1119 await flushAsyncWork(window, 12);
1120 expect(abortedCount).toBe(0);
1121
1122 window.Date.now = realNow;
1123 controller.detach();
1124 window.close();
1125 });
1126
1127 test('cache-only mode performs initial warmup prefetch window on load', async () =>
1128 {
1129 const window = createWindow();
1130 const helper = loadSharedVideoPlayer(window);
1131 const { player, videojs } = buildPlayerHarness(window);
1132 const requestedTimes = [];
1133
1134 window.fetch = jest.fn(async (url) =>
1135 {
1136 const parsed = new URL(url, 'http://localhost/');
1137 requestedTimes.push(Number(parsed.searchParams.get('timeSeconds')));
1138 return new Response(null, {
1139 status: 204,
1140 headers: {
1141 'X-Subtitle-Frame-Status': 'none',
1142 'X-Subtitle-Request-Received-At-Ms': '1000',
1143 'X-Subtitle-Response-Sent-At-Ms': '1010',
1144 },
1145 });
1146 });
1147
1148 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1149 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1150 }, {
1151 currentFetchEnabled: false,
1152 lookaheadSeconds: 0,
1153 initialPrefetchSeconds: 2,
1154 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1155 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1156 }),
1157 });
1158
1159 await flushAsyncWork(window, 12);
1160
1161 expect(requestedTimes).toEqual(expect.arrayContaining([0, 0.5, 1, 1.5, 2]));
1162
1163 controller.detach();
1164 await flushAsyncWork(window, 2);
1165 window.close();
1166 });
1167
1168 test('renders requested and received subtitle markers on the seek bar', async () =>
1169 {
1170 const window = createWindow();
1171 const helper = loadSharedVideoPlayer(window);
1172 const { player, videojs } = buildPlayerHarness(window);
1173
1174 window.fetch = jest.fn(async () =>
1175 {
1176 return new Response('png-data', {
1177 status: 200,
1178 headers: {
1179 'Content-Type': 'image/png',
1180 'X-Subtitle-Frame-Status': 'ok',
1181 'X-Subtitle-Request-Received-At-Ms': '1000',
1182 'X-Subtitle-Response-Sent-At-Ms': '1012',
1183 'X-Subtitle-Frame-Start-Time': '2.5',
1184 'X-Subtitle-Frame-End-Time': '3.5',
1185 'X-Subtitle-Frame-Width': '320',
1186 'X-Subtitle-Frame-Height': '180',
1187 'X-Subtitle-Frame-Canvas-Width': '640',
1188 'X-Subtitle-Frame-Canvas-Height': '360',
1189 },
1190 });
1191 });
1192
1193 player.duration(10);
1194 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1195 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1196 }, {
1197 lookaheadSeconds: 0,
1198 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1199 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1200 }),
1201 });
1202
1203 await flushAsyncWork(window, 8);
1204
1205 const requestedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-right');
1206 const receivedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-left');
1207 expect(requestedMarker).toBeTruthy();
1208 expect(receivedMarker).toBeTruthy();
1209 expect(requestedMarker.style.display).toBe('block');
1210 expect(receivedMarker.style.display).toBe('block');
1211 expect(requestedMarker.style.left).toBe('100.0000%');
1212 expect(receivedMarker.style.left).toBe('25.0000%');
1213 expect(requestedMarker.textContent).toBe(']');
1214 expect(receivedMarker.textContent).toBe('[');
1215
1216 controller.detach();
1217 await new Promise((resolve) => window.setTimeout(resolve, 300));
1218 await flushAsyncWork(window, 2);
1219
1220 window.close();
1221 });
1222
1223 test('advances both seek markers when subtitle request returns 204 without frame timing headers', async () =>
1224 {
1225 const window = createWindow();
1226 const helper = loadSharedVideoPlayer(window);
1227 const { player, videojs } = buildPlayerHarness(window);
1228
1229 player.duration(10);
1230 player.setCurrentTime(4);
1231 window.fetch = jest.fn(async () =>
1232 {
1233 return new Response(null, {
1234 status: 204,
1235 headers: {
1236 'X-Subtitle-Frame-Status': 'none',
1237 'X-Subtitle-Request-Received-At-Ms': '1000',
1238 'X-Subtitle-Response-Sent-At-Ms': '1010',
1239 },
1240 });
1241 });
1242
1243 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1244 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1245 }, {
1246 lookaheadSeconds: 0,
1247 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1248 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1249 }),
1250 });
1251
1252 await flushAsyncWork(window, 8);
1253
1254 const requestedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-right');
1255 const receivedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-left');
1256 expect(requestedMarker).toBeTruthy();
1257 expect(receivedMarker).toBeTruthy();
1258 expect(requestedMarker.style.display).toBe('block');
1259 expect(receivedMarker.style.display).toBe('block');
1260 expect(requestedMarker.style.left).toBe('100.0000%');
1261 expect(receivedMarker.style.left).toBe('100.0000%');
1262 expect(requestedMarker.textContent).toBe(']');
1263 expect(receivedMarker.textContent).toBe('[');
1264
1265 controller.detach();
1266 await flushAsyncWork(window, 2);
1267 window.close();
1268 });
1269
1270 test('advances seek markers to the end of an empty prefetch tail window', async () =>
1271 {
1272 const window = createWindow();
1273 const helper = loadSharedVideoPlayer(window);
1274 const { player, videojs } = buildPlayerHarness(window);
1275
1276 player.duration(120);
1277 player.setCurrentTime(110);
1278
1279 window.fetch = jest.fn(async () =>
1280 {
1281 return new Response(null, {
1282 status: 204,
1283 headers: {
1284 'X-Subtitle-Frame-Status': 'none',
1285 'X-Subtitle-Request-Received-At-Ms': '1000',
1286 'X-Subtitle-Response-Sent-At-Ms': '1010',
1287 },
1288 });
1289 });
1290
1291 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1292 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1293 }, {
1294 lookaheadSeconds: 0,
1295 initialPrefetchSeconds: 0,
1296 currentFetchEnabled: false,
1297 cacheMissFallbackEnabled: false,
1298 prefetchAdaptiveStepEnabled: true,
1299 prefetchStepSecondsMin: 10,
1300 prefetchStepSecondsMax: 10,
1301 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1302 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1303 }),
1304 buildPrefetchRequest: ({ currentTime, endTime, streamIndex }) => ({
1305 url: `/subtitle-range?streamIndex=${streamIndex}&startTimeSeconds=${currentTime}&endTimeSeconds=${endTime}`,
1306 }),
1307 });
1308
1309 player.trigger('timeupdate');
1310 await flushAsyncWork(window, 8);
1311
1312 const requestedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-right');
1313 const receivedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-left');
1314 expect(requestedMarker).toBeTruthy();
1315 expect(receivedMarker).toBeTruthy();
1316 expect(requestedMarker.style.left).toBe('100.0000%');
1317 expect(receivedMarker.style.left).toBe('100.0000%');
1318
1319 controller.detach();
1320 await flushAsyncWork(window, 2);
1321 window.close();
1322 });
1323
1324 test('keeps existing marker positions while the next request is still in flight', async () =>
1325 {
1326 const window = createWindow();
1327 const helper = loadSharedVideoPlayer(window);
1328 const { player, videojs } = buildPlayerHarness(window);
1329 let pendingResolve = null;
1330
1331 player.duration(10);
1332 window.fetch = jest.fn((url) =>
1333 {
1334 const parsed = new URL(url, 'http://localhost/');
1335 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
1336
1337 if (timeSeconds === 0)
1338 {
1339 return Promise.resolve(new Response('png-data', {
1340 status: 200,
1341 headers: {
1342 'Content-Type': 'image/png',
1343 'X-Subtitle-Frame-Status': 'ok',
1344 'X-Subtitle-Frame-Start-Time': '2',
1345 'X-Subtitle-Frame-End-Time': '3',
1346 'X-Subtitle-Frame-Width': '320',
1347 'X-Subtitle-Frame-Height': '180',
1348 'X-Subtitle-Frame-Canvas-Width': '640',
1349 'X-Subtitle-Frame-Canvas-Height': '360',
1350 },
1351 }));
1352 }
1353
1354 return new Promise((resolve) =>
1355 {
1356 pendingResolve = resolve;
1357 });
1358 });
1359
1360 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1361 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1362 }, {
1363 lookaheadSeconds: 0,
1364 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1365 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1366 }),
1367 });
1368
1369 await flushAsyncWork(window, 8);
1370
1371 const requestedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-right');
1372 const receivedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-left');
1373 expect(requestedMarker).toBeTruthy();
1374 expect(receivedMarker).toBeTruthy();
1375 expect(requestedMarker.style.left).toBe('0.0000%');
1376 expect(receivedMarker.style.left).toBe('20.0000%');
1377
1378 player.setCurrentTime(1.5);
1379 player.trigger('timeupdate');
1380 await flushAsyncWork(window, 2);
1381
1382 expect(requestedMarker.style.left).toBe('0.0000%');
1383 expect(receivedMarker.style.left).toBe('20.0000%');
1384
1385 pendingResolve(new Response(null, {
1386 status: 204,
1387 headers: {
1388 'X-Subtitle-Frame-Status': 'none',
1389 },
1390 }));
1391
1392 await flushAsyncWork(window, 8);
1393 expect(requestedMarker.style.display).toBe('block');
1394 expect(receivedMarker.style.display).toBe('block');
1395 expect(requestedMarker.style.left).toBe('15.0000%');
1396 expect(receivedMarker.style.left).toBe('20.0000%');
1397
1398 controller.detach();
1399 await flushAsyncWork(window, 2);
1400 window.close();
1401 });
1402
1403 test('keeps marker positions forward-only when later responses resolve with earlier times', async () =>
1404 {
1405 const window = createWindow();
1406 const helper = loadSharedVideoPlayer(window);
1407 const { player, videojs } = buildPlayerHarness(window);
1408 const requestedTimes = [];
1409
1410 player.duration(12);
1411 window.fetch = jest.fn(async (url) =>
1412 {
1413 const parsed = new URL(url, 'http://localhost/');
1414 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
1415 requestedTimes.push(timeSeconds);
1416
1417 if (requestedTimes.length === 1)
1418 {
1419 return new Response('png-data', {
1420 status: 200,
1421 headers: {
1422 'Content-Type': 'image/png',
1423 'X-Subtitle-Frame-Status': 'ok',
1424 'X-Subtitle-Frame-Start-Time': '4',
1425 'X-Subtitle-Frame-End-Time': '5',
1426 'X-Subtitle-Frame-Width': '320',
1427 'X-Subtitle-Frame-Height': '180',
1428 'X-Subtitle-Frame-Canvas-Width': '640',
1429 'X-Subtitle-Frame-Canvas-Height': '360',
1430 },
1431 });
1432 }
1433
1434 return new Response('png-data', {
1435 status: 200,
1436 headers: {
1437 'Content-Type': 'image/png',
1438 'X-Subtitle-Frame-Status': 'ok',
1439 'X-Subtitle-Frame-Start-Time': '2',
1440 'X-Subtitle-Frame-End-Time': '3',
1441 'X-Subtitle-Frame-Width': '320',
1442 'X-Subtitle-Frame-Height': '180',
1443 'X-Subtitle-Frame-Canvas-Width': '640',
1444 'X-Subtitle-Frame-Canvas-Height': '360',
1445 },
1446 });
1447 });
1448
1449 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1450 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1451 }, {
1452 lookaheadSeconds: 0,
1453 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1454 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1455 }),
1456 });
1457
1458 await flushAsyncWork(window, 8);
1459
1460 const requestedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-right');
1461 const receivedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-left');
1462 expect(requestedMarker).toBeTruthy();
1463 expect(receivedMarker).toBeTruthy();
1464 expect(requestedMarker.style.left).toBe('100.0000%');
1465 expect(receivedMarker.style.left).toBe('33.3333%');
1466
1467 player.setCurrentTime(1.5);
1468 player.trigger('timeupdate');
1469 await flushAsyncWork(window, 8);
1470
1471 // Second response reports an older start time, but markers stay monotonic.
1472 expect(requestedMarker.style.left).toBe('100.0000%');
1473 expect(receivedMarker.style.left).toBe('33.3333%');
1474
1475 controller.detach();
1476 await flushAsyncWork(window, 2);
1477 window.close();
1478 });
1479
1480 test('continues current subtitle refreshes after a force-seek aborts the in-flight request', async () =>
1481 {
1482 const window = createWindow();
1483 const helper = loadSharedVideoPlayer(window);
1484 const { player, videojs } = buildPlayerHarness(window);
1485 const requestedTimes = [];
1486
1487 window.fetch = jest.fn((url, init = {}) =>
1488 {
1489 const parsed = new URL(url, 'http://localhost/');
1490 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
1491 requestedTimes.push(timeSeconds);
1492
1493 if (requestedTimes.length === 1)
1494 {
1495 return new Promise((resolve, reject) =>
1496 {
1497 if (init.signal && typeof init.signal.addEventListener === 'function')
1498 {
1499 init.signal.addEventListener('abort', () =>
1500 {
1501 reject(new window.DOMException('Aborted', 'AbortError'));
1502 }, { once: true });
1503 }
1504 });
1505 }
1506
1507 return Promise.resolve(new Response(null, {
1508 status: 204,
1509 headers: {
1510 'X-Subtitle-Frame-Status': 'none',
1511 },
1512 }));
1513 });
1514
1515 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1516 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1517 }, {
1518 lookaheadSeconds: 0,
1519 currentRequestTimeoutMs: 300,
1520 logToConsole: false,
1521 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1522 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1523 }),
1524 });
1525
1526 await flushAsyncWork(window, 4);
1527 const afterInitialLoadCalls = window.fetch.mock.calls.length;
1528 expect(afterInitialLoadCalls).toBeGreaterThan(0);
1529
1530 player.setCurrentTime(5);
1531 player.trigger('seeking');
1532 await flushAsyncWork(window, 20);
1533
1534 expect(window.fetch.mock.calls.length).toBeGreaterThanOrEqual(2);
1535 expect(requestedTimes).toEqual(expect.arrayContaining([0, 5]));
1536
1537 controller.detach();
1538 await flushAsyncWork(window, 2);
1539 window.close();
1540 });
1541
1542 test('recovers when a current subtitle request hangs and times out', async () =>
1543 {
1544 const window = createWindow();
1545 const helper = loadSharedVideoPlayer(window);
1546 const { player, videojs } = buildPlayerHarness(window);
1547 const requestedTimes = [];
1548
1549 window.fetch = jest.fn((url, init = {}) =>
1550 {
1551 const parsed = new URL(url, 'http://localhost/');
1552 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
1553 requestedTimes.push(timeSeconds);
1554
1555 if (requestedTimes.length === 1)
1556 {
1557 return new Promise((resolve, reject) =>
1558 {
1559 if (init.signal && typeof init.signal.addEventListener === 'function')
1560 {
1561 init.signal.addEventListener('abort', () =>
1562 {
1563 reject(new window.DOMException('Aborted', 'AbortError'));
1564 }, { once: true });
1565 }
1566 });
1567 }
1568
1569 return Promise.resolve(new Response(null, {
1570 status: 204,
1571 headers: { 'X-Subtitle-Frame-Status': 'none' },
1572 }));
1573 });
1574
1575 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1576 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1577 }, {
1578 lookaheadSeconds: 0,
1579 currentRequestTimeoutMs: 250,
1580 logToConsole: false,
1581 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1582 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1583 }),
1584 });
1585
1586 await flushAsyncWork(window, 3);
1587
1588 player.setCurrentTime(1.5);
1589 player.trigger('timeupdate');
1590
1591 await new Promise((resolve) => window.setTimeout(resolve, 320));
1592 player.trigger('timeupdate');
1593 await new Promise((resolve) => window.setTimeout(resolve, 220));
1594 await flushAsyncWork(window, 20);
1595
1596 expect(window.fetch.mock.calls.length).toBeGreaterThanOrEqual(2);
1597 expect(requestedTimes).toEqual(expect.arrayContaining([0, 1.5]));
1598
1599 controller.detach();
1600 await new Promise((resolve) => window.setTimeout(resolve, 200));
1601 await flushAsyncWork(window, 20);
1602 window.close();
1603 });
1604
1605 test('reuses cached subtitle frames after rewinding when server no longer has older frames', async () =>
1606 {
1607 const window = createWindow();
1608 const helper = loadSharedVideoPlayer(window);
1609 const { player, videojs } = buildPlayerHarness(window);
1610
1611 player.duration(10);
1612 player.setCurrentTime(2);
1613 window.fetch = jest.fn(async (url) =>
1614 {
1615 const parsed = new URL(url, 'http://localhost/');
1616 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
1617
1618 if (Math.abs(timeSeconds - 2) < 1e-6)
1619 {
1620 return new Response('png-data', {
1621 status: 200,
1622 headers: {
1623 'Content-Type': 'image/png',
1624 'X-Subtitle-Frame-Status': 'ok',
1625 'X-Subtitle-Frame-Start-Time': '2',
1626 'X-Subtitle-Frame-End-Time': '3',
1627 'X-Subtitle-Frame-Width': '320',
1628 'X-Subtitle-Frame-Height': '180',
1629 'X-Subtitle-Frame-Canvas-Width': '640',
1630 'X-Subtitle-Frame-Canvas-Height': '360',
1631 },
1632 });
1633 }
1634
1635 return new Response(null, {
1636 status: 204,
1637 headers: {
1638 'X-Subtitle-Frame-Status': 'none',
1639 },
1640 });
1641 });
1642
1643 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1644 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1645 }, {
1646 lookaheadSeconds: 0,
1647 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1648 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1649 }),
1650 });
1651
1652 await flushAsyncWork(window, 8);
1653 const afterInitialLoadCalls = window.fetch.mock.calls.length;
1654 expect(afterInitialLoadCalls).toBeGreaterThan(0);
1655
1656 player.setCurrentTime(4);
1657 player.trigger('timeupdate');
1658 await flushAsyncWork(window, 8);
1659 const afterForwardSeekCalls = window.fetch.mock.calls.length;
1660 expect(afterForwardSeekCalls).toBeGreaterThanOrEqual(afterInitialLoadCalls);
1661
1662 const overlay = player.el().querySelector('.video-subtitle-overlay');
1663 expect(overlay).toBeTruthy();
1664 expect(overlay.style.display).toBe('none');
1665
1666 player.setCurrentTime(2.5);
1667 player.trigger('timeupdate');
1668 await flushAsyncWork(window, 8);
1669
1670 expect(window.fetch.mock.calls.length).toBe(afterForwardSeekCalls);
1671 expect(overlay.style.display).toBe('block');
1672
1673 controller.detach();
1674 await flushAsyncWork(window, 2);
1675 window.close();
1676 });
1677
1678 test('registers stream cache service worker once when supported', async () =>
1679 {
1680 const window = createWindow();
1681 const helper = loadSharedVideoPlayer(window);
1682 const register = jest.fn(async () => ({}));
1683 window.navigator.serviceWorker = { register };
1684
1685 const first = await helper.enableVideoStreamClientCache();
1686 const second = await helper.enableVideoStreamClientCache();
1687
1688 expect(first).toBe(true);
1689 expect(second).toBe(true);
1690 expect(register).toHaveBeenCalledTimes(1);
1691 expect(register).toHaveBeenCalledWith('/stream-cache-sw.js', {
1692 scope: '/',
1693 updateViaCache: 'none',
1694 });
1695
1696 window.close();
1697 });
1698
1699 test('stream-ahead prefetch follows playlists and fetches segment assets', async () =>
1700 {
1701 const window = createWindow();
1702 const helper = loadSharedVideoPlayer(window);
1703 const requestedUrls = [];
1704
1705 window.fetch = jest.fn(async (input) =>
1706 {
1707 const url = String(input && input.url ? input.url : input);
1708 requestedUrls.push(url);
1709
1710 if (url === 'http://localhost/master.m3u8')
1711 {
1712 return new Response('#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=100000\nstream_0.m3u8\n#EXT-X-ENDLIST\n', {
1713 status: 200,
1714 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1715 });
1716 }
1717
1718 if (url === 'http://localhost/stream_0.m3u8')
1719 {
1720 return new Response('#EXTM3U\n#EXTINF:4,\nseg0.ts\n#EXTINF:4,\nseg1.ts\n#EXT-X-ENDLIST\n', {
1721 status: 200,
1722 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1723 });
1724 }
1725
1726 if (url === 'http://localhost/seg0.ts' || url === 'http://localhost/seg1.ts')
1727 {
1728 return new Response(new Uint8Array([1, 2, 3, 4]), {
1729 status: 200,
1730 headers: { 'Content-Type': 'video/mp2t' },
1731 });
1732 }
1733
1734 return new Response(null, { status: 404 });
1735 });
1736
1737 const controller = helper.bindStreamAheadPrefetch({
1738 playlistUrl: 'http://localhost/master.m3u8',
1739 pollIntervalMs: 0,
1740 credentials: 'same-origin',
1741 });
1742
1743 expect(controller).toBeTruthy();
1744 await controller.done();
1745
1746 expect(requestedUrls).toEqual(expect.arrayContaining([
1747 'http://localhost/master.m3u8',
1748 'http://localhost/stream_0.m3u8',
1749 'http://localhost/seg0.ts',
1750 'http://localhost/seg1.ts',
1751 ]));
1752
1753 controller.stop();
1754 window.close();
1755 });
1756
1757 test('stream-ahead prefetch reports cached-through progress for fetched segments', async () =>
1758 {
1759 const window = createWindow();
1760 const helper = loadSharedVideoPlayer(window);
1761 const progressSamples = [];
1762
1763 window.fetch = jest.fn(async (input) =>
1764 {
1765 const url = String(input && input.url ? input.url : input);
1766
1767 if (url === 'http://localhost/master.m3u8')
1768 {
1769 return new Response('#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=100000\nstream_0.m3u8\n#EXT-X-ENDLIST\n', {
1770 status: 200,
1771 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1772 });
1773 }
1774
1775 if (url === 'http://localhost/stream_0.m3u8')
1776 {
1777 return new Response('#EXTM3U\n#EXTINF:4,\nseg0.ts\n#EXTINF:4,\nseg1.ts\n#EXT-X-ENDLIST\n', {
1778 status: 200,
1779 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1780 });
1781 }
1782
1783 if (url === 'http://localhost/seg0.ts' || url === 'http://localhost/seg1.ts')
1784 {
1785 return new Response(new Uint8Array([1, 2, 3, 4]), {
1786 status: 200,
1787 headers: { 'Content-Type': 'video/mp2t' },
1788 });
1789 }
1790
1791 return new Response(null, { status: 404 });
1792 });
1793
1794 const controller = helper.bindStreamAheadPrefetch({
1795 playlistUrl: 'http://localhost/master.m3u8',
1796 pollIntervalMs: 0,
1797 credentials: 'same-origin',
1798 });
1799
1800 expect(controller).toBeTruthy();
1801 const unsubscribe = controller.subscribe((status) =>
1802 {
1803 progressSamples.push(status && status.cachedThroughSeconds);
1804 });
1805
1806 await controller.done();
1807 unsubscribe();
1808
1809 expect(progressSamples.some((value) => Number.isFinite(value) && value >= 8)).toBe(true);
1810
1811 controller.stop();
1812 window.close();
1813 });
1814
1815 test('stream-ahead prefetch infers cached-through progress from segment filenames', async () =>
1816 {
1817 const window = createWindow();
1818 const helper = loadSharedVideoPlayer(window);
1819 const progressSamples = [];
1820
1821 window.fetch = jest.fn(async (input) =>
1822 {
1823 const url = String(input && input.url ? input.url : input);
1824
1825 if (url === 'http://localhost/master.m3u8')
1826 {
1827 return new Response('#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=100000\nstream_0.m3u8\n#EXT-X-ENDLIST\n', {
1828 status: 200,
1829 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1830 });
1831 }
1832
1833 if (url === 'http://localhost/stream_0.m3u8')
1834 {
1835 return new Response('#EXTM3U\nstream_0_segment_000000.ts\nstream_0_segment_000001.ts\n#EXT-X-ENDLIST\n', {
1836 status: 200,
1837 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1838 });
1839 }
1840
1841 if (url === 'http://localhost/stream_0_segment_000000.ts' || url === 'http://localhost/stream_0_segment_000001.ts')
1842 {
1843 return new Response(new Uint8Array([1, 2, 3, 4]), {
1844 status: 200,
1845 headers: { 'Content-Type': 'video/mp2t' },
1846 });
1847 }
1848
1849 return new Response(null, { status: 404 });
1850 });
1851
1852 const controller = helper.bindStreamAheadPrefetch({
1853 playlistUrl: 'http://localhost/master.m3u8',
1854 pollIntervalMs: 0,
1855 credentials: 'same-origin',
1856 });
1857
1858 expect(controller).toBeTruthy();
1859 const unsubscribe = controller.subscribe((status) =>
1860 {
1861 progressSamples.push(status && status.cachedThroughSeconds);
1862 });
1863
1864 await controller.done();
1865 unsubscribe();
1866
1867 expect(progressSamples.some((value) => Number.isFinite(value) && value >= 8)).toBe(true);
1868
1869 controller.stop();
1870 window.close();
1871 });
1872
1873 test('stream-ahead prefetch infers cached-through progress for m4s segment filenames', async () =>
1874 {
1875 const window = createWindow();
1876 const helper = loadSharedVideoPlayer(window);
1877 const progressSamples = [];
1878
1879 window.fetch = jest.fn(async (input) =>
1880 {
1881 const url = String(input && input.url ? input.url : input);
1882
1883 if (url === 'http://localhost/master.m3u8')
1884 {
1885 return new Response('#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=100000\nstream_0.m3u8\n#EXT-X-ENDLIST\n', {
1886 status: 200,
1887 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1888 });
1889 }
1890
1891 if (url === 'http://localhost/stream_0.m3u8')
1892 {
1893 return new Response('#EXTM3U\nstream_0_segment_000000.m4s\nstream_0_segment_000001.m4s\n#EXT-X-ENDLIST\n', {
1894 status: 200,
1895 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1896 });
1897 }
1898
1899 if (url === 'http://localhost/stream_0_segment_000000.m4s' || url === 'http://localhost/stream_0_segment_000001.m4s')
1900 {
1901 return new Response(new Uint8Array([1, 2, 3, 4]), {
1902 status: 200,
1903 headers: { 'Content-Type': 'video/mp4' },
1904 });
1905 }
1906
1907 return new Response(null, { status: 404 });
1908 });
1909
1910 const controller = helper.bindStreamAheadPrefetch({
1911 playlistUrl: 'http://localhost/master.m3u8',
1912 pollIntervalMs: 0,
1913 credentials: 'same-origin',
1914 });
1915
1916 expect(controller).toBeTruthy();
1917 const unsubscribe = controller.subscribe((status) =>
1918 {
1919 progressSamples.push(status && status.cachedThroughSeconds);
1920 });
1921
1922 await controller.done();
1923 unsubscribe();
1924
1925 expect(progressSamples.some((value) => Number.isFinite(value) && value >= 8)).toBe(true);
1926
1927 controller.stop();
1928 window.close();
1929 });
1930
1931 test('stream-ahead prefetch reports ratio progress from fetched sections when timing is unknown', async () =>
1932 {
1933 const window = createWindow();
1934 const helper = loadSharedVideoPlayer(window);
1935 const statusSamples = [];
1936
1937 window.fetch = jest.fn(async (input) =>
1938 {
1939 const url = String(input && input.url ? input.url : input);
1940
1941 if (url === 'http://localhost/master.m3u8')
1942 {
1943 return new Response('#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=100000\nstream_0.m3u8\n#EXT-X-ENDLIST\n', {
1944 status: 200,
1945 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1946 });
1947 }
1948
1949 if (url === 'http://localhost/stream_0.m3u8')
1950 {
1951 return new Response('#EXTM3U\nchunk-alpha.bin\nchunk-beta.bin\n#EXT-X-ENDLIST\n', {
1952 status: 200,
1953 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1954 });
1955 }
1956
1957 if (url === 'http://localhost/chunk-alpha.bin' || url === 'http://localhost/chunk-beta.bin')
1958 {
1959 return new Response(new Uint8Array([1, 2, 3, 4]), {
1960 status: 200,
1961 headers: { 'Content-Type': 'application/octet-stream' },
1962 });
1963 }
1964
1965 return new Response(null, { status: 404 });
1966 });
1967
1968 const controller = helper.bindStreamAheadPrefetch({
1969 playlistUrl: 'http://localhost/master.m3u8',
1970 pollIntervalMs: 0,
1971 credentials: 'same-origin',
1972 });
1973
1974 expect(controller).toBeTruthy();
1975 const unsubscribe = controller.subscribe((status) =>
1976 {
1977 statusSamples.push(status || {});
1978 });
1979
1980 await controller.done();
1981 unsubscribe();
1982
1983 const finalStatus = statusSamples[statusSamples.length - 1] || {};
1984 expect(finalStatus.totalSegmentCount).toBe(2);
1985 expect(finalStatus.fetchedSegmentCount).toBe(2);
1986 expect(finalStatus.cachedThroughRatio).toBe(1);
1987
1988 controller.stop();
1989 window.close();
1990 });
1991
1992 test('clears cached stream assets for a finished playlist session', async () =>
1993 {
1994 const window = createWindow();
1995 const helper = loadSharedVideoPlayer(window);
1996 const requests = [
1997 new window.Request('http://localhost/api/files/video-stream/sess-a/master.m3u8'),
1998 new window.Request('http://localhost/api/files/video-stream/sess-a/stream_0_segment_000001.ts'),
1999 new window.Request('http://localhost/api/files/video-stream/sess-b/master.m3u8'),
2000 ];
2001 const deleteCalls = [];
2002 const cache = {
2003 keys: jest.fn(async () => requests),
2004 delete: jest.fn(async (request) =>
2005 {
2006 deleteCalls.push(request.url);
2007 return true;
2008 }),
2009 };
2010 window.caches = {
2011 open: jest.fn(async () => cache),
2012 };
2013
2014 await helper.clearVideoStreamClientCache('http://localhost/api/files/video-stream/sess-a/master.m3u8');
2015
2016 expect(window.caches.open).toHaveBeenCalledWith('filemanager-stream-cache-v1');
2017 expect(cache.keys).toHaveBeenCalledTimes(1);
2018 expect(deleteCalls).toEqual(expect.arrayContaining([
2019 'http://localhost/api/files/video-stream/sess-a/master.m3u8',
2020 'http://localhost/api/files/video-stream/sess-a/stream_0_segment_000001.ts',
2021 ]));
2022 expect(deleteCalls).not.toContain('http://localhost/api/files/video-stream/sess-b/master.m3u8');
2023
2024 window.close();
2025 });
2026});