kempo-server 1.6.0 → 1.6.2

package/tests/moduleCache.node-test.js

@@ -0,0 +1,279 @@
+import ModuleCache from '../src/moduleCache.js';
+import path from 'path';
+import { writeFile, unlink, stat, mkdir, rm } from 'fs/promises';
+
+/*
+  Test Utilities
+*/
+const activeCaches = [];
+
+const createTestCache = (config = {}) => {
+  const cache = new ModuleCache({
+    enableMemoryMonitoring: false, // Always disable to prevent hanging
+    watchFiles: false,             // Default to false for most tests
+    ...config
+  });
+  activeCaches.push(cache);
+  return cache;
+};
+const createTempDir = async () => {
+  const tempDir = path.join(process.cwd(), 'tests', 'temp-cache-test');
+  try {
+    await mkdir(tempDir, { recursive: true });
+  } catch(e) {
+    // Directory might already exist
+  }
+  return tempDir;
+};
+
+const cleanupTempDir = async (tempDir) => {
+  try {
+    await rm(tempDir, { recursive: true });
+  } catch(e) {
+    // Directory might not exist
+  }
+};
+
+/*
+  Lifecycle Callbacks
+*/
+
+export const afterAll = async () => {
+  // Destroy all active caches to clean up timers and watchers
+  for(let i = 0; i < activeCaches.length; i++) {
+    activeCaches[i].destroy();
+  }
+  activeCaches.length = 0;
+  
+  // Give file watchers extra time to fully close
+  await new Promise(resolve => setTimeout(resolve, 500));
+  
+  const tempDir = path.join(process.cwd(), 'tests', 'temp-cache-test');
+  await cleanupTempDir(tempDir);
+};
+
+/*
+  Module Cache Tests
+*/
+export default {
+  'basic LRU functionality works correctly': async ({pass, fail, log}) => {
+    const cache = createTestCache({
+      maxSize: 2,
+      maxMemoryMB: 10,
+      ttlMs: 60000,
+      watchFiles: false
+    });
+
+    const mockStats1 = { mtime: new Date('2023-01-01') };
+    const mockStats2 = { mtime: new Date('2023-01-02') };
+    const mockStats3 = { mtime: new Date('2023-01-03') };
+
+    cache.set('/test1.js', { default: () => 'test1' }, mockStats1, 1);
+    if(cache.cache.size !== 1) {
+      cache.destroy();
+      return fail('size should be 1');
+    }
+
+    cache.set('/test2.js', { default: () => 'test2' }, mockStats2, 1);
+    if(cache.cache.size !== 2) {
+      cache.destroy();
+      return fail('size should be 2');
+    }
+
+    cache.set('/test3.js', { default: () => 'test3' }, mockStats3, 1);
+    if(cache.cache.size !== 2) {
+      cache.destroy();
+      return fail('size should still be 2');
+    }
+    if(cache.get('/test1.js', mockStats1) !== null) {
+      cache.destroy();
+      return fail('oldest should be evicted');
+    }
+
+    cache.destroy();
+    pass('LRU functionality verified');
+  },
+
+  'TTL expiration invalidates entries': async ({pass, fail, log}) => {
+    const cache = createTestCache({
+      maxSize: 10,
+      ttlMs: 50,
+      watchFiles: false
+    });
+
+    const mockStats = { mtime: new Date('2023-01-01') };
+    cache.set('/test.js', { default: () => 'test' }, mockStats, 1);
+    
+    if(cache.get('/test.js', mockStats) === null) {
+      cache.destroy();
+      return fail('should be available immediately');
+    }
+    
+    await new Promise(resolve => setTimeout(resolve, 100));
+    
+    if(cache.get('/test.js', mockStats) !== null) {
+      cache.destroy();
+      return fail('should be expired');
+    }
+    
+    cache.destroy();
+    pass('TTL expiration verified');
+  },
+
+  'file modification invalidates cache entry': async ({pass, fail, log}) => {
+    const cache = createTestCache({
+      maxSize: 10,
+      ttlMs: 60000,
+      watchFiles: false
+    });
+
+    const oldStats = { mtime: new Date('2023-01-01') };
+    const newStats = { mtime: new Date('2023-01-02') };
+    
+    cache.set('/test.js', { default: () => 'test' }, oldStats, 1);
+    
+    if(cache.get('/test.js', oldStats) === null) {
+      cache.destroy();
+      return fail('should be available with old stats');
+    }
+    
+    if(cache.get('/test.js', newStats) !== null) {
+      cache.destroy();
+      return fail('should be invalidated with newer stats');
+    }
+    
+    cache.destroy();
+    pass('File modification invalidation verified');
+  },
+
+  'memory limit enforcement evicts oldest entries': async ({pass, fail, log}) => {
+    const cache = createTestCache({
+      maxSize: 100,
+      maxMemoryMB: 0.002,
+      ttlMs: 60000,
+      watchFiles: false
+    });
+
+    const mockStats = { mtime: new Date('2023-01-01') };
+    
+    cache.set('/test1.js', { default: () => 'test1' }, mockStats, 1);
+    cache.set('/test2.js', { default: () => 'test2' }, mockStats, 1);
+    cache.set('/test3.js', { default: () => 'test3' }, mockStats, 1);
+    
+    if(cache.get('/test1.js', mockStats) !== null) {
+      cache.destroy();
+      return fail('first entry should be evicted due to memory limit');
+    }
+    
+    if(cache.get('/test2.js', mockStats) === null) {
+      cache.destroy();
+      return fail('second entry should still be cached');
+    }
+    
+    if(cache.get('/test3.js', mockStats) === null) {
+      cache.destroy();
+      return fail('third entry should still be cached');
+    }
+    
+    cache.destroy();
+    pass('Memory limit enforcement verified');
+  },
+
+  'statistics tracking works correctly': async ({pass, fail, log}) => {
+    const cache = createTestCache({
+      maxSize: 10,
+      watchFiles: false
+    });
+
+    const mockStats = { mtime: new Date('2023-01-01') };
+    
+    if(cache.get('/test.js', mockStats) !== null) {
+      cache.destroy();
+      return fail('should be cache miss');
+    }
+    
+    if(cache.stats.misses !== 1) {
+      cache.destroy();
+      return fail('miss count should be 1');
+    }
+    
+    cache.set('/test.js', { default: () => 'test' }, mockStats, 1);
+    
+    if(cache.get('/test.js', mockStats) === null) {
+      cache.destroy();
+      return fail('should be cache hit');
+    }
+    
+    if(cache.stats.hits !== 1) {
+      cache.destroy();
+      return fail('hit count should be 1');
+    }
+    
+    if(cache.getHitRate() !== 50) {
+      cache.destroy();
+      return fail('hit rate should be 50%');
+    }
+    
+    const stats = cache.getStats();
+    if(!stats.cache || !stats.stats || !stats.memory) {
+      cache.destroy();
+      return fail('stats structure invalid');
+    }
+    
+    cache.destroy();
+    pass('Statistics tracking verified');
+  },
+
+  'file watching invalidates cache on changes': async ({pass, fail, log}) => {
+    let cache;
+    let testFilePath;
+    
+    const tempDir = await createTempDir();
+    
+    cache = createTestCache({
+      maxSize: 10,
+      ttlMs: 60000,
+      watchFiles: true
+    });
+
+    testFilePath = path.join(tempDir, 'watch-test.js');
+    
+    await writeFile(testFilePath, 'export default () => "v1";');
+    const initialStats = await stat(testFilePath);
+    
+    const module = { default: () => 'v1' };
+    cache.set(testFilePath, module, initialStats, 1);
+    
+    if(cache.get(testFilePath, initialStats) === null) {
+      await unlink(testFilePath);
+      cache.destroy();
+      return fail('should be in cache initially');
+    }
+    
+    await new Promise(resolve => setTimeout(resolve, 50));
+    await writeFile(testFilePath, 'export default () => "v2";');
+    
+    await new Promise(resolve => setTimeout(resolve, 200));
+    
+    if(cache.get(testFilePath, initialStats) !== null) {
+      await unlink(testFilePath);
+      cache.destroy();
+      return fail('should be invalidated after file change');
+    }
+    
+    if(cache.stats.fileChanges === 0) {
+      await unlink(testFilePath);
+      cache.destroy();
+      return fail('file change should be tracked');
+    }
+    
+    // Clean up immediately
+    await unlink(testFilePath);
+    cache.destroy();
+    
+    // Give extra time for file watcher cleanup
+    await new Promise(resolve => setTimeout(resolve, 100));
+    
+    pass('File watching verified');
+  }
+};

