qunitx-cli 0.0.2 → 0.0.3

package/lib/setup/web-server.js

@@ -0,0 +1,241 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import findInternalAssetsFromHTML from '../utils/find-internal-assets-from-html.js';
+import TAPDisplayTestResult from '../tap/display-test-result.js';
+import pathExists from '../utils/path-exists.js';
+import HTTPServer, { MIME_TYPES } from '../servers/http.js';
+
+const fsPromise = fs.promises;
+
+export default async function setupWebServer(config = {
+  port: 1234, debug: false, watch: false, timeout: 10000
+}, cachedContent) {
+  let STATIC_FILES_PATH = path.join(config.projectRoot, config.output);
+  let 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") {
+        console.log('TAP version 13');
+      } else if ((event === 'testEnd') && !abort) {
+        if (details.status === 'failed') {
+          config.lastFailedTestFiles = config.lastRanTestFiles;
+        }
+
+        TAPDisplayTestResult(config.COUNTER, details)
+      }
+    });
+  });
+
+  server.get('/', async (req, res) => {
+    let TEST_RUNTIME_TO_INJECT = testRuntimeToInject(config.port, config);
+    let htmlContent = escapeAndInjectTestsToHTML(
+      replaceAssetPaths(cachedContent.mainHTML.html, cachedContent.mainHTML.filePath, config.projectRoot),
+      TEST_RUNTIME_TO_INJECT,
+      cachedContent.allTestCode
+    );
+
+    res.write(htmlContent);
+    res.end();
+
+    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),
+      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) => {
+    let possibleDynamicHTML = cachedContent.dynamicContentHTMLs[`${config.projectRoot}${req.path}`];
+    if (possibleDynamicHTML) {
+      let TEST_RUNTIME_TO_INJECT = testRuntimeToInject(config.port, config);
+      let 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);
+    }
+
+    let url = req.url;
+    let requestStartedAt = new Date();
+    let filePath = (url.endsWith("/") ? [STATIC_FILES_PATH, url, "index.html"] : [STATIC_FILES_PATH, url]).join('');
+    let statusCode = await pathExists(filePath) ? 200 : 404;
+
+    res.writeHead(statusCode, {
+      "Content-Type": req.headers.accept?.includes('text/html')
+        ? MIME_TYPES.html
+        : MIME_TYPES[path.extname(filePath).substring(1).toLowerCase()] || MIME_TYPES.html
+    });
+
+    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, htmlPath, projectRoot) {
+  let assetPaths = findInternalAssetsFromHTML(html);
+  let htmlDirectory = htmlPath.split('/').slice(0, -1).join('/')
+
+  return assetPaths.reduce((result, assetPath) => {
+    let normalizedFullAbsolutePath = path.normalize(`${htmlDirectory}/${assetPath}`);
+
+    return result.replace(assetPath, normalizedFullAbsolutePath.replace(projectRoot, '.'));
+  }, html);
+}
+
+function testRuntimeToInject(port, config) {
+  return `<script>
+    window.testTimeout = 0;
+    setInterval(() => {
+      window.testTimeout = window.testTimeout + 1000;
+    }, 1000);
+
+    (function() {
+      function setupWebsocket() {
+        window.socket = new WebSocket('ws://localhost:${port}');
+        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' }))
+          }
+        });
+      }
+
+      function trySetupWebsocket() {
+        try {
+          setupWebsocket();
+        } catch(error) {
+          console.log(error);
+          window.setTimeout(() => trySetupWebsocket(), 10);
+        }
+      }
+
+      trySetupWebsocket();
+    })();
+
+    {{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, 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);
+        }
+
+        window.testTimeout = ${config.timeout};
+        return;
+      }
+
+      window.QUnit.begin(() => { // NOTE: might be useful in future for hanged module tracking
+        if (window.IS_PUPPETEER) {
+          window.socket.send(JSON.stringify({ event: 'connection' }));
+        }
+      });
+      window.QUnit.moduleStart((details) => { // NOTE: might be useful in future for hanged module tracking
+        if (window.IS_PUPPETEER) {
+          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++;
+        window.QUNIT_RESULT.currentTest = null;
+        if (window.IS_PUPPETEER) {
+          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_PUPPETEER) {
+          window.setTimeout(() => {
+            window.socket.send(JSON.stringify({ event: 'done', details: details, abort: window.abortQUnit }, getCircularReplacer()))
+          }, 50);
+        }
+        window.setTimeout(() => {
+          window.testTimeout = ${config.timeout};
+        }, 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);
+      }
+    }
+
+    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
+    );
+}

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

@@ -0,0 +1,22 @@
+import fs from 'node:fs/promises';
+
+export default async function writeOutputStaticFiles({ projectRoot, output }, cachedContent) {
+  let staticHTMLPromises = Object.keys(cachedContent.staticHTMLs).map(async (staticHTMLKey) => {
+    let htmlRelativePath = staticHTMLKey.replace(`${projectRoot}/`, '');
+
+    await ensureFolderExists(`${projectRoot}/${output}/${htmlRelativePath}`);
+    await fs.writeFile(`${projectRoot}/${output}/${htmlRelativePath}`, cachedContent.staticHTMLs[staticHTMLKey]);
+  });
+  let assetPromises = Array.from(cachedContent.assets).map(async (assetAbsolutePath) => {
+    let 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) {
+  await fs.mkdir(assetPath.split('/').slice(0, -1).join('/'), { recursive: true });
+}

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

@@ -0,0 +1,15 @@
+export default function({ testCount, passCount, skipCount, failCount }, timeTaken) {
+  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.js

@@ -0,0 +1,73 @@
+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
+  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.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('  ...');
+      }
+
+      return errorCount;
+    }, 0);
+  } else if (details.status === 'passed') {
+    COUNTER.passCount++;
+    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) {
+      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/utils/find-internal-assets-from-html.js

@@ -0,0 +1,16 @@
+import cheerio 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()
+    .map((scriptNode) => $(scriptNode).attr('src'))
+    .filter((uri) => !ABSOLUTE_URL_REGEX.test(uri));
+  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`));
+}

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

