'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 mockRootAliases = {}; let mockUser = { username: 'admin', isAdmin: true, permissions: {} }; let mockThumbPath = null; let mockFolderImages = []; let mockFolderIconFile = null; let lastFolderIconAssignment = undefined; 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 users ( id INTEGER PRIMARY KEY AUTOINCREMENT, username TEXT UNIQUE NOT NULL, password_hash TEXT NOT NULL, is_admin INTEGER NOT NULL DEFAULT 0, permissions TEXT NOT NULL DEFAULT '{}' ); CREATE TABLE IF NOT EXISTS file_meta ( file_path TEXT PRIMARY KEY, uploader TEXT NOT NULL DEFAULT '', downloaders TEXT NOT NULL DEFAULT '[]' ); `); } return db; } return { getDb, initDb: getDb }; }); jest.mock('../server/config', () => ({ loadConfig: () => ({ port: 3000, paths: [...mockPaths], rootAliases: { ...mockRootAliases } }), saveConfig: (config) => { mockPaths = [...(config.paths || [])]; mockRootAliases = { ...(config.rootAliases || {}) }; }, getEffectivePaths: (paths) => paths, getAllowedRoot: (targetPath, roots) => { const path = require('path'); const absTarget = path.resolve(String(targetPath || '')); return roots.find((root) => { const absRoot = path.resolve(root); return absTarget === absRoot || absTarget.startsWith(absRoot + path.sep); }) || null; }, })); jest.mock('../server/auth', () => ({ requireAuth: (req, res, next) => { req.user = mockUser; next(); }, })); jest.mock('../server/thumbnail-cache', () => ({ getCachedThumbnailInfo: async () => { if (!mockThumbPath) return null; return { thumbPath: mockThumbPath, contentType: 'image/webp' }; }, getImagesWithThumbnailsInDir: async () => mockFolderImages.slice(), getFolderIconSourceFile: async () => mockFolderIconFile, setFolderIconAssignment: async (folderPath, imagePath) => { lastFolderIconAssignment = { folderPath, imagePath }; }, })); const filesRoutes = require('../server/routes/files'); const { getDb } = require('../server/db'); let server; let baseUrl; let rootDir; beforeAll(async () => { rootDir = fs.mkdtempSync(path.join(os.tmpdir(), 'filemanager-files-routes-')); mockPaths = [rootDir]; const app = express(); app.use(express.json()); app.use('/api/files', filesRoutes); 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 }); mockRootAliases = {}; mockUser = { username: 'admin', isAdmin: true, permissions: {} }; mockThumbPath = null; mockFolderImages = []; mockFolderIconFile = null; lastFolderIconAssignment = undefined; const db = getDb(); db.prepare('DELETE FROM file_meta').run([]); db.prepare('DELETE FROM users').run([]); }); function req (method, routePath, body) { const payload = body ? JSON.stringify(body) : undefined; return new Promise((resolve, reject) => { const request = http.request(baseUrl + routePath, { method, headers: { 'Content-Type': 'application/json', ...(payload ? { 'Content-Length': Buffer.byteLength(payload) } : {}), }, }, res => { let data = ''; res.on('data', chunk => data += chunk); res.on('end', () => resolve({ status: res.statusCode, body: JSON.parse(data) })); }); request.on('error', reject); if (payload) request.write(payload); request.end(); }); } function reqRaw (method, routePath) { return new Promise((resolve, reject) => { const request = http.request(baseUrl + routePath, { method }, res => { const chunks = []; res.on('data', chunk => chunks.push(Buffer.from(chunk))); res.on('end', () => resolve({ status: res.statusCode, headers: res.headers, body: Buffer.concat(chunks), })); }); request.on('error', reject); request.end(); }); } describe('POST /api/files/move', () => { test('moves a file into another folder and rewrites metadata', async () => { const from = path.join(rootDir, 'alpha.txt'); const toDir = path.join(rootDir, 'folder'); fs.writeFileSync(from, 'hello'); fs.mkdirSync(toDir); getDb().prepare('INSERT INTO file_meta (file_path, uploader, downloaders) VALUES (?, ?, ?)') .run([from, 'admin', '["alice"]']); const { status, body } = await req('POST', '/api/files/move', { from, toDir }); expect(status).toBe(200); expect(body.ok).toBe(true); expect(fs.existsSync(from)).toBe(false); expect(fs.existsSync(path.join(toDir, 'alpha.txt'))).toBe(true); const meta = getDb().prepare('SELECT * FROM file_meta WHERE file_path = ?').get([path.join(toDir, 'alpha.txt')]); expect(meta).toMatchObject({ uploader: 'admin', downloaders: '["alice"]' }); }); test('moves a folder into another folder and rewrites descendant metadata', async () => { const fromDir = path.join(rootDir, 'src-folder'); const nestedFile = path.join(fromDir, 'child.txt'); const toDir = path.join(rootDir, 'dest-folder'); fs.mkdirSync(fromDir); fs.mkdirSync(toDir); fs.writeFileSync(nestedFile, 'hello'); getDb().prepare('INSERT INTO file_meta (file_path, uploader, downloaders) VALUES (?, ?, ?)') .run([nestedFile, 'admin', '[]']); const { status } = await req('POST', '/api/files/move', { from: fromDir, toDir }); expect(status).toBe(200); expect(fs.existsSync(fromDir)).toBe(false); expect(fs.existsSync(path.join(toDir, 'src-folder', 'child.txt'))).toBe(true); const movedMeta = getDb().prepare('SELECT * FROM file_meta WHERE file_path = ?') .get([path.join(toDir, 'src-folder', 'child.txt')]); expect(movedMeta).toBeTruthy(); }); test('rejects moving a folder into itself', async () => { const fromDir = path.join(rootDir, 'src-folder'); const childDir = path.join(fromDir, 'child'); fs.mkdirSync(childDir, { recursive: true }); const { status, body } = await req('POST', '/api/files/move', { from: fromDir, toDir: childDir }); expect(status).toBe(400); expect(body.error).toMatch(/folder into itself/i); }); }); describe('root alias endpoints', () => { test('GET /api/files/roots returns alias label and original name', async () => { mockRootAliases = { [path.resolve(rootDir)]: 'Workspace' }; const { status, body } = await req('GET', '/api/files/roots'); expect(status).toBe(200); expect(body.roots).toHaveLength(1); expect(body.roots[0]).toMatchObject({ path: rootDir, label: 'Workspace', alias: 'Workspace', originalName: path.basename(rootDir), }); }); test('POST /api/files/root-alias stores alias without renaming filesystem path', async () => { const originalBase = path.basename(rootDir); const { status, body } = await req('POST', '/api/files/root-alias', { rootPath: rootDir, alias: 'Shared Files', }); expect(status).toBe(200); expect(body.ok).toBe(true); expect(body.root).toMatchObject({ path: rootDir, label: 'Shared Files', alias: 'Shared Files', originalName: originalBase, }); expect(fs.existsSync(rootDir)).toBe(true); const afterRoots = await req('GET', '/api/files/roots'); expect(afterRoots.status).toBe(200); expect(afterRoots.body.roots[0].label).toBe('Shared Files'); expect(afterRoots.body.roots[0].originalName).toBe(originalBase); }); test('POST /api/files/root-alias rejects non-root paths', async () => { const nested = path.join(rootDir, 'sub'); fs.mkdirSync(nested, { recursive: true }); const { status } = await req('POST', '/api/files/root-alias', { rootPath: nested, alias: 'Nested', }); expect(status).toBe(400); }); }); describe('GET /api/files/thumbnail', () => { test('returns 404 while cached thumbnail is not ready', async () => { const source = path.join(rootDir, 'photo.jpg'); fs.writeFileSync(source, 'not-an-image'); const { status, body } = await req('GET', `/api/files/thumbnail?file=${encodeURIComponent(source)}`); expect(status).toBe(404); expect(body.error).toMatch(/not ready/i); }); test('serves cached thumbnail file when available', async () => { const source = path.join(rootDir, 'photo.jpg'); const thumb = path.join(rootDir, 'photo-thumb.webp'); fs.writeFileSync(source, 'not-an-image'); fs.writeFileSync(thumb, 'webp-bytes'); mockThumbPath = thumb; const response = await reqRaw('GET', `/api/files/thumbnail?file=${encodeURIComponent(source)}`); expect(response.status).toBe(200); expect(String(response.headers['content-type'] || '')).toContain('image/webp'); expect(response.body.toString('utf8')).toBe('webp-bytes'); }); }); describe('GET /api/files/root-access', () => { test('returns users with R/R+W modes for an exact root path', async () => { const label = path.basename(rootDir); const db = getDb(); db.prepare('INSERT INTO users (username, password_hash, is_admin, permissions) VALUES (?, ?, ?, ?)') .run(['admin', 'x', 1, '{}']); db.prepare('INSERT INTO users (username, password_hash, is_admin, permissions) VALUES (?, ?, ?, ?)') .run(['alice', 'x', 0, JSON.stringify({ [label]: { read: true, write: false } })]); db.prepare('INSERT INTO users (username, password_hash, is_admin, permissions) VALUES (?, ?, ?, ?)') .run(['bob', 'x', 0, JSON.stringify({ [label]: { read: true, write: true } })]); db.prepare('INSERT INTO users (username, password_hash, is_admin, permissions) VALUES (?, ?, ?, ?)') .run(['charlie', 'x', 0, JSON.stringify({ other: { read: true, write: false } })]); const { status, body } = await req('GET', `/api/files/root-access?rootPath=${encodeURIComponent(rootDir)}`); expect(status).toBe(200); expect(body.root).toMatchObject({ path: rootDir, originalName: label }); expect(body.users).toEqual([ { username: 'admin', mode: 'R+W' }, { username: 'bob', mode: 'R+W' }, { username: 'alice', mode: 'R' }, ]); }); test('rejects non-exact nested root paths', async () => { const nested = path.join(rootDir, 'sub'); fs.mkdirSync(nested, { recursive: true }); const { status } = await req('GET', `/api/files/root-access?rootPath=${encodeURIComponent(nested)}`); expect(status).toBe(400); }); }); describe('folder icon endpoints', () => { test('GET /api/files/folder-images returns images that have cached thumbnails', async () => { const subDir = path.join(rootDir, 'photos'); fs.mkdirSync(subDir); const imgPath = path.join(subDir, 'a.jpg'); fs.writeFileSync(imgPath, 'img'); mockFolderImages = [{ filePath: imgPath, thumbRelPath: 'thumbs/a.jpg.webp' }]; const { status, body } = await req('GET', `/api/files/folder-images?dir=${encodeURIComponent(rootDir)}`); expect(status).toBe(200); expect(body.images).toHaveLength(1); expect(body.images[0].filePath).toBe(imgPath); }); test('GET /api/files/folder-images returns empty list when no thumbnails available', async () => { mockFolderImages = []; const { status, body } = await req('GET', `/api/files/folder-images?dir=${encodeURIComponent(rootDir)}`); expect(status).toBe(200); expect(body.images).toEqual([]); }); test('GET /api/files/folder-icon returns null when no icon available', async () => { mockFolderIconFile = null; const { status, body } = await req('GET', `/api/files/folder-icon?dir=${encodeURIComponent(rootDir)}`); expect(status).toBe(200); expect(body.icon).toBeNull(); }); test('GET /api/files/folder-icon returns source file path when icon is available', async () => { const imgPath = path.join(rootDir, 'cover.jpg'); fs.writeFileSync(imgPath, 'img'); mockFolderIconFile = imgPath; const { status, body } = await req('GET', `/api/files/folder-icon?dir=${encodeURIComponent(rootDir)}`); expect(status).toBe(200); expect(body.icon).toMatchObject({ filePath: imgPath }); }); test('POST /api/files/folder-icon sets explicit assignment when thumbnail is ready', async () => { const imgPath = path.join(rootDir, 'cover.jpg'); const thumbFile = path.join(rootDir, 'cover.webp'); fs.writeFileSync(imgPath, 'img'); fs.writeFileSync(thumbFile, 'webp'); mockThumbPath = thumbFile; const { status, body } = await req('POST', '/api/files/folder-icon', { folderPath: rootDir, imagePath: imgPath, }); expect(status).toBe(200); expect(body.ok).toBe(true); expect(lastFolderIconAssignment).toEqual({ folderPath: rootDir, imagePath: imgPath }); }); test('POST /api/files/folder-icon rejects image without cached thumbnail', async () => { const imgPath = path.join(rootDir, 'missing.jpg'); fs.writeFileSync(imgPath, 'img'); mockThumbPath = null; const { status, body } = await req('POST', '/api/files/folder-icon', { folderPath: rootDir, imagePath: imgPath, }); expect(status).toBe(404); expect(body.error).toMatch(/thumbnail not ready/i); }); test('POST /api/files/folder-icon clears assignment when imagePath is null', async () => { const { status, body } = await req('POST', '/api/files/folder-icon', { folderPath: rootDir, imagePath: null, }); expect(status).toBe(200); expect(body.ok).toBe(true); expect(lastFolderIconAssignment).toEqual({ folderPath: rootDir, imagePath: null }); }); test('POST /api/files/folder-icon returns 403 for read-only user', async () => { const label = path.basename(rootDir); mockUser = { username: 'reader', isAdmin: false, permissions: { [label]: { read: true, write: false } }, }; const imgPath = path.join(rootDir, 'photo.jpg'); fs.writeFileSync(imgPath, 'img'); const { status } = await req('POST', '/api/files/folder-icon', { folderPath: rootDir, imagePath: imgPath, }); expect(status).toBe(403); }); });