package/tests/requestWrapper.node-test.js

@@ -3,32 +3,31 @@ import createRequestWrapper from '../src/requestWrapper.js';
 
 export default {
   'parses query and path and provides params': async ({pass, fail}) => {
-    try {
-      const req = createMockReq({url: '/user/123?x=1&y=2', headers: {host: 'localhost'}});
-      const wrapped = createRequestWrapper(req, {id: '123'});
-      if(wrapped.path !== '/user/123') return fail('path');
-      if(!(wrapped.query.x === '1' && wrapped.query.y === '2')) return fail('query');
-      if(wrapped.params.id !== '123') return fail('params');
-      pass('parsed url');
-    } catch(e){ fail(e.message); }
+    const req = createMockReq({url: '/user/123?x=1&y=2', headers: {host: 'localhost'}});
+    const wrapped = createRequestWrapper(req, {id: '123'});
+    
+    if(wrapped.path !== '/user/123') return fail('path');
+    if(!(wrapped.query.x === '1' && wrapped.query.y === '2')) return fail('query');
+    if(wrapped.params.id !== '123') return fail('params');
+    
+    pass('parsed url');
   },
   'body/json/text/buffer helpers work': async ({pass, fail}) => {
-    try {
-      const payload = {a: 1};
-      // Each body reader must have its own stream instance
-      const reqText = createMockReq({method: 'POST', url: '/', headers: {host: 'x', 'content-type': 'application/json'}, body: JSON.stringify(payload)});
-      const text = await createRequestWrapper(reqText).text();
-      if(text !== JSON.stringify(payload)) return fail('text');
+    const payload = {a: 1};
+    // Each body reader must have its own stream instance
+    const reqText = createMockReq({method: 'POST', url: '/', headers: {host: 'x', 'content-type': 'application/json'}, body: JSON.stringify(payload)});
+    const text = await createRequestWrapper(reqText).text();
+    if(text !== JSON.stringify(payload)) return fail('text');
 
-      const reqJson = createMockReq({method: 'POST', url: '/', headers: {host: 'x', 'content-type': 'application/json'}, body: JSON.stringify(payload)});
-      const obj = await createRequestWrapper(reqJson).json();
-      if(obj.a !== 1) return fail('json');
+    const reqJson = createMockReq({method: 'POST', url: '/', headers: {host: 'x', 'content-type': 'application/json'}, body: JSON.stringify(payload)});
+    const obj = await createRequestWrapper(reqJson).json();
+    if(obj.a !== 1) return fail('json');
 
-      const reqBuf = createMockReq({url: '/', headers: {host: 'x'}, body: 'abc'});
-      const buf = await createRequestWrapper(reqBuf).buffer();
-      if(!(Buffer.isBuffer(buf) && buf.toString() === 'abc')) return fail('buffer');
-      pass('helpers');
-    } catch(e){ fail(e.message); }
+    const reqBuf = createMockReq({url: '/', headers: {host: 'x'}, body: 'abc'});
+    const buf = await createRequestWrapper(reqBuf).buffer();
+    if(!(Buffer.isBuffer(buf) && buf.toString() === 'abc')) return fail('buffer');
+    
+    pass('helpers');
   },
   'invalid json throws': async ({pass, fail}) => {
     const req = createMockReq({url: '/', headers: {host: 'x'}, body: 'not json'});
@@ -40,12 +39,12 @@ export default {
     }
   },
   'get and is helpers': async ({pass, fail}) => {
-    try {
-      const req = createMockReq({url: '/', headers: {'content-type': 'text/plain', host: 'x'}});
-      const w = createRequestWrapper(req);
-      if(w.get('content-type') !== 'text/plain') return fail('get');
-      if(w.is('text/plain') !== true) return fail('is');
-      pass('header helpers');
-    } catch(e){ fail(e.message); }
+    const req = createMockReq({url: '/', headers: {'content-type': 'text/plain', host: 'x'}});
+    const w = createRequestWrapper(req);
+    
+    if(w.get('content-type') !== 'text/plain') return fail('get');
+    if(w.is('text/plain') !== true) return fail('is');
+    
+    pass('header helpers');
   }
 };

