koa-classic-server 3.0.0 → 3.1.0

package/__tests__/template-timeout.test.js

@@ -1,321 +0,0 @@
-const Koa = require('koa');
-const koaClassicServer = require('../index.cjs');
-const supertest = require('supertest');
-const path = require('path');
-
-const ROOT = path.join(__dirname, 'publicWwwTest');
-const TEMPLATE_URL = '/ejs-templates/simple.ejs';
-
-function buildServer(renderFn, opts = {}) {
-    const app = new Koa();
-    app.silent = true;
-    app.use(koaClassicServer(ROOT, {
-        method: ['GET'],
-        hidden: { dotFiles: { default: 'hidden' }, dotDirs: { default: 'visible' } },
-        template: {
-            ext: ['ejs'],
-            render: renderFn,
-            ...(opts.renderTimeout !== undefined ? { renderTimeout: opts.renderTimeout } : {})
-        }
-    }));
-    const server = app.listen();
-    return { server, request: supertest(server) };
-}
-
-// Sleep that does not keep the event loop alive — used to simulate
-// non-cooperative long-running work without leaving orphan timers behind.
-function unrefSleep(ms) {
-    return new Promise(resolve => {
-        const t = setTimeout(resolve, ms);
-        if (typeof t.unref === 'function') t.unref();
-    });
-}
-
-describe('template.renderTimeout', () => {
-    let consoleErrorSpy;
-
-    beforeEach(() => {
-        consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
-    });
-
-    afterEach(() => {
-        consoleErrorSpy.mockRestore();
-    });
-
-    describe('Factory validation', () => {
-        test('rejects negative renderTimeout', () => {
-            expect(() => koaClassicServer(ROOT, {
-                template: { ext: ['ejs'], render: () => {}, renderTimeout: -1 }
-            })).toThrow(/renderTimeout must be a finite number/);
-        });
-
-        test('rejects non-number renderTimeout', () => {
-            expect(() => koaClassicServer(ROOT, {
-                template: { ext: ['ejs'], render: () => {}, renderTimeout: '5000' }
-            })).toThrow(/renderTimeout must be a finite number/);
-        });
-
-        test('rejects NaN renderTimeout', () => {
-            expect(() => koaClassicServer(ROOT, {
-                template: { ext: ['ejs'], render: () => {}, renderTimeout: NaN }
-            })).toThrow(/renderTimeout must be a finite number/);
-        });
-
-        test('rejects Infinity renderTimeout', () => {
-            expect(() => koaClassicServer(ROOT, {
-                template: { ext: ['ejs'], render: () => {}, renderTimeout: Infinity }
-            })).toThrow(/renderTimeout must be a finite number/);
-        });
-
-        test('accepts 0 (disabled)', () => {
-            expect(() => koaClassicServer(ROOT, {
-                template: { ext: ['ejs'], render: () => {}, renderTimeout: 0 }
-            })).not.toThrow();
-        });
-
-        test('accepts positive integer', () => {
-            expect(() => koaClassicServer(ROOT, {
-                template: { ext: ['ejs'], render: () => {}, renderTimeout: 1000 }
-            })).not.toThrow();
-        });
-
-        test('defaults to 30000 when undefined', () => {
-            const opts = { template: { ext: ['ejs'], render: () => {} } };
-            koaClassicServer(ROOT, opts);
-            expect(opts.template.renderTimeout).toBe(30000);
-        });
-    });
-
-    describe('Successful render within timeout', () => {
-        let env;
-        afterEach(() => env && env.server.close());
-
-        test('returns 200 when render completes before timeout', async () => {
-            env = buildServer(async (ctx) => {
-                await new Promise(r => setTimeout(r, 20));
-                ctx.type = 'text/html';
-                ctx.body = '<p>ok</p>';
-            }, { renderTimeout: 500 });
-
-            const res = await env.request.get(TEMPLATE_URL);
-            expect(res.status).toBe(200);
-            expect(res.text).toContain('ok');
-        });
-    });
-
-    describe('Timeout behaviour', () => {
-        let env;
-        afterEach(() => env && env.server.close());
-
-        test('returns 504 when render exceeds timeout', async () => {
-            env = buildServer(async () => {
-                await unrefSleep(5000);
-            }, { renderTimeout: 100 });
-
-            const res = await env.request.get(TEMPLATE_URL);
-            expect(res.status).toBe(504);
-            expect(res.text).toContain('Gateway Timeout');
-            expect(res.text).toContain('took too long to render');
-        });
-
-        test('504 response carries security headers', async () => {
-            env = buildServer(async () => {
-                await unrefSleep(5000);
-            }, { renderTimeout: 50 });
-
-            const res = await env.request.get(TEMPLATE_URL);
-            expect(res.status).toBe(504);
-            expect(res.headers['content-security-policy']).toMatch(/default-src 'none'/);
-            expect(res.headers['x-content-type-options']).toBe('nosniff');
-            expect(res.headers['x-frame-options']).toBe('DENY');
-        });
-
-        test('renderTimeout: 0 disables the timer (render is allowed to run long)', async () => {
-            env = buildServer(async (ctx) => {
-                await new Promise(r => setTimeout(r, 200));
-                ctx.type = 'text/html';
-                ctx.body = '<p>slow but ok</p>';
-            }, { renderTimeout: 0 });
-
-            const res = await env.request.get(TEMPLATE_URL);
-            expect(res.status).toBe(200);
-            expect(res.text).toContain('slow but ok');
-        });
-    });
-
-    describe('Render argument contract', () => {
-        let env;
-        afterEach(() => env && env.server.close());
-
-        test('render is called with (ctx, next, filePath, rawBuffer, signal) in that order', async () => {
-            let received;
-            env = buildServer(async (...args) => {
-                received = args;
-                args[0].body = 'ok';
-            }, { renderTimeout: 1000 });
-
-            await env.request.get(TEMPLATE_URL);
-
-            expect(received).toHaveLength(5);
-            // ctx: Koa context — must expose req/res/state
-            expect(received[0]).toBeDefined();
-            expect(received[0].req).toBeDefined();
-            expect(received[0].res).toBeDefined();
-            expect(received[0].state).toBeDefined();
-            // next: function (downstream middleware)
-            expect(typeof received[1]).toBe('function');
-            // filePath: absolute path to the requested file
-            expect(typeof received[2]).toBe('string');
-            expect(path.isAbsolute(received[2])).toBe(true);
-            expect(received[2]).toMatch(/simple\.ejs$/);
-            // rawBuffer: Buffer or null depending on serverCache.rawFile state
-            expect(received[3] === null || Buffer.isBuffer(received[3])).toBe(true);
-            // signal: AbortSignal
-            expect(received[4]).toBeInstanceOf(AbortSignal);
-        });
-    });
-
-    describe('AbortSignal contract', () => {
-        let env;
-        afterEach(() => env && env.server.close());
-
-        test('passes an AbortSignal as 5th argument', async () => {
-            let receivedSignal;
-            env = buildServer(async (ctx, _next, _path, _buf, signal) => {
-                receivedSignal = signal;
-                ctx.body = 'ok';
-            }, { renderTimeout: 1000 });
-
-            await env.request.get(TEMPLATE_URL);
-            expect(receivedSignal).toBeInstanceOf(AbortSignal);
-            expect(receivedSignal.aborted).toBe(false);
-        });
-
-        test('signal is NOT aborted after a successful render completes', async () => {
-            let signalAtEnd;
-            let signalRef;
-            env = buildServer(async (ctx, _next, _path, _buf, signal) => {
-                signalRef = signal;
-                await new Promise(r => setTimeout(r, 20));
-                signalAtEnd = signal.aborted;
-                ctx.type = 'text/html';
-                ctx.body = '<p>done</p>';
-            }, { renderTimeout: 1000 });
-
-            const res = await env.request.get(TEMPLATE_URL);
-            expect(res.status).toBe(200);
-            // Signal must not be aborted at the end of a successful render
-            expect(signalAtEnd).toBe(false);
-            // ...and must remain non-aborted after the handler finishes
-            // (i.e. our cleanup must not abort it as a side-effect)
-            await new Promise(r => setTimeout(r, 50));
-            expect(signalRef.aborted).toBe(false);
-        });
-
-        test('signal aborts when render times out', async () => {
-            let signalAtTimeout = null;
-            env = buildServer(async (ctx, _next, _path, _buf, signal) => {
-                await unrefSleep(300);
-                signalAtTimeout = signal.aborted;
-            }, { renderTimeout: 50 });
-
-            const res = await env.request.get(TEMPLATE_URL);
-            expect(res.status).toBe(504);
-            await new Promise(r => setTimeout(r, 400));
-            expect(signalAtTimeout).toBe(true);
-        });
-
-        test('cooperative render that honours signal terminates early', async () => {
-            const renderDuration = jest.fn();
-            env = buildServer(async (ctx, _next, _path, _buf, signal) => {
-                const start = Date.now();
-                try {
-                    await new Promise((resolve, reject) => {
-                        const t = setTimeout(resolve, 5000);
-                        signal.addEventListener('abort', () => {
-                            clearTimeout(t);
-                            reject(new Error('aborted'));
-                        });
-                    });
-                } finally {
-                    renderDuration(Date.now() - start);
-                }
-            }, { renderTimeout: 50 });
-
-            const res = await env.request.get(TEMPLATE_URL);
-            expect(res.status).toBe(504);
-            await new Promise(r => setTimeout(r, 200));
-            const elapsed = renderDuration.mock.calls[0]?.[0] ?? 9999;
-            expect(elapsed).toBeLessThan(1000);
-        });
-    });
-
-    describe('Error handling integrity', () => {
-        let env;
-        afterEach(() => env && env.server.close());
-
-        test('late rejection after timeout does not crash the process', async () => {
-            const unhandledHandler = jest.fn();
-            process.on('unhandledRejection', unhandledHandler);
-
-            env = buildServer(async () => {
-                await new Promise(r => setTimeout(r, 100));
-                throw new Error('late failure');
-            }, { renderTimeout: 30 });
-
-            const res = await env.request.get(TEMPLATE_URL);
-            expect(res.status).toBe(504);
-
-            await new Promise(r => setTimeout(r, 250));
-            process.off('unhandledRejection', unhandledHandler);
-            expect(unhandledHandler).not.toHaveBeenCalled();
-        });
-
-        test('synchronous render returning rejected promise still produces 500', async () => {
-            env = buildServer(() => Promise.reject(new Error('boom')), { renderTimeout: 1000 });
-
-            const res = await env.request.get(TEMPLATE_URL);
-            expect(res.status).toBe(500);
-            expect(res.text).toContain('Internal Server Error');
-        });
-
-        test('synchronous throw in render produces 500', async () => {
-            env = buildServer(() => { throw new Error('sync boom'); }, { renderTimeout: 1000 });
-
-            const res = await env.request.get(TEMPLATE_URL);
-            expect(res.status).toBe(500);
-            expect(res.text).toContain('Internal Server Error');
-        });
-    });
-
-    describe('Client disconnect', () => {
-        let env;
-        afterEach(() => env && env.server.close());
-
-        test('signal aborts when client closes the connection before render finishes', async () => {
-            let abortObserved = false;
-            env = buildServer(async (ctx, _next, _path, _buf, signal) => {
-                signal.addEventListener('abort', () => { abortObserved = true; });
-                await unrefSleep(1000);
-                ctx.body = 'late';
-            }, { renderTimeout: 0 });
-
-            const addr = env.server.address();
-            const http = require('http');
-            await new Promise((resolve) => {
-                const req = http.request({
-                    host: addr.address === '::' ? '127.0.0.1' : addr.address,
-                    port: addr.port,
-                    path: TEMPLATE_URL,
-                    method: 'GET'
-                }, () => {});
-                req.on('error', () => {});
-                req.end();
-                setTimeout(() => { req.destroy(); resolve(); }, 50);
-            });
-
-            await new Promise(r => setTimeout(r, 100));
-            expect(abortObserved).toBe(true);
-        });
-    });
-});

