qunitx-cli 0.1.1 → 0.5.0

package/lib/commands/init.js

@@ -7,49 +7,57 @@ import defaultProjectConfigValues from '../boilerplates/default-project-config-v
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
-export default async function() {
+export default async function () {
   let projectRoot = await findProjectRoot();
   let oldPackageJSON = JSON.parse(await fs.readFile(`${projectRoot}/package.json`));
-  let htmlPaths = process.argv.slice(2).reduce((result, arg) => {
-    if (arg.endsWith('.html')) {
-      result.push(arg);
-    }
+  let htmlPaths = process.argv.slice(2).reduce(
+    (result, arg) => {
+      if (arg.endsWith('.html')) {
+        result.push(arg);
+      }
 
-    return result;
-  }, oldPackageJSON.qunitx && oldPackageJSON.qunitx.htmlPaths ? oldPackageJSON.qunitx.htmlPaths : []);
+      return result;
+    },
+    oldPackageJSON.qunitx && oldPackageJSON.qunitx.htmlPaths ? oldPackageJSON.qunitx.htmlPaths : [],
+  );
   let newQunitxConfig = Object.assign(
     defaultProjectConfigValues,
     htmlPaths.length > 0 ? { htmlPaths } : { htmlPaths: ['test/tests.html'] },
-    oldPackageJSON.qunitx
+    oldPackageJSON.qunitx,
   );
 
   await Promise.all([
     writeTestsHTML(projectRoot, newQunitxConfig, oldPackageJSON),
     rewritePackageJSON(projectRoot, newQunitxConfig, oldPackageJSON),
-    writeTSConfigIfNeeded(projectRoot)
+    writeTSConfigIfNeeded(projectRoot),
   ]);
 }
 
 async function writeTestsHTML(projectRoot, newQunitxConfig, oldPackageJSON) {
   let testHTMLTemplateBuffer = await fs.readFile(`${__dirname}/../boilerplates/setup/tests.hbs`);
 
-  return await Promise.all(newQunitxConfig.htmlPaths.map(async (htmlPath) => {
-    let targetPath = `${projectRoot}/${htmlPath}`;
-    if (await pathExists(targetPath)) {
-      return console.log(`${htmlPath} already exists`);
-    } else {
-      let targetDirectory = path.dirname(targetPath);
-      let targetOutputPath = path.relative(targetDirectory, `${projectRoot}/${newQunitxConfig.output}/tests.js`);
-      let testHTMLTemplate = testHTMLTemplateBuffer
-        .toString()
-        .replace('{{applicationName}}', oldPackageJSON.name);
+  return await Promise.all(
+    newQunitxConfig.htmlPaths.map(async (htmlPath) => {
+      let targetPath = `${projectRoot}/${htmlPath}`;
+      if (await pathExists(targetPath)) {
+        return console.log(`${htmlPath} already exists`);
+      } else {
+        let targetDirectory = path.dirname(targetPath);
+        let targetOutputPath = path.relative(
+          targetDirectory,
+          `${projectRoot}/${newQunitxConfig.output}/tests.js`,
+        );
+        let testHTMLTemplate = testHTMLTemplateBuffer
+          .toString()
+          .replace('{{applicationName}}', oldPackageJSON.name);
 
-      await fs.mkdir(targetDirectory, { recursive: true });
-      await fs.writeFile(targetPath, testHTMLTemplate);
+        await fs.mkdir(targetDirectory, { recursive: true });
+        await fs.writeFile(targetPath, testHTMLTemplate);
 
-      console.log(`${targetPath} written`);
-    }
-  }));
+        console.log(`${targetPath} written`);
+      }
+    }),
+  );
 }
 
 async function rewritePackageJSON(projectRoot, newQunitxConfig, oldPackageJSON) {
@@ -61,7 +69,9 @@ async function rewritePackageJSON(projectRoot, newQunitxConfig, oldPackageJSON)
 async function writeTSConfigIfNeeded(projectRoot) {
   let targetPath = `${projectRoot}/tsconfig.json`;
   if (!(await pathExists(targetPath))) {
-    let tsConfigTemplateBuffer = await fs.readFile(`${__dirname}/../boilerplates/setup/tsconfig.json`);
+    let tsConfigTemplateBuffer = await fs.readFile(
+      `${__dirname}/../boilerplates/setup/tsconfig.json`,
+    );
 
     await fs.writeFile(targetPath, tsConfigTemplateBuffer);
 

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

@@ -17,81 +17,99 @@ class BundleError extends Error {
   }
 }
 
+// Exported so run.js can pre-build all group bundles in parallel with Chrome startup.
+export async function buildTestBundle(config, cachedContent) {
+  const { projectRoot, output } = config;
+  const allTestFilePaths = Object.keys(config.fsTree);
+
+  await Promise.all([
+    esbuild.build({
+      stdin: {
+        contents: allTestFilePaths.map((f) => `import "${f}";`).join(''),
+        resolveDir: process.cwd(),
+      },
+      bundle: true,
+      logLevel: 'error',
+      outfile: `${projectRoot}/${output}/tests.js`,
+      keepNames: true,
+      sourcemap: 'inline',
+    }),
+    Promise.all(
+      cachedContent.htmlPathsToRunTests.map(async (htmlPath) => {
+        const targetPath = `${config.projectRoot}/${config.output}${htmlPath}`;
+        if (htmlPath !== '/') {
+          await fs.rm(targetPath, { force: true, recursive: true });
+          await fs.mkdir(targetPath.split('/').slice(0, -1).join('/'), { recursive: true });
+        }
+      }),
+    ),
+  ]);
+
+  cachedContent.allTestCode = await fs.readFile(`${projectRoot}/${output}/tests.js`);
+}
+
 export default async function runTestsInBrowser(
   config,
   cachedContent = {},
   connections,
-  targetTestFilesToFilter
+  targetTestFilesToFilter,
 ) {
-  const { projectRoot, timeout, output } = config;
+  const { projectRoot, output } = config;
   const allTestFilePaths = Object.keys(config.fsTree);
   const runHasFilter = !!targetTestFilesToFilter;
 
-  config.COUNTER = { testCount: 0, failCount: 0, skipCount: 0, passCount: 0 };
+  // In group mode the COUNTER is shared across all groups and managed by run.js.
+  if (!config._groupMode) {
+    config.COUNTER = { testCount: 0, failCount: 0, skipCount: 0, passCount: 0 };
+  }
   config.lastRanTestFiles = targetTestFilesToFilter || allTestFilePaths;
 
   try {
-    await Promise.all([
-      esbuild.build({
-        stdin: {
-          contents: allTestFilePaths.reduce((result, fileAbsolutePath) => {
-            return result + `import "${fileAbsolutePath}";`
-          }, ''),
-          resolveDir: process.cwd()
-        },
-        bundle: true,
-        logLevel: 'error',
-        outfile: `${projectRoot}/${output}/tests.js`,
-        keepNames: true
-      }), // NOTE: This prevents file cache most likely
-      Promise.all(cachedContent.htmlPathsToRunTests.map(async (htmlPath) => {
-        let targetPath = `${config.projectRoot}/${config.output}${htmlPath}`;
-
-        if (htmlPath !== '/') {
-          await fs.rm(targetPath, { force: true, recursive: true });
-          await fs.mkdir(targetPath.split('/').slice(0, -1).join('/'), { recursive: true }); // NOTE: this can be done earlier
-        }
-      }))
-    ]);
-    cachedContent.allTestCode = await fs.readFile(`${projectRoot}/${output}/tests.js`);
+    // Skip bundle build if run.js already pre-built it (group mode optimization).
+    if (!cachedContent.allTestCode) {
+      await buildTestBundle(config, cachedContent);
+    }
 
     if (runHasFilter) {
-      let outputPath = `${projectRoot}/${output}/filtered-tests.js`;
-
+      const outputPath = `${projectRoot}/${output}/filtered-tests.js`;
       await buildFilteredTests(targetTestFilesToFilter, outputPath);
       cachedContent.filteredTestCode = (await fs.readFile(outputPath)).toString();
     }
 
-    let TIME_COUNTER = timeCounter();
+    const TIME_COUNTER = timeCounter();
 
     if (runHasFilter) {
       await runTestInsideHTMLFile('/qunitx.html', connections, config);
     } else {
-      await Promise.all(cachedContent.htmlPathsToRunTests.map((htmlPath) => {
-        return runTestInsideHTMLFile(htmlPath, connections, config); // NOTE: maybe make this blocking
-      }));
+      await Promise.all(
+        cachedContent.htmlPathsToRunTests.map((htmlPath) =>
+          runTestInsideHTMLFile(htmlPath, connections, config),
+        ),
+      );
     }
 
-    let TIME_TAKEN = TIME_COUNTER.stop()
-
-    TAPDisplayFinalResult(config.COUNTER, TIME_TAKEN);
+    const TIME_TAKEN = TIME_COUNTER.stop();
 
-    if (config.after) {
-      await runUserModule(`${process.cwd()}/${config.after}`, config.COUNTER, 'after');
-    }
+    // In group mode the parent orchestrator handles the final summary, after hook, and exit.
+    if (!config._groupMode) {
+      TAPDisplayFinalResult(config.COUNTER, TIME_TAKEN);
 
-    if (!config.watch) {
-      await Promise.all([
-        connections.server && connections.server.close(),
-        connections.browser && connections.browser.close()
-      ]);
+      if (config.after) {
+        await runUserModule(`${process.cwd()}/${config.after}`, config.COUNTER, 'after');
+      }
 
-      return process.exit(config.COUNTER.failCount > 0 ? 1 : 0);
+      if (!config.watch) {
+        await Promise.all([
+          connections.server && connections.server.close(),
+          connections.browser && connections.browser.close(),
+        ]);
+        return process.exit(config.COUNTER.failCount > 0 ? 1 : 0);
+      }
     }
-  } catch(error) {
+  } catch (error) {
     config.lastFailedTestFiles = config.lastRanTestFiles;
     console.log(error);
-    let exception = new BundleError(error);
+    const exception = new BundleError(error);
 
     if (config.watch) {
       console.log(`# ${exception}`);
@@ -106,31 +124,41 @@ export default async function runTestsInBrowser(
 function buildFilteredTests(filteredTests, outputPath) {
   return esbuild.build({
     stdin: {
-      contents: filteredTests.reduce((result, fileAbsolutePath) => {
-        return result + `import "${fileAbsolutePath}";`
-      }, ''),
-      resolveDir: process.cwd()
+      contents: filteredTests.map((f) => `import "${f}";`).join(''),
+      resolveDir: process.cwd(),
     },
     bundle: true,
     logLevel: 'error',
-    outfile: outputPath
+    outfile: outputPath,
+    sourcemap: 'inline',
   });
 }
 
-async function runTestInsideHTMLFile(filePath, { page, server }, config) {
+async function runTestInsideHTMLFile(filePath, { page, server, browser }, config) {
   let QUNIT_RESULT;
   let targetError;
   try {
-    await wait(350);
     console.log('#', kleur.blue(`QUnitX running: http://localhost:${config.port}${filePath}`));
-    await page.goto(`http://localhost:${config.port}${filePath}`, { timeout: 0 });
-    await page.evaluate(() => {
+
+    const testsDone = new Promise((resolve) => {
+      config._testRunDone = resolve;
+    });
+
+    await page.evaluateOnNewDocument(() => {
       window.IS_PUPPETEER = true;
     });
-    await page.waitForFunction(`window.testTimeout >= ${config.timeout}`, { timeout: 0 });
+    await page.goto(`http://localhost:${config.port}${filePath}`, {
+      timeout: config.timeout + 10000,
+    });
+    await Promise.race([
+      testsDone,
+      page.waitForFunction(`window.testTimeout >= ${config.timeout}`, {
+        timeout: config.timeout + 10000,
+      }),
+    ]);
 
     QUNIT_RESULT = await page.evaluate(() => window.QUNIT_RESULT);
-  } catch(error) {
+  } catch (error) {
     targetError = error;
     console.log(error);
     console.error(error);
@@ -140,23 +168,25 @@ async function runTestInsideHTMLFile(filePath, { page, server }, config) {
     console.log(targetError);
     console.log('BROWSER: runtime error thrown during executing tests');
     console.error('BROWSER: runtime error thrown during executing tests');
-
-    await failOnNonWatchMode(config.watch);
+    await failOnNonWatchMode(config.watch, { server, browser }, config._groupMode);
   } else if (QUNIT_RESULT.totalTests > QUNIT_RESULT.finishedTests) {
     console.log(targetError);
     console.log(`BROWSER: TEST TIMED OUT: ${QUNIT_RESULT.currentTest}`);
     console.error(`BROWSER: TEST TIMED OUT: ${QUNIT_RESULT.currentTest}`);
-
-    await failOnNonWatchMode(config.watch);
+    await failOnNonWatchMode(config.watch, { server, browser }, config._groupMode);
   }
 }
 
-async function failOnNonWatchMode(watchMode = false) {
+async function failOnNonWatchMode(watchMode = false, connections = {}, groupMode = false) {
   if (!watchMode) {
-    await new Promise((resolve, reject) => setTimeout(() => resolve(process.exit(1)), 100));
+    if (groupMode) {
+      // Parent orchestrator handles cleanup and exit; signal failure via throw.
+      throw new Error('Browser test run failed');
+    }
+    await Promise.all([
+      connections.server && connections.server.close(),
+      connections.browser && connections.browser.close(),
+    ]);
+    process.exit(1);
   }
 }
-
-function wait(duration) {
-  return new Promise((resolve) => setTimeout(() => { resolve() }, duration));
-}

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}`);