qunitx-cli 0.1.1 → 0.5.0

package/lib/setup/web-server.js

@@ -7,9 +7,15 @@ 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) {
+export default async function setupWebServer(
+  config = {
+    port: 1234,
+    debug: false,
+    watch: false,
+    timeout: 10000,
+  },
+  cachedContent,
+) {
   let STATIC_FILES_PATH = path.join(config.projectRoot, config.output);
   let server = new HTTPServer();
 
@@ -17,14 +23,21 @@ export default async function setupWebServer(config = {
     socket.on('message', function message(data) {
       const { event, details, abort } = JSON.parse(data);
 
-      if (event === "connection") {
-        console.log('TAP version 13');
-      } else if ((event === 'testEnd') && !abort) {
+      if (event === 'connection') {
+        if (!config._groupMode) console.log('TAP version 13');
+      } else if (event === 'testEnd' && !abort) {
         if (details.status === 'failed') {
           config.lastFailedTestFiles = config.lastRanTestFiles;
         }
 
-        TAPDisplayTestResult(config.COUNTER, details)
+        TAPDisplayTestResult(config.COUNTER, details);
+      } else if (event === 'done') {
+        // Signal test completion. TCP ordering guarantees all testEnd messages
+        // preceding this on the same connection are already processed by Node.js.
+        if (typeof config._testRunDone === 'function') {
+          config._testRunDone();
+          config._testRunDone = null;
+        }
       }
     });
   });
@@ -32,29 +45,43 @@ export default async function setupWebServer(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),
+      replaceAssetPaths(
+        cachedContent.mainHTML.html,
+        cachedContent.mainHTML.filePath,
+        config.projectRoot,
+      ),
       TEST_RUNTIME_TO_INJECT,
-      cachedContent.allTestCode
+      cachedContent.allTestCode,
     );
 
     res.write(htmlContent);
     res.end();
 
-    return await fsPromise.writeFile(`${config.projectRoot}/${config.output}/index.html`, htmlContent);
+    return await fsPromise.writeFile(
+      `${config.projectRoot}/${config.output}/index.html`,
+      htmlContent,
+    );
   });
 
   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),
+      replaceAssetPaths(
+        cachedContent.mainHTML.html,
+        cachedContent.mainHTML.filePath,
+        config.projectRoot,
+      ),
       TEST_RUNTIME_TO_INJECT,
-      cachedContent.filteredTestCode
+      cachedContent.filteredTestCode,
     );
 
     res.write(htmlContent);
     res.end();
 
-    return await fsPromise.writeFile(`${config.projectRoot}/${config.output}/qunitx.html`, htmlContent);
+    return await fsPromise.writeFile(
+      `${config.projectRoot}/${config.output}/qunitx.html`,
+      htmlContent,
+    );
   });
 
   server.get('/*', async (req, res) => {
@@ -64,31 +91,35 @@ export default async function setupWebServer(config = {
       let htmlContent = escapeAndInjectTestsToHTML(
         possibleDynamicHTML,
         TEST_RUNTIME_TO_INJECT,
-        cachedContent.allTestCode
+        cachedContent.allTestCode,
       );
 
       res.write(htmlContent);
       res.end();
 
-      return await fsPromise.writeFile(`${config.projectRoot}/${config.output}${req.path}`, htmlContent);
+      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;
+    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')
+      'Content-Type': req.headers.accept?.includes('text/html')
         ? MIME_TYPES.html
-        : MIME_TYPES[path.extname(filePath).substring(1).toLowerCase()] || MIME_TYPES.html
+        : MIME_TYPES[path.extname(filePath).substring(1).toLowerCase()] || MIME_TYPES.html,
     });
 
     if (statusCode === 404) {
       res.end();
     } else {
-      fs.createReadStream(filePath)
-        .pipe(res);
+      fs.createReadStream(filePath).pipe(res);
     }
 
     console.log(`# [HTTPServer] GET ${url} ${statusCode} - ${new Date() - requestStartedAt}ms`);
@@ -99,7 +130,7 @@ export default async function setupWebServer(config = {
 
 function replaceAssetPaths(html, htmlPath, projectRoot) {
   let assetPaths = findInternalAssetsFromHTML(html);
-  let htmlDirectory = htmlPath.split('/').slice(0, -1).join('/')
+  let htmlDirectory = htmlPath.split('/').slice(0, -1).join('/');
 
   return assetPaths.reduce((result, assetPath) => {
     let normalizedFullAbsolutePath = path.normalize(`${htmlDirectory}/${assetPath}`);
@@ -116,29 +147,46 @@ function testRuntimeToInject(port, config) {
     }, 1000);
 
     (function() {
-      function setupWebsocket() {
-        window.socket = new WebSocket('ws://localhost:${port}');
+      let wsRetryCount = 0;
+      const WS_MAX_RETRIES = 50; // 500ms total before giving up
+
+      function setupWebSocket() {
+        try {
+          window.socket = new WebSocket('ws://localhost:${port}');
+        } catch (error) {
+          console.log(error);
+          retryOrFail();
+          return;
+        }
+
+        window.socket.addEventListener('open', function() {
+          setupQUnit();
+        });
+        window.socket.addEventListener('error', function() {
+          retryOrFail();
+        });
         window.socket.addEventListener('message', function(messageEvent) {
           if (!window.IS_PUPPETEER && messageEvent.data === 'refresh') {
             window.location.reload(true);
           } else if (window.IS_PUPPETEER && messageEvent.data === 'abort') {
             window.abortQUnit = true;
             window.QUnit.config.queue.length = 0;
-            window.socket.send(JSON.stringify({ event: 'abort' }))
+            window.socket.send(JSON.stringify({ event: 'abort' }));
           }
         });
       }
 
-      function trySetupWebsocket() {
-        try {
-          setupWebsocket();
-        } catch(error) {
-          console.log(error);
-          window.setTimeout(() => trySetupWebsocket(), 10);
+      function retryOrFail() {
+        wsRetryCount++;
+        if (wsRetryCount > WS_MAX_RETRIES) {
+          console.log('WebSocket connection failed after ' + WS_MAX_RETRIES + ' retries');
+          window.testTimeout = ${config.timeout};
+          return;
         }
+        window.setTimeout(setupWebSocket, 10);
       }
 
-      trySetupWebsocket();
+      setupWebSocket();
     })();
 
     {{allTestCode}}
@@ -163,13 +211,8 @@ function testRuntimeToInject(port, config) {
     function setupQUnit() {
       window.QUNIT_RESULT = { totalTests: 0, finishedTests: 0, currentTest: '' };
 
-      if (!window.socket ) {
-        return window.setTimeout(() => setupQUnit(), 10);
-      } else if (!window.QUnit || !window.QUnit.moduleStart || window.QUnit.config.queue === 0) {
-        if (socket.readyState == 0) {
-          return window.setTimeout(() => setupQUnit(), 10);
-        }
-
+      if (!window.QUnit) {
+        console.log('QUnit not found after WebSocket connected');
         window.testTimeout = ${config.timeout};
         return;
       }
@@ -211,31 +254,14 @@ function testRuntimeToInject(port, config) {
         }, 75);
       });
 
-      if ([1, 3].includes(window.socket.readyState)) {
-        return window.setTimeout(() => window.QUnit.start(), 25);
-      } else {
-        let connectionTrialCount = 0;
-        let connectionInterval = window.setInterval(() => {
-          if ([1, 3].includes(window.socket.readyState) || connectionTrialCount > 25) {
-            window.clearInterval(connectionInterval);
-
-            return window.setTimeout(() => window.QUnit.start(), 25);
-          }
-
-          connectionTrialCount = connectionTrialCount + 1;
-        }, 10);
-      }
+      window.setTimeout(() => window.QUnit.start(), 25);
     }
-
-    setupQUnit();
   </script>`;
 }
 
 function escapeAndInjectTestsToHTML(html, testRuntimeCode, testContentCode) {
-  return html
-    .replace('{{content}}',
-      testRuntimeCode
-        .replace('{{allTestCode}}', testContentCode)
-        .replace('</script>', '<\/script>') // NOTE: remove this when simple-html-tokenizer PR gets merged
-    );
+  return html.replace(
+    '{{content}}',
+    testRuntimeCode.replace('{{allTestCode}}', testContentCode).replace('</script>', '<\/script>'), // NOTE: remove this when simple-html-tokenizer PR gets merged
+  );
 }

package/lib/setup/write-output-static-files.js

@@ -5,7 +5,10 @@ export default async function writeOutputStaticFiles({ projectRoot, output }, ca
     let htmlRelativePath = staticHTMLKey.replace(`${projectRoot}/`, '');
 
     await ensureFolderExists(`${projectRoot}/${output}/${htmlRelativePath}`);
-    await fs.writeFile(`${projectRoot}/${output}/${htmlRelativePath}`, cachedContent.staticHTMLs[staticHTMLKey]);
+    await fs.writeFile(
+      `${projectRoot}/${output}/${htmlRelativePath}`,
+      cachedContent.staticHTMLs[staticHTMLKey],
+    );
   });
   let assetPromises = Array.from(cachedContent.assets).map(async (assetAbsolutePath) => {
     let assetRelativePath = assetAbsolutePath.replace(`${projectRoot}/`, '');

package/lib/tap/display-final-result.js

@@ -1,4 +1,4 @@
-export default function({ testCount, passCount, skipCount, failCount }, timeTaken) {
+export default function ({ testCount, passCount, skipCount, failCount }, timeTaken) {
   console.log('');
   console.log(`1..${testCount}`);
   console.log(`# tests ${testCount}`);
@@ -12,4 +12,4 @@ export default function({ testCount, passCount, skipCount, failCount }, timeTake
   console.log(`# duration ${timeTaken}`);
   console.log('');
 }
-  // console.log(details.timeTaken); // runtime
+// console.log(details.timeTaken); // runtime

package/lib/tap/display-test-result.js

@@ -1,9 +1,10 @@
-import yaml from 'js-yaml'
+import yaml from 'js-yaml';
 import indentString from '../utils/indent-string.js';
 
 // tape TAP output: ['operator', 'stack', 'at', 'expected', 'actual']
 // ava TAP output: ['message', 'name', 'at', 'assertion', 'values'] // Assertion #5, message
-export default function(COUNTER, details) { // NOTE: https://github.com/qunitjs/qunit/blob/master/src/html-reporter/diff.js
+export default function (COUNTER, details) {
+  // NOTE: https://github.com/qunitjs/qunit/blob/master/src/html-reporter/diff.js
   COUNTER.testCount++;
 
   if (details.status === 'skipped') {
@@ -13,21 +14,34 @@ export default function(COUNTER, details) { // NOTE: https://github.com/qunitjs/
     console.log(`not ok ${COUNTER.testCount}`, details.fullName.join(' | '), '# skip');
   } else if (details.status === 'failed') {
     COUNTER.failCount++;
-    console.log(`not ok ${COUNTER.testCount}`, details.fullName.join(' | '), `# (${details.runtime.toFixed(0)} ms)`);
+    console.log(
+      `not ok ${COUNTER.testCount}`,
+      details.fullName.join(' | '),
+      `# (${details.runtime.toFixed(0)} ms)`,
+    );
     details.assertions.reduce((errorCount, assertion, index) => {
       if (!assertion.passed && assertion.todo === false) {
         COUNTER.errorCount++;
         let stack = assertion.stack?.match(/\(.+\)/g);
 
         console.log('  ---');
-        console.log(indentString(yaml.dump({
-          name: `Assertion #${index + 1}`, // TODO: check what happens on runtime errors
-          actual: assertion.actual ? JSON.parse(JSON.stringify(assertion.actual, getCircularReplacer())) : assertion.actual,
-          expected: assertion.expected ? JSON.parse(JSON.stringify(assertion.expected, getCircularReplacer())) : assertion.expected,
-          message: assertion.message || null,
-          stack: assertion.stack || null,
-          at: stack ? stack[0].replace('(file://', '').replace(')', '') : null
-        }), 4));
+        console.log(
+          indentString(
+            yaml.dump({
+              name: `Assertion #${index + 1}`, // TODO: check what happens on runtime errors
+              actual: assertion.actual
+                ? JSON.parse(JSON.stringify(assertion.actual, getCircularReplacer()))
+                : assertion.actual,
+              expected: assertion.expected
+                ? JSON.parse(JSON.stringify(assertion.expected, getCircularReplacer()))
+                : assertion.expected,
+              message: assertion.message || null,
+              stack: assertion.stack || null,
+              at: stack ? stack[0].replace('(file://', '').replace(')', '') : null,
+            }),
+            4,
+          ),
+        );
         console.log('  ...');
       }
 
@@ -35,21 +49,25 @@ export default function(COUNTER, details) { // NOTE: https://github.com/qunitjs/
     }, 0);
   } else if (details.status === 'passed') {
     COUNTER.passCount++;
-    console.log(`ok ${COUNTER.testCount}`, details.fullName.join(' | '), `# (${details.runtime.toFixed(0)} ms)`);
+    console.log(
+      `ok ${COUNTER.testCount}`,
+      details.fullName.join(' | '),
+      `# (${details.runtime.toFixed(0)} ms)`,
+    );
   }
 }
 
 function getCircularReplacer() {
   const ancestors = [];
   return function (key, value) {
-    if (typeof value !== "object" || value === null) {
+    if (typeof value !== 'object' || value === null) {
       return value;
     }
     while (ancestors.length > 0 && ancestors.at(-1) !== this) {
       ancestors.pop();
     }
     if (ancestors.includes(value)) {
-      return "[Circular]";
+      return '[Circular]';
     }
     ancestors.push(value);
     return value;

package/lib/utils/find-chrome.js

@@ -0,0 +1,16 @@
+import { exec } from 'node:child_process';
+
+const CANDIDATES = ['google-chrome-stable', 'google-chrome', 'chromium', 'chromium-browser'];
+
+export default async function findChrome() {
+  if (process.env.CHROME_BIN) return process.env.CHROME_BIN;
+
+  return Promise.any(
+    CANDIDATES.map(
+      (name) =>
+        new Promise((resolve, reject) =>
+          exec(`which ${name}`, (err, stdout) => (err ? reject() : resolve(stdout.trim()))),
+        ),
+    ),
+  ).catch(() => null);
+}

package/lib/utils/find-internal-assets-from-html.js

@@ -1,16 +1,18 @@
-import cheerio from 'cheerio';
+import { load } from 'cheerio';
 
 const ABSOLUTE_URL_REGEX = new RegExp('^(?:[a-z]+:)?//', 'i');
 
 export default function findInternalAssetsFromHTML(htmlContent) {
-  const $ = cheerio.load(htmlContent);
-  const internalJSFiles = $('script[src]').toArray()
+  const $ = load(htmlContent);
+  const internalJSFiles = $('script[src]')
+    .toArray()
     .map((scriptNode) => $(scriptNode).attr('src'))
     .filter((uri) => !ABSOLUTE_URL_REGEX.test(uri));
-  const internalCSSFiles = $('link[href]').toArray()
+  const internalCSSFiles = $('link[href]')
+    .toArray()
     .map((scriptNode) => $(scriptNode).attr('href'))
     .filter((uri) => !ABSOLUTE_URL_REGEX.test(uri));
 
   return internalCSSFiles.concat(internalJSFiles);
-    // TODO: maybe needs normalization ? .map((fileReferencePath) => fileReferencePath.replace('/assets', `${projectRoot}/tmp/assets`));
+  // TODO: maybe needs normalization ? .map((fileReferencePath) => fileReferencePath.replace('/assets', `${projectRoot}/tmp/assets`));
 }

package/lib/utils/find-project-root.js

@@ -1,7 +1,7 @@
 import process from 'node:process';
 import searchInParentDirectories from './search-in-parent-directories.js';
 
-export default async function() {
+export default async function () {
   try {
     let absolutePath = await searchInParentDirectories('.', 'package.json');
     if (!absolutePath.includes('package.json')) {
@@ -14,4 +14,3 @@ export default async function() {
     process.exit(1);
   }
 }
-

package/lib/utils/indent-string.js

@@ -1,11 +1,11 @@
 export default function indentString(string, count = 1, options = {}) {
-	const { indent = ' ', includeEmptyLines = false } = options;
+  const { indent = ' ', includeEmptyLines = false } = options;
 
-	if (count <= 0) {
-		return string;
-	}
+  if (count <= 0) {
+    return string;
+  }
 
-	const regex = includeEmptyLines ? /^/gm : /^(?!\s*$)/gm;
+  const regex = includeEmptyLines ? /^/gm : /^(?!\s*$)/gm;
 
-	return string.replace(regex, indent.repeat(count));
+  return string.replace(regex, indent.repeat(count));
 }

package/lib/utils/listen-to-keyboard-key.js

@@ -5,12 +5,16 @@ let targetInputs = {};
 let inputs = [];
 let listenerAdded = false;
 
-export default function listenToKeyboardKey(inputString, closure, options = { caseSensitive: false }) {
+export default function listenToKeyboardKey(
+  inputString,
+  closure,
+  options = { caseSensitive: false },
+) {
   stdin.setRawMode(true);
   stdin.resume();
   stdin.setEncoding('utf8');
   if (!listenerAdded) {
-    stdin.on('data', function(key){
+    stdin.on('data', function (key) {
       if (key === '\u0003') {
         process.exit(); // so node process doesnt trap Control-C
       }

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

@@ -1,44 +1,47 @@
 // { inputs: [], debug: true, watch: true, failFast: true, htmlPaths: [], output }
-export default async function(projectRoot) {
-  const providedFlags = process.argv.slice(2).reduce((result, arg) => {
-    if (arg.startsWith('--debug')) {
-      return Object.assign(result, { debug: parseBoolean(arg.split('=')[1]) });
-    } else if (arg.startsWith('--watch')) {
-      return Object.assign(result, { watch: parseBoolean(arg.split('=')[1]) });
-    } else if (arg.startsWith('--failfast') || arg.startsWith('--failFast')) {
-      return Object.assign(result, { failFast: parseBoolean(arg.split('=')[1]) });
-    } else if (arg.startsWith('--timeout')) {
-      return Object.assign(result, { timeout: arg.split('=')[1] || 10000 });
-    } else if (arg.startsWith('--output')) {
-      return Object.assign(result, { output: arg.split('=')[1] });
-    } else if (arg.endsWith('.html')) {
-      if (result.htmlPaths) {
-        result.htmlPaths.push(arg);
-      } else {
-        result.htmlPaths = [arg];
+export default function (projectRoot) {
+  const providedFlags = process.argv.slice(2).reduce(
+    (result, arg) => {
+      if (arg.startsWith('--debug')) {
+        return Object.assign(result, { debug: parseBoolean(arg.split('=')[1]) });
+      } else if (arg.startsWith('--watch')) {
+        return Object.assign(result, { watch: parseBoolean(arg.split('=')[1]) });
+      } else if (arg.startsWith('--failfast') || arg.startsWith('--failFast')) {
+        return Object.assign(result, { failFast: parseBoolean(arg.split('=')[1]) });
+      } else if (arg.startsWith('--timeout')) {
+        return Object.assign(result, { timeout: arg.split('=')[1] || 10000 });
+      } else if (arg.startsWith('--output')) {
+        return Object.assign(result, { output: arg.split('=')[1] });
+      } else if (arg.endsWith('.html')) {
+        if (result.htmlPaths) {
+          result.htmlPaths.push(arg);
+        } else {
+          result.htmlPaths = [arg];
+        }
+
+        return result;
+      } else if (arg.startsWith('--port')) {
+        return Object.assign(result, { port: Number(arg.split('=')[1]) });
+      } else if (arg.startsWith('--before')) {
+        return Object.assign(result, { before: parseModule(arg.split('=')[1]) });
+      } else if (arg.startsWith('--after')) {
+        return Object.assign(result, { after: parseModule(arg.split('=')[1]) });
       }
 
-      return result;
-    } else if (arg.startsWith('--port')) {
-      return Object.assign(result, { port: Number(arg.split('=')[1]) });
-    } else if (arg.startsWith('--before')) {
-      return Object.assign(result, { before: parseModule(arg.split('=')[1]) });
-    } else if (arg.startsWith('--after')) {
-      return Object.assign(result, { after: parseModule(arg.split('=')[1]) });
-    }
-
-    // maybe set watch depth via micromatch(so incl metadata)
-    result.inputs.add(arg.startsWith(projectRoot) ? arg : `${process.cwd()}/${arg}`);
+      // maybe set watch depth via micromatch(so incl metadata)
+      result.inputs.add(arg.startsWith(projectRoot) ? arg : `${process.cwd()}/${arg}`);
 
-    return result;
-  }, { inputs: new Set([]) });
+      return result;
+    },
+    { inputs: new Set([]) },
+  );
 
   providedFlags.inputs = Array.from(providedFlags.inputs);
 
   return providedFlags;
 }
 
-function parseBoolean(result, defaultValue=true) {
+function parseBoolean(result, defaultValue = true) {
   if (result === 'true') {
     return true;
   } else if (result === 'false') {

package/lib/utils/resolve-port-number-for.js

@@ -3,7 +3,7 @@ export default async function resolvePortNumberFor(portNumber) {
     return portNumber;
   }
 
-  return (await resolvePortNumberFor(portNumber + 1));
+  return await resolvePortNumberFor(portNumber + 1);
 }
 
 function portIsAvailable(portNumber) {
@@ -11,13 +11,13 @@ function portIsAvailable(portNumber) {
     const net = await import('net');
     const server = net.createServer();
 
-    server.once('error', function(err) {
+    server.once('error', function (err) {
       if (err.code === 'EADDRINUSE') {
         resolve(false);
       }
     });
 
-    server.once('listening', function() {
+    server.once('listening', function () {
       server.close();
       resolve(true);
     });

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

@@ -4,9 +4,11 @@ export default async function runUserModule(modulePath, params, scriptPosition)
   try {
     let func = await import(modulePath);
     if (func) {
-      func.default ?
-        await func.default(params) :
-        typeof func === 'function' ? await func(params) : null;
+      func.default
+        ? await func.default(params)
+        : typeof func === 'function'
+          ? await func(params)
+          : null;
     }
   } catch (error) {
     console.log('#', kleur.red(`QUnitX ${scriptPosition} script failed:`));

package/lib/utils/search-in-parent-directories.js

@@ -9,7 +9,10 @@ async function searchInParentDirectories(directory, targetEntry) {
     return;
   }
 
-  return await searchInParentDirectories(directory.slice(0, directory.lastIndexOf('/')), targetEntry);
+  return await searchInParentDirectories(
+    directory.slice(0, directory.lastIndexOf('/')),
+    targetEntry,
+  );
 }
 
 export default searchInParentDirectories;

package/lib/utils/time-counter.js

@@ -1,8 +1,8 @@
-export default function() {
+export default function () {
   const startTime = new Date();
 
   return {
     startTime: startTime,
-    stop: () => +(new Date()) - (+startTime)
+    stop: () => +new Date() - +startTime,
   };
 }