import { describe, it, beforeEach, afterEach } from 'node:test';
import assert from 'node:assert/strict';
import fs from 'node:fs';
import path from 'node:path';
import { MockApacheDriver } from '../../src/infrastructure/apache/mock.apache.driver.js';
import { FolderService } from '../../src/services/folder.service.js';
describe('Unit Tests: Folder Service & File Manager (folder.service.js)', () => {
const testTmpDir = path.resolve(process.cwd(), '.tmp/test-folder-manager');
let mockDriver;
let folderService;
let testWebRoot;
beforeEach(() => {
if (fs.existsSync(testTmpDir)) {
fs.rmSync(testTmpDir, { recursive: true, force: true });
}
mockDriver = new MockApacheDriver(testTmpDir);
testWebRoot = mockDriver.webRoot;
folderService = new FolderService(mockDriver);
});
afterEach(() => {
if (fs.existsSync(testTmpDir)) {
fs.rmSync(testTmpDir, { recursive: true, force: true });
}
});
it('listFilesInFolder: debe listar archivos en la raíz y en subdirectorios con metadatos completos', async () => {
const siteDir = path.join(testWebRoot, 'my-site');
const subDir = path.join(siteDir, 'css');
fs.mkdirSync(subDir, { recursive: true });
fs.writeFileSync(path.join(siteDir, 'index.html'), '
Hola
', 'utf-8');
fs.writeFileSync(path.join(subDir, 'style.css'), 'body { margin: 0; }', 'utf-8');
// Listar raíz
const rootList = await folderService.listFilesInFolder('my-site');
assert.equal(rootList.folder, 'my-site');
assert.equal(rootList.path, '');
assert.equal(rootList.files.length, 2);
const indexFile = rootList.files.find((f) => f.name === 'index.html');
assert.ok(indexFile);
assert.equal(indexFile.type, 'file');
assert.equal(indexFile.isEditable, true);
const cssFolder = rootList.files.find((f) => f.name === 'css');
assert.ok(cssFolder);
assert.equal(cssFolder.type, 'directory');
// Listar subdirectorio
const subList = await folderService.listFilesInFolder('my-site', 'css');
assert.equal(subList.folder, 'my-site');
assert.equal(subList.path, 'css');
assert.equal(subList.files.length, 1);
assert.equal(subList.files[0].name, 'style.css');
});
it('readFileContent: debe leer el contenido de texto hasta 2MB', async () => {
const siteDir = path.join(testWebRoot, 'my-site');
fs.mkdirSync(siteDir, { recursive: true });
const content = '';
fs.writeFileSync(path.join(siteDir, 'info.php'), content, 'utf-8');
const result = await folderService.readFileContent('my-site', 'info.php');
assert.equal(result.folder, 'my-site');
assert.equal(result.name, 'info.php');
assert.equal(result.content, content);
assert.ok(result.sizeBytes > 0);
});
it('readFileContent: debe rechazar la lectura si el archivo supera los 2MB', async () => {
const siteDir = path.join(testWebRoot, 'my-site');
fs.mkdirSync(siteDir, { recursive: true });
const largeFile = path.join(siteDir, 'huge.dat');
// Crear archivo de 2.5 MB
const buffer = Buffer.alloc(2.5 * 1024 * 1024);
fs.writeFileSync(largeFile, buffer);
await assert.rejects(
async () => folderService.readFileContent('my-site', 'huge.dat'),
(err) => {
assert.equal(err.status, 400);
assert.equal(err.code, 'FILE_TOO_LARGE');
return true;
}
);
});
it('saveFileContent: debe guardar contenido y aplicar permisos 0664', async () => {
const siteDir = path.join(testWebRoot, 'my-site');
fs.mkdirSync(siteDir, { recursive: true });
const result = await folderService.saveFileContent('my-site', 'app.js', 'console.log("ok");');
assert.equal(result.name, 'app.js');
assert.equal(result.path, 'app.js');
const filePath = path.join(siteDir, 'app.js');
assert.ok(fs.existsSync(filePath));
const savedContent = fs.readFileSync(filePath, 'utf-8');
assert.equal(savedContent, 'console.log("ok");');
});
it('uploadFile: debe decodificar contenido base64 y guardarlo correctamente', async () => {
const siteDir = path.join(testWebRoot, 'my-site');
fs.mkdirSync(siteDir, { recursive: true });
const rawText = 'Hello from base64 upload!';
const base64 = Buffer.from(rawText, 'utf-8').toString('base64');
const uploaded = await folderService.uploadFile('my-site', '', 'uploaded.txt', base64);
assert.equal(uploaded.name, 'uploaded.txt');
const filePath = path.join(siteDir, 'uploaded.txt');
assert.ok(fs.existsSync(filePath));
assert.equal(fs.readFileSync(filePath, 'utf-8'), rawText);
});
it('createItem: debe crear archivos y directorios con validación de colisiones', async () => {
const siteDir = path.join(testWebRoot, 'my-site');
fs.mkdirSync(siteDir, { recursive: true });
// Crear directorio
const dirItem = await folderService.createItem('my-site', '', 'assets', 'dir');
assert.equal(dirItem.type, 'directory');
assert.ok(fs.existsSync(path.join(siteDir, 'assets')));
// Crear archivo dentro de assets
const fileItem = await folderService.createItem('my-site', 'assets', 'main.css', 'file');
assert.equal(fileItem.type, 'file');
assert.ok(fs.existsSync(path.join(siteDir, 'assets/main.css')));
// Debe rechazar duplicados
await assert.rejects(
async () => folderService.createItem('my-site', 'assets', 'main.css', 'file'),
(err) => {
assert.equal(err.status, 409);
assert.equal(err.code, 'ITEM_ALREADY_EXISTS');
return true;
}
);
});
it('deleteItem: debe eliminar archivos y directorios de forma segura', async () => {
const siteDir = path.join(testWebRoot, 'my-site');
const targetFile = path.join(siteDir, 'trash.txt');
fs.mkdirSync(siteDir, { recursive: true });
fs.writeFileSync(targetFile, 'delete me');
const res = await folderService.deleteItem('my-site', 'trash.txt');
assert.equal(res.deleted, true);
assert.equal(fs.existsSync(targetFile), false);
});
it('deleteItem: debe impedir la eliminación de la raíz del subdominio', async () => {
const siteDir = path.join(testWebRoot, 'my-site');
fs.mkdirSync(siteDir, { recursive: true });
await assert.rejects(
async () => folderService.deleteItem('my-site', ''),
(err) => {
assert.equal(err.status, 403);
assert.equal(err.code, 'FORBIDDEN_OPERATION');
return true;
}
);
});
it('debe proteger contra intentos de Path Traversal en todas las operaciones', async () => {
const siteDir = path.join(testWebRoot, 'my-site');
fs.mkdirSync(siteDir, { recursive: true });
await assert.rejects(
async () => folderService.readFileContent('my-site', '../../../../etc/passwd'),
(err) => {
assert.equal(err.status, 403);
assert.equal(err.code, 'PATH_TRAVERSAL_DETECTED');
return true;
}
);
await assert.rejects(
async () => folderService.saveFileContent('my-site', '../../../../etc/malicious', 'hacked'),
(err) => {
assert.equal(err.status, 403);
assert.equal(err.code, 'PATH_TRAVERSAL_DETECTED');
return true;
}
);
});
});