BlueGit

timfa filemanager

Files

filemanager / tests / page.load.test.js

page.load.test.js

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