qunitx 0.5.3 → 0.6.0

package/lib/commands/run/tests-in-browser.js

@@ -122,8 +122,8 @@ async function runTestInsideHTMLFile(filePath, { page, server }, config) {
   let targetError;
   try {
     await wait(350);
-    console.log('#', kleur.blue(`QUnitX running: http://localhost:${server.config.port}${filePath}`));
-    await page.goto(`http://localhost:${server.config.port}${filePath}`, { timeout: 0 });
+    console.log('#', kleur.blue(`QUnitX running: http://localhost:${config.port}${filePath}`));
+    await page.goto(`http://localhost:${config.port}${filePath}`, { timeout: 0 });
     await page.evaluate(() => {
       window.IS_PUPPETEER = true;
     });

package/lib/commands/run.js

@@ -142,7 +142,7 @@ async function addCachedContentMainHTML(projectRoot, cachedContent) {
 
 function logWatcherAndKeyboardShortcutInfo(config, server) {
   if (config.browser) {
-    console.log('#', kleur.blue(`Watching files... You can browse the tests on http://localhost:${server.config.port} ...`)); // NOTE: maybe add also qx to exit
+    console.log('#', kleur.blue(`Watching files... You can browse the tests on http://localhost:${config.port} ...`)); // NOTE: maybe add also qx to exit
     console.log('#', kleur.blue(`Shortcuts: Press "qq" to abort running tests, "qa" to run all the tests, "qf" to run last failing test, "ql" to repeat last test`)); // NOTE: maybe add also qx to test specific
   } else {
     console.log('#', kleur.blue(`Watching files...`));

package/lib/servers/http.js

@@ -0,0 +1,229 @@
+import http from 'node:http';
+import WebSocket, { WebSocketServer } from 'ws';
+import bindServerToPort from '../setup/bind-server-to-port.js';
+
+export const MIME_TYPES = {
+  html: "text/html; charset=UTF-8",
+  js: "application/javascript",
+  css: "text/css",
+  png: "image/png",
+  jpg: "image/jpg",
+  gif: "image/gif",
+  ico: "image/x-icon",
+  svg: "image/svg+xml",
+};
+
+export default class HTTPServer {
+  static serve(config = { port: 1234 }, handler) {
+    let onListen = config.onListen || ((server) => {});
+    let onError = config.onError || ((error) => {});
+
+    return new Promise((resolve, reject) => {
+      let server = http.createServer((req, res) => {
+        return handler(req, res);
+      });
+      server = server;
+      server.on('error', (error) => {
+        onError(error);
+        reject(error);
+      }).once('listening', () => {
+        onListen(Object.assign({ hostname: '127.0.0.1', server }, config));
+        resolve(server);
+      })
+
+      server.wss = new WebSocketServer({ server });
+      server.wss.on('error', (error) => {
+        console.log('# [WebSocketServer] Error:');
+        console.trace(error);
+      });
+
+      bindServerToPort(server, config)
+    });
+  }
+
+  constructor() {
+    this.routes = {
+      GET: {},
+      POST: {},
+      DELETE: {},
+      PUT: {}
+    };
+    this.middleware = [];
+    this._server = http.createServer((req, res) => {
+      res.send = (data) => {
+        res.setHeader('Content-Type', 'text/plain');
+        res.end(data);
+      };
+      res.json = (data) => {
+        res.setHeader('Content-Type', 'application/json');
+        res.end(JSON.stringify(data));
+      };
+
+      return this.handleRequest(req, res);
+    });
+    this.wss = new WebSocketServer({ server: this._server });
+    this.wss.on('error', (error) => {
+      console.log('### WebSocketServer Error:');
+      console.log(error);
+    });
+  }
+
+  get(path, handler) {
+    this.registerRouteHandler('GET', path, handler);
+  }
+
+  listen(port = 0, callback = () => {}) {
+    return new Promise((resolve, reject) => {
+      this._server.listen(port, (error) => {
+        if (error) {
+          reject(error);
+        } else {
+          resolve(callback());
+        }
+      });
+    });
+  }
+
+  publish(data) {
+    this.wss.clients.forEach((client) => {
+      if (client.readyState === WebSocket.OPEN) {
+        client.send(data);
+      }
+    });
+  }
+
+  post(path, handler) {
+    this.registerRouteHandler('POST', path, handler);
+  }
+
+  delete(path, handler) {
+    this.registerRouteHandler('DELETE', path, handler);
+  }
+
+  put(path, handler) {
+    this.registerRouteHandler('PUT', path, handler);
+  }
+
+  use(middleware) {
+    this.middleware.push(middleware);
+  }
+
+  registerRouteHandler(method, path, handler) {
+    if (!this.routes[method]) {
+      this.routes[method] = {};
+    }
+
+    this.routes[method][path] = {
+      path,
+      handler,
+      paramNames: this.extractParamNames(path),
+      isWildcard: path === '/*'
+    };
+  }
+
+  handleRequest(req, res) {
+    const { method, url } = req;
+    const matchingRoute = this.findRouteHandler(method, url);
+
+    if (matchingRoute) {
+      req.params = this.extractParams(matchingRoute, url);
+      this.runMiddleware(req, res, matchingRoute.handler);
+    } else {
+      res.statusCode = 404;
+      res.setHeader('Content-Type', 'text/plain');
+      res.end('Not found');
+    }
+  }
+
+  runMiddleware(req, res, callback) {
+    let index = 0;
+    const next = () => {
+      if (index >= this.middleware.length) {
+        callback(req, res);
+      } else {
+        const middleware = this.middleware[index];
+        index++;
+        middleware(req, res, next);
+      }
+    };
+    next();
+  }
+
+  findRouteHandler(method, url) {
+    const routes = this.routes[method];
+    if (!routes) {
+      return null;
+    }
+
+    return routes[url] || Object.values(routes).find(route => {
+      const { path, isWildcard } = route;
+
+      if (!isWildcard && !path.includes(':')) {
+        return false;
+      }
+
+      if (isWildcard || this.matchPathSegments(path, url)) {
+        if (route.paramNames.length > 0) {
+          const regexPattern = this.buildRegexPattern(path, route.paramNames);
+          const regex = new RegExp(`^${regexPattern}$`);
+          const regexMatches = regex.exec(url);
+          if (regexMatches) {
+            route.paramValues = regexMatches.slice(1);
+          }
+        }
+        return true;
+      }
+
+      return false;
+    }) || routes['/*'] || null;
+  }
+
+  matchPathSegments(path, url) {
+    const pathSegments = path.split('/');
+    const urlSegments = url.split('/');
+
+    if (pathSegments.length !== urlSegments.length) {
+      return false;
+    }
+
+    for (let i = 0; i < pathSegments.length; i++) {
+      const pathSegment = pathSegments[i];
+      const urlSegment = urlSegments[i];
+
+      if (pathSegment.startsWith(':')) {
+        continue;
+      }
+
+      if (pathSegment !== urlSegment) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  buildRegexPattern(path, paramNames) {
+    let regexPattern = path.replace(/:[^/]+/g, '([^/]+)');
+    regexPattern = regexPattern.replace(/\//g, '\\/');
+
+    return regexPattern;
+  }
+
+  extractParamNames(path) {
+    const paramRegex = /:(\w+)/g;
+    const paramMatches = path.match(paramRegex);
+
+    return paramMatches ? paramMatches.map(match => match.slice(1)) : [];
+  }
+
+  extractParams(route, url) {
+    const { paramNames, paramValues } = route;
+    const params = {};
+
+    for (let i = 0; i < paramNames.length; i++) {
+      params[paramNames[i]] = paramValues[i];
+    }
+
+    return params;
+  }
+}

package/lib/setup/bind-server-to-port.js

@@ -1,7 +1,7 @@
 import resolvePortNumberFor from '../utils/resolve-port-number-for.js';
 
 // NOTE: there was a race condition between socket.connection and server.listen, check if nanoexpress fixes it
-export default async function bindServerToPort(config, server) {
+export default async function bindServerToPort(server, config) {
   try {
     let port = await resolvePortNumberFor(config.port);
 

package/lib/setup/browser.js

@@ -1,5 +1,3 @@
-import fs from 'node:fs/promises';
-import kleur from 'kleur';
 import Puppeteer from 'puppeteer';
 import setupWebServer from './web-server.js';
 import bindServerToPort from './bind-server-to-port.js';
@@ -16,9 +14,9 @@ export default async function setupBrowser(config = {
       headless: 'new',
     }),
   ]);
-  let [page, ..._] = await Promise.all([
+  let [page, _] = await Promise.all([
     browser.newPage(),
-    bindServerToPort(config, server)
+    bindServerToPort(server, config)
   ]);
 
   page.on('console', async (msg) => {

package/lib/setup/web-server.js

@@ -1,37 +1,21 @@
-import fs from 'node:fs/promises';
+import fs from 'node:fs';
 import path from 'node:path';
-import kleur from 'kleur';
-import express from 'nanoexpress';
-import staticServe from '@nanoexpress/middleware-static-serve';
 import findInternalAssetsFromHTML from '../utils/find-internal-assets-from-html.js';
 import TAPDisplayTestResult from '../tap/display-test-result.js';
+import pathExists from '../utils/path-exists.js';
+import HTTPServer, { MIME_TYPES } from '../servers/http.js';
+
+const fsPromise = fs.promises;
 
 export default async function setupWebServer(config = {
   port: 1234, debug: false, watch: false, timeout: 10000
 }, cachedContent) {
-  let ServerConsole = ['log', 'error', 'done', 'warn', 'info'].reduce((result, type) => {
-    return Object.assign(result, {
-      [type]: (...messages) => {
-        console.log(`# HTTPServer[${type}] :`, ...messages);
-      }
-    });
-  }, {});
-  ServerConsole.debug = (...messages) => {
-    if (config.debug) {
-      console.log('#', kleur.blue(`HTTPServer`), ...messages);
-    }
-  };
+  let STATIC_FILES_PATH = path.join(config.projectRoot, config.output);
+  let server = new HTTPServer();
 
-  let app = express({ console: ServerConsole });
-  let Decoder = new TextDecoder("utf-8");
-
-  app.ws('/', {
-    open(ws) {
-      ws.subscribe('refresh');
-      ws.subscribe('abort');
-    },
-    message(ws, message) {
-      const { event, details, abort } = JSON.parse(Decoder.decode(message));
+  server.wss.on('connection', function connection(socket) {
+    socket.on('message', function message(data) {
+      const { event, details, abort } = JSON.parse(data);
 
       if (event === "connection") {
         console.log('TAP version 13');
@@ -42,67 +26,75 @@ export default async function setupWebServer(config = {
 
         TAPDisplayTestResult(config.COUNTER, details)
       }
-    }
+    });
   });
 
-  app.get('/', async (req, res) => {
-    let TEST_RUNTIME_TO_INJECT = testRuntimeToInject(app.config.port, config);
+  server.get('/', async (req, res) => {
+    let TEST_RUNTIME_TO_INJECT = testRuntimeToInject(config.port, config);
     let htmlContent = escapeAndInjectTestsToHTML(
       replaceAssetPaths(cachedContent.mainHTML.html, cachedContent.mainHTML.filePath, config.projectRoot),
       TEST_RUNTIME_TO_INJECT,
       cachedContent.allTestCode
     );
 
-    res.send(htmlContent);
+    res.write(htmlContent);
+    res.end();
 
-    return await fs.writeFile(`${config.projectRoot}/${config.output}/index.html`, htmlContent);
+    return await fsPromise.writeFile(`${config.projectRoot}/${config.output}/index.html`, htmlContent);
   });
 
-  app.get('/qunitx.html', async (req, res) => {
-    let TEST_RUNTIME_TO_INJECT = testRuntimeToInject(app.config.port, config);
+  server.get('/qunitx.html', async (req, res) => {
+    let TEST_RUNTIME_TO_INJECT = testRuntimeToInject(config.port, config);
     let htmlContent = escapeAndInjectTestsToHTML(
       replaceAssetPaths(cachedContent.mainHTML.html, cachedContent.mainHTML.filePath, config.projectRoot),
       TEST_RUNTIME_TO_INJECT,
       cachedContent.filteredTestCode
     );
 
-    res.send(htmlContent);
+    res.write(htmlContent);
+    res.end();
 
-    return await fs.writeFile(`${config.projectRoot}/${config.output}/qunitx.html`, htmlContent);
+    return await fsPromise.writeFile(`${config.projectRoot}/${config.output}/qunitx.html`, htmlContent);
   });
 
-  app.use(staticServe(path.join(config.projectRoot, config.output), {
-    mode: 'live',
-    lastModified: true,
-    index: false
-  }));
-
-  app.get('/*', async (req, res) => {
-    if (config.debug) {
-      console.log(`# [HTTPServer] ${req.method} ${req.path}`);
-    }
-
-    let dynamicHTML = cachedContent.dynamicContentHTMLs[`${config.projectRoot}${req.path}`];
-    if (dynamicHTML) {
-      let TEST_RUNTIME_TO_INJECT = testRuntimeToInject(app.config.port, config);
+  server.get('/*', async (req, res) => {
+    let possibleDynamicHTML = cachedContent.dynamicContentHTMLs[`${config.projectRoot}${req.path}`];
+    if (possibleDynamicHTML) {
+      let TEST_RUNTIME_TO_INJECT = testRuntimeToInject(config.port, config);
       let htmlContent = escapeAndInjectTestsToHTML(
-        dynamicHTML,
+        possibleDynamicHTML,
         TEST_RUNTIME_TO_INJECT,
         cachedContent.allTestCode
       );
 
-      res.send(htmlContent);
+      res.write(htmlContent);
+      res.end();
+
+      return await fsPromise.writeFile(`${config.projectRoot}/${config.output}${req.path}`, htmlContent);
+    }
+
+    let url = req.url;
+    let requestStartedAt = new Date();
+    let filePath = (url.endsWith("/") ? [STATIC_FILES_PATH, url, "index.html"] : [STATIC_FILES_PATH, url]).join('');
+    let statusCode = await pathExists(filePath) ? 200 : 404;
+
+    res.writeHead(statusCode, {
+      "Content-Type": req.headers.accept?.includes('text/html')
+        ? MIME_TYPES.html
+        : MIME_TYPES[path.extname(filePath).substring(1).toLowerCase()] || MIME_TYPES.html
+    });
 
-      return await fs.writeFile(`${config.projectRoot}/${config.output}${req.path}`, htmlContent);
+    if (statusCode === 404) {
+      res.end();
+    } else {
+      fs.createReadStream(filePath)
+        .pipe(res);
     }
 
-    return res.send({
-      code: 404,
-      message: 'Not found'
-    })
+    console.log(`# [HTTPServer] GET ${url} ${statusCode} - ${new Date() - requestStartedAt}ms`);
   });
 
-  return app;
+  return server;
 }
 
 function replaceAssetPaths(html, htmlPath, projectRoot) {

package/lib/utils/parse-cli-flags.js

@@ -1,5 +1,3 @@
-import fs from 'node:fs/promises';
-
 // { inputs: [], browser: true, debug: true, watch: true, failFast: true, htmlPaths: [], output }
 export default async function(projectRoot) {
   const providedFlags = process.argv.slice(2).reduce((result, arg) => {

package/lib/utils/run-user-module.js

@@ -10,7 +10,7 @@ export default async function runUserModule(modulePath, params, scriptPosition)
     }
   } catch (error) {
     console.log('#', kleur.red(`QUnitX ${scriptPosition} script failed:`));
-    console.log(error);
+    console.trace(error);
     console.error(error);
 
     return process.exit(1);

package/lol.ts

@@ -0,0 +1,18 @@
+Deno.serve((req) => {
+  let timer: number;
+  const body = new ReadableStream({
+    async start(controller) {
+      timer = setInterval(() => {
+        controller.enqueue("Hello, World!\n");
+      }, 1000);
+    },
+    cancel() {
+      clearInterval(timer);
+    },
+  });
+  return new Response(body.pipeThrough(new TextEncoderStream()), {
+    headers: {
+      "content-type": "text/plain; charset=utf-8",
+    },
+  });
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "qunitx",
   "type": "module",
-  "version": "0.5.3",
+  "version": "0.6.0",
   "description": "Experimental improvements, suggestions for qunit CLI",
   "author": "Izel Nakri",
   "license": "MIT",
@@ -52,18 +52,17 @@
     "test:sanity-second": "./cli.js test/helpers/passing-tests.js test/helpers/passing-tests.ts"
   },
   "dependencies": {
-    "@nanoexpress/middleware-static-serve": "^1.0.4",
     "cheerio": "^1.0.0-rc.10",
     "chokidar": "^3.5.3",
     "esbuild": "^0.17.19",
     "js-yaml": "^4.1.0",
     "jsdom": "^22.0.0",
     "kleur": "^4.1.5",
-    "nanoexpress": "^6.2.1",
     "picomatch": "^2.3.1",
     "puppeteer": "20.2.0",
     "recursive-lookup": "1.1.0",
-    "ts-node": "^10.7.0"
+    "ts-node": "^10.7.0",
+    "ws": "^8.13.0"
   },
   "devDependencies": {
     "auto-changelog": "^2.4.0",