BlueGit

timfa filemanager

Files

filemanager / tests / page.load.test.js

page.load.test.js

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