package/__tests__/test-regex-quick.js

@@ -1,158 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Quick test: RegExp index option
- */
-
-const Koa = require('koa');
-const koaClassicServer = require('./index.cjs');
-const fs = require('fs');
-const path = require('path');
-const http = require('http');
-
-// Crea directory di test
-const testDir = path.join(__dirname, 'test-regex-temp');
-if (fs.existsSync(testDir)) {
-    fs.readdirSync(testDir).forEach(file => {
-        fs.unlinkSync(path.join(testDir, file));
-    });
-    fs.rmdirSync(testDir);
-}
-fs.mkdirSync(testDir);
-
-// Test case 1: Case-insensitive matching
-console.log('\n📋 TEST 1: Case-insensitive /index\\.html/i\n');
-console.log('File creati:');
-console.log('  - INDEX.HTML (maiuscolo)');
-console.log('  - other.txt\n');
-
-fs.writeFileSync(path.join(testDir, 'INDEX.HTML'), '<h1>INDEX.HTML (MAIUSCOLO)</h1>');
-fs.writeFileSync(path.join(testDir, 'other.txt'), 'altro file');
-
-const app1 = new Koa();
-app1.use(koaClassicServer(testDir, {
-    index: [/index\.html/i]  // ← REGEXP CASE-INSENSITIVE!
-}));
-
-const server1 = app1.listen(9001);
-
-// Test la richiesta
-setTimeout(() => {
-    http.get('http://localhost:9001/', (res) => {
-        let data = '';
-        res.on('data', chunk => data += chunk);
-        res.on('end', () => {
-            if (data.includes('INDEX.HTML (MAIUSCOLO)')) {
-                console.log('✅ SUCCESS: Il server ha trovato INDEX.HTML usando /index\\.html/i');
-                console.log('   Contenuto ricevuto: ' + data.trim());
-            } else {
-                console.log('❌ FAIL: Pattern non ha matchato');
-                console.log('   Contenuto ricevuto: ' + data);
-            }
-
-            server1.close();
-
-            // Test case 2
-            runTest2();
-        });
-    });
-}, 100);
-
-function runTest2() {
-    // Pulisci directory
-    fs.readdirSync(testDir).forEach(file => {
-        fs.unlinkSync(path.join(testDir, file));
-    });
-
-    console.log('\n📋 TEST 2: Multi-extension /index\\.(html|htm)/i\n');
-    console.log('File creati:');
-    console.log('  - Index.HTM (mixed case, estensione .htm)');
-    console.log('  - other.html\n');
-
-    fs.writeFileSync(path.join(testDir, 'Index.HTM'), '<h1>Index.HTM (mixed case)</h1>');
-    fs.writeFileSync(path.join(testDir, 'other.html'), '<h1>altro</h1>');
-
-    const app2 = new Koa();
-    app2.use(koaClassicServer(testDir, {
-        index: [/index\.(html|htm)/i]  // ← REGEXP con (html|htm)!
-    }));
-
-    const server2 = app2.listen(9002);
-
-    setTimeout(() => {
-        http.get('http://localhost:9002/', (res) => {
-            let data = '';
-            res.on('data', chunk => data += chunk);
-            res.on('end', () => {
-                if (data.includes('Index.HTM (mixed case)')) {
-                    console.log('✅ SUCCESS: Il server ha trovato Index.HTM usando /index\\.(html|htm)/i');
-                    console.log('   Contenuto ricevuto: ' + data.trim());
-                } else {
-                    console.log('❌ FAIL: Pattern non ha matchato');
-                    console.log('   Contenuto ricevuto: ' + data);
-                }
-
-                server2.close();
-
-                // Test case 3
-                runTest3();
-            });
-        });
-    }, 100);
-}
-
-function runTest3() {
-    // Pulisci directory
-    fs.readdirSync(testDir).forEach(file => {
-        fs.unlinkSync(path.join(testDir, file));
-    });
-
-    console.log('\n📋 TEST 3: Array con priorità [/index\\.html/i, /default\\.html/i]\n');
-    console.log('File creati:');
-    console.log('  - DEFAULT.HTML (maiuscolo)');
-    console.log('  - other.txt\n');
-    console.log('Nota: index.html NON esiste, dovrebbe trovare default.html\n');
-
-    fs.writeFileSync(path.join(testDir, 'DEFAULT.HTML'), '<h1>DEFAULT.HTML (fallback)</h1>');
-    fs.writeFileSync(path.join(testDir, 'other.txt'), 'altro');
-
-    const app3 = new Koa();
-    app3.use(koaClassicServer(testDir, {
-        index: [
-            /index\.html/i,    // Prima cerca index.html (NON esiste)
-            /default\.html/i   // Poi cerca default.html (ESISTE!)
-        ]
-    }));
-
-    const server3 = app3.listen(9003);
-
-    setTimeout(() => {
-        http.get('http://localhost:9003/', (res) => {
-            let data = '';
-            res.on('data', chunk => data += chunk);
-            res.on('end', () => {
-                if (data.includes('DEFAULT.HTML (fallback)')) {
-                    console.log('✅ SUCCESS: Il server ha fatto fallback a DEFAULT.HTML');
-                    console.log('   Contenuto ricevuto: ' + data.trim());
-                } else {
-                    console.log('❌ FAIL: Fallback non ha funzionato');
-                    console.log('   Contenuto ricevuto: ' + data);
-                }
-
-                server3.close();
-
-                // Cleanup finale
-                cleanup();
-            });
-        });
-    }, 100);
-}
-
-function cleanup() {
-    console.log('\n🧹 Pulizia...\n');
-    fs.readdirSync(testDir).forEach(file => {
-        fs.unlinkSync(path.join(testDir, file));
-    });
-    fs.rmdirSync(testDir);
-    console.log('✅ Tutti i test completati!\n');
-}

