supertape 12.0.4 → 12.0.6

package/ChangeLog

@@ -1,3 +1,16 @@
+2026.01.08, v12.0.6
+
+feature:
+- 563cd9e supertape: --dry-run
+
+2026.01.08, v12.0.5
+
+fix:
+- f11518b supertape: get back fakeEmitter
+
+feature:
+- 6f60aff supertape: get rid of mock-require
+
 2026.01.08, v12.0.4
 
 feature:

package/lib/cli/parse-args.js

@@ -33,6 +33,7 @@ const getYargsOptions = () => {
             'check-scopes',
             'check-assertions-count',
             'worker',
+            'dry-run',
         ],
         alias: {
             version: 'v',

package/lib/cli.js

@@ -159,10 +159,6 @@ async function _cli(overrides) {
         workerFormatter,
     });
     
-    const stream = await supertape.createStream();
-    
-    stream.pipe(stdout);
-    
     const files = removeDuplicates(allFiles);
     
     filesCount(files.length);
@@ -170,6 +166,9 @@ async function _cli(overrides) {
     if (!files.length)
         return OK;
     
+    const stream = await supertape.createStream();
+    stream.pipe(stdout);
+    
     const resolvedNames = [];
     
     // always resolve before import for windows
@@ -177,8 +176,9 @@ async function _cli(overrides) {
         resolvedNames.push(pathToFileURL(resolvePath(cwd, file)));
     }
     
-    for (const resolved of resolvedNames)
-        await import(resolved);
+    if (!args.dryRun)
+        for (const resolved of resolvedNames)
+            await import(resolved);
     
     const [result] = await once(supertape.run(), 'end');
     

package/lib/emitter.mjs

@@ -0,0 +1,61 @@
+import {stdout} from 'node:process';
+import {EventEmitter} from 'node:events';
+import runTests from './run-tests.js';
+
+export const createEmitter = (overrides = {}) => {
+    const {
+        quiet,
+        stream = stdout,
+        format,
+        getOperators,
+        isStop,
+        readyFormatter,
+        workerFormatter,
+        createFormatter,
+        loop,
+        isDebug,
+    } = overrides;
+    
+    const tests = [];
+    const emitter = new EventEmitter();
+    
+    emitter.on('test', (message, fn, {skip, only, extensions, at, validations, timeout}) => {
+        tests.push({
+            message,
+            fn,
+            skip,
+            only,
+            extensions,
+            at,
+            validations,
+            timeout,
+        });
+    });
+    
+    emitter.on('loop', () => {
+        loop({
+            emitter,
+            tests,
+        });
+    });
+    
+    emitter.on('run', async () => {
+        const {harness, formatter} = readyFormatter || await createFormatter(format);
+        
+        if (!quiet)
+            harness.pipe(stream);
+        
+        const operators = await getOperators();
+        
+        const result = await runTests(tests, {
+            formatter: workerFormatter || formatter,
+            operators,
+            isStop,
+            isDebug,
+        });
+        
+        emitter.emit('end', result);
+    });
+    
+    return emitter;
+};

package/lib/is-debug.js

@@ -3,4 +3,4 @@
 const process = require('node:process');
 const argv = process.execArgv.join();
 
-module.exports = argv.includes('inspect') || argv.includes('debug');
+module.exports = () => argv.includes('inspect') || argv.includes('debug');

package/lib/run-tests.js

@@ -3,7 +3,7 @@
 const fullstore = require('fullstore');
 const wraptile = require('wraptile');
 const {tryToCatch} = require('try-to-catch');
-const isDebug = require('./is-debug');
+const _isDebug = require('./is-debug');
 
 const {createValidator} = require('./validator');
 
@@ -17,10 +17,10 @@ const getInitOperators = async () => await import('./operators.mjs');
 
 const DEBUG_TIME = 3000 * 1000;
 
-const doTimeout = (time, value) => {
+const doTimeout = (time, value, {isDebug}) => {
     let stop;
     
-    if (isDebug)
+    if (isDebug())
         time = DEBUG_TIME;
     
     const promise = new Promise((resolve) => {
@@ -31,7 +31,14 @@ const doTimeout = (time, value) => {
     return [promise, stop];
 };
 
-module.exports = async (tests, {formatter, operators, isStop}) => {
+module.exports = async (tests, overrides = {}) => {
+    const {
+        formatter,
+        operators,
+        isStop,
+        isDebug = _isDebug,
+    } = overrides;
+    
     const onlyTests = tests.filter(isOnly);
     
     if (onlyTests.length)
@@ -40,6 +47,7 @@ module.exports = async (tests, {formatter, operators, isStop}) => {
             operators,
             skipped: tests.length - onlyTests.length,
             isStop,
+            isDebug,
         });
     
     const notSkippedTests = tests.filter(notSkip);
@@ -50,10 +58,19 @@ module.exports = async (tests, {formatter, operators, isStop}) => {
         operators,
         skipped,
         isStop,
+        isDebug,
     });
 };
 
-async function runTests(tests, {formatter, operators, skipped, isStop}) {
+async function runTests(tests, overrides = {}) {
+    const {
+        formatter,
+        operators,
+        skipped,
+        isStop,
+        isDebug,
+    } = overrides;
+    
     const count = fullstore(0);
     const failed = fullstore(0);
     const passed = fullstore(0);
@@ -95,7 +112,7 @@ async function runTests(tests, {formatter, operators, skipped, isStop}) {
             getValidationMessage,
             validations,
             timeout,
-            
+            isDebug,
             extensions: {
                 ...operators,
                 ...extensions,
@@ -134,6 +151,7 @@ async function runOneTest(options) {
         getValidationMessage,
         validations,
         timeout,
+        isDebug,
     } = options;
     
     const isReturn = fullstore(false);
@@ -162,7 +180,10 @@ async function runOneTest(options) {
     });
     
     if (!isReturn()) {
-        const [timer, stopTimer] = doTimeout(timeout, ['timeout']);
+        const [timer, stopTimer] = doTimeout(timeout, ['timeout'], {
+            isDebug,
+        });
+        
         const [error] = await Promise.race([tryToCatch(fn, t), timer]);
         
         stopTimer();

package/lib/supertape.js

@@ -1,7 +1,7 @@
 'use strict';
 
-const process = require('node:process');
 const {EventEmitter} = require('node:events');
+const process = require('node:process');
 const {PassThrough} = require('node:stream');
 
 const stub = require('@cloudcmd/stub');
@@ -12,20 +12,32 @@ const {maybeOnce} = require('./maybe-once');
 const options = require('../supertape.json');
 
 const {getAt, setValidations} = require('./validator');
-const runTests = require('./run-tests');
-const _createFormatter = require('./formatter').createFormatter;
-const createFormatter = once(_createFormatter);
-
-const createEmitter = once(_createEmitter);
 
+const {createEmitter: _createEmitter} = require('./emitter.mjs');
+const _createFormatter = require('./formatter').createFormatter;
+const {env} = process;
 const {assign} = Object;
-const {stdout} = process;
+const createEmitter = once(_createEmitter);
+const createFormatter = once(_createFormatter);
 
-// 5ms ought to be enough for anybody
-const {
-    SUPERTAPE_LOAD_LOOP_TIMEOUT = 5,
-    SUPERTAPE_TIMEOUT = 3000,
-} = process.env;
+const createExtend = (test) => (extensions) => {
+    const extendedTest = getExtend(test, extensions);
+    
+    assign(extendedTest, {
+        test: extendedTest,
+        stub,
+    });
+    
+    extendedTest.only = getExtend(test, extensions, {
+        only: true,
+    });
+    
+    extendedTest.skip = getExtend(test, extensions, {
+        skip: true,
+    });
+    
+    return extendedTest;
+};
 
 let mainEmitter;
 
@@ -36,7 +48,7 @@ const getOperators = once(async () => {
     return await loadOperators(operators);
 });
 
-const defaultOptions = {
+const getDefaultOptions = () => ({
     skip: false,
     only: false,
     extensions: {},
@@ -49,52 +61,8 @@ const defaultOptions = {
     checkIfEnded: true,
     checkAssertionsCount: true,
     checkScopes: true,
-    timeout: SUPERTAPE_TIMEOUT,
-};
-
-function _createEmitter({quiet, stream = stdout, format, getOperators, isStop, readyFormatter, workerFormatter}) {
-    const tests = [];
-    const emitter = new EventEmitter();
-    
-    emitter.on('test', (message, fn, {skip, only, extensions, at, validations, timeout}) => {
-        tests.push({
-            message,
-            fn,
-            skip,
-            only,
-            extensions,
-            at,
-            validations,
-            timeout,
-        });
-    });
-    
-    emitter.on('loop', () => {
-        loop({
-            emitter,
-            tests,
-        });
-    });
-    
-    emitter.on('run', async () => {
-        const {harness, formatter} = readyFormatter || await createFormatter(format);
-        
-        if (!quiet)
-            harness.pipe(stream);
-        
-        const operators = await getOperators();
-        
-        const result = await runTests(tests, {
-            formatter: workerFormatter || formatter,
-            operators,
-            isStop,
-        });
-        
-        emitter.emit('end', result);
-    });
-    
-    return emitter;
-}
+    timeout: env.SUPERTAPE_TIMEOUT || 3000,
+});
 
 module.exports = test;
 
@@ -115,15 +83,23 @@ const createStream = async () => {
 
 module.exports.createStream = createStream;
 module.exports.createTest = async (testOptions = {}) => {
-    const {format = 'tap', formatter} = testOptions;
+    const {
+        format = 'tap',
+        formatter,
+        isDebug,
+    } = testOptions;
+    
     const readyFormatter = await _createFormatter(formatter || format);
     
     const stream = new PassThrough();
     const emitter = _createEmitter({
-        ...defaultOptions,
+        ...getDefaultOptions(),
         ...testOptions,
         readyFormatter,
         stream,
+        loop,
+        createFormatter,
+        isDebug,
     });
     
     const fn = (message, fn, options = {}) => {
@@ -137,6 +113,7 @@ module.exports.createTest = async (testOptions = {}) => {
     assign(fn, {
         stream,
         ...test,
+        extend: createExtend(fn),
         test: fn,
         run: () => {
             emitter.emit('run');
@@ -146,7 +123,7 @@ module.exports.createTest = async (testOptions = {}) => {
     return fn;
 };
 
-function test(message, fn, options = {}) {
+function test(message, fn, options = {}, overrides = {}) {
     const {
         run,
         quiet,
@@ -163,11 +140,13 @@ function test(message, fn, options = {}) {
         workerFormatter,
         timeout,
     } = {
-        ...defaultOptions,
+        ...getDefaultOptions(),
         ...initedOptions,
         ...options,
     };
     
+    const {StackTracey} = overrides;
+    
     const validations = {
         checkDuplicates,
         checkScopes,
@@ -177,13 +156,18 @@ function test(message, fn, options = {}) {
     
     setValidations(validations);
     
-    const at = getAt();
+    const at = getAt({
+        StackTracey,
+    });
+    
     const emitter = options.emitter || createEmitter({
+        loop,
         format,
         quiet,
         getOperators,
         isStop,
         workerFormatter,
+        createFormatter,
     });
     
     mainEmitter = emitter;
@@ -217,7 +201,7 @@ test.only = (message, fn, options) => {
     });
 };
 
-const getExtend = (extensions, type) => (message, fn, options) => {
+const getExtend = (test, extensions, type) => (message, fn, options) => {
     return test(message, fn, {
         extensions,
         ...options,
@@ -228,28 +212,16 @@ const getExtend = (extensions, type) => (message, fn, options) => {
 test.stub = stub;
 test.test = test;
 
-test.extend = (extensions) => {
-    const extendedTest = getExtend(extensions);
-    
-    assign(extendedTest, {
-        test: extendedTest,
-        stub,
-    });
-    
-    extendedTest.only = getExtend(extensions, {
-        only: true,
-    });
-    
-    extendedTest.skip = getExtend(extensions, {
-        skip: true,
-    });
-    
-    return extendedTest;
-};
+test.extend = createExtend(test);
 
 const loop = maybeOnce(({emitter, tests}) => {
     let previousCount = 0;
     
+    // 5ms ought to be enough for anybody
+    const {
+        SUPERTAPE_LOAD_LOOP_TIMEOUT = 5,
+    } = env;
+    
     (function loop() {
         if (previousCount === tests.length) {
             emitter.emit('run');
@@ -262,7 +234,23 @@ const loop = maybeOnce(({emitter, tests}) => {
     })();
 });
 
-module.exports.run = () => {
+module.exports.run = ({fake} = {}) => {
+    if (!mainEmitter || fake)
+        return fakeEmitter();
+    
     mainEmitter.emit('loop');
+    
     return mainEmitter;
 };
+
+function fakeEmitter() {
+    const emitter = new EventEmitter();
+    
+    process.nextTick(() => {
+        emitter.emit('end', {
+            failed: 0,
+        });
+    });
+    
+    return emitter;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supertape",
-  "version": "12.0.4",
+  "version": "12.0.6",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "📼 Supertape simplest high speed test runner with superpowers",
   "homepage": "http://github.com/coderaiser/supertape",