BlueGit

timfa filemanager

Files

filemanager / tests / page.load.test.js

page.load.test.js

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