qunitx-cli 0.1.2 → 0.5.1

package/lib/commands/run.js

@@ -1,103 +1,200 @@
 import fs from 'node:fs/promises';
 import { normalize, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { availableParallelism } from 'node:os';
+import Puppeteer from 'puppeteer';
 import kleur from 'kleur';
-import runTestsInBrowser from './run/tests-in-browser.js';
+import runTestsInBrowser, { buildTestBundle } from './run/tests-in-browser.js';
 import setupBrowser from '../setup/browser.js';
 import fileWatcher from '../setup/file-watcher.js';
 import findInternalAssetsFromHTML from '../utils/find-internal-assets-from-html.js';
 import runUserModule from '../utils/run-user-module.js';
 import setupKeyboardEvents from '../setup/keyboard-events.js';
 import writeOutputStaticFiles from '../setup/write-output-static-files.js';
+import timeCounter from '../utils/time-counter.js';
+import TAPDisplayFinalResult from '../tap/display-final-result.js';
+import findChrome from '../utils/find-chrome.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
-export default async function(config) {
-  let cachedContent = await buildCachedContent(config, config.htmlPaths);
-  let [connections, _] = await Promise.all([
-    setupBrowser(config, cachedContent),
-    writeOutputStaticFiles(config, cachedContent)
-  ]);
-  config.expressApp = connections.server;
+export default async function (config) {
+  const cachedContent = await buildCachedContent(config, config.htmlPaths);
 
   if (config.watch) {
+    // WATCH MODE: single browser, all test files bundled together.
+    // The HTTP server stays alive so the user can browse http://localhost:PORT
+    // and see all tests running in a single QUnit view.
+    const [connections] = await Promise.all([
+      setupBrowser(config, cachedContent),
+      writeOutputStaticFiles(config, cachedContent),
+    ]);
+    config.expressApp = connections.server;
     setupKeyboardEvents(config, cachedContent, connections);
-  }
 
-  if (config.before) {
-    await runUserModule(`${process.cwd()}/${config.before}`, config, 'before');
-  }
+    if (config.before) {
+      await runUserModule(`${process.cwd()}/${config.before}`, config, 'before');
+    }
 
-  await runTestsInBrowser(config, cachedContent, connections);
+    try {
+      await runTestsInBrowser(config, cachedContent, connections);
+    } catch (error) {
+      await Promise.all([
+        connections.server && connections.server.close(),
+        connections.browser && connections.browser.close(),
+      ]);
+      throw error;
+    }
 
-  if (config.watch) {
     logWatcherAndKeyboardShortcutInfo(config, connections.server);
 
     await fileWatcher(
       config.testFileLookupPaths,
       config,
       async (event, file) => {
-        if (event === 'addDir') {
-          return;
-        } else if (['unlink', 'unlinkDir'].includes(event)) {
+        if (event === 'addDir') return;
+        if (['unlink', 'unlinkDir'].includes(event)) {
           return await runTestsInBrowser(config, cachedContent, connections);
         }
-
         await runTestsInBrowser(config, cachedContent, connections, [file]);
       },
-      (path, event) => connections.server.publish('refresh', 'refresh')
+      (_path, _event) => connections.server.publish('refresh', 'refresh'),
     );
-  }
-}
+  } else {
+    // CONCURRENT MODE: split test files across N groups = availableParallelism().
+    // All group bundles are built while Chrome is starting up, so esbuild time
+    // is hidden behind the ~1.2s Chrome launch. Each group then gets its own
+    // HTTP server and Puppeteer page inside one shared browser instance.
+    const allFiles = Object.keys(config.fsTree);
+    const groupCount = Math.min(allFiles.length, availableParallelism());
+    const groups = splitIntoGroups(allFiles, groupCount);
+
+    // Shared COUNTER so TAP test numbers are globally sequential across all groups.
+    config.COUNTER = { testCount: 0, failCount: 0, skipCount: 0, passCount: 0 };
+    config.lastRanTestFiles = allFiles;
+
+    const groupConfigs = groups.map((groupFiles, i) => ({
+      ...config,
+      fsTree: Object.fromEntries(groupFiles.map((f) => [f, config.fsTree[f]])),
+      // Single group keeps the root output dir for backward-compatible file paths.
+      output: groupCount === 1 ? config.output : `${config.output}/group-${i}`,
+      _groupMode: true,
+    }));
+    const groupCachedContents = groups.map(() => ({ ...cachedContent }));
+
+    // Build all group bundles and write static files while Chrome is starting up.
+    const [browser] = await Promise.all([
+      findChrome().then((chromePath) =>
+        Puppeteer.launch({
+          args: [
+            '--no-sandbox',
+            '--disable-gpu',
+            '--remote-debugging-port=0',
+            '--window-size=1440,900',
+          ],
+          executablePath: chromePath,
+          headless: true,
+        }),
+      ),
+      Promise.all(
+        groupConfigs.map((groupConfig, i) =>
+          Promise.all([
+            buildTestBundle(groupConfig, groupCachedContents[i]),
+            writeOutputStaticFiles(groupConfig, groupCachedContents[i]),
+          ]),
+        ),
+      ),
+    ]);
+
+    console.log('TAP version 13');
+    const TIME_COUNTER = timeCounter();
+    let hasFatalError = false;
+
+    await Promise.allSettled(
+      groupConfigs.map(async (groupConfig, i) => {
+        const connections = await setupBrowser(groupConfig, groupCachedContents[i], browser);
+        groupConfig.expressApp = connections.server;
+
+        if (config.before) {
+          await runUserModule(`${process.cwd()}/${config.before}`, groupConfig, 'before');
+        }
 
-async function buildCachedContent(config, htmlPaths) {
-  let htmlBuffers = await Promise.all(config.htmlPaths.map((htmlPath) => fs.readFile(htmlPath)));   // TODO: remove this and read it from the fsTree, should be cached?
-  let cachedContent = htmlPaths.reduce((result, htmlPath, index) => {
-    let filePath = config.htmlPaths[index];
-    let html = htmlBuffers[index].toString();
+        try {
+          await runTestsInBrowser(groupConfig, groupCachedContents[i], connections);
+        } catch {
+          hasFatalError = true;
+        } finally {
+          await Promise.all([
+            connections.server && connections.server.close(),
+            connections.page && connections.page.close(),
+          ]);
+        }
+      }),
+    );
 
-    if (html.includes('{{content}}')) { // TODO: here I could do html analysis to see which static js certain html points to? Complex algorithm
-      result.dynamicContentHTMLs[filePath] = html;
+    await browser.close();
 
-      let relativePath = filePath.replace(config.projectRoot, '');
+    TAPDisplayFinalResult(config.COUNTER, TIME_COUNTER.stop());
 
-      result.htmlPathsToRunTests.push(relativePath);
-    } else {
-      console.log('#', kleur.yellow(`WARNING: Static html file with no {{content}} detected. Therefore ignoring ${filePath}`));
-      result.staticHTMLs[filePath] = html;
+    if (config.after) {
+      await runUserModule(`${process.cwd()}/${config.after}`, config.COUNTER, 'after');
     }
 
-    findInternalAssetsFromHTML(html).forEach((key) => {
-      result.assets.add(normalizeInternalAssetPathFromHTML(config.projectRoot, key, filePath))
-    });
+    process.exit(config.COUNTER.failCount > 0 || hasFatalError ? 1 : 0);
+  }
+}
 
-    return result;
-  }, {
-    allTestCode: null,
-    assets: new Set(),
-    htmlPathsToRunTests: [],
-    mainHTML: { filePath: null, html: null },
-    staticHTMLs: {},
-    dynamicContentHTMLs: {}
-  });
+async function buildCachedContent(config, htmlPaths) {
+  const htmlBuffers = await Promise.all(config.htmlPaths.map((htmlPath) => fs.readFile(htmlPath)));
+  const cachedContent = htmlPaths.reduce(
+    (result, htmlPath, index) => {
+      const filePath = config.htmlPaths[index];
+      const html = htmlBuffers[index].toString();
+
+      if (html.includes('{{content}}')) {
+        result.dynamicContentHTMLs[filePath] = html;
+        result.htmlPathsToRunTests.push(filePath.replace(config.projectRoot, ''));
+      } else {
+        console.log(
+          '#',
+          kleur.yellow(
+            `WARNING: Static html file with no {{content}} detected. Therefore ignoring ${filePath}`,
+          ),
+        );
+        result.staticHTMLs[filePath] = html;
+      }
+
+      findInternalAssetsFromHTML(html).forEach((key) => {
+        result.assets.add(normalizeInternalAssetPathFromHTML(config.projectRoot, key, filePath));
+      });
+
+      return result;
+    },
+    {
+      allTestCode: null,
+      assets: new Set(),
+      htmlPathsToRunTests: [],
+      mainHTML: { filePath: null, html: null },
+      staticHTMLs: {},
+      dynamicContentHTMLs: {},
+    },
+  );
 
   if (cachedContent.htmlPathsToRunTests.length === 0) {
     cachedContent.htmlPathsToRunTests = ['/'];
   }
 
-  return await addCachedContentMainHTML(config.projectRoot, cachedContent);
+  return addCachedContentMainHTML(config.projectRoot, cachedContent);
 }
 
 async function addCachedContentMainHTML(projectRoot, cachedContent) {
-  let mainHTMLPath = Object.keys(cachedContent.dynamicContentHTMLs)[0];
+  const mainHTMLPath = Object.keys(cachedContent.dynamicContentHTMLs)[0];
   if (mainHTMLPath) {
     cachedContent.mainHTML = {
       filePath: mainHTMLPath,
-      html: cachedContent.dynamicContentHTMLs[mainHTMLPath]
+      html: cachedContent.dynamicContentHTMLs[mainHTMLPath],
     };
   } else {
-    let html = (await fs.readFile(`${__dirname}/../boilerplates/setup/tests.hbs`)).toString();
-
+    const html = (await fs.readFile(`${__dirname}/../boilerplates/setup/tests.hbs`)).toString();
     cachedContent.mainHTML = { filePath: `${projectRoot}/test/tests.html`, html };
     cachedContent.assets.add(`${projectRoot}/node_modules/qunitx/vendor/qunit.css`);
   }
@@ -105,14 +202,27 @@ async function addCachedContentMainHTML(projectRoot, cachedContent) {
   return cachedContent;
 }
 
-function logWatcherAndKeyboardShortcutInfo(config, server) {
-  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
+function splitIntoGroups(files, groupCount) {
+  const groups = Array.from({ length: groupCount }, () => []);
+  files.forEach((file, i) => groups[i % groupCount].push(file));
+  return groups.filter((g) => g.length > 0);
 }
 
-function normalizeInternalAssetPathFromHTML(projectRoot, assetPath, htmlPath) { // NOTE: maybe normalize ..
-  let currentDirectory = htmlPath ? htmlPath.split('/').slice(0, -1).join('/') : projectRoot;
+function logWatcherAndKeyboardShortcutInfo(config, server) {
+  console.log(
+    '#',
+    kleur.blue(`Watching files... You can browse the tests on http://localhost:${config.port} ...`),
+  );
+  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`,
+    ),
+  );
+}
 
+function normalizeInternalAssetPathFromHTML(projectRoot, assetPath, htmlPath) {
+  const currentDirectory = htmlPath ? htmlPath.split('/').slice(0, -1).join('/') : projectRoot;
   return assetPath.startsWith('./')
     ? normalize(`${currentDirectory}/${assetPath.slice(2)}`)
     : normalize(`${currentDirectory}/${assetPath}`);

package/lib/servers/http.js

@@ -3,14 +3,14 @@ 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",
+  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 {
@@ -23,13 +23,15 @@ export default class HTTPServer {
         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
+        .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) => {
@@ -37,7 +39,7 @@ export default class HTTPServer {
         console.trace(error);
       });
 
-      bindServerToPort(server, config)
+      bindServerToPort(server, config);
     });
   }
 
@@ -46,7 +48,7 @@ export default class HTTPServer {
       GET: {},
       POST: {},
       DELETE: {},
-      PUT: {}
+      PUT: {},
     };
     this.middleware = [];
     this._server = http.createServer((req, res) => {
@@ -78,13 +80,17 @@ export default class HTTPServer {
 
   listen(port = 0, callback = () => {}) {
     return new Promise((resolve, reject) => {
-      this._server.listen(port, (error) => {
-        if (error) {
-          reject(error);
-        } else {
-          resolve(callback());
-        }
-      });
+      const onError = (err) => {
+        this._server.off('listening', onListening);
+        reject(err);
+      };
+      const onListening = () => {
+        this._server.off('error', onError);
+        resolve(callback());
+      };
+      this._server.once('error', onError);
+      this._server.once('listening', onListening);
+      this._server.listen(port);
     });
   }
 
@@ -121,16 +127,20 @@ export default class HTTPServer {
       path,
       handler,
       paramNames: this.extractParamNames(path),
-      isWildcard: path === '/*'
+      isWildcard: path === '/*',
     };
   }
 
   handleRequest(req, res) {
     const { method, url } = req;
-    const matchingRoute = this.findRouteHandler(method, url);
+    const urlObj = new URL(url, 'http://localhost');
+    const pathname = urlObj.pathname;
+    req.path = pathname;
+    req.query = Object.fromEntries(urlObj.searchParams);
+    const matchingRoute = this.findRouteHandler(method, pathname);
 
     if (matchingRoute) {
-      req.params = this.extractParams(matchingRoute, url);
+      req.params = this.extractParams(matchingRoute, pathname);
       this.runMiddleware(req, res, matchingRoute.handler);
     } else {
       res.statusCode = 404;
@@ -159,27 +169,32 @@ export default class HTTPServer {
       return null;
     }
 
-    return routes[url] || Object.values(routes).find(route => {
-      const { path, isWildcard } = route;
+    return (
+      routes[url] ||
+      Object.values(routes).find((route) => {
+        const { path, isWildcard } = route;
 
-      if (!isWildcard && !path.includes(':')) {
-        return false;
-      }
+        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);
+        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 true;
-      }
 
-      return false;
-    }) || routes['/*'] || null;
+        return false;
+      }) ||
+      routes['/*'] ||
+      null
+    );
   }
 
   matchPathSegments(path, url) {
@@ -217,7 +232,7 @@ export default class HTTPServer {
     const paramRegex = /:(\w+)/g;
     const paramMatches = path.match(paramRegex);
 
-    return paramMatches ? paramMatches.map(match => match.slice(1)) : [];
+    return paramMatches ? paramMatches.map((match) => match.slice(1)) : [];
   }
 
   extractParams(route, url) {

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

@@ -1,14 +1,5 @@
-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(server, config) {
-  try {
-    let port = await resolvePortNumberFor(config.port);
-
-    await server.listen(port);
-
-    return server;
-  } catch(e) {
-    return await bindServerToPort(server, Object.assign(config, { port: config.port + 1 }));
-  }
+  await server.listen(0);
+  config.port = server._server.address().port;
+  return server;
 }

package/lib/setup/browser.js

@@ -1,23 +1,35 @@
 import Puppeteer from 'puppeteer';
 import setupWebServer from './web-server.js';
 import bindServerToPort from './bind-server-to-port.js';
+import findChrome from '../utils/find-chrome.js';
 
-export default async function setupBrowser(config = {
-  port: 1234, debug: false, watch: false, timeout: 10000
-}, cachedContent) {
+export default async function setupBrowser(
+  config = {
+    port: 1234,
+    debug: false,
+    watch: false,
+    timeout: 10000,
+  },
+  cachedContent,
+  existingBrowser = null,
+) {
   let [server, browser] = await Promise.all([
     setupWebServer(config, cachedContent),
-    Puppeteer.launch({
-      debugger: config.debug || false,
-      args: ['--no-sandbox', '--disable-gpu', '--remote-debugging-port=0', '--window-size=1440,900'],
-      executablePath: process.env.CHROME_BIN || null,
-      headless: 'new',
-    }),
-  ]);
-  let [page, _] = await Promise.all([
-    browser.newPage(),
-    bindServerToPort(server, config)
+    existingBrowser
+      ? Promise.resolve(existingBrowser)
+      : Puppeteer.launch({
+          debugger: config.debug || false,
+          args: [
+            '--no-sandbox',
+            '--disable-gpu',
+            '--remote-debugging-port=0',
+            '--window-size=1440,900',
+          ],
+          executablePath: await findChrome(),
+          headless: true,
+        }),
   ]);
+  let [page, _] = await Promise.all([browser.newPage(), bindServerToPort(server, config)]);
 
   page.on('console', async (msg) => {
     if (config.debug) {
@@ -28,7 +40,7 @@ export default async function setupBrowser(config = {
   });
   page.on('error', (msg) => {
     try {
-      throw error;
+      throw msg;
     } catch (e) {
       console.error(e, e.stack);
       console.log(e, e.stack);
@@ -49,7 +61,3 @@ export default async function setupBrowser(config = {
 function turnToObjects(jsHandle) {
   return jsHandle.jsonValue();
 }
-
-// function turnMStoSecond(timeInMS) {
-//   return (timeInMS / 1000).toFixed(2);
-// }

package/lib/setup/config.js

@@ -7,23 +7,21 @@ import parseCliFlags from '../utils/parse-cli-flags.js';
 
 export default async function setupConfig() {
   let projectRoot = await findProjectRoot();
-  let [projectPackageJSON, cliConfigFlags] = await Promise.all([
-    readConfigFromPackageJSON(projectRoot),
-    parseCliFlags(projectRoot)
-  ]);
+  let cliConfigFlags = parseCliFlags(projectRoot);
+  let projectPackageJSON = await readConfigFromPackageJSON(projectRoot);
   let inputs = cliConfigFlags.inputs.concat(readInputsFromPackageJSON(projectPackageJSON));
   let config = {
-    projectRoot,
-    htmlPaths: [],
-    lastFailedTestFiles: null,
-    lastRanTestFiles: null,
     ...defaultProjectConfigValues,
+    htmlPaths: [],
     ...projectPackageJSON.qunitx,
     ...cliConfigFlags,
-    inputs
+    projectRoot,
+    inputs,
+    testFileLookupPaths: setupTestFilePaths(projectRoot, inputs),
+    lastFailedTestFiles: null,
+    lastRanTestFiles: null,
   };
   config.htmlPaths = normalizeHTMLPaths(config.projectRoot, config.htmlPaths);
-  config.testFileLookupPaths = setupTestFilePaths(config.projectRoot, config.inputs);
   config.fsTree = await setupFSTree(config.testFileLookupPaths, config);
 
   return config;

package/lib/setup/file-watcher.js

@@ -1,7 +1,12 @@
 import chokidar from 'chokidar';
 import kleur from 'kleur';
 
-export default async function setupFileWatchers(testFileLookupPaths, config, onEventFunc, onFinishFunc) {
+export default async function setupFileWatchers(
+  testFileLookupPaths,
+  config,
+  onEventFunc,
+  onFinishFunc,
+) {
   let extensions = ['js', 'ts'];
   let fileWatchers = testFileLookupPaths.reduce((watcher, watchPath) => {
     return Object.assign(watcher, {
@@ -9,14 +14,26 @@ export default async function setupFileWatchers(testFileLookupPaths, config, onE
         if (extensions.some((extension) => path.endsWith(extension))) {
           mutateFSTree(config.fsTree, event, path);
 
-          console.log('#', kleur.magenta().bold('=================================================================='));
+          console.log(
+            '#',
+            kleur
+              .magenta()
+              .bold('=================================================================='),
+          );
           console.log('#', getEventColor(event), path.split(config.projectRoot)[1]);
-          console.log('#', kleur.magenta().bold('=================================================================='));
+          console.log(
+            '#',
+            kleur
+              .magenta()
+              .bold('=================================================================='),
+          );
 
           if (!global.chokidarBuild) {
             global.chokidarBuild = true;
 
-            let result = extensions.some((extension) => path.endsWith(extension)) ? onEventFunc(event, path) : null;
+            let result = extensions.some((extension) => path.endsWith(extension))
+              ? onEventFunc(event, path)
+              : null;
 
             if (!(result instanceof Promise)) {
               global.chokidarBuild = false;
@@ -35,7 +52,7 @@ export default async function setupFileWatchers(testFileLookupPaths, config, onE
               .finally(() => (global.chokidarBuild = false));
           }
         }
-      })
+      }),
     });
   }, {});
 
@@ -45,7 +62,7 @@ export default async function setupFileWatchers(testFileLookupPaths, config, onE
       Object.keys(fileWatchers).forEach((watcherKey) => fileWatchers[watcherKey].close());
 
       return fileWatchers;
-    }
+    },
   };
 }