BlueGit

timfa filemanager

Files

filemanager / tests / page.load.test.js

page.load.test.js

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