kempo-server 1.3.0 → 1.4.3

package/tests/router.node-test.js

@@ -0,0 +1,88 @@
+import http from 'http';
+import path from 'path';
+import {withTempDir, write, expect, randomPort, httpGet, log} from './test-utils.js';
+import router from '../router.js';
+import defaultConfig from '../defaultConfig.js';
+
+export default {
+  'serves static files and 404s unknown': async ({pass, fail, log}) => {
+    try {
+  await withTempDir(async (dir) => {
+    await write(dir, 'index.html', '<h1>Home</h1>');
+  const prev = process.cwd();
+  process.chdir(dir);
+  const flags = {root: '.', logging: 0, scan: false};
+  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 ok = await httpGet(`http://localhost:${port}/index.html`);
+          log('ok status: ' + ok.res.statusCode);
+          if(ok.res.statusCode !== 200) throw new Error('static 200');
+          const miss = await httpGet(`http://localhost:${port}/nope`);
+          log('miss status: ' + miss.res.statusCode);
+          if(miss.res.statusCode !== 404) throw new Error('404');
+        } finally {
+          server.close();
+      process.chdir(prev);
+        }
+      });
+      pass('static + 404');
+    } catch(e){ fail(e.message); }
+  },
+  'rescan on 404 when enabled and not blacklisted': async ({pass, fail, log}) => {
+    try {
+  await withTempDir(async (dir) => {
+  const prev = process.cwd();
+  process.chdir(dir);
+  const flags = {root: '.', logging: 0, scan: true};
+  const handler = await router(flags, log);
+        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 miss1 = await httpGet(`http://localhost:${port}/late.html`);
+          log('first miss: ' + miss1.res.statusCode);
+          if(miss1.res.statusCode !== 404) throw new Error('first 404');
+          await write(dir, 'late.html', 'later');
+          const hit = await httpGet(`http://localhost:${port}/late.html`);
+          log('hit after rescan: ' + hit.res.statusCode);
+          if(hit.res.statusCode !== 200) throw new Error('served after rescan');
+    } finally { server.close(); process.chdir(prev); }
+      });
+      pass('rescan');
+    } catch(e){ fail(e.message); }
+  },
+  'custom and wildcard routes serve mapped files': async ({pass, fail, log}) => {
+    try {
+  await withTempDir(async (dir) => {
+  const fileA = await write(dir, 'a.txt', 'A');
+  const fileB = await write(dir, 'b/1.txt', 'B1');
+  const prev = process.cwd();
+  process.chdir(dir);
+  const flags = {root: '.', logging: 0, scan: false};
+  const logFn = () => {};
+  // write config before init
+  await write(dir, '.config.json', JSON.stringify({customRoutes: {'/a': fileA, 'b/*': path.join(dir, 'b/*')}}));
+  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 r1 = await httpGet(`http://localhost:${port}/a`);
+          log('custom status: ' + r1.res.statusCode);
+          if(r1.body.toString() !== 'A') throw new Error('custom route');
+          const r2 = await httpGet(`http://localhost:${port}/b/1.txt`);
+          log('wildcard status: ' + r2.res.statusCode);
+          if(r2.body.toString() !== 'B1') throw new Error('wildcard');
+    } finally { server.close(); process.chdir(prev); }
+      });
+      pass('custom+wildcard');
+    } catch(e){ fail(e.message); }
+  }
+};

package/tests/serveFile.node-test.js

@@ -0,0 +1,52 @@
+import serveFile from '../serveFile.js';
+import findFile from '../findFile.js';
+import defaultConfig from '../defaultConfig.js';
+import path from 'path';
+import {createMockReq, createMockRes, withTempDir, write, expect, log} from './test-utils.js';
+
+export default {
+  'serves static file with correct mime': async ({pass, fail}) => {
+    try {
+      await withTempDir(async (dir) => {
+        const cfg = JSON.parse(JSON.stringify(defaultConfig));
+        await write(dir, 'index.html', '<h1>Hi</h1>');
+        const files = [path.join(dir, 'index.html')];
+        const res = createMockRes();
+        const ok = await serveFile(files, dir, '/index.html', 'GET', cfg, createMockReq(), res, log);
+        expect(ok === true, 'should serve');
+        expect(res.statusCode === 200, 'status');
+        expect(res.getHeader('Content-Type') === 'text/html', 'mime');
+      });
+      pass('static');
+    } catch(e){ fail(e.message); }
+  },
+  'executes route files by calling default export': async ({pass, fail}) => {
+    try {
+      await withTempDir(async (dir) => {
+        const cfg = JSON.parse(JSON.stringify(defaultConfig));
+        await write(dir, 'api/GET.js', "export default async (req, res) => { res.status(201).json({ok:true, params:req.params}); }\n");
+        const files = [path.join(dir, 'api/GET.js')];
+        const res = createMockRes();
+        const ok = await serveFile(files, dir, '/api', 'GET', cfg, createMockReq(), res, log);
+        expect(ok === true, 'served route');
+        expect(res.statusCode === 201, 'route status');
+        expect(res.getBody().toString().includes('ok'), 'body contains ok');
+      });
+      pass('route exec');
+    } catch(e){ fail(e.message); }
+  },
+  'handles route file without default function': async ({pass, fail}) => {
+    try {
+      await withTempDir(async (dir) => {
+        const cfg = JSON.parse(JSON.stringify(defaultConfig));
+        await write(dir, 'api/GET.js', "export const x = 1;\n");
+        const files = [path.join(dir, 'api/GET.js')];
+        const res = createMockRes();
+        const ok = await serveFile(files, dir, '/api', 'GET', cfg, createMockReq(), res, log);
+        expect(ok === true, 'handled');
+        expect(res.statusCode === 500, '500');
+      });
+      pass('route no default');
+    } catch(e){ fail(e.message); }
+  }
+};