package/__tests__/useOriginalUrl.test.js

@@ -1,213 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//
-//  TEST FOR useOriginalUrl OPTION
-//  This test verifies that the useOriginalUrl option works correctly with URL rewriting middleware
-//
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-const supertest = require('supertest');
-const koaClassicServer = require('../index.cjs');
-const Koa = require('koa');
-const fs = require('fs');
-const path = require('path');
-
-const rootDir = path.join(__dirname, 'publicWwwTest');
-
-// Create a simple test file if it doesn't exist
-const testFilePath = path.join(rootDir, 'test-page.html');
-const testFileContent = '<!DOCTYPE html><html><head><title>Test Page</title></head><body><h1>Test Page</h1></body></html>';
-
-beforeAll(() => {
-    // Ensure test directory exists
-    if (!fs.existsSync(rootDir)) {
-        fs.mkdirSync(rootDir, { recursive: true });
-    }
-
-    // Create test file
-    if (!fs.existsSync(testFilePath)) {
-        fs.writeFileSync(testFilePath, testFileContent, 'utf-8');
-    }
-});
-
-describe('useOriginalUrl option tests', () => {
-
-    describe('Default behavior (useOriginalUrl: true)', () => {
-        let app;
-        let server;
-
-        beforeAll(() => {
-            app = new Koa();
-
-            // i18n middleware that rewrites URLs
-            app.use(async (ctx, next) => {
-                if (ctx.path.match(/^\/it\//)) {
-                    // Rewrite /it/page.html to /page.html
-                    ctx.url = ctx.path.replace(/^\/it/, '');
-                }
-                await next();
-            });
-
-            // Serve files with default useOriginalUrl: true
-            app.use(koaClassicServer(rootDir, {
-                useOriginalUrl: true  // Default behavior
-            }));
-
-            server = app.listen();
-        });
-
-        afterAll(() => {
-            server.close();
-        });
-
-        test('should use ctx.originalUrl (original request path)', async () => {
-            // Request /it/test-page.html
-            // ctx.originalUrl = /it/test-page.html (unchanged)
-            // ctx.url = /test-page.html (rewritten by middleware)
-            // With useOriginalUrl: true, server looks for /it/test-page.html (which doesn't exist)
-            const response = await supertest(server).get('/it/test-page.html');
-
-            // Should return 404 because /it/test-page.html doesn't exist
-            expect(response.status).toBe(404);
-        });
-
-        test('should serve file without rewriting', async () => {
-            // Request /test-page.html directly (no rewriting)
-            const response = await supertest(server).get('/test-page.html');
-
-            // Should return 200 and the file content
-            expect(response.status).toBe(200);
-            expect(response.text).toContain('Test Page');
-        });
-    });
-
-    describe('URL rewriting support (useOriginalUrl: false)', () => {
-        let app;
-        let server;
-
-        beforeAll(() => {
-            app = new Koa();
-
-            // i18n middleware that rewrites URLs
-            app.use(async (ctx, next) => {
-                if (ctx.path.match(/^\/it\//)) {
-                    // Rewrite /it/page.html to /page.html
-                    ctx.url = ctx.path.replace(/^\/it/, '');
-                }
-                await next();
-            });
-
-            // Serve files with useOriginalUrl: false to use rewritten URL
-            app.use(koaClassicServer(rootDir, {
-                useOriginalUrl: false  // Use ctx.url (rewritten)
-            }));
-
-            server = app.listen();
-        });
-
-        afterAll(() => {
-            server.close();
-        });
-
-        test('should use ctx.url (rewritten path)', async () => {
-            // Request /it/test-page.html
-            // ctx.originalUrl = /it/test-page.html (unchanged)
-            // ctx.url = /test-page.html (rewritten by middleware)
-            // With useOriginalUrl: false, server looks for /test-page.html (which exists)
-            const response = await supertest(server).get('/it/test-page.html');
-
-            // Should return 200 and the file content
-            expect(response.status).toBe(200);
-            expect(response.text).toContain('Test Page');
-        });
-
-        test('should still serve file without rewriting', async () => {
-            // Request /test-page.html directly (no rewriting)
-            const response = await supertest(server).get('/test-page.html');
-
-            // Should return 200 and the file content
-            expect(response.status).toBe(200);
-            expect(response.text).toContain('Test Page');
-        });
-    });
-
-    describe('Complex i18n routing scenario', () => {
-        let app;
-        let server;
-
-        beforeAll(() => {
-            app = new Koa();
-
-            // More complex i18n middleware
-            app.use(async (ctx, next) => {
-                const langPattern = /^\/(it|fr|de|es)\//;
-                const match = ctx.path.match(langPattern);
-                if (match) {
-                    // Store language in state
-                    ctx.state.lang = match[1];
-                    // Strip language prefix
-                    ctx.url = ctx.path.replace(langPattern, '/');
-                }
-                await next();
-            });
-
-            app.use(koaClassicServer(rootDir, {
-                useOriginalUrl: false
-            }));
-
-            server = app.listen();
-        });
-
-        afterAll(() => {
-            server.close();
-        });
-
-        test('should work with Italian locale (/it/)', async () => {
-            const response = await supertest(server).get('/it/test-page.html');
-            expect(response.status).toBe(200);
-            expect(response.text).toContain('Test Page');
-        });
-
-        test('should work with French locale (/fr/)', async () => {
-            const response = await supertest(server).get('/fr/test-page.html');
-            expect(response.status).toBe(200);
-            expect(response.text).toContain('Test Page');
-        });
-
-        test('should work with German locale (/de/)', async () => {
-            const response = await supertest(server).get('/de/test-page.html');
-            expect(response.status).toBe(200);
-            expect(response.text).toContain('Test Page');
-        });
-
-        test('should work with Spanish locale (/es/)', async () => {
-            const response = await supertest(server).get('/es/test-page.html');
-            expect(response.status).toBe(200);
-            expect(response.text).toContain('Test Page');
-        });
-    });
-
-    describe('Backward compatibility', () => {
-        let app;
-        let server;
-
-        beforeAll(() => {
-            app = new Koa();
-
-            // No URL rewriting middleware
-            // Default useOriginalUrl (should be true)
-            app.use(koaClassicServer(rootDir));
-
-            server = app.listen();
-        });
-
-        afterAll(() => {
-            server.close();
-        });
-
-        test('should work with default options (backward compatible)', async () => {
-            const response = await supertest(server).get('/test-page.html');
-            expect(response.status).toBe(200);
-            expect(response.text).toContain('Test Page');
-        });
-    });
-});