kempo-server 1.6.0 → 1.6.2

package/tests/builtinMiddleware.node-test.js

@@ -4,71 +4,70 @@ import {corsMiddleware, compressionMiddleware, rateLimitMiddleware, securityMidd
 
 export default {
   'cors middleware sets headers and handles OPTIONS': async ({pass, fail}) => {
-    try {
-      const res = createMockRes();
-      const mw = corsMiddleware({origin: '*', methods: ['GET'], headers: ['X']});
-      const req = createMockReq({method: 'OPTIONS', headers: {origin: 'http://x'}});
-      await mw(req, res, async () => {});
-      if(!res.isEnded()) return fail('preflight should end');
-      if(!(res.getHeader('Access-Control-Allow-Origin') === 'http://x' || res.getHeader('Access-Control-Allow-Origin') === '*')) return fail('origin header');
-      pass('cors');
-    } catch(e){ fail(e.message); }
+    const res = createMockRes();
+    const mw = corsMiddleware({origin: '*', methods: ['GET'], headers: ['X']});
+    const req = createMockReq({method: 'OPTIONS', headers: {origin: 'http://x'}});
+    await mw(req, res, async () => {});
+    
+    if(!res.isEnded()) return fail('preflight should end');
+    if(!(res.getHeader('Access-Control-Allow-Origin') === 'http://x' || res.getHeader('Access-Control-Allow-Origin') === '*')) return fail('origin header');
+    
+    pass('cors');
   },
   'compression middleware gzips when threshold met and client accepts': async ({pass, fail}) => {
-    try {
-      const res = createMockRes();
-      const mw = compressionMiddleware({threshold: 1024});
-      const req = createMockReq({headers: {'accept-encoding': 'gzip'}});
-      // simulate next writing large body
-  await mw(req, res, async () => {
-        res.write(bigString(5000));
-        res.end();
-      });
-  await new Promise(r => setTimeout(r, 10));
-      const body = res.getBody();
-      const original = Buffer.from(bigString(5000));
-      const gzLen = await gzipSize(original);
-      // If gzipped is smaller, we expect gzip header. Otherwise, implementation may send uncompressed.
-      if(gzLen < original.length){
-        if(res.getHeader('Content-Encoding') !== 'gzip') return fail('should gzip when beneficial');
-      }
-      if(body.length <= 0) return fail('has body');
-      pass('compression');
-    } catch(e){ fail(e.message); }
+    const res = createMockRes();
+    const mw = compressionMiddleware({threshold: 1024});
+    const req = createMockReq({headers: {'accept-encoding': 'gzip'}});
+    // simulate next writing large body
+    await mw(req, res, async () => {
+      res.write(bigString(5000));
+      res.end();
+    });
+    await new Promise(r => setTimeout(r, 10));
+    const body = res.getBody();
+    const original = Buffer.from(bigString(5000));
+    const gzLen = await gzipSize(original);
+    // If gzipped is smaller, we expect gzip header. Otherwise, implementation may send uncompressed.
+    if(gzLen < original.length){
+      if(res.getHeader('Content-Encoding') !== 'gzip') return fail('should gzip when beneficial');
+    }
+    if(body.length <= 0) return fail('has body');
+    
+    pass('compression');
   },
   'rate limit returns 429 after maxRequests': async ({pass, fail}) => {
-    try {
-      const cfg = {maxRequests: 2, windowMs: 1000, message: 'Too many'};
-      const mw = rateLimitMiddleware(cfg);
-      const req = createMockReq();
-      const res1 = createMockRes();
-      await mw(req, res1, async () => {});
-      const res2 = createMockRes();
-      await mw(req, res2, async () => {});
-      const res3 = createMockRes();
-      await mw(req, res3, async () => {});
-      if(res3.statusCode !== 429) return fail('should rate limit');
-      pass('rateLimit');
-    } catch(e){ fail(e.message); }
+    const cfg = {maxRequests: 2, windowMs: 1000, message: 'Too many'};
+    const mw = rateLimitMiddleware(cfg);
+    const req = createMockReq();
+    const res1 = createMockRes();
+    await mw(req, res1, async () => {});
+    const res2 = createMockRes();
+    await mw(req, res2, async () => {});
+    const res3 = createMockRes();
+    await mw(req, res3, async () => {});
+    
+    if(res3.statusCode !== 429) return fail('should rate limit');
+    
+    pass('rateLimit');
   },
   'security middleware sets headers': async ({pass, fail}) => {
-    try {
-      const res = createMockRes();
-      const mw = securityMiddleware({headers: {'X-Test': '1'}});
-      await mw(createMockReq(), res, async () => {});
-      if(res.getHeader('X-Test') !== '1') return fail('header set');
-      pass('security');
-    } catch(e){ fail(e.message); }
+    const res = createMockRes();
+    const mw = securityMiddleware({headers: {'X-Test': '1'}});
+    await mw(createMockReq(), res, async () => {});
+    
+    if(res.getHeader('X-Test') !== '1') return fail('header set');
+    
+    pass('security');
   },
   'logging middleware logs after response end': async ({pass, fail}) => {
-    try {
-      const logs = [];
-      const logger = (m) => logs.push(String(m));
-      const mw = loggingMiddleware({includeUserAgent: true, includeResponseTime: true}, logger);
-      const res = createMockRes();
-      await mw(createMockReq({headers: {'user-agent': 'UA'}}), res, async () => { res.end('x'); });
-      if(!(logs.length === 1 && logs[0].includes('GET /') && logs[0].includes('UA'))) return fail('logged');
-      pass('logging');
-    } catch(e){ fail(e.message); }
+    const logs = [];
+    const logger = (m) => logs.push(String(m));
+    const mw = loggingMiddleware({includeUserAgent: true, includeResponseTime: true}, logger);
+    const res = createMockRes();
+    await mw(createMockReq({headers: {'user-agent': 'UA'}}), res, async () => { res.end('x'); });
+    
+    if(!(logs.length === 1 && logs[0].includes('GET /') && logs[0].includes('UA'))) return fail('logged');
+    
+    pass('logging');
   }
 };

package/tests/cacheConfig.node-test.js

@@ -0,0 +1,117 @@
+import defaultConfig from '../src/defaultConfig.js';
+import path from 'path';
+import { writeFile, mkdir, rm } from 'fs/promises';
+
+/*
+  Test Utilities
+*/
+const createTempConfig = async (config) => {
+  const tempDir = path.join(process.cwd(), 'tests', 'temp-config-test');
+  await mkdir(tempDir, { recursive: true });
+  
+  const configPath = path.join(tempDir, 'test.config.json');
+  await writeFile(configPath, JSON.stringify(config, null, 2));
+  
+  return { tempDir, configPath };
+};
+
+const cleanupTempConfig = async (tempDir) => {
+  try {
+    await rm(tempDir, { recursive: true });
+  } catch(e) {
+    // Directory might not exist
+  }
+};
+
+/*
+  Lifecycle Callbacks
+*/
+export const afterAll = async () => {
+  const tempDir = path.join(process.cwd(), 'tests', 'temp-config-test');
+  await cleanupTempConfig(tempDir);
+};
+
+/*
+  Cache Configuration Tests
+*/
+export default {
+  'default cache configuration includes all required fields': async ({pass, fail}) => {
+    const cache = defaultConfig.cache;
+    
+    if(!cache) return fail('cache config missing from defaults');
+    if(typeof cache.enabled !== 'boolean') return fail('enabled should be boolean');
+    if(typeof cache.maxSize !== 'number') return fail('maxSize should be number');
+    if(typeof cache.maxMemoryMB !== 'number') return fail('maxMemoryMB should be number');
+    if(typeof cache.ttlMs !== 'number') return fail('ttlMs should be number');
+    if(typeof cache.maxHeapUsagePercent !== 'number') return fail('maxHeapUsagePercent should be number');
+    if(typeof cache.memoryCheckInterval !== 'number') return fail('memoryCheckInterval should be number');
+    if(typeof cache.watchFiles !== 'boolean') return fail('watchFiles should be boolean');
+    if(typeof cache.enableMemoryMonitoring !== 'boolean') return fail('enableMemoryMonitoring should be boolean');
+    
+    pass('Default cache configuration verified');
+  },
+
+  'cache can be completely disabled': async ({pass, fail}) => {
+    const { tempDir, configPath } = await createTempConfig({
+      cache: { enabled: false }
+    });
+    
+    // Import router to test config loading
+    const router = await import('../src/router.js');
+    const flags = { root: 'docs', config: configPath };
+    
+    const handler = await router.default(flags, () => {}); // Empty log function
+    
+    if(handler.moduleCache !== null) {
+      await cleanupTempConfig(tempDir);
+      return fail('cache should be null when disabled');
+    }
+    
+    await cleanupTempConfig(tempDir);
+    pass('Cache disable configuration verified');
+  },
+
+  'custom cache limits are applied correctly': async ({pass, fail}) => {
+    const { tempDir, configPath } = await createTempConfig({
+      cache: {
+        enabled: true,
+        maxSize: 25,
+        maxMemoryMB: 10,
+        ttlMs: 120000
+      }
+    });
+    
+    const router = await import('../src/router.js');
+    const flags = { root: 'docs', config: configPath };
+    
+    const handler = await router.default(flags, () => {});
+    
+    if(!handler.moduleCache) {
+      await cleanupTempConfig(tempDir);
+      return fail('cache should be enabled');
+    }
+    
+    const stats = handler.getStats();
+    if(stats.cache.maxSize !== 25) {
+      handler.moduleCache.destroy();
+      await cleanupTempConfig(tempDir);
+      return fail('maxSize not applied');
+    }
+    
+    if(stats.cache.maxMemoryMB !== 10) {
+      handler.moduleCache.destroy();
+      await cleanupTempConfig(tempDir);
+      return fail('maxMemoryMB not applied');
+    }
+    
+    if(stats.config.ttlMs !== 120000) {
+      handler.moduleCache.destroy();
+      await cleanupTempConfig(tempDir);
+      return fail('ttlMs not applied');
+    }
+    
+    handler.moduleCache.destroy();
+    await cleanupTempConfig(tempDir);
+    pass('Custom cache configuration verified');
+  }
+};

package/tests/defaultConfig.node-test.js

@@ -2,12 +2,11 @@ import defaultConfig from '../src/defaultConfig.js';
 
 export default {
   'defaultConfig contains required fields and types': async ({pass, fail}) => {
-    try {
-      if(typeof defaultConfig !== 'object') throw new Error('not object');
-      if(!defaultConfig.allowedMimes || !defaultConfig.disallowedRegex) throw new Error('missing keys');
-      if(!defaultConfig.routeFiles.includes('GET.js')) throw new Error('routeFiles missing GET.js');
-      if(!defaultConfig.middleware || typeof defaultConfig.middleware !== 'object') throw new Error('middleware missing');
-      pass('shape ok');
-    } catch(e){ fail(e.message); }
+    if(typeof defaultConfig !== 'object') return fail('not object');
+    if(!defaultConfig.allowedMimes || !defaultConfig.disallowedRegex) return fail('missing keys');
+    if(!defaultConfig.routeFiles.includes('GET.js')) return fail('routeFiles missing GET.js');
+    if(!defaultConfig.middleware || typeof defaultConfig.middleware !== 'object') return fail('middleware missing');
+    
+    pass('shape ok');
   }
 };

package/tests/example-middleware.node-test.js

@@ -8,24 +8,23 @@ const {default: authMiddleware} = await import(url.pathToFileURL(examplePath));
 
 export default {
   'blocks when API key missing and allows when present': async ({pass, fail}) => {
-    try {
-      await setEnv({API_KEY: 'abc'}, async () => {
-        const res1 = createMockRes();
-        await authMiddleware(createMockReq({url:'/private'}), res1, async ()=>{});
-        if(res1.statusCode !== 401) return fail('should 401 without key');
+    await setEnv({API_KEY: 'abc'}, async () => {
+      const res1 = createMockRes();
+      await authMiddleware(createMockReq({url:'/private'}), res1, async ()=>{});
+      if(res1.statusCode !== 401) return fail('should 401 without key');
 
-        const res2 = createMockRes();
-        const req2 = createMockReq({headers: {'x-api-key': 'abc'}, url:'/private'});
-        let called = false;
-        await authMiddleware(req2, res2, async ()=>{ called = true; });
-        if(!called) return fail('should call next');
-        if(!(req2.user && req2.user.authenticated)) return fail('user attached');
+      const res2 = createMockRes();
+      const req2 = createMockReq({headers: {'x-api-key': 'abc'}, url:'/private'});
+      let called = false;
+      await authMiddleware(req2, res2, async ()=>{ called = true; });
+      if(!called) return fail('should call next');
+      if(!(req2.user && req2.user.authenticated)) return fail('user attached');
 
-        const res3 = createMockRes();
-        await authMiddleware(createMockReq({url:'/public/file'}), res3, async ()=>{});
-        if(res3.isEnded() === true) return fail('public should not end');
-      });
-      pass('auth middleware');
-    } catch(e){ fail(e.message); }
+      const res3 = createMockRes();
+      await authMiddleware(createMockReq({url:'/public/file'}), res3, async ()=>{});
+      if(res3.isEnded() === true) return fail('public should not end');
+    });
+    
+    pass('auth middleware');
   }
 };

package/tests/findFile.node-test.js

@@ -4,43 +4,43 @@ import path from 'path';
 const toAbs = (root, p) => path.join(root, p);
 
 export default {
-  'exact match returns file': async ({pass, fail, log}) => {
-    try {
-      const root = path.join(process.cwd(), 'tmp-root');
-      const files = [toAbs(root, 'a/b/GET.js')];
-      const [file, params] = await findFile(files, root, '/a/b/GET.js', 'GET', log);
-      if(file !== files[0]) throw new Error('not exact');
-      if(Object.keys(params).length !== 0) throw new Error('params present');
-      pass('exact');
-    } catch(e){ fail(e.message); }
+  'exact match returns file': async ({pass, fail}) => {
+    const root = path.join(process.cwd(), 'tmp-root');
+    const files = [toAbs(root, 'a/b/GET.js')];
+    const [file, params] = await findFile(files, root, '/a/b/GET.js', 'GET', () => {});
+    
+    if(file !== files[0]) return fail('not exact');
+    if(Object.keys(params).length !== 0) return fail('params present');
+    
+    pass('exact');
   },
-  'directory index prioritization and method specific': async ({pass, fail, log}) => {
-    try {
-  const root = path.join(process.cwd(), 'tmp-root');
-  const files = ['a/index.html', 'a/GET.js', 'a/index.js'].map(p => toAbs(root, p));
-  const [file] = await findFile(files, root, '/a', 'GET', log);
-  if(!file || path.basename(file) !== 'GET.js') throw new Error('priority not respected');
-      pass('dir index');
-    } catch(e){ fail(e.message); }
+  'directory index prioritization and method specific': async ({pass, fail}) => {
+    const root = path.join(process.cwd(), 'tmp-root');
+    const files = ['a/index.html', 'a/GET.js', 'a/index.js'].map(p => toAbs(root, p));
+    const [file] = await findFile(files, root, '/a', 'GET', () => {});
+    
+    if(!file || path.basename(file) !== 'GET.js') return fail('priority not respected');
+    
+    pass('dir index');
   },
-  'dynamic match with params and best priority': async ({pass, fail, log}) => {
-    try {
-  const root = path.join(process.cwd(), 'tmp-root');
-      const files = ['user/[id]/GET.js', 'user/[id]/index.html', 'user/[id]/index.js'].map(p => toAbs(root, p));
-  const [file, params] = await findFile(files, root, '/user/42', 'GET', log);
-  if(!file || path.basename(file) !== 'GET.js') throw new Error('did not pick GET.js');
-      if(params.id !== '42') throw new Error('param missing');
-      pass('dynamic');
-    } catch(e){ fail(e.message); }
+  'dynamic match with params and best priority': async ({pass, fail}) => {
+    const root = path.join(process.cwd(), 'tmp-root');
+    const files = ['user/[id]/GET.js', 'user/[id]/index.html', 'user/[id]/index.js'].map(p => toAbs(root, p));
+    const [file, params] = await findFile(files, root, '/user/42', 'GET', () => {});
+    
+    if(!file || path.basename(file) !== 'GET.js') return fail('did not pick GET.js');
+    if(params.id !== '42') return fail('param missing');
+    
+    pass('dynamic');
   },
-  'no match returns false and empty params': async ({pass, fail, log}) => {
-    try {
-  const root = path.join(process.cwd(), 'tmp-root');
-      const files = ['x/y/index.html'].map(p => toAbs(root, p));
-      const [file, params] = await findFile(files, root, '/nope', 'GET', log);
-      if(file !== false) throw new Error('should be false');
-      if(Object.keys(params).length !== 0) throw new Error('params not empty');
-      pass('no match');
-    } catch(e){ fail(e.message); }
+  'no match returns false and empty params': async ({pass, fail}) => {
+    const root = path.join(process.cwd(), 'tmp-root');
+    const files = ['x/y/index.html'].map(p => toAbs(root, p));
+    const [file, params] = await findFile(files, root, '/nope', 'GET', () => {});
+    
+    if(file !== false) return fail('should be false');
+    if(Object.keys(params).length !== 0) return fail('params not empty');
+    
+    pass('no match');
   }
 };

package/tests/getFiles.node-test.js

@@ -5,21 +5,21 @@ import {withTempDir, write, log} from './test-utils.js';
 
 export default {
   'scans directories recursively and filters by mime and disallowed': async ({pass, fail}) => {
-    try {
-      await withTempDir(async (dir) => {
-        const cfg = JSON.parse(JSON.stringify(defaultConfig));
-        await write(dir, 'index.html', '<!doctype html>');
-        await write(dir, '.env', 'SECRET=1');
-        await write(dir, 'notes.xyz', 'unknown');
-        await write(dir, 'sub/app.js', 'console.log(1)');
-  const files = await getFiles(dir, cfg, log);
-  const rel = files.map(f => path.relative(dir, f).replace(/\\/g, '/'));
-        if(!rel.includes('index.html')) return fail('includes html');
-        if(!rel.includes('sub/app.js')) return fail('includes js');
-  if(rel.includes('.env')) return fail('excludes disallowed');
-        if(rel.includes('notes.xyz')) return fail('excludes unknown ext');
-      });
-      pass('scan and filter');
-    } catch(e){ fail(e.message); }
+    await withTempDir(async (dir) => {
+      const cfg = JSON.parse(JSON.stringify(defaultConfig));
+      await write(dir, 'index.html', '<!doctype html>');
+      await write(dir, '.env', 'SECRET=1');
+      await write(dir, 'notes.xyz', 'unknown');
+      await write(dir, 'sub/app.js', 'console.log(1)');
+      const files = await getFiles(dir, cfg, log);
+      const rel = files.map(f => path.relative(dir, f).replace(/\\/g, '/'));
+      
+      if(!rel.includes('index.html')) return fail('includes html');
+      if(!rel.includes('sub/app.js')) return fail('includes js');
+      if(rel.includes('.env')) return fail('excludes disallowed');
+      if(rel.includes('notes.xyz')) return fail('excludes unknown ext');
+    });
+    
+    pass('scan and filter');
   }
 };

package/tests/getFlags.node-test.js

@@ -4,27 +4,27 @@ export default {
   'parses long flags with values and booleans': async ({pass, fail}) => {
     const args = ['--port', '8080', '--scan'];
     const flags = getFlags(args, {port: 3000, scan: false});
-    try {
-      if(flags.port !== '8080') throw new Error('port not parsed');
-      if(flags.scan !== true) throw new Error('scan boolean not parsed');
-      pass('parsed long flags');
-    } catch(e){ fail(e.message); }
+    
+    if(flags.port !== '8080') return fail('port not parsed');
+    if(flags.scan !== true) return fail('scan boolean not parsed');
+    
+    pass('parsed long flags');
   },
   'parses short flags using map and preserves defaults': async ({pass, fail}) => {
     const args = ['-p', '9090', '-s'];
     const flags = getFlags(args, {port: 3000, scan: false}, {p: 'port', s: 'scan'});
-    try {
-      if(flags.port !== '9090') throw new Error('short mapped value failed');
-      if(flags.scan !== true) throw new Error('short mapped boolean failed');
-      pass('short flags parsed');
-    } catch(e){ fail(e.message); }
+    
+    if(flags.port !== '9090') return fail('short mapped value failed');
+    if(flags.scan !== true) return fail('short mapped boolean failed');
+    
+    pass('short flags parsed');
   },
   'treats next arg starting with dash as boolean flag': async ({pass, fail}) => {
     const args = ['-l', '-5', 'file'];
     const flags = getFlags(args, {l: 2});
-    try {
-      if(flags.l !== true) throw new Error('should be boolean true');
-      pass('dash after flag -> boolean');
-    } catch(e){ fail(e.message); }
+    
+    if(flags.l !== true) return fail('should be boolean true');
+    
+    pass('dash after flag -> boolean');
   }
 };

package/tests/index.node-test.js

@@ -3,21 +3,29 @@ import path from 'path';
 
 export default {
   'index.js CLI starts server and serves root': async ({pass, fail}) => {
-    try {
-      await withTempDir(async (dir) => {
-  await write(dir, 'index.html', 'home');
-  const port = randomPort();
-  const args = [path.join(process.cwd(), 'dist/index.js'), '-r', '.', '-p', String(port), '-l', '0'];
-  const child = await startNode(args, {cwd: dir});
-  // wait briefly for server to start
-  await new Promise(r => setTimeout(r, 400));
-        const {res, body} = await httpGet(`http://localhost:${port}/index.html`);
-        if(res.statusCode !== 200) return fail('server running');
-        if(body.toString() !== 'home') return fail('served');
-  child.kill();
-  await new Promise(r => setTimeout(r, 50));
-      });
-      pass('cli');
-    } catch(e){ fail(e.message); }
+    await withTempDir(async (dir) => {
+      await write(dir, 'index.html', 'home');
+      const port = randomPort();
+      const args = [path.join(process.cwd(), 'dist/index.js'), '-r', '.', '-p', String(port), '-l', '0'];
+      const child = await startNode(args, {cwd: dir});
+      // wait briefly for server to start
+      await new Promise(r => setTimeout(r, 400));
+      const {res, body} = await httpGet(`http://localhost:${port}/index.html`);
+      
+      if(res.statusCode !== 200) {
+        child.kill();
+        return fail('server running');
+      }
+      
+      if(body.toString() !== 'home') {
+        child.kill();
+        return fail('served');
+      }
+      
+      child.kill();
+      await new Promise(r => setTimeout(r, 50));
+    });
+    
+    pass('cli');
   }
 };

package/tests/middlewareRunner.node-test.js

@@ -3,16 +3,16 @@ import {createMockReq, createMockRes} from './test-utils.js';
 
 export default {
   'runs middleware in order and calls finalHandler': async ({pass, fail}) => {
-    try {
-      const mr = new MiddlewareRunner();
-      const calls = [];
-      mr.use(async (_req, _res, next) => { calls.push('a'); await next(); calls.push('a:after'); });
-      mr.use(async (_req, _res, next) => { calls.push('b'); await next(); calls.push('b:after'); });
-      const req = createMockReq();
-      const res = createMockRes();
-      await mr.run(req, res, async () => { calls.push('final'); });
-      if(calls.join(',') !== 'a,b,final,b:after,a:after') return fail('order incorrect');
-      pass('middleware order');
-    } catch(e){ fail(e.message); }
+    const mr = new MiddlewareRunner();
+    const calls = [];
+    mr.use(async (_req, _res, next) => { calls.push('a'); await next(); calls.push('a:after'); });
+    mr.use(async (_req, _res, next) => { calls.push('b'); await next(); calls.push('b:after'); });
+    const req = createMockReq();
+    const res = createMockRes();
+    await mr.run(req, res, async () => { calls.push('final'); });
+    
+    if(calls.join(',') !== 'a,b,final,b:after,a:after') return fail('order incorrect');
+    
+    pass('middleware order');
   }
 };