BlueGit

timfa filemanager

Files

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

shared-video-player.test.js

2268f152 History
shared-video-player.test.js 43.7 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('prefetches at least through the buffered video end', async () =>
231 {
232 const window = createWindow();
233 const helper = loadSharedVideoPlayer(window);
234 const { player, videojs } = buildPlayerHarness(window);
235 const requestedTimes = [];
236
237 player.setBufferedEnd(3);
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 buildFrameRequest: ({ currentTime, streamIndex }) => ({
254 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
255 }),
256 });
257
258 await flushAsyncWork(window, 12);
259
260 expect(requestedTimes).toEqual(expect.arrayContaining([0, 0.5, 1, 1.5, 2, 2.5, 3]));
261
262 window.close();
263 });
264
265 test('prefetch uses furthest buffered end when player.bufferedEnd under-reports', async () =>
266 {
267 const window = createWindow();
268 const helper = loadSharedVideoPlayer(window);
269 const { player, videojs } = buildPlayerHarness(window);
270 const requestedTimes = [];
271
272 player.setBufferedEnd(0);
273 player.tech = () => ({
274 el: () => ({
275 buffered: {
276 length: 1,
277 end: () => 6,
278 },
279 }),
280 });
281
282 window.fetch = jest.fn(async (url) =>
283 {
284 const parsed = new URL(url, 'http://localhost/');
285 requestedTimes.push(Number(parsed.searchParams.get('timeSeconds')));
286 return new Response(null, {
287 status: 204,
288 headers: { 'X-Subtitle-Frame-Status': 'none' },
289 });
290 });
291
292 helper.bindImageSubtitleOverlay(player, videojs, {}, {
293 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
294 }, {
295 lookaheadSeconds: 0,
296 buildFrameRequest: ({ currentTime, streamIndex }) => ({
297 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
298 }),
299 });
300
301 await flushAsyncWork(window, 16);
302
303 expect(requestedTimes).toEqual(expect.arrayContaining([0, 0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5, 5.5, 6]));
304
305 window.close();
306 });
307
308 test('prefetch frontier jumps to current playback time instead of replaying stale lag', async () =>
309 {
310 const window = createWindow();
311 const helper = loadSharedVideoPlayer(window);
312 const { player, videojs } = buildPlayerHarness(window);
313 const requestedTimes = [];
314
315 player.setBufferedEnd(35);
316
317 window.fetch = jest.fn(async (url) =>
318 {
319 const parsed = new URL(url, 'http://localhost/');
320 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
321 requestedTimes.push(timeSeconds);
322 return new Response(null, {
323 status: 204,
324 headers: { 'X-Subtitle-Frame-Status': 'none' },
325 });
326 });
327
328 helper.bindImageSubtitleOverlay(player, videojs, {}, {
329 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
330 }, {
331 lookaheadSeconds: 0,
332 buildFrameRequest: ({ currentTime, streamIndex }) => ({
333 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
334 }),
335 });
336
337 await flushAsyncWork(window, 8);
338 expect(requestedTimes).toEqual(expect.arrayContaining([0, 0.5]));
339
340 requestedTimes.length = 0;
341 player.setCurrentTime(20);
342 player.setBufferedEnd(40);
343 player.trigger('timeupdate');
344 await flushAsyncWork(window, 8);
345
346 expect(requestedTimes).toContain(20);
347 const prefetchAfterJump = requestedTimes.filter((value) => value > 20);
348 expect(prefetchAfterJump.length).toBeGreaterThan(0);
349 expect(Math.min(...prefetchAfterJump)).toBeGreaterThanOrEqual(20.5);
350
351 window.close();
352 });
353
354 test('does not restart current subtitle request while one is in flight', async () =>
355 {
356 const window = createWindow();
357 const helper = loadSharedVideoPlayer(window);
358 const { player, videojs } = buildPlayerHarness(window);
359 const pendingResolvers = [];
360 const requestTimes = [];
361
362 window.fetch = jest.fn((url, init = {}) =>
363 {
364 const parsed = new URL(url, 'http://localhost/');
365 requestTimes.push(Number(parsed.searchParams.get('timeSeconds')));
366
367 if (pendingResolvers.length === 0)
368 {
369 return new Promise((resolve) =>
370 {
371 pendingResolvers.push(() => resolve(new Response(null, {
372 status: 204,
373 headers: { 'X-Subtitle-Frame-Status': 'none' },
374 })));
375 });
376 }
377
378 expect(init.signal && init.signal.aborted).toBe(false);
379 return Promise.resolve(new Response(null, {
380 status: 204,
381 headers: { 'X-Subtitle-Frame-Status': 'none' },
382 }));
383 });
384
385 helper.bindImageSubtitleOverlay(player, videojs, {}, {
386 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
387 }, {
388 lookaheadSeconds: 0,
389 buildFrameRequest: ({ currentTime, streamIndex }) => ({
390 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
391 }),
392 });
393
394 await flushAsyncWork(window, 3);
395 expect(window.fetch).toHaveBeenCalledTimes(1);
396
397 player.setCurrentTime(1.5);
398 player.trigger('timeupdate');
399 player.setCurrentTime(2.25);
400 player.trigger('timeupdate');
401 await flushAsyncWork(window, 2);
402
403 expect(window.fetch).toHaveBeenCalledTimes(1);
404
405 pendingResolvers[0]();
406 await flushAsyncWork(window, 5);
407
408 expect(window.fetch.mock.calls.length).toBeGreaterThanOrEqual(2);
409 expect(requestTimes).toEqual(expect.arrayContaining([0, 2.25]));
410
411 window.close();
412 });
413
414 test('aborts in-flight prefetch requests when the overlay is detached', async () =>
415 {
416 const window = createWindow();
417 const helper = loadSharedVideoPlayer(window);
418 const { player, videojs } = buildPlayerHarness(window);
419 const activeSignals = [];
420
421 window.fetch = jest.fn((url, init = {}) =>
422 {
423 const parsed = new URL(url, 'http://localhost/');
424 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
425
426 if (timeSeconds === 0)
427 {
428 return Promise.resolve(new Response(null, {
429 status: 204,
430 headers: { 'X-Subtitle-Frame-Status': 'none' },
431 }));
432 }
433
434 activeSignals.push(init.signal || null);
435
436 return new Promise((resolve, reject) =>
437 {
438 if (init.signal && typeof init.signal.addEventListener === 'function')
439 {
440 init.signal.addEventListener('abort', () =>
441 {
442 reject(new DOMException('Aborted', 'AbortError'));
443 }, { once: true });
444 }
445 });
446 });
447
448 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
449 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
450 }, {
451 lookaheadSeconds: 1,
452 buildFrameRequest: ({ currentTime, streamIndex }) => ({
453 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
454 }),
455 });
456
457 await flushAsyncWork(window, 3);
458 expect(activeSignals.length).toBeGreaterThan(0);
459
460 controller.detach();
461 await flushAsyncWork(window, 2);
462
463 expect(activeSignals.every(signal => signal && signal.aborted)).toBe(true);
464
465 window.close();
466 });
467
468 test('logs current subtitle request lifecycle events and flushes them on detach', async () =>
469 {
470 const window = createWindow();
471 const helper = loadSharedVideoPlayer(window);
472 const { player, videojs } = buildPlayerHarness(window);
473 const sentBatches = [];
474
475 window.fetch = jest.fn(async () =>
476 {
477 return new Response('png-data', {
478 status: 200,
479 headers: {
480 'Content-Type': 'image/png',
481 'X-Subtitle-Frame-Status': 'ok',
482 'X-Subtitle-Request-Received-At-Ms': '1000',
483 'X-Subtitle-Response-Sent-At-Ms': '1012',
484 'X-Subtitle-Frame-Start-Time': '1.5',
485 'X-Subtitle-Frame-End-Time': '3.2',
486 'X-Subtitle-Frame-Width': '320',
487 'X-Subtitle-Frame-Height': '180',
488 'X-Subtitle-Frame-Canvas-Width': '640',
489 'X-Subtitle-Frame-Canvas-Height': '360',
490 },
491 });
492 });
493
494 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
495 sessionId: 'sess-1',
496 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
497 }, {
498 lookaheadSeconds: 0,
499 sendSubtitleLogBatch: (entries) =>
500 {
501 sentBatches.push(entries);
502 return Promise.resolve();
503 },
504 buildFrameRequest: ({ currentTime, streamIndex }) => ({
505 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
506 }),
507 });
508
509 await flushAsyncWork(window, 8);
510 controller.detach();
511 await flushAsyncWork(window, 4);
512
513 const flattened = sentBatches.flat();
514 expect(flattened.map((entry) => entry.eventType)).toEqual(expect.arrayContaining([
515 'subtitle_png_requested',
516 'subtitle_png_sent',
517 'subtitle_png_received',
518 ]));
519
520 window.close();
521 });
522
523 test('logs prefetch subtitle lifecycle events', async () =>
524 {
525 const window = createWindow();
526 const helper = loadSharedVideoPlayer(window);
527 const { player, videojs } = buildPlayerHarness(window);
528 const sentBatches = [];
529
530 window.fetch = jest.fn(async () =>
531 {
532 return new Response(null, {
533 status: 204,
534 headers: {
535 'X-Subtitle-Frame-Status': 'none',
536 'X-Subtitle-Request-Received-At-Ms': '1000',
537 'X-Subtitle-Response-Sent-At-Ms': '1010',
538 'X-Subtitle-Frame-Start-Time': '2',
539 'X-Subtitle-Frame-End-Time': '3',
540 },
541 });
542 });
543
544 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
545 sessionId: 'sess-1',
546 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
547 }, {
548 lookaheadSeconds: 1,
549 sendSubtitleLogBatch: (entries) =>
550 {
551 sentBatches.push(entries);
552 return Promise.resolve();
553 },
554 buildFrameRequest: ({ currentTime, streamIndex }) => ({
555 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
556 }),
557 });
558
559 await flushAsyncWork(window, 8);
560 controller.detach();
561 await flushAsyncWork(window, 4);
562
563 const flattened = sentBatches.flat();
564 const prefetchEvents = flattened.filter((entry) => entry.requestKind === 'prefetch').map((entry) => entry.eventType);
565 expect(prefetchEvents).toEqual(expect.arrayContaining([
566 'subtitle_png_requested',
567 'subtitle_png_sent',
568 'subtitle_png_not_available',
569 ]));
570
571 window.close();
572 });
573
574 test('cache-only current mode avoids direct current subtitle fetch requests', async () =>
575 {
576 const window = createWindow();
577 const helper = loadSharedVideoPlayer(window);
578 const { player, videojs } = buildPlayerHarness(window);
579 const sentBatches = [];
580
581 player.setCurrentTime(8);
582 window.fetch = jest.fn(async () =>
583 {
584 return new Response(null, {
585 status: 204,
586 headers: {
587 'X-Subtitle-Frame-Status': 'none',
588 'X-Subtitle-Request-Received-At-Ms': '1000',
589 'X-Subtitle-Response-Sent-At-Ms': '1010',
590 },
591 });
592 });
593
594 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
595 sessionId: 'sess-1',
596 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
597 }, {
598 currentFetchEnabled: false,
599 lookaheadSeconds: 0,
600 sendSubtitleLogBatch: (entries) =>
601 {
602 sentBatches.push(entries);
603 return Promise.resolve();
604 },
605 buildFrameRequest: ({ currentTime, streamIndex }) => ({
606 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
607 }),
608 });
609
610 await flushAsyncWork(window, 8);
611 controller.detach();
612 await flushAsyncWork(window, 4);
613
614 const flattened = sentBatches.flat();
615 expect(flattened.length).toBeGreaterThan(0);
616 const requestKinds = new Set(flattened.map((entry) => entry.requestKind).filter(Boolean));
617 expect(requestKinds.has('prefetch')).toBe(true);
618 expect(requestKinds.has('current')).toBe(false);
619
620 window.close();
621 });
622
623 test('renders requested and received subtitle markers on the seek bar', async () =>
624 {
625 const window = createWindow();
626 const helper = loadSharedVideoPlayer(window);
627 const { player, videojs } = buildPlayerHarness(window);
628
629 window.fetch = jest.fn(async () =>
630 {
631 return new Response('png-data', {
632 status: 200,
633 headers: {
634 'Content-Type': 'image/png',
635 'X-Subtitle-Frame-Status': 'ok',
636 'X-Subtitle-Request-Received-At-Ms': '1000',
637 'X-Subtitle-Response-Sent-At-Ms': '1012',
638 'X-Subtitle-Frame-Start-Time': '2.5',
639 'X-Subtitle-Frame-End-Time': '3.5',
640 'X-Subtitle-Frame-Width': '320',
641 'X-Subtitle-Frame-Height': '180',
642 'X-Subtitle-Frame-Canvas-Width': '640',
643 'X-Subtitle-Frame-Canvas-Height': '360',
644 },
645 });
646 });
647
648 player.duration(10);
649 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
650 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
651 }, {
652 lookaheadSeconds: 0,
653 buildFrameRequest: ({ currentTime, streamIndex }) => ({
654 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
655 }),
656 });
657
658 await flushAsyncWork(window, 8);
659
660 const requestedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-right');
661 const receivedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-left');
662 expect(requestedMarker).toBeTruthy();
663 expect(receivedMarker).toBeTruthy();
664 expect(requestedMarker.style.display).toBe('block');
665 expect(receivedMarker.style.display).toBe('block');
666 expect(requestedMarker.style.left).toBe('100.0000%');
667 expect(receivedMarker.style.left).toBe('25.0000%');
668 expect(requestedMarker.textContent).toBe(']');
669 expect(receivedMarker.textContent).toBe('[');
670
671 controller.detach();
672 await new Promise((resolve) => window.setTimeout(resolve, 300));
673 await flushAsyncWork(window, 2);
674
675 window.close();
676 });
677
678 test('advances both seek markers when subtitle request returns 204 without frame timing headers', async () =>
679 {
680 const window = createWindow();
681 const helper = loadSharedVideoPlayer(window);
682 const { player, videojs } = buildPlayerHarness(window);
683
684 player.duration(10);
685 player.setCurrentTime(4);
686 window.fetch = jest.fn(async () =>
687 {
688 return new Response(null, {
689 status: 204,
690 headers: {
691 'X-Subtitle-Frame-Status': 'none',
692 'X-Subtitle-Request-Received-At-Ms': '1000',
693 'X-Subtitle-Response-Sent-At-Ms': '1010',
694 },
695 });
696 });
697
698 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
699 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
700 }, {
701 lookaheadSeconds: 0,
702 buildFrameRequest: ({ currentTime, streamIndex }) => ({
703 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
704 }),
705 });
706
707 await flushAsyncWork(window, 8);
708
709 const requestedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-right');
710 const receivedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-left');
711 expect(requestedMarker).toBeTruthy();
712 expect(receivedMarker).toBeTruthy();
713 expect(requestedMarker.style.display).toBe('block');
714 expect(receivedMarker.style.display).toBe('block');
715 expect(requestedMarker.style.left).toBe('100.0000%');
716 expect(receivedMarker.style.left).toBe('100.0000%');
717 expect(requestedMarker.textContent).toBe(']');
718 expect(receivedMarker.textContent).toBe('[');
719
720 controller.detach();
721 await flushAsyncWork(window, 2);
722 window.close();
723 });
724
725 test('keeps existing marker positions while the next request is still in flight', async () =>
726 {
727 const window = createWindow();
728 const helper = loadSharedVideoPlayer(window);
729 const { player, videojs } = buildPlayerHarness(window);
730 let pendingResolve = null;
731
732 player.duration(10);
733 window.fetch = jest.fn((url) =>
734 {
735 const parsed = new URL(url, 'http://localhost/');
736 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
737
738 if (timeSeconds === 0)
739 {
740 return Promise.resolve(new Response('png-data', {
741 status: 200,
742 headers: {
743 'Content-Type': 'image/png',
744 'X-Subtitle-Frame-Status': 'ok',
745 'X-Subtitle-Frame-Start-Time': '2',
746 'X-Subtitle-Frame-End-Time': '3',
747 'X-Subtitle-Frame-Width': '320',
748 'X-Subtitle-Frame-Height': '180',
749 'X-Subtitle-Frame-Canvas-Width': '640',
750 'X-Subtitle-Frame-Canvas-Height': '360',
751 },
752 }));
753 }
754
755 return new Promise((resolve) =>
756 {
757 pendingResolve = resolve;
758 });
759 });
760
761 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
762 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
763 }, {
764 lookaheadSeconds: 0,
765 buildFrameRequest: ({ currentTime, streamIndex }) => ({
766 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
767 }),
768 });
769
770 await flushAsyncWork(window, 8);
771
772 const requestedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-right');
773 const receivedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-left');
774 expect(requestedMarker).toBeTruthy();
775 expect(receivedMarker).toBeTruthy();
776 expect(requestedMarker.style.left).toBe('0.0000%');
777 expect(receivedMarker.style.left).toBe('20.0000%');
778
779 player.setCurrentTime(1.5);
780 player.trigger('timeupdate');
781 await flushAsyncWork(window, 2);
782
783 expect(requestedMarker.style.left).toBe('0.0000%');
784 expect(receivedMarker.style.left).toBe('20.0000%');
785
786 pendingResolve(new Response(null, {
787 status: 204,
788 headers: {
789 'X-Subtitle-Frame-Status': 'none',
790 },
791 }));
792
793 await flushAsyncWork(window, 8);
794 expect(requestedMarker.style.display).toBe('block');
795 expect(receivedMarker.style.display).toBe('block');
796 expect(requestedMarker.style.left).toBe('15.0000%');
797 expect(receivedMarker.style.left).toBe('20.0000%');
798
799 controller.detach();
800 await flushAsyncWork(window, 2);
801 window.close();
802 });
803
804 test('keeps marker positions forward-only when later responses resolve with earlier times', async () =>
805 {
806 const window = createWindow();
807 const helper = loadSharedVideoPlayer(window);
808 const { player, videojs } = buildPlayerHarness(window);
809 const requestedTimes = [];
810
811 player.duration(12);
812 window.fetch = jest.fn(async (url) =>
813 {
814 const parsed = new URL(url, 'http://localhost/');
815 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
816 requestedTimes.push(timeSeconds);
817
818 if (requestedTimes.length === 1)
819 {
820 return new Response('png-data', {
821 status: 200,
822 headers: {
823 'Content-Type': 'image/png',
824 'X-Subtitle-Frame-Status': 'ok',
825 'X-Subtitle-Frame-Start-Time': '4',
826 'X-Subtitle-Frame-End-Time': '5',
827 'X-Subtitle-Frame-Width': '320',
828 'X-Subtitle-Frame-Height': '180',
829 'X-Subtitle-Frame-Canvas-Width': '640',
830 'X-Subtitle-Frame-Canvas-Height': '360',
831 },
832 });
833 }
834
835 return new Response('png-data', {
836 status: 200,
837 headers: {
838 'Content-Type': 'image/png',
839 'X-Subtitle-Frame-Status': 'ok',
840 'X-Subtitle-Frame-Start-Time': '2',
841 'X-Subtitle-Frame-End-Time': '3',
842 'X-Subtitle-Frame-Width': '320',
843 'X-Subtitle-Frame-Height': '180',
844 'X-Subtitle-Frame-Canvas-Width': '640',
845 'X-Subtitle-Frame-Canvas-Height': '360',
846 },
847 });
848 });
849
850 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
851 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
852 }, {
853 lookaheadSeconds: 0,
854 buildFrameRequest: ({ currentTime, streamIndex }) => ({
855 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
856 }),
857 });
858
859 await flushAsyncWork(window, 8);
860
861 const requestedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-right');
862 const receivedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-left');
863 expect(requestedMarker).toBeTruthy();
864 expect(receivedMarker).toBeTruthy();
865 expect(requestedMarker.style.left).toBe('100.0000%');
866 expect(receivedMarker.style.left).toBe('33.3333%');
867
868 player.setCurrentTime(1.5);
869 player.trigger('timeupdate');
870 await flushAsyncWork(window, 8);
871
872 // Second response reports an older start time, but markers stay monotonic.
873 expect(requestedMarker.style.left).toBe('100.0000%');
874 expect(receivedMarker.style.left).toBe('33.3333%');
875
876 controller.detach();
877 await flushAsyncWork(window, 2);
878 window.close();
879 });
880
881 test('continues current subtitle refreshes after a force-seek aborts the in-flight request', async () =>
882 {
883 const window = createWindow();
884 const helper = loadSharedVideoPlayer(window);
885 const { player, videojs } = buildPlayerHarness(window);
886 const requestedTimes = [];
887
888 window.fetch = jest.fn((url, init = {}) =>
889 {
890 const parsed = new URL(url, 'http://localhost/');
891 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
892 requestedTimes.push(timeSeconds);
893
894 if (requestedTimes.length === 1)
895 {
896 return new Promise((resolve, reject) =>
897 {
898 if (init.signal && typeof init.signal.addEventListener === 'function')
899 {
900 init.signal.addEventListener('abort', () =>
901 {
902 reject(new window.DOMException('Aborted', 'AbortError'));
903 }, { once: true });
904 }
905 });
906 }
907
908 return Promise.resolve(new Response(null, {
909 status: 204,
910 headers: {
911 'X-Subtitle-Frame-Status': 'none',
912 },
913 }));
914 });
915
916 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
917 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
918 }, {
919 lookaheadSeconds: 0,
920 currentRequestTimeoutMs: 300,
921 logToConsole: false,
922 buildFrameRequest: ({ currentTime, streamIndex }) => ({
923 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
924 }),
925 });
926
927 await flushAsyncWork(window, 4);
928 const afterInitialLoadCalls = window.fetch.mock.calls.length;
929 expect(afterInitialLoadCalls).toBeGreaterThan(0);
930
931 player.setCurrentTime(5);
932 player.trigger('seeking');
933 await flushAsyncWork(window, 20);
934
935 expect(window.fetch.mock.calls.length).toBeGreaterThanOrEqual(2);
936 expect(requestedTimes).toEqual(expect.arrayContaining([0, 5]));
937
938 controller.detach();
939 await flushAsyncWork(window, 2);
940 window.close();
941 });
942
943 test('recovers when a current subtitle request hangs and times out', async () =>
944 {
945 const window = createWindow();
946 const helper = loadSharedVideoPlayer(window);
947 const { player, videojs } = buildPlayerHarness(window);
948 const requestedTimes = [];
949
950 window.fetch = jest.fn((url, init = {}) =>
951 {
952 const parsed = new URL(url, 'http://localhost/');
953 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
954 requestedTimes.push(timeSeconds);
955
956 if (requestedTimes.length === 1)
957 {
958 return new Promise((resolve, reject) =>
959 {
960 if (init.signal && typeof init.signal.addEventListener === 'function')
961 {
962 init.signal.addEventListener('abort', () =>
963 {
964 reject(new window.DOMException('Aborted', 'AbortError'));
965 }, { once: true });
966 }
967 });
968 }
969
970 return Promise.resolve(new Response(null, {
971 status: 204,
972 headers: { 'X-Subtitle-Frame-Status': 'none' },
973 }));
974 });
975
976 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
977 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
978 }, {
979 lookaheadSeconds: 0,
980 currentRequestTimeoutMs: 250,
981 logToConsole: false,
982 buildFrameRequest: ({ currentTime, streamIndex }) => ({
983 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
984 }),
985 });
986
987 await flushAsyncWork(window, 3);
988
989 player.setCurrentTime(1.5);
990 player.trigger('timeupdate');
991
992 await new Promise((resolve) => window.setTimeout(resolve, 320));
993 player.trigger('timeupdate');
994 await new Promise((resolve) => window.setTimeout(resolve, 220));
995 await flushAsyncWork(window, 20);
996
997 expect(window.fetch.mock.calls.length).toBeGreaterThanOrEqual(2);
998 expect(requestedTimes).toEqual(expect.arrayContaining([0, 1.5]));
999
1000 controller.detach();
1001 await new Promise((resolve) => window.setTimeout(resolve, 200));
1002 await flushAsyncWork(window, 20);
1003 window.close();
1004 });
1005
1006 test('reuses cached subtitle frames after rewinding when server no longer has older frames', async () =>
1007 {
1008 const window = createWindow();
1009 const helper = loadSharedVideoPlayer(window);
1010 const { player, videojs } = buildPlayerHarness(window);
1011
1012 player.duration(10);
1013 player.setCurrentTime(2);
1014 window.fetch = jest.fn(async (url) =>
1015 {
1016 const parsed = new URL(url, 'http://localhost/');
1017 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
1018
1019 if (Math.abs(timeSeconds - 2) < 1e-6)
1020 {
1021 return new Response('png-data', {
1022 status: 200,
1023 headers: {
1024 'Content-Type': 'image/png',
1025 'X-Subtitle-Frame-Status': 'ok',
1026 'X-Subtitle-Frame-Start-Time': '2',
1027 'X-Subtitle-Frame-End-Time': '3',
1028 'X-Subtitle-Frame-Width': '320',
1029 'X-Subtitle-Frame-Height': '180',
1030 'X-Subtitle-Frame-Canvas-Width': '640',
1031 'X-Subtitle-Frame-Canvas-Height': '360',
1032 },
1033 });
1034 }
1035
1036 return new Response(null, {
1037 status: 204,
1038 headers: {
1039 'X-Subtitle-Frame-Status': 'none',
1040 },
1041 });
1042 });
1043
1044 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1045 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1046 }, {
1047 lookaheadSeconds: 0,
1048 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1049 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1050 }),
1051 });
1052
1053 await flushAsyncWork(window, 8);
1054 const afterInitialLoadCalls = window.fetch.mock.calls.length;
1055 expect(afterInitialLoadCalls).toBeGreaterThan(0);
1056
1057 player.setCurrentTime(4);
1058 player.trigger('timeupdate');
1059 await flushAsyncWork(window, 8);
1060 const afterForwardSeekCalls = window.fetch.mock.calls.length;
1061 expect(afterForwardSeekCalls).toBeGreaterThanOrEqual(afterInitialLoadCalls);
1062
1063 const overlay = player.el().querySelector('.video-subtitle-overlay');
1064 expect(overlay).toBeTruthy();
1065 expect(overlay.style.display).toBe('none');
1066
1067 player.setCurrentTime(2.5);
1068 player.trigger('timeupdate');
1069 await flushAsyncWork(window, 8);
1070
1071 expect(window.fetch.mock.calls.length).toBe(afterForwardSeekCalls);
1072 expect(overlay.style.display).toBe('block');
1073
1074 controller.detach();
1075 await flushAsyncWork(window, 2);
1076 window.close();
1077 });
1078
1079 test('registers stream cache service worker once when supported', async () =>
1080 {
1081 const window = createWindow();
1082 const helper = loadSharedVideoPlayer(window);
1083 const register = jest.fn(async () => ({}));
1084 window.navigator.serviceWorker = { register };
1085
1086 const first = await helper.enableVideoStreamClientCache();
1087 const second = await helper.enableVideoStreamClientCache();
1088
1089 expect(first).toBe(true);
1090 expect(second).toBe(true);
1091 expect(register).toHaveBeenCalledTimes(1);
1092 expect(register).toHaveBeenCalledWith('/stream-cache-sw.js', {
1093 scope: '/',
1094 updateViaCache: 'none',
1095 });
1096
1097 window.close();
1098 });
1099
1100 test('stream-ahead prefetch follows playlists and fetches segment assets', async () =>
1101 {
1102 const window = createWindow();
1103 const helper = loadSharedVideoPlayer(window);
1104 const requestedUrls = [];
1105
1106 window.fetch = jest.fn(async (input) =>
1107 {
1108 const url = String(input && input.url ? input.url : input);
1109 requestedUrls.push(url);
1110
1111 if (url === 'http://localhost/master.m3u8')
1112 {
1113 return new Response('#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=100000\nstream_0.m3u8\n#EXT-X-ENDLIST\n', {
1114 status: 200,
1115 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1116 });
1117 }
1118
1119 if (url === 'http://localhost/stream_0.m3u8')
1120 {
1121 return new Response('#EXTM3U\n#EXTINF:4,\nseg0.ts\n#EXTINF:4,\nseg1.ts\n#EXT-X-ENDLIST\n', {
1122 status: 200,
1123 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1124 });
1125 }
1126
1127 if (url === 'http://localhost/seg0.ts' || url === 'http://localhost/seg1.ts')
1128 {
1129 return new Response(new Uint8Array([1, 2, 3, 4]), {
1130 status: 200,
1131 headers: { 'Content-Type': 'video/mp2t' },
1132 });
1133 }
1134
1135 return new Response(null, { status: 404 });
1136 });
1137
1138 const controller = helper.bindStreamAheadPrefetch({
1139 playlistUrl: 'http://localhost/master.m3u8',
1140 pollIntervalMs: 0,
1141 credentials: 'same-origin',
1142 });
1143
1144 expect(controller).toBeTruthy();
1145 await controller.done();
1146
1147 expect(requestedUrls).toEqual(expect.arrayContaining([
1148 'http://localhost/master.m3u8',
1149 'http://localhost/stream_0.m3u8',
1150 'http://localhost/seg0.ts',
1151 'http://localhost/seg1.ts',
1152 ]));
1153
1154 controller.stop();
1155 window.close();
1156 });
1157
1158 test('stream-ahead prefetch reports cached-through progress for fetched segments', async () =>
1159 {
1160 const window = createWindow();
1161 const helper = loadSharedVideoPlayer(window);
1162 const progressSamples = [];
1163
1164 window.fetch = jest.fn(async (input) =>
1165 {
1166 const url = String(input && input.url ? input.url : input);
1167
1168 if (url === 'http://localhost/master.m3u8')
1169 {
1170 return new Response('#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=100000\nstream_0.m3u8\n#EXT-X-ENDLIST\n', {
1171 status: 200,
1172 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1173 });
1174 }
1175
1176 if (url === 'http://localhost/stream_0.m3u8')
1177 {
1178 return new Response('#EXTM3U\n#EXTINF:4,\nseg0.ts\n#EXTINF:4,\nseg1.ts\n#EXT-X-ENDLIST\n', {
1179 status: 200,
1180 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1181 });
1182 }
1183
1184 if (url === 'http://localhost/seg0.ts' || url === 'http://localhost/seg1.ts')
1185 {
1186 return new Response(new Uint8Array([1, 2, 3, 4]), {
1187 status: 200,
1188 headers: { 'Content-Type': 'video/mp2t' },
1189 });
1190 }
1191
1192 return new Response(null, { status: 404 });
1193 });
1194
1195 const controller = helper.bindStreamAheadPrefetch({
1196 playlistUrl: 'http://localhost/master.m3u8',
1197 pollIntervalMs: 0,
1198 credentials: 'same-origin',
1199 });
1200
1201 expect(controller).toBeTruthy();
1202 const unsubscribe = controller.subscribe((status) =>
1203 {
1204 progressSamples.push(status && status.cachedThroughSeconds);
1205 });
1206
1207 await controller.done();
1208 unsubscribe();
1209
1210 expect(progressSamples.some((value) => Number.isFinite(value) && value >= 8)).toBe(true);
1211
1212 controller.stop();
1213 window.close();
1214 });
1215
1216 test('stream-ahead prefetch infers cached-through progress from segment filenames', async () =>
1217 {
1218 const window = createWindow();
1219 const helper = loadSharedVideoPlayer(window);
1220 const progressSamples = [];
1221
1222 window.fetch = jest.fn(async (input) =>
1223 {
1224 const url = String(input && input.url ? input.url : input);
1225
1226 if (url === 'http://localhost/master.m3u8')
1227 {
1228 return new Response('#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=100000\nstream_0.m3u8\n#EXT-X-ENDLIST\n', {
1229 status: 200,
1230 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1231 });
1232 }
1233
1234 if (url === 'http://localhost/stream_0.m3u8')
1235 {
1236 return new Response('#EXTM3U\nstream_0_segment_000000.ts\nstream_0_segment_000001.ts\n#EXT-X-ENDLIST\n', {
1237 status: 200,
1238 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1239 });
1240 }
1241
1242 if (url === 'http://localhost/stream_0_segment_000000.ts' || url === 'http://localhost/stream_0_segment_000001.ts')
1243 {
1244 return new Response(new Uint8Array([1, 2, 3, 4]), {
1245 status: 200,
1246 headers: { 'Content-Type': 'video/mp2t' },
1247 });
1248 }
1249
1250 return new Response(null, { status: 404 });
1251 });
1252
1253 const controller = helper.bindStreamAheadPrefetch({
1254 playlistUrl: 'http://localhost/master.m3u8',
1255 pollIntervalMs: 0,
1256 credentials: 'same-origin',
1257 });
1258
1259 expect(controller).toBeTruthy();
1260 const unsubscribe = controller.subscribe((status) =>
1261 {
1262 progressSamples.push(status && status.cachedThroughSeconds);
1263 });
1264
1265 await controller.done();
1266 unsubscribe();
1267
1268 expect(progressSamples.some((value) => Number.isFinite(value) && value >= 8)).toBe(true);
1269
1270 controller.stop();
1271 window.close();
1272 });
1273
1274 test('stream-ahead prefetch infers cached-through progress for m4s segment filenames', async () =>
1275 {
1276 const window = createWindow();
1277 const helper = loadSharedVideoPlayer(window);
1278 const progressSamples = [];
1279
1280 window.fetch = jest.fn(async (input) =>
1281 {
1282 const url = String(input && input.url ? input.url : input);
1283
1284 if (url === 'http://localhost/master.m3u8')
1285 {
1286 return new Response('#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=100000\nstream_0.m3u8\n#EXT-X-ENDLIST\n', {
1287 status: 200,
1288 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1289 });
1290 }
1291
1292 if (url === 'http://localhost/stream_0.m3u8')
1293 {
1294 return new Response('#EXTM3U\nstream_0_segment_000000.m4s\nstream_0_segment_000001.m4s\n#EXT-X-ENDLIST\n', {
1295 status: 200,
1296 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1297 });
1298 }
1299
1300 if (url === 'http://localhost/stream_0_segment_000000.m4s' || url === 'http://localhost/stream_0_segment_000001.m4s')
1301 {
1302 return new Response(new Uint8Array([1, 2, 3, 4]), {
1303 status: 200,
1304 headers: { 'Content-Type': 'video/mp4' },
1305 });
1306 }
1307
1308 return new Response(null, { status: 404 });
1309 });
1310
1311 const controller = helper.bindStreamAheadPrefetch({
1312 playlistUrl: 'http://localhost/master.m3u8',
1313 pollIntervalMs: 0,
1314 credentials: 'same-origin',
1315 });
1316
1317 expect(controller).toBeTruthy();
1318 const unsubscribe = controller.subscribe((status) =>
1319 {
1320 progressSamples.push(status && status.cachedThroughSeconds);
1321 });
1322
1323 await controller.done();
1324 unsubscribe();
1325
1326 expect(progressSamples.some((value) => Number.isFinite(value) && value >= 8)).toBe(true);
1327
1328 controller.stop();
1329 window.close();
1330 });
1331
1332 test('stream-ahead prefetch reports ratio progress from fetched sections when timing is unknown', async () =>
1333 {
1334 const window = createWindow();
1335 const helper = loadSharedVideoPlayer(window);
1336 const statusSamples = [];
1337
1338 window.fetch = jest.fn(async (input) =>
1339 {
1340 const url = String(input && input.url ? input.url : input);
1341
1342 if (url === 'http://localhost/master.m3u8')
1343 {
1344 return new Response('#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=100000\nstream_0.m3u8\n#EXT-X-ENDLIST\n', {
1345 status: 200,
1346 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1347 });
1348 }
1349
1350 if (url === 'http://localhost/stream_0.m3u8')
1351 {
1352 return new Response('#EXTM3U\nchunk-alpha.bin\nchunk-beta.bin\n#EXT-X-ENDLIST\n', {
1353 status: 200,
1354 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1355 });
1356 }
1357
1358 if (url === 'http://localhost/chunk-alpha.bin' || url === 'http://localhost/chunk-beta.bin')
1359 {
1360 return new Response(new Uint8Array([1, 2, 3, 4]), {
1361 status: 200,
1362 headers: { 'Content-Type': 'application/octet-stream' },
1363 });
1364 }
1365
1366 return new Response(null, { status: 404 });
1367 });
1368
1369 const controller = helper.bindStreamAheadPrefetch({
1370 playlistUrl: 'http://localhost/master.m3u8',
1371 pollIntervalMs: 0,
1372 credentials: 'same-origin',
1373 });
1374
1375 expect(controller).toBeTruthy();
1376 const unsubscribe = controller.subscribe((status) =>
1377 {
1378 statusSamples.push(status || {});
1379 });
1380
1381 await controller.done();
1382 unsubscribe();
1383
1384 const finalStatus = statusSamples[statusSamples.length - 1] || {};
1385 expect(finalStatus.totalSegmentCount).toBe(2);
1386 expect(finalStatus.fetchedSegmentCount).toBe(2);
1387 expect(finalStatus.cachedThroughRatio).toBe(1);
1388
1389 controller.stop();
1390 window.close();
1391 });
1392
1393 test('clears cached stream assets for a finished playlist session', async () =>
1394 {
1395 const window = createWindow();
1396 const helper = loadSharedVideoPlayer(window);
1397 const requests = [
1398 new window.Request('http://localhost/api/files/video-stream/sess-a/master.m3u8'),
1399 new window.Request('http://localhost/api/files/video-stream/sess-a/stream_0_segment_000001.ts'),
1400 new window.Request('http://localhost/api/files/video-stream/sess-b/master.m3u8'),
1401 ];
1402 const deleteCalls = [];
1403 const cache = {
1404 keys: jest.fn(async () => requests),
1405 delete: jest.fn(async (request) =>
1406 {
1407 deleteCalls.push(request.url);
1408 return true;
1409 }),
1410 };
1411 window.caches = {
1412 open: jest.fn(async () => cache),
1413 };
1414
1415 await helper.clearVideoStreamClientCache('http://localhost/api/files/video-stream/sess-a/master.m3u8');
1416
1417 expect(window.caches.open).toHaveBeenCalledWith('filemanager-stream-cache-v1');
1418 expect(cache.keys).toHaveBeenCalledTimes(1);
1419 expect(deleteCalls).toEqual(expect.arrayContaining([
1420 'http://localhost/api/files/video-stream/sess-a/master.m3u8',
1421 'http://localhost/api/files/video-stream/sess-a/stream_0_segment_000001.ts',
1422 ]));
1423 expect(deleteCalls).not.toContain('http://localhost/api/files/video-stream/sess-b/master.m3u8');
1424
1425 window.close();
1426 });
1427});