BlueGit

timfa filemanager

Files

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

shared-video-player.test.js

cd2795a6 History
shared-video-player.test.js 32.1 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 at least through the buffered video end', async () =>
196 {
197 const window = createWindow();
198 const helper = loadSharedVideoPlayer(window);
199 const { player, videojs } = buildPlayerHarness(window);
200 const requestedTimes = [];
201
202 player.setBufferedEnd(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, 12);
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 uses furthest buffered end when player.bufferedEnd under-reports', async () =>
231 {
232 const window = createWindow();
233 const helper = loadSharedVideoPlayer(window);
234 const { player, videojs } = buildPlayerHarness(window);
235 const requestedTimes = [];
236
237 player.setBufferedEnd(0);
238 player.tech = () => ({
239 el: () => ({
240 buffered: {
241 length: 1,
242 end: () => 6,
243 },
244 }),
245 });
246
247 window.fetch = jest.fn(async (url) =>
248 {
249 const parsed = new URL(url, 'http://localhost/');
250 requestedTimes.push(Number(parsed.searchParams.get('timeSeconds')));
251 return new Response(null, {
252 status: 204,
253 headers: { 'X-Subtitle-Frame-Status': 'none' },
254 });
255 });
256
257 helper.bindImageSubtitleOverlay(player, videojs, {}, {
258 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
259 }, {
260 lookaheadSeconds: 0,
261 buildFrameRequest: ({ currentTime, streamIndex }) => ({
262 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
263 }),
264 });
265
266 await flushAsyncWork(window, 16);
267
268 expect(requestedTimes).toEqual(expect.arrayContaining([0, 0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5, 5.5, 6]));
269
270 window.close();
271 });
272
273 test('prefetch frontier jumps to current playback time instead of replaying stale lag', async () =>
274 {
275 const window = createWindow();
276 const helper = loadSharedVideoPlayer(window);
277 const { player, videojs } = buildPlayerHarness(window);
278 const requestedTimes = [];
279
280 player.setBufferedEnd(35);
281
282 window.fetch = jest.fn(async (url) =>
283 {
284 const parsed = new URL(url, 'http://localhost/');
285 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
286 requestedTimes.push(timeSeconds);
287 return new Response(null, {
288 status: 204,
289 headers: { 'X-Subtitle-Frame-Status': 'none' },
290 });
291 });
292
293 helper.bindImageSubtitleOverlay(player, videojs, {}, {
294 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
295 }, {
296 lookaheadSeconds: 0,
297 buildFrameRequest: ({ currentTime, streamIndex }) => ({
298 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
299 }),
300 });
301
302 await flushAsyncWork(window, 8);
303 expect(requestedTimes).toEqual(expect.arrayContaining([0, 0.5]));
304
305 requestedTimes.length = 0;
306 player.setCurrentTime(20);
307 player.setBufferedEnd(40);
308 player.trigger('timeupdate');
309 await flushAsyncWork(window, 8);
310
311 expect(requestedTimes).toContain(20);
312 const prefetchAfterJump = requestedTimes.filter((value) => value > 20);
313 expect(prefetchAfterJump.length).toBeGreaterThan(0);
314 expect(Math.min(...prefetchAfterJump)).toBeGreaterThanOrEqual(20.5);
315
316 window.close();
317 });
318
319 test('does not restart current subtitle request while one is in flight', async () =>
320 {
321 const window = createWindow();
322 const helper = loadSharedVideoPlayer(window);
323 const { player, videojs } = buildPlayerHarness(window);
324 const pendingResolvers = [];
325 const requestTimes = [];
326
327 window.fetch = jest.fn((url, init = {}) =>
328 {
329 const parsed = new URL(url, 'http://localhost/');
330 requestTimes.push(Number(parsed.searchParams.get('timeSeconds')));
331
332 if (pendingResolvers.length === 0)
333 {
334 return new Promise((resolve) =>
335 {
336 pendingResolvers.push(() => resolve(new Response(null, {
337 status: 204,
338 headers: { 'X-Subtitle-Frame-Status': 'none' },
339 })));
340 });
341 }
342
343 expect(init.signal && init.signal.aborted).toBe(false);
344 return Promise.resolve(new Response(null, {
345 status: 204,
346 headers: { 'X-Subtitle-Frame-Status': 'none' },
347 }));
348 });
349
350 helper.bindImageSubtitleOverlay(player, videojs, {}, {
351 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
352 }, {
353 lookaheadSeconds: 0,
354 buildFrameRequest: ({ currentTime, streamIndex }) => ({
355 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
356 }),
357 });
358
359 await flushAsyncWork(window, 3);
360 expect(window.fetch).toHaveBeenCalledTimes(1);
361
362 player.setCurrentTime(1.5);
363 player.trigger('timeupdate');
364 player.setCurrentTime(2.25);
365 player.trigger('timeupdate');
366 await flushAsyncWork(window, 2);
367
368 expect(window.fetch).toHaveBeenCalledTimes(1);
369
370 pendingResolvers[0]();
371 await flushAsyncWork(window, 5);
372
373 expect(window.fetch.mock.calls.length).toBeGreaterThanOrEqual(2);
374 expect(requestTimes).toEqual(expect.arrayContaining([0, 2.25]));
375
376 window.close();
377 });
378
379 test('aborts in-flight prefetch requests when the overlay is detached', async () =>
380 {
381 const window = createWindow();
382 const helper = loadSharedVideoPlayer(window);
383 const { player, videojs } = buildPlayerHarness(window);
384 const activeSignals = [];
385
386 window.fetch = jest.fn((url, init = {}) =>
387 {
388 const parsed = new URL(url, 'http://localhost/');
389 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
390
391 if (timeSeconds === 0)
392 {
393 return Promise.resolve(new Response(null, {
394 status: 204,
395 headers: { 'X-Subtitle-Frame-Status': 'none' },
396 }));
397 }
398
399 activeSignals.push(init.signal || null);
400
401 return new Promise((resolve, reject) =>
402 {
403 if (init.signal && typeof init.signal.addEventListener === 'function')
404 {
405 init.signal.addEventListener('abort', () =>
406 {
407 reject(new DOMException('Aborted', 'AbortError'));
408 }, { once: true });
409 }
410 });
411 });
412
413 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
414 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
415 }, {
416 lookaheadSeconds: 1,
417 buildFrameRequest: ({ currentTime, streamIndex }) => ({
418 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
419 }),
420 });
421
422 await flushAsyncWork(window, 3);
423 expect(activeSignals.length).toBeGreaterThan(0);
424
425 controller.detach();
426 await flushAsyncWork(window, 2);
427
428 expect(activeSignals.every(signal => signal && signal.aborted)).toBe(true);
429
430 window.close();
431 });
432
433 test('logs current subtitle request lifecycle events and flushes them on detach', async () =>
434 {
435 const window = createWindow();
436 const helper = loadSharedVideoPlayer(window);
437 const { player, videojs } = buildPlayerHarness(window);
438 const sentBatches = [];
439
440 window.fetch = jest.fn(async () =>
441 {
442 return new Response('png-data', {
443 status: 200,
444 headers: {
445 'Content-Type': 'image/png',
446 'X-Subtitle-Frame-Status': 'ok',
447 'X-Subtitle-Request-Received-At-Ms': '1000',
448 'X-Subtitle-Response-Sent-At-Ms': '1012',
449 'X-Subtitle-Frame-Start-Time': '1.5',
450 'X-Subtitle-Frame-End-Time': '3.2',
451 'X-Subtitle-Frame-Width': '320',
452 'X-Subtitle-Frame-Height': '180',
453 'X-Subtitle-Frame-Canvas-Width': '640',
454 'X-Subtitle-Frame-Canvas-Height': '360',
455 },
456 });
457 });
458
459 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
460 sessionId: 'sess-1',
461 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
462 }, {
463 lookaheadSeconds: 0,
464 sendSubtitleLogBatch: (entries) =>
465 {
466 sentBatches.push(entries);
467 return Promise.resolve();
468 },
469 buildFrameRequest: ({ currentTime, streamIndex }) => ({
470 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
471 }),
472 });
473
474 await flushAsyncWork(window, 8);
475 controller.detach();
476 await flushAsyncWork(window, 4);
477
478 const flattened = sentBatches.flat();
479 expect(flattened.map((entry) => entry.eventType)).toEqual(expect.arrayContaining([
480 'subtitle_png_requested',
481 'subtitle_png_sent',
482 'subtitle_png_received',
483 ]));
484
485 window.close();
486 });
487
488 test('logs prefetch subtitle lifecycle events', async () =>
489 {
490 const window = createWindow();
491 const helper = loadSharedVideoPlayer(window);
492 const { player, videojs } = buildPlayerHarness(window);
493 const sentBatches = [];
494
495 window.fetch = jest.fn(async () =>
496 {
497 return new Response(null, {
498 status: 204,
499 headers: {
500 'X-Subtitle-Frame-Status': 'none',
501 'X-Subtitle-Request-Received-At-Ms': '1000',
502 'X-Subtitle-Response-Sent-At-Ms': '1010',
503 'X-Subtitle-Frame-Start-Time': '2',
504 'X-Subtitle-Frame-End-Time': '3',
505 },
506 });
507 });
508
509 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
510 sessionId: 'sess-1',
511 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
512 }, {
513 lookaheadSeconds: 1,
514 sendSubtitleLogBatch: (entries) =>
515 {
516 sentBatches.push(entries);
517 return Promise.resolve();
518 },
519 buildFrameRequest: ({ currentTime, streamIndex }) => ({
520 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
521 }),
522 });
523
524 await flushAsyncWork(window, 8);
525 controller.detach();
526 await flushAsyncWork(window, 4);
527
528 const flattened = sentBatches.flat();
529 const prefetchEvents = flattened.filter((entry) => entry.requestKind === 'prefetch').map((entry) => entry.eventType);
530 expect(prefetchEvents).toEqual(expect.arrayContaining([
531 'subtitle_png_requested',
532 'subtitle_png_sent',
533 'subtitle_png_not_available',
534 ]));
535
536 window.close();
537 });
538
539 test('renders requested and received subtitle markers on the seek bar', async () =>
540 {
541 const window = createWindow();
542 const helper = loadSharedVideoPlayer(window);
543 const { player, videojs } = buildPlayerHarness(window);
544
545 window.fetch = jest.fn(async () =>
546 {
547 return new Response('png-data', {
548 status: 200,
549 headers: {
550 'Content-Type': 'image/png',
551 'X-Subtitle-Frame-Status': 'ok',
552 'X-Subtitle-Request-Received-At-Ms': '1000',
553 'X-Subtitle-Response-Sent-At-Ms': '1012',
554 'X-Subtitle-Frame-Start-Time': '2.5',
555 'X-Subtitle-Frame-End-Time': '3.5',
556 'X-Subtitle-Frame-Width': '320',
557 'X-Subtitle-Frame-Height': '180',
558 'X-Subtitle-Frame-Canvas-Width': '640',
559 'X-Subtitle-Frame-Canvas-Height': '360',
560 },
561 });
562 });
563
564 player.duration(10);
565 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
566 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
567 }, {
568 lookaheadSeconds: 0,
569 buildFrameRequest: ({ currentTime, streamIndex }) => ({
570 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
571 }),
572 });
573
574 await flushAsyncWork(window, 8);
575
576 const requestedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-right');
577 const receivedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-left');
578 expect(requestedMarker).toBeTruthy();
579 expect(receivedMarker).toBeTruthy();
580 expect(requestedMarker.style.display).toBe('block');
581 expect(receivedMarker.style.display).toBe('block');
582 expect(requestedMarker.style.left).toBe('0.0000%');
583 expect(receivedMarker.style.left).toBe('25.0000%');
584 expect(requestedMarker.textContent).toBe(']');
585 expect(receivedMarker.textContent).toBe('[');
586
587 controller.detach();
588 await new Promise((resolve) => window.setTimeout(resolve, 300));
589 await flushAsyncWork(window, 2);
590
591 window.close();
592 });
593
594 test('advances both seek markers when subtitle request returns 204 without frame timing headers', async () =>
595 {
596 const window = createWindow();
597 const helper = loadSharedVideoPlayer(window);
598 const { player, videojs } = buildPlayerHarness(window);
599
600 player.duration(10);
601 player.setCurrentTime(4);
602 window.fetch = jest.fn(async () =>
603 {
604 return new Response(null, {
605 status: 204,
606 headers: {
607 'X-Subtitle-Frame-Status': 'none',
608 'X-Subtitle-Request-Received-At-Ms': '1000',
609 'X-Subtitle-Response-Sent-At-Ms': '1010',
610 },
611 });
612 });
613
614 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
615 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
616 }, {
617 lookaheadSeconds: 0,
618 buildFrameRequest: ({ currentTime, streamIndex }) => ({
619 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
620 }),
621 });
622
623 await flushAsyncWork(window, 8);
624
625 const requestedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-right');
626 const receivedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-left');
627 expect(requestedMarker).toBeTruthy();
628 expect(receivedMarker).toBeTruthy();
629 expect(requestedMarker.style.display).toBe('block');
630 expect(receivedMarker.style.display).toBe('block');
631 expect(requestedMarker.style.left).toBe('40.0000%');
632 expect(receivedMarker.style.left).toBe('40.0000%');
633 expect(requestedMarker.textContent).toBe(']');
634 expect(receivedMarker.textContent).toBe('[');
635
636 controller.detach();
637 await flushAsyncWork(window, 2);
638 window.close();
639 });
640
641 test('keeps existing marker positions while the next request is still in flight', async () =>
642 {
643 const window = createWindow();
644 const helper = loadSharedVideoPlayer(window);
645 const { player, videojs } = buildPlayerHarness(window);
646 let pendingResolve = null;
647
648 player.duration(10);
649 window.fetch = jest.fn((url) =>
650 {
651 const parsed = new URL(url, 'http://localhost/');
652 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
653
654 if (timeSeconds === 0)
655 {
656 return Promise.resolve(new Response('png-data', {
657 status: 200,
658 headers: {
659 'Content-Type': 'image/png',
660 'X-Subtitle-Frame-Status': 'ok',
661 'X-Subtitle-Frame-Start-Time': '2',
662 'X-Subtitle-Frame-End-Time': '3',
663 'X-Subtitle-Frame-Width': '320',
664 'X-Subtitle-Frame-Height': '180',
665 'X-Subtitle-Frame-Canvas-Width': '640',
666 'X-Subtitle-Frame-Canvas-Height': '360',
667 },
668 }));
669 }
670
671 return new Promise((resolve) =>
672 {
673 pendingResolve = resolve;
674 });
675 });
676
677 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
678 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
679 }, {
680 lookaheadSeconds: 0,
681 buildFrameRequest: ({ currentTime, streamIndex }) => ({
682 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
683 }),
684 });
685
686 await flushAsyncWork(window, 8);
687
688 const requestedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-right');
689 const receivedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-left');
690 expect(requestedMarker).toBeTruthy();
691 expect(receivedMarker).toBeTruthy();
692 expect(requestedMarker.style.left).toBe('0.0000%');
693 expect(receivedMarker.style.left).toBe('20.0000%');
694
695 player.setCurrentTime(1.5);
696 player.trigger('timeupdate');
697 await flushAsyncWork(window, 2);
698
699 expect(requestedMarker.style.left).toBe('0.0000%');
700 expect(receivedMarker.style.left).toBe('20.0000%');
701
702 pendingResolve(new Response(null, {
703 status: 204,
704 headers: {
705 'X-Subtitle-Frame-Status': 'none',
706 },
707 }));
708
709 await flushAsyncWork(window, 8);
710 expect(requestedMarker.style.display).toBe('block');
711 expect(receivedMarker.style.display).toBe('block');
712 expect(requestedMarker.style.left).toBe('15.0000%');
713 expect(receivedMarker.style.left).toBe('20.0000%');
714
715 controller.detach();
716 await flushAsyncWork(window, 2);
717 window.close();
718 });
719
720 test('keeps marker positions forward-only when later responses resolve with earlier times', async () =>
721 {
722 const window = createWindow();
723 const helper = loadSharedVideoPlayer(window);
724 const { player, videojs } = buildPlayerHarness(window);
725 const requestedTimes = [];
726
727 player.duration(12);
728 window.fetch = jest.fn(async (url) =>
729 {
730 const parsed = new URL(url, 'http://localhost/');
731 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
732 requestedTimes.push(timeSeconds);
733
734 if (requestedTimes.length === 1)
735 {
736 return new Response('png-data', {
737 status: 200,
738 headers: {
739 'Content-Type': 'image/png',
740 'X-Subtitle-Frame-Status': 'ok',
741 'X-Subtitle-Frame-Start-Time': '4',
742 'X-Subtitle-Frame-End-Time': '5',
743 'X-Subtitle-Frame-Width': '320',
744 'X-Subtitle-Frame-Height': '180',
745 'X-Subtitle-Frame-Canvas-Width': '640',
746 'X-Subtitle-Frame-Canvas-Height': '360',
747 },
748 });
749 }
750
751 return new Response('png-data', {
752 status: 200,
753 headers: {
754 'Content-Type': 'image/png',
755 'X-Subtitle-Frame-Status': 'ok',
756 'X-Subtitle-Frame-Start-Time': '2',
757 'X-Subtitle-Frame-End-Time': '3',
758 'X-Subtitle-Frame-Width': '320',
759 'X-Subtitle-Frame-Height': '180',
760 'X-Subtitle-Frame-Canvas-Width': '640',
761 'X-Subtitle-Frame-Canvas-Height': '360',
762 },
763 });
764 });
765
766 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
767 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
768 }, {
769 lookaheadSeconds: 0,
770 buildFrameRequest: ({ currentTime, streamIndex }) => ({
771 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
772 }),
773 });
774
775 await flushAsyncWork(window, 8);
776
777 const requestedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-right');
778 const receivedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-left');
779 expect(requestedMarker).toBeTruthy();
780 expect(receivedMarker).toBeTruthy();
781 expect(requestedMarker.style.left).toBe('0.0000%');
782 expect(receivedMarker.style.left).toBe('33.3333%');
783
784 player.setCurrentTime(1.5);
785 player.trigger('timeupdate');
786 await flushAsyncWork(window, 8);
787
788 // Second response reports an older start time, but markers stay monotonic.
789 expect(requestedMarker.style.left).toBe('12.5000%');
790 expect(receivedMarker.style.left).toBe('33.3333%');
791
792 controller.detach();
793 await flushAsyncWork(window, 2);
794 window.close();
795 });
796
797 test('continues current subtitle refreshes after a force-seek aborts the in-flight request', async () =>
798 {
799 const window = createWindow();
800 const helper = loadSharedVideoPlayer(window);
801 const { player, videojs } = buildPlayerHarness(window);
802 const requestedTimes = [];
803
804 window.fetch = jest.fn((url, init = {}) =>
805 {
806 const parsed = new URL(url, 'http://localhost/');
807 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
808 requestedTimes.push(timeSeconds);
809
810 if (requestedTimes.length === 1)
811 {
812 return new Promise((resolve, reject) =>
813 {
814 if (init.signal && typeof init.signal.addEventListener === 'function')
815 {
816 init.signal.addEventListener('abort', () =>
817 {
818 reject(new window.DOMException('Aborted', 'AbortError'));
819 }, { once: true });
820 }
821 });
822 }
823
824 return Promise.resolve(new Response(null, {
825 status: 204,
826 headers: {
827 'X-Subtitle-Frame-Status': 'none',
828 },
829 }));
830 });
831
832 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
833 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
834 }, {
835 lookaheadSeconds: 0,
836 currentRequestTimeoutMs: 300,
837 logToConsole: false,
838 buildFrameRequest: ({ currentTime, streamIndex }) => ({
839 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
840 }),
841 });
842
843 await flushAsyncWork(window, 4);
844 expect(window.fetch).toHaveBeenCalledTimes(1);
845
846 player.setCurrentTime(5);
847 player.trigger('seeking');
848 await flushAsyncWork(window, 20);
849
850 expect(window.fetch.mock.calls.length).toBeGreaterThanOrEqual(2);
851 expect(requestedTimes).toEqual(expect.arrayContaining([0, 5]));
852
853 controller.detach();
854 await flushAsyncWork(window, 2);
855 window.close();
856 });
857
858 test('recovers when a current subtitle request hangs and times out', async () =>
859 {
860 const window = createWindow();
861 const helper = loadSharedVideoPlayer(window);
862 const { player, videojs } = buildPlayerHarness(window);
863 const requestedTimes = [];
864
865 window.fetch = jest.fn((url, init = {}) =>
866 {
867 const parsed = new URL(url, 'http://localhost/');
868 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
869 requestedTimes.push(timeSeconds);
870
871 if (requestedTimes.length === 1)
872 {
873 return new Promise((resolve, reject) =>
874 {
875 if (init.signal && typeof init.signal.addEventListener === 'function')
876 {
877 init.signal.addEventListener('abort', () =>
878 {
879 reject(new window.DOMException('Aborted', 'AbortError'));
880 }, { once: true });
881 }
882 });
883 }
884
885 return Promise.resolve(new Response(null, {
886 status: 204,
887 headers: { 'X-Subtitle-Frame-Status': 'none' },
888 }));
889 });
890
891 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
892 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
893 }, {
894 lookaheadSeconds: 0,
895 currentRequestTimeoutMs: 250,
896 logToConsole: false,
897 buildFrameRequest: ({ currentTime, streamIndex }) => ({
898 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
899 }),
900 });
901
902 await flushAsyncWork(window, 3);
903
904 player.setCurrentTime(1.5);
905 player.trigger('timeupdate');
906
907 await new Promise((resolve) => window.setTimeout(resolve, 320));
908 player.trigger('timeupdate');
909 await new Promise((resolve) => window.setTimeout(resolve, 220));
910 await flushAsyncWork(window, 20);
911
912 expect(window.fetch.mock.calls.length).toBeGreaterThanOrEqual(2);
913 expect(requestedTimes).toEqual(expect.arrayContaining([0, 1.5]));
914
915 controller.detach();
916 await new Promise((resolve) => window.setTimeout(resolve, 200));
917 await flushAsyncWork(window, 20);
918 window.close();
919 });
920
921 test('reuses cached subtitle frames after rewinding when server no longer has older frames', async () =>
922 {
923 const window = createWindow();
924 const helper = loadSharedVideoPlayer(window);
925 const { player, videojs } = buildPlayerHarness(window);
926
927 player.duration(10);
928 player.setCurrentTime(2);
929 window.fetch = jest.fn(async (url) =>
930 {
931 const parsed = new URL(url, 'http://localhost/');
932 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
933
934 if (Math.abs(timeSeconds - 2) < 1e-6)
935 {
936 return new Response('png-data', {
937 status: 200,
938 headers: {
939 'Content-Type': 'image/png',
940 'X-Subtitle-Frame-Status': 'ok',
941 'X-Subtitle-Frame-Start-Time': '2',
942 'X-Subtitle-Frame-End-Time': '3',
943 'X-Subtitle-Frame-Width': '320',
944 'X-Subtitle-Frame-Height': '180',
945 'X-Subtitle-Frame-Canvas-Width': '640',
946 'X-Subtitle-Frame-Canvas-Height': '360',
947 },
948 });
949 }
950
951 return new Response(null, {
952 status: 204,
953 headers: {
954 'X-Subtitle-Frame-Status': 'none',
955 },
956 });
957 });
958
959 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
960 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
961 }, {
962 lookaheadSeconds: 0,
963 buildFrameRequest: ({ currentTime, streamIndex }) => ({
964 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
965 }),
966 });
967
968 await flushAsyncWork(window, 8);
969 expect(window.fetch).toHaveBeenCalledTimes(1);
970
971 player.setCurrentTime(4);
972 player.trigger('timeupdate');
973 await flushAsyncWork(window, 8);
974 expect(window.fetch).toHaveBeenCalledTimes(2);
975
976 const overlay = player.el().querySelector('.video-subtitle-overlay');
977 expect(overlay).toBeTruthy();
978 expect(overlay.style.display).toBe('none');
979
980 player.setCurrentTime(2.5);
981 player.trigger('timeupdate');
982 await flushAsyncWork(window, 8);
983
984 expect(window.fetch).toHaveBeenCalledTimes(2);
985 expect(overlay.style.display).toBe('block');
986
987 controller.detach();
988 await flushAsyncWork(window, 2);
989 window.close();
990 });
991
992 test('registers stream cache service worker once when supported', async () =>
993 {
994 const window = createWindow();
995 const helper = loadSharedVideoPlayer(window);
996 const register = jest.fn(async () => ({}));
997 window.navigator.serviceWorker = { register };
998
999 const first = await helper.enableVideoStreamClientCache();
1000 const second = await helper.enableVideoStreamClientCache();
1001
1002 expect(first).toBe(true);
1003 expect(second).toBe(true);
1004 expect(register).toHaveBeenCalledTimes(1);
1005 expect(register).toHaveBeenCalledWith('/stream-cache-sw.js', {
1006 scope: '/',
1007 updateViaCache: 'none',
1008 });
1009
1010 window.close();
1011 });
1012
1013 test('clears cached stream assets for a finished playlist session', async () =>
1014 {
1015 const window = createWindow();
1016 const helper = loadSharedVideoPlayer(window);
1017 const requests = [
1018 new window.Request('http://localhost/api/files/video-stream/sess-a/master.m3u8'),
1019 new window.Request('http://localhost/api/files/video-stream/sess-a/stream_0_segment_000001.ts'),
1020 new window.Request('http://localhost/api/files/video-stream/sess-b/master.m3u8'),
1021 ];
1022 const deleteCalls = [];
1023 const cache = {
1024 keys: jest.fn(async () => requests),
1025 delete: jest.fn(async (request) =>
1026 {
1027 deleteCalls.push(request.url);
1028 return true;
1029 }),
1030 };
1031 window.caches = {
1032 open: jest.fn(async () => cache),
1033 };
1034
1035 await helper.clearVideoStreamClientCache('http://localhost/api/files/video-stream/sess-a/master.m3u8');
1036
1037 expect(window.caches.open).toHaveBeenCalledWith('filemanager-stream-cache-v1');
1038 expect(cache.keys).toHaveBeenCalledTimes(1);
1039 expect(deleteCalls).toEqual(expect.arrayContaining([
1040 'http://localhost/api/files/video-stream/sess-a/master.m3u8',
1041 'http://localhost/api/files/video-stream/sess-a/stream_0_segment_000001.ts',
1042 ]));
1043 expect(deleteCalls).not.toContain('http://localhost/api/files/video-stream/sess-b/master.m3u8');
1044
1045 window.close();
1046 });
1047});