@@ -0,0 +1,17 @@
+import process from 'node:process';
+import searchInParentDirectories from './search-in-parent-directories.js';
+
+export default async function() {
+  try {
+    let absolutePath = await searchInParentDirectories('.', 'package.json');
+    if (!absolutePath.includes('package.json')) {
+      throw new Error('package.json mising');
+    }
+
+    return absolutePath.replace('/package.json', '');
+  } catch (error) {
+    console.log('couldnt find projects package.json, did you run $ npm init ??');
+    process.exit(1);
+  }
+}
+

package/lib/utils/indent-string.js

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

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

@@ -0,0 +1,44 @@
+import process from 'node:process';
+
+let stdin = process.stdin;
+let targetInputs = {};
+let inputs = [];
+let listenerAdded = 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){
+      if (key === '\u0003') {
+        process.exit(); // so node process doesnt trap Control-C
+      }
+
+      inputs.shift();
+      inputs.push(key);
+
+      let inputString = inputs.join('');
+      let targetListener = targetInputs[inputString.toUpperCase()];
+      if (targetListener && targetListenerConformsToCase(targetListener, inputString)) {
+        targetListener.closure(inputString);
+        inputs.fill(undefined);
+      }
+    });
+    listenerAdded = true;
+  }
+
+  if (inputString.length > inputs.length) {
+    inputs.length = inputString.length;
+  }
+
+  targetInputs[inputString.toUpperCase()] = Object.assign(options, { closure });
+}
+
+function targetListenerConformsToCase(targetListener, inputString) {
+  if (targetListener.caseSensitive) {
+    return inputString === inputString.toUpperCase();
+  }
+
+  return true;
+}

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

