qunitx-cli 0.9.4 → 0.9.8

package/lib/setup/keyboard-events.ts

@@ -1,38 +0,0 @@
-import { blue } from '../utils/color.ts';
-import listenToKeyboardKey from '../utils/listen-to-keyboard-key.ts';
-import runTestsInBrowser from '../commands/run/tests-in-browser.ts';
-import type { Config, CachedContent, Connections } from '../types.ts';
-
-/**
- * Registers watch-mode keyboard shortcuts: `qq` to abort, `qa` to run all, `qf` for last failed, `ql` for last run.
- * @returns {void}
- */
-export default function setupKeyboardEvents(
-  config: Config,
-  cachedContent: CachedContent,
-  connections: Connections,
-): void {
-  listenToKeyboardKey('qq', () => abortBrowserQUnit(config, connections));
-  listenToKeyboardKey('qa', () => {
-    abortBrowserQUnit(config, connections);
-    runTestsInBrowser(config, cachedContent, connections);
-  });
-  listenToKeyboardKey('qf', () => {
-    abortBrowserQUnit(config, connections);
-
-    if (!config.lastFailedTestFiles) {
-      console.log('#', blue(`QUnitX: No tests failed so far, so repeating the last test run`));
-      return runTestsInBrowser(config, cachedContent, connections, config.lastRanTestFiles);
-    }
-
-    runTestsInBrowser(config, cachedContent, connections, config.lastFailedTestFiles);
-  });
-  listenToKeyboardKey('ql', () => {
-    abortBrowserQUnit(config, connections);
-    runTestsInBrowser(config, cachedContent, connections, config.lastRanTestFiles);
-  });
-}
-
-function abortBrowserQUnit(_config: Config, connections: Connections): void {
-  connections.server.publish('abort', 'abort');
-}

package/lib/setup/test-file-paths.ts

