qunitx-cli 0.0.2 → 0.1.0

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.1.0",
   "description": "Browser runner for QUnitx: run your qunitx tests in google-chrome",
   "main": "index.js",
   "author": "Izel Nakri",
@@ -23,7 +23,10 @@
     "prepack": "npm run build",
     "release:alpha": "node_modules/.bin/release-it --preRelease=alpha --no-git.requireUpstream",
     "release:beta": "node_modules/.bin/release-it --preRelease=beta --no-git.requireUpstream",
-    "release": "node_modules/.bin/release-it"
+    "release": "node_modules/.bin/release-it",
+    "test": "node --test test/index.js",
+    "test:sanity-first": "./cli.js test/helpers/failing-tests.js test/helpers/failing-tests.ts",
+    "test:sanity-second": "./cli.js test/helpers/passing-tests.js test/helpers/passing-tests.ts"
   },
   "engines": {
     "node": ">=20.3.0"
@@ -38,12 +41,12 @@
   "dependencies": {
     "cheerio": "^1.0.0-rc.10",
     "chokidar": "^3.5.3",
-    "esbuild": "^0.18.12",
+    "esbuild": "^0.18.14",
     "js-yaml": "^4.1.0",
     "jsdom": "^22.0.0",
     "kleur": "^4.1.5",
     "picomatch": "^2.3.1",
-    "puppeteer": "20.8.2",
+    "puppeteer": "20.8.3",
     "recursive-lookup": "1.1.0",
     "ws": "^8.13.0"
   },
@@ -54,7 +57,7 @@
     "prettier": "^3.0.0",
     "qunit": "^2.19.4",
     "qunitx": "^0.6.0",
-    "release-it": "^16.1.0"
+    "release-it": "^16.1.2"
   },
   "volta": {
     "node": "20.4.0"

package/test/commands/help-test.js

@@ -0,0 +1,72 @@
+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:
+--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 --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";

package/test/commands/init-test.js

@@ -0,0 +1,44 @@
+import { module, test } from 'qunitx';
+import assert from 'node:assert';
+import { promisify } from 'node:util';
+import { exec } from 'node:child_process';
+
+const shell = promisify(exec);
+const cli = async function(arg = '') {
+  if (process.argv[0].includes('deno')) {
+    return await shell(`deno run --allow-read ${CWD}/deno/cli.js ${arg}`);
+  }
+
+  return await shell(`deno run --allow-read ${CWD}/cli.js ${arg}`);
+}
+
+module('Commands | init tests', () => {
+  test('$ qunitx init -> creates the test.html and correctly', async () => {
+    // assert missing
+    const { stdout } = await cli('init');
+    // assert added
+  });
+
+  // it('$ qunitx init warns existing files and assigns attributes to package.json', async function() {
+
+  // });
+
+  // it('$ qunitx init -> recreates missing files from package.json if it exists', async function() {
+
+  // });
+});
+
+async function stripQUnitXFromPackageJSON() {
+
+}
+
+// it('$ qunitx unknown -> raises error', async function() {
+//   t.plan(2);
+
+//   try {
+//     await shell(`node ${process.cwd()}/cli.js dasd`);
+//   } catch ({ stdout }) {
+//     assert.ok(stdout.includes('qunitx unknown command. Available options are:'));
+//     assert.ok(stdout.includes(printedHelpOutput));
+//   }
+// });

package/test/flags/after-test.js

@@ -0,0 +1,23 @@
+import { module, test } from 'qunitx';
+import { assertPassingTestCase, assertFailingTestCase, assertTAPResult } from '../helpers/assert-stdout.js';
+import shell from '../helpers/shell.js';
+
+module('--after script tests for browser mode', { concurrency: false }, (_hooks, moduleMetadata) => {
+  test('--after works when it doesnt need to be awaited', async (assert, testMetadata) => {
+    const { stdout } = await shell('node cli.js test/helpers/passing-tests.js --after=test/helpers/after-script-basic.js', { ...moduleMetadata, ...testMetadata });
+
+    assert.ok(stdout.includes('This is running from after script!!'));
+    assertPassingTestCase(assert, stdout, { debug: false, testNo: 1, moduleName: '{{moduleName}}' });
+    assertTAPResult(assert, stdout, { testCount: 3 });
+  });
+
+  test('--after works when it needs to be awaited', async (assert, testMetadata) => {
+    const { stdout } = await shell('node cli.js test/helpers/passing-tests.js --after=test/helpers/after-script-async.js', { ...moduleMetadata, ...testMetadata });
+
+    assert.ok(stdout.includes('This is running from after script!!'));
+    assert.ok(stdout.includes('After script result is written:'));
+    assert.ok(stdout.includes(JSON.stringify({ testCount: 3, failCount: 0, skipCount: 0, passCount: 3 }, null, 2)));
+    assertPassingTestCase(assert, stdout, { testNo: 1, moduleName: '{{moduleName}}' });
+    assertTAPResult(assert, stdout, { testCount: 3 });
+  });
+});

package/test/flags/before-test.js

@@ -0,0 +1,23 @@
+import { module, test } from 'qunitx';
+import { assertPassingTestCase, assertFailingTestCase, assertTAPResult } from '../helpers/assert-stdout.js';
+import shell from '../helpers/shell.js';
+
+module('--before script tests for browser mode', { concurrency: false }, (_hooks, moduleMetadata) => {
+  test('--before works when it doesnt need to be awaited', async (assert, testMetadata) => {
+    const { stdout } = await shell('node cli.js test/helpers/passing-tests.js --before=test/helpers/before-script-basic.js', { ...moduleMetadata, ...testMetadata });
+
+    assert.ok(stdout.includes('This is running from before script!!'));
+    assertPassingTestCase(assert, stdout, { testNo: 1, moduleName: '{{moduleName}}' });
+    assertTAPResult(assert, stdout, { testCount: 3 });
+  });
+
+  test('--before works it needs to be awaited', { concurrency: false }, async (assert, testMetadata) => {
+    const { stdout } = await shell('node cli.js test/helpers/passing-tests.js test/helpers/before-script-web-server-tests.js --before=test/helpers/before-script-async.js', { ...moduleMetadata, ...testMetadata });
+
+    assert.ok(stdout.includes('This is running from before script!!'));
+    assert.ok(stdout.includes('Starting before script with:'));
+    assertPassingTestCase(assert, stdout, { testNo: 1, moduleName: '{{moduleName}}' });
+    assertPassingTestCase(assert, stdout, { testNo: 4, moduleName: '{{moduleName}} Before script web server tests' });
+    assertTAPResult(assert, stdout, { testCount: 4 });
+  });
+});

package/test/flags/coverage-test.js

@@ -0,0 +1,6 @@
+import { module, test } from 'qunitx';
+
+// test('todo', async (t) => {
+//   t.true(true);
+// });
+

package/test/flags/failfast-test.js

@@ -0,0 +1,5 @@
+import { module, test } from 'qunitx';
+
+// test('todo', async (t) => {
+//   t.true(true);
+// });

package/test/flags/index.js

@@ -0,0 +1,2 @@
+import "./after-test.js";
+import "./before-test.js";

package/test/flags/output-test.js

@@ -0,0 +1,6 @@
+import { module, test } from 'qunitx';
+
+// test('todo', async (t) => {
+//   t.true(true);
+// });
+

package/test/flags/reporter-test.js

@@ -0,0 +1,6 @@
+import { module, test } from 'qunitx';
+
+// test('todo', async (t) => {
+//   t.true(true);
+// });
+

package/test/flags/timeout-test.js

@@ -0,0 +1,6 @@
+import { module, test } from 'qunitx';
+
+// test('todo', async (t) => {
+//   t.true(true);
+// });
+

package/test/flags/watch-test.js

@@ -0,0 +1,6 @@
+import { module, test } from 'qunitx';
+
+// test('todo', async (t) => {
+//   t.true(true);
+// });
+

package/test/helpers/after-script-async.js

@@ -0,0 +1,13 @@
+import fs from 'fs/promises';
+import './after-script-basic.js';
+
+export default async function(results) {
+  let resultsInString = JSON.stringify(results, null, 2);
+
+  await fs.rm(`${process.cwd()}/tmp/results.json`, { force: true, recursive: true });
+  await fs.writeFile(`${process.cwd()}/tmp/results.json`, resultsInString);
+
+  console.log('After script result is written:');
+  console.log(resultsInString);
+}
+

package/test/helpers/after-script-basic.js

@@ -0,0 +1 @@
+console.log('This is running from after script!!');

package/test/helpers/assert-stdout.js

@@ -0,0 +1,112 @@
+export function assertStdout(assert, folderNames, options={ checkFailure: false, debug: false }) {
+  // folderNames.forEach((folder
+}
+
+export function assertPassingTestCase(assert, stdout, options={ moduleName: '{{moduleName}}', debug: false }) {
+  let { moduleName, debug } = options;
+
+  if (debug) {
+    assert.ok(new RegExp(`ok \. ${moduleName} | assert.ok works # (\d+ ms)`).test(stdout));
+    assert.ok(stdout.includes('resolving async test'));
+    assert.ok(/(.+)placeholder(.+)/g.test(stdout));
+    assert.ok(/(.+)anotherObject(.+)/g.test(stdout));
+    assert.ok(new RegExp(`ok \. ${moduleName} | async test finishes # (\d+ ms)`).test(stdout));
+    assert.ok(stdout.includes('calling deepEqual test case'));
+    // assert.ok(new RegExp(`ok ${testNo++} ${moduleName} | deepEqual true works # (\d+ ms)`).test(stdout));
+  } else {
+    assert.ok(new RegExp(`ok \. ${moduleName} | assert.ok works # (\d+ ms)`).test(stdout));
+    assert.ok(new RegExp(`ok \. ${moduleName} | async test finishes # (\d+ ms)`).test(stdout));
+    // assert.ok(new RegExp(`ok ${testNo++} ${moduleName} | deepEqual true works # (\d+ ms)`).test(stdout));
+  }
+}
+
+export function assertFailingTestCase(assert, stdout, options={ moduleName: '{{moduleName}}', debug: false }) {
+  let { moduleName, debug } = options;
+
+  if (debug) {
+    assert.ok(stdout.includes('calling assert true test case'));
+    assert.ok(stdout.includes('resolving async test'));
+    assert.ok(/(.+)placeholder(.+)/g.test(stdout));
+    assert.ok(/(.+)anotherObject(.+)/g.test(stdout));
+  } else {
+    assert.ok(!stdout.includes('calling assert true test case'));
+    assert.ok(!stdout.includes('resolving async test'));
+    assert.notOk(/(.+)placeholder(.+)/g.test(stdout));
+    assert.notOk(/(.+)anotherObject(.+)/g.test(stdout));
+
+    assert.ok(new RegExp(`not ok 2 ${moduleName} | async test finishes # (\d+ ms)␊
+        ---␊
+          name: 'Assertion #1'␊
+          actual: null␊
+          expected: null␊
+          message: 'Promise rejected during "async test finishes": wait is not a function'␊
+          stack: |-␊
+            TypeError: wait is not a function␊
+                at Object.<anonymous> (\S+:\d+:\d+)␊
+          at: '\S+:\d+:\d+'␊
+        ...␊
+        ---␊
+          name: 'Assertion #2'␊
+          actual: null␊
+          expected: null␊
+          message: 'Expected 4 assertions, but 1 were run'␊
+          stack: '    at Object.<anonymous> (\S+:\d+:\d+)'␊
+          at: '\S+:\d+:\d+'␊
+        ...`).test(stdout));
+    assert.ok(new RegExp(`not ok 3 ${moduleName} | runtime error output # (\d+ ms)
+      ---
+        name: 'Assertion #1'
+        actual: null
+        expected: true
+        message: null
+        stack: '    at Object.<anonymous> (\S+:\d+:\d+)'
+        at: '\S+:\d+:\d+'
+      ...
+      ---
+        name: 'Assertion #2'
+        actual: null
+        expected: null
+        message: >-
+          Died on test #2     at Object.<anonymous>
+          (\S+:\d+:\d+): Cannot
+          read property 'second' of undefined
+        stack: |-
+          TypeError: Cannot read property 'second' of undefined
+              at Object.<anonymous> (\S+:\d+:\d+)
+        at: '\S+:\d+:\d+'
+      ...
+    `).test(stdout));
+    assert.ok(new RegExp(`not ok 4 ${moduleName} | deepEqual true works # (\d+ ms)␊
+        ---␊
+          name: 'Assertion #1'␊
+          actual:␊
+            firstName: Izel␊
+            lastName: Nakri␊
+          expected:␊
+            firstName: Isaac␊
+            lastName: Nakri␊
+          message: null␊
+          stack: '    at Object.<anonymous> (\S+:\d+:\d+)'␊
+          at: '\S+:\d+:\d+'␊
+        ...␊`).test(stdout));
+  }
+}
+
+export function assertTAPResult(assert, stdout, options={ testCount: 0, failCount: 0 }) {
+  if (options.failCount) {
+    return assert.ok(new RegExp(`# pass ${options.testCount - options.failCount}
+# skip 0
+# fail (${options.failCount}|${options.failCount + 1})`).test(stdout));
+  }
+
+  assert.ok(new RegExp(`# pass ${options.testCount}
+# skip 0
+# fail 0`).test(stdout));
+}
+
+export default {
+  assertStdout,
+  assertPassingTestCase,
+  assertFailingTestCase,
+  assertTAPResult
+}

package/test/helpers/before-script-async.js

@@ -0,0 +1,35 @@
+import express from 'express';
+import cors from "cors";
+import kleur from 'kleur';
+import bindServerToPort from '../../lib/setup/bind-server-to-port.js';
+import './before-script-basic.js';
+import QUnit from 'qunitx';
+
+export default async function(config) {
+  console.log('Starting before script with:');
+
+  let hasServerRunning = !!config.expressApp;
+
+  config.expressApp = config.expressApp || express();
+  config.expressApp.use(cors());
+  config.expressApp.get("/films", (req, res) => {
+    console.log('req received');
+    res.json({ film: "responsed correctly" });
+  });
+  config.expressApp.get("/movies/too-big-to-fail", (req, res) => {
+    res.json({ movie: "is too-big-to-fail" });
+  });
+
+  if (!hasServerRunning) {
+    console.log('DOESNT HAVE SERVER RUNNING');
+    let server = await bindServerToPort(config.expressApp, config);
+
+    QUnit.config.port = config.port;
+    console.log(`Web server started on port ${QUnit.config.port}`);
+  }
+}
+
+function wait(duration) {
+  return new Promise((resolve) => setTimeout(() => { resolve() }, duration));
+}
+

package/test/helpers/before-script-basic.js

@@ -0,0 +1 @@
+console.log('This is running from before script!!');

package/test/helpers/before-script-web-server-tests.js

@@ -0,0 +1,28 @@
+import { module, test } from 'qunitx';
+
+module('{{moduleName}} Before script web server tests', function(hooks) {
+  test('assert true works', async function (assert) {
+    let json;
+    try {
+      let port = window.QUnit.config.port || location.port;
+
+      await wait(250);
+
+      let res = await fetch(`http://127.0.0.1:${port}/films`);
+      json = await res.json();
+    } catch (err) {
+      console.log('FETCH ERR', err);
+      console.log(err.cause);
+    }
+
+    assert.deepEqual(json, { film: 'responsed correctly' });
+  });
+
+  // test('async test finishes', async function (assert) {
+
+  // });
+});
+
+function wait(duration) {
+  return new Promise((resolve) => setTimeout(() => { resolve() }, duration));
+}

package/test/helpers/failing-tests.js

@@ -0,0 +1,49 @@
+import { module, test } from 'qunitx';
+
+module('{{moduleName}} Failing Tests', function(hooks) {
+  test('assert true works', function (assert) {
+    assert.expect(3);
+    assert.ok(true);
+    console.log('calling assert true test case');
+    assert.equal(true, true);
+    assert.equal(null, null);
+  });
+
+  test('async test finishes', async function (assert) {
+    assert.expect(4);
+
+    const wait = () => new Promise((resolve, reject) => {
+      window.setTimeout(() => {
+        console.log('resolving async test');
+        console.log({
+          moduleName: 'called resolved async test with object',
+          placeholder: 1000,
+          anotherObject: {
+            firstName: 'Izel',
+            createdAt: new Date('2021-03-06')
+          }
+        });
+        resolve(true);
+      }, 50);
+    });
+    const result = await wait();
+
+    assert.ok(true);
+    assert.equal(false, result);
+    assert.equal(null, null);
+  });
+
+  test('runtime error output', function (assert) {
+    let smt = {};
+
+    assert.equal(undefined, true);
+    assert.deepEqual(smt.first.second, {});
+  });
+
+  test('deepEqual true works', function (assert) {
+    const me = { firstName: 'Izel', lastName: 'Nakri' };
+
+    console.log('calling deepEqual test case');
+    assert.deepEqual(me, { firstName: 'Isaac', lastName: 'Nakri' });
+  });
+});

package/test/helpers/failing-tests.ts

@@ -0,0 +1,49 @@
+import { module, test } from 'qunitx';
+
+module('{{moduleName}} Failing Tests', function(hooks) {
+  test('assert true works', function (assert) {
+    assert.expect(3);
+    assert.ok(true);
+    console.log('calling assert true test case');
+    assert.equal(true, true);
+    assert.equal(null, null);
+  });
+
+  test('async test finishes', async function (assert) {
+    assert.expect(4);
+
+    const wait = () => new Promise((resolve, reject) => {
+      window.setTimeout(() => {
+        console.log('resolving async test');
+        console.log({
+          moduleName: 'called resolved async test with object',
+          placeholder: 1000,
+          anotherObject: {
+            firstName: 'Izel',
+            createdAt: new Date('2021-03-06')
+          }
+        });
+        resolve(true);
+      }, 50);
+    });
+    const result = await wait();
+
+    assert.ok(true);
+    assert.equal(false, result);
+    assert.equal(null, null);
+  });
+
+  test('runtime error output', function (assert) {
+    let smt = {};
+
+    assert.equal(undefined, true);
+    assert.deepEqual(smt.first.second, {});
+  });
+
+  test('deepEqual true works', function (assert) {
+    const me = { firstName: 'Izel', lastName: 'Nakri' };
+
+    console.log('calling deepEqual test case');
+    assert.deepEqual(me, { firstName: 'Isaac', lastName: 'Nakri' });
+  });
+});