BlueGit

timfa filemanager

Files

filemanager / tests / page.load.test.js

page.load.test.js

page.load.test.js 57.7 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 waitFor(dom, () => dom.window.document.querySelectorAll('#sidebar-actions button').length >= 4);
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 waitFor(dom, () => Array.from(dom.window.document.querySelectorAll('#sidebar-actions button')).map(b => b.textContent).join('|') === 'View / Download|Share');
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('stl tiles use a server-generated thumbnail instead of a badge', async () =>
912 {
913 listFixture = {
914 '/data': [
915 {
916 name: 'part.stl',
917 path: '/data/part.stl',
918 isDir: false,
919 size: 256,
920 mtime: Date.now(),
921 },
922 ],
923 };
924 // Thumbnail is served by the server cache endpoint (no client-side geometry parsing).
925 // thumbnailStatusFixture defaults to 200, so the endpoint returns a mock WebP blob.
926
927 const { dom, runtimeErrors } = await bootClient();
928 expect(runtimeErrors).toEqual([]);
929
930 await waitFor(dom, () => !!dom.window.document.querySelector('.icon[data-preview-path="/data/part.stl"] image'));
931
932 const icon = dom.window.document.querySelector('.icon[data-preview-path="/data/part.stl"]');
933 expect(icon).toBeTruthy();
934 expect(icon.classList.contains('thumb-pending')).toBe(false);
935 expect(icon.dataset.thumbReady).toBe('1');
936 // href is a blob URL created from the server-returned WebP
937 expect(String(icon.querySelector('image').getAttribute('href') || '')).toMatch(/^blob:/);
938
939 dom.window.close();
940 });
941
942 test('expanded file preview shows a Share button next to Download', async () =>
943 {
944 downloadFixture['/data/readme.txt'] = {
945 type: 'text/plain',
946 body: 'hello preview',
947 };
948
949 const { dom, runtimeErrors } = await bootClient();
950 expect(runtimeErrors).toEqual([]);
951
952 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/readme.txt"]'));
953
954 const fileTile = dom.window.document.querySelector('.file-item[data-path="/data/readme.txt"]');
955 expect(fileTile).toBeTruthy();
956
957 fileTile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
958 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-expand-share'));
959
960 const shareBtn = dom.window.document.querySelector('.preview-expand-share');
961 const downloadBtn = dom.window.document.querySelector('.preview-expand-download');
962 const actions = dom.window.document.querySelector('.preview-expand-actions');
963 expect(shareBtn).toBeTruthy();
964 expect(downloadBtn).toBeTruthy();
965 expect(actions).toBeTruthy();
966 expect(actions.contains(shareBtn)).toBe(true);
967 expect(actions.contains(downloadBtn)).toBe(true);
968 expect(shareBtn.textContent).toBe('Share');
969
970 dom.window.close();
971 });
972
973 test('expanded STL preview falls back gracefully when WebGL is unavailable', async () =>
974 {
975 listFixture['/data'] = [
976 {
977 name: 'part.stl',
978 path: '/data/part.stl',
979 isDir: false,
980 size: 128,
981 mtime: Date.now(),
982 },
983 ];
984 downloadFixture['/data/part.stl'] = {
985 type: 'model/stl',
986 body: 'solid part\nendsolid part\n',
987 };
988
989 const { dom, runtimeErrors } = await bootClient();
990 expect(runtimeErrors).toEqual([]);
991
992 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/part.stl"]'));
993
994 const fileTile = dom.window.document.querySelector('.file-item[data-path="/data/part.stl"]');
995 expect(fileTile).toBeTruthy();
996
997 fileTile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
998 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-expand-content .preview-unsupported'));
999
1000 const fallback = dom.window.document.querySelector('.preview-expand-content .preview-unsupported');
1001 expect(fallback.textContent).toMatch(/3d preview is not available/i);
1002
1003 dom.window.close();
1004 });
1005
1006 test('expanded STL preview does not start file drag when dragging over the preview', async () =>
1007 {
1008 listFixture['/data'] = [
1009 {
1010 name: 'part.stl',
1011 path: '/data/part.stl',
1012 isDir: false,
1013 size: 128,
1014 mtime: Date.now(),
1015 },
1016 ];
1017 downloadFixture['/data/part.stl'] = {
1018 type: 'model/stl',
1019 body: 'solid part\nendsolid part\n',
1020 };
1021
1022 const { dom, runtimeErrors } = await bootClient();
1023 expect(runtimeErrors).toEqual([]);
1024
1025 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/part.stl"]'));
1026
1027 const fileTile = dom.window.document.querySelector('.file-item[data-path="/data/part.stl"]');
1028 fileTile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1029 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item--preview'));
1030
1031 const previewTile = dom.window.document.querySelector('.file-item--preview');
1032 previewTile.dispatchEvent(new dom.window.MouseEvent('pointerdown', {
1033 bubbles: true,
1034 button: 0,
1035 clientX: 100,
1036 clientY: 100,
1037 }));
1038 dom.window.document.dispatchEvent(new dom.window.MouseEvent('pointermove', {
1039 bubbles: true,
1040 clientX: 140,
1041 clientY: 140,
1042 }));
1043
1044 await new Promise(resolve => dom.window.setTimeout(resolve, 40));
1045 expect(previewTile.classList.contains('dragging')).toBe(false);
1046
1047 dom.window.close();
1048 });
1049
1050 test('expanded video preview uses a stream session and video.js', async () =>
1051 {
1052 listFixture['/data'] = [
1053 {
1054 name: 'clip.mkv',
1055 path: '/data/clip.mkv',
1056 isDir: false,
1057 size: 64,
1058 mtime: Date.now(),
1059 },
1060 ];
1061 videoStreamFixture['/data/clip.mkv'] = {
1062 sessionId: 'video-session',
1063 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
1064 durationSeconds: 120,
1065 subtitleTracks: [{ label: 'English', language: 'eng', default: true, src: '/api/files/video-stream/video-session/subtitle-0.vtt' }],
1066 };
1067
1068 const { dom, runtimeErrors } = await bootClient();
1069 expect(runtimeErrors).toEqual([]);
1070
1071 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1072
1073 const fileTile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1074 expect(fileTile).toBeTruthy();
1075
1076 fileTile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1077 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1078
1079 expect(dom.window.__lastVideoJsOptions).toBeTruthy();
1080 expect(dom.window.__lastVideoJsOptions.sources[0].src).toBe('/api/files/video-stream/video-session/master.m3u8');
1081 expect(dom.window.__lastVideoJsOptions.fluid).toBe(false);
1082 expect(dom.window.__lastVideoJsOptions.fill).toBe(true);
1083 expect(dom.window.__lastVideoJsOptions.controlBar).toMatchObject({
1084 currentTimeDisplay: true,
1085 timeDivider: true,
1086 durationDisplay: true,
1087 remainingTimeDisplay: false,
1088 });
1089 expect(dom.window.__lastVideoJsPlayer.duration()).toBe(120);
1090 expect(dom.window.__lastVideoJsOptions.tracks).toEqual([
1091 {
1092 kind: 'subtitles',
1093 src: '/api/files/video-stream/video-session/subtitle-0.vtt',
1094 srclang: 'eng',
1095 label: 'English',
1096 default: true,
1097 },
1098 ]);
1099
1100 dom.window.close();
1101 });
1102
1103 test('video preview does not close on backdrop click and closes via X button', async () =>
1104 {
1105 listFixture['/data'] = [
1106 {
1107 name: 'clip.mkv',
1108 path: '/data/clip.mkv',
1109 isDir: false,
1110 size: 64,
1111 mtime: Date.now(),
1112 },
1113 ];
1114 videoStreamFixture['/data/clip.mkv'] = {
1115 sessionId: 'video-session',
1116 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
1117 subtitleTracks: [],
1118 subtitleSummary: { total: 0, converted: 0, skipped: 0 },
1119 };
1120
1121 const { dom, runtimeErrors } = await bootClient();
1122 expect(runtimeErrors).toEqual([]);
1123
1124 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1125
1126 const tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1127 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1128 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-backdrop'));
1129
1130 const backdrop = dom.window.document.querySelector('.preview-backdrop');
1131 backdrop.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
1132 await new Promise(resolve => dom.window.setTimeout(resolve, 40));
1133
1134 expect(dom.window.document.querySelector('.preview-backdrop')).toBeTruthy();
1135
1136 const closeBtn = dom.window.document.querySelector('.preview-expand-close');
1137 closeBtn.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
1138 await new Promise(resolve => dom.window.setTimeout(resolve, 280));
1139
1140 expect(dom.window.document.querySelector('.preview-backdrop')).toBeNull();
1141
1142 dom.window.close();
1143 });
1144
1145 test('video preview releases the backend stream session when closed', async () =>
1146 {
1147 listFixture['/data'] = [
1148 {
1149 name: 'clip.mkv',
1150 path: '/data/clip.mkv',
1151 isDir: false,
1152 size: 64,
1153 mtime: Date.now(),
1154 },
1155 ];
1156 videoStreamFixture['/data/clip.mkv'] = {
1157 sessionId: 'video-session',
1158 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
1159 subtitleTracks: [],
1160 subtitleSummary: { total: 0, converted: 0, skipped: 0 },
1161 };
1162
1163 const { dom, runtimeErrors } = await bootClient();
1164 expect(runtimeErrors).toEqual([]);
1165
1166 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1167
1168 const tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1169 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1170 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1171
1172 const closeBtn = dom.window.document.querySelector('.preview-expand-close');
1173 closeBtn.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
1174 await waitFor(dom, () => releasedVideoStreamSessions.includes('video-session'));
1175
1176 dom.window.close();
1177 });
1178
1179 test('video preview restores per-user saved volume preference', async () =>
1180 {
1181 listFixture['/data'] = [
1182 {
1183 name: 'clip.mkv',
1184 path: '/data/clip.mkv',
1185 isDir: false,
1186 size: 64,
1187 mtime: Date.now(),
1188 },
1189 ];
1190 videoStreamFixture['/data/clip.mkv'] = {
1191 sessionId: 'video-session',
1192 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
1193 subtitleTracks: [],
1194 subtitleSummary: { total: 0, converted: 0, skipped: 0 },
1195 };
1196
1197 const { dom, runtimeErrors } = await bootClient();
1198 expect(runtimeErrors).toEqual([]);
1199
1200 dom.window.localStorage.setItem('filemanager.video-prefs.v1.tester', JSON.stringify({ volume: 0.3 }));
1201
1202 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1203
1204 const tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1205 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1206 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1207
1208 expect(dom.window.__lastVideoJsVolumeSet).toBe(0.3);
1209
1210 dom.window.close();
1211 });
1212
1213 test('video preview restores saved subtitle/audio track names when available', async () =>
1214 {
1215 listFixture['/data'] = [
1216 {
1217 name: 'clip.mkv',
1218 path: '/data/clip.mkv',
1219 isDir: false,
1220 size: 64,
1221 mtime: Date.now(),
1222 },
1223 ];
1224 videoStreamFixture['/data/clip.mkv'] = {
1225 sessionId: 'video-session',
1226 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
1227 subtitleTracks: [
1228 { label: 'English', language: 'eng', default: true, src: '/api/files/video-stream/video-session/subtitle-0.vtt' },
1229 { label: 'French', language: 'fra', default: false, src: '/api/files/video-stream/video-session/subtitle-1.vtt' },
1230 ],
1231 subtitleSummary: { total: 2, converted: 2, skipped: 0 },
1232 };
1233
1234 const { dom, runtimeErrors } = await bootClient();
1235 expect(runtimeErrors).toEqual([]);
1236
1237 dom.window.__mockVideoJsAudioTracks = [
1238 { label: 'Stereo', enabled: false },
1239 { label: 'Director commentary', enabled: true },
1240 ];
1241 dom.window.localStorage.setItem('filemanager.video-prefs.v1.tester', JSON.stringify({
1242 subtitleTrackName: 'French',
1243 audioTrackName: 'Stereo',
1244 }));
1245
1246 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1247
1248 const tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1249 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1250 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1251
1252 expect(dom.window.localStorage.getItem('vjs-text-track-settings')).toBe(DEFAULT_VIDEO_TEXT_TRACK_SETTINGS_RAW);
1253 expect(dom.window.__lastVideoJsTextTracks.item(0).mode).toBe('disabled');
1254 expect(dom.window.__lastVideoJsTextTracks.item(1).mode).toBe('showing');
1255 expect(dom.window.__lastVideoJsAudioTracks.item(0).enabled).toBe(true);
1256 expect(dom.window.__lastVideoJsAudioTracks.item(1).enabled).toBe(false);
1257
1258 dom.window.close();
1259 });
1260
1261 test('video preview keeps default tracks when saved names are not present', 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: [
1276 { label: 'English', language: 'eng', default: true, src: '/api/files/video-stream/video-session/subtitle-0.vtt' },
1277 { label: 'French', language: 'fra', default: false, src: '/api/files/video-stream/video-session/subtitle-1.vtt' },
1278 ],
1279 subtitleSummary: { total: 2, converted: 2, skipped: 0 },
1280 };
1281
1282 const { dom, runtimeErrors } = await bootClient();
1283 expect(runtimeErrors).toEqual([]);
1284
1285 dom.window.__mockVideoJsAudioTracks = [
1286 { label: 'Stereo', enabled: false },
1287 { label: 'Director commentary', enabled: true },
1288 ];
1289 dom.window.localStorage.setItem('filemanager.video-prefs.v1.tester', JSON.stringify({
1290 subtitleTrackName: 'Spanish',
1291 audioTrackName: 'Dolby Atmos',
1292 }));
1293
1294 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1295
1296 const tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1297 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1298 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1299
1300 expect(dom.window.__lastVideoJsTextTracks.item(0).mode).toBe('showing');
1301 expect(dom.window.__lastVideoJsTextTracks.item(1).mode).toBe('disabled');
1302 expect(dom.window.__lastVideoJsAudioTracks.item(0).enabled).toBe(false);
1303 expect(dom.window.__lastVideoJsAudioTracks.item(1).enabled).toBe(true);
1304
1305 dom.window.close();
1306 });
1307
1308 test('video preview saves subtitle/audio track names per user when selection changes', async () =>
1309 {
1310 listFixture['/data'] = [
1311 {
1312 name: 'clip.mkv',
1313 path: '/data/clip.mkv',
1314 isDir: false,
1315 size: 64,
1316 mtime: Date.now(),
1317 },
1318 ];
1319 videoStreamFixture['/data/clip.mkv'] = {
1320 sessionId: 'video-session',
1321 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
1322 subtitleTracks: [
1323 { label: 'English', language: 'eng', default: true, src: '/api/files/video-stream/video-session/subtitle-0.vtt' },
1324 { label: 'French', language: 'fra', default: false, src: '/api/files/video-stream/video-session/subtitle-1.vtt' },
1325 ],
1326 subtitleSummary: { total: 2, converted: 2, skipped: 0 },
1327 };
1328
1329 const { dom, runtimeErrors } = await bootClient();
1330 expect(runtimeErrors).toEqual([]);
1331
1332 dom.window.__mockVideoJsAudioTracks = [
1333 { label: 'Stereo', enabled: true },
1334 { label: 'Director commentary', enabled: false },
1335 ];
1336
1337 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1338
1339 const tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1340 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1341 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1342
1343 dom.window.__lastVideoJsTextTracks.item(0).mode = 'disabled';
1344 dom.window.__lastVideoJsTextTracks.item(1).mode = 'showing';
1345 dom.window.__lastVideoJsTextTracks.dispatchEvent('change');
1346
1347 dom.window.__lastVideoJsAudioTracks.item(0).enabled = false;
1348 dom.window.__lastVideoJsAudioTracks.item(1).enabled = true;
1349 dom.window.__lastVideoJsAudioTracks.dispatchEvent('change');
1350
1351 const stored = JSON.parse(dom.window.localStorage.getItem('filemanager.video-prefs.v1.tester'));
1352 expect(stored.subtitleTrackName).toBe('French');
1353 expect(stored.audioTrackName).toBe('Director commentary');
1354
1355 dom.window.close();
1356 });
1357
1358 test('video preview applies default caption style per user when no saved style exists', async () =>
1359 {
1360 listFixture['/data'] = [
1361 {
1362 name: 'clip.mkv',
1363 path: '/data/clip.mkv',
1364 isDir: false,
1365 size: 64,
1366 mtime: Date.now(),
1367 },
1368 ];
1369 videoStreamFixture['/data/clip.mkv'] = {
1370 sessionId: 'video-session',
1371 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
1372 subtitleTracks: [{ label: 'English', language: 'eng', default: true, src: '/api/files/video-stream/video-session/subtitle-0.vtt' }],
1373 subtitleSummary: { total: 1, converted: 1, skipped: 0 },
1374 };
1375
1376 const { dom, runtimeErrors } = await bootClient();
1377 expect(runtimeErrors).toEqual([]);
1378
1379 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1380 const tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1381 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1382 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1383
1384 expect(dom.window.localStorage.getItem('vjs-text-track-settings')).toBe(DEFAULT_VIDEO_TEXT_TRACK_SETTINGS_RAW);
1385 const storedRaw = dom.window.localStorage.getItem('filemanager.video-prefs.v1.tester');
1386 if (storedRaw)
1387 {
1388 const stored = JSON.parse(storedRaw);
1389 expect(stored.textTrackSettings).toBeUndefined();
1390 }
1391
1392 dom.window.close();
1393 });
1394
1395 test('video preview does not save caption style settings per user on close', async () =>
1396 {
1397 listFixture['/data'] = [
1398 {
1399 name: 'clip.mkv',
1400 path: '/data/clip.mkv',
1401 isDir: false,
1402 size: 64,
1403 mtime: Date.now(),
1404 },
1405 ];
1406 videoStreamFixture['/data/clip.mkv'] = {
1407 sessionId: 'video-session',
1408 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
1409 subtitleTracks: [{ label: 'English', language: 'eng', default: true, src: '/api/files/video-stream/video-session/subtitle-0.vtt' }],
1410 subtitleSummary: { total: 1, converted: 1, skipped: 0 },
1411 };
1412
1413 const { dom, runtimeErrors } = await bootClient();
1414 expect(runtimeErrors).toEqual([]);
1415
1416 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1417 const tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1418 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1419 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1420
1421 // Simulate updated caption style persisted by Video.js internals.
1422 dom.window.localStorage.setItem('vjs-text-track-settings', '{"color":"#ffffff"}');
1423
1424 const closeBtn = dom.window.document.querySelector('.preview-expand-close');
1425 closeBtn.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
1426 await new Promise(resolve => dom.window.setTimeout(resolve, 280));
1427
1428 const storedRaw = dom.window.localStorage.getItem('filemanager.video-prefs.v1.tester');
1429 if (storedRaw)
1430 {
1431 const stored = JSON.parse(storedRaw);
1432 expect(stored.textTrackSettings).toBeUndefined();
1433 }
1434
1435 dom.window.close();
1436 });
1437});