qunitx 0.3.8 → 0.4.1

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

@@ -119,7 +119,9 @@ function buildFilteredTests(filteredTests, outputPath) {
 
 async function runTestInsideHTMLFile(filePath, { page, server }, config) {
   let QUNIT_RESULT;
+  let targetError;
   try {
+    await wait(350);
     console.log('#', kleur.blue(`QUnitX running: http://localhost:${server.config.port}${filePath}`));
     await page.goto(`http://localhost:${server.config.port}${filePath}`, { timeout: 0 });
     await page.evaluate(() => {
@@ -129,16 +131,19 @@ async function runTestInsideHTMLFile(filePath, { page, server }, config) {
 
     QUNIT_RESULT = await page.evaluate(() => window.QUNIT_RESULT);
   } catch(error) {
+    targetError = error;
     console.log(error);
     console.error(error);
   }
 
   if (!QUNIT_RESULT || QUNIT_RESULT.totalTests === 0) {
+    console.log(targetError);
     console.log('BROWSER: runtime error thrown during executing tests');
     console.error('BROWSER: runtime error thrown during executing tests');
 
     await failOnNonWatchMode(config.watch);
   } else if (QUNIT_RESULT.totalTests > QUNIT_RESULT.finishedTests) {
+    console.log(targetError);
     console.log(`BROWSER: TEST TIMED OUT: ${QUNIT_RESULT.currentTest}`);
     console.error(`BROWSER: TEST TIMED OUT: ${QUNIT_RESULT.currentTest}`);
 
@@ -151,3 +156,7 @@ async function failOnNonWatchMode(watchMode = false) {
     await new Promise((resolve, reject) => setTimeout(() => resolve(process.exit(1)), 100));
   }
 }
+
+function wait(duration) {
+  return new Promise((resolve) => setTimeout(() => { resolve() }, duration));
+}

package/lib/commands/run.js

@@ -16,21 +16,22 @@ import writeOutputStaticFiles from '../setup/write-output-static-files.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
 export default async function(config) {
-  if (config.before) {
-    await runUserModule(`${process.cwd()}/${config.before}`, config, 'before');
-  }
-
   if (config.browser) {
     let cachedContent = await buildCachedContent(config, config.htmlPaths);
     let [connections, _] = await Promise.all([
       setupBrowser(config, cachedContent),
       writeOutputStaticFiles(config, cachedContent)
     ]);
+    config.expressApp = connections.server;
 
     if (config.watch) {
       setupKeyboardEvents(config, cachedContent, connections);
     }
 
+    if (config.before) {
+      await runUserModule(`${process.cwd()}/${config.before}`, config, 'before');
+    }
+
     await runTestsInBrowser(config, cachedContent, connections);
 
     if (config.watch) {
@@ -60,6 +61,10 @@ export default async function(config) {
       setupKeyboardEvents(config);
     }
 
+    if (config.before) {
+      await runUserModule(`${process.cwd()}/${config.before}`, config, 'before');
+    }
+
     await runTestsInNode(Object.keys(config.fsTree), config);
 
     if (config.watch) {

package/lib/setup/browser.js

@@ -11,7 +11,7 @@ export default async function setupBrowser(config = {
     setupWebServer(config, cachedContent),
     Puppeteer.launch({
       executablePath: process.env.CHROME_BIN || null,
-      headless: true,
+      headless: 'new',
       args: ['--no-sandbox', '--disable-gpu', '--remote-debugging-port=0', '--window-size=1440,900']
     }),
   ]);

package/lib/setup/web-server.js

@@ -194,14 +194,29 @@ function testRuntimeToInject(port, config) {
       });
       window.QUnit.done((details) => {
         if (window.IS_PUPPETEER) {
-          window.socket.send(JSON.stringify({ event: 'done', details: details, abort: window.abortQUnit }));
+          window.setTimeout(() => {
+            window.socket.send(JSON.stringify({ event: 'done', details: details, abort: window.abortQUnit }))
+          }, 50);
         }
         window.setTimeout(() => {
           window.testTimeout = ${config.timeout};
         }, 75);
       });
 
-      window.setTimeout(() => window.QUnit.start(), 10);
+      if ([1, 3].includes(window.socket.readyState)) {
+        return window.setTimeout(() => window.QUnit.start(), 10);
+      } else {
+        let connectionTrialCount = 0;
+        let connectionInterval = window.setInterval(() => {
+          if ([1, 3].includes(window.socket.readyState) || connectionTrialCount > 10) {
+            window.clearInterval(connectionInterval);
+
+            return window.setTimeout(() => window.QUnit.start(), 10);
+          }
+
+          connectionTrialCount = connectionTrialCount + 1;
+        }, 10);
+      }
     }
 
     setupQUnit();

package/lol.js

@@ -0,0 +1,4 @@
+import fs from 'node:fs/promises';
+
+console.log(await fs.lstat('./test-output.log'));
+

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "qunitx",
   "type": "module",
-  "version": "0.3.8",
+  "version": "0.4.1",
   "description": "Experimental improvements, suggestions for qunit CLI",
   "author": "Izel Nakri",
   "license": "MIT",
@@ -9,6 +9,9 @@
     "qunit",
     "qunit-plugin"
   ],
+  "engines": {
+    "node": ">=20.1.0"
+  },
   "main": "index.js",
   "bin": {
     "qunitx": "cli.js"
@@ -28,7 +31,7 @@
     "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",
-    "test": "node --test test/index.js",
+    "test": "node --test test/index.js | tee test-output.log",
     "test:old": "node_modules/.bin/mocha --require test/setup.js --bail --exit --check-leaks test/inputs test/commands test/flags/after-test.js test/flags/before-test.js -t=20000",
     "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"
@@ -37,13 +40,13 @@
     "@nanoexpress/middleware-static-serve": "^1.0.4",
     "cheerio": "^1.0.0-rc.10",
     "chokidar": "^3.5.3",
-    "esbuild": "^0.14.25",
+    "esbuild": "^0.17.18",
     "js-yaml": "^4.1.0",
     "kleur": "^4.1.5",
-    "nanoexpress": "^6.1.0",
+    "nanoexpress": "^6.2.1",
     "picomatch": "^2.3.1",
-    "puppeteer": "13.5.2",
-    "recursive-lookup": "1.0.0",
+    "puppeteer": "20.1.2",
+    "recursive-lookup": "1.1.0",
     "ts-node": "^10.7.0"
   },
   "devDependencies": {
@@ -52,11 +55,11 @@
     "express": "^4.17.3",
     "prettier": "^2.8.8",
     "qunit": "^2.18.0",
-    "qunitx": "^0.3.6",
+    "qunitx": "^0.3.8",
     "release-it": "^15.10.3"
   },
   "volta": {
-    "node": "19.9.0"
+    "node": "20.1.0"
   },
   "prettier": {
     "printWidth": 100,

package/shims/nodejs-assert.js

@@ -0,0 +1,28 @@
+import assert from 'node:assert';
+
+// TODO: write test cases for these
+export default {
+  async: assert.async,
+  deepEqual: assert.deepStrictEqual,
+  equal: assert.strictEqual,
+  expect: assert.expect,
+  false: assert.false,
+  notDeepEqual: assert.notDeepStrictEqual,
+  notEqual: assert.notEqual,
+  notOk(state, message) {
+    return assert.ok(!state, message);
+  },
+  notPropContains: assert.notPropContains,
+  notPropEqual: assert.notPropEqual,
+  notStrictEqual: assert.notStrictEqual,
+  ok: assert.ok,
+  propContains: assert.propContains,
+  pushResult: assert.pushResult,
+  rejects: assert.rejects,
+  step: assert.step,
+  strictEqual: assert.strictEqual,
+  throws: assert.throws,
+  timeout: assert.timeout,
+  true: assert.true,
+  verifySteps: assert.verifySteps
+};

package/shims/nodejs.js

@@ -0,0 +1,71 @@
+import { run, describe, it, before, after, beforeEach, afterEach } from 'node:test';
+import assert from './nodejs-assert.js';
+
+export const module = async function(moduleName, runtimeOptions, moduleContent) {
+  let targetRuntimeOptions = moduleContent ? runtimeOptions : {};
+  let targetModuleContent = moduleContent ? moduleContent : runtimeOptions;
+
+  return describe(moduleName, assignDefaultValues(targetRuntimeOptions, { concurrency: true }), async function() {
+    return await targetModuleContent({ before, after, beforeEach, afterEach }, {
+      moduleName,
+      options: runtimeOptions
+    });
+  });
+}
+
+export const test = async function(testName, runtimeOptions, testContent) {
+  let targetRuntimeOptions = testContent ? runtimeOptions : {};
+  let targetTestContent = testContent ? testContent : runtimeOptions;
+
+  return it(testName, assignDefaultValues(targetRuntimeOptions, { concurrency: true }), async function() {
+    return await targetTestContent(assert, { testName, options: runtimeOptions });
+  });
+}
+
+function assignDefaultValues(options, defaultValues) {
+  for (let key in defaultValues) {
+    if (options[key] === undefined) {
+      options[key] = defaultValues[key];
+    }
+  }
+}
+
+// NOTE: later maybe expose these as well:
+
+// import QUnit from './vendor/qunit.js';
+
+// QUnit.config.autostart = false;
+
+// export const isLocal = QUnit.isLocal;
+// export const on = QUnit.on;
+// export const test = QUnit.test;
+// export const skip = QUnit.skip;
+// export const start = QUnit.start;
+// export const is = QUnit.is;
+// export const extend = QUnit.extend;
+// export const stack = QUnit.stack;
+// export const onUnhandledRejection = QUnit.onUnhandledRejection;
+// export const assert = QUnit.assert;
+// export const dump = QUnit.dump;
+// export const done = QUnit.done;
+// export const testStart = QUnit.testStart;
+// export const moduleStart = QUnit.moduleStart;
+// export const version = QUnit.version;
+// export const module = QUnit.module;
+// export const todo = QUnit.todo;
+// export const only = QUnit.only;
+// export const config = QUnit.config;
+// export const objectType = QUnit.objectType;
+// export const load = QUnit.load;
+// export const onError = QUnit.onError;
+// export const pushFailure = QUnit.pushFailure;
+// export const equiv = QUnit.equiv;
+// export const begin = QUnit.begin;
+// export const log = QUnit.log;
+// export const testDone = QUnit.testDone;
+// export const moduleDone = QUnit.moduleDone;
+// export const diff = QUnit.diff;
+
+// export default Object.assign(QUnit, {
+//   QUnitxVersion: '0.0.1'
+// });