supertape 6.7.4 → 6.9.0

package/ChangeLog

@@ -1,3 +1,32 @@
+2021.09.25, v6.9.0
+
+feature:
+- (supertape) fail when couple t.end() operators found
+
+
+2021.09.25, v6.8.2
+
+feature:
+- (supertape) check that no assertions called after t.end() in async operators
+
+
+2021.09.24, v6.8.1
+
+fix:
+- (supertape) ability to disable check-assertions-count per test
+
+
+2021.09.24, v6.8.0
+
+fix:
+- (supertape) check that no assertions called after t.end()
+
+feature:
+- (supertape) add support of check assertions count
+- (@supertape/operator-stub) add calledBefore, calledAfter
+- (@supertape/operator-stub) notCalled: add additional check: called with args
+
+
 2021.09.20, v6.7.4
 
 fix:

package/README.md

@@ -46,6 +46,8 @@ Options
    -v, --version               output version information and exit
    -f, --format                use a specific output format - default: progress-bar/tap on CI
    -r, --require               require module
+   --check-scopes              check that messages contains scope: 'scope: message'
+   --check-assertions-count    check that assertion count is no more then 1
    --no-check-duplicates       do not check messages for duplicates
 ```
 
@@ -53,7 +55,8 @@ Options
 
 - `SUPERTAPE_TIMEOUT` - timeout for long running processes;
 - `SUPERTAPE_CHECK_DUPLICATES` - toggle check duplicates;
-- `SUPERTAPE_CHECK_SCOPES` - check that test message has a scope: `scope: subject`
+- `SUPERTAPE_CHECK_SCOPES` - check that test message has a scope: `scope: subject`;
+- `SUPERTAPE_CHECK_ASSERTIONS_COUNT` - check that assertion count is no more then 1;
 
 ```js
 test('tape: error', (t) => {

package/help.json

@@ -4,5 +4,6 @@
     "-f, --format               ": "use a specific output format - default: progress-bar/tap on CI",
     "-r, --require              ": "require module",
     "--check-scopes             ": "check that messages contains scope: 'scope: message'",
+    "--check-assertions-count   ": "check that assertion count is no more then 1",
     "--no-check-duplicates      ": "do not check messages for duplicates"
 }

package/lib/cli.js

@@ -33,6 +33,7 @@ const filesCount = fullstore(0);
 const {
     SUPERTAPE_CHECK_DUPLICATES = '1',
     SUPERTAPE_CHECK_SCOPES = '0',
+    SUPERTAPE_CHECK_ASSERTIONS_COUNT = '0',
 } = process.env;
 
 module.exports = async ({argv, cwd, stdout, stderr, exit}) => {
@@ -89,6 +90,7 @@ const yargsOptions = {
         'help',
         'check-duplicates',
         'check-scopes',
+        'check-assertions-count',
     ],
     alias: {
         version: 'v',
@@ -97,12 +99,14 @@ const yargsOptions = {
         require: 'r',
         checkDuplicates: 'd',
         checkScopes: 's',
+        checkAssertionsCount: 'a',
     },
     default: {
         format: 'progress-bar',
         require: [],
         checkDuplicates: SUPERTAPE_CHECK_DUPLICATES !== '0',
         checkScopes: SUPERTAPE_CHECK_SCOPES === '1',
+        checkAssertionsCount: SUPERTAPE_CHECK_ASSERTIONS_COUNT === '1',
     },
 };
 
@@ -148,6 +152,7 @@ async function cli({argv, cwd, stdout, isStop}) {
         format,
         checkDuplicates,
         checkScopes,
+        checkAssertionsCount,
     } = args;
     
     supertape.init({
@@ -157,6 +162,7 @@ async function cli({argv, cwd, stdout, isStop}) {
         isStop,
         checkDuplicates,
         checkScopes,
+        checkAssertionsCount,
     });
     
     supertape.createStream().pipe(stdout);

package/lib/operators.mjs

@@ -14,7 +14,6 @@ const isFn = (a) => typeof a === 'function';
 const isStr = (a) => typeof a === 'string';
 const isObj = (a) => typeof a === 'object';
 
-// backward compatibility or maybe formatters support
 const end = () => {};
 
 const ok = (actual, message = 'should be truthy') => ({
@@ -165,16 +164,68 @@ const initOperator = (runnerState) => (name) => {
     
     if (isAsync(fn))
         return async (...a) => {
+            const [valid, end] = validateEnd({
+                name,
+                operators,
+                runnerState,
+            });
+            
+            if (!valid)
+                return end;
+            
             const testState = await fn(...a);
             return run(name, runnerState, testState);
         };
     
     return (...a) => {
+        const [valid, end] = validateEnd({
+            name,
+            operators,
+            runnerState,
+        });
+        
+        if (!valid)
+            return end;
+        
         const testState = fn(...a);
         return run(name, runnerState, testState);
     };
 };
 
+const VALID = true;
+const INVALID = false;
+
+function validateEnd({name, operators, runnerState}) {
+    const {
+        isEnded,
+        incAssertionsCount,
+    } = runnerState;
+    
+    incAssertionsCount();
+    
+    if (name === 'end' && isEnded())
+        return [INVALID, run(
+            'fail',
+            runnerState,
+            operators.fail(`Cannot use a couple 't.end()' operators in one test`),
+        )];
+    
+    if (name === 'end') {
+        isEnded(true);
+        return [INVALID, end];
+    }
+    
+    if (isEnded()) {
+        return [INVALID, run(
+            'fail',
+            runnerState,
+            operators.fail(`Cannot run assertions after 't.end()' called`),
+        )];
+    }
+    
+    return [VALID];
+}
+
 const validate = (a) => {
     if (isFn(a))
         return fail('looks like operator returns function, it will always fail');
@@ -223,13 +274,15 @@ function run(name, {formatter, count, incCount, incPassed, incFailed}, testState
     });
 }
 
-export const initOperators = ({formatter, count, incCount, incPassed, incFailed, extensions}) => {
+export const initOperators = ({formatter, count, incCount, incPassed, incFailed, incAssertionsCount, isEnded, extensions}) => {
     const operator = initOperator({
         formatter,
         count,
         incCount,
         incPassed,
         incFailed,
+        isEnded,
+        incAssertionsCount,
     });
     
     const extendedOperators = {};
@@ -251,7 +304,7 @@ export const initOperators = ({formatter, count, incCount, incPassed, incFailed,
         comment: comment({formatter}),
         match: operator('match'),
         notMatch: operator('notMatch'),
-        end,
+        end: operator('end'),
         
         ...extendedOperators,
     };

package/lib/run-tests.js

@@ -3,24 +3,16 @@
 const fullstore = require('fullstore');
 const wraptile = require('wraptile');
 const tryToCatch = require('try-to-catch');
-const once = require('once');
 const isDebug = require('./is-debug');
 
 const {createValidator} = require('./validator');
 
 const inc = wraptile((store) => store(store() + 1));
-
 const isOnly = ({only}) => only;
-
 const isSkip = ({skip}) => skip;
-
 const notSkip = ({skip}) => !skip;
 
-const getInitOperators = once(async () => {
-    const {initOperators} = await import('./operators.mjs');
-    
-    return initOperators;
-});
+const getInitOperators = async () => await import('./operators.mjs');
 
 const {
     SUPERTAPE_TIMEOUT = 3000,
@@ -83,7 +75,7 @@ async function runTests(tests, {formatter, operators, skiped, isStop}) {
         tests,
     });
     
-    for (const {fn, message, extensions, at} of tests) {
+    for (const {fn, message, extensions, at, validations} of tests) {
         if (wasStop())
             break;
         
@@ -104,6 +96,7 @@ async function runTests(tests, {formatter, operators, skiped, isStop}) {
             incFailed,
             incPassed,
             getValidationMessage,
+            validations,
             
             extensions: {
                 ...operators,
@@ -127,12 +120,18 @@ async function runTests(tests, {formatter, operators, skiped, isStop}) {
     };
 }
 
-async function runOneTest({message, at, fn, extensions, formatter, count, total, failed, incCount, incPassed, incFailed, getValidationMessage}) {
+async function runOneTest({message, at, fn, extensions, formatter, count, total, failed, incCount, incPassed, incFailed, getValidationMessage, validations}) {
+    const isReturn = fullstore(false);
+    const assertionsCount = fullstore(0);
+    const isEnded = fullstore(false);
+    const incAssertionsCount = inc(assertionsCount);
+    
     formatter.emit('test', {
         test: message,
     });
     
-    const initOperators = await getInitOperators();
+    const {initOperators} = await getInitOperators();
+    const {checkIfEnded} = validations;
     
     const t = initOperators({
         formatter,
@@ -140,16 +139,35 @@ async function runOneTest({message, at, fn, extensions, formatter, count, total,
         incCount,
         incPassed,
         incFailed,
+        assertionsCount,
+        incAssertionsCount,
+        isEnded,
         extensions,
+        checkIfEnded,
     });
     
-    const [timer, stopTimer] = timeout(SUPERTAPE_TIMEOUT, ['timeout']);
-    const [error] = await Promise.race([tryToCatch(fn, t), timer]);
-    stopTimer();
+    if (!isReturn()) {
+        const [timer, stopTimer] = timeout(SUPERTAPE_TIMEOUT, ['timeout']);
+        const [error] = await Promise.race([tryToCatch(fn, t), timer]);
+        stopTimer();
+        isEnded(false);
+        
+        if (error) {
+            t.fail(error, at);
+            t.end();
+            isReturn(true);
+        }
+    }
     
-    if (error) {
-        t.fail(error, at);
-        t.end();
+    if (!isReturn()) {
+        const [validationMessage, atLine] = getValidationMessage(message, {
+            assertionsCount: assertionsCount(),
+        });
+        
+        if (atLine) {
+            t.fail(validationMessage, atLine);
+            t.end();
+        }
     }
     
     formatter.emit('test:end', {
@@ -158,11 +176,4 @@ async function runOneTest({message, at, fn, extensions, formatter, count, total,
         test: message,
         failed: failed(),
     });
-    
-    const [validationMessage, atLine] = getValidationMessage(message);
-    
-    if (atLine) {
-        t.fail(validationMessage, atLine);
-        t.end();
-    }
 }

package/lib/supertape.js

@@ -35,6 +35,8 @@ const defaultOptions = {
     getOperators,
     isStop: () => false,
     checkDuplicates: true,
+    checkIfEnded: true,
+    checkAssertionsCount: false,
     checkScopes: false,
 };
 
@@ -111,6 +113,8 @@ function test(message, fn, options = {}) {
         isStop,
         checkDuplicates,
         checkScopes,
+        checkAssertionsCount,
+        checkIfEnded,
     } = {
         ...defaultOptions,
         ...initedOptions,
@@ -120,6 +124,8 @@ function test(message, fn, options = {}) {
     const validations = {
         checkDuplicates,
         checkScopes,
+        checkAssertionsCount,
+        checkIfEnded,
     };
     
     setValidations(validations);

package/lib/validator.js

@@ -14,11 +14,13 @@ const processedList = new Set();
 const validations = {
     checkDuplicates: true,
     checkScopes: false,
+    checkAssertionsCount: true,
 };
 
 const validators = {
     checkDuplicates,
     checkScopes,
+    checkAssertionsCount,
 };
 
 const {
@@ -33,16 +35,17 @@ const findByMessage = (msg, tests) => {
     return filtered;
 };
 
-module.exports.setValidations = ({checkDuplicates, checkScopes}) => {
+module.exports.setValidations = ({checkDuplicates, checkScopes, checkAssertionsCount}) => {
     assign(validations, {
         checkDuplicates,
         checkScopes,
+        checkAssertionsCount,
     });
 };
 
 const isValidationEnabled = (a) => values(a).filter(Boolean).length;
 
-module.exports.createValidator = ({tests}) => (msg) => {
+module.exports.createValidator = ({tests}) => (msg, options) => {
     if (!isValidationEnabled(validations))
         return [];
     
@@ -55,7 +58,7 @@ module.exports.createValidator = ({tests}) => (msg) => {
         if (!filtered.length)
             throw Error('☝️Looks like message cannot be find in tests, this should never happen');
         
-        const [message, at] = validators[name](msg, filtered);
+        const [message, at] = validators[name](msg, filtered, options);
         
         if (at)
             return [message, at];
@@ -65,14 +68,6 @@ module.exports.createValidator = ({tests}) => (msg) => {
 };
 
 module.exports.getAt = () => {
-    const {
-        checkDuplicates,
-        checkScopes,
-    } = validations;
-    
-    if (!checkDuplicates && !checkScopes)
-        return '';
-    
     return getFileName();
 };
 
@@ -91,6 +86,19 @@ function getFileName() {
     return '';
 }
 
+function checkAssertionsCount(msg, filtered, options) {
+    const {assertionsCount} = options;
+    const [, at] = filtered[0];
+    
+    if (!isEnabled(filtered, 'checkAssertionsCount'))
+        return [];
+    
+    if (assertionsCount > 1)
+        return [`Only one assertion per test allowed, looks like you have more`, at];
+    
+    return [];
+}
+
 function checkScopes(msg, filtered) {
     const [message, at] = filtered[0];
     

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supertape",
-  "version": "6.7.4",
+  "version": "6.9.0",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "tape compatible test runner with superpowers",
   "homepage": "http://github.com/coderaiser/supertape",