package/tests/responseWrapper.node-test.js

@@ -3,72 +3,72 @@ import createResponseWrapper from '../src/responseWrapper.js';
 
 export default {
   'status and set/get headers and type': async ({pass, fail}) => {
-    try {
-      const res = createMockRes();
-      const w = createResponseWrapper(res);
-      w.status(201).set('X-Test', '1').type('json');
-      if(res.statusCode !== 201) return fail('status');
-      if(res.getHeader('X-Test') !== '1') return fail('set/get');
-      if(res.getHeader('Content-Type') !== 'application/json') return fail('type');
-      pass('status+headers+type');
-    } catch(e){ fail(e.message); }
+    const res = createMockRes();
+    const w = createResponseWrapper(res);
+    w.status(201).set('X-Test', '1').type('json');
+    
+    if(res.statusCode !== 201) return fail('status');
+    if(res.getHeader('X-Test') !== '1') return fail('set/get');
+    if(res.getHeader('Content-Type') !== 'application/json') return fail('type');
+    
+    pass('status+headers+type');
   },
   'json sends and prevents further changes': async ({pass, fail}) => {
-    try {
-      const res = createMockRes();
-      const w = createResponseWrapper(res);
-      w.json({a: 1});
-      if(!res.isEnded()) return fail('ended');
-      try { w.set('X', 'y'); fail('should not set after send'); } catch(_){ /* ok */ }
-      pass('json');
-    } catch(e){ fail(e.message); }
+    const res = createMockRes();
+    const w = createResponseWrapper(res);
+    w.json({a: 1});
+    
+    if(!res.isEnded()) return fail('ended');
+    
+    try { w.set('X', 'y'); fail('should not set after send'); } catch(_){ /* ok */ }
+    
+    pass('json');
   },
   'send handles string, object, buffer and null': async ({pass, fail}) => {
-    try {
-  const res1 = createMockRes();
-  createResponseWrapper(res1).send('hello');
-  // Content-Type defaults to text/html for string when not set
-  if(res1.getHeader('Content-Type') !== 'text/html') return fail('string content-type');
-      if(res1.getBody().toString() !== 'hello') return fail('string body');
+    const res1 = createMockRes();
+    createResponseWrapper(res1).send('hello');
+    // Content-Type defaults to text/html for string when not set
+    if(res1.getHeader('Content-Type') !== 'text/html') return fail('string content-type');
+    if(res1.getBody().toString() !== 'hello') return fail('string body');
 
-      const res2 = createMockRes();
-      createResponseWrapper(res2).send({a:1});
-      if(res2.getHeader('Content-Type') !== 'application/json') return fail('object content-type');
+    const res2 = createMockRes();
+    createResponseWrapper(res2).send({a:1});
+    if(res2.getHeader('Content-Type') !== 'application/json') return fail('object content-type');
 
-  const res3 = createMockRes();
-  const buf = Buffer.from('abc');
-  createResponseWrapper(res3).send(buf);
-  const body3 = res3.getBody().toString();
-  if(!body3.includes('"data"')) return fail('buffer equal');
+    const res3 = createMockRes();
+    const buf = Buffer.from('abc');
+    createResponseWrapper(res3).send(buf);
+    const body3 = res3.getBody().toString();
+    if(!body3.includes('"data"')) return fail('buffer equal');
 
-  const res4 = createMockRes();
-  createResponseWrapper(res4).send(null);
-  if(!res4.isEnded()) return fail('null ended');
-      pass('send variants');
-    } catch(e){ fail(e.message); }
+    const res4 = createMockRes();
+    createResponseWrapper(res4).send(null);
+    if(!res4.isEnded()) return fail('null ended');
+    
+    pass('send variants');
   },
   'html and text helpers': async ({pass, fail}) => {
-    try {
-      const r1 = createMockRes();
-      createResponseWrapper(r1).html('<h1>Ok</h1>');
-      if(r1.getHeader('Content-Type') !== 'text/html') return fail('html type');
+    const r1 = createMockRes();
+    createResponseWrapper(r1).html('<h1>Ok</h1>');
+    if(r1.getHeader('Content-Type') !== 'text/html') return fail('html type');
 
-      const r2 = createMockRes();
-      createResponseWrapper(r2).text('plain');
-      if(r2.getHeader('Content-Type') !== 'text/plain') return fail('text type');
-      pass('helpers');
-    } catch(e){ fail(e.message); }
+    const r2 = createMockRes();
+    createResponseWrapper(r2).text('plain');
+    if(r2.getHeader('Content-Type') !== 'text/plain') return fail('text type');
+    
+    pass('helpers');
   },
   'redirect and cookies': async ({pass, fail}) => {
-    try {
-      const r = createMockRes();
-      const w = createResponseWrapper(r);
-      w.cookie('a', 'b', {httpOnly: true, path: '/'});
-      const cookies = parseCookies(r.getHeader('Set-Cookie'));
-      if(!(cookies.length === 1 && cookies[0].includes('a=b'))) return fail('cookie added');
-      w.redirect('/next', 301);
-      if(!(r.statusCode === 301 && r.getHeader('Location') === '/next')) return fail('redirect');
-      pass('redirect+cookie');
-    } catch(e){ fail(e.message); }
+    const r = createMockRes();
+    const w = createResponseWrapper(r);
+    w.cookie('a', 'b', {httpOnly: true, path: '/'});
+    const cookies = parseCookies(r.getHeader('Set-Cookie'));
+    
+    if(!(cookies.length === 1 && cookies[0].includes('a=b'))) return fail('cookie added');
+    
+    w.redirect('/next', 301);
+    if(!(r.statusCode === 301 && r.getHeader('Location') === '/next')) return fail('redirect');
+    
+    pass('redirect+cookie');
   }
 };

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