@@ -0,0 +1,57 @@
+// { 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];
+      }
+
+      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}`);
+
+    return result;
+  }, { inputs: new Set([]) });
+
+  providedFlags.inputs = Array.from(providedFlags.inputs);
+
+  return providedFlags;
+}
+
+function parseBoolean(result, defaultValue=true) {
+  if (result === 'true') {
+    return true;
+  } else if (result === 'false') {
+    return false;
+  }
+
+  return defaultValue;
+}
+
+function parseModule(value) {
+  if (['false', "'false'", '"false"', ''].includes(value)) {
+    return false;
+  }
+
+  return value;
+}

package/lib/utils/path-exists.js

@@ -0,0 +1,11 @@
+import fs from 'node:fs/promises';
+
+export default async function pathExists(path) {
+  try {
+    await fs.access(path);
+
+    return true;
+  } catch {
+    return false;
+  }
+}

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

@@ -0,0 +1,27 @@
+export default async function resolvePortNumberFor(portNumber) {
+  if (await portIsAvailable(portNumber)) {
+    return portNumber;
+  }
+
+  return (await resolvePortNumberFor(portNumber + 1));
+}
+
+function portIsAvailable(portNumber) {
+  return new Promise(async (resolve) => {
+    const net = await import('net');
+    const server = net.createServer();
+
+    server.once('error', function(err) {
+      if (err.code === 'EADDRINUSE') {
+        resolve(false);
+      }
+    });
+
+    server.once('listening', function() {
+      server.close();
+      resolve(true);
+    });
+
+    server.listen(portNumber);
+  });
+}

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

@@ -0,0 +1,18 @@
+import kleur from 'kleur';
+
+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;
+    }
+  } catch (error) {
+    console.log('#', kleur.red(`QUnitX ${scriptPosition} script failed:`));
+    console.trace(error);
+    console.error(error);
+
+    return process.exit(1);
+  }
+}

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

@@ -0,0 +1,15 @@
+import pathExists from './path-exists.js';
+
+async function searchInParentDirectories(directory, targetEntry) {
+  directory = directory === '.' ? process.cwd() : directory;
+
+  if (await pathExists(`${directory}/${targetEntry}`)) {
+    return `${directory}/${targetEntry}`;
+  } else if (directory === '') {
+    return;
+  }
+
+  return await searchInParentDirectories(directory.slice(0, directory.lastIndexOf('/')), targetEntry);
+}
+
+export default searchInParentDirectories;

package/lib/utils/time-counter.js

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "qunitx-cli",
   "type": "module",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "Browser runner for QUnitx: run your qunitx tests in google-chrome",
   "main": "index.js",
   "author": "Izel Nakri",

package/test/commands/help-test.js

@@ -0,0 +1,73 @@
+import { module, test } from 'qunitx';
+import process from "node:process";
+import fs from 'node:fs';
+import { promisify } from 'node:util';
+import { exec } from 'node:child_process';
+
+const CWD = process.cwd();
+const VERSION = JSON.parse(fs.readFileSync(`${CWD}/package.json`)).version;
+const shell = promisify(exec);
+const cli = async function(arg = '') {
+  if (process.argv[0].includes('deno')) {
+    return await shell(`deno run --allow-read --allow-env ${CWD}/deno/cli.js ${arg}`);
+  }
+
+  return await shell(`node ${CWD}/cli.js ${arg}`);
+}
+
+const printedHelpOutput = `[qunitx v${VERSION}] Usage: qunitx [targets] --$flags
+
+Input options:
+- File: $ qunitx test/foo.js
+- Folder: $ qunitx test/login
+- Globs: $ qunitx test/**/*-test.js
+- Combination: $ qunitx test/foo.js test/bar.js test/*-test.js test/logout
+
+Optional flags:
+--browser : run qunit tests in chromium with puppeteer instead of node.js(which is the default)
+--debug : print console output when tests run in browser
+--watch : run the target file or folders, watch them for continuous run and expose http server under localhost
+--timeout : change default timeout per test case
+--output : folder to distribute built qunitx html and js that a webservers can run[default: tmp]
+--failFast : run the target file or folders with immediate abort if a single test fails
+--before : run a script before the tests(i.e start a new web server before tests)
+--after : run a script after the tests(i.e save test results to a file)
+
+Example: $ qunitx test/foo.ts app/e2e --browser --debug --watch --before=scripts/start-new-webserver.js --after=scripts/write-test-results.js
+
+Commands:
+$ qunitx init               # Bootstraps qunitx base html and add qunitx config to package.json if needed
+$ qunitx new $testFileName  # Creates a qunitx test file`;
+
+module('Commands | Help tests', () => {
+  test('$ qunitx -> prints help text', async (assert) => {
+    const { stdout } = await cli();
+
+    console.log(stdout);
+    assert.ok(stdout.includes(printedHelpOutput));
+  });
+
+  test('$ qunitx print -> prints help text', async (assert) => {
+    const { stdout } = await cli('print');
+
+    assert.ok(stdout.includes(printedHelpOutput));
+  });
+
+  test('$ qunitx p -> prints help text', async (assert) => {
+    const { stdout } = await cli('p');
+
+    assert.ok(stdout.includes(printedHelpOutput));
+  });
+
+  test('$ qunitx help -> prints help text', async (assert) => {
+    const { stdout } = await cli('help');
+
+    assert.ok(stdout.includes(printedHelpOutput));
+  });
+
+  test('$ qunitx h -> prints help text', async (assert) => {
+    const { stdout } = await cli('h');
+
+    assert.ok(stdout.includes(printedHelpOutput));
+  });
+});

package/test/commands/index.js

@@ -0,0 +1,2 @@
+import "./help-test.js";
+// import "./init-test.js";