BlueGit

timfa filemanager

Files

filemanager / tests / page.load.test.js

page.load.test.js

8fd0f82d History
page.load.test.js 65.6 KiB Download Raw
1'use strict';
2
3const express = require('express');
4const http = require('http');
5const path = require('path');
6const { once } = require('events');
7const { webcrypto } = require('crypto');
8
9const DEFAULT_VIDEO_TEXT_TRACK_SETTINGS_RAW = JSON.stringify({
10 backgroundOpacity: '0',
11 edgeStyle: 'uniform',
12});
13
14describe('page load smoke test', () =>
15{
16 let server;
17 let baseUrl;
18 let JSDOM;
19 let VirtualConsole;
20 let rootsFixture;
21 let listFixture;
22 let spaceFixture;
23 let meFixture;
24 let thumbnailStatusFixture;
25 let rootAccessFixture;
26 let folderIconFixture;
27 let adminUsersFixture;
28 let 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('shows pending icon spinner when image thumbnail cache is not ready', async () =>
708 {
709 listFixture = {
710 '/data': [
711 {
712 name: 'photo.png',
713 path: '/data/photo.png',
714 isDir: false,
715 size: 1024,
716 mtime: Date.now(),
717 },
718 ],
719 };
720 thumbnailStatusFixture['/data/photo.png'] = 404;
721
722 const { dom, runtimeErrors } = await bootClient();
723 expect(runtimeErrors).toEqual([]);
724
725 await new Promise(resolve => dom.window.setTimeout(resolve, 80));
726 const icon = dom.window.document.querySelector('.icon[data-preview-path="/data/photo.png"]');
727 expect(icon).toBeTruthy();
728 expect(icon.classList.contains('thumb-pending')).toBe(true);
729
730 dom.window.close();
731 });
732
733 test('shows pending icon spinner when video thumbnail cache is not ready', async () =>
734 {
735 listFixture = {
736 '/data': [
737 {
738 name: 'clip.mp4',
739 path: '/data/clip.mp4',
740 isDir: false,
741 size: 5 * 1024 * 1024,
742 mtime: Date.now(),
743 },
744 ],
745 };
746 thumbnailStatusFixture['/data/clip.mp4'] = 404;
747
748 const { dom, runtimeErrors } = await bootClient();
749 expect(runtimeErrors).toEqual([]);
750
751 await new Promise(resolve => dom.window.setTimeout(resolve, 80));
752 const icon = dom.window.document.querySelector('.icon[data-preview-path="/data/clip.mp4"]');
753 expect(icon).toBeTruthy();
754 expect(icon.classList.contains('thumb-pending')).toBe(true);
755
756 dom.window.close();
757 });
758
759 test('rapid file reselection does not duplicate sidebar action buttons after delayed metadata', async () =>
760 {
761 listFixture = {
762 '/data': [
763 {
764 name: 'first.txt',
765 path: '/data/first.txt',
766 isDir: false,
767 size: 10,
768 mtime: Date.now(),
769 },
770 {
771 name: 'second.txt',
772 path: '/data/second.txt',
773 isDir: false,
774 size: 20,
775 mtime: Date.now(),
776 },
777 ],
778 };
779 metaDelayMsFixture['/data/first.txt'] = 120;
780
781 const { dom, runtimeErrors } = await bootClient();
782 expect(runtimeErrors).toEqual([]);
783
784 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/first.txt"]'));
785 const firstTile = dom.window.document.querySelector('.file-item[data-path="/data/first.txt"]');
786 const secondTile = dom.window.document.querySelector('.file-item[data-path="/data/second.txt"]');
787 expect(firstTile).toBeTruthy();
788 expect(secondTile).toBeTruthy();
789
790 firstTile.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
791 await new Promise(resolve => dom.window.setTimeout(resolve, 10));
792 secondTile.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
793
794 await waitFor(dom, () => Array.from(dom.window.document.querySelectorAll('#sidebar-actions button')).map(b => b.textContent).join('|') === 'View / Download|Share');
795
796 const actionButtons = Array.from(dom.window.document.querySelectorAll('#sidebar-actions button')).map(b => b.textContent);
797 expect(actionButtons).toEqual(['View / Download', 'Share']);
798
799 dom.window.close();
800 });
801
802 test('video tiles show centred watched overlays after watched metadata is loaded', async () =>
803 {
804 listFixture = {
805 '/data': [
806 {
807 name: 'watched-full.mkv',
808 path: '/data/watched-full.mkv',
809 isDir: false,
810 size: 100,
811 mtime: Date.now(),
812 },
813 {
814 name: 'watched-part.mkv',
815 path: '/data/watched-part.mkv',
816 isDir: false,
817 size: 100,
818 mtime: Date.now(),
819 },
820 ],
821 };
822 metaWatchedByFixture['/data/watched-full.mkv'] = { tester: 'fully' };
823 metaWatchedByFixture['/data/watched-part.mkv'] = { tester: 'partway' };
824
825 const { dom, runtimeErrors } = await bootClient();
826 expect(runtimeErrors).toEqual([]);
827
828 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/watched-full.mkv"] .watched-overlay--fully'));
829
830 const fullOverlayPath = dom.window.document.querySelector('.file-item[data-path="/data/watched-full.mkv"] .watched-overlay--fully path');
831 const partOverlayPath = dom.window.document.querySelector('.file-item[data-path="/data/watched-part.mkv"] .watched-overlay--partway path');
832
833 expect(fullOverlayPath).toBeTruthy();
834 expect(fullOverlayPath.getAttribute('fill')).toBe('#ffffff');
835
836 expect(partOverlayPath).toBeTruthy();
837 expect(partOverlayPath.getAttribute('fill')).toBe('#ffffff');
838 expect(partOverlayPath.getAttribute('stroke')).toBeNull();
839
840 dom.window.close();
841 });
842
843 test('admin user modal locks write checkbox while read is unchecked', async () =>
844 {
845 meFixture = { username: 'admin', isAdmin: true, permissions: {} };
846 adminConfigFixture = { port: 3000, paths: ['/data'], effectivePaths: ['/data'] };
847 adminUsersFixture = {
848 users: [
849 {
850 id: 9,
851 username: 'guest',
852 isAdmin: false,
853 permissions: { data: { read: false, write: true } },
854 },
855 ],
856 };
857
858 const { dom, runtimeErrors } = await bootClient();
859 expect(runtimeErrors).toEqual([]);
860
861 dom.window.document.getElementById('btn-admin').dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
862 await new Promise(resolve => dom.window.setTimeout(resolve, 80));
863
864 const editBtn = dom.window.document.querySelector('#admin-users-list [data-action="edit"]');
865 expect(editBtn).toBeTruthy();
866 editBtn.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
867 await new Promise(resolve => dom.window.setTimeout(resolve, 40));
868
869 const readCb = dom.window.document.querySelector('input[data-label="data"][data-type="read"]');
870 const writeCb = dom.window.document.querySelector('input[data-label="data"][data-type="write"]');
871 expect(readCb).toBeTruthy();
872 expect(writeCb).toBeTruthy();
873 expect(readCb.checked).toBe(false);
874 expect(writeCb.checked).toBe(false);
875 expect(writeCb.disabled).toBe(true);
876
877 readCb.checked = true;
878 readCb.dispatchEvent(new dom.window.Event('change', { bubbles: true }));
879 expect(writeCb.disabled).toBe(false);
880
881 writeCb.checked = true;
882 readCb.checked = false;
883 readCb.dispatchEvent(new dom.window.Event('change', { bubbles: true }));
884 expect(writeCb.checked).toBe(false);
885 expect(writeCb.disabled).toBe(true);
886
887 dom.window.close();
888 });
889
890 test('admin user modal disables admin checkbox when editing own account', async () =>
891 {
892 meFixture = { username: 'admin', isAdmin: true, permissions: {} };
893 adminConfigFixture = { port: 3000, paths: ['/data'], effectivePaths: ['/data'] };
894 adminUsersFixture = {
895 users: [
896 {
897 id: 1,
898 username: 'admin',
899 isAdmin: true,
900 permissions: {},
901 },
902 ],
903 };
904
905 const { dom, runtimeErrors } = await bootClient();
906 expect(runtimeErrors).toEqual([]);
907
908 dom.window.document.getElementById('btn-admin').dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
909 await new Promise(resolve => dom.window.setTimeout(resolve, 80));
910
911 const editBtn = dom.window.document.querySelector('#admin-users-list [data-action="edit"]');
912 expect(editBtn).toBeTruthy();
913 editBtn.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
914 await new Promise(resolve => dom.window.setTimeout(resolve, 40));
915
916 const adminCb = dom.window.document.getElementById('user-is-admin');
917 expect(adminCb).toBeTruthy();
918 expect(adminCb.checked).toBe(true);
919 expect(adminCb.disabled).toBe(true);
920
921 dom.window.close();
922 });
923
924 test('admin panel hides orphaned user folders subsection when there are no orphan folders', async () =>
925 {
926 meFixture = { username: 'admin', isAdmin: true, permissions: {} };
927 orphanUserFoldersFixture = { folders: [] };
928
929 const { dom, runtimeErrors } = await bootClient();
930 expect(runtimeErrors).toEqual([]);
931
932 dom.window.document.getElementById('btn-admin').dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
933 await new Promise(resolve => dom.window.setTimeout(resolve, 80));
934
935 const section = dom.window.document.getElementById('admin-orphan-userfolders-section');
936 expect(section).toBeTruthy();
937 expect(section.classList.contains('hidden')).toBe(true);
938
939 dom.window.close();
940 });
941
942 test('admin panel lists orphaned user folders and open button navigates into that folder', async () =>
943 {
944 meFixture = { username: 'admin', isAdmin: true, permissions: {} };
945 orphanUserFoldersFixture = {
946 folders: [
947 {
948 folderName: 'ghost-user',
949 path: '/userfolders/ghost-user',
950 itemCount: 1,
951 },
952 ],
953 };
954 listFixture['/userfolders/ghost-user'] = [
955 {
956 name: 'leftover.txt',
957 path: '/userfolders/ghost-user/leftover.txt',
958 isDir: false,
959 size: 20,
960 mtime: Date.now(),
961 },
962 ];
963
964 const { dom, runtimeErrors } = await bootClient();
965 expect(runtimeErrors).toEqual([]);
966
967 dom.window.document.getElementById('btn-admin').dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
968 await new Promise(resolve => dom.window.setTimeout(resolve, 80));
969
970 const section = dom.window.document.getElementById('admin-orphan-userfolders-section');
971 expect(section.classList.contains('hidden')).toBe(false);
972
973 const openBtn = dom.window.document.querySelector('#admin-orphan-userfolders-list [data-action="open-orphan-folder"]');
974 expect(openBtn).toBeTruthy();
975 openBtn.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
976
977 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/userfolders/ghost-user/leftover.txt"]'));
978 expect(dom.window.document.getElementById('admin-modal').classList.contains('hidden')).toBe(true);
979
980 dom.window.close();
981 });
982
983 test('admin topbar shows update badge after login when updates are available', async () =>
984 {
985 meFixture = { username: 'admin', isAdmin: true, permissions: {} };
986 updateStatusFixture = {
987 underSystemd: true,
988 commitsAhead: ['a1b2c3 Update one', 'd4e5f6 Update two'],
989 };
990
991 const { dom, runtimeErrors } = await bootClient();
992 expect(runtimeErrors).toEqual([]);
993
994 await waitFor(dom, () => dom.window.document.getElementById('admin-update-badge').textContent === '2');
995
996 const badge = dom.window.document.getElementById('admin-update-badge');
997 expect(badge.classList.contains('hidden')).toBe(false);
998 expect(badge.textContent).toBe('2');
999
1000 dom.window.close();
1001 });
1002
1003 test('opening admin panel with updates scrolls to and highlights the update button', async () =>
1004 {
1005 meFixture = { username: 'admin', isAdmin: true, permissions: {} };
1006 updateStatusFixture = {
1007 underSystemd: true,
1008 commitsAhead: ['a1b2c3 Update one'],
1009 };
1010
1011 const { dom, runtimeErrors } = await bootClient();
1012 expect(runtimeErrors).toEqual([]);
1013
1014 const adminBtn = dom.window.document.getElementById('btn-admin');
1015 adminBtn.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
1016
1017 await waitFor(dom, () =>
1018 {
1019 const shutdownBtn = dom.window.document.getElementById('admin-shutdown-btn');
1020 return shutdownBtn && shutdownBtn.classList.contains('admin-update-highlight');
1021 });
1022
1023 const shutdownBtn = dom.window.document.getElementById('admin-shutdown-btn');
1024 expect(shutdownBtn.textContent).toBe('Restart & Update');
1025 expect(shutdownBtn.classList.contains('admin-update-highlight')).toBe(true);
1026 expect(dom.window.__lastScrollIntoViewId).toBe('admin-shutdown-btn');
1027
1028 dom.window.close();
1029 });
1030
1031 test('uses direct svg thumbnail when svg file is under 1MB', async () =>
1032 {
1033 listFixture = {
1034 '/data': [
1035 {
1036 name: 'icon.svg',
1037 path: '/data/icon.svg',
1038 isDir: false,
1039 size: 400 * 1024,
1040 mtime: Date.now(),
1041 },
1042 ],
1043 };
1044 thumbnailStatusFixture['/data/icon.svg'] = 404;
1045 downloadFixture['/data/icon.svg'] = {
1046 type: 'image/svg+xml',
1047 body: '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 10 10"><rect width="10" height="10" fill="red"/></svg>',
1048 };
1049
1050 const { dom, runtimeErrors } = await bootClient();
1051 expect(runtimeErrors).toEqual([]);
1052
1053 await new Promise(resolve => dom.window.setTimeout(resolve, 80));
1054 const icon = dom.window.document.querySelector('.icon[data-preview-path="/data/icon.svg"]');
1055 expect(icon).toBeTruthy();
1056 expect(icon.classList.contains('thumb-pending')).toBe(false);
1057 expect(icon.dataset.thumbReady).toBe('1');
1058
1059 dom.window.close();
1060 });
1061
1062 test('stl tiles use a server-generated thumbnail instead of a badge', async () =>
1063 {
1064 listFixture = {
1065 '/data': [
1066 {
1067 name: 'part.stl',
1068 path: '/data/part.stl',
1069 isDir: false,
1070 size: 256,
1071 mtime: Date.now(),
1072 },
1073 ],
1074 };
1075 // Thumbnail is served by the server cache endpoint (no client-side geometry parsing).
1076 // thumbnailStatusFixture defaults to 200, so the endpoint returns a mock WebP blob.
1077
1078 const { dom, runtimeErrors } = await bootClient();
1079 expect(runtimeErrors).toEqual([]);
1080
1081 await waitFor(dom, () => !!dom.window.document.querySelector('.icon[data-preview-path="/data/part.stl"] image'));
1082
1083 const icon = dom.window.document.querySelector('.icon[data-preview-path="/data/part.stl"]');
1084 expect(icon).toBeTruthy();
1085 expect(icon.classList.contains('thumb-pending')).toBe(false);
1086 expect(icon.dataset.thumbReady).toBe('1');
1087 // href is a blob URL created from the server-returned WebP
1088 expect(String(icon.querySelector('image').getAttribute('href') || '')).toMatch(/^blob:/);
1089
1090 dom.window.close();
1091 });
1092
1093 test('expanded file preview shows a Share button next to Download', async () =>
1094 {
1095 downloadFixture['/data/readme.txt'] = {
1096 type: 'text/plain',
1097 body: 'hello preview',
1098 };
1099
1100 const { dom, runtimeErrors } = await bootClient();
1101 expect(runtimeErrors).toEqual([]);
1102
1103 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/readme.txt"]'));
1104
1105 const fileTile = dom.window.document.querySelector('.file-item[data-path="/data/readme.txt"]');
1106 expect(fileTile).toBeTruthy();
1107
1108 fileTile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1109 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-expand-share'));
1110
1111 const shareBtn = dom.window.document.querySelector('.preview-expand-share');
1112 const downloadBtn = dom.window.document.querySelector('.preview-expand-download');
1113 const actions = dom.window.document.querySelector('.preview-expand-actions');
1114 expect(shareBtn).toBeTruthy();
1115 expect(downloadBtn).toBeTruthy();
1116 expect(actions).toBeTruthy();
1117 expect(actions.contains(shareBtn)).toBe(true);
1118 expect(actions.contains(downloadBtn)).toBe(true);
1119 expect(shareBtn.textContent).toBe('Share');
1120
1121 dom.window.close();
1122 });
1123
1124 test('expanded STL preview falls back gracefully when WebGL is unavailable', async () =>
1125 {
1126 listFixture['/data'] = [
1127 {
1128 name: 'part.stl',
1129 path: '/data/part.stl',
1130 isDir: false,
1131 size: 128,
1132 mtime: Date.now(),
1133 },
1134 ];
1135 downloadFixture['/data/part.stl'] = {
1136 type: 'model/stl',
1137 body: 'solid part\nendsolid part\n',
1138 };
1139
1140 const { dom, runtimeErrors } = await bootClient();
1141 expect(runtimeErrors).toEqual([]);
1142
1143 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/part.stl"]'));
1144
1145 const fileTile = dom.window.document.querySelector('.file-item[data-path="/data/part.stl"]');
1146 expect(fileTile).toBeTruthy();
1147
1148 fileTile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1149 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-expand-content .preview-unsupported'));
1150
1151 const fallback = dom.window.document.querySelector('.preview-expand-content .preview-unsupported');
1152 expect(fallback.textContent).toMatch(/3d preview is not available/i);
1153
1154 dom.window.close();
1155 });
1156
1157 test('expanded STL preview does not start file drag when dragging over the preview', async () =>
1158 {
1159 listFixture['/data'] = [
1160 {
1161 name: 'part.stl',
1162 path: '/data/part.stl',
1163 isDir: false,
1164 size: 128,
1165 mtime: Date.now(),
1166 },
1167 ];
1168 downloadFixture['/data/part.stl'] = {
1169 type: 'model/stl',
1170 body: 'solid part\nendsolid part\n',
1171 };
1172
1173 const { dom, runtimeErrors } = await bootClient();
1174 expect(runtimeErrors).toEqual([]);
1175
1176 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/part.stl"]'));
1177
1178 const fileTile = dom.window.document.querySelector('.file-item[data-path="/data/part.stl"]');
1179 fileTile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1180 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item--preview'));
1181
1182 const previewTile = dom.window.document.querySelector('.file-item--preview');
1183 previewTile.dispatchEvent(new dom.window.MouseEvent('pointerdown', {
1184 bubbles: true,
1185 button: 0,
1186 clientX: 100,
1187 clientY: 100,
1188 }));
1189 dom.window.document.dispatchEvent(new dom.window.MouseEvent('pointermove', {
1190 bubbles: true,
1191 clientX: 140,
1192 clientY: 140,
1193 }));
1194
1195 await new Promise(resolve => dom.window.setTimeout(resolve, 40));
1196 expect(previewTile.classList.contains('dragging')).toBe(false);
1197
1198 dom.window.close();
1199 });
1200
1201 test('expanded file preview keeps the surrounding tiles in place', async () =>
1202 {
1203 listFixture['/data'] = [
1204 {
1205 name: 'alpha.txt',
1206 path: '/data/alpha.txt',
1207 isDir: false,
1208 size: 12,
1209 mtime: Date.now(),
1210 },
1211 {
1212 name: 'beta.txt',
1213 path: '/data/beta.txt',
1214 isDir: false,
1215 size: 12,
1216 mtime: Date.now(),
1217 },
1218 ];
1219 downloadFixture['/data/alpha.txt'] = {
1220 type: 'text/plain',
1221 body: 'hello preview',
1222 };
1223
1224 const { dom, runtimeErrors } = await bootClient();
1225 expect(runtimeErrors).toEqual([]);
1226
1227 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/alpha.txt"]'));
1228
1229 const firstTile = dom.window.document.querySelector('.file-item[data-path="/data/alpha.txt"]');
1230 firstTile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1231
1232 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item--preview'));
1233
1234 const grid = dom.window.document.getElementById('file-grid');
1235 expect(grid.children.length).toBe(2);
1236 expect(grid.children[0].classList.contains('file-item--preview-placeholder')).toBe(true);
1237 expect(grid.children[1].dataset.path).toBe('/data/beta.txt');
1238 expect(dom.window.document.body.querySelector('.file-item--preview')).toBeTruthy();
1239
1240 dom.window.close();
1241 });
1242
1243 test('expanded video preview uses a stream session and video.js', async () =>
1244 {
1245 listFixture['/data'] = [
1246 {
1247 name: 'clip.mkv',
1248 path: '/data/clip.mkv',
1249 isDir: false,
1250 size: 64,
1251 mtime: Date.now(),
1252 },
1253 ];
1254 videoStreamFixture['/data/clip.mkv'] = {
1255 sessionId: 'video-session',
1256 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
1257 durationSeconds: 120,
1258 subtitleTracks: [{ label: 'English', language: 'eng', default: true, src: '/api/files/video-stream/video-session/subtitle-0.vtt' }],
1259 };
1260
1261 const { dom, runtimeErrors } = await bootClient();
1262 expect(runtimeErrors).toEqual([]);
1263
1264 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1265
1266 const fileTile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1267 expect(fileTile).toBeTruthy();
1268
1269 fileTile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1270 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1271
1272 expect(dom.window.__lastVideoJsOptions).toBeTruthy();
1273 expect(dom.window.__lastVideoJsOptions.sources[0].src).toBe('/api/files/video-stream/video-session/master.m3u8');
1274 expect(dom.window.__lastVideoJsOptions.fluid).toBe(false);
1275 expect(dom.window.__lastVideoJsOptions.fill).toBe(true);
1276 expect(dom.window.__lastVideoJsOptions.controlBar).toMatchObject({
1277 currentTimeDisplay: true,
1278 timeDivider: true,
1279 durationDisplay: true,
1280 remainingTimeDisplay: false,
1281 });
1282 expect(dom.window.__lastVideoJsPlayer.duration()).toBe(120);
1283 expect(dom.window.__lastVideoJsOptions.tracks).toEqual([
1284 {
1285 kind: 'subtitles',
1286 src: '/api/files/video-stream/video-session/subtitle-0.vtt',
1287 srclang: 'eng',
1288 label: 'English',
1289 default: true,
1290 },
1291 ]);
1292
1293 dom.window.close();
1294 });
1295
1296 test('video preview does not close on backdrop click and closes via X button', async () =>
1297 {
1298 listFixture['/data'] = [
1299 {
1300 name: 'clip.mkv',
1301 path: '/data/clip.mkv',
1302 isDir: false,
1303 size: 64,
1304 mtime: Date.now(),
1305 },
1306 ];
1307 videoStreamFixture['/data/clip.mkv'] = {
1308 sessionId: 'video-session',
1309 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
1310 subtitleTracks: [],
1311 subtitleSummary: { total: 0, converted: 0, skipped: 0 },
1312 };
1313
1314 const { dom, runtimeErrors } = await bootClient();
1315 expect(runtimeErrors).toEqual([]);
1316
1317 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1318
1319 const tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1320 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1321 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-backdrop'));
1322
1323 const backdrop = dom.window.document.querySelector('.preview-backdrop');
1324 backdrop.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
1325 await new Promise(resolve => dom.window.setTimeout(resolve, 40));
1326
1327 expect(dom.window.document.querySelector('.preview-backdrop')).toBeTruthy();
1328
1329 const closeBtn = dom.window.document.querySelector('.preview-expand-close');
1330 closeBtn.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
1331 await new Promise(resolve => dom.window.setTimeout(resolve, 280));
1332
1333 expect(dom.window.document.querySelector('.preview-backdrop')).toBeNull();
1334
1335 dom.window.close();
1336 });
1337
1338 test('video preview releases the backend stream session when closed', 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 subtitleTracks: [],
1353 subtitleSummary: { total: 0, converted: 0, skipped: 0 },
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 tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1362 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1363 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1364
1365 const closeBtn = dom.window.document.querySelector('.preview-expand-close');
1366 closeBtn.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
1367 await waitFor(dom, () => releasedVideoStreamSessions.includes('video-session'));
1368
1369 dom.window.close();
1370 });
1371
1372 test('video preview restores per-user saved volume preference', async () =>
1373 {
1374 listFixture['/data'] = [
1375 {
1376 name: 'clip.mkv',
1377 path: '/data/clip.mkv',
1378 isDir: false,
1379 size: 64,
1380 mtime: Date.now(),
1381 },
1382 ];
1383 videoStreamFixture['/data/clip.mkv'] = {
1384 sessionId: 'video-session',
1385 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
1386 subtitleTracks: [],
1387 subtitleSummary: { total: 0, converted: 0, skipped: 0 },
1388 };
1389
1390 const { dom, runtimeErrors } = await bootClient();
1391 expect(runtimeErrors).toEqual([]);
1392
1393 dom.window.localStorage.setItem('filemanager.video-prefs.v1.tester', JSON.stringify({ volume: 0.3 }));
1394
1395 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1396
1397 const tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1398 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1399 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1400
1401 expect(dom.window.__lastVideoJsVolumeSet).toBe(0.3);
1402
1403 dom.window.close();
1404 });
1405
1406 test('video preview restores saved subtitle/audio track names when available', async () =>
1407 {
1408 listFixture['/data'] = [
1409 {
1410 name: 'clip.mkv',
1411 path: '/data/clip.mkv',
1412 isDir: false,
1413 size: 64,
1414 mtime: Date.now(),
1415 },
1416 ];
1417 videoStreamFixture['/data/clip.mkv'] = {
1418 sessionId: 'video-session',
1419 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
1420 subtitleTracks: [
1421 { label: 'English', language: 'eng', default: true, src: '/api/files/video-stream/video-session/subtitle-0.vtt' },
1422 { label: 'French', language: 'fra', default: false, src: '/api/files/video-stream/video-session/subtitle-1.vtt' },
1423 ],
1424 subtitleSummary: { total: 2, converted: 2, skipped: 0 },
1425 };
1426
1427 const { dom, runtimeErrors } = await bootClient();
1428 expect(runtimeErrors).toEqual([]);
1429
1430 dom.window.__mockVideoJsAudioTracks = [
1431 { label: 'Stereo', enabled: false },
1432 { label: 'Director commentary', enabled: true },
1433 ];
1434 dom.window.localStorage.setItem('filemanager.video-prefs.v1.tester', JSON.stringify({
1435 subtitleTrackName: 'French',
1436 audioTrackName: 'Stereo',
1437 }));
1438
1439 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1440
1441 const tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1442 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1443 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1444
1445 expect(dom.window.localStorage.getItem('vjs-text-track-settings')).toBe(DEFAULT_VIDEO_TEXT_TRACK_SETTINGS_RAW);
1446 expect(dom.window.__lastVideoJsTextTracks.item(0).mode).toBe('disabled');
1447 expect(dom.window.__lastVideoJsTextTracks.item(1).mode).toBe('showing');
1448 expect(dom.window.__lastVideoJsAudioTracks.item(0).enabled).toBe(true);
1449 expect(dom.window.__lastVideoJsAudioTracks.item(1).enabled).toBe(false);
1450
1451 dom.window.close();
1452 });
1453
1454 test('video preview keeps default tracks when saved names are not present', async () =>
1455 {
1456 listFixture['/data'] = [
1457 {
1458 name: 'clip.mkv',
1459 path: '/data/clip.mkv',
1460 isDir: false,
1461 size: 64,
1462 mtime: Date.now(),
1463 },
1464 ];
1465 videoStreamFixture['/data/clip.mkv'] = {
1466 sessionId: 'video-session',
1467 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
1468 subtitleTracks: [
1469 { label: 'English', language: 'eng', default: true, src: '/api/files/video-stream/video-session/subtitle-0.vtt' },
1470 { label: 'French', language: 'fra', default: false, src: '/api/files/video-stream/video-session/subtitle-1.vtt' },
1471 ],
1472 subtitleSummary: { total: 2, converted: 2, skipped: 0 },
1473 };
1474
1475 const { dom, runtimeErrors } = await bootClient();
1476 expect(runtimeErrors).toEqual([]);
1477
1478 dom.window.__mockVideoJsAudioTracks = [
1479 { label: 'Stereo', enabled: false },
1480 { label: 'Director commentary', enabled: true },
1481 ];
1482 dom.window.localStorage.setItem('filemanager.video-prefs.v1.tester', JSON.stringify({
1483 subtitleTrackName: 'Spanish',
1484 audioTrackName: 'Dolby Atmos',
1485 }));
1486
1487 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1488
1489 const tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1490 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1491 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1492
1493 expect(dom.window.__lastVideoJsTextTracks.item(0).mode).toBe('showing');
1494 expect(dom.window.__lastVideoJsTextTracks.item(1).mode).toBe('disabled');
1495 expect(dom.window.__lastVideoJsAudioTracks.item(0).enabled).toBe(false);
1496 expect(dom.window.__lastVideoJsAudioTracks.item(1).enabled).toBe(true);
1497
1498 dom.window.close();
1499 });
1500
1501 test('video preview saves subtitle/audio track names per user when selection changes', 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: true },
1527 { label: 'Director commentary', enabled: false },
1528 ];
1529
1530 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1531
1532 const tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1533 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1534 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1535
1536 dom.window.__lastVideoJsTextTracks.item(0).mode = 'disabled';
1537 dom.window.__lastVideoJsTextTracks.item(1).mode = 'showing';
1538 dom.window.__lastVideoJsTextTracks.dispatchEvent('change');
1539
1540 dom.window.__lastVideoJsAudioTracks.item(0).enabled = false;
1541 dom.window.__lastVideoJsAudioTracks.item(1).enabled = true;
1542 dom.window.__lastVideoJsAudioTracks.dispatchEvent('change');
1543
1544 const stored = JSON.parse(dom.window.localStorage.getItem('filemanager.video-prefs.v1.tester'));
1545 expect(stored.subtitleTrackName).toBe('French');
1546 expect(stored.audioTrackName).toBe('Director commentary');
1547
1548 dom.window.close();
1549 });
1550
1551 test('video preview applies default caption style per user when no saved style exists', async () =>
1552 {
1553 listFixture['/data'] = [
1554 {
1555 name: 'clip.mkv',
1556 path: '/data/clip.mkv',
1557 isDir: false,
1558 size: 64,
1559 mtime: Date.now(),
1560 },
1561 ];
1562 videoStreamFixture['/data/clip.mkv'] = {
1563 sessionId: 'video-session',
1564 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
1565 subtitleTracks: [{ label: 'English', language: 'eng', default: true, src: '/api/files/video-stream/video-session/subtitle-0.vtt' }],
1566 subtitleSummary: { total: 1, converted: 1, skipped: 0 },
1567 };
1568
1569 const { dom, runtimeErrors } = await bootClient();
1570 expect(runtimeErrors).toEqual([]);
1571
1572 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1573 const tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1574 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1575 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1576
1577 expect(dom.window.localStorage.getItem('vjs-text-track-settings')).toBe(DEFAULT_VIDEO_TEXT_TRACK_SETTINGS_RAW);
1578 const storedRaw = dom.window.localStorage.getItem('filemanager.video-prefs.v1.tester');
1579 if (storedRaw)
1580 {
1581 const stored = JSON.parse(storedRaw);
1582 expect(stored.textTrackSettings).toBeUndefined();
1583 }
1584
1585 dom.window.close();
1586 });
1587
1588 test('video preview does not save caption style settings per user on close', async () =>
1589 {
1590 listFixture['/data'] = [
1591 {
1592 name: 'clip.mkv',
1593 path: '/data/clip.mkv',
1594 isDir: false,
1595 size: 64,
1596 mtime: Date.now(),
1597 },
1598 ];
1599 videoStreamFixture['/data/clip.mkv'] = {
1600 sessionId: 'video-session',
1601 playlistUrl: '/api/files/video-stream/video-session/master.m3u8',
1602 subtitleTracks: [{ label: 'English', language: 'eng', default: true, src: '/api/files/video-stream/video-session/subtitle-0.vtt' }],
1603 subtitleSummary: { total: 1, converted: 1, skipped: 0 },
1604 };
1605
1606 const { dom, runtimeErrors } = await bootClient();
1607 expect(runtimeErrors).toEqual([]);
1608
1609 await waitFor(dom, () => !!dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]'));
1610 const tile = dom.window.document.querySelector('.file-item[data-path="/data/clip.mkv"]');
1611 tile.dispatchEvent(new dom.window.MouseEvent('dblclick', { bubbles: true }));
1612 await waitFor(dom, () => !!dom.window.document.querySelector('.preview-video-js'));
1613
1614 // Simulate updated caption style persisted by Video.js internals.
1615 dom.window.localStorage.setItem('vjs-text-track-settings', '{"color":"#ffffff"}');
1616
1617 const closeBtn = dom.window.document.querySelector('.preview-expand-close');
1618 closeBtn.dispatchEvent(new dom.window.MouseEvent('click', { bubbles: true }));
1619 await new Promise(resolve => dom.window.setTimeout(resolve, 280));
1620
1621 const storedRaw = dom.window.localStorage.getItem('filemanager.video-prefs.v1.tester');
1622 if (storedRaw)
1623 {
1624 const stored = JSON.parse(storedRaw);
1625 expect(stored.textTrackSettings).toBeUndefined();
1626 }
1627
1628 dom.window.close();
1629 });
1630});