qunitx-cli 0.0.2 → 0.0.3

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 '../../index.js';
+
+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 '../../index.js';
+
+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' });
+  });
+});

package/test/helpers/fs-writers.js

@@ -0,0 +1,36 @@
+import fs from 'node:fs/promises';
+import crypto from 'node:crypto';
+
+export async function writeTestFolder(options={ addFailingTests: false, mixedExtensions: false }) {
+  let { addFailingTests, mixedExtensions } = options;
+  let folderName = crypto.randomUUID();
+  let extension = mixedExtensions ? 'ts' : 'js';
+  let [passingsTestTemplate, failingTestTemplate] = await Promise.all([
+    fs.readFile(`${process.cwd()}/test/helpers/passing-tests.js`),
+    options.addFailingTests ? fs.readFile(`${process.cwd()}/test/helpers/failing-tests.js`) : null,
+    fs.mkdir(`${process.cwd()}/tmp/${folderName}`, { recursive: true })
+  ]);
+
+  await Promise.all([
+    writeTestFile(folderName, 'first-module-pass', 'js', passingsTestTemplate),
+    writeTestFile(folderName, 'second-module-pass', extension, passingsTestTemplate),
+    addFailingTests ? writeTestFile(folderName, 'first-module-fail', 'js', failingTestTemplate) : null,
+    addFailingTests ? writeTestFile(folderName, 'second-module-fail', extension, failingTestTemplate) : null,
+    addFailingTests ? writeTestFile(folderName, 'third-module-fail', extension, failingTestTemplate) : null,
+  ]);
+
+
+  return folderName;
+}
+
+export function writeTestFile(folderName, testFileName, extension, templateBuffer) {
+  return fs.writeFile(
+    `${process.cwd()}/tmp/${folderName}/${testFileName}.${extension}`,
+    templateBuffer.toString().replace('{{moduleName}}', `${folderName} | ${testFileName}`)
+  );
+}
+
+export default {
+  writeTestFolder,
+  writeTestFile
+};

package/test/helpers/index-with-content.html

@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width">
+    <title>HTML with content tests</title>
+    <link href="../../node_modules/qunit/qunit/qunit.css" rel="stylesheet">
+  </head>
+  <body>
+    <div id="qunit"></div>
+    <div id="qunit-fixture"></div>
+
+    {{content}}
+
+    <script>
+      console.log('Hello from index-with-content.html');
+    </script>
+    <script src="./passing-tests-dist.js"></script>
+  </body>
+</html>`

package/test/helpers/index-without-content.html

@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width">
+    <title>HTML without content tests</title>
+    <link href="../../node_modules/qunit/qunit/qunit.css" rel="stylesheet">
+  </head>
+  <body>
+    <div id="qunit"></div>
+    <div id="qunit-fixture"></div>
+
+    <!-- this has no {content} so should be just viewed in the browser with no console interaction(?) -->
+    <script>
+      console.log('Hello from index-without-content.html');
+    </script>
+    <script src="./passing-tests-dist.js"></script>
+    <script>
+      window.QUnit.start();
+    </script>
+  </body>
+</html>`