BlueGit

timfa filemanager

Files

filemanager / tests / page.load.test.js

page.load.test.js

page.load.test.js 62.9 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 user modal disables admin checkbox when editing own account', async () =>
888 {
889 meFixture = { username: 'admin', isAdmin: true, permissions: {} };
890 adminConfigFixture = { port: 3000, paths: ['/data'], effectivePaths: ['/data'] };
891 adminUsersFixture = {
892 users: [
893 {
894 id: 1,
895 username: 'admin',
896 isAdmin: true,
897 permissions: {},
898 },
899 ],
900 };
901
902 const { dom, runtimeErrors } = await bootClient();
903 expect(runtimeErrors).toEqual([]);
904
905 dom.window.document.getElementById('btn-admin').dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
906 await new Promise(resolve => dom.window.setTimeout(resolve, 80));
907
908 const editBtn = dom.window.document.querySelector('#admin-users-list [data-action="edit"]');
909 expect(editBtn).toBeTruthy();
910 editBtn.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
911 await new Promise(resolve => dom.window.setTimeout(resolve, 40));
912
913 const adminCb = dom.window.document.getElementById('user-is-admin');
914 expect(adminCb).toBeTruthy();
915 expect(adminCb.checked).toBe(true);
916 expect(adminCb.disabled).toBe(true);
917
918 dom.window.close();
919 });
920
921 test('admin topbar shows update badge after login when updates are available', async () =>
922 {
923 meFixture = { username: 'admin', isAdmin: true, permissions: {} };
924 updateStatusFixture = {
925 underSystemd: true,
926 commitsAhead: ['a1b2c3 Update one', 'd4e5f6 Update two'],
927 };
928
929 const { dom, runtimeErrors } = await bootClient();
930 expect(runtimeErrors).toEqual([]);
931
932 await waitFor(dom, () => dom.window.document.getElementById('admin-update-badge').textContent === '2');
933
934 const badge = dom.window.document.getElementById('admin-update-badge');
935 expect(badge.classList.contains('hidden')).toBe(false);
936 expect(badge.textContent).toBe('2');
937
938 dom.window.close();
939 });
940
941 test('opening admin panel with updates scrolls to and highlights the update button', async () =>
942 {
943 meFixture = { username: 'admin', isAdmin: true, permissions: {} };
944 updateStatusFixture = {
945 underSystemd: true,
946 commitsAhead: ['a1b2c3 Update one'],
947 };
948
949 const { dom, runtimeErrors } = await bootClient();
950 expect(runtimeErrors).toEqual([]);
951
952 const adminBtn = dom.window.document.getElementById('btn-admin');
953 adminBtn.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
954
955 await waitFor(dom, () =>
956 {
957 const shutdownBtn = dom.window.document.getElementById('admin-shutdown-btn');
958 return shutdownBtn && shutdownBtn.classList.contains('admin-update-highlight');
959 });
960
961 const shutdownBtn = dom.window.document.getElementById('admin-shutdown-btn');
962 expect(shutdownBtn.textContent).toBe('Restart & Update');
963 expect(shutdownBtn.classList.contains('admin-update-highlight')).toBe(true);
964 expect(dom.window.__lastScrollIntoViewId).toBe('admin-shutdown-btn');
965
966 dom.window.close();
967 });
968
969 test('uses direct svg thumbnail when svg file is under 1MB', async () =>
970 {
971 listFixture = {
972 '/data': [
973 {
974 name: 'icon.svg',
975 path: '/data/icon.svg',
976 isDir: false,
977 size: 400 * 1024,
978 mtime: Date.now(),
979 },
980 ],
981 };
982 thumbnailStatusFixture['/data/icon.svg'] = 404;
983 downloadFixture['/data/icon.svg'] = {
984 type: 'image/svg+xml',
985 body: '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 10 10"><rect width="10" height="10" fill="red"/></svg>',
986 };
987
988 const { dom, runtimeErrors } = await bootClient();
989 expect(runtimeErrors).toEqual([]);
990
991 await new Promise(resolve => dom.window.setTimeout(resolve, 80));
992 const icon = dom.window.document.querySelector('.icon[data-preview-path="/data/icon.svg"]');
993 expect(icon).toBeTruthy();
994 expect(icon.classList.contains('thumb-pending')).toBe(false);
995 expect(icon.dataset.thumbReady).toBe('1');
996
997 dom.window.close();
998 });
999
1000 test('stl tiles use a server-generated thumbnail instead of a badge', async () =>
1001 {
1002 listFixture = {
1003 '/data': [
1004 {
1005 name: 'part.stl',
1006 path: '/data/part.stl',
1007 isDir: false,
1008 size: 256,
1009 mtime: Date.now(),
1010 },
1011 ],
1012 };
1013 // Thumbnail is served by the server cache endpoint (no client-side geometry parsing).
1014 // thumbnailStatusFixture defaults to 200, so the endpoint returns a mock WebP blob.
1015
1016 const { dom, runtimeErrors } = await bootClient();
1017 expect(runtimeErrors).toEqual([]);
1018
1019 await waitFor(dom, () => !!dom.window.document.querySelector('.icon[data-preview-path="/data/part.stl"] image'));
1020
1021 const icon = dom.window.document.querySelector('.icon[data-preview-path="/data/part.stl"]');
1022 expect(icon).toBeTruthy();
1023 expect(icon.classList.contains('thumb-pending')).toBe(false);
1024 expect(icon.dataset.thumbReady).toBe('1');
1025 // href is a blob URL created from the server-returned WebP
1026 expect(String(icon.querySelector('image').getAttribute('href') || '')).toMatch(/^blob:/);
1027
1028 dom.window.close();
1029 });
1030
1031 test('expanded file preview shows a Share button next to Download', async () =>
1032 {
1033 downloadFixture['/data/readme.txt'] = {
1034 type: 'text/plain',
1035 body: 'hello preview',
1036 };
1037
1038 const { dom, runtimeErrors } = await bootClient();
1039 expect(runtimeErrors).toEqual([]);
1040
1041 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/readme.txt"]'));
1042
1043 const fileTile = dom.window.document.querySelector('.file-item[data-path="/data/readme.txt"]');
1044 expect(fileTile).toBeTruthy();
1045
1046 fileTile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1047 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-expand-share'));
1048
1049 const shareBtn = dom.window.document.querySelector('.preview-expand-share');
1050 const downloadBtn = dom.window.document.querySelector('.preview-expand-download');
1051 const actions = dom.window.document.querySelector('.preview-expand-actions');
1052 expect(shareBtn).toBeTruthy();
1053 expect(downloadBtn).toBeTruthy();
1054 expect(actions).toBeTruthy();
1055 expect(actions.contains(shareBtn)).toBe(true);
1056 expect(actions.contains(downloadBtn)).toBe(true);
1057 expect(shareBtn.textContent).toBe('Share');
1058
1059 dom.window.close();
1060 });
1061
1062 test('expanded STL preview falls back gracefully when WebGL is unavailable', async () =>
1063 {
1064 listFixture['/data'] = [
1065 {
1066 name: 'part.stl',
1067 path: '/data/part.stl',
1068 isDir: false,
1069 size: 128,
1070 mtime: Date.now(),
1071 },
1072 ];
1073 downloadFixture['/data/part.stl'] = {
1074 type: 'model/stl',
1075 body: 'solid part\nendsolid part\n',
1076 };
1077
1078 const { dom, runtimeErrors } = await bootClient();
1079 expect(runtimeErrors).toEqual([]);
1080
1081 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/part.stl"]'));
1082
1083 const fileTile = dom.window.document.querySelector('.file-item[data-path="/data/part.stl"]');
1084 expect(fileTile).toBeTruthy();
1085
1086 fileTile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1087 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-expand-content .preview-unsupported'));
1088
1089 const fallback = dom.window.document.querySelector('.preview-expand-content .preview-unsupported');
1090 expect(fallback.textContent).toMatch(/3d preview is not available/i);
1091
1092 dom.window.close();
1093 });
1094
1095 test('expanded STL preview does not start file drag when dragging over the preview', async () =>
1096 {
1097 listFixture['/data'] = [
1098 {
1099 name: 'part.stl',
1100 path: '/data/part.stl',
1101 isDir: false,
1102 size: 128,
1103 mtime: Date.now(),
1104 },
1105 ];
1106 downloadFixture['/data/part.stl'] = {
1107 type: 'model/stl',
1108 body: 'solid part\nendsolid part\n',
1109 };
1110
1111 const { dom, runtimeErrors } = await bootClient();
1112 expect(runtimeErrors).toEqual([]);
1113
1114 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/part.stl"]'));
1115
1116 const fileTile = dom.window.document.querySelector('.file-item[data-path="/data/part.stl"]');
1117 fileTile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1118 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item--preview'));
1119
1120 const previewTile = dom.window.document.querySelector('.file-item--preview');
1121 previewTile.dispatchEvent(new dom.window.MouseEvent('pointerdown', {
1122 bubbles: true,
1123 button: 0,
1124 clientX: 100,
1125 clientY: 100,
1126 }));
1127 dom.window.document.dispatchEvent(new dom.window.MouseEvent('pointermove', {
1128 bubbles: true,
1129 clientX: 140,
1130 clientY: 140,
1131 }));
1132
1133 await new Promise(resolve => dom.window.setTimeout(resolve, 40));
1134 expect(previewTile.classList.contains('dragging')).toBe(false);
1135
1136 dom.window.close();
1137 });
1138
1139 test('expanded file preview keeps the surrounding tiles in place', async () =>
1140 {
1141 listFixture['/data'] = [
1142 {
1143 name: 'alpha.txt',
1144 path: '/data/alpha.txt',
1145 isDir: false,
1146 size: 12,
1147 mtime: Date.now(),
1148 },
1149 {
1150 name: 'beta.txt',
1151 path: '/data/beta.txt',
1152 isDir: false,
1153 size: 12,
1154 mtime: Date.now(),
1155 },
1156 ];
1157 downloadFixture['/data/alpha.txt'] = {
1158 type: 'text/plain',
1159 body: 'hello preview',
1160 };
1161
1162 const { dom, runtimeErrors } = await bootClient();
1163 expect(runtimeErrors).toEqual([]);
1164
1165 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/alpha.txt"]'));
1166
1167 const firstTile = dom.window.document.querySelector('.file-item[data-path="/data/alpha.txt"]');
1168 firstTile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1169
1170 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item--preview'));
1171
1172 const grid = dom.window.document.getElementById('file-grid');
1173 expect(grid.children.length).toBe(2);
1174 expect(grid.children[0].classList.contains('file-item--preview-placeholder')).toBe(true);
1175 expect(grid.children[1].dataset.path).toBe('/data/beta.txt');
1176 expect(dom.window.document.body.querySelector('.file-item--preview')).toBeTruthy();
1177
1178 dom.window.close();
1179 });
1180
1181 test('expanded video preview uses a stream session and video.js', async () =>
1182 {
1183 listFixture['/data'] = [
1184 {
1185 name: 'clip.mkv',
1186 path: '/data/clip.mkv',
1187 isDir: false,
1188 size: 64,
1189 mtime: Date.now(),
1190 },
1191 ];
1192 videoStreamFixture['/data/clip.mkv'] = {
1193 sessionId: 'video-session',
1194 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
1195 durationSeconds: 120,
1196 subtitleTracks: [{ label: 'English', language: 'eng', default: true, src: '/api/files/video-stream/video-session/subtitle-0.vtt' }],
1197 };
1198
1199 const { dom, runtimeErrors } = await bootClient();
1200 expect(runtimeErrors).toEqual([]);
1201
1202 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1203
1204 const fileTile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1205 expect(fileTile).toBeTruthy();
1206
1207 fileTile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1208 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1209
1210 expect(dom.window.__lastVideoJsOptions).toBeTruthy();
1211 expect(dom.window.__lastVideoJsOptions.sources[0].src).toBe('/api/files/video-stream/video-session/master.m3u8');
1212 expect(dom.window.__lastVideoJsOptions.fluid).toBe(false);
1213 expect(dom.window.__lastVideoJsOptions.fill).toBe(true);
1214 expect(dom.window.__lastVideoJsOptions.controlBar).toMatchObject({
1215 currentTimeDisplay: true,
1216 timeDivider: true,
1217 durationDisplay: true,
1218 remainingTimeDisplay: false,
1219 });
1220 expect(dom.window.__lastVideoJsPlayer.duration()).toBe(120);
1221 expect(dom.window.__lastVideoJsOptions.tracks).toEqual([
1222 {
1223 kind: 'subtitles',
1224 src: '/api/files/video-stream/video-session/subtitle-0.vtt',
1225 srclang: 'eng',
1226 label: 'English',
1227 default: true,
1228 },
1229 ]);
1230
1231 dom.window.close();
1232 });
1233
1234 test('video preview does not close on backdrop click and closes via X button', async () =>
1235 {
1236 listFixture['/data'] = [
1237 {
1238 name: 'clip.mkv',
1239 path: '/data/clip.mkv',
1240 isDir: false,
1241 size: 64,
1242 mtime: Date.now(),
1243 },
1244 ];
1245 videoStreamFixture['/data/clip.mkv'] = {
1246 sessionId: 'video-session',
1247 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
1248 subtitleTracks: [],
1249 subtitleSummary: { total: 0, converted: 0, skipped: 0 },
1250 };
1251
1252 const { dom, runtimeErrors } = await bootClient();
1253 expect(runtimeErrors).toEqual([]);
1254
1255 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1256
1257 const tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1258 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1259 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-backdrop'));
1260
1261 const backdrop = dom.window.document.querySelector('.preview-backdrop');
1262 backdrop.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
1263 await new Promise(resolve => dom.window.setTimeout(resolve, 40));
1264
1265 expect(dom.window.document.querySelector('.preview-backdrop')).toBeTruthy();
1266
1267 const closeBtn = dom.window.document.querySelector('.preview-expand-close');
1268 closeBtn.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
1269 await new Promise(resolve => dom.window.setTimeout(resolve, 280));
1270
1271 expect(dom.window.document.querySelector('.preview-backdrop')).toBeNull();
1272
1273 dom.window.close();
1274 });
1275
1276 test('video preview releases the backend stream session when closed', 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 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1298
1299 const tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1300 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1301 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1302
1303 const closeBtn = dom.window.document.querySelector('.preview-expand-close');
1304 closeBtn.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
1305 await waitFor(dom, () => releasedVideoStreamSessions.includes('video-session'));
1306
1307 dom.window.close();
1308 });
1309
1310 test('video preview restores per-user saved volume preference', 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 subtitleSummary: { total: 0, converted: 0, skipped: 0 },
1326 };
1327
1328 const { dom, runtimeErrors } = await bootClient();
1329 expect(runtimeErrors).toEqual([]);
1330
1331 dom.window.localStorage.setItem('filemanager.video-prefs.v1.tester', JSON.stringify({ volume: 0.3 }));
1332
1333 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1334
1335 const tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1336 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1337 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1338
1339 expect(dom.window.__lastVideoJsVolumeSet).toBe(0.3);
1340
1341 dom.window.close();
1342 });
1343
1344 test('video preview restores saved subtitle/audio track names when available', async () =>
1345 {
1346 listFixture['/data'] = [
1347 {
1348 name: 'clip.mkv',
1349 path: '/data/clip.mkv',
1350 isDir: false,
1351 size: 64,
1352 mtime: Date.now(),
1353 },
1354 ];
1355 videoStreamFixture['/data/clip.mkv'] = {
1356 sessionId: 'video-session',
1357 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
1358 subtitleTracks: [
1359 { label: 'English', language: 'eng', default: true, src: '/api/files/video-stream/video-session/subtitle-0.vtt' },
1360 { label: 'French', language: 'fra', default: false, src: '/api/files/video-stream/video-session/subtitle-1.vtt' },
1361 ],
1362 subtitleSummary: { total: 2, converted: 2, skipped: 0 },
1363 };
1364
1365 const { dom, runtimeErrors } = await bootClient();
1366 expect(runtimeErrors).toEqual([]);
1367
1368 dom.window.__mockVideoJsAudioTracks = [
1369 { label: 'Stereo', enabled: false },
1370 { label: 'Director commentary', enabled: true },
1371 ];
1372 dom.window.localStorage.setItem('filemanager.video-prefs.v1.tester', JSON.stringify({
1373 subtitleTrackName: 'French',
1374 audioTrackName: 'Stereo',
1375 }));
1376
1377 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1378
1379 const tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1380 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1381 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1382
1383 expect(dom.window.localStorage.getItem('vjs-text-track-settings')).toBe(DEFAULT_VIDEO_TEXT_TRACK_SETTINGS_RAW);
1384 expect(dom.window.__lastVideoJsTextTracks.item(0).mode).toBe('disabled');
1385 expect(dom.window.__lastVideoJsTextTracks.item(1).mode).toBe('showing');
1386 expect(dom.window.__lastVideoJsAudioTracks.item(0).enabled).toBe(true);
1387 expect(dom.window.__lastVideoJsAudioTracks.item(1).enabled).toBe(false);
1388
1389 dom.window.close();
1390 });
1391
1392 test('video preview keeps default tracks when saved names are not present', async () =>
1393 {
1394 listFixture['/data'] = [
1395 {
1396 name: 'clip.mkv',
1397 path: '/data/clip.mkv',
1398 isDir: false,
1399 size: 64,
1400 mtime: Date.now(),
1401 },
1402 ];
1403 videoStreamFixture['/data/clip.mkv'] = {
1404 sessionId: 'video-session',
1405 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
1406 subtitleTracks: [
1407 { label: 'English', language: 'eng', default: true, src: '/api/files/video-stream/video-session/subtitle-0.vtt' },
1408 { label: 'French', language: 'fra', default: false, src: '/api/files/video-stream/video-session/subtitle-1.vtt' },
1409 ],
1410 subtitleSummary: { total: 2, converted: 2, skipped: 0 },
1411 };
1412
1413 const { dom, runtimeErrors } = await bootClient();
1414 expect(runtimeErrors).toEqual([]);
1415
1416 dom.window.__mockVideoJsAudioTracks = [
1417 { label: 'Stereo', enabled: false },
1418 { label: 'Director commentary', enabled: true },
1419 ];
1420 dom.window.localStorage.setItem('filemanager.video-prefs.v1.tester', JSON.stringify({
1421 subtitleTrackName: 'Spanish',
1422 audioTrackName: 'Dolby Atmos',
1423 }));
1424
1425 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1426
1427 const tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1428 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1429 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1430
1431 expect(dom.window.__lastVideoJsTextTracks.item(0).mode).toBe('showing');
1432 expect(dom.window.__lastVideoJsTextTracks.item(1).mode).toBe('disabled');
1433 expect(dom.window.__lastVideoJsAudioTracks.item(0).enabled).toBe(false);
1434 expect(dom.window.__lastVideoJsAudioTracks.item(1).enabled).toBe(true);
1435
1436 dom.window.close();
1437 });
1438
1439 test('video preview saves subtitle/audio track names per user when selection changes', async () =>
1440 {
1441 listFixture['/data'] = [
1442 {
1443 name: 'clip.mkv',
1444 path: '/data/clip.mkv',
1445 isDir: false,
1446 size: 64,
1447 mtime: Date.now(),
1448 },
1449 ];
1450 videoStreamFixture['/data/clip.mkv'] = {
1451 sessionId: 'video-session',
1452 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
1453 subtitleTracks: [
1454 { label: 'English', language: 'eng', default: true, src: '/api/files/video-stream/video-session/subtitle-0.vtt' },
1455 { label: 'French', language: 'fra', default: false, src: '/api/files/video-stream/video-session/subtitle-1.vtt' },
1456 ],
1457 subtitleSummary: { total: 2, converted: 2, skipped: 0 },
1458 };
1459
1460 const { dom, runtimeErrors } = await bootClient();
1461 expect(runtimeErrors).toEqual([]);
1462
1463 dom.window.__mockVideoJsAudioTracks = [
1464 { label: 'Stereo', enabled: true },
1465 { label: 'Director commentary', enabled: false },
1466 ];
1467
1468 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1469
1470 const tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1471 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1472 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1473
1474 dom.window.__lastVideoJsTextTracks.item(0).mode = 'disabled';
1475 dom.window.__lastVideoJsTextTracks.item(1).mode = 'showing';
1476 dom.window.__lastVideoJsTextTracks.dispatchEvent('change');
1477
1478 dom.window.__lastVideoJsAudioTracks.item(0).enabled = false;
1479 dom.window.__lastVideoJsAudioTracks.item(1).enabled = true;
1480 dom.window.__lastVideoJsAudioTracks.dispatchEvent('change');
1481
1482 const stored = JSON.parse(dom.window.localStorage.getItem('filemanager.video-prefs.v1.tester'));
1483 expect(stored.subtitleTrackName).toBe('French');
1484 expect(stored.audioTrackName).toBe('Director commentary');
1485
1486 dom.window.close();
1487 });
1488
1489 test('video preview applies default caption style per user when no saved style exists', async () =>
1490 {
1491 listFixture['/data'] = [
1492 {
1493 name: 'clip.mkv',
1494 path: '/data/clip.mkv',
1495 isDir: false,
1496 size: 64,
1497 mtime: Date.now(),
1498 },
1499 ];
1500 videoStreamFixture['/data/clip.mkv'] = {
1501 sessionId: 'video-session',
1502 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
1503 subtitleTracks: [{ label: 'English', language: 'eng', default: true, src: '/api/files/video-stream/video-session/subtitle-0.vtt' }],
1504 subtitleSummary: { total: 1, converted: 1, skipped: 0 },
1505 };
1506
1507 const { dom, runtimeErrors } = await bootClient();
1508 expect(runtimeErrors).toEqual([]);
1509
1510 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1511 const tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1512 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1513 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1514
1515 expect(dom.window.localStorage.getItem('vjs-text-track-settings')).toBe(DEFAULT_VIDEO_TEXT_TRACK_SETTINGS_RAW);
1516 const storedRaw = dom.window.localStorage.getItem('filemanager.video-prefs.v1.tester');
1517 if (storedRaw)
1518 {
1519 const stored = JSON.parse(storedRaw);
1520 expect(stored.textTrackSettings).toBeUndefined();
1521 }
1522
1523 dom.window.close();
1524 });
1525
1526 test('video preview does not save caption style settings per user on close', async () =>
1527 {
1528 listFixture['/data'] = [
1529 {
1530 name: 'clip.mkv',
1531 path: '/data/clip.mkv',
1532 isDir: false,
1533 size: 64,
1534 mtime: Date.now(),
1535 },
1536 ];
1537 videoStreamFixture['/data/clip.mkv'] = {
1538 sessionId: 'video-session',
1539 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
1540 subtitleTracks: [{ label: 'English', language: 'eng', default: true, src: '/api/files/video-stream/video-session/subtitle-0.vtt' }],
1541 subtitleSummary: { total: 1, converted: 1, skipped: 0 },
1542 };
1543
1544 const { dom, runtimeErrors } = await bootClient();
1545 expect(runtimeErrors).toEqual([]);
1546
1547 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1548 const tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1549 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1550 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1551
1552 // Simulate updated caption style persisted by Video.js internals.
1553 dom.window.localStorage.setItem('vjs-text-track-settings', '{"color":"#ffffff"}');
1554
1555 const closeBtn = dom.window.document.querySelector('.preview-expand-close');
1556 closeBtn.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
1557 await new Promise(resolve => dom.window.setTimeout(resolve, 280));
1558
1559 const storedRaw = dom.window.localStorage.getItem('filemanager.video-prefs.v1.tester');
1560 if (storedRaw)
1561 {
1562 const stored = JSON.parse(storedRaw);
1563 expect(stored.textTrackSettings).toBeUndefined();
1564 }
1565
1566 dom.window.close();
1567 });
1568});