@flancer32/teq-web 0.3.1 → 0.4.0

package/test/unit/Back/Handler/Static/A/FileService.test.mjs

@@ -1,225 +0,0 @@
-import { describe, it, beforeEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { EventEmitter } from 'node:events';
-import { buildTestContainer } from '../../../../common.js';
-
-const normalize = p => p.replace(/\\/g, '/').replace(/\/+/g, '/').replace(/\/$/, '');
-
-class MockRes extends EventEmitter {
-  constructor() {
-    super();
-    this.data = '';
-    this.status = undefined;
-    this.headers = undefined;
-    this._hs = false;
-    this._ended = false;
-  }
-  get headersSent() {
-    return this._hs;
-  }
-  get writableEnded() {
-    return this._ended;
-  }
-  writeHead(status, headers) {
-    this.status = status;
-    this.headers = headers;
-    this._hs = true;
-  }
-  write(chunk) {
-    this.data += chunk;
-  }
-  end(chunk) {
-    if (chunk) this.write(chunk);
-    this._ended = true;
-    this.emit('finish');
-  }
-}
-
-describe('Fl32_Web_Back_Handler_Static_A_FileService', () => {
-  let storage, mockFs, mime, logger, logs, addFile, addDir;
-
-  beforeEach(() => {
-    storage = new Map();
-
-    // mock fs.promises.stat and createReadStream
-    mockFs = {
-      promises: {
-        stat: async p => {
-          const key = normalize(p);
-          if (!storage.has(key)) throw new Error('ENOENT');
-          const entry = storage.get(key);
-          return {
-            isFile: entry.isFile,
-            isDirectory: entry.isDirectory,
-            size: entry.size,
-            mtime: entry.mtime
-          };
-        }
-      },
-      createReadStream: p => ({
-        pipe: res => {
-          setImmediate(() => {
-            const key = normalize(p);
-            const entry = storage.get(key);
-            if (entry && entry.content != null) res.write(entry.content);
-            res.end();
-          });
-        }
-      })
-    };
-
-    // simple mime helper
-    mime = {
-      getByExt: () => 'text/plain'
-    };
-
-    logs = [];
-    // simple logger collecting calls
-    logger = {
-      info: (...args) => logs.push(['info', ...args]),
-      warn: (...args) => logs.push(['warn', ...args]),
-      exception: (...args) => logs.push(['exception', ...args])
-    };
-
-    // helpers to populate mock FS
-    addFile = (p, content) => {
-      const key = normalize(p);
-      storage.set(key, {
-        isFile: () => true,
-        isDirectory: () => false,
-        size: Buffer.byteLength(content),
-        mtime: new Date(),
-        content
-      });
-    };
-    addDir = p => {
-      const key = normalize(p);
-      storage.set(key, {
-        isFile: () => false,
-        isDirectory: () => true,
-        size: 0,
-        mtime: new Date()
-      });
-    };
-  });
-
-  it('serves existing file', async () => {
-    addFile('/root/a.txt', 'A');
-
-    /** @type {{ root: string, prefix: string, defaults: string[] }} */
-    const config = { root: '/root', prefix: '/p/', defaults: ['index.html'] };
-    const res = new MockRes();
-
-    const container = buildTestContainer();
-    container.register('node:fs', mockFs);
-    container.register('Fl32_Web_Back_Helper_Mime$', mime);
-    container.register('Fl32_Web_Back_Logger$', logger);
-
-    /** @type {Fl32_Web_Back_Handler_Static_A_FileService} */
-    const service = await container.get('Fl32_Web_Back_Handler_Static_A_FileService$');
-
-    const ok = await service.serve(config, 'a.txt', {}, res);
-    await new Promise(r => res.on('finish', r));
-
-    assert.ok(ok);
-    assert.strictEqual(res.status, 200);
-    assert.strictEqual(res.data, 'A');
-  });
-
-  it('returns false when file not found', async () => {
-    addDir('/root');
-
-    /** @type {{ root: string, prefix: string, defaults: string[] }} */
-    const config = { root: '/root', prefix: '/p/', defaults: ['index.html'] };
-    const res = new MockRes();
-
-    const container = buildTestContainer();
-    container.register('node:fs', mockFs);
-    container.register('Fl32_Web_Back_Helper_Mime$', mime);
-    container.register('Fl32_Web_Back_Logger$', logger);
-
-    /** @type {Fl32_Web_Back_Handler_Static_A_FileService} */
-    const service = await container.get('Fl32_Web_Back_Handler_Static_A_FileService$');
-
-    const ok = await service.serve(config, 'missing.txt', {}, res);
-    assert.strictEqual(ok, false);
-  });
-
-  it('logs info when file is missing during stat', async () => {
-    mockFs.promises.stat = async () => {
-      const err = new Error('ENOENT');
-      err.code = 'ENOENT';
-      throw err;
-    };
-    /** @type {{ root: string, prefix: string, defaults: string[] }} */
-    const config = { root: '/root', prefix: '/p/', defaults: [] };
-    const res = new MockRes();
-
-    const container = buildTestContainer();
-    container.register('node:fs', mockFs);
-    container.register('Fl32_Web_Back_Helper_Mime$', mime);
-    container.register('Fl32_Web_Back_Logger$', logger);
-    container.register('Fl32_Web_Back_Handler_Static_A_Fallback$', { apply: async p => p });
-
-    /** @type {Fl32_Web_Back_Handler_Static_A_FileService} */
-    const service = await container.get('Fl32_Web_Back_Handler_Static_A_FileService$');
-
-    const ok = await service.serve(config, 'missing.txt', {}, res);
-
-    assert.strictEqual(ok, false);
-    assert.strictEqual(logs.length, 1);
-    assert.strictEqual(logs[0][0], 'info');
-  });
-
-  it('logs warn on access errors', async () => {
-    /** force EACCES error */
-    mockFs.promises.stat = async () => {
-      const err = new Error('EACCES');
-      err.code = 'EACCES';
-      throw err;
-    };
-
-    /** @type {{ root: string, prefix: string, defaults: string[] }} */
-    const config = { root: '/root', prefix: '/p/', defaults: [] };
-    const res = new MockRes();
-
-    const container = buildTestContainer();
-    container.register('node:fs', mockFs);
-    container.register('Fl32_Web_Back_Helper_Mime$', mime);
-    container.register('Fl32_Web_Back_Logger$', logger);
-    container.register('Fl32_Web_Back_Handler_Static_A_Fallback$', { apply: async p => p });
-
-    /** @type {Fl32_Web_Back_Handler_Static_A_FileService} */
-    const service = await container.get('Fl32_Web_Back_Handler_Static_A_FileService$');
-
-    const ok = await service.serve(config, 'denied.txt', {}, res);
-
-    assert.strictEqual(ok, false);
-    assert.strictEqual(logs.length, 1);
-    assert.strictEqual(logs[0][0], 'warn');
-  });
-
-  it('logs exception on unexpected errors', async () => {
-    addFile('/root/x.txt', 'X');
-    mockFs.createReadStream = () => { throw new Error('boom'); };
-
-    /** @type {{ root: string, prefix: string, defaults: string[] }} */
-    const config = { root: '/root', prefix: '/p/', defaults: [] };
-    const res = new MockRes();
-
-    const container = buildTestContainer();
-    container.register('node:fs', mockFs);
-    container.register('Fl32_Web_Back_Helper_Mime$', mime);
-    container.register('Fl32_Web_Back_Logger$', logger);
-    container.register('Fl32_Web_Back_Handler_Static_A_Fallback$', { apply: async p => p });
-
-    /** @type {Fl32_Web_Back_Handler_Static_A_FileService} */
-    const service = await container.get('Fl32_Web_Back_Handler_Static_A_FileService$');
-
-    const ok = await service.serve(config, 'x.txt', {}, res);
-
-    assert.strictEqual(ok, false);
-    assert.strictEqual(logs.length, 1);
-    assert.strictEqual(logs[0][0], 'exception');
-  });
-});

package/test/unit/Back/Handler/Static/A/Registry.test.mjs

@@ -1,83 +0,0 @@
-import { describe, it } from 'node:test';
-import assert from 'node:assert/strict';
-import { buildTestContainer } from '../../../../common.js';
-
-/** Simple config factory mock */
-function getMockFactory() {
-    return { create: dto => ({ root: dto.root, prefix: dto.prefix }) };
-}
-
-describe('Fl32_Web_Back_Handler_Static_A_Registry', () => {
-    it('stores initial config', async () => {
-        const container = buildTestContainer();
-        container.register('Fl32_Web_Back_Handler_Static_A_Config$', getMockFactory());
-        /** @type {Fl32_Web_Back_Handler_Static_A_Registry} */
-        const registry = await container.get('Fl32_Web_Back_Handler_Static_A_Registry$');
-
-        registry.addConfigs([{ root: '/a', prefix: '/p/' }]);
-        const match = registry.find('/p/file.txt');
-
-        assert.ok(match);
-        assert.strictEqual(match.config.root, '/a');
-    });
-
-    it('adds config with new prefix', async () => {
-        const container = buildTestContainer();
-        container.register('Fl32_Web_Back_Handler_Static_A_Config$', getMockFactory());
-        const registry = await container.get('Fl32_Web_Back_Handler_Static_A_Registry$');
-
-        registry.addConfigs([{ root: '/a', prefix: '/p/' }]);
-        registry.addConfigs([{ root: '/b', prefix: '/p/s/' }]);
-
-        const match = registry.find('/p/s/file.txt');
-        assert.ok(match);
-        assert.strictEqual(match.config.root, '/b');
-    });
-
-    it('ignores config with existing prefix', async () => {
-        const container = buildTestContainer();
-        container.register('Fl32_Web_Back_Handler_Static_A_Config$', getMockFactory());
-        const registry = await container.get('Fl32_Web_Back_Handler_Static_A_Registry$');
-
-        registry.addConfigs([{ root: '/a', prefix: '/p/' }]);
-        registry.addConfigs([{ root: '/b', prefix: '/p/s/' }]);
-        registry.addConfigs([{ root: '/c', prefix: '/p/s/' }]);
-
-        const match = registry.find('/p/s/test.txt');
-        assert.ok(match);
-        assert.strictEqual(match.config.root, '/b');
-    });
-
-    it('logs warning when prefix already exists', async () => {
-        const log = [];
-        const container = buildTestContainer();
-        container.register('Fl32_Web_Back_Handler_Static_A_Config$', getMockFactory());
-        container.register('Fl32_Web_Back_Logger$', {
-            warn: (...args) => log.push(args)
-        });
-        const registry = await container.get('Fl32_Web_Back_Handler_Static_A_Registry$');
-
-        registry.addConfigs([{ root: '/a', prefix: '/p/' }]);
-        registry.addConfigs([{ root: '/b', prefix: '/p/' }]);
-
-        assert.strictEqual(log.length, 1);
-        assert.ok(log[0][0].includes('/p/'));
-    });
-
-    it('prefers longer prefix when matching', async () => {
-        const container = buildTestContainer();
-        container.register('Fl32_Web_Back_Handler_Static_A_Config$', getMockFactory());
-        const registry = await container.get('Fl32_Web_Back_Handler_Static_A_Registry$');
-
-        registry.addConfigs([
-            { root: '/a', prefix: '/p/' },
-            { root: '/b', prefix: '/p/s/' }
-        ]);
-
-        const match1 = registry.find('/p/s/x.txt');
-        const match2 = registry.find('/p/y.txt');
-
-        assert.strictEqual(match1.config.root, '/b');
-        assert.strictEqual(match2.config.root, '/a');
-    });
-});

package/test/unit/Back/Handler/Static/A/Resolver.test.mjs

@@ -1,73 +0,0 @@
-import { describe, it } from 'node:test';
-import assert from 'node:assert/strict';
-import { buildTestContainer } from '../../../../common.js';
-
-describe('Fl32_Web_Back_Handler_Static_A_Resolver', () => {
-    it('resolves allowed path', async () => {
-        const container = buildTestContainer();
-        /** @type {Fl32_Web_Back_Handler_Static_A_Resolver} */
-        const resolver = await container.get('Fl32_Web_Back_Handler_Static_A_Resolver$');
-
-        const { resolve } = await import('node:path');
-        const config = {
-            root: resolve('/root'),
-            prefix: '/p/',
-            allow: { pkg: ['a.txt'] }
-        };
-
-        const fsPath = resolver.resolve(config, 'pkg/a.txt');
-        assert.strictEqual(fsPath, resolve('/root/pkg/a.txt'));
-    });
-
-    it('returns null for disallowed path', async () => {
-        const container = buildTestContainer();
-        /** @type {Fl32_Web_Back_Handler_Static_A_Resolver} */
-        const resolver = await container.get('Fl32_Web_Back_Handler_Static_A_Resolver$');
-
-        const { resolve } = await import('node:path');
-        const config = {
-            root: resolve('/root'),
-            prefix: '/p/',
-            allow: { pkg: ['a.txt'] }
-        };
-
-        const result = resolver.resolve(config, 'pkg/b.txt');
-        assert.strictEqual(result, null);
-    });
-
-    it('throws on path traversal attempts', async () => {
-        const container = buildTestContainer();
-        /** @type {Fl32_Web_Back_Handler_Static_A_Resolver} */
-        const resolver = await container.get('Fl32_Web_Back_Handler_Static_A_Resolver$');
-
-        const { resolve } = await import('node:path');
-        const config = {
-            root: resolve('/root'),
-            prefix: '/p/',
-            allow: { pkg: ['a.txt'] }
-        };
-
-        assert.throws(
-            () => resolver.resolve(config, '../x'),
-            /Static access denied/
-        );
-    });
-
-    it('throws on absolute rel paths', async () => {
-        const container = buildTestContainer();
-        /** @type {Fl32_Web_Back_Handler_Static_A_Resolver} */
-        const resolver = await container.get('Fl32_Web_Back_Handler_Static_A_Resolver$');
-
-        const { resolve } = await import('node:path');
-        const config = {
-            root: resolve('/root'),
-            prefix: '/p/',
-            allow: { pkg: ['a.txt'] }
-        };
-
-        assert.throws(
-            () => resolver.resolve(config, '/etc/passwd'),
-            /Static access denied/
-        );
-    });
-});

package/test/unit/Back/Handler/Static/Static.test.mjs

@@ -1,235 +0,0 @@
-import {describe, it, beforeEach} from 'node:test';
-import assert from 'node:assert/strict';
-import {EventEmitter} from 'node:events';
-import {buildTestContainer} from '../../../common.js';
-
-/** Simple HTTP/2 constants mock */
-const mockHttp2 = {
-    constants: {
-        HTTP2_HEADER_CONTENT_LENGTH: 'content-length',
-        HTTP2_HEADER_CONTENT_TYPE: 'content-type',
-        HTTP2_HEADER_LAST_MODIFIED: 'last-modified',
-        HTTP_STATUS_OK: 200
-    }
-};
-
-/** Minimal path mock for FS key normalization */
-const mockPath = {
-    resolve: (...parts) => parts.join('/').replace(/\/+/g, '/'),
-    join: (...parts) => parts.join('/').replace(/\/+/g, '/'),
-    isAbsolute: p => p.startsWith('/'),
-    extname: p => {
-        const m = p.match(/(\.[^./]+)$/);
-        return m ? m[1] : '';
-    }
-};
-
-/** In-memory FS storage */
-let storage;
-let mockFs;
-
-function resetFs() {
-    storage = new Map();
-}
-
-function addFile(p, content) {
-    const key = mockPath.resolve(p);
-    storage.set(key, {
-        isFile: () => true,
-        isDirectory: () => false,
-        size: Buffer.byteLength(content),
-        mtime: new Date(),
-        content
-    });
-}
-
-function addDir(p) {
-    const key = mockPath.resolve(p);
-    storage.set(key, {
-        isFile: () => false,
-        isDirectory: () => true,
-        size: 0,
-        mtime: new Date(),
-        content: null
-    });
-}
-
-beforeEach(() => {
-    resetFs();
-    mockFs = {
-        promises: {
-            stat: async p => {
-                const key = mockPath.resolve(p);
-                if (!storage.has(key)) throw new Error('ENOENT');
-                const entry = storage.get(key);
-                return {
-                    isFile: entry.isFile,
-                    isDirectory: entry.isDirectory,
-                    size: entry.size,
-                    mtime: entry.mtime
-                };
-            }
-        },
-        createReadStream: p => ({
-            pipe: res => {
-                setImmediate(() => {
-                    const entry = storage.get(mockPath.resolve(p));
-                    if (entry && entry.content != null) res.write(entry.content);
-                    res.end();
-                });
-            }
-        })
-    };
-});
-
-/** Mock response with writable stream semantics */
-class MockRes extends EventEmitter {
-    constructor() {
-        super();
-        this.data = Buffer.alloc(0);
-        this.statusCode = undefined;
-        this.headers = undefined;
-        this._sent = false;
-        this._ended = false;
-    }
-
-    get headersSent() { return this._sent; }
-
-    get writableEnded() { return this._ended; }
-
-    writeHead(status, headers) {
-        this.statusCode = status;
-        this.headers = headers;
-        this._sent = true;
-    }
-
-    write(chunk) {
-        this.data = Buffer.concat([this.data, Buffer.from(chunk)]);
-    }
-
-    end(chunk) {
-        if (chunk) this.write(chunk);
-        this._ended = true;
-        this.emit('finish');
-    }
-}
-
-describe('Fl32_Web_Back_Handler_Static', () => {
-    let container;
-
-    beforeEach(() => {
-        container = buildTestContainer();
-        container.register('node:fs', mockFs);
-        container.register('node:http2', mockHttp2);
-        container.register('node:path', mockPath);
-        container.register('Fl32_Web_Back_Logger$', {
-            warn: () => {},
-            exception: () => {}
-        });
-    });
-
-    it('serves from the most specific source', async () => {
-        addDir('/a');
-        addFile('/a/test.txt', 'A');
-        addDir('/b');
-        addFile('/b/test.txt', 'B');
-
-        /** @type {Fl32_Web_Back_Dto_Handler_Source} */
-        const dtoSource = await container.get('Fl32_Web_Back_Dto_Handler_Source$');
-        /** @type {Fl32_Web_Back_Handler_Static} */
-        const handler = await container.get('Fl32_Web_Back_Handler_Static$');
-
-        await handler.init({
-            sources: [
-                dtoSource.create({prefix: '/files/', root: '/a', allow: {'.': ['.']}, defaults: []}),
-                dtoSource.create({prefix: '/files/special/', root: '/b', allow: {'.': ['.']}, defaults: []})
-            ]
-        });
-
-        const res = new MockRes();
-        const ok = await handler.handle({url: '/files/special/test.txt'}, res);
-        await new Promise(r => res.on('finish', r));
-
-        assert.strictEqual(ok, true);
-        assert.strictEqual(res.data.toString(), 'B');
-    });
-
-    it('enforces allow-list rules', async () => {
-        addFile('src/Back/Server.js', 'class X {}');
-        addFile('src/Back/Handler/Static.js', 'ignore');
-
-        /** @type {Fl32_Web_Back_Dto_Handler_Source} */
-        const dtoSource = await container.get('Fl32_Web_Back_Dto_Handler_Source$');
-        /** @type {Fl32_Web_Back_Handler_Static} */
-        const handler = await container.get('Fl32_Web_Back_Handler_Static$');
-
-        await handler.init({
-            sources: [
-                dtoSource.create({prefix: '/s/', root: 'src', allow: {Back: ['Server.js']}, defaults: []})
-            ]
-        });
-
-        const okRes = new MockRes();
-        const ok = await handler.handle({url: '/s/Back/Server.js'}, okRes);
-        await new Promise(r => okRes.on('finish', r));
-        assert.strictEqual(ok, true);
-
-        const badRes = new MockRes();
-        const bad = await handler.handle({url: '/s/Back/Handler/Static.js'}, badRes);
-        assert.strictEqual(bad, false);
-        assert.strictEqual(badRes.headersSent, false);
-    });
-
-    it('serves index files in directories', async () => {
-        addDir('/dir');
-        addDir('/dir/d');
-        addFile('/dir/d/index.txt', 'INDEX');
-
-        /** @type {Fl32_Web_Back_Dto_Handler_Source} */
-        const dtoSource = await container.get('Fl32_Web_Back_Dto_Handler_Source$');
-        /** @type {Fl32_Web_Back_Handler_Static} */
-        const handler = await container.get('Fl32_Web_Back_Handler_Static$');
-
-        await handler.init({
-            sources: [
-                dtoSource.create({
-                    prefix: '/w/',
-                    root: '/dir',
-                    allow: {'.': ['.']},
-                    defaults: ['index.txt']
-                })
-            ]
-        });
-
-        const res = new MockRes();
-        const ok = await handler.handle({url: '/w/d/'}, res);
-        await new Promise(r => res.on('finish', r));
-
-        assert.strictEqual(ok, true);
-        assert.strictEqual(res.data.toString(), 'INDEX');
-    });
-
-    it('rejects traversal and unmatched prefixes', async () => {
-        addFile('/safe/file.txt', 'ok');
-
-        /** @type {Fl32_Web_Back_Dto_Handler_Source} */
-        const dtoSource = await container.get('Fl32_Web_Back_Dto_Handler_Source$');
-        /** @type {Fl32_Web_Back_Handler_Static} */
-        const handler = await container.get('Fl32_Web_Back_Handler_Static$');
-
-        await handler.init({
-            sources: [
-                dtoSource.create({prefix: '/p/', root: '/safe', allow: {'.': ['.']}, defaults: []})
-            ]
-        });
-
-        const res1 = new MockRes();
-        const bad1 = await handler.handle({url: '/p/../file.txt'}, res1);
-        assert.strictEqual(bad1, false);
-
-        const res2 = new MockRes();
-        const bad2 = await handler.handle({url: '/x/file.txt'}, res2);
-        assert.strictEqual(bad2, false);
-        assert.strictEqual(res2.headersSent, false);
-    });
-});

package/test/unit/Back/Helper/Order/Kahn.test.mjs

@@ -1,59 +0,0 @@
-import {describe, it} from 'node:test';
-import assert from 'node:assert/strict';
-import {buildTestContainer} from '../../../common.js';
-
-describe('Fl32_Web_Back_Helper_Order_Kahn', () => {
-
-    describe('sort', () => {
-        it('should sort handlers respecting after/before constraints', async () => {
-            const container = buildTestContainer();
-            const sorter = await container.get('Fl32_Web_Back_Helper_Order_Kahn$');
-
-            // Mock handlers with dependencies
-            const mk = (name, after = [], before = []) => ({
-                getRegistrationInfo: () => ({name, after, before})
-            });
-
-            const a = mk('a');                  // no deps
-            const b = mk('b', ['a']);           // after a
-            const c = mk('c', [], ['b']);       // before b (== b after c)
-            const d = mk('d', ['b', 'c']);      // after b and c
-
-            const result = sorter.sort([a, b, c, d]);
-            const names = result.map(h => h.getRegistrationInfo().name);
-            assert.deepStrictEqual(names, ['a', 'c', 'b', 'd']);
-        });
-
-        it('should detect circular dependency', async () => {
-            const container = buildTestContainer();
-            const sorter = await container.get('Fl32_Web_Back_Helper_Order_Kahn$');
-
-            const mk = (name, after = [], before = []) => ({
-                getRegistrationInfo: () => ({name, after, before})
-            });
-
-            const x = mk('x', ['y']);
-            const y = mk('y', ['x']);
-
-            assert.throws(() => {
-                sorter.sort([x, y]);
-            }, /Circular dependency detected/);
-        });
-
-        it('should ignore references to unknown handlers', async () => {
-            const container = buildTestContainer();
-            const sorter = await container.get('Fl32_Web_Back_Helper_Order_Kahn$');
-
-            const mk = (name, after = [], before = []) => ({
-                getRegistrationInfo: () => ({name, after, before})
-            });
-
-            const a = mk('a', ['ghost']); // ghost does not exist
-            const b = mk('b');
-
-            const result = sorter.sort([a, b]);
-            const names = result.map(h => h.getRegistrationInfo().name);
-            assert.deepStrictEqual(names.sort(), ['a', 'b']); // Order can vary, but no crash
-        });
-    });
-});