package/tests/test-utils.js

@@ -0,0 +1,106 @@
+import {Readable} from 'stream';
+import {mkdtemp, rm, writeFile, mkdir} from 'fs/promises';
+import os from 'os';
+import path from 'path';
+
+export const createMockReq = ({method = 'GET', url = '/', headers = {}, body = null, remoteAddress = '127.0.0.1'} = {}) => {
+  const stream = new Readable({read(){}});
+  stream.method = method;
+  stream.url = url;
+  stream.headers = headers;
+  stream.socket = {remoteAddress};
+  if(body !== null && body !== undefined){
+    const data = typeof body === 'string' || Buffer.isBuffer(body) ? body : JSON.stringify(body);
+    setImmediate(() => {
+      stream.emit('data', Buffer.from(data));
+      stream.emit('end');
+    });
+  } else {
+    setImmediate(() => stream.emit('end'));
+  }
+  return stream;
+};
+
+export const createMockRes = () => {
+  const headers = new Map();
+  let ended = false;
+  let statusCode = 200;
+  const chunks = [];
+  return {
+    get statusCode(){return statusCode;},
+    set statusCode(v){statusCode = v;},
+    setHeader: (k, v) => headers.set(k, v),
+    getHeader: (k) => headers.get(k),
+    writeHead: (code, hdrs = {}) => {
+      statusCode = code;
+      Object.entries(hdrs).forEach(([k, v]) => headers.set(k, v));
+    },
+    write: (chunk) => { if(chunk) chunks.push(Buffer.from(chunk)); return true; },
+    end: (chunk) => { if(chunk) chunks.push(Buffer.from(chunk)); ended = true; },
+    getHeaders: () => Object.fromEntries(headers),
+    getBody: () => Buffer.concat(chunks),
+    isEnded: () => ended
+  };
+};
+
+export const withTempDir = async (fn) => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), 'kempo-tests-'));
+  try {
+    return await fn(dir);
+  } finally {
+    await rm(dir, {recursive: true, force: true});
+  }
+};
+
+export const write = async (root, rel, content = '') => {
+  const full = path.join(root, rel);
+  await mkdir(path.dirname(full), {recursive: true});
+  await writeFile(full, content);
+  return full;
+};
+
+export const wait = ms => new Promise(r => setTimeout(r, ms));
+
+export const log = (..._args) => {};
+
+export const bigString = (size = 5000) => 'x'.repeat(size);
+
+export const randomPort = () => 1024 + Math.floor(Math.random() * 50000);
+
+export const httpGet = (url) => new Promise((resolve, reject) => {
+  import('http').then(({get}) => {
+    get(url, res => {
+      const chunks = [];
+      res.on('data', c => chunks.push(c));
+      res.on('end', () => resolve({res, body: Buffer.concat(chunks)}));
+    }).on('error', reject);
+  }).catch(reject);
+});
+
+export const startNode = async (args, options = {}) => {
+  const {spawn} = await import('child_process');
+  const child = spawn(process.execPath, args, {stdio: ['ignore', 'pipe', 'pipe'], ...options});
+  child.stdout.setEncoding('utf8');
+  child.stderr.setEncoding('utf8');
+  return child;
+};
+
+export const setEnv = (pairs, fn) => {
+  const prev = {};
+  Object.keys(pairs).forEach(k => { prev[k] = process.env[k]; process.env[k] = pairs[k]; });
+  const restore = () => { Object.keys(pairs).forEach(k => { if(prev[k] === undefined){ delete process.env[k]; } else { process.env[k] = prev[k]; } }); };
+  return fn().finally(restore);
+};
+
+export const expect = (condition, message) => {
+  if(!condition){ throw new Error(message); }
+};
+
+export const toString = (buf) => Buffer.isBuffer(buf) ? buf.toString() : String(buf);
+
+export const gzipSize = async (buf) => {
+  const {gzip} = await import('zlib');
+  return new Promise((res, rej) => gzip(buf, (e, out) => e ? rej(e) : res(out.length)));
+};
+
+export const parseCookies = (setCookie) => Array.isArray(setCookie) ? setCookie : (setCookie ? [setCookie] : []);