kempo-server 1.6.1 → 1.6.3

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');
   }
 };

package/tests/moduleCache.node-test.js

@@ -37,31 +37,19 @@ const cleanupTempDir = async (tempDir) => {
 /*
   Lifecycle Callbacks
 */
-export const beforeAll = async (log) => {
-  log('Setting up module cache test environment...');
-};
 
-export const afterAll = async (log) => {
-  log('Starting cleanup of module cache test environment...');
-  
-  log(`Found ${activeCaches.length} active caches to destroy`);
+export const afterAll = async () => {
   // Destroy all active caches to clean up timers and watchers
   for(let i = 0; i < activeCaches.length; i++) {
-    log(`Destroying cache ${i + 1}/${activeCaches.length}`);
     activeCaches[i].destroy();
   }
   activeCaches.length = 0;
-  log('All caches destroyed');
   
   // Give file watchers extra time to fully close
-  log('Waiting for file watchers to close...');
   await new Promise(resolve => setTimeout(resolve, 500));
-  log('File watcher wait complete');
   
   const tempDir = path.join(process.cwd(), 'tests', 'temp-cache-test');
-  log('Cleaning up temp directory...');
   await cleanupTempDir(tempDir);
-  log('Module cache test cleanup complete');
 };
 
 /*
@@ -69,206 +57,223 @@ export const afterAll = async (log) => {
 */
 export default {
   'basic LRU functionality works correctly': async ({pass, fail, log}) => {
-    try {
-      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') };
+    const cache = createTestCache({
+      maxSize: 2,
+      maxMemoryMB: 10,
+      ttlMs: 60000,
+      watchFiles: false
+    });
 
-      cache.set('/test1.js', { default: () => 'test1' }, mockStats1, 1);
-      if(cache.cache.size !== 1) throw new Error('size should be 1');
+    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('/test2.js', { default: () => 'test2' }, mockStats2, 1);
-      if(cache.cache.size !== 2) throw new Error('size should be 2');
+    cache.set('/test1.js', { default: () => 'test1' }, mockStats1, 1);
+    if(cache.cache.size !== 1) {
+      cache.destroy();
+      return fail('size should be 1');
+    }
 
-      cache.set('/test3.js', { default: () => 'test3' }, mockStats3, 1);
-      if(cache.cache.size !== 2) throw new Error('size should still be 2');
-      if(cache.get('/test1.js', mockStats1) !== null) throw new Error('oldest should be evicted');
+    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();
-      log('✓ LRU eviction working correctly');
-      pass('LRU functionality verified');
-    } catch(e){ 
-      cache?.destroy(); 
-      fail(e.message); 
+      return fail('oldest should be evicted');
     }
+
+    cache.destroy();
+    pass('LRU functionality verified');
   },
 
   'TTL expiration invalidates entries': async ({pass, fail, log}) => {
-    try {
-      const cache = createTestCache({
-        maxSize: 10,
-        ttlMs: 50,
-        watchFiles: false
-      });
+    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) throw new Error('should be available immediately');
-      
-      await new Promise(resolve => setTimeout(resolve, 100));
-      
-      if(cache.get('/test.js', mockStats) !== null) throw new Error('should be expired');
-      
+    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();
-      log('✓ TTL expiration working');
-      pass('TTL expiration verified');
-    } catch(e){ 
-      cache?.destroy(); 
-      fail(e.message); 
+      return fail('should be expired');
     }
+    
+    cache.destroy();
+    pass('TTL expiration verified');
   },
 
   'file modification invalidates cache entry': async ({pass, fail, log}) => {
-    try {
-      const cache = createTestCache({
-        maxSize: 10,
-        ttlMs: 60000,
-        watchFiles: false
-      });
+    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) throw new Error('should be available with old stats');
-      if(cache.get('/test.js', newStats) !== null) throw new Error('should be invalidated with newer stats');
-      
+    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();
-      log('✓ File modification detection working');
-      pass('File modification invalidation verified');
-    } catch(e){ 
-      cache?.destroy(); 
-      fail(e.message); 
+      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}) => {
-    try {
-      const cache = createTestCache({
-        maxSize: 100,
-        maxMemoryMB: 0.002,
-        ttlMs: 60000,
-        watchFiles: false
-      });
+    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) throw new Error('first entry should be evicted due to memory limit');
-      if(cache.get('/test2.js', mockStats) === null) throw new Error('second entry should still be cached');
-      if(cache.get('/test3.js', mockStats) === null) throw new Error('third entry should still be cached');
-      
+    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();
-      log('✓ Memory limit enforcement working');
-      pass('Memory limit enforcement verified');
-    } catch(e){ 
-      cache?.destroy(); 
-      fail(e.message); 
+      return fail('third entry should still be cached');
     }
+    
+    cache.destroy();
+    pass('Memory limit enforcement verified');
   },
 
   'statistics tracking works correctly': async ({pass, fail, log}) => {
-    try {
-      const cache = createTestCache({
-        maxSize: 10,
-        watchFiles: false
-      });
+    const cache = createTestCache({
+      maxSize: 10,
+      watchFiles: false
+    });
 
-      const mockStats = { mtime: new Date('2023-01-01') };
-      
-      if(cache.get('/test.js', mockStats) !== null) throw new Error('should be cache miss');
-      if(cache.stats.misses !== 1) throw new Error('miss count should be 1');
-      
-      cache.set('/test.js', { default: () => 'test' }, mockStats, 1);
-      if(cache.get('/test.js', mockStats) === null) throw new Error('should be cache hit');
-      if(cache.stats.hits !== 1) throw new Error('hit count should be 1');
-      
-      if(cache.getHitRate() !== 50) throw new Error('hit rate should be 50%');
-      
-      const stats = cache.getStats();
-      if(!stats.cache || !stats.stats || !stats.memory) throw new Error('stats structure invalid');
-      
+    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();
-      log('✓ Statistics tracking accurate');
-      pass('Statistics tracking verified');
-    } catch(e){ 
-      cache?.destroy(); 
-      fail(e.message); 
+      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;
-    try {
-      log('Starting file watching test...');
-      const tempDir = await createTempDir();
-      log('Created temp directory');
-      
-      cache = createTestCache({
-        maxSize: 10,
-        ttlMs: 60000,
-        watchFiles: true
-      });
-      log('Created cache with file watching enabled');
+    
+    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";');
-      log('Wrote initial test file');
-      const initialStats = await stat(testFilePath);
-      
-      const module = { default: () => 'v1' };
-      cache.set(testFilePath, module, initialStats, 1);
-      log('Set initial cache entry');
-      
-      if(cache.get(testFilePath, initialStats) === null) throw new Error('should be in cache initially');
-      log('Verified initial cache entry exists');
-      
-      await new Promise(resolve => setTimeout(resolve, 50));
-      await writeFile(testFilePath, 'export default () => "v2";');
-      log('Modified test file');
-      
-      await new Promise(resolve => setTimeout(resolve, 200));
-      log('Waited for file watcher to detect changes');
-      
-      if(cache.get(testFilePath, initialStats) !== null) throw new Error('should be invalidated after file change');
-      if(cache.stats.fileChanges === 0) throw new Error('file change should be tracked');
-      log('Verified cache invalidation worked');
-      
-      // Clean up immediately
+    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);
-      log('Deleted test file');
       cache.destroy();
-      log('Destroyed cache');
-      cache = null; // Ensure it's not destroyed again in catch
-      
-      // Give extra time for file watcher cleanup
-      await new Promise(resolve => setTimeout(resolve, 100));
-      log('File watching test cleanup complete');
-      
-      log('✓ File watching invalidation working');
-      pass('File watching verified');
-    } catch(e){ 
-      log(`Error in file watching test: ${e.message}`);
-      if (testFilePath) {
-        try { await unlink(testFilePath); log('Cleaned up test file after error'); } catch {}
-      }
-      cache?.destroy(); 
-      log('Destroyed cache after error');
-      fail(e.message); 
+      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');
   }
 };