qunitx-cli 0.0.3 → 0.1.1

package/test/helpers/passing-tests.js

@@ -1,44 +0,0 @@
-import { module, test } from 'qunitx';
-
-module('{{moduleName}} Passing 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(3);
-
-    const wait = new Promise((resolve, reject) => {
-      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(true, result);
-    assert.equal(null, null);
-
-    result;
-  });
-
-  test('deepEqual true works', function (assert) {
-    const me = { firstName: 'Izel', lastName: 'Nakri' };
-
-    console.log('calling deepEqual test case');
-    assert.deepEqual(me, { firstName: 'Izel', lastName: 'Nakri' });
-  });
-});

package/test/helpers/passing-tests.ts

@@ -1,44 +0,0 @@
-import { module, test } from 'qunitx';
-
-module('{{moduleName}} Passing 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(3);
-
-    const wait = new Promise((resolve, reject) => {
-      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(true, result);
-    assert.equal(null, null);
-
-    result;
-  });
-
-  test('deepEqual true works', function (assert) {
-    const me = { firstName: 'Izel', lastName: 'Nakri' };
-
-    console.log('calling deepEqual test case');
-    assert.deepEqual(me, { firstName: 'Izel', lastName: 'Nakri' });
-  });
-});

package/test/helpers/shell.js

@@ -1,37 +0,0 @@
-import { promisify } from 'node:util';
-import { exec } from 'node:child_process';
-
-const shell = promisify(exec);
-
-export default async function execute(commandString, { moduleName = '', testName = '' } = {}) {
-  try {
-    let result = await shell(commandString);
-    let { stdout, stderr } = result;
-
-    console.trace(`
-      TEST NAME: ${moduleName} | ${testName}
-      TEST COMMAND: ${commandString}
-      ${stdout.split('\n').map((line, index) => `${index}: ${line}`).join('\n')}
-    `);
-
-    if (stderr && stderr !== '') {
-      console.trace(`
-        TEST NAME: ${moduleName} | ${testName}
-        TEST COMMAND: ${commandString}
-        ${stderr.split('\n').map((line, index) => `${index}: ${line}`).join('\n')}
-      `);
-    }
-
-    return result;
-  } catch (error) {
-    console.trace(`
-      ERROR TEST Name: ${moduleName} | ${testName}
-      ERROR TEST COMMAND: ${commandString}
-      ${error}
-    `);
-
-    throw error;;
-  }
-
-
-}

package/test/index.js

@@ -1,22 +0,0 @@
-import "./setup.js";
-// import { tap } from 'node:test/reporters';
-// import { run } from 'node:test';
-
-// run({
-//   concurrency: true,
-//   files: [
-//     "./test/commands/index.js",
-//     "./test/flags/index.js",
-//     "./test/inputs/index.js",
-//     "./test/setup/index.js",
-//   ],
-//   // timeout: 20000
-// })
-//   .compose(tap)
-//   .pipe(process.stdout);
-
-import "./commands/index.js";
-import "./flags/index.js";
-import "./inputs/index.js";
-import "./setup/index.js";
-

package/test/inputs/advanced-htmls-test.js

@@ -1,21 +0,0 @@
-import { module, test } from 'qunitx';
-
-// runTestInsideHTMLFile
-
-module('Advanced HTML Input Tests', function() {
-  test('testing with specific html without content works', async function(assert) {
-    assert.equal(true, true);
-  //   const { stdout } = await shell('node cli.js test/helpers/index-without-content.html');
-
-  //   console.log(stdout);
-
-  //   assert.match(stdout, /Hello from index-without-content.html/);
-  });
-});
-
-// html without content
-// html without content --browser --debug
-// html with content
-// html with content  --browser --debug
-// multiple htmls
-// multiple htmls --browser --debug --output

package/test/inputs/error-edge-cases-test.js

@@ -1,11 +0,0 @@
-import { module, test } from 'qunitx';
-
-// TODO: invalid extension, use --debug without browser
-// folder/file doesnt exist to watch
-// unknown command
-
-module('Advanced Error Edge Cases Tests', function() {
-  test('todo', async function(assert) {
-    assert.ok(true);
-  });
-});

package/test/inputs/file-and-folder-test.js

@@ -1,11 +0,0 @@
-import { module, test } from 'qunitx';
-
-module('File and Folder Combination Tests', function() {
-  test('todo', async function(assert) {
-    assert.ok(true);
-  });
-});
-
-
-
-// TODO: add file folder and multiple html

package/test/inputs/file-test.js

@@ -1,169 +0,0 @@
-import { module, test } from 'qunitx';
-import { assertPassingTestCase, assertFailingTestCase, assertTAPResult } from '../helpers/assert-stdout.js';
-import shell from '../helpers/shell.js';
-
-module('File Input Tests', { concurrency: false }, (_hooks, moduleMetadata) => {
-  // test('testing a single passing js file works', async (assert, testMetadata) => {
-  //   const { stdout } = await shell('node tmp/test/passing-tests.js', { ...moduleMetadata, ...testMetadata });
-
-  //   assertPassingTestCase(assert, stdout, { debug: true, testNo: 1, moduleName: '{{moduleName}}' });
-  //   assertTAPResult(assert, stdout, { testCount: 3 });
-  // });
-
-//   test('testing a single failing js file works', async (assert, testMetadata) => {
-//     try {
-//       await shell('node tmp/test/failing-tests.js', { ...moduleMetadata, ...testMetadata });
-//     } catch(cmd) {
-//       assert.ok(cmd.stdout.includes('TAP version 13'));
-//       assert.ok(cmd.stdout.includes('calling assert true test case'));
-//       assert.ok(new RegExp(`ok 1 {{moduleName}} | assert.ok works # (\d+ ms)`).test(cmd.stdout));
-//       assert.ok(cmd.stdout.includes('resolving async test'));
-//       assert.ok(cmd.stdout.includes(`{
-//   moduleName: 'called resolved async test with object',
-//   placeholder: 1000,
-//   anotherObject: { firstName: 'Izel', createdAt: 2021-03-06T00:00:00.000Z }
-// }`));
-//       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> (file://\w+/tmp/test/failing-tests.js:\d+:\d+)␊
-//           at: '\w+/tmp/test/failing-tests.js:\d+:\d+'␊
-//         ...␊
-//         ---␊
-//           name: 'Assertion #2'␊
-//           actual: null␊
-//           expected: null␊
-//           message: 'Expected 4 assertions, but 1 were run'␊
-//           stack: '    at Object.<anonymous> (file://\w+/tmp/test/failing-tests.js:\d+:\d+)'␊
-//           at: '\w+/tmp/test/failing-tests.js:\d+:\d+'␊
-//         ...`).test(cmd.stdout));
-//       assert.ok(cmd.stdout.includes('calling deepEqual test case'));
-//       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> (file://\w+/tmp/test/failing-tests.js:\d+:\d+)'
-//         at: '\w+/tmp/test/failing-tests.js:\d+:\d+'
-//       ...
-//       ---
-//         name: 'Assertion #2'
-//         actual: null
-//         expected: null
-//         message: >-
-//           Died on test #2     at Object.<anonymous>
-//           (file://\w+/tmp/test/failing-tests.js:\d+:\d+): Cannot
-//           read property 'second' of undefined
-//         stack: |-
-//           TypeError: Cannot read property 'second' of undefined
-//               at Object.<anonymous> (file://\w+/tmp/test/failing-tests.js:\d+:\d+)
-//         at: '\w+/tmp/test/failing-tests.js:\d+:\d+'
-//       ...
-//     `).test(cmd.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> (file://\w+/tmp/test/failing-tests.js:\d+:\d+)'␊
-//           at: '\w+/tmp/test/failing-tests.js:\d+:\d+'␊
-//         ...␊`).test(cmd.stdout));
-//       assert.ok(cmd.stdout.includes('1..4'));
-//       assert.ok(cmd.stdout.includes('# tests 4'));
-//       assert.ok(cmd.stdout.includes('# pass 1'));
-//       assert.ok(cmd.stdout.includes('# skip 0'));
-//       assert.ok(cmd.stdout.includes('# fail 3'));
-//     }
-//   });
-
-//   // test.skip('testing a single passing ts file works', async function() {
-//   // });
-
-//   // test.skip('testing a single failing ts file works', async function() {
-//   // });
-
-  test('testing a single passing js file with works, console output supressed', async (assert, testMetadata) => {
-    const { stdout } = await shell('node cli.js tmp/test/passing-tests.js', { ...moduleMetadata, ...testMetadata });
-
-    assertPassingTestCase(assert, stdout, { testNo: 1, moduleName: '{{moduleName}}' });
-    assertTAPResult(assert, stdout, { testCount: 3 });
-  });
-
-  test('testing a single passing js file with --debug works', async (assert, testMetadata) => {
-    const { stdout } = await shell('node cli.js tmp/test/passing-tests.js --debug', { ...moduleMetadata, ...testMetadata });
-
-    assert.ok(new RegExp(/# QUnitX running: http\:\/\/localhost:\d+/).test(stdout));
-    assert.ok(stdout.includes('TAP version 13'));
-    assertPassingTestCase(assert, stdout, { debug: true, testNo: 1, moduleName: '{{moduleName}}' });
-    assertTAPResult(assert, stdout, { testCount: 3 });
-  });
-
-  test('testing a single failing js file works', async (assert, testMetadata) => {
-    try {
-      let { stdout } = await shell('node cli.js tmp/test/failing-tests.js', { ...moduleMetadata, ...testMetadata });
-    } catch(cmd) {
-      assert.ok(cmd.stdout.includes('TAP version 13'));
-      assertFailingTestCase(assert, cmd.stdout, { testNo: 1, moduleName: '{{moduleName}}' });
-      assertTAPResult(assert, cmd.stdout, { testCount: 4, failCount: 3 });
-    }
-  });
-
-  test('testing a single failing js file with --debug works', async (assert, testMetadata) => {
-    try {
-      await shell('node cli.js tmp/test/failing-tests.js --debug', { ...moduleMetadata, ...testMetadata });
-    } catch(cmd) {
-      assert.ok(cmd.stdout.includes('TAP version 13'));
-      assertFailingTestCase(assert, cmd.stdout, { debug: true, testNo: 1, moduleName: '{{moduleName}}' });
-      assertTAPResult(assert, cmd.stdout, { testCount: 4, failCount: 3 });
-    }
-  });
-
-  test('testing a single passing ts file works, console output supressed', async (assert, testMetadata) => {
-    const { stdout } = await shell('node cli.js tmp/test/passing-tests.ts', { ...moduleMetadata, ...testMetadata });
-
-    assert.ok(stdout.includes('TAP version 13'));
-    assertPassingTestCase(assert, stdout, { testNo: 1, moduleName: '{{moduleName}}' });
-    assertTAPResult(assert, stdout, { testCount: 3 });
-  });
-
-  test('testing a single passing ts file with --debug works', async (assert, testMetadata) => {
-    const { stdout } = await shell('node cli.js tmp/test/passing-tests.ts --debug', { ...moduleMetadata, ...testMetadata });
-
-    assert.ok(new RegExp(/# QUnitX running: http\:\/\/localhost:\d+/).test(stdout));
-    assert.ok(stdout.includes('TAP version 13'));
-
-    assertPassingTestCase(assert, stdout, { debug: true, testNo: 1, moduleName: '{{moduleName}}' });
-    assertTAPResult(assert, stdout, { testCount: 3 });
-  });
-
-  test('testing a single failing ts file works', async (assert, testMetadata) => {
-    try {
-      await shell('node cli.js tmp/test/failing-tests.ts', { ...moduleMetadata, ...testMetadata });
-    } catch(cmd) {
-      assert.ok(cmd.stdout.includes('TAP version 13'));
-      assertPassingTestCase(assert, cmd.stdout, { testNo: 1, moduleName: '{{moduleName}}' });
-      assertTAPResult(assert, cmd.stdout, { testCount: 4, failCount: 3 });
-    }
-  });
-
-  test('testing a single failing ts file with --debug works', async (assert, testMetadata) => {
-    try {
-      await shell('node cli.js tmp/test/failing-tests.ts --debug', { ...moduleMetadata, ...testMetadata });
-    } catch(cmd) {
-      assert.ok(cmd.stdout.includes('TAP version 13'));
-      assertPassingTestCase(assert, cmd.stdout, { debug: true, testNo: 1, moduleName: '{{moduleName}}' });
-      assertTAPResult(assert, cmd.stdout, { testCount: 4, failCount: 3 });
-    }
-  });
-});

package/test/inputs/folder-test.js

@@ -1,193 +0,0 @@
-import { module, test } from 'qunitx';
-import { writeTestFolder } from '../helpers/fs-writers.js';
-import { assertPassingTestCase, assertFailingTestCase, assertTAPResult } from '../helpers/assert-stdout.js';
-import shell from '../helpers/shell.js';
-
-
-module('Folder Input Tests', { concurrency: false }, (_hooks, moduleMetadata) => {
-  // test('works for a single folder input with all passing tests', async (assert, testMetadata) => {
-  //   let folderName = await writeTestFolder({ addFailingTests: false, });
-
-  //   const { stdout } = await shell(`node cli.js tmp/${folderName}`, { ...moduleMetadata, ...testMetadata });
-
-  //   assertPassingTestCase(assert, stdout, { debug: true, moduleName: `${folderName} | first-module-pass` });
-  //   assertPassingTestCase(assert, stdout, { debug: true, moduleName: `${folderName} | second-module-pass` });
-  //   assertTAPResult(assert, stdout, { testCount: 6 });
-  // });
-
-  // test('works for a single folder input with few failing tests', async (assert, testMetadata) => {
-  //   let folderName = await writeTestFolder({ addFailingTests: true });
-
-  //   try {
-  //     await shell(`node cli.js tmp/${folderName}`, { ...moduleMetadata, ...testMetadata });
-  //   } catch (cmd) {
-  //     assertPassingTestCase(assert, cmd.stdout, { debug: true, moduleName: `${folderName} | first-module-pass` });
-  //     assertPassingTestCase(assert, cmd.stdout, { debug: true, moduleName: `${folderName} | second-module-pass` });
-  //     assertFailingTestCase(assert, cmd.stdout, { debug: true, moduleName: `${folderName} | first-module-fail` });
-  //     assertFailingTestCase(assert, cmd.stdout, { debug: true, moduleName: `${folderName} | second-module-fail` });
-  //     assertFailingTestCase(assert, cmd.stdout, { debug: true, moduleName: `${folderName} | third-module-fail` });
-  //     assertTAPResult(assert, cmd.stdout, { testCount: 18, failCount: 9 });
-  //   }
-  // });
-
-  // test('works for a multiple folders input with all passing tests', async (assert, ...testMetadata) => {
-  //   let firstFolderName = await writeTestFolder({ addFailingTests: false, });
-  //   let secondFolderName = await writeTestFolder({ addFailingTests: false });
-
-  //   const { stdout } = await shell(`node cli.js tmp/${firstFolderName} tmp/${secondFolderName}`, { ...moduleMetadata, ...testMetadata });
-
-  //   assertPassingTestCase(assert, stdout, { debug: true, moduleName: `${firstFolderName} | first-module-pass` });
-  //   assertPassingTestCase(assert, stdout, { debug: true, moduleName: `${firstFolderName} | second-module-pass` });
-  //   assertPassingTestCase(assert, stdout, { debug: true, moduleName: `${secondFolderName} | first-module-pass` });
-  //   assertPassingTestCase(assert, stdout, { debug: true, moduleName: `${secondFolderName} | second-module-pass` });
-  //   assertTAPResult(assert, stdout, { testCount: 12 });
-  // });
-
-  // test('works for a multiple folders input with few failing tests', async (assert, ...testMetadata) => {
-  //   let firstFolderName = await writeTestFolder({ addFailingTests: true });
-  //   let secondFolderName = await writeTestFolder({ addFailingTests: false });
-  //   let thirdFolderName = await writeTestFolder({ addFailingTests: true });
-
-  //   try {
-  //     await shell(`node cli.js tmp/${firstFolderName} tmp/${secondFolderName}`, { ...moduleMetadata, ...testMetadata });
-  //   } catch (cmd) {
-  //     assertPassingTestCase(assert, cmd.stdout, { debug: true, moduleName: `${firstFolderName} | first-module-pass` });
-  //     assertPassingTestCase(assert, cmd.stdout, { debug: true, moduleName: `${firstFolderName} | second-module-pass` });
-  //     assertFailingTestCase(assert, cmd.stdout, { debug: true, moduleName: `${firstFolderName} | first-module-fail` });
-  //     assertFailingTestCase(assert, cmd.stdout, { debug: true, moduleName: `${firstFolderName} | second-module-fail` });
-  //     assertFailingTestCase(assert, cmd.stdout, { debug: true, moduleName: `${firstFolderName} | third-module-fail` });
-  //     assertPassingTestCase(assert, cmd.stdout, { debug: true, moduleName: `${secondFolderName} | first-module-pass` });
-  //     assertPassingTestCase(assert, cmd.stdout, { debug: true, moduleName: `${secondFolderName} | second-module-pass` });
-  //     assertPassingTestCase(assert, cmd.stdout, { debug: true, moduleName: `${thirdFolderName} | first-module-pass` });
-  //     assertPassingTestCase(assert, cmd.stdout, { debug: true, moduleName: `${thirdFolderName} | second-module-pass` });
-  //     assertFailingTestCase(assert, cmd.stdout, { debug: true, moduleName: `${thirdFolderName} | first-module-fail` });
-  //     assertFailingTestCase(assert, cmd.stdout, { debug: true, moduleName: `${thirdFolderName} | second-module-fail` });
-  //     assertFailingTestCase(assert, cmd.stdout, { debug: true, moduleName: `${thirdFolderName} | third-module-fail` });
-  //     assertTAPResult(assert, cmd.stdout, { testCount: 24, failCount: 9 });
-  //   }
-  // });
-
-  test('works for a single folder input in browser mode with all passing tests', async (assert, testMetadata) => {
-    let folderName = await writeTestFolder({ addFailingTests: false, });
-
-    const { stdout } = await shell(`node cli.js tmp/${folderName}`, { ...moduleMetadata, ...testMetadata });
-
-    assertPassingTestCase(assert, stdout, { debug: false, moduleName: `${folderName} | first-module-pass` });
-    assertPassingTestCase(assert, stdout, { debug: false, moduleName: `${folderName} | second-module-pass` });
-    assertTAPResult(assert, stdout, { testCount: 6 });
-  });
-
-  test('works for a single folder input in browser mode with few failing tests', async (assert, testMetadata) => {
-    let folderName = await writeTestFolder({ addFailingTests: true });
-
-    try {
-      await shell(`node cli.js tmp/${folderName}`, { ...moduleMetadata, ...testMetadata });
-    } catch (cmd) {
-      assertPassingTestCase(assert, cmd.stdout, { debug: false, moduleName: `${folderName} | first-module-pass` });
-      assertPassingTestCase(assert, cmd.stdout, { debug: false, moduleName: `${folderName} | second-module-pass` });
-      assertFailingTestCase(assert, cmd.stdout, { debug: false, moduleName: `${folderName} | first-module-fail` });
-      assertFailingTestCase(assert, cmd.stdout, { debug: false, moduleName: `${folderName} | second-module-fail` });
-      assertFailingTestCase(assert, cmd.stdout, { debug: false, moduleName: `${folderName} | third-module-fail` });
-      assertTAPResult(assert, cmd.stdout, { testCount: 18, failCount: 9 });
-    }
-  });
-
-  test('works for a multiple folders input in browser mode with all passing tests', async (assert, testMetadata) => {
-    let firstFolderName = await writeTestFolder({ addFailingTests: false, });
-    let secondFolderName = await writeTestFolder({ addFailingTests: false });
-
-    const { stdout } = await shell(`node cli.js tmp/${firstFolderName} tmp/${secondFolderName}`, { ...moduleMetadata, ...testMetadata });
-
-    assertPassingTestCase(assert, stdout, { debug: false, moduleName: `${firstFolderName} | first-module-pass` });
-    assertPassingTestCase(assert, stdout, { debug: false, moduleName: `${firstFolderName} | second-module-pass` });
-    assertPassingTestCase(assert, stdout, { debug: false, moduleName: `${secondFolderName} | first-module-pass` });
-    assertPassingTestCase(assert, stdout, { debug: false, moduleName: `${secondFolderName} | second-module-pass` });
-    assertTAPResult(assert, stdout, { testCount: 12 });
-  });
-
-  test('works for a multiple folders input in browser mode with few failing tests', async (assert, testMetadata) => {
-    let firstFolderName = await writeTestFolder({ addFailingTests: true });
-    let secondFolderName = await writeTestFolder({ addFailingTests: false });
-    let thirdFolderName = await writeTestFolder({ addFailingTests: true });
-
-    try {
-      await shell(`node cli.js tmp/${firstFolderName} tmp/${secondFolderName}`, { ...moduleMetadata, ...testMetadata });
-    } catch (cmd) {
-      assertPassingTestCase(assert, cmd.stdout, { debug: false, moduleName: `${firstFolderName} | first-module-pass` });
-      assertPassingTestCase(assert, cmd.stdout, { debug: false, moduleName: `${firstFolderName} | second-module-pass` });
-      assertFailingTestCase(assert, cmd.stdout, { debug: false, moduleName: `${firstFolderName} | first-module-fail` });
-      assertFailingTestCase(assert, cmd.stdout, { debug: false, moduleName: `${firstFolderName} | second-module-fail` });
-      assertFailingTestCase(assert, cmd.stdout, { debug: false, moduleName: `${firstFolderName} | third-module-fail` });
-      assertPassingTestCase(assert, cmd.stdout, { debug: false, moduleName: `${secondFolderName} | first-module-pass` });
-      assertPassingTestCase(assert, cmd.stdout, { debug: false, moduleName: `${secondFolderName} | second-module-pass` });
-      assertPassingTestCase(assert, cmd.stdout, { debug: false, moduleName: `${thirdFolderName} | first-module-pass` });
-      assertPassingTestCase(assert, cmd.stdout, { debug: false, moduleName: `${thirdFolderName} | second-module-pass` });
-      assertFailingTestCase(assert, cmd.stdout, { debug: false, moduleName: `${thirdFolderName} | first-module-fail` });
-      assertFailingTestCase(assert, cmd.stdout, { debug: false, moduleName: `${thirdFolderName} | second-module-fail` });
-      assertFailingTestCase(assert, cmd.stdout, { debug: false, moduleName: `${thirdFolderName} | third-module-fail` });
-      assertTAPResult(assert, cmd.stdout, { testCount: 24, failCount: 9 });
-    }
-  });
-
-  test('works for a single folder input in browser mode with debug and all passing tests', async (assert, testMetadata) => {
-    let folderName = await writeTestFolder({ addFailingTests: false, });
-
-    const { stdout } = await shell(`node cli.js tmp/${folderName} --debug`, { ...moduleMetadata, ...testMetadata });
-
-    assertPassingTestCase(assert, stdout, { debug: true, moduleName: `${folderName} | first-module-pass` });
-    assertPassingTestCase(assert, stdout, { debug: true, moduleName: `${folderName} | second-module-pass` });
-    assertTAPResult(assert, stdout, { testCount: 6 });
-  });
-
-  test('works for a single folder input in browser mode with debug and few failing tests', async (assert, testMetadata) => {
-    let folderName = await writeTestFolder({ addFailingTests: true });
-
-    try {
-      await shell(`node cli.js tmp/${folderName} --debug`, { ...moduleMetadata, ...testMetadata });
-    } catch (cmd) {
-      assertPassingTestCase(assert, cmd.stdout, { debug: true, moduleName: `${folderName} | first-module-pass` });
-      assertPassingTestCase(assert, cmd.stdout, { debug: true, moduleName: `${folderName} | second-module-pass` });
-      assertFailingTestCase(assert, cmd.stdout, { debug: true, moduleName: `${folderName} | first-module-fail` });
-      assertFailingTestCase(assert, cmd.stdout, { debug: true, moduleName: `${folderName} | second-module-fail` });
-      assertFailingTestCase(assert, cmd.stdout, { debug: true, moduleName: `${folderName} | third-module-fail` });
-      assertTAPResult(assert, cmd.stdout, { testCount: 18, failCount: 9 });
-    }
-  });
-
-  test('works for a multiple folders input in browser mode with debug and all passing tests', async (assert, testMetadata) => {
-    let firstFolderName = await writeTestFolder({ addFailingTests: false, });
-    let secondFolderName = await writeTestFolder({ addFailingTests: false });
-
-    const { stdout } = await shell(`node cli.js tmp/${firstFolderName} tmp/${secondFolderName} --debug`, { ...moduleMetadata, ...testMetadata });
-
-    assertPassingTestCase(assert, stdout, { debug: true, moduleName: `${firstFolderName} | first-module-pass` });
-    assertPassingTestCase(assert, stdout, { debug: true, moduleName: `${firstFolderName} | second-module-pass` });
-    assertPassingTestCase(assert, stdout, { debug: true, moduleName: `${secondFolderName} | first-module-pass` });
-    assertPassingTestCase(assert, stdout, { debug: true, moduleName: `${secondFolderName} | second-module-pass` });
-    assertTAPResult(assert, stdout, { testCount: 12 });
-  });
-
-  test('works for a multiple folders input in browser mode with debug and few failing tests', async (assert, testMetadata) => {
-    let firstFolderName = await writeTestFolder({ addFailingTests: true });
-    let secondFolderName = await writeTestFolder({ addFailingTests: false });
-    let thirdFolderName = await writeTestFolder({ addFailingTests: true });
-
-    try {
-      await shell(`node cli.js tmp/${firstFolderName} tmp/${secondFolderName} --debug`, { ...moduleMetadata, ...testMetadata });
-    } catch (cmd) {
-      assertPassingTestCase(assert, cmd.stdout, { debug: true, moduleName: `${firstFolderName} | first-module-pass` });
-      assertPassingTestCase(assert, cmd.stdout, { debug: true, moduleName: `${firstFolderName} | second-module-pass` });
-      assertFailingTestCase(assert, cmd.stdout, { debug: true, moduleName: `${firstFolderName} | first-module-fail` });
-      assertFailingTestCase(assert, cmd.stdout, { debug: true, moduleName: `${firstFolderName} | second-module-fail` });
-      assertFailingTestCase(assert, cmd.stdout, { debug: true, moduleName: `${firstFolderName} | third-module-fail` });
-      assertPassingTestCase(assert, cmd.stdout, { debug: true, moduleName: `${secondFolderName} | first-module-pass` });
-      assertPassingTestCase(assert, cmd.stdout, { debug: true, moduleName: `${secondFolderName} | second-module-pass` });
-      assertPassingTestCase(assert, cmd.stdout, { debug: true, moduleName: `${thirdFolderName} | first-module-pass` });
-      assertPassingTestCase(assert, cmd.stdout, { debug: true, moduleName: `${thirdFolderName} | second-module-pass` });
-      assertFailingTestCase(assert, cmd.stdout, { debug: true, moduleName: `${thirdFolderName} | first-module-fail` });
-      assertFailingTestCase(assert, cmd.stdout, { debug: true, moduleName: `${thirdFolderName} | second-module-fail` });
-      assertFailingTestCase(assert, cmd.stdout, { debug: true, moduleName: `${thirdFolderName} | third-module-fail` });
-      assertTAPResult(assert, cmd.stdout, { testCount: 24, failCount: 9 });
-    }
-  });
-});

package/test/inputs/index.js

@@ -1,5 +0,0 @@
-import "./advanced-htmls-test.js";
-import "./error-edge-cases-test.js";
-import "./file-and-folder-test.js";
-import "./file-test.js";
-import "./folder-test.js";

package/test/setup/index.js

@@ -1 +0,0 @@
-import "./test-file-paths-test.js";

package/test/setup/test-file-paths-test.js

@@ -1,33 +0,0 @@
-import { module, test } from 'qunitx';
-import setupTestFilePaths from '../../lib/setup/test-file-paths.js';
-
-module('Setup | glob(*) input tests | test-file-paths tests', () => {
-  test('setupTestFilePaths() works correctly on different inputs', (assert) => {
-    let projectRoot = '/home/izelnakri/Github/qunitx';
-
-    assert.deepEqual(setupTestFilePaths(projectRoot, [
-      `${projectRoot}/tmp`,
-      `${projectRoot}/tmp/vendor`,
-      `${projectRoot}/another/first/*`,
-      `${projectRoot}/another/first/something/helpers`,
-      `${projectRoot}/tmp/build-*`,
-      `${projectRoot}/vendor`,
-      `${projectRoot}/vendor-*`,
-      `${projectRoot}/vendor-*/files`,
-      `${projectRoot}/tests/**/something/*-test.ts`,
-      `${projectRoot}/tests/**/*.ts`,
-      `${projectRoot}/assets/something-test.ts`,
-      `${projectRoot}/assets/*-test.js`,
-      `${projectRoot}/tmp/build-*/*-test.ts`,
-      `${projectRoot}/vendor/*-test.js`,
-    ]), [
-      `${projectRoot}/tmp`,
-      `${projectRoot}/another/first/*`,
-      `${projectRoot}/vendor`,
-      `${projectRoot}/vendor-*`,
-      `${projectRoot}/tests/**/*.ts`,
-      `${projectRoot}/assets/*-test.js`,
-      `${projectRoot}/assets/something-test.ts`,
-    ]);
-  });
-});

package/test/setup.js

@@ -1,17 +0,0 @@
-import fs from 'node:fs/promises';
-
-process.env['FORCE_COLOR'] = 0;
-
-await fs.rm('./tmp', { recursive: true, force: true });
-await fs.mkdir('./tmp/test', { recursive: true });
-let [failingTestContent, passingTestContent] = await Promise.all([
-  fs.readFile('./test/helpers/failing-tests.js'),
-  fs.readFile('./test/helpers/passing-tests.js'),
-]);
-
-await Promise.all([
-  fs.writeFile('./tmp/test/failing-tests.js', failingTestContent.toString()),
-  fs.writeFile('./tmp/test/failing-tests.ts', failingTestContent.toString()),
-  fs.writeFile('./tmp/test/passing-tests.js', passingTestContent.toString()),
-  fs.writeFile('./tmp/test/passing-tests.ts', passingTestContent.toString())
-]);