BlueGit

timfa filemanager

Files

filemanager / tests / page.load.test.js

page.load.test.js

page.load.test.js 53.4 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('shows pending icon spinner when video thumbnail cache is not ready', async () =>
724 {
725 listFixture = {
726 '/data': [
727 {
728 name: 'clip.mp4',
729 path: '/data/clip.mp4',
730 isDir: false,
731 size: 5 * 1024 * 1024,
732 mtime: Date.now(),
733 },
734 ],
735 };
736 thumbnailStatusFixture['/data/clip.mp4'] = 404;
737
738 const { dom, runtimeErrors } = await bootClient();
739 expect(runtimeErrors).toEqual([]);
740
741 await new Promise(resolve => dom.window.setTimeout(resolve, 80));
742 const icon = dom.window.document.querySelector('.icon[data-preview-path="/data/clip.mp4"]');
743 expect(icon).toBeTruthy();
744 expect(icon.classList.contains('thumb-pending')).toBe(true);
745
746 dom.window.close();
747 });
748
749 test('rapid file reselection does not duplicate sidebar action buttons after delayed metadata', async () =>
750 {
751 listFixture = {
752 '/data': [
753 {
754 name: 'first.txt',
755 path: '/data/first.txt',
756 isDir: false,
757 size: 10,
758 mtime: Date.now(),
759 },
760 {
761 name: 'second.txt',
762 path: '/data/second.txt',
763 isDir: false,
764 size: 20,
765 mtime: Date.now(),
766 },
767 ],
768 };
769 metaDelayMsFixture['/data/first.txt'] = 120;
770
771 const { dom, runtimeErrors } = await bootClient();
772 expect(runtimeErrors).toEqual([]);
773
774 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/first.txt"]'));
775 const firstTile = dom.window.document.querySelector('.file-item[data-path="/data/first.txt"]');
776 const secondTile = dom.window.document.querySelector('.file-item[data-path="/data/second.txt"]');
777 expect(firstTile).toBeTruthy();
778 expect(secondTile).toBeTruthy();
779
780 firstTile.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
781 await new Promise(resolve => dom.window.setTimeout(resolve, 10));
782 secondTile.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
783
784 await new Promise(resolve => dom.window.setTimeout(resolve, 220));
785
786 const actionButtons = Array.from(dom.window.document.querySelectorAll('#sidebar-actions button')).map(b => b.textContent);
787 expect(actionButtons).toEqual(['View / Download', 'Share']);
788
789 dom.window.close();
790 });
791
792 test('video tiles show centred watched overlays after watched metadata is loaded', async () =>
793 {
794 listFixture = {
795 '/data': [
796 {
797 name: 'watched-full.mkv',
798 path: '/data/watched-full.mkv',
799 isDir: false,
800 size: 100,
801 mtime: Date.now(),
802 },
803 {
804 name: 'watched-part.mkv',
805 path: '/data/watched-part.mkv',
806 isDir: false,
807 size: 100,
808 mtime: Date.now(),
809 },
810 ],
811 };
812 metaWatchedByFixture['/data/watched-full.mkv'] = { tester: 'fully' };
813 metaWatchedByFixture['/data/watched-part.mkv'] = { tester: 'partway' };
814
815 const { dom, runtimeErrors } = await bootClient();
816 expect(runtimeErrors).toEqual([]);
817
818 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/watched-full.mkv"] .watched-overlay--fully'));
819
820 const fullOverlayPath = dom.window.document.querySelector('.file-item[data-path="/data/watched-full.mkv"] .watched-overlay--fully path');
821 const partOverlayPath = dom.window.document.querySelector('.file-item[data-path="/data/watched-part.mkv"] .watched-overlay--partway path');
822
823 expect(fullOverlayPath).toBeTruthy();
824 expect(fullOverlayPath.getAttribute('fill')).toBe('#ffffff');
825
826 expect(partOverlayPath).toBeTruthy();
827 expect(partOverlayPath.getAttribute('fill')).toBe('#ffffff');
828 expect(partOverlayPath.getAttribute('stroke')).toBeNull();
829
830 dom.window.close();
831 });
832
833 test('admin user modal locks write checkbox while read is unchecked', async () =>
834 {
835 meFixture = { username: 'admin', isAdmin: true, permissions: {} };
836 adminConfigFixture = { port: 3000, paths: ['/data'], effectivePaths: ['/data'] };
837 adminUsersFixture = {
838 users: [
839 {
840 id: 9,
841 username: 'guest',
842 isAdmin: false,
843 permissions: { data: { read: false, write: true } },
844 },
845 ],
846 };
847
848 const { dom, runtimeErrors } = await bootClient();
849 expect(runtimeErrors).toEqual([]);
850
851 dom.window.document.getElementById('btn-admin').dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
852 await new Promise(resolve => dom.window.setTimeout(resolve, 80));
853
854 const editBtn = dom.window.document.querySelector('#admin-users-list [data-action="edit"]');
855 expect(editBtn).toBeTruthy();
856 editBtn.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
857 await new Promise(resolve => dom.window.setTimeout(resolve, 40));
858
859 const readCb = dom.window.document.querySelector('input[data-label="data"][data-type="read"]');
860 const writeCb = dom.window.document.querySelector('input[data-label="data"][data-type="write"]');
861 expect(readCb).toBeTruthy();
862 expect(writeCb).toBeTruthy();
863 expect(readCb.checked).toBe(false);
864 expect(writeCb.checked).toBe(false);
865 expect(writeCb.disabled).toBe(true);
866
867 readCb.checked = true;
868 readCb.dispatchEvent(new dom.window.Event('change', { bubbles: true }));
869 expect(writeCb.disabled).toBe(false);
870
871 writeCb.checked = true;
872 readCb.checked = false;
873 readCb.dispatchEvent(new dom.window.Event('change', { bubbles: true }));
874 expect(writeCb.checked).toBe(false);
875 expect(writeCb.disabled).toBe(true);
876
877 dom.window.close();
878 });
879
880 test('uses direct svg thumbnail when svg file is under 1MB', async () =>
881 {
882 listFixture = {
883 '/data': [
884 {
885 name: 'icon.svg',
886 path: '/data/icon.svg',
887 isDir: false,
888 size: 400 * 1024,
889 mtime: Date.now(),
890 },
891 ],
892 };
893 thumbnailStatusFixture['/data/icon.svg'] = 404;
894 downloadFixture['/data/icon.svg'] = {
895 type: 'image/svg+xml',
896 body: '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 10 10"><rect width="10" height="10" fill="red"/></svg>',
897 };
898
899 const { dom, runtimeErrors } = await bootClient();
900 expect(runtimeErrors).toEqual([]);
901
902 await new Promise(resolve => dom.window.setTimeout(resolve, 80));
903 const icon = dom.window.document.querySelector('.icon[data-preview-path="/data/icon.svg"]');
904 expect(icon).toBeTruthy();
905 expect(icon.classList.contains('thumb-pending')).toBe(false);
906 expect(icon.dataset.thumbReady).toBe('1');
907
908 dom.window.close();
909 });
910
911 test('expanded file preview shows a Share button next to Download', async () =>
912 {
913 downloadFixture['/data/readme.txt'] = {
914 type: 'text/plain',
915 body: 'hello preview',
916 };
917
918 const { dom, runtimeErrors } = await bootClient();
919 expect(runtimeErrors).toEqual([]);
920
921 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/readme.txt"]'));
922
923 const fileTile = dom.window.document.querySelector('.file-item[data-path="/data/readme.txt"]');
924 expect(fileTile).toBeTruthy();
925
926 fileTile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
927 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-expand-share'));
928
929 const shareBtn = dom.window.document.querySelector('.preview-expand-share');
930 const downloadBtn = dom.window.document.querySelector('.preview-expand-download');
931 const actions = dom.window.document.querySelector('.preview-expand-actions');
932 expect(shareBtn).toBeTruthy();
933 expect(downloadBtn).toBeTruthy();
934 expect(actions).toBeTruthy();
935 expect(actions.contains(shareBtn)).toBe(true);
936 expect(actions.contains(downloadBtn)).toBe(true);
937 expect(shareBtn.textContent).toBe('Share');
938
939 dom.window.close();
940 });
941
942 test('expanded video preview uses a stream session and video.js', async () =>
943 {
944 listFixture['/data'] = [
945 {
946 name: 'clip.mkv',
947 path: '/data/clip.mkv',
948 isDir: false,
949 size: 64,
950 mtime: Date.now(),
951 },
952 ];
953 videoStreamFixture['/data/clip.mkv'] = {
954 sessionId: 'video-session',
955 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
956 durationSeconds: 120,
957 subtitleTracks: [{ label: 'English', language: 'eng', default: true, src: '/api/files/video-stream/video-session/subtitle-0.vtt' }],
958 };
959
960 const { dom, runtimeErrors } = await bootClient();
961 expect(runtimeErrors).toEqual([]);
962
963 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
964
965 const fileTile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
966 expect(fileTile).toBeTruthy();
967
968 fileTile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
969 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
970
971 expect(dom.window.__lastVideoJsOptions).toBeTruthy();
972 expect(dom.window.__lastVideoJsOptions.sources[0].src).toBe('/api/files/video-stream/video-session/master.m3u8');
973 expect(dom.window.__lastVideoJsOptions.fluid).toBe(false);
974 expect(dom.window.__lastVideoJsOptions.fill).toBe(true);
975 expect(dom.window.__lastVideoJsOptions.controlBar).toMatchObject({
976 currentTimeDisplay: true,
977 timeDivider: true,
978 durationDisplay: true,
979 remainingTimeDisplay: false,
980 });
981 expect(dom.window.__lastVideoJsPlayer.duration()).toBe(120);
982 expect(dom.window.__lastVideoJsOptions.tracks).toEqual([
983 {
984 kind: 'subtitles',
985 src: '/api/files/video-stream/video-session/subtitle-0.vtt',
986 srclang: 'eng',
987 label: 'English',
988 default: true,
989 },
990 ]);
991
992 dom.window.close();
993 });
994
995 test('video preview does not close on backdrop click and closes via X button', async () =>
996 {
997 listFixture['/data'] = [
998 {
999 name: 'clip.mkv',
1000 path: '/data/clip.mkv',
1001 isDir: false,
1002 size: 64,
1003 mtime: Date.now(),
1004 },
1005 ];
1006 videoStreamFixture['/data/clip.mkv'] = {
1007 sessionId: 'video-session',
1008 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
1009 subtitleTracks: [],
1010 subtitleSummary: { total: 0, converted: 0, skipped: 0 },
1011 };
1012
1013 const { dom, runtimeErrors } = await bootClient();
1014 expect(runtimeErrors).toEqual([]);
1015
1016 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1017
1018 const tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1019 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1020 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-backdrop'));
1021
1022 const backdrop = dom.window.document.querySelector('.preview-backdrop');
1023 backdrop.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
1024 await new Promise(resolve => dom.window.setTimeout(resolve, 40));
1025
1026 expect(dom.window.document.querySelector('.preview-backdrop')).toBeTruthy();
1027
1028 const closeBtn = dom.window.document.querySelector('.preview-expand-close');
1029 closeBtn.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
1030 await new Promise(resolve => dom.window.setTimeout(resolve, 280));
1031
1032 expect(dom.window.document.querySelector('.preview-backdrop')).toBeNull();
1033
1034 dom.window.close();
1035 });
1036
1037 test('video preview releases the backend stream session when closed', async () =>
1038 {
1039 listFixture['/data'] = [
1040 {
1041 name: 'clip.mkv',
1042 path: '/data/clip.mkv',
1043 isDir: false,
1044 size: 64,
1045 mtime: Date.now(),
1046 },
1047 ];
1048 videoStreamFixture['/data/clip.mkv'] = {
1049 sessionId: 'video-session',
1050 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
1051 subtitleTracks: [],
1052 subtitleSummary: { total: 0, converted: 0, skipped: 0 },
1053 };
1054
1055 const { dom, runtimeErrors } = await bootClient();
1056 expect(runtimeErrors).toEqual([]);
1057
1058 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1059
1060 const tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1061 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1062 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1063
1064 const closeBtn = dom.window.document.querySelector('.preview-expand-close');
1065 closeBtn.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
1066 await waitFor(dom, () => releasedVideoStreamSessions.includes('video-session'));
1067
1068 dom.window.close();
1069 });
1070
1071 test('video preview restores per-user saved volume preference', async () =>
1072 {
1073 listFixture['/data'] = [
1074 {
1075 name: 'clip.mkv',
1076 path: '/data/clip.mkv',
1077 isDir: false,
1078 size: 64,
1079 mtime: Date.now(),
1080 },
1081 ];
1082 videoStreamFixture['/data/clip.mkv'] = {
1083 sessionId: 'video-session',
1084 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
1085 subtitleTracks: [],
1086 subtitleSummary: { total: 0, converted: 0, skipped: 0 },
1087 };
1088
1089 const { dom, runtimeErrors } = await bootClient();
1090 expect(runtimeErrors).toEqual([]);
1091
1092 dom.window.localStorage.setItem('filemanager.video-prefs.v1.tester', JSON.stringify({ volume: 0.3 }));
1093
1094 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1095
1096 const tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1097 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1098 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1099
1100 expect(dom.window.__lastVideoJsVolumeSet).toBe(0.3);
1101
1102 dom.window.close();
1103 });
1104
1105 test('video preview restores saved subtitle/audio track names when available', async () =>
1106 {
1107 listFixture['/data'] = [
1108 {
1109 name: 'clip.mkv',
1110 path: '/data/clip.mkv',
1111 isDir: false,
1112 size: 64,
1113 mtime: Date.now(),
1114 },
1115 ];
1116 videoStreamFixture['/data/clip.mkv'] = {
1117 sessionId: 'video-session',
1118 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
1119 subtitleTracks: [
1120 { label: 'English', language: 'eng', default: true, src: '/api/files/video-stream/video-session/subtitle-0.vtt' },
1121 { label: 'French', language: 'fra', default: false, src: '/api/files/video-stream/video-session/subtitle-1.vtt' },
1122 ],
1123 subtitleSummary: { total: 2, converted: 2, skipped: 0 },
1124 };
1125
1126 const { dom, runtimeErrors } = await bootClient();
1127 expect(runtimeErrors).toEqual([]);
1128
1129 dom.window.__mockVideoJsAudioTracks = [
1130 { label: 'Stereo', enabled: false },
1131 { label: 'Director commentary', enabled: true },
1132 ];
1133 dom.window.localStorage.setItem('filemanager.video-prefs.v1.tester', JSON.stringify({
1134 subtitleTrackName: 'French',
1135 audioTrackName: 'Stereo',
1136 }));
1137
1138 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1139
1140 const tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1141 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1142 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1143
1144 expect(dom.window.localStorage.getItem('vjs-text-track-settings')).toBe(DEFAULT_VIDEO_TEXT_TRACK_SETTINGS_RAW);
1145 expect(dom.window.__lastVideoJsTextTracks.item(0).mode).toBe('disabled');
1146 expect(dom.window.__lastVideoJsTextTracks.item(1).mode).toBe('showing');
1147 expect(dom.window.__lastVideoJsAudioTracks.item(0).enabled).toBe(true);
1148 expect(dom.window.__lastVideoJsAudioTracks.item(1).enabled).toBe(false);
1149
1150 dom.window.close();
1151 });
1152
1153 test('video preview keeps default tracks when saved names are not present', async () =>
1154 {
1155 listFixture['/data'] = [
1156 {
1157 name: 'clip.mkv',
1158 path: '/data/clip.mkv',
1159 isDir: false,
1160 size: 64,
1161 mtime: Date.now(),
1162 },
1163 ];
1164 videoStreamFixture['/data/clip.mkv'] = {
1165 sessionId: 'video-session',
1166 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
1167 subtitleTracks: [
1168 { label: 'English', language: 'eng', default: true, src: '/api/files/video-stream/video-session/subtitle-0.vtt' },
1169 { label: 'French', language: 'fra', default: false, src: '/api/files/video-stream/video-session/subtitle-1.vtt' },
1170 ],
1171 subtitleSummary: { total: 2, converted: 2, skipped: 0 },
1172 };
1173
1174 const { dom, runtimeErrors } = await bootClient();
1175 expect(runtimeErrors).toEqual([]);
1176
1177 dom.window.__mockVideoJsAudioTracks = [
1178 { label: 'Stereo', enabled: false },
1179 { label: 'Director commentary', enabled: true },
1180 ];
1181 dom.window.localStorage.setItem('filemanager.video-prefs.v1.tester', JSON.stringify({
1182 subtitleTrackName: 'Spanish',
1183 audioTrackName: 'Dolby Atmos',
1184 }));
1185
1186 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1187
1188 const tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1189 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1190 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1191
1192 expect(dom.window.__lastVideoJsTextTracks.item(0).mode).toBe('showing');
1193 expect(dom.window.__lastVideoJsTextTracks.item(1).mode).toBe('disabled');
1194 expect(dom.window.__lastVideoJsAudioTracks.item(0).enabled).toBe(false);
1195 expect(dom.window.__lastVideoJsAudioTracks.item(1).enabled).toBe(true);
1196
1197 dom.window.close();
1198 });
1199
1200 test('video preview saves subtitle/audio track names per user when selection changes', async () =>
1201 {
1202 listFixture['/data'] = [
1203 {
1204 name: 'clip.mkv',
1205 path: '/data/clip.mkv',
1206 isDir: false,
1207 size: 64,
1208 mtime: Date.now(),
1209 },
1210 ];
1211 videoStreamFixture['/data/clip.mkv'] = {
1212 sessionId: 'video-session',
1213 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
1214 subtitleTracks: [
1215 { label: 'English', language: 'eng', default: true, src: '/api/files/video-stream/video-session/subtitle-0.vtt' },
1216 { label: 'French', language: 'fra', default: false, src: '/api/files/video-stream/video-session/subtitle-1.vtt' },
1217 ],
1218 subtitleSummary: { total: 2, converted: 2, skipped: 0 },
1219 };
1220
1221 const { dom, runtimeErrors } = await bootClient();
1222 expect(runtimeErrors).toEqual([]);
1223
1224 dom.window.__mockVideoJsAudioTracks = [
1225 { label: 'Stereo', enabled: true },
1226 { label: 'Director commentary', enabled: false },
1227 ];
1228
1229 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1230
1231 const tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1232 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1233 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1234
1235 dom.window.__lastVideoJsTextTracks.item(0).mode = 'disabled';
1236 dom.window.__lastVideoJsTextTracks.item(1).mode = 'showing';
1237 dom.window.__lastVideoJsTextTracks.dispatchEvent('change');
1238
1239 dom.window.__lastVideoJsAudioTracks.item(0).enabled = false;
1240 dom.window.__lastVideoJsAudioTracks.item(1).enabled = true;
1241 dom.window.__lastVideoJsAudioTracks.dispatchEvent('change');
1242
1243 const stored = JSON.parse(dom.window.localStorage.getItem('filemanager.video-prefs.v1.tester'));
1244 expect(stored.subtitleTrackName).toBe('French');
1245 expect(stored.audioTrackName).toBe('Director commentary');
1246
1247 dom.window.close();
1248 });
1249
1250 test('video preview applies default caption style per user when no saved style exists', async () =>
1251 {
1252 listFixture['/data'] = [
1253 {
1254 name: 'clip.mkv',
1255 path: '/data/clip.mkv',
1256 isDir: false,
1257 size: 64,
1258 mtime: Date.now(),
1259 },
1260 ];
1261 videoStreamFixture['/data/clip.mkv'] = {
1262 sessionId: 'video-session',
1263 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
1264 subtitleTracks: [{ label: 'English', language: 'eng', default: true, src: '/api/files/video-stream/video-session/subtitle-0.vtt' }],
1265 subtitleSummary: { total: 1, converted: 1, skipped: 0 },
1266 };
1267
1268 const { dom, runtimeErrors } = await bootClient();
1269 expect(runtimeErrors).toEqual([]);
1270
1271 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1272 const tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1273 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1274 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1275
1276 expect(dom.window.localStorage.getItem('vjs-text-track-settings')).toBe(DEFAULT_VIDEO_TEXT_TRACK_SETTINGS_RAW);
1277 const storedRaw = dom.window.localStorage.getItem('filemanager.video-prefs.v1.tester');
1278 if (storedRaw)
1279 {
1280 const stored = JSON.parse(storedRaw);
1281 expect(stored.textTrackSettings).toBeUndefined();
1282 }
1283
1284 dom.window.close();
1285 });
1286
1287 test('video preview does not save caption style settings per user on close', async () =>
1288 {
1289 listFixture['/data'] = [
1290 {
1291 name: 'clip.mkv',
1292 path: '/data/clip.mkv',
1293 isDir: false,
1294 size: 64,
1295 mtime: Date.now(),
1296 },
1297 ];
1298 videoStreamFixture['/data/clip.mkv'] = {
1299 sessionId: 'video-session',
1300 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
1301 subtitleTracks: [{ label: 'English', language: 'eng', default: true, src: '/api/files/video-stream/video-session/subtitle-0.vtt' }],
1302 subtitleSummary: { total: 1, converted: 1, skipped: 0 },
1303 };
1304
1305 const { dom, runtimeErrors } = await bootClient();
1306 expect(runtimeErrors).toEqual([]);
1307
1308 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1309 const tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1310 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1311 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1312
1313 // Simulate updated caption style persisted by Video.js internals.
1314 dom.window.localStorage.setItem('vjs-text-track-settings', '{"color":"#ffffff"}');
1315
1316 const closeBtn = dom.window.document.querySelector('.preview-expand-close');
1317 closeBtn.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
1318 await new Promise(resolve => dom.window.setTimeout(resolve, 280));
1319
1320 const storedRaw = dom.window.localStorage.getItem('filemanager.video-prefs.v1.tester');
1321 if (storedRaw)
1322 {
1323 const stored = JSON.parse(storedRaw);
1324 expect(stored.textTrackSettings).toBeUndefined();
1325 }
1326
1327 dom.window.close();
1328 });
1329});