@@ -4,43 +4,55 @@ import router from '../src/router.js';
 
 export default {
   'built-in middleware can be configured on router': async ({pass, fail}) => {
-    try {
-      await withTempDir(async (dir) => {
-        await write(dir, '.config.json', JSON.stringify({
-          middleware: {
-            cors: {enabled: true, origin: '*', methods: ['GET'], headers: ['X']},
-            compression: {enabled: true, threshold: 1},
-            rateLimit: {enabled: true, maxRequests: 1, windowMs: 1000, message: 'Too many'},
-            security: {enabled: true, headers: {'X-Test':'1'}},
-            logging: {enabled: true, includeUserAgent: false, includeResponseTime: true}
-          }
-        }));
-  await write(dir, 'index.html', 'hello world');
-  const prev = process.cwd();
-  process.chdir(dir);
-  const flags = {root: '.', logging: 0, scan: false};
-  const handler = await router(flags, () => {});
-        const server = http.createServer(handler);
-        const port = randomPort();
-        await new Promise(r => server.listen(port, r));
-        await new Promise(r => setTimeout(r, 50));
-        try {
-          const {get} = await import('http');
-          const one = await new Promise((res)=>{
-            get(`http://localhost:${port}/index.html`, {headers: {'accept-encoding': 'gzip'}}, r =>{
-              const chunks = []; r.on('data', c => chunks.push(c)); r.on('end', ()=> res({r, body: Buffer.concat(chunks)}));
-            });
-          });
-          if(one.r.statusCode !== 200) return fail('first ok');
-          const two = await new Promise((res)=>{
-            get(`http://localhost:${port}/index.html`, r =>{
-              const chunks = []; r.on('data', c => chunks.push(c)); r.on('end', ()=> res({r, body: Buffer.concat(chunks)}));
-            });
-          });
-          if(two.r.statusCode !== 429) return fail('rate limited');
-        } finally { server.close(); process.chdir(prev); }
+    await withTempDir(async (dir) => {
+      await write(dir, '.config.json', JSON.stringify({
+        middleware: {
+          cors: {enabled: true, origin: '*', methods: ['GET'], headers: ['X']},
+          compression: {enabled: true, threshold: 1},
+          rateLimit: {enabled: true, maxRequests: 1, windowMs: 1000, message: 'Too many'},
+          security: {enabled: true, headers: {'X-Test':'1'}},
+          logging: {enabled: true, includeUserAgent: false, includeResponseTime: true}
+        }
+      }));
+      await write(dir, 'index.html', 'hello world');
+      const prev = process.cwd();
+      process.chdir(dir);
+      const flags = {root: '.', logging: 0, scan: false};
+      const handler = await router(flags, () => {});
+      const server = http.createServer(handler);
+      const port = randomPort();
+      await new Promise(r => server.listen(port, r));
+      await new Promise(r => setTimeout(r, 50));
+      
+      const {get} = await import('http');
+      const one = await new Promise((res)=>{
+        get(`http://localhost:${port}/index.html`, {headers: {'accept-encoding': 'gzip'}}, r =>{
+          const chunks = []; r.on('data', c => chunks.push(c)); r.on('end', ()=> res({r, body: Buffer.concat(chunks)}));
+        });
       });
-      pass('router middleware');
-    } catch(e){ fail(e.message); }
+      
+      if(one.r.statusCode !== 200) {
+        server.close();
+        process.chdir(prev);
+        return fail('first ok');
+      }
+      
+      const two = await new Promise((res)=>{
+        get(`http://localhost:${port}/index.html`, r =>{
+          const chunks = []; r.on('data', c => chunks.push(c)); r.on('end', ()=> res({r, body: Buffer.concat(chunks)}));
+        });
+      });
+      
+      if(two.r.statusCode !== 429) {
+        server.close();
+        process.chdir(prev);
+        return fail('rate limited');
+      }
+      
+      server.close();
+      process.chdir(prev);
+    });
+    
+    pass('router middleware');
   }
 };