kempo-server 2.1.1 → 3.0.0

package/tests/config-flag.node-test.js

@@ -14,7 +14,7 @@ export default {
       port: 3000,
       logging: 2,
       root: './',
-      config: '.config.json'
+      config: '.config.js'
     }, {
       p: 'port',
       l: 'logging',
@@ -22,8 +22,8 @@ export default {
       c: 'config'
     });
     
-    if (flags.config !== '.config.json') {
-      return fail('default config should be .config.json');
+    if (flags.config !== '.config.js') {
+      return fail('default config should be .config.js');
     }
     if (flags.port !== '8080') {
       return fail('other flags should still work');
@@ -36,12 +36,12 @@ export default {
   },
 
   'getFlags parses custom config flag with long form': async ({pass, fail}) => {
-    const args = ['--root', 'public', '--config', 'dev.config.json'];
+    const args = ['--root', 'public', '--config', 'dev.config.js'];
     const flags = getFlags(args, {
       port: 3000,
       logging: 2,
       root: './',
-      config: '.config.json'
+      config: '.config.js'
     }, {
       p: 'port',
       l: 'logging',
@@ -49,7 +49,7 @@ export default {
       c: 'config'
     });
     
-    if (flags.config !== 'dev.config.json') {
+    if (flags.config !== 'dev.config.js') {
       return fail('should parse custom config file');
     }
     if (flags.root !== 'public') {
@@ -60,12 +60,12 @@ export default {
   },
 
   'getFlags parses custom config flag with short form': async ({pass, fail}) => {
-    const args = ['--root', 'public', '-c', 'production.config.json'];
+    const args = ['--root', 'public', '-c', 'production.config.js'];
     const flags = getFlags(args, {
       port: 3000,
       logging: 2,
       root: './',
-      config: '.config.json'
+      config: '.config.js'
     }, {
       p: 'port',
       l: 'logging',
@@ -73,7 +73,7 @@ export default {
       c: 'config'
     });
     
-    if (flags.config !== 'production.config.json') {
+    if (flags.config !== 'production.config.js') {
       return fail('should parse short form config flag');
     }
     if (flags.root !== 'public') {
@@ -85,19 +85,19 @@ export default {
 
   'router uses default config file when none specified': async ({pass, fail}) => {
     await withTempDir(async (dir) => {
-      // Create a custom config file as .config.json (default name)
+      // Create a custom config file as .config.js (default name)
       const customConfig = {
         allowedMimes: {
           html: { mime: "text/html", encoding: "utf8" },
           custom: { mime: "text/custom", encoding: "utf8" }
         }
       };
-      await write(dir, '.config.json', JSON.stringify(customConfig));
+      await write(dir, '.config.js', `export default ${JSON.stringify(customConfig)}`);
       await write(dir, 'test.custom', 'custom content');
       
       const prev = process.cwd();
       process.chdir(dir);
-      const flags = {root: '.', logging: 0, rescan: false, config: '.config.json'};
+      const flags = {root: '.', logging: 0, rescan: false, config: '.config.js'};
       const logFn = () => {};
       const handler = await router(flags, logFn);
       const server = http.createServer(handler);
@@ -131,12 +131,12 @@ export default {
             special: { mime: "text/special", encoding: "utf8" }
           }
         };
-      await write(dir, 'dev.config.json', JSON.stringify(customConfig));
+      await write(dir, 'dev.config.js', `export default ${JSON.stringify(customConfig)}`);
       await write(dir, 'test.special', 'special content');
       
       const prev = process.cwd();
       process.chdir(dir);
-      const flags = {root: '.', logging: 0, rescan: false, config: 'dev.config.json'};
+      const flags = {root: '.', logging: 0, rescan: false, config: 'dev.config.js'};
       const logFn = () => {};
       const handler = await router(flags, logFn);
       const server = http.createServer(handler);
@@ -171,7 +171,7 @@ export default {
             absolute: { mime: "text/absolute", encoding: "utf8" }
           }
         };
-      const configPath = await write(configDir, 'prod.config.json', JSON.stringify(customConfig));
+      const configPath = await write(configDir, 'prod.config.js', `export default ${JSON.stringify(customConfig)}`);
       await write(dir, 'test.absolute', 'absolute content');
       
       const prev = process.cwd();
@@ -201,14 +201,51 @@ export default {
     });
   },
 
-  'router falls back to default config when custom config file missing': async ({pass, fail}) => {
+  'router falls back to .config.json when .config.js is missing': async ({pass, fail}) => {
+    await withTempDir(async (dir) => {
+      const customConfig = {
+        allowedMimes: {
+          html: { mime: "text/html", encoding: "utf8" },
+          jsononly: { mime: "text/jsononly", encoding: "utf8" }
+        }
+      };
+      await write(dir, '.config.json', JSON.stringify(customConfig));
+      await write(dir, 'test.jsononly', 'json fallback content');
+      
+      const prev = process.cwd();
+      process.chdir(dir);
+      const flags = {root: '.', logging: 0, rescan: false, config: '.config.js'};
+      const logFn = () => {};
+      const handler = await router(flags, logFn);
+      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 response = await httpGet(`http://localhost:${port}/test.jsononly`);
+        if (response.res.statusCode !== 200) {
+          return fail('should fall back to .config.json and serve custom mime');
+        }
+        if (response.res.headers['content-type'] !== 'text/jsononly; charset=utf-8') {
+          return fail('should use config from JSON fallback');
+        }
+        pass('falls back to .config.json when .config.js missing');
+      } finally {
+        server.close();
+        process.chdir(prev);
+      }
+    });
+  },
+
+  'router falls back to default config when no config file exists': async ({pass, fail}) => {
     await withTempDir(async (dir) => {
       await write(dir, 'index.html', '<h1>Home</h1>');
       
       const prev = process.cwd();
       process.chdir(dir);
-      // Point to non-existent config file
-      const flags = {root: '.', logging: 0, rescan: false, config: 'nonexistent.config.json'};
+      const flags = {root: '.', logging: 0, rescan: false, config: 'nonexistent.config.js'};
       const logFn = () => {};
       const handler = await router(flags, logFn);
       const server = http.createServer(handler);
@@ -235,13 +272,12 @@ export default {
 
   'router handles malformed config file gracefully': async ({pass, fail}) => {
     await withTempDir(async (dir) => {
-      // Create malformed JSON config
-      await write(dir, 'bad.config.json', '{ invalid json }');
+      await write(dir, 'bad.config.js', 'this is not valid javascript export default {');
       await write(dir, 'index.html', '<h1>Home</h1>');
       
       const prev = process.cwd();
       process.chdir(dir);
-      const flags = {root: '.', logging: 0, rescan: false, config: 'bad.config.json'};
+      const flags = {root: '.', logging: 0, rescan: false, config: 'bad.config.js'};
       const logFn = () => {};
       const handler = await router(flags, logFn);
       const server = http.createServer(handler);
@@ -275,13 +311,13 @@ export default {
         },
         maxRescanAttempts: 5
       };
-      await write(dir, 'partial.config.json', JSON.stringify(partialConfig));
+      await write(dir, 'partial.config.js', `export default ${JSON.stringify(partialConfig)}`);
       await write(dir, 'test.js', 'console.log("test");'); // JS should still work from default config
       await write(dir, 'test.custom', 'custom content');
       
       const prev = process.cwd();
       process.chdir(dir);
-      const flags = {root: '.', logging: 0, rescan: false, config: 'partial.config.json'};
+      const flags = {root: '.', logging: 0, rescan: false, config: 'partial.config.js'};
       const logFn = () => {};
       const handler = await router(flags, logFn);
       const server = http.createServer(handler);
@@ -320,7 +356,7 @@ export default {
     await withTempDir(async (dir) => {
       // Create a config file outside the server root
       const configDir = path.join(dir, '..', 'config-outside-root');
-      const configFilePath = await write(configDir, 'outside.config.json', '{"allowedMimes": {"test": "application/test"}}');
+      const configFilePath = await write(configDir, 'outside.config.js', `export default {allowedMimes: {test: "application/test"}}`);
       
       // Create a file in the server root to verify it doesn't start
       await write(dir, 'index.html', '<h1>Home</h1>');
@@ -330,7 +366,7 @@ export default {
       
       try {
         // Try to use config file outside server root with relative path
-        const flags = {root: '.', logging: 0, rescan: false, config: '../config-outside-root/outside.config.json'};
+        const flags = {root: '.', logging: 0, rescan: false, config: '../config-outside-root/outside.config.js'};
         
         log('Test setup:');
         log('dir: ' + dir);

package/tests/customRoute-outside-root.node-test.js

@@ -44,7 +44,7 @@ export default {
             '/src/file.txt': '../src/file.txt'
           }
         };
-        await writeFile(path.join(rootDir, '.config.json'), JSON.stringify(config));
+        await writeFile(path.join(rootDir, '.config.js'), `export default ${JSON.stringify(config)}`);
         log('Config written: ' + JSON.stringify(config));
 
   // Set working directory to temp dir so relative paths resolve correctly

package/tests/rescan.node-test.js

@@ -0,0 +1,69 @@
+import http from 'http';
+import {withTestDir} from './utils/test-dir.js';
+import {write} from './utils/file-writer.js';
+import {randomPort} from './utils/port.js';
+import {httpGet} from './utils/http.js';
+import router from '../src/router.js';
+import rescan from '../src/rescan.js';
+
+export default {
+  'rescan() triggers file rescan and returns file count': async ({pass, fail}) => {
+    await withTestDir(async dir => {
+      const prev = process.cwd();
+      process.chdir(dir);
+      const flags = {root: '.', logging: 0};
+      const logFn = () => {};
+
+      await write(dir, '.config.json', JSON.stringify({
+        maxRescanAttempts: 0
+      }));
+      await write(dir, 'index.html', '<h1>Home</h1>');
+
+      const handler = await router(flags, logFn);
+      const server = http.createServer(handler);
+      const port = randomPort();
+      await new Promise(r => server.listen(port, r));
+      await new Promise(r => setTimeout(r, 50));
+
+      const miss = await httpGet(`http://localhost:${port}/added.html`);
+      if(miss.res.statusCode !== 404) {
+        server.close();
+        process.chdir(prev);
+        return fail('should 404 before file exists');
+      }
+
+      await write(dir, 'added.html', '<h1>Added</h1>');
+
+      const stillMiss = await httpGet(`http://localhost:${port}/added.html`);
+      if(stillMiss.res.statusCode !== 404) {
+        server.close();
+        process.chdir(prev);
+        return fail('should still 404 with maxRescanAttempts=0');
+      }
+
+      const count = await rescan();
+      if(typeof count !== 'number' || count < 2) {
+        server.close();
+        process.chdir(prev);
+        return fail(`rescan should return file count, got: ${count}`);
+      }
+
+      const hit = await httpGet(`http://localhost:${port}/added.html`);
+      if(hit.res.statusCode !== 200) {
+        server.close();
+        process.chdir(prev);
+        return fail('should serve file after rescan()');
+      }
+
+      if(!hit.body.toString().includes('Added')) {
+        server.close();
+        process.chdir(prev);
+        return fail('should serve correct content after rescan');
+      }
+
+      server.close();
+      process.chdir(prev);
+    });
+    pass('rescan() works from imported function');
+  },
+};

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

@@ -172,6 +172,51 @@ export default {
       pass('wildcard routes correctly override static files');
     } catch(e){ 
       fail(e.message); 
-    }
-  }
+    }  },
+
+  'wildcard routes without leading slash match requests': async ({pass, fail, log}) => {
+    try {
+      await withTempDir(async (dir) => {
+        await write(dir, 'media/icon.png', 'icon-data');
+        await write(dir, 'media/logo.svg', '<svg/>');
+
+        const prev = process.cwd();
+        process.chdir(dir);
+
+        const flags = {root: 'docs', logging: 0};
+
+        // Keys without leading slash — the bug caused these to never match
+        const config = {
+          customRoutes: {
+            'media/*': '../media/*'
+          }
+        };
+
+        await write(dir, 'docs/.config.json', JSON.stringify(config));
+        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 r1 = await httpGet(`http://localhost:${port}/media/icon.png`);
+          log('png status: ' + r1.res.statusCode);
+          if(r1.res.statusCode !== 200) throw new Error('expected 200 for /media/icon.png');
+          if(r1.body.toString() !== 'icon-data') throw new Error('wrong content for icon.png');
+
+          const r2 = await httpGet(`http://localhost:${port}/media/logo.svg`);
+          log('svg status: ' + r2.res.statusCode);
+          if(r2.res.statusCode !== 200) throw new Error('expected 200 for /media/logo.svg');
+          if(r2.body.toString() !== '<svg/>') throw new Error('wrong content for logo.svg');
+        } finally {
+          await new Promise(r => server.close(r));
+          process.chdir(prev);
+        }
+      });
+      pass('wildcard routes without leading slash match requests correctly');
+    } catch(e){
+      fail(e.message);
+    }  }
 };

package/tests/templating-parse.node-test.js

@@ -0,0 +1,243 @@
+import {
+  extractAttrs,
+  extractContentBlocks,
+  replaceLocations,
+  stripFragmentWrapper,
+  resolveVars,
+  resolveIfs,
+  resolveForeach,
+  resolveFragmentTags,
+  evalCondition,
+  resolvePath
+} from '../src/templating/parse.js';
+
+export default {
+  'extractAttrs parses double-quoted attributes': ({pass, fail}) => {
+    const result = extractAttrs('template="default" title="Hello"');
+    if(result.template !== 'default') return fail('template wrong');
+    if(result.title !== 'Hello') return fail('title wrong');
+    pass();
+  },
+  'extractAttrs parses single-quoted attributes': ({pass, fail}) => {
+    const result = extractAttrs("name='test'");
+    if(result.name !== 'test') return fail('name wrong');
+    pass();
+  },
+  'extractContentBlocks extracts named blocks': ({pass, fail}) => {
+    const xml = '<content location="main">Hello</content><content location="sidebar">World</content>';
+    const blocks = extractContentBlocks(xml);
+    if(blocks.main !== 'Hello') return fail('main wrong');
+    if(blocks.sidebar !== 'World') return fail('sidebar wrong');
+    pass();
+  },
+  'replaceLocations fills named locations': ({pass, fail}) => {
+    const html = '<location name="main" />';
+    const result = replaceLocations(html, {main: '<p>Hi</p>'});
+    if(result !== '<p>Hi</p>') return fail(`got: ${result}`);
+    pass();
+  },
+  'replaceLocations uses fallback content': ({pass, fail}) => {
+    const html = '<location name="main">fallback</location>';
+    const result = replaceLocations(html, {});
+    if(result !== 'fallback') return fail(`got: ${result}`);
+    pass();
+  },
+  'replaceLocations uses content over fallback': ({pass, fail}) => {
+    const html = '<location name="main">fallback</location>';
+    const result = replaceLocations(html, {main: 'real'});
+    if(result !== 'real') return fail(`got: ${result}`);
+    pass();
+  },
+  'stripFragmentWrapper removes wrapping fragment tag': ({pass, fail}) => {
+    const result = stripFragmentWrapper('<fragment name="nav"><nav>Hi</nav></fragment>');
+    if(result !== '<nav>Hi</nav>') return fail(`got: ${result}`);
+    pass();
+  },
+  'stripFragmentWrapper returns content unchanged if no wrapper': ({pass, fail}) => {
+    const result = stripFragmentWrapper('<nav>Hi</nav>');
+    if(result !== '<nav>Hi</nav>') return fail(`got: ${result}`);
+    pass();
+  },
+  'resolvePath navigates dot path': ({pass, fail}) => {
+    const result = resolvePath({a: {b: {c: 42}}}, 'a.b.c');
+    if(result !== 42) return fail(`got: ${result}`);
+    pass();
+  },
+  'resolvePath returns undefined for missing path': ({pass, fail}) => {
+    const result = resolvePath({a: 1}, 'b.c');
+    if(result !== undefined) return fail(`got: ${result}`);
+    pass();
+  },
+  'resolveVars replaces simple variables': ({pass, fail}) => {
+    const result = resolveVars('Hello {{name}}!', {name: 'World'});
+    if(result !== 'Hello World!') return fail(`got: ${result}`);
+    pass();
+  },
+  'resolveVars replaces dot-path variables': ({pass, fail}) => {
+    const result = resolveVars('{{user.name}}', {user: {name: 'Bob'}});
+    if(result !== 'Bob') return fail(`got: ${result}`);
+    pass();
+  },
+  'resolveVars calls function values': ({pass, fail}) => {
+    const result = resolveVars('{{fn}}', {fn: () => 'called'});
+    if(result !== 'called') return fail(`got: ${result}`);
+    pass();
+  },
+  'resolveVars replaces missing vars with empty string': ({pass, fail}) => {
+    const result = resolveVars('{{missing}}', {});
+    if(result !== '') return fail(`got: ${result}`);
+    pass();
+  },
+  'resolveIfs keeps content when condition is true': ({pass, fail}) => {
+    const result = resolveIfs('<if condition="show">visible</if>', {show: true});
+    if(result !== 'visible') return fail(`got: ${result}`);
+    pass();
+  },
+  'resolveIfs removes content when condition is false': ({pass, fail}) => {
+    const result = resolveIfs('<if condition="show">visible</if>', {show: false});
+    if(result !== '') return fail(`got: ${result}`);
+    pass();
+  },
+  'resolveIfs handles comparison operators': ({pass, fail}) => {
+    const result = resolveIfs('<if condition="count > 5">big</if>', {count: 10});
+    if(result !== 'big') return fail(`got: ${result}`);
+    pass();
+  },
+  'resolveIfs handles nested ifs': ({pass, fail}) => {
+    const html = '<if condition="a"><if condition="b">inner</if></if>';
+    const result = resolveIfs(html, {a: true, b: true});
+    if(result !== 'inner') return fail(`got: ${result}`);
+    pass();
+  },
+  'resolveForeach iterates arrays': ({pass, fail}) => {
+    const html = '<foreach in="items" as="item">{{item}},</foreach>';
+    const result = resolveForeach(html, {items: ['a', 'b', 'c']});
+    if(result !== 'a,b,c,') return fail(`got: ${result}`);
+    pass();
+  },
+  'resolveForeach handles empty array': ({pass, fail}) => {
+    const html = '<foreach in="items" as="item">{{item}}</foreach>';
+    const result = resolveForeach(html, {items: []});
+    if(result !== '') return fail(`got: ${result}`);
+    pass();
+  },
+  'resolveForeach handles missing var': ({pass, fail}) => {
+    const html = '<foreach in="nope" as="item">{{item}}</foreach>';
+    const result = resolveForeach(html, {});
+    if(result !== '') return fail(`got: ${result}`);
+    pass();
+  },
+  'resolveForeach handles object items with dot paths': ({pass, fail}) => {
+    const html = '<foreach in="users" as="u">{{u.name}}</foreach>';
+    const result = resolveForeach(html, {users: [{name: 'Alice'}, {name: 'Bob'}]});
+    if(result !== 'AliceBob') return fail(`got: ${result}`);
+    pass();
+  },
+  'resolveFragmentTags inlines fragment content': ({pass, fail}) => {
+    const html = '<fragment name="nav" />';
+    const finder = name => name === 'nav' ? '<nav>Link</nav>' : null;
+    const result = resolveFragmentTags(html, finder, 0, 10);
+    if(result !== '<nav>Link</nav>') return fail(`got: ${result}`);
+    pass();
+  },
+  'resolveFragmentTags uses fallback when fragment not found': ({pass, fail}) => {
+    const html = '<fragment name="missing">fallback</fragment>';
+    const finder = () => null;
+    const result = resolveFragmentTags(html, finder, 0, 10);
+    if(result !== 'fallback') return fail(`got: ${result}`);
+    pass();
+  },
+  'resolveFragmentTags throws on max depth': ({pass, fail}) => {
+    const html = '<fragment name="loop" />';
+    const finder = () => '<fragment name="loop" />';
+    try {
+      resolveFragmentTags(html, finder, 0, 3);
+      fail('should have thrown');
+    } catch(e){
+      if(!e.message.includes('depth exceeded')) return fail(`wrong error: ${e.message}`);
+      pass();
+    }
+  },
+  'evalCondition: truthy identifier': ({pass, fail}) => {
+    if(!evalCondition('active', {active: true})) return fail('should be true');
+    pass();
+  },
+  'evalCondition: falsy identifier': ({pass, fail}) => {
+    if(evalCondition('active', {active: false})) return fail('should be false');
+    pass();
+  },
+  'evalCondition: string equality': ({pass, fail}) => {
+    if(!evalCondition('env === "prod"', {env: 'prod'})) return fail('should be true');
+    pass();
+  },
+  'evalCondition: string inequality': ({pass, fail}) => {
+    if(!evalCondition('env !== "dev"', {env: 'prod'})) return fail('should be true');
+    pass();
+  },
+  'evalCondition: numeric comparison': ({pass, fail}) => {
+    if(!evalCondition('count >= 10', {count: 10})) return fail('should be true');
+    if(evalCondition('count > 10', {count: 10})) return fail('should be false');
+    pass();
+  },
+  'evalCondition: logical AND': ({pass, fail}) => {
+    if(!evalCondition('a && b', {a: true, b: true})) return fail('should be true');
+    if(evalCondition('a && b', {a: true, b: false})) return fail('should be false');
+    pass();
+  },
+  'evalCondition: logical OR': ({pass, fail}) => {
+    if(!evalCondition('a || b', {a: false, b: true})) return fail('should be true');
+    if(evalCondition('a || b', {a: false, b: false})) return fail('should be false');
+    pass();
+  },
+  'evalCondition: NOT operator': ({pass, fail}) => {
+    if(!evalCondition('!hidden', {hidden: false})) return fail('should be true');
+    if(evalCondition('!hidden', {hidden: true})) return fail('should be false');
+    pass();
+  },
+  'evalCondition: parenthesized expression': ({pass, fail}) => {
+    if(!evalCondition('(a || b) && c', {a: false, b: true, c: true})) return fail('should be true');
+    if(evalCondition('(a || b) && c', {a: false, b: true, c: false})) return fail('should be false');
+    pass();
+  },
+  'evalCondition: dot-path variable': ({pass, fail}) => {
+    if(!evalCondition('user.admin', {user: {admin: true}})) return fail('should be true');
+    pass();
+  },
+  'evalCondition: boolean literals': ({pass, fail}) => {
+    if(!evalCondition('true', {})) return fail('true should be true');
+    if(evalCondition('false', {})) return fail('false should be false');
+    pass();
+  },
+  'extractContentBlocks defaults location to default': ({pass, fail}) => {
+    const blocks = extractContentBlocks('<content>Hello</content>');
+    if(blocks.default !== 'Hello') return fail(`got: ${blocks.default}`);
+    pass();
+  },
+  'extractContentBlocks concatenates multiple contents to same location': ({pass, fail}) => {
+    const xml = '<content location="main">A</content><content location="main">B</content>';
+    const blocks = extractContentBlocks(xml);
+    if(blocks.main !== 'AB') return fail(`got: ${blocks.main}`);
+    pass();
+  },
+  'extractContentBlocks concatenates default contents': ({pass, fail}) => {
+    const xml = '<content>A</content><content>B</content>';
+    const blocks = extractContentBlocks(xml);
+    if(blocks.default !== 'AB') return fail(`got: ${blocks.default}`);
+    pass();
+  },
+  'replaceLocations defaults nameless location to default': ({pass, fail}) => {
+    const result = replaceLocations('<location />', {default: 'Hi'});
+    if(result !== 'Hi') return fail(`got: ${result}`);
+    pass();
+  },
+  'replaceLocations defaults nameless block location to default': ({pass, fail}) => {
+    const result = replaceLocations('<location>fallback</location>', {default: 'Hi'});
+    if(result !== 'Hi') return fail(`got: ${result}`);
+    pass();
+  },
+  'replaceLocations uses fallback for nameless location': ({pass, fail}) => {
+    const result = replaceLocations('<location>fallback</location>', {});
+    if(result !== 'fallback') return fail(`got: ${result}`);
+    pass();
+  }
+};