192 lines
7.1 KiB
JavaScript
192 lines
7.1 KiB
JavaScript
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'), '<h1>Hola</h1>', '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 = '<?php echo "Hello World"; ?>';
|
|
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;
|
|
}
|
|
);
|
|
});
|
|
});
|