@@ -1,74 +0,0 @@
-import { matchesGlob } from 'node:path';
-
-function isGlob(str: string): boolean {
-  return /[*?{[]/.test(str);
-}
-
-interface PathMeta {
-  input: string;
-  isFile: boolean;
-  isGlob: boolean;
-}
-
-/**
- * Deduplicates a list of file, folder, and glob inputs so that more-specific paths covered by broader ones are removed.
- * @returns {string[]}
- */
-export default function setupTestFilePaths(_projectRoot: string, inputs: string[]): string[] {
-  // NOTE: very complex algorithm, order is very important
-  const [folders, filesWithGlob, filesWithoutGlob] = inputs.reduce(
-    (result, input) => {
-      const glob = isGlob(input);
-
-      if (!pathIsFile(input)) {
-        result[0].push({ input, isFile: false, isGlob: glob });
-      } else {
-        result[glob ? 1 : 2].push({ input, isFile: true, isGlob: glob });
-      }
-
-      return result;
-    },
-    [[], [], []],
-  );
-
-  const result = folders.reduce((folderResult, folder) => {
-    if (!pathIsIncludedInPaths(folders, folder)) {
-      folderResult.push(folder);
-    }
-
-    return folderResult;
-  }, []);
-
-  filesWithGlob.forEach((file) => {
-    if (!pathIsIncludedInPaths(result, file) && !pathIsIncludedInPaths(filesWithGlob, file)) {
-      result.push(file);
-    }
-  });
-  filesWithoutGlob.forEach((file) => {
-    if (!pathIsIncludedInPaths(result, file)) {
-      result.push(file);
-    }
-  });
-
-  return result.map((metaItem) => metaItem.input);
-}
-
-function pathIsFile(path: string): boolean {
-  const inputs = path.split('/');
-
-  return inputs[inputs.length - 1].includes('.');
-}
-
-function pathIsIncludedInPaths(paths: PathMeta[], targetPath: PathMeta): boolean {
-  return paths.some((path) => {
-    if (path === targetPath) {
-      return false;
-    }
-
-    return matchesGlob(targetPath.input, buildGlobFormat(path));
-  });
-}
-
-function buildGlobFormat(path: PathMeta): string {
-  return path.isFile ? path.input : `${path.input}/**`;
-}

package/lib/setup/web-server.ts

@@ -1,274 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import findInternalAssetsFromHTML from '../utils/find-internal-assets-from-html.ts';
-import TAPDisplayTestResult from '../tap/display-test-result.ts';
-import pathExists from '../utils/path-exists.ts';
-import HTTPServer, { MIME_TYPES } from '../servers/http.ts';
-import type { Config, CachedContent } from '../types.ts';
-
-const fsPromise = fs.promises;
-
-/**
- * Creates and returns an HTTPServer with routes for the test HTML, filtered test page, and static assets, plus a WebSocket handler that streams TAP events.
- * @returns {object}
- */
-export default function setupWebServer(config: Config, cachedContent: CachedContent): HTTPServer {
-  const STATIC_FILES_PATH = path.join(config.projectRoot, config.output);
-  const server = new HTTPServer();
-
-  server.wss.on('connection', function connection(socket) {
-    socket.on('message', function message(data) {
-      const { event, details, abort } = JSON.parse(data);
-
-      if (event === 'connection') {
-        if (!config._groupMode) console.log('TAP version 13');
-        config._resetTestTimeout?.();
-      } else if (event === 'testEnd' && !abort) {
-        if (details.status === 'failed') {
-          config.lastFailedTestFiles = config.lastRanTestFiles;
-        }
-
-        config._resetTestTimeout?.();
-        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;
-        }
-      }
-    });
-  });
-
-  server.get('/', async (_req, res) => {
-    const TEST_RUNTIME_TO_INJECT = testRuntimeToInject(config.port, config);
-    const htmlContent = escapeAndInjectTestsToHTML(
-      replaceAssetPaths(
-        cachedContent.mainHTML.html,
-        cachedContent.mainHTML.filePath,
-        config.projectRoot,
-      ),
-      TEST_RUNTIME_TO_INJECT,
-      cachedContent.allTestCode,
-    );
-
-    res.write(htmlContent);
-    res.end();
-
-    return await fsPromise.writeFile(
-      `${config.projectRoot}/${config.output}/index.html`,
-      htmlContent,
-    );
-  });
-
-  server.get('/qunitx.html', async (_req, res) => {
-    const TEST_RUNTIME_TO_INJECT = testRuntimeToInject(config.port, config);
-    const htmlContent = escapeAndInjectTestsToHTML(
-      replaceAssetPaths(
-        cachedContent.mainHTML.html,
-        cachedContent.mainHTML.filePath,
-        config.projectRoot,
-      ),
-      TEST_RUNTIME_TO_INJECT,
-      cachedContent.filteredTestCode,
-    );
-
-    res.write(htmlContent);
-    res.end();
-
-    return await fsPromise.writeFile(
-      `${config.projectRoot}/${config.output}/qunitx.html`,
-      htmlContent,
-    );
-  });
-
-  server.get('/*', async (req, res) => {
-    const possibleDynamicHTML =
-      cachedContent.dynamicContentHTMLs[`${config.projectRoot}${req.path}`];
-    if (possibleDynamicHTML) {
-      const TEST_RUNTIME_TO_INJECT = testRuntimeToInject(config.port, config);
-      const htmlContent = escapeAndInjectTestsToHTML(
-        possibleDynamicHTML,
-        TEST_RUNTIME_TO_INJECT,
-        cachedContent.allTestCode,
-      );
-
-      res.write(htmlContent);
-      res.end();
-
-      return await fsPromise.writeFile(
-        `${config.projectRoot}/${config.output}${req.path}`,
-        htmlContent,
-      );
-    }
-
-    const url = req.url;
-    const requestStartedAt = new Date();
-    const filePath = (
-      url.endsWith('/') ? [STATIC_FILES_PATH, url, 'index.html'] : [STATIC_FILES_PATH, url]
-    ).join('');
-    const 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,
-    });
-
-    if (statusCode === 404) {
-      res.end();
-    } else {
-      fs.createReadStream(filePath).pipe(res);
-    }
-
-    console.log(`# [HTTPServer] GET ${url} ${statusCode} - ${new Date() - requestStartedAt}ms`);
-  });
-
-  return server;
-}
-
-function replaceAssetPaths(html: string, htmlPath: string, projectRoot: string): string {
-  const assetPaths = findInternalAssetsFromHTML(html);
-  const htmlDirectory = htmlPath.split('/').slice(0, -1).join('/');
-
-  return assetPaths.reduce((result, assetPath) => {
-    const normalizedFullAbsolutePath = path.normalize(`${htmlDirectory}/${assetPath}`);
-
-    return result.replace(assetPath, normalizedFullAbsolutePath.replace(projectRoot, '.'));
-  }, html);
-}
-
-function testRuntimeToInject(port: number, config: Config): string {
-  return `<script>
-    window.testTimeout = 0;
-    setInterval(() => {
-      window.testTimeout = window.testTimeout + 1000;
-    }, 1000);
-
-    (function() {
-      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_PLAYWRIGHT && messageEvent.data === 'refresh') {
-            window.location.reload(true);
-          } else if (window.IS_PLAYWRIGHT && messageEvent.data === 'abort') {
-            window.abortQUnit = true;
-            window.QUnit.config.queue.length = 0;
-            window.socket.send(JSON.stringify({ event: 'abort' }));
-          }
-        });
-      }
-
-      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);
-      }
-
-      setupWebSocket();
-    })();
-
-    {{allTestCode}}
-
-    function getCircularReplacer() {
-      const ancestors = [];
-      return function (key, value) {
-        if (typeof value !== "object" || value === null) {
-          return value;
-        }
-        while (ancestors.length > 0 && ancestors.at(-1) !== this) {
-          ancestors.pop();
-        }
-        if (ancestors.includes(value)) {
-          return "[Circular]";
-        }
-        ancestors.push(value);
-        return value;
-      };
-    }
-
-    function setupQUnit() {
-      window.QUNIT_RESULT = { totalTests: 0, finishedTests: 0, failedTests: 0, currentTest: '' };
-
-      if (!window.QUnit) {
-        console.log('QUnit not found after WebSocket connected');
-        window.testTimeout = ${config.timeout};
-        return;
-      }
-
-      window.QUnit.begin(() => { // NOTE: might be useful in future for hanged module tracking
-        if (window.IS_PLAYWRIGHT) {
-          window.socket.send(JSON.stringify({ event: 'connection' }));
-        }
-      });
-      window.QUnit.moduleStart((details) => { // NOTE: might be useful in future for hanged module tracking
-        if (window.IS_PLAYWRIGHT) {
-          window.socket.send(JSON.stringify({ event: 'moduleStart', details: details }, getCircularReplacer()));
-        }
-      });
-      window.QUnit.on('testStart', (details) => {
-        window.QUNIT_RESULT.totalTests++;
-        window.QUNIT_RESULT.currentTest = details.fullName.join(' | ');
-      });
-      window.QUnit.on('testEnd', (details) => { // NOTE: https://github.com/qunitjs/qunit/blob/master/src/html-reporter/diff.js
-        window.testTimeout = 0;
-        window.QUNIT_RESULT.finishedTests++;
-        if (details.status === 'failed') window.QUNIT_RESULT.failedTests++;
-        window.QUNIT_RESULT.currentTest = null;
-        if (window.IS_PLAYWRIGHT) {
-          window.socket.send(JSON.stringify({ event: 'testEnd', details: details, abort: window.abortQUnit }, getCircularReplacer()));
-
-          if (${config.failFast} && details.status === 'failed') {
-            window.QUnit.config.queue.length = 0;
-          }
-        }
-      });
-      window.QUnit.done((details) => {
-        if (window.IS_PLAYWRIGHT) {
-          window.socket.send(JSON.stringify({ event: 'done', details: details, abort: window.abortQUnit }, getCircularReplacer()));
-          // Do NOT set testTimeout here. The WS 'done' event (testsDone promise) is the
-          // canonical completion signal for Playwright runs. waitForFunction is reserved
-          // for true timeouts (test hangs) where testTimeout increments naturally via setInterval.
-          // Setting testTimeout after done caused a race: under CI load, waitForFunction could
-          // win before Node.js processed the WS done message, dropping all testEnd events.
-        } else {
-          window.testTimeout = ${config.timeout};
-        }
-      });
-
-      window.QUnit.start();
-    }
-  </script>`;
-}
-
-function escapeAndInjectTestsToHTML(
-  html: string,
-  testRuntimeCode: string,
-  testContentCode: Buffer | string | null | undefined,
-): string {
-  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.ts

@@ -1,33 +0,0 @@
-import fs from 'node:fs/promises';
-import type { CachedContent } from '../types.ts';
-
-/**
- * Copies static HTML files and referenced assets from the project into the configured output directory.
- * @returns {Promise<void>}
- */
-export default async function writeOutputStaticFiles(
-  { projectRoot, output }: { projectRoot: string; output: string },
-  cachedContent: CachedContent,
-): Promise<void> {
-  const staticHTMLPromises = Object.keys(cachedContent.staticHTMLs).map(async (staticHTMLKey) => {
-    const htmlRelativePath = staticHTMLKey.replace(`${projectRoot}/`, '');
-
-    await ensureFolderExists(`${projectRoot}/${output}/${htmlRelativePath}`);
-    await fs.writeFile(
-      `${projectRoot}/${output}/${htmlRelativePath}`,
-      cachedContent.staticHTMLs[staticHTMLKey],
-    );
-  });
-  const assetPromises = Array.from(cachedContent.assets).map(async (assetAbsolutePath) => {
-    const assetRelativePath = assetAbsolutePath.replace(`${projectRoot}/`, '');
-
-    await ensureFolderExists(`${projectRoot}/${output}/${assetRelativePath}`);
-    await fs.copyFile(assetAbsolutePath, `${projectRoot}/${output}/${assetRelativePath}`);
-  });
-
-  await Promise.all(staticHTMLPromises.concat(assetPromises));
-}
-
-async function ensureFolderExists(assetPath: string): Promise<void> {
-  await fs.mkdir(assetPath.split('/').slice(0, -1).join('/'), { recursive: true });
-}

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

@@ -1,25 +0,0 @@
-import type { Counter } from '../types.ts';
-
-/**
- * Prints the TAP plan line and test-run summary (total, pass, skip, fail, duration).
- * @returns {void}
- */
-
-export default function TAPDisplayFinalResult(
-  { testCount, passCount, skipCount, failCount }: Counter,
-  timeTaken: number,
-): void {
-  console.log('');
-  console.log(`1..${testCount}`);
-  console.log(`# tests ${testCount}`);
-  console.log(`# pass ${passCount}`);
-  console.log(`# skip ${skipCount}`);
-  console.log(`# fail ${failCount}`);
-
-  // let seconds = timeTaken > 1000 ? Math.floor(timeTaken / 1000) : 0;
-  // let milliseconds = timeTaken % 100;
-
-  console.log(`# duration ${timeTaken}`);
-  console.log('');
-}
-// console.log(details.timeTaken); // runtime

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

@@ -1,109 +0,0 @@
-import dumpYaml from './dump-yaml.ts';
-import indentString from '../utils/indent-string.ts';
-import type { Counter } from '../types.ts';
-
-interface TestAssertion {
-  passed: boolean;
-  todo: boolean;
-  stack?: string;
-  actual?: unknown;
-  expected?: unknown;
-  message?: string;
-}
-interface TestDetails {
-  status: string;
-  fullName: string[];
-  runtime: number;
-  assertions: TestAssertion[];
-}
-
-// tape TAP output: ['operator', 'stack', 'at', 'expected', 'actual']
-// ava TAP output: ['message', 'name', 'at', 'assertion', 'values'] // Assertion #5, message
-/**
- * Formats and prints a single QUnit testEnd event as a TAP `ok`/`not ok` line with optional YAML failure block.
- * @returns {void}
- */
-export default function TAPDisplayTestResult(COUNTER: Counter, details: TestDetails): void {
-  // NOTE: https://github.com/qunitjs/qunit/blob/master/src/html-reporter/diff.js
-  COUNTER.testCount++;
-
-  if (details.status === 'skipped') {
-    COUNTER.skipCount++;
-    console.log(`ok ${COUNTER.testCount}`, details.fullName.join(' | '), '# skip');
-  } else if (details.status === 'todo') {
-    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)`,
-    );
-    details.assertions.forEach((assertion, index) => {
-      if (!assertion.passed && assertion.todo === false) {
-        COUNTER.errorCount = (COUNTER.errorCount ?? 0) + 1;
-        const stack = assertion.stack?.match(/\(.+\)/g);
-
-        console.log('  ---');
-        console.log(
-          indentString(
-            dumpYaml({
-              name: `Assertion #${index + 1}`,
-              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('  ...');
-      }
-    });
-  } else if (details.status === 'passed') {
-    COUNTER.passCount++;
-    console.log(
-      `ok ${COUNTER.testCount}`,
-      details.fullName.join(' | '),
-      `# (${details.runtime.toFixed(0)} ms)`,
-    );
-  }
-}
-
-function getCircularReplacer(): (_key: string, value: unknown) => unknown {
-  const ancestors: object[] = [];
-  return function (this: object, _key: string, value: unknown) {
-    if (typeof value !== 'object' || value === null) {
-      return value;
-    }
-    while (ancestors.length > 0 && ancestors.at(-1) !== this) {
-      ancestors.pop();
-    }
-    if (ancestors.includes(value)) {
-      return '[Circular]';
-    }
-    ancestors.push(value);
-    return value;
-  };
-}
-
-// not ok 10 test exited without ending: deepEqual true works
-//   ---
-//     operator: fail
-//     at: process.<anonymous> (/home/izelnakri/ava-test/node_modules/tape/index.js:85:19)
-//     stack: |-
-//       Error: test exited without ending: deepEqual true works
-//           at Test.assert [as _assert] (/home/izelnakri/ava-test/node_modules/tape/lib/test.js:269:54)
-//           at Test.bound [as _assert] (/home/izelnakri/ava-test/node_modules/tape/lib/test.js:90:32)
-//           at Test.fail (/home/izelnakri/ava-test/node_modules/tape/lib/test.js:363:10)
-//           at Test.bound [as fail] (/home/izelnakri/ava-test/node_modules/tape/lib/test.js:90:32)
-//           at Test._exit (/home/izelnakri/ava-test/node_modules/tape/lib/test.js:226:14)
-//           at Test.bound [as _exit] (/home/izelnakri/ava-test/node_modules/tape/lib/test.js:90:32)
-//           at process.<anonymous> (/home/izelnakri/ava-test/node_modules/tape/index.js:85:19)
-//           at process.emit (node:events:376:20)
-//   ...

package/lib/tap/dump-yaml.ts

@@ -1,84 +0,0 @@
-/**
- * Minimal YAML serializer for TAP assertion failure blocks.
- * Handles the fixed schema: { name, actual, expected, message, stack, at }.
- * Values for actual/expected are pre-sanitized via JSON.parse(JSON.stringify(...)).
- */
-
-// Single compiled regex covering all cases where a plain YAML scalar would be misread:
-// - YAML reserved words (null, true, false, ~, yes, no, on, off — case-insensitive)
-// - Starts with a YAML indicator: { [ ! | > ' " % @ `
-// - Block indicators that need a space: - ? : at start of string
-// - Document separator: ---
-// - Looks like a number (integer, float, hex, octal, scientific)
-// - Timestamp-like strings that YAML 1.1 auto-casts to Date
-// - Contains ': ' (key–value) or '#' anywhere (comment)
-// - Empty string
-// Also covers single-letter YAML 1.1 booleans: y/Y → true, n/N → false
-const NEEDS_QUOTING =
-  /^$|^(null|true|false|~|yes|no|on|off|y|n)$|^[{[!|>'"#%@`]|^[-?:](\s|$)|^---|^[-+]?(\d|\.\d)|^\d{4}-\d{2}-\d{2}|: |#/i;
-
-function needsQuoting(str: string): boolean {
-  return NEEDS_QUOTING.test(str);
-}
-
-function dumpString(str: string, indent: string): string {
-  if (str === '') return "''";
-  if (str.includes('\n')) {
-    // Block scalar |- (strip trailing newline), each line indented by current indent + 2
-    return '|-\n' + str.replace(/^/gm, `${indent}  `);
-  }
-  if (needsQuoting(str)) return `'${str.replace(/'/g, "''")}'`;
-  return str;
-}
-
-function dumpValue(value: unknown, indent: string): string {
-  if (value === null || value === undefined) return 'null';
-  if (typeof value === 'boolean' || typeof value === 'number') return String(value);
-  if (typeof value === 'string') return dumpString(value, indent);
-  if (Array.isArray(value)) {
-    if (value.length === 0) return '[]';
-    const next = `${indent}  `;
-    return '\n' + value.map((v) => `${next}- ${dumpValue(v, next)}`).join('\n');
-  }
-  // Plain object
-  const entries = Object.entries(value);
-  if (entries.length === 0) return '{}';
-  const next = `${indent}  `;
-  return '\n' + entries.map(([k, v]) => `${next}${k}: ${dumpValue(v, next)}`).join('\n');
-}
-
-// Emits `key: value\n` or `key:\n  ...\n` — no trailing space before block scalars.
-function yamlLine(key: string, value: unknown): string {
-  const v = dumpValue(value, '');
-  return v[0] === '\n' ? `${key}:${v}\n` : `${key}: ${v}\n`;
-}
-
-/**
- * Serializes the fixed TAP assertion object to a YAML string.
- * Uses a template literal (no Object.entries overhead) for the known top-level keys.
- * @returns {string}
- */
-export default function dumpYaml({
-  name,
-  actual,
-  expected,
-  message,
-  stack,
-  at,
-}: {
-  name: string;
-  actual: unknown;
-  expected: unknown;
-  message: string | null;
-  stack: string | null;
-  at: string | null;
-}): string {
-  return (
-    `name: ${dumpString(name, '')}\n` +
-    yamlLine('actual', actual) +
-    yamlLine('expected', expected) +
-    yamlLine('message', message) +
-    yamlLine('stack', stack) +
-    yamlLine('at', at)
-  );
-}