BlueGit

timfa filemanager

Files

filemanager / tests / page.load.test.js

page.load.test.js

e6a17fae History
page.load.test.js 52.5 KiB Download Raw
1'use strict';
2
3const express = require('express');
4const http = require('http');
5const path = require('path');
6const { once } = require('events');
7const { webcrypto } = require('crypto');
8
9const DEFAULT_VIDEO_TEXT_TRACK_SETTINGS_RAW = JSON.stringify({
10 backgroundOpacity: '0',
11 edgeStyle: 'uniform',
12});
13
14describe('page load smoke test', () =>
15{
16 let server;
17 let baseUrl;
18 let JSDOM;
19 let VirtualConsole;
20 let rootsFixture;
21 let listFixture;
22 let spaceFixture;
23 let meFixture;
24 let thumbnailStatusFixture;
25 let rootAccessFixture;
26 let folderIconFixture;
27 let adminUsersFixture;
28 let adminConfigFixture;
29 let downloadFixture;
30 let videoStreamFixture;
31 let metaDelayMsFixture;
32 let metaWatchedByFixture;
33 let releasedVideoStreamSessions;
34 let setupNeededFixture;
35 const openDoms = [];
36
37 beforeEach(() =>
38 {
39 rootsFixture = [{ label: 'Root', path: '/data' }];
40 listFixture = {
41 '/data': [
42 {
43 name: 'readme.txt',
44 path: '/data/readme.txt',
45 isDir: false,
46 size: 12,
47 mtime: Date.now(),
48 },
49 ],
50 };
51 spaceFixture = {
52 '/data': { usedBytes: 0, freeBytes: 1024 * 1024 },
53 };
54 meFixture = { username: 'tester', isAdmin: false, permissions: {} };
55 thumbnailStatusFixture = {};
56 rootAccessFixture = {};
57 folderIconFixture = {};
58 adminUsersFixture = { users: [] };
59 adminConfigFixture = { port: 3000, paths: ['/data'], effectivePaths: ['/data'] };
60 downloadFixture = {};
61 videoStreamFixture = {};
62 metaDelayMsFixture = {};
63 metaWatchedByFixture = {};
64 releasedVideoStreamSessions = [];
65 setupNeededFixture = false;
66 });
67
68 beforeAll(async () =>
69 {
70 ({ JSDOM, VirtualConsole } = require('jsdom'));
71
72 const app = express();
73 const publicDir = path.join(__dirname, '../public');
74
75 app.use(express.json());
76 app.use(express.static(publicDir));
77
78 app.get('/api/auth/server-key', (req, res) => res.json({ publicKey: null }));
79 app.get('/api/auth/setup-needed', (req, res) => res.json({ needed: setupNeededFixture }));
80 app.get('/api/auth/me', (req, res) => res.json(meFixture));
81 app.get('/api/files/roots', (req, res) => res.json({ roots: rootsFixture }));
82 app.get('/api/files/list', (req, res) =>
83 {
84 const dir = req.query.dir;
85 res.json({ items: listFixture[dir] || [] });
86 });
87 app.get('/api/files/space', (req, res) =>
88 {
89 const dir = req.query.dir;
90 const stats = spaceFixture[dir] || { usedBytes: 0, freeBytes: null };
91 res.json(stats);
92 });
93 app.get('/api/files/thumbnail', (req, res) =>
94 {
95 const file = String(req.query.file || '');
96 const status = Number(thumbnailStatusFixture[file] || 200);
97 if (status === 404)
98 {
99 return res.status(404).json({ error: 'Thumbnail not ready.' });
100 }
101 res.type('image/webp').send('thumb');
102 });
103 app.get('/api/files/download', (req, res) =>
104 {
105 const file = String(req.query.file || '');
106 const payload = downloadFixture[file];
107 if (!payload)
108 {
109 return res.status(404).json({ error: 'File not found.' });
110 }
111 res.type(payload.type || 'application/octet-stream').send(payload.body || 'x');
112 });
113 app.get('/api/files/meta', (req, res) =>
114 {
115 const file = String(req.query.file || '');
116 const allItems = Object.values(listFixture).flat();
117 const item = allItems.find((it) => it.path === file);
118 if (!item)
119 {
120 return res.status(404).json({ error: 'File not found.' });
121 }
122 const sendMeta = () =>
123 {
124 res.json({
125 name: item.name,
126 size: item.size || 0,
127 mtime: new Date(item.mtime || Date.now()).toISOString(),
128 uploader: '',
129 downloaders: [],
130 watchedBy: metaWatchedByFixture[file] || item.watchedBy || {},
131 });
132 };
133
134 const delayMs = Number(metaDelayMsFixture[file] || 0);
135 if (delayMs > 0)
136 {
137 setTimeout(sendMeta, delayMs);
138 return;
139 }
140
141 sendMeta();
142 });
143 app.post('/api/files/video-stream', (req, res) =>
144 {
145 const filePath = String(req.body?.filePath || '');
146 const payload = videoStreamFixture[filePath];
147 if (!payload)
148 {
149 return res.status(404).json({ error: 'Stream not found.' });
150 }
151 res.json(payload);
152 });
153 app.delete('/api/files/video-stream/:sessionId', (req, res) =>
154 {
155 releasedVideoStreamSessions.push(String(req.params.sessionId || ''));
156 res.json({ ok: true });
157 });
158 app.post('/api/files/watch-progress', (req, res) =>
159 {
160 res.json({ ok: true, updated: true });
161 });
162 app.post('/api/files/watched-statuses', (req, res) =>
163 {
164 const requested = Array.isArray(req.body?.filePaths) ? req.body.filePaths : [];
165 const statuses = {};
166
167 for (const rawPath of requested)
168 {
169 const filePath = String(rawPath || '');
170 const allItems = Object.values(listFixture).flat();
171 const item = allItems.find((it) => it.path === filePath);
172 const watchedBy = metaWatchedByFixture[filePath] || (item && item.watchedBy) || {};
173 const status = String(watchedBy.tester || '').toLowerCase();
174 if (status === 'fully' || status === 'partway') statuses[filePath] = status;
175 }
176
177 res.json({ statuses });
178 });
179 app.get('/api/files/root-access', (req, res) =>
180 {
181 const rootPath = String(req.query.rootPath || '');
182 res.json({ users: rootAccessFixture[rootPath] || [] });
183 });
184 app.get('/api/files/folder-icon', (req, res) =>
185 {
186 const dir = String(req.query.dir || '');
187 const icon = folderIconFixture[dir] || null;
188 res.json({ icon });
189 });
190 app.get('/api/files/folder-images', (req, res) =>
191 {
192 res.json({ images: [] });
193 });
194 app.get('/api/admin/config', (req, res) => res.json(adminConfigFixture));
195 app.get('/api/admin/users', (req, res) => res.json(adminUsersFixture));
196 app.post('/api/auth/logout', (req, res) => res.json({ ok: true }));
197 app.get('*', (req, res) => res.sendFile(path.join(publicDir, 'index.html')));
198
199 server = http.createServer(app);
200 server.listen(0);
201 await once(server, 'listening');
202 baseUrl = `http://127.0.0.1:${server.address().port}`;
203 });
204
205 afterAll(() => server.close());
206
207 afterEach(() =>
208 {
209 while (openDoms.length)
210 {
211 const dom = openDoms.pop();
212 try { dom.window.close(); } catch { /* ignore */ }
213 }
214 });
215
216 async function bootClient ({ mobile = false, savedSession } = {})
217 {
218 const virtualConsole = new VirtualConsole();
219 const runtimeErrors = [];
220
221 virtualConsole.on('jsdomError', (err) =>
222 {
223 runtimeErrors.push(err);
224 });
225
226 const dom = await JSDOM.fromURL(baseUrl + '/', {
227 resources: 'usable',
228 runScripts: 'dangerously',
229 pretendToBeVisual: true,
230 virtualConsole,
231 beforeParse (window)
232 {
233 window.crypto = webcrypto;
234 window.fetch = (input, init) =>
235 {
236 const url = typeof input === 'string' ? input : input.url;
237 return fetch(new URL(url, baseUrl).toString(), init);
238 };
239 window.HTMLElement.prototype.focus = function focus () { };
240 window.HTMLCanvasElement.prototype.getContext = () => null;
241 window.matchMedia = () => ({ matches: mobile, addListener () { }, removeListener () { }, addEventListener () { }, removeEventListener () { } });
242 window.scrollTo = () => { };
243 let blobCounter = 0;
244 window.URL.createObjectURL = () => `blob:mock-${blobCounter++}`;
245 window.URL.revokeObjectURL = () => { };
246 window.__lastVideoJsOptions = null;
247 window.__lastVideoJsVolumeSet = null;
248 window.__lastVideoJsPlayer = null;
249 window.__lastVideoJsTextTracks = null;
250 window.__lastVideoJsAudioTracks = null;
251 window.__mockVideoJsAudioTracks = [];
252 window.videojs = (element, options) =>
253 {
254 window.__lastVideoJsOptions = options;
255 let volumeValue = 1;
256 let durationValue = 20;
257
258 const listenersByType = new Map();
259 function makeEventTarget ()
260 {
261 const listeners = new Map();
262 return {
263 addEventListener (type, fn)
264 {
265 if (!listeners.has(type)) listeners.set(type, new Set());
266 listeners.get(type).add(fn);
267 },
268 removeEventListener (type, fn)
269 {
270 const handlers = listeners.get(type);
271 if (!handlers) return;
272 handlers.delete(fn);
273 },
274 dispatchEvent (type)
275 {
276 const handlers = listeners.get(type);
277 if (!handlers) return;
278 for (const fn of Array.from(handlers)) fn();
279 },
280 };
281 }
282
283 function makeTrackList (tracks)
284 {
285 const eventTarget = makeEventTarget();
286 const list = {
287 length: tracks.length,
288 item (index)
289 {
290 return tracks[index] || null;
291 },
292 addEventListener: eventTarget.addEventListener,
293 removeEventListener: eventTarget.removeEventListener,
294 dispatchEvent: eventTarget.dispatchEvent,
295 };
296
297 for (let i = 0; i < tracks.length; i++)
298 {
299 list[i] = tracks[i];
300 }
301
302 return list;
303 }
304
305 const textTracks = makeTrackList((options?.tracks || []).map((track) => ({
306 kind: track.kind,
307 label: track.label,
308 language: track.srclang,
309 mode: track.default ? 'showing' : 'disabled',
310 })));
311 const audioTracks = makeTrackList((window.__mockVideoJsAudioTracks || []).map((track) => ({
312 label: track.label,
313 language: track.language,
314 enabled: !!track.enabled,
315 })));
316
317 window.__lastVideoJsTextTracks = textTracks;
318 window.__lastVideoJsAudioTracks = audioTracks;
319
320 const player = {
321 ready (cb)
322 {
323 if (typeof cb === 'function') cb();
324 },
325 on (type, fn)
326 {
327 if (!listenersByType.has(type)) listenersByType.set(type, new Set());
328 listenersByType.get(type).add(fn);
329 },
330 trigger (type)
331 {
332 const listeners = listenersByType.get(type);
333 if (!listeners) return;
334 for (const fn of Array.from(listeners)) fn();
335 },
336 duration (next)
337 {
338 if (next === undefined) return durationValue;
339 durationValue = Number(next);
340 return durationValue;
341 },
342 currentTime () { return 0; },
343 textTracks () { return textTracks; },
344 audioTracks () { return audioTracks; },
345 volume (next)
346 {
347 if (next === undefined) return volumeValue;
348 volumeValue = Number(next);
349 window.__lastVideoJsVolumeSet = volumeValue;
350 return volumeValue;
351 },
352 dispose () { },
353 };
354 window.__lastVideoJsPlayer = player;
355 return player;
356 };
357
358 const defaultSaved = {
359 token: 'saved-token',
360 dir: '/data',
361 rootPath: '/data',
362 lastOperationAt: Date.now(),
363 };
364 const effectiveSaved = savedSession === undefined ? defaultSaved : savedSession;
365 if (effectiveSaved)
366 {
367 window.localStorage.setItem('filemanager.session.v1', JSON.stringify(effectiveSaved));
368 }
369 window.addEventListener('error', (event) => runtimeErrors.push(event.error || new Error(event.message)));
370 window.addEventListener('unhandledrejection', (event) => runtimeErrors.push(event.reason || new Error('Unhandled rejection')));
371 },
372 });
373
374 await new Promise((resolve) => dom.window.addEventListener('load', resolve, { once: true }));
375 await new Promise((resolve) =>
376 {
377 const startedAt = Date.now();
378 const maxWaitMs = 2000;
379
380 function checkReady ()
381 {
382 const app = dom.window.document.getElementById('app');
383 if (app && !app.classList.contains('hidden'))
384 {
385 resolve();
386 return;
387 }
388
389 if (Date.now() - startedAt >= maxWaitMs)
390 {
391 resolve();
392 return;
393 }
394
395 dom.window.setTimeout(checkReady, 25);
396 }
397
398 checkReady();
399 });
400
401 openDoms.push(dom);
402
403 return { dom, runtimeErrors };
404 }
405
406 async function waitFor (dom, predicate, timeoutMs = 5000)
407 {
408 const startedAt = Date.now();
409 while (Date.now() - startedAt < timeoutMs)
410 {
411 if (predicate()) return true;
412 await new Promise(resolve => dom.window.setTimeout(resolve, 25));
413 }
414 return predicate();
415 }
416
417 test('requests / and boots the client without runtime errors', async () =>
418 {
419 const { dom, runtimeErrors } = await bootClient();
420
421 expect(runtimeErrors).toEqual([]);
422 expect(dom.window.document.getElementById('app').classList.contains('hidden')).toBe(false);
423 expect(dom.window.document.getElementById('sidebar').classList.contains('hidden')).toBe(false);
424
425 dom.window.close();
426 });
427
428 test('login overlay uses username and current-password autocomplete tokens', async () =>
429 {
430 const { dom, runtimeErrors } = await bootClient({ savedSession: null });
431
432 expect(runtimeErrors).toEqual([]);
433
434 const username = dom.window.document.getElementById('auth-username');
435 const password = dom.window.document.getElementById('auth-password');
436 expect(username.getAttribute('autocomplete')).toBe('username');
437 expect(password.getAttribute('autocomplete')).toBe('current-password');
438
439 dom.window.close();
440 });
441
442 test('first-run setup uses new-password autocomplete token', async () =>
443 {
444 setupNeededFixture = true;
445
446 const { dom, runtimeErrors } = await bootClient({ savedSession: null });
447
448 expect(runtimeErrors).toEqual([]);
449
450 const password = dom.window.document.getElementById('auth-password');
451 expect(password.getAttribute('autocomplete')).toBe('new-password');
452
453 dom.window.close();
454 });
455
456 test('keeps sidebar folded on initial mobile boot', async () =>
457 {
458 const { dom, runtimeErrors } = await bootClient({ mobile: true });
459
460 expect(runtimeErrors).toEqual([]);
461 expect(dom.window.document.getElementById('app').classList.contains('hidden')).toBe(false);
462 expect(dom.window.document.getElementById('sidebar').classList.contains('hidden')).toBe(true);
463
464 dom.window.close();
465 });
466
467 test('suppresses default context menu on mobile file long-press', async () =>
468 {
469 const { dom, runtimeErrors } = await bootClient({ mobile: true });
470
471 expect(runtimeErrors).toEqual([]);
472
473 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item'));
474
475 const tile = dom.window.document.querySelector('.file-item');
476 expect(tile).toBeTruthy();
477
478 const evt = new dom.window.MouseEvent('contextmenu', {
479 bubbles: true,
480 cancelable: true,
481 view: dom.window,
482 });
483
484 const dispatchResult = tile.dispatchEvent(evt);
485 expect(dispatchResult).toBe(false);
486 expect(evt.defaultPrevented).toBe(true);
487
488 dom.window.close();
489 });
490
491 test('in Home, root tiles single-click focus and double-click open', async () =>
492 {
493 rootsFixture = [
494 { label: 'Root A', path: '/data-a' },
495 { label: 'Root B', path: '/data-b' },
496 ];
497 listFixture = {
498 '/data-a': [
499 {
500 name: 'docs',
501 path: '/data-a/docs',
502 isDir: true,
503 size: 0,
504 mtime: Date.now(),
505 },
506 ],
507 };
508 spaceFixture = {
509 '/data-a': { usedBytes: 2048, freeBytes: 4096 },
510 '/data-b': { usedBytes: 1024, freeBytes: 8192 },
511 };
512 folderIconFixture = {
513 '/data-a': { filePath: '/data-a/docs/cover.jpg' },
514 };
515
516 const { dom, runtimeErrors } = await bootClient({
517 savedSession: {
518 token: 'saved-token',
519 dir: null,
520 rootPath: null,
521 lastOperationAt: Date.now(),
522 },
523 });
524 expect(runtimeErrors).toEqual([]);
525
526 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data-a"]'));
527
528 const rootTile = dom.window.document.querySelector('.file-item[data-path="/data-a"]');
529 expect(rootTile).toBeTruthy();
530
531 rootTile.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
532 await new Promise(resolve => dom.window.setTimeout(resolve, 40));
533
534 expect(rootTile.classList.contains('selected')).toBe(true);
535 expect(dom.window.document.querySelector('.file-item[data-path="/data-b"]')).toBeTruthy();
536 expect(dom.window.document.getElementById('sidebar-meta').textContent).toContain('Used');
537 expect(dom.window.document.getElementById('sidebar-meta').textContent).toContain('Remaining');
538
539 let rootIconImage = null;
540 for (let i = 0; i < 10; i++)
541 {
542 const rootIconSvg = rootTile.querySelector('.icon svg');
543 rootIconImage = rootIconSvg ? rootIconSvg.querySelector('image') : null;
544 if (rootIconImage) break;
545 await new Promise(resolve => dom.window.setTimeout(resolve, 25));
546 }
547 // Root tiles should load folder icon thumbnails in Home view.
548 expect(rootIconImage).toBeTruthy();
549
550 rootTile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
551 await new Promise(resolve => dom.window.setTimeout(resolve, 80));
552
553 expect(dom.window.document.querySelector('.file-item[data-path="/data-a/docs"]')).toBeTruthy();
554
555 dom.window.close();
556 });
557
558 test('root sidebar shows alias and original name, and excludes Move to action', async () =>
559 {
560 rootsFixture = [
561 { label: 'Shared', path: '/data-a', originalName: 'data-a', alias: 'Shared' },
562 { label: 'Root B', path: '/data-b', originalName: 'data-b', alias: null },
563 ];
564 meFixture = {
565 username: 'tester',
566 isAdmin: false,
567 permissions: {
568 'data-a': { read: true, write: true },
569 'data-b': { read: true, write: false },
570 },
571 };
572 spaceFixture = {
573 '/data-a': { usedBytes: 1024, freeBytes: 2048 },
574 '/data-b': { usedBytes: 2048, freeBytes: 1024 },
575 };
576 rootAccessFixture = {
577 '/data-a': [
578 { username: 'alice', mode: 'R' },
579 { username: 'bob', mode: 'R+W' },
580 ],
581 };
582
583 const { dom, runtimeErrors } = await bootClient({
584 savedSession: {
585 token: 'saved-token',
586 dir: null,
587 rootPath: null,
588 lastOperationAt: Date.now(),
589 },
590 });
591
592 expect(runtimeErrors).toEqual([]);
593 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data-a"]'));
594
595 const rootTile = dom.window.document.querySelector('.file-item[data-path="/data-a"]');
596 expect(rootTile).toBeTruthy();
597 rootTile.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
598 await new Promise(resolve => dom.window.setTimeout(resolve, 40));
599
600 const sidebarText = dom.window.document.getElementById('sidebar-meta').textContent;
601 expect(sidebarText).toContain('Alias');
602 expect(sidebarText).toContain('Shared');
603 expect(sidebarText).toContain('Original name');
604 expect(sidebarText).toContain('data-a');
605 expect(sidebarText).toContain('Access');
606 expect(sidebarText).toContain('alice R');
607 expect(sidebarText).toContain('bob R+W');
608
609 const accessItems = Array.from(dom.window.document.querySelectorAll('#sidebar-meta .root-access-list li')).map(li => li.textContent.trim());
610 expect(accessItems).toEqual(['bob R+W', 'alice R']);
611
612 const actionButtons = Array.from(dom.window.document.querySelectorAll('#sidebar-actions button')).map(b => b.textContent);
613 expect(actionButtons).toContain('Rename');
614 expect(actionButtons).not.toContain('Move to');
615 expect(actionButtons).not.toContain('Delete');
616
617 dom.window.close();
618 });
619
620 test('files inside My Folder still expose write actions to the owner', async () =>
621 {
622 const myFolderPath = '/personal/tester';
623 rootsFixture = [
624 { label: 'My Folder', path: myFolderPath, originalName: 'tester', alias: 'My Folder', isUserFolder: true },
625 { label: 'Root', path: '/data', originalName: 'data', alias: null },
626 ];
627 listFixture = {
628 [myFolderPath]: [
629 {
630 name: 'private.txt',
631 path: `${myFolderPath}/private.txt`,
632 isDir: false,
633 size: 3,
634 mtime: Date.now(),
635 },
636 ],
637 };
638 meFixture = {
639 username: 'tester',
640 isAdmin: false,
641 permissions: {},
642 };
643
644 const { dom, runtimeErrors } = await bootClient({
645 savedSession: {
646 token: 'saved-token',
647 dir: null,
648 rootPath: null,
649 lastOperationAt: Date.now(),
650 },
651 });
652
653 expect(runtimeErrors).toEqual([]);
654 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/personal/tester"]'));
655
656 const rootTile = dom.window.document.querySelector('.file-item[data-path="/personal/tester"]');
657 rootTile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
658 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/personal/tester/private.txt"]'));
659
660 const fileTile = dom.window.document.querySelector('.file-item[data-path="/personal/tester/private.txt"]');
661 fileTile.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
662 await new Promise(resolve => dom.window.setTimeout(resolve, 40));
663
664 const actionButtons = Array.from(dom.window.document.querySelectorAll('#sidebar-actions button')).map(b => b.textContent);
665 expect(actionButtons).toContain('Share');
666 expect(actionButtons).toContain('Move to');
667 expect(actionButtons).toContain('Copy to');
668 expect(actionButtons).toContain('Rename');
669
670 dom.window.close();
671 });
672
673 test('base-level root sidebar shows access list with no item selected', async () =>
674 {
675 rootAccessFixture = {
676 '/data': [
677 { username: 'tim', mode: 'R+W' },
678 { username: 'guest', mode: 'R' },
679 ],
680 };
681
682 const { dom, runtimeErrors } = await bootClient();
683 expect(runtimeErrors).toEqual([]);
684
685 await new Promise(resolve => dom.window.setTimeout(resolve, 80));
686 const sidebarText = dom.window.document.getElementById('sidebar-meta').textContent;
687 expect(sidebarText).toContain('Access');
688 expect(sidebarText).toContain('tim R+W');
689 expect(sidebarText).toContain('guest R');
690
691 const accessItems = Array.from(dom.window.document.querySelectorAll('#sidebar-meta .root-access-list li')).map(li => li.textContent.trim());
692 expect(accessItems).toEqual(['tim R+W', 'guest R']);
693
694 dom.window.close();
695 });
696
697 test('shows pending icon spinner when image thumbnail cache is not ready', async () =>
698 {
699 listFixture = {
700 '/data': [
701 {
702 name: 'photo.png',
703 path: '/data/photo.png',
704 isDir: false,
705 size: 1024,
706 mtime: Date.now(),
707 },
708 ],
709 };
710 thumbnailStatusFixture['/data/photo.png'] = 404;
711
712 const { dom, runtimeErrors } = await bootClient();
713 expect(runtimeErrors).toEqual([]);
714
715 await new Promise(resolve => dom.window.setTimeout(resolve, 80));
716 const icon = dom.window.document.querySelector('.icon[data-preview-path="/data/photo.png"]');
717 expect(icon).toBeTruthy();
718 expect(icon.classList.contains('thumb-pending')).toBe(true);
719
720 dom.window.close();
721 });
722
723 test('rapid file reselection does not duplicate sidebar action buttons after delayed metadata', async () =>
724 {
725 listFixture = {
726 '/data': [
727 {
728 name: 'first.txt',
729 path: '/data/first.txt',
730 isDir: false,
731 size: 10,
732 mtime: Date.now(),
733 },
734 {
735 name: 'second.txt',
736 path: '/data/second.txt',
737 isDir: false,
738 size: 20,
739 mtime: Date.now(),
740 },
741 ],
742 };
743 metaDelayMsFixture['/data/first.txt'] = 120;
744
745 const { dom, runtimeErrors } = await bootClient();
746 expect(runtimeErrors).toEqual([]);
747
748 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/first.txt"]'));
749 const firstTile = dom.window.document.querySelector('.file-item[data-path="/data/first.txt"]');
750 const secondTile = dom.window.document.querySelector('.file-item[data-path="/data/second.txt"]');
751 expect(firstTile).toBeTruthy();
752 expect(secondTile).toBeTruthy();
753
754 firstTile.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
755 await new Promise(resolve => dom.window.setTimeout(resolve, 10));
756 secondTile.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
757
758 await new Promise(resolve => dom.window.setTimeout(resolve, 220));
759
760 const actionButtons = Array.from(dom.window.document.querySelectorAll('#sidebar-actions button')).map(b => b.textContent);
761 expect(actionButtons).toEqual(['View / Download', 'Share']);
762
763 dom.window.close();
764 });
765
766 test('video tiles show centred watched overlays after watched metadata is loaded', async () =>
767 {
768 listFixture = {
769 '/data': [
770 {
771 name: 'watched-full.mkv',
772 path: '/data/watched-full.mkv',
773 isDir: false,
774 size: 100,
775 mtime: Date.now(),
776 },
777 {
778 name: 'watched-part.mkv',
779 path: '/data/watched-part.mkv',
780 isDir: false,
781 size: 100,
782 mtime: Date.now(),
783 },
784 ],
785 };
786 metaWatchedByFixture['/data/watched-full.mkv'] = { tester: 'fully' };
787 metaWatchedByFixture['/data/watched-part.mkv'] = { tester: 'partway' };
788
789 const { dom, runtimeErrors } = await bootClient();
790 expect(runtimeErrors).toEqual([]);
791
792 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/watched-full.mkv"] .watched-overlay--fully'));
793
794 const fullOverlayPath = dom.window.document.querySelector('.file-item[data-path="/data/watched-full.mkv"] .watched-overlay--fully path');
795 const partOverlayPath = dom.window.document.querySelector('.file-item[data-path="/data/watched-part.mkv"] .watched-overlay--partway path');
796
797 expect(fullOverlayPath).toBeTruthy();
798 expect(fullOverlayPath.getAttribute('fill')).toBe('#ffffff');
799
800 expect(partOverlayPath).toBeTruthy();
801 expect(partOverlayPath.getAttribute('fill')).toBe('none');
802 expect(partOverlayPath.getAttribute('stroke')).toBe('#ffffff');
803
804 dom.window.close();
805 });
806
807 test('admin user modal locks write checkbox while read is unchecked', async () =>
808 {
809 meFixture = { username: 'admin', isAdmin: true, permissions: {} };
810 adminConfigFixture = { port: 3000, paths: ['/data'], effectivePaths: ['/data'] };
811 adminUsersFixture = {
812 users: [
813 {
814 id: 9,
815 username: 'guest',
816 isAdmin: false,
817 permissions: { data: { read: false, write: true } },
818 },
819 ],
820 };
821
822 const { dom, runtimeErrors } = await bootClient();
823 expect(runtimeErrors).toEqual([]);
824
825 dom.window.document.getElementById('btn-admin').dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
826 await new Promise(resolve => dom.window.setTimeout(resolve, 80));
827
828 const editBtn = dom.window.document.querySelector('#admin-users-list [data-action="edit"]');
829 expect(editBtn).toBeTruthy();
830 editBtn.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
831 await new Promise(resolve => dom.window.setTimeout(resolve, 40));
832
833 const readCb = dom.window.document.querySelector('input[data-label="data"][data-type="read"]');
834 const writeCb = dom.window.document.querySelector('input[data-label="data"][data-type="write"]');
835 expect(readCb).toBeTruthy();
836 expect(writeCb).toBeTruthy();
837 expect(readCb.checked).toBe(false);
838 expect(writeCb.checked).toBe(false);
839 expect(writeCb.disabled).toBe(true);
840
841 readCb.checked = true;
842 readCb.dispatchEvent(new dom.window.Event('change', { bubbles: true }));
843 expect(writeCb.disabled).toBe(false);
844
845 writeCb.checked = true;
846 readCb.checked = false;
847 readCb.dispatchEvent(new dom.window.Event('change', { bubbles: true }));
848 expect(writeCb.checked).toBe(false);
849 expect(writeCb.disabled).toBe(true);
850
851 dom.window.close();
852 });
853
854 test('uses direct svg thumbnail when svg file is under 1MB', async () =>
855 {
856 listFixture = {
857 '/data': [
858 {
859 name: 'icon.svg',
860 path: '/data/icon.svg',
861 isDir: false,
862 size: 400 * 1024,
863 mtime: Date.now(),
864 },
865 ],
866 };
867 thumbnailStatusFixture['/data/icon.svg'] = 404;
868 downloadFixture['/data/icon.svg'] = {
869 type: 'image/svg+xml',
870 body: '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 10 10"><rect width="10" height="10" fill="red"/></svg>',
871 };
872
873 const { dom, runtimeErrors } = await bootClient();
874 expect(runtimeErrors).toEqual([]);
875
876 await new Promise(resolve => dom.window.setTimeout(resolve, 80));
877 const icon = dom.window.document.querySelector('.icon[data-preview-path="/data/icon.svg"]');
878 expect(icon).toBeTruthy();
879 expect(icon.classList.contains('thumb-pending')).toBe(false);
880 expect(icon.dataset.thumbReady).toBe('1');
881
882 dom.window.close();
883 });
884
885 test('expanded file preview shows a Share button next to Download', async () =>
886 {
887 downloadFixture['/data/readme.txt'] = {
888 type: 'text/plain',
889 body: 'hello preview',
890 };
891
892 const { dom, runtimeErrors } = await bootClient();
893 expect(runtimeErrors).toEqual([]);
894
895 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/readme.txt"]'));
896
897 const fileTile = dom.window.document.querySelector('.file-item[data-path="/data/readme.txt"]');
898 expect(fileTile).toBeTruthy();
899
900 fileTile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
901 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-expand-share'));
902
903 const shareBtn = dom.window.document.querySelector('.preview-expand-share');
904 const downloadBtn = dom.window.document.querySelector('.preview-expand-download');
905 const actions = dom.window.document.querySelector('.preview-expand-actions');
906 expect(shareBtn).toBeTruthy();
907 expect(downloadBtn).toBeTruthy();
908 expect(actions).toBeTruthy();
909 expect(actions.contains(shareBtn)).toBe(true);
910 expect(actions.contains(downloadBtn)).toBe(true);
911 expect(shareBtn.textContent).toBe('Share');
912
913 dom.window.close();
914 });
915
916 test('expanded video preview uses a stream session and video.js', async () =>
917 {
918 listFixture['/data'] = [
919 {
920 name: 'clip.mkv',
921 path: '/data/clip.mkv',
922 isDir: false,
923 size: 64,
924 mtime: Date.now(),
925 },
926 ];
927 videoStreamFixture['/data/clip.mkv'] = {
928 sessionId: 'video-session',
929 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
930 durationSeconds: 120,
931 subtitleTracks: [{ label: 'English', language: 'eng', default: true, src: '/api/files/video-stream/video-session/subtitle-0.vtt' }],
932 };
933
934 const { dom, runtimeErrors } = await bootClient();
935 expect(runtimeErrors).toEqual([]);
936
937 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
938
939 const fileTile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
940 expect(fileTile).toBeTruthy();
941
942 fileTile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
943 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
944
945 expect(dom.window.__lastVideoJsOptions).toBeTruthy();
946 expect(dom.window.__lastVideoJsOptions.sources[0].src).toBe('/api/files/video-stream/video-session/master.m3u8');
947 expect(dom.window.__lastVideoJsOptions.fluid).toBe(false);
948 expect(dom.window.__lastVideoJsOptions.fill).toBe(true);
949 expect(dom.window.__lastVideoJsOptions.controlBar).toMatchObject({
950 currentTimeDisplay: true,
951 timeDivider: true,
952 durationDisplay: true,
953 remainingTimeDisplay: false,
954 });
955 expect(dom.window.__lastVideoJsPlayer.duration()).toBe(120);
956 expect(dom.window.__lastVideoJsOptions.tracks).toEqual([
957 {
958 kind: 'subtitles',
959 src: '/api/files/video-stream/video-session/subtitle-0.vtt',
960 srclang: 'eng',
961 label: 'English',
962 default: true,
963 },
964 ]);
965
966 dom.window.close();
967 });
968
969 test('video preview does not close on backdrop click and closes via X button', async () =>
970 {
971 listFixture['/data'] = [
972 {
973 name: 'clip.mkv',
974 path: '/data/clip.mkv',
975 isDir: false,
976 size: 64,
977 mtime: Date.now(),
978 },
979 ];
980 videoStreamFixture['/data/clip.mkv'] = {
981 sessionId: 'video-session',
982 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
983 subtitleTracks: [],
984 subtitleSummary: { total: 0, converted: 0, skipped: 0 },
985 };
986
987 const { dom, runtimeErrors } = await bootClient();
988 expect(runtimeErrors).toEqual([]);
989
990 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
991
992 const tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
993 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
994 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-backdrop'));
995
996 const backdrop = dom.window.document.querySelector('.preview-backdrop');
997 backdrop.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
998 await new Promise(resolve => dom.window.setTimeout(resolve, 40));
999
1000 expect(dom.window.document.querySelector('.preview-backdrop')).toBeTruthy();
1001
1002 const closeBtn = dom.window.document.querySelector('.preview-expand-close');
1003 closeBtn.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
1004 await new Promise(resolve => dom.window.setTimeout(resolve, 280));
1005
1006 expect(dom.window.document.querySelector('.preview-backdrop')).toBeNull();
1007
1008 dom.window.close();
1009 });
1010
1011 test('video preview releases the backend stream session when closed', async () =>
1012 {
1013 listFixture['/data'] = [
1014 {
1015 name: 'clip.mkv',
1016 path: '/data/clip.mkv',
1017 isDir: false,
1018 size: 64,
1019 mtime: Date.now(),
1020 },
1021 ];
1022 videoStreamFixture['/data/clip.mkv'] = {
1023 sessionId: 'video-session',
1024 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
1025 subtitleTracks: [],
1026 subtitleSummary: { total: 0, converted: 0, skipped: 0 },
1027 };
1028
1029 const { dom, runtimeErrors } = await bootClient();
1030 expect(runtimeErrors).toEqual([]);
1031
1032 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1033
1034 const tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1035 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1036 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1037
1038 const closeBtn = dom.window.document.querySelector('.preview-expand-close');
1039 closeBtn.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
1040 await waitFor(dom, () => releasedVideoStreamSessions.includes('video-session'));
1041
1042 dom.window.close();
1043 });
1044
1045 test('video preview restores per-user saved volume preference', async () =>
1046 {
1047 listFixture['/data'] = [
1048 {
1049 name: 'clip.mkv',
1050 path: '/data/clip.mkv',
1051 isDir: false,
1052 size: 64,
1053 mtime: Date.now(),
1054 },
1055 ];
1056 videoStreamFixture['/data/clip.mkv'] = {
1057 sessionId: 'video-session',
1058 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
1059 subtitleTracks: [],
1060 subtitleSummary: { total: 0, converted: 0, skipped: 0 },
1061 };
1062
1063 const { dom, runtimeErrors } = await bootClient();
1064 expect(runtimeErrors).toEqual([]);
1065
1066 dom.window.localStorage.setItem('filemanager.video-prefs.v1.tester', JSON.stringify({ volume: 0.3 }));
1067
1068 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1069
1070 const tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1071 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1072 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1073
1074 expect(dom.window.__lastVideoJsVolumeSet).toBe(0.3);
1075
1076 dom.window.close();
1077 });
1078
1079 test('video preview restores saved subtitle/audio track names when available', async () =>
1080 {
1081 listFixture['/data'] = [
1082 {
1083 name: 'clip.mkv',
1084 path: '/data/clip.mkv',
1085 isDir: false,
1086 size: 64,
1087 mtime: Date.now(),
1088 },
1089 ];
1090 videoStreamFixture['/data/clip.mkv'] = {
1091 sessionId: 'video-session',
1092 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
1093 subtitleTracks: [
1094 { label: 'English', language: 'eng', default: true, src: '/api/files/video-stream/video-session/subtitle-0.vtt' },
1095 { label: 'French', language: 'fra', default: false, src: '/api/files/video-stream/video-session/subtitle-1.vtt' },
1096 ],
1097 subtitleSummary: { total: 2, converted: 2, skipped: 0 },
1098 };
1099
1100 const { dom, runtimeErrors } = await bootClient();
1101 expect(runtimeErrors).toEqual([]);
1102
1103 dom.window.__mockVideoJsAudioTracks = [
1104 { label: 'Stereo', enabled: false },
1105 { label: 'Director commentary', enabled: true },
1106 ];
1107 dom.window.localStorage.setItem('filemanager.video-prefs.v1.tester', JSON.stringify({
1108 subtitleTrackName: 'French',
1109 audioTrackName: 'Stereo',
1110 }));
1111
1112 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1113
1114 const tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1115 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1116 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1117
1118 expect(dom.window.localStorage.getItem('vjs-text-track-settings')).toBe(DEFAULT_VIDEO_TEXT_TRACK_SETTINGS_RAW);
1119 expect(dom.window.__lastVideoJsTextTracks.item(0).mode).toBe('disabled');
1120 expect(dom.window.__lastVideoJsTextTracks.item(1).mode).toBe('showing');
1121 expect(dom.window.__lastVideoJsAudioTracks.item(0).enabled).toBe(true);
1122 expect(dom.window.__lastVideoJsAudioTracks.item(1).enabled).toBe(false);
1123
1124 dom.window.close();
1125 });
1126
1127 test('video preview keeps default tracks when saved names are not present', async () =>
1128 {
1129 listFixture['/data'] = [
1130 {
1131 name: 'clip.mkv',
1132 path: '/data/clip.mkv',
1133 isDir: false,
1134 size: 64,
1135 mtime: Date.now(),
1136 },
1137 ];
1138 videoStreamFixture['/data/clip.mkv'] = {
1139 sessionId: 'video-session',
1140 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
1141 subtitleTracks: [
1142 { label: 'English', language: 'eng', default: true, src: '/api/files/video-stream/video-session/subtitle-0.vtt' },
1143 { label: 'French', language: 'fra', default: false, src: '/api/files/video-stream/video-session/subtitle-1.vtt' },
1144 ],
1145 subtitleSummary: { total: 2, converted: 2, skipped: 0 },
1146 };
1147
1148 const { dom, runtimeErrors } = await bootClient();
1149 expect(runtimeErrors).toEqual([]);
1150
1151 dom.window.__mockVideoJsAudioTracks = [
1152 { label: 'Stereo', enabled: false },
1153 { label: 'Director commentary', enabled: true },
1154 ];
1155 dom.window.localStorage.setItem('filemanager.video-prefs.v1.tester', JSON.stringify({
1156 subtitleTrackName: 'Spanish',
1157 audioTrackName: 'Dolby Atmos',
1158 }));
1159
1160 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1161
1162 const tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1163 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1164 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1165
1166 expect(dom.window.__lastVideoJsTextTracks.item(0).mode).toBe('showing');
1167 expect(dom.window.__lastVideoJsTextTracks.item(1).mode).toBe('disabled');
1168 expect(dom.window.__lastVideoJsAudioTracks.item(0).enabled).toBe(false);
1169 expect(dom.window.__lastVideoJsAudioTracks.item(1).enabled).toBe(true);
1170
1171 dom.window.close();
1172 });
1173
1174 test('video preview saves subtitle/audio track names per user when selection changes', async () =>
1175 {
1176 listFixture['/data'] = [
1177 {
1178 name: 'clip.mkv',
1179 path: '/data/clip.mkv',
1180 isDir: false,
1181 size: 64,
1182 mtime: Date.now(),
1183 },
1184 ];
1185 videoStreamFixture['/data/clip.mkv'] = {
1186 sessionId: 'video-session',
1187 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
1188 subtitleTracks: [
1189 { label: 'English', language: 'eng', default: true, src: '/api/files/video-stream/video-session/subtitle-0.vtt' },
1190 { label: 'French', language: 'fra', default: false, src: '/api/files/video-stream/video-session/subtitle-1.vtt' },
1191 ],
1192 subtitleSummary: { total: 2, converted: 2, skipped: 0 },
1193 };
1194
1195 const { dom, runtimeErrors } = await bootClient();
1196 expect(runtimeErrors).toEqual([]);
1197
1198 dom.window.__mockVideoJsAudioTracks = [
1199 { label: 'Stereo', enabled: true },
1200 { label: 'Director commentary', enabled: false },
1201 ];
1202
1203 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1204
1205 const tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1206 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1207 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1208
1209 dom.window.__lastVideoJsTextTracks.item(0).mode = 'disabled';
1210 dom.window.__lastVideoJsTextTracks.item(1).mode = 'showing';
1211 dom.window.__lastVideoJsTextTracks.dispatchEvent('change');
1212
1213 dom.window.__lastVideoJsAudioTracks.item(0).enabled = false;
1214 dom.window.__lastVideoJsAudioTracks.item(1).enabled = true;
1215 dom.window.__lastVideoJsAudioTracks.dispatchEvent('change');
1216
1217 const stored = JSON.parse(dom.window.localStorage.getItem('filemanager.video-prefs.v1.tester'));
1218 expect(stored.subtitleTrackName).toBe('French');
1219 expect(stored.audioTrackName).toBe('Director commentary');
1220
1221 dom.window.close();
1222 });
1223
1224 test('video preview applies default caption style per user when no saved style exists', async () =>
1225 {
1226 listFixture['/data'] = [
1227 {
1228 name: 'clip.mkv',
1229 path: '/data/clip.mkv',
1230 isDir: false,
1231 size: 64,
1232 mtime: Date.now(),
1233 },
1234 ];
1235 videoStreamFixture['/data/clip.mkv'] = {
1236 sessionId: 'video-session',
1237 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
1238 subtitleTracks: [{ label: 'English', language: 'eng', default: true, src: '/api/files/video-stream/video-session/subtitle-0.vtt' }],
1239 subtitleSummary: { total: 1, converted: 1, skipped: 0 },
1240 };
1241
1242 const { dom, runtimeErrors } = await bootClient();
1243 expect(runtimeErrors).toEqual([]);
1244
1245 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1246 const tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1247 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1248 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1249
1250 expect(dom.window.localStorage.getItem('vjs-text-track-settings')).toBe(DEFAULT_VIDEO_TEXT_TRACK_SETTINGS_RAW);
1251 const storedRaw = dom.window.localStorage.getItem('filemanager.video-prefs.v1.tester');
1252 if (storedRaw)
1253 {
1254 const stored = JSON.parse(storedRaw);
1255 expect(stored.textTrackSettings).toBeUndefined();
1256 }
1257
1258 dom.window.close();
1259 });
1260
1261 test('video preview does not save caption style settings per user on close', async () =>
1262 {
1263 listFixture['/data'] = [
1264 {
1265 name: 'clip.mkv',
1266 path: '/data/clip.mkv',
1267 isDir: false,
1268 size: 64,
1269 mtime: Date.now(),
1270 },
1271 ];
1272 videoStreamFixture['/data/clip.mkv'] = {
1273 sessionId: 'video-session',
1274 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
1275 subtitleTracks: [{ label: 'English', language: 'eng', default: true, src: '/api/files/video-stream/video-session/subtitle-0.vtt' }],
1276 subtitleSummary: { total: 1, converted: 1, skipped: 0 },
1277 };
1278
1279 const { dom, runtimeErrors } = await bootClient();
1280 expect(runtimeErrors).toEqual([]);
1281
1282 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1283 const tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1284 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1285 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1286
1287 // Simulate updated caption style persisted by Video.js internals.
1288 dom.window.localStorage.setItem('vjs-text-track-settings', '{"color":"#ffffff"}');
1289
1290 const closeBtn = dom.window.document.querySelector('.preview-expand-close');
1291 closeBtn.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
1292 await new Promise(resolve => dom.window.setTimeout(resolve, 280));
1293
1294 const storedRaw = dom.window.localStorage.getItem('filemanager.video-prefs.v1.tester');
1295 if (storedRaw)
1296 {
1297 const stored = JSON.parse(storedRaw);
1298 expect(stored.textTrackSettings).toBeUndefined();
1299 }
1300
1301 dom.window.close();
1302 });
1303});