tape-six 0.12.0 → 0.12.1

package/README.md

@@ -32,6 +32,7 @@ If you are familiar with other TAP-based libraries you'll feel right at home.
 
 The most recent releases:
 
+* 0.12.1 *Minor Deno-related refactoring, fixed the way tests are triggered.*
 * 0.12.0 *Removed data to avoid serializing non-serializable objects.*
 * 0.11.0 *Minor improvements to the server: temporary redirects, a hyperlink to the web app.*
 * 0.10.0 *Refactored test runners, refactored stopping tests on failure, added JSONL reporter, fixed bugs.*

package/bin/tape6-node.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+
+import process from 'node:process';
+import {fileURLToPath} from 'node:url';
+
+import {resolveTests, resolvePatterns} from '../src/utils/config.js';
+
+import {getReporter, setReporter} from '../src/test.js';
+import State, {StopTest} from '../src/State.js';
+import TapReporter from '../src/TapReporter.js';
+import {selectTimer} from '../src/utils/timer.js';
+
+import TestWorker from '../src/node/TestWorker.js';
+
+const options = {},
+  rootFolder = process.cwd();
+
+let flags = '',
+  parallel = '',
+  files = [];
+
+const showSelf = () => {
+  const self = new URL(import.meta.url);
+  if (self.protocol === 'file:') {
+    console.log(fileURLToPath(self));
+  } else {
+    console.log(self);
+  }
+  process.exit(0);
+};
+
+const config = () => {
+  if (process.argv.includes('--self')) showSelf();
+
+  const optionNames = {
+    f: 'failureOnly',
+    t: 'showTime',
+    b: 'showBanner',
+    d: 'showData',
+    o: 'failOnce',
+    n: 'showAssertNumber',
+    c: 'hasColors'
+  };
+
+  let flagIsSet = false,
+    parIsSet = false;
+
+  for (let i = 2; i < process.argv.length; ++i) {
+    const arg = process.argv[i];
+    if (arg == '-f' || arg == '--flags') {
+      if (++i < process.argv.length) {
+        flags = process.argv[i];
+        flagIsSet = true;
+      }
+      continue;
+    }
+    if (arg == '-p' || arg == '--par') {
+      if (++i < process.argv.length) {
+        parallel = process.argv[i];
+        parIsSet = true;
+        if (!parallel || isNaN(parallel)) {
+          parallel = '';
+          parIsSet = false;
+        }
+      }
+      continue;
+    }
+    files.push(arg);
+  }
+
+  if (!flagIsSet) {
+    flags = process.env.TAPE6_FLAGS || flags;
+  }
+  for (let i = 0; i < flags.length; ++i) {
+    const option = flags[i].toLowerCase(),
+      name = optionNames[option];
+    if (typeof name == 'string') options[name] = option !== flags[i];
+  }
+
+  if (!parIsSet) {
+    parallel = process.env.TAPE6_PAR || parallel;
+  }
+  if (parallel) {
+    parallel = Math.max(0, +parallel);
+    if (parallel === Infinity) parallel = 0;
+  } else {
+    parallel = 0;
+  }
+  if (!parallel) parallel = navigator.hardwareConcurrency;
+};
+
+const init = async () => {
+  let reporter = getReporter();
+  if (!reporter) {
+    if (process.env.TAPE6_JSONL) {
+      const JSONLReporter = (await import('../src/JSONLReporter.js')).default,
+        jsonlReporter = new JSONLReporter(options);
+      reporter = jsonlReporter.report.bind(jsonlReporter);
+    } else if (!process.env.TAPE6_TAP) {
+      const TTYReporter = (await import('../src/TTYReporter.js')).default,
+        ttyReporter = new TTYReporter(options);
+      ttyReporter.testCounter = -2;
+      ttyReporter.technicalDepth = 1;
+      reporter = ttyReporter.report.bind(ttyReporter);
+    }
+    if (!reporter) {
+      const tapReporter = new TapReporter({useJson: true});
+      reporter = tapReporter.report.bind(tapReporter);
+    }
+    setReporter(reporter);
+  }
+
+  if (files.length) {
+    files = await resolvePatterns(rootFolder, files);
+  } else {
+    files = await resolveTests(rootFolder, 'node');
+  }
+};
+
+const safeEmit = rootState => event => {
+  try {
+    rootState.emit(event);
+  } catch (error) {
+    if (!(error instanceof StopTest)) throw error;
+  }
+};
+
+const main = async () => {
+  config();
+  await init();
+  await selectTimer();
+
+  process.on('uncaughtException', (error, origin) =>
+    console.error('UNHANDLED ERROR:', origin, error)
+  );
+
+  const rootState = new State(null, {callback: getReporter(), failOnce: options.failOnce}),
+    worker = new TestWorker(safeEmit(rootState), parallel, options);
+
+  rootState.emit({type: 'test', test: 0, time: rootState.timer.now()});
+
+  await new Promise(resolve => {
+    worker.done = () => resolve();
+    worker.execute(files);
+  });
+
+  rootState.emit({
+    type: 'end',
+    test: 0,
+    time: rootState.timer.now(),
+    fail: rootState.failed > 0,
+    data: rootState
+  });
+
+  process.exit(rootState.failed > 0 ? 1 : 0);
+};
+
+main().catch(error => console.error('ERROR:', error));

package/bin/tape6-runner.js

@@ -5,11 +5,12 @@ import {fileURLToPath} from 'node:url';
 
 const requestedRuntime =
   {
-    node: 'tape6.js',
+    node: 'tape6-node.js',
     deno: 'tape6-deno.js',
     bun: 'tape6-bun.js',
     server: 'tape6-server.js',
-    runner: 'tape6-runner.js'
+    runner: 'tape6-runner.js',
+    main: 'tape6.js'
   }[process.argv[2]];
 
 const runtime = requestedRuntime || 'tape6.js',

package/bin/tape6.js

@@ -3,156 +3,21 @@
 import process from 'node:process';
 import {fileURLToPath} from 'node:url';
 
-import {resolveTests, resolvePatterns} from '../src/utils/config.js';
-
-import {getReporter, setReporter} from '../src/test.js';
-import State, {StopTest} from '../src/State.js';
-import TapReporter from '../src/TapReporter.js';
-import {selectTimer} from '../src/utils/timer.js';
-
-import TestWorker from '../src/node/TestWorker.js';
-
-const options = {},
-  rootFolder = process.cwd();
-
-let flags = '',
-  parallel = '',
-  files = [];
-
-const showSelf = () => {
+if (process.argv.includes('--self')) {
   const self = new URL(import.meta.url);
   if (self.protocol === 'file:') {
     console.log(fileURLToPath(self));
   } else {
     console.log(self);
   }
-  process.exit(0);
-};
-
-const config = () => {
-  if (process.argv.includes('--self')) showSelf();
-
-  const optionNames = {
-    f: 'failureOnly',
-    t: 'showTime',
-    b: 'showBanner',
-    d: 'showData',
-    o: 'failOnce',
-    n: 'showAssertNumber',
-    c: 'hasColors'
-  };
-
-  let flagIsSet = false,
-    parIsSet = false;
-
-  for (let i = 2; i < process.argv.length; ++i) {
-    const arg = process.argv[i];
-    if (arg == '-f' || arg == '--flags') {
-      if (++i < process.argv.length) {
-        flags = process.argv[i];
-        flagIsSet = true;
-      }
-      continue;
-    }
-    if (arg == '-p' || arg == '--par') {
-      if (++i < process.argv.length) {
-        parallel = process.argv[i];
-        parIsSet = true;
-        if (!parallel || isNaN(parallel)) {
-          parallel = '';
-          parIsSet = false;
-        }
-      }
-      continue;
-    }
-    files.push(arg);
-  }
-
-  if (!flagIsSet) {
-    flags = process.env.TAPE6_FLAGS || flags;
-  }
-  for (let i = 0; i < flags.length; ++i) {
-    const option = flags[i].toLowerCase(),
-      name = optionNames[option];
-    if (typeof name == 'string') options[name] = option !== flags[i];
-  }
-
-  if (!parIsSet) {
-    parallel = process.env.TAPE6_PAR || parallel;
-  }
-  if (parallel) {
-    parallel = Math.max(0, +parallel);
-    if (parallel === Infinity) parallel = 0;
+} else {
+  if (typeof Deno == 'object') {
+    await import('./tape6-deno.js');
+  } else if (typeof Bun == 'object') {
+    await import('./tape6-bun.js');
+  } else if (typeof process == 'object' && process.versions?.node) {
+    await import('./tape6-node.js');
   } else {
-    parallel = 0;
+    throw new Error('tape6 is not supported in this environment');
   }
-  if (!parallel) parallel = navigator.hardwareConcurrency;
-};
-
-const init = async () => {
-  let reporter = getReporter();
-  if (!reporter) {
-    if (process.env.TAPE6_JSONL) {
-      const JSONLReporter = (await import('../src/JSONLReporter.js')).default,
-        jsonlReporter = new JSONLReporter(options);
-      reporter = jsonlReporter.report.bind(jsonlReporter);
-    } else if (!process.env.TAPE6_TAP) {
-      const TTYReporter = (await import('../src/TTYReporter.js')).default,
-        ttyReporter = new TTYReporter(options);
-      ttyReporter.testCounter = -2;
-      ttyReporter.technicalDepth = 1;
-      reporter = ttyReporter.report.bind(ttyReporter);
-    }
-    if (!reporter) {
-      const tapReporter = new TapReporter({useJson: true});
-      reporter = tapReporter.report.bind(tapReporter);
-    }
-    setReporter(reporter);
-  }
-
-  if (files.length) {
-    files = await resolvePatterns(rootFolder, files);
-  } else {
-    files = await resolveTests(rootFolder, 'node');
-  }
-};
-
-const safeEmit = rootState => event => {
-  try {
-    rootState.emit(event);
-  } catch (error) {
-    if (!(error instanceof StopTest)) throw error;
-  }
-};
-
-const main = async () => {
-  config();
-  await init();
-  await selectTimer();
-
-  process.on('uncaughtException', (error, origin) =>
-    console.error('UNHANDLED ERROR:', origin, error)
-  );
-
-  const rootState = new State(null, {callback: getReporter(), failOnce: options.failOnce}),
-    worker = new TestWorker(safeEmit(rootState), parallel, options);
-
-  rootState.emit({type: 'test', test: 0, time: rootState.timer.now()});
-
-  await new Promise(resolve => {
-    worker.done = () => resolve();
-    worker.execute(files);
-  });
-
-  rootState.emit({
-    type: 'end',
-    test: 0,
-    time: rootState.timer.now(),
-    fail: rootState.failed > 0,
-    data: rootState
-  });
-
-  process.exit(rootState.failed > 0 ? 1 : 0);
-};
-
-main().catch(error => console.error('ERROR:', error));
+}

package/index.js

@@ -5,7 +5,8 @@ import {
   getReporter,
   setReporter,
   runTests,
-  getConfiguredFlag
+  getConfiguredFlag,
+  registerNotifyCallback
 } from './src/test.js';
 import defer from './src/utils/defer.js';
 import State from './src/State.js';
@@ -21,9 +22,7 @@ const optionNames = {
   c: 'hasColors'
 };
 
-defer(async () => {
-  if (getConfiguredFlag()) return; // bail out => somebody else is running the show
-
+const init = async () => {
   const isNode = typeof process == 'object' && process.versions?.node,
     isDeno = typeof Deno == 'object',
     isBun = typeof Bun == 'object',
@@ -100,9 +99,19 @@ defer(async () => {
     setReporter(reporter);
   }
 
-  const rootState = new State(null, {callback: reporter, failOnce: options.failOnce});
+  return {reporter, options};
+};
+
+let settings = null;
+
+const testCallback = async () => {
+  if (!settings) settings = await init();
+
+  const {reporter, options} = settings,
+    rootState = new State(null, {callback: reporter, failOnce: options.failOnce});
 
   rootState.emit({type: 'test', test: 0, time: rootState.timer.now()});
+
   for (;;) {
     const tests = getTests();
     if (!tests.length) break;
@@ -111,6 +120,7 @@ defer(async () => {
     if (!canContinue) break;
     await new Promise(resolve => defer(resolve));
   }
+
   rootState.emit({
     type: 'end',
     test: 0,
@@ -119,15 +129,22 @@ defer(async () => {
     data: rootState
   });
 
-  if (isDeno) {
-    Deno.exit(rootState.failed > 0 ? 1 : 0);
-  } else if (isBun) {
-    process.exit(rootState.failed > 0 ? 1 : 0);
-  } else if (isNode) {
-    process.exit(rootState.failed > 0 ? 1 : 0);
+  if (typeof Deno == 'object') {
+    rootState.failed > 0 && Deno.exit(1);
+  } else if (typeof Bun == 'object') {
+    rootState.failed > 0 && process.exit(1);
+  } else if (typeof process == 'object' && process.versions?.node) {
+    rootState.failed > 0 && process.exit(1);
   } else if (typeof __tape6_reportResults == 'function') {
     __tape6_reportResults(rootState.failed > 0 ? 'failure' : 'success');
   }
-});
+
+  registerNotifyCallback(testCallback); // register self again
+};
+
+if (!getConfiguredFlag()) {
+  // if nobody is running the show
+  registerNotifyCallback(testCallback);
+}
 
 export default test;

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "tape-six",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "description": "TAP the test harness for the modern JavaScript (ES6).",
   "type": "module",
   "main": "index.js",
   "module": "index.js",
   "exports": {
-    ".": "./index.js"
+    ".": "./index.js",
+    "./bin/*": "./bin/*"
   },
   "bin": {
     "tape6": "bin/tape6.js",
@@ -62,6 +63,6 @@
     }
   },
   "devDependencies": {
-    "puppeteer": "^23.4.0"
+    "puppeteer": "^23.4.1"
   }
 }

package/src/bun/TestWorker.js

@@ -22,12 +22,7 @@ export default class TestWorker extends EventServer {
       try {
         this.report(id, msg);
       } catch (error) {
-        if (error instanceof StopTest) {
-          console.error('# immediate StopTest:', error.message || 'StopTest is activated');
-          worker.terminate();
-          process.exit(1);
-        }
-        throw error;
+        if (!(error instanceof StopTest)) throw error;
       }
       if (msg.type === 'end' && msg.test === 0) {
         this.close(id);

package/src/deno/TestWorker.js

@@ -26,12 +26,7 @@ export default class TestWorker extends EventServer {
       try {
         this.report(id, msg);
       } catch (error) {
-        if (error instanceof StopTest) {
-          console.error('# immediate StopTest:', error.message || 'StopTest is activated');
-          worker.terminate();
-          Deno.exit(1);
-        }
-        throw error;
+        if (!(error instanceof StopTest)) throw error;
       }
       if (msg.type === 'end' && msg.test === 0) {
         this.close(id);

package/src/test.js

@@ -4,15 +4,25 @@ import Tester from './Tester.js';
 import Deferred from './utils/Deferred.js';
 import timeout from './utils/timeout.js';
 import {formatTime} from './utils/formatters.js';
+import defer from './utils/defer.js';
 
 let tests = [],
   reporter = null,
   testCounter = 0,
-  isConfigured = false;
+  isConfigured = false,
+  notifyCallback = null;
 
 export const getConfiguredFlag = () => isConfigured;
 export const setConfiguredFlag = value => (isConfigured = !!value);
 
+export const registerNotifyCallback = callback => {
+  if (tests.length) {
+    defer(callback);
+  } else {
+    notifyCallback = callback;
+  }
+};
+
 const processArgs = (name, options, testFn) => {
   // normalize arguments
   if (typeof name == 'function') {
@@ -55,7 +65,11 @@ export const test = async (name, options, testFn) => {
     isTimerSet = true;
   }
   const deferred = new Deferred();
-  tests.push({options, deferred});
+  if (tests.push({options, deferred}) === 1 && notifyCallback) {
+    defer(notifyCallback);
+    notifyCallback = null;
+  }
+
   return deferred.promise;
 };