BlueGit

timfa filemanager

Files

filemanager / tests / page.load.test.js

page.load.test.js

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