'use strict'; const express = require('express'); const fs = require('fs'); const http = require('http'); const os = require('os'); const path = require('path'); const { once } = require('events'); let mockPaths = []; let mockUserPath = null; let mockUser = { username: 'testuser', isAdmin: true, permissions: {} }; let mockVideoStreamSession = null; let mockVideoStreamAsset = null; let releasedVideoStreamSessionId = null; let mockSubtitleFrameResult = null; let mockSubtitleFrameError = null; let mockSubtitleRangeResult = null; let mockSubtitleRangeError = null; jest.mock('../server/db', () => { const { Database } = require('node-sqlite3-wasm'); let db; function getDb () { if (!db) { db = new Database(':memory:'); db.exec(` CREATE TABLE IF NOT EXISTS share_tokens ( token TEXT PRIMARY KEY, file_path TEXT NOT NULL, is_dir INTEGER NOT NULL DEFAULT 0, created_by TEXT NOT NULL, created_at INTEGER NOT NULL, expires_at INTEGER NOT NULL ); `); } return db; } return { getDb, initDb: getDb }; }); jest.mock('../server/config', () => ({ loadConfig: () => ({ port: 3000, paths: [...mockPaths], userPath: mockUserPath, rootAliases: {} }), saveConfig: jest.fn(), getEffectivePaths: (paths) => paths, getAllowedRoot: (targetPath, roots) => { const pathMod = require('path'); const absTarget = pathMod.resolve(String(targetPath || '')); return roots.find((root) => { const absRoot = pathMod.resolve(root); return absTarget === absRoot || absTarget.startsWith(absRoot + pathMod.sep); }) || null; }, })); jest.mock('../server/auth', () => ({ requireAuth: (req, res, next) => { req.user = mockUser; next(); }, })); jest.mock('../server/video-stream', () => ({ createVideoStreamSession: jest.fn(async () => { if (mockVideoStreamSession instanceof Error) throw mockVideoStreamSession; return mockVideoStreamSession || { sessionId: 'share-video-session', subtitleTracks: [] }; }), sendVideoStreamAsset: jest.fn(async (sessionId, assetPath, req, res) => { if (typeof mockVideoStreamAsset === 'function') { await mockVideoStreamAsset(sessionId, assetPath, req, res); return; } res.type('application/vnd.apple.mpegurl').send('#EXTM3U\n'); }), releaseVideoStreamSession: jest.fn((sessionId) => { releasedVideoStreamSessionId = sessionId; }), })); jest.mock('../server/image-subtitles', () => ({ renderImageSubtitleFrame: jest.fn(async () => { if (mockSubtitleFrameError) throw mockSubtitleFrameError; return mockSubtitleFrameResult; }), renderImageSubtitleFramesInRange: jest.fn(async () => { if (mockSubtitleRangeError) throw mockSubtitleRangeError; return mockSubtitleRangeResult; }), })); jest.mock('../server/logger', () => ({ logError: jest.fn(), })); jest.mock('../server/subtitle-debug-log', () => ({ appendSubtitleDebugEntries: jest.fn(), })); const shareRoutes = require('../server/routes/share'); const { getDb } = require('../server/db'); let server; let baseUrl; let rootDir; function get (p) { return fetch(baseUrl + p); } function post (p, body) { return fetch(baseUrl + p, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body), }); } beforeAll(async () => { rootDir = fs.mkdtempSync(path.join(os.tmpdir(), 'filemanager-share-test-')); mockPaths = [rootDir]; const app = express(); app.use(express.json()); app.use('/api/share', shareRoutes); app.use((err, req, res, _next) => { res.status(err.status || 500).json({ error: err.message || 'Internal error' }); }); server = http.createServer(app); server.listen(0); await once(server, 'listening'); baseUrl = `http://127.0.0.1:${server.address().port}`; }); afterAll(() => { server.close(); fs.rmSync(rootDir, { recursive: true, force: true }); }); beforeEach(() => { fs.rmSync(rootDir, { recursive: true, force: true }); fs.mkdirSync(rootDir, { recursive: true }); if (mockUserPath) { fs.rmSync(mockUserPath, { recursive: true, force: true }); fs.mkdirSync(mockUserPath, { recursive: true }); } mockUserPath = null; mockVideoStreamSession = null; mockVideoStreamAsset = null; releasedVideoStreamSessionId = null; mockSubtitleFrameResult = null; mockSubtitleFrameError = null; mockSubtitleRangeResult = null; mockSubtitleRangeError = null; // Reset DB between tests const db = getDb(); db.exec('DELETE FROM share_tokens'); }); // --------------------------------------------------------------------------- // POST /api/share/create // --------------------------------------------------------------------------- describe('POST /api/share/create', () => { test('creates a token for a file', async () => { const filePath = path.join(rootDir, 'hello.txt'); fs.writeFileSync(filePath, 'hello'); const res = await post('/api/share/create', { filePath }); expect(res.status).toBe(200); const body = await res.json(); expect(typeof body.token).toBe('string'); expect(body.token).toHaveLength(64); // 32 bytes hex expect(typeof body.expiresAt).toBe('number'); expect(body.expiresAt).toBeGreaterThan(Date.now()); }); test('creates a token for a directory', async () => { const dirPath = path.join(rootDir, 'subdir'); fs.mkdirSync(dirPath); const res = await post('/api/share/create', { filePath: dirPath }); expect(res.status).toBe(200); const body = await res.json(); expect(typeof body.token).toBe('string'); }); test('returns 400 when filePath is missing', async () => { const res = await post('/api/share/create', {}); expect(res.status).toBe(400); }); test('returns 403 when path is outside configured roots', async () => { const res = await post('/api/share/create', { filePath: os.tmpdir() }); expect(res.status).toBe(403); }); test('returns 404 when file does not exist', async () => { const res = await post('/api/share/create', { filePath: path.join(rootDir, 'missing.txt') }); expect(res.status).toBe(404); }); test('creates a token for a file inside My Folder', async () => { const userFolderBase = fs.mkdtempSync(path.join(os.tmpdir(), 'filemanager-share-userfolders-')); const userFolder = path.join(userFolderBase, 'testuser'); const filePath = path.join(userFolder, 'private.txt'); mockUserPath = userFolderBase; mockUser = { username: 'testuser', isAdmin: false, permissions: {} }; fs.mkdirSync(userFolder, { recursive: true }); fs.writeFileSync(filePath, 'private'); try { const res = await post('/api/share/create', { filePath }); expect(res.status).toBe(200); const body = await res.json(); expect(typeof body.token).toBe('string'); } finally { fs.rmSync(userFolderBase, { recursive: true, force: true }); } }); }); // --------------------------------------------------------------------------- // GET /api/share/info/:token // --------------------------------------------------------------------------- describe('GET /api/share/info/:token', () => { function insertToken ({ token, filePath, isDir = 0, expiresAt = Date.now() + 86400000 }) { getDb().prepare( 'INSERT INTO share_tokens (token, file_path, is_dir, created_by, created_at, expires_at) VALUES (?,?,?,?,?,?)', ).run([token, filePath, isDir, 'testuser', Date.now(), expiresAt]); } test('returns file info for a valid token', async () => { const filePath = path.join(rootDir, 'info.txt'); fs.writeFileSync(filePath, 'data'); insertToken({ token: 'aaaa', filePath }); const res = await get('/api/share/info/aaaa'); expect(res.status).toBe(200); const body = await res.json(); expect(body.name).toBe('info.txt'); expect(body.isDir).toBe(false); expect(typeof body.expiresAt).toBe('number'); }); test('returns isDir=true for directory tokens', async () => { const dirPath = path.join(rootDir, 'mydir'); fs.mkdirSync(dirPath); insertToken({ token: 'bbbb', filePath: dirPath, isDir: 1 }); const res = await get('/api/share/info/bbbb'); expect(res.status).toBe(200); const body = await res.json(); expect(body.isDir).toBe(true); }); test('returns 404 for unknown token', async () => { const res = await get('/api/share/info/unknowntoken'); expect(res.status).toBe(404); }); test('returns 410 for expired token', async () => { const filePath = path.join(rootDir, 'exp.txt'); fs.writeFileSync(filePath, 'x'); insertToken({ token: 'cccc', filePath, expiresAt: Date.now() - 1000 }); const res = await get('/api/share/info/cccc'); expect(res.status).toBe(410); }); }); // --------------------------------------------------------------------------- // GET /api/share/preview/:token // --------------------------------------------------------------------------- describe('GET /api/share/preview/:token', () => { function insertToken ({ token, filePath, isDir = 0, expiresAt = Date.now() + 86400000 }) { getDb().prepare( 'INSERT INTO share_tokens (token, file_path, is_dir, created_by, created_at, expires_at) VALUES (?,?,?,?,?,?)', ).run([token, filePath, isDir, 'testuser', Date.now(), expiresAt]); } test('streams file content for a valid file token', async () => { const filePath = path.join(rootDir, 'preview.txt'); fs.writeFileSync(filePath, 'preview content'); insertToken({ token: 'prev1', filePath }); const res = await get('/api/share/preview/prev1'); expect(res.status).toBe(200); const text = await res.text(); expect(text).toBe('preview content'); }); test('returns 400 when token points to a directory', async () => { const dirPath = path.join(rootDir, 'previewdir'); fs.mkdirSync(dirPath); insertToken({ token: 'prev2', filePath: dirPath, isDir: 1 }); const res = await get('/api/share/preview/prev2'); expect(res.status).toBe(400); }); test('returns 410 for expired token', async () => { const filePath = path.join(rootDir, 'ep.txt'); fs.writeFileSync(filePath, 'x'); insertToken({ token: 'prev3', filePath, expiresAt: Date.now() - 1 }); const res = await get('/api/share/preview/prev3'); expect(res.status).toBe(410); }); }); describe('GET /api/share/video-stream/:token', () => { function insertToken ({ token, filePath, isDir = 0, expiresAt = Date.now() + 86400000 }) { getDb().prepare( 'INSERT INTO share_tokens (token, file_path, is_dir, created_by, created_at, expires_at) VALUES (?,?,?,?,?,?)', ).run([token, filePath, isDir, 'testuser', Date.now(), expiresAt]); } test('creates a stream session for a shared video', async () => { const filePath = path.join(rootDir, 'movie.mkv'); fs.writeFileSync(filePath, 'video'); insertToken({ token: 'stream1', filePath }); mockVideoStreamSession = { sessionId: 'share-sess-1', durationSeconds: 42.25, subtitleTracks: [{ fileName: 'subtitle-0.vtt', label: 'English', language: 'eng', isDefault: true }], }; const res = await get('/api/share/video-stream/stream1'); expect(res.status).toBe(200); const body = await res.json(); expect(body.playlistUrl).toBe('/api/share/video-stream/session/share-sess-1/master.m3u8'); expect(body.durationSeconds).toBe(42.25); expect(body.subtitleTracks).toEqual([ { label: 'English', language: 'eng', default: true, src: '/api/share/video-stream/session/share-sess-1/subtitle-0.vtt', }, ]); }); test('serves stream assets from an existing share session', async () => { mockVideoStreamAsset = async (_sessionId, _assetPath, _req, res) => { res.type('application/vnd.apple.mpegurl').send('#EXTM3U\n'); }; const res = await get('/api/share/video-stream/session/share-sess-1/master.m3u8'); expect(res.status).toBe(200); expect(await res.text()).toBe('#EXTM3U\n'); }); test('releases an existing share stream session', async () => { const res = await fetch(baseUrl + '/api/share/video-stream/session/share-sess-1', { method: 'DELETE', }); expect(res.status).toBe(200); expect(await res.json()).toEqual({ ok: true }); expect(releasedVideoStreamSessionId).toBe('share-sess-1'); }); test('renders image subtitle frames for a shared video', async () => { const filePath = path.join(rootDir, 'movie-subs.mkv'); fs.writeFileSync(filePath, 'video'); insertToken({ token: 'stream-subs', filePath }); mockSubtitleFrameResult = { frame: Buffer.from('png-data'), left: 100, top: 50, width: 320, height: 180, canvasWidth: 640, canvasHeight: 360, startTimeSeconds: 1.5, endTimeSeconds: 3.2, }; const res = await get('/api/share/video-stream-subtitle-frame/stream-subs?streamIndex=0&timeSeconds=2.5&videoWidth=1920&videoHeight=1080'); expect(res.status).toBe(200); expect(res.headers.get('content-type')).toMatch(/image\/png/); expect(res.headers.get('x-subtitle-frame-status')).toBe('ok'); expect(res.headers.get('x-subtitle-frame-left')).toBe('100'); expect(res.headers.get('x-subtitle-frame-top')).toBe('50'); expect(res.headers.get('x-subtitle-frame-width')).toBe('320'); expect(res.headers.get('x-subtitle-frame-height')).toBe('180'); expect(res.headers.get('x-subtitle-frame-canvas-width')).toBe('640'); expect(res.headers.get('x-subtitle-frame-canvas-height')).toBe('360'); expect(res.headers.get('x-subtitle-frame-start-time')).toBe('1.5'); expect(res.headers.get('x-subtitle-frame-end-time')).toBe('3.2'); expect(Number(res.headers.get('x-subtitle-request-received-at-ms'))).toBeGreaterThan(0); expect(Number(res.headers.get('x-subtitle-response-sent-at-ms'))).toBeGreaterThan(0); expect(Buffer.from(await res.arrayBuffer()).equals(Buffer.from('png-data'))).toBe(true); }); test('renders image subtitle frames for a shared video range request', async () => { const filePath = path.join(rootDir, 'movie-subs.mkv'); fs.writeFileSync(filePath, 'video'); insertToken({ token: 'stream-subs-range', filePath }); mockSubtitleRangeResult = { frames: [ { frame: Buffer.from('png-a'), left: 10, top: 20, width: 300, height: 90, canvasWidth: 640, canvasHeight: 360, startTimeSeconds: 2, endTimeSeconds: 4, }, ], }; const res = await get('/api/share/video-stream-subtitle-range/stream-subs-range?streamIndex=0&startTimeSeconds=2&endTimeSeconds=8&videoWidth=1920&videoHeight=1080'); expect(res.status).toBe(200); expect(await res.json()).toEqual(expect.objectContaining({ status: 'ok', startTimeSeconds: 2, endTimeSeconds: 8, frames: [expect.objectContaining({ left: 10, top: 20, width: 300, height: 90, canvasWidth: 640, canvasHeight: 360, startTimeSeconds: 2, endTimeSeconds: 4, contentType: 'image/png', frameBase64: Buffer.from('png-a').toString('base64'), })], })); }); test('persists subtitle debug batches for shared video playback', async () => { const filePath = path.join(rootDir, 'movie-subs.mkv'); fs.writeFileSync(filePath, 'video'); insertToken({ token: 'stream-subs-log', filePath }); const { appendSubtitleDebugEntries } = require('../server/subtitle-debug-log'); const res = await post('/api/share/video-stream-subtitle-log/stream-subs-log', { sessionId: 'share-sess-1', entries: [ { loggedAtMs: 1000, eventType: 'subtitle_png_requested' }, ], }); expect(res.status).toBe(200); expect(await res.json()).toEqual({ ok: true }); expect(appendSubtitleDebugEntries).toHaveBeenCalledWith(expect.objectContaining({ videoName: 'movie-subs.mkv', context: expect.objectContaining({ filePath, sessionId: 'share-sess-1', source: 'share', shareToken: 'stream-subs-log', }), })); }); }); // --------------------------------------------------------------------------- // GET /api/share/download/:token // --------------------------------------------------------------------------- describe('GET /api/share/download/:token', () => { function insertToken ({ token, filePath, isDir = 0, expiresAt = Date.now() + 86400000 }) { getDb().prepare( 'INSERT INTO share_tokens (token, file_path, is_dir, created_by, created_at, expires_at) VALUES (?,?,?,?,?,?)', ).run([token, filePath, isDir, 'testuser', Date.now(), expiresAt]); } test('downloads a file', async () => { const filePath = path.join(rootDir, 'dl.txt'); fs.writeFileSync(filePath, 'download me'); insertToken({ token: 'dl01', filePath }); const res = await get('/api/share/download/dl01'); expect(res.status).toBe(200); const text = await res.text(); expect(text).toBe('download me'); }); test('downloads a directory as zip', async () => { const dirPath = path.join(rootDir, 'zipit'); fs.mkdirSync(dirPath); fs.writeFileSync(path.join(dirPath, 'a.txt'), 'aaa'); insertToken({ token: 'dl02', filePath: dirPath, isDir: 1 }); const res = await get('/api/share/download/dl02'); expect(res.status).toBe(200); const ct = res.headers.get('content-type') || ''; // Express sends application/zip or application/octet-stream for .zip downloads expect(ct.includes('zip') || ct.includes('octet')).toBe(true); const buf = await res.arrayBuffer(); // ZIP magic bytes: PK\x03\x04 expect(new Uint8Array(buf.slice(0, 4))).toEqual(new Uint8Array([0x50, 0x4b, 0x03, 0x04])); }); test('returns 410 for expired token', async () => { const filePath = path.join(rootDir, 'edl.txt'); fs.writeFileSync(filePath, 'x'); insertToken({ token: 'dl03', filePath, expiresAt: Date.now() - 1 }); const res = await get('/api/share/download/dl03'); expect(res.status).toBe(410); }); test('returns 404 for unknown token', async () => { const res = await get('/api/share/download/nosuchtoken'); expect(res.status).toBe(404); }); }); // --------------------------------------------------------------------------- // pruneZipCache // --------------------------------------------------------------------------- describe('pruneZipCache', () => { test('deletes zip files older than 1 day', () => { const { pruneZipCache, ZIP_CACHE_DIR } = require('../server/routes/share'); fs.mkdirSync(ZIP_CACHE_DIR, { recursive: true }); const oldZip = path.join(ZIP_CACHE_DIR, 'old.zip'); fs.writeFileSync(oldZip, 'fake zip'); // Back-date the mtime by 25 hours const pastTime = new Date(Date.now() - 25 * 60 * 60 * 1000); fs.utimesSync(oldZip, pastTime, pastTime); const freshZip = path.join(ZIP_CACHE_DIR, 'fresh.zip'); fs.writeFileSync(freshZip, 'fake fresh zip'); pruneZipCache(); expect(fs.existsSync(oldZip)).toBe(false); expect(fs.existsSync(freshZip)).toBe(true); // Cleanup try { fs.unlinkSync(freshZip); } catch { /* ignore */ } }); }); describe('purgeExpiredShareTokens', () => { test('deletes expired share tokens and keeps valid ones', () => { const { purgeExpiredShareTokens } = require('../server/routes/share'); const db = getDb(); const now = Date.now(); db.prepare( 'INSERT INTO share_tokens (token, file_path, is_dir, created_by, created_at, expires_at) VALUES (?,?,?,?,?,?)', ).run(['expired-token', '/tmp/old.txt', 0, 'testuser', now - 10000, now - 1000]); db.prepare( 'INSERT INTO share_tokens (token, file_path, is_dir, created_by, created_at, expires_at) VALUES (?,?,?,?,?,?)', ).run(['active-token', '/tmp/new.txt', 0, 'testuser', now - 1000, now + 60000]); const removed = purgeExpiredShareTokens({ nowMs: now }); expect(removed).toBeGreaterThanOrEqual(1); const remaining = db.prepare('SELECT token FROM share_tokens ORDER BY token').all().map((row) => row.token); expect(remaining).toContain('active-token'); expect(remaining).not.toContain('expired-token'); }); }); // --------------------------------------------------------------------------- // buildShareOpenGraphPage // --------------------------------------------------------------------------- describe('buildShareOpenGraphPage', () => { const { buildShareOpenGraphPage } = require('../server/routes/share'); const mockReq = { protocol: 'https', get: (header) => { if (header === 'host') return 'example.com'; return null; }, }; function insertToken ({ token, filePath, isDir = 0, expiresAt = Date.now() + 86400000 }) { getDb() .prepare('INSERT OR REPLACE INTO share_tokens (token, file_path, is_dir, created_by, created_at, expires_at) VALUES (?,?,?,?,?,?)') .run([token, filePath, isDir, 'testuser', Date.now(), expiresAt]); } test('returns HTML page containing correct og:title for a valid file token', () => { insertToken({ token: 'og-valid', filePath: '/data/report.pdf' }); const html = buildShareOpenGraphPage('og-valid', mockReq); expect(html).toContain('report.pdf'); }); test('includes og:image and summary_large_image twitter:card for image files', () => { insertToken({ token: 'og-img', filePath: '/data/photo.jpg' }); const html = buildShareOpenGraphPage('og-img', mockReq); expect(html).toContain('property="og:image"'); expect(html).toContain('/api/share/preview/og-img'); expect(html).toContain('summary_large_image'); }); test('includes og:image for png files', () => { insertToken({ token: 'og-png', filePath: '/data/banner.png' }); const html = buildShareOpenGraphPage('og-png', mockReq); expect(html).toContain('property="og:image"'); }); test('includes og:image for webp files', () => { insertToken({ token: 'og-webp', filePath: '/data/thumb.webp' }); const html = buildShareOpenGraphPage('og-webp', mockReq); expect(html).toContain('property="og:image"'); }); test('does not include og:image for non-image files and uses summary twitter:card', () => { insertToken({ token: 'og-video', filePath: '/data/movie.mkv' }); const html = buildShareOpenGraphPage('og-video', mockReq); expect(html).not.toContain('property="og:image"'); expect(html).toContain('content="summary"'); }); test('does not include og:image for directory tokens', () => { insertToken({ token: 'og-dir', filePath: '/data/photos', isDir: 1 }); const html = buildShareOpenGraphPage('og-dir', mockReq); expect(html).not.toContain('property="og:image"'); }); test('returns "Link Expired" in og:title for an expired token', () => { insertToken({ token: 'og-exp', filePath: '/data/old.jpg', expiresAt: Date.now() - 1000 }); const html = buildShareOpenGraphPage('og-exp', mockReq); expect(html).toContain('content="Link Expired"'); expect(html).not.toContain('property="og:image"'); }); test('returns "Link Not Found" in og:title for an unknown token', () => { const html = buildShareOpenGraphPage('does-not-exist', mockReq); expect(html).toContain('content="Link Not Found"'); }); test('includes og:url pointing to the share page', () => { insertToken({ token: 'og-url', filePath: '/data/file.txt' }); const html = buildShareOpenGraphPage('og-url', mockReq); expect(html).toContain('https://example.com/share/og-url'); }); test('og:description mentions validity for a valid token', () => { insertToken({ token: 'og-desc', filePath: '/data/doc.pdf', expiresAt: Date.now() + 7200000 }); const html = buildShareOpenGraphPage('og-desc', mockReq); expect(html).toContain('Valid for'); }); test('retains the full share page client JS (not a bare meta-only response)', () => { insertToken({ token: 'og-full', filePath: '/data/file.txt' }); const html = buildShareOpenGraphPage('og-full', mockReq); // The interactive share page JS should still be present. expect(html).toContain('api/share/info/'); }); });