@supertape/operator-stub 1.7.0 → 1.10.0

package/README.md

@@ -1,11 +1,9 @@
-# @supertape/operator-stub [![NPM version][NPMIMGURL]][NPMURL] [![Dependency Status][DependencyStatusIMGURL]][DependencyStatusURL] [![Build Status][BuildStatusIMGURL]][BuildStatusURL] [![Coverage Status][CoverageIMGURL]][CoverageURL]
+# @supertape/operator-stub [![NPM version][NPMIMGURL]][NPMURL] [![Build Status][BuildStatusIMGURL]][BuildStatusURL] [![Coverage Status][CoverageIMGURL]][CoverageURL]
 
 [NPMIMGURL]: https://img.shields.io/npm/v/supertape.svg?style=flat&longCache=true
 [BuildStatusIMGURL]: https://img.shields.io/travis/coderaiser/supertape/master.svg?style=flat&longCache=true
-[DependencyStatusIMGURL]: https://img.shields.io/david/coderaiser/supertape.svg?path=packages/operator-stub&style=flat&longCache=true
 [NPMURL]: https://npmjs.org/package/supertape "npm"
 [BuildStatusURL]: https://travis-ci.org/coderaiser/supertape "Build Status"
-[DependencyStatusURL]: https://david-dm.org/coderaiser/supertape?path=packages/operator-stub "Dependency Status"
 [CoverageURL]: https://coveralls.io/github/coderaiser/supertape?branch=master
 [CoverageIMGURL]: https://coveralls.io/repos/coderaiser/supertape/badge.svg?branch=master&service=github
 
@@ -125,6 +123,72 @@ test('function called with new', (t) => {
 });
 ```
 
+### t.calledBefore(fn1, fn2[, message])
+
+Check that `fn1` called before `fn2`.
+Do not forget to set names of stubs.
+
+```js
+import test, {
+    stub,
+} from 'supertape';
+
+test('function called with new', (t) => {
+    const init = stub().withName('init');
+    const show = stub().withName('show');
+    
+    init();
+    show();
+    
+    t.calledBefore(show, init);
+    t.end();
+});
+```
+
+### t.calledAfter(fn1, fn2[, message])
+
+Check that `fn1` called after `fn2`.
+Do not forget to set names of stubs.
+
+```js
+import test, {
+    stub,
+} from 'supertape';
+
+test('function called with new', (t) => {
+    const init = stub().withName('init');
+    const show = stub().withName('show');
+    
+    init();
+    show();
+    
+    t.calledAfter(init, show);
+    t.end();
+});
+```
+
+### t.calledInOrder([fn1, fn2, fnN][, message])
+
+Check that array of stubs `fns` called in order;
+Do not forget to set names of stubs.
+
+```js
+import test, {
+    stub,
+} from 'supertape';
+
+test('function called with new', (t) => {
+    const init = stub().withName('init');
+    const show = stub().withName('show');
+    
+    init();
+    show();
+    
+    t.calledInOrder([init, show]);
+    t.end();
+});
+```
+
 ## License
 
 MIT

package/lib/stub.d.ts

@@ -2,10 +2,10 @@ import {Stub} from '@cloudcmd/stub';
 
 type Result = {
     is: boolean,
-    expected: any,
-    actual: any,
+    expected: unknown,
+    actual: unknown,
     message: string,
-}
+};
 export function stub(arg?: unknown): Stub;
 
 export interface OperatorStub {
@@ -17,5 +17,8 @@ export interface OperatorStub {
     calledOnce: (fn: Stub, message?: string) => Result;
     calledTwice: (fn: Stub, message?: string) => Result;
     calledWithNew: (fn: Stub, message?: string) => Result;
+    calledBefore: (fn1: Stub, fn2: Stub, message?: string) => Result;
+    calledAfter: (fn1: Stub, fn2: Stub, message?: string) => Result;
+    calledInOrder: (fns: Stub[], message?: string) => Result;
 }
 

package/lib/stub.js

@@ -1,7 +1,7 @@
 import {isStub} from '@cloudcmd/stub';
 
 const isString = (a) => typeof a === 'string';
-const getExpectedStubMessage = (fn) => `Expected stub, but received: ${fn.toString()}`;
+const getExpectedStubMessage = (fn) => `Expected stub, but received: ${fn?.toString()}`;
 
 const {stringify} = JSON;
 const {isArray} = Array;
@@ -17,10 +17,13 @@ export const notCalled = (operator) => (fn, message = 'should not be called') =>
     if (!isStub(fn))
         return operator.fail(getExpectedStubMessage(fn));
     
+    if (!isString(message))
+        return operator.fail(`'t.notCalled' expects message to be string, but received: '${stringify(message)}', looks like you need 't.notCalledWith'`);
+    
     return operator.notOk(fn.called, message);
 };
 
-export const calledWith = (operator) => (fn, args, message = 'should be called with arguments') => {
+export const calledWith = (operator) => (fn, args, message = `should be called with 'args'`) => {
     if (!isStub(fn))
         return operator.fail(getExpectedStubMessage(fn));
     
@@ -28,10 +31,10 @@ export const calledWith = (operator) => (fn, args, message = 'should be called w
         return operator.fail(`Expected function to be called with arguments, but not called at all`);
     
     if (!args)
-        return operator.fail(`You haven't provided 'arguments', looks like you need 't.calledWithNoArgs()'`);
+        return operator.fail(`You haven't provided 'args', looks like you need 't.calledWithNoArgs()'`);
     
     if (!isArray(args))
-        return operator.fail(`Expected 'arguments' to be 'array' but received: ${stringify(args)}`);
+        return operator.fail(`Expected 'args' to be 'array' but received: ${stringify(args)}`);
     
     const {length} = fn.args;
     const calledArgs = fn.args[length - 1];
@@ -62,13 +65,9 @@ export const calledCount = (operator) => (fn, count, message = 'should be called
     return operator.equal(fn.callCount, count, message);
 };
 
-export const calledOnce = (operator) => (fn, message = 'should be called once') => {
-    return calledCount(operator)(fn, 1, message);
-};
+export const calledOnce = (operator) => (fn, message = 'should be called once') => calledCount(operator)(fn, 1, message);
 
-export const calledTwice = (operator) => (fn, count, message = 'should be called twice') => {
-    return calledCount(operator)(fn, 2, message);
-};
+export const calledTwice = (operator) => (fn, count, message = 'should be called twice') => calledCount(operator)(fn, 2, message);
 
 export const calledWithNew = (operator) => (fn, message = 'should be called with new') => {
     if (!isStub(fn))
@@ -77,3 +76,76 @@ export const calledWithNew = (operator) => (fn, message = 'should be called with
     return operator.ok(fn.calledWithNew(), message);
 };
 
+const noName = ({name}) => name === 'anonymous';
+
+export const calledBefore = (operator) => (fn1, fn2, message) => {
+    message = message || `should call '${fn1.name}' before '${fn2.name}'`;
+    
+    if (!isStub(fn1))
+        return operator.fail(getExpectedStubMessage(fn1));
+    
+    if (!isStub(fn2))
+        return operator.fail(getExpectedStubMessage(fn2));
+    
+    if (noName(fn1) || noName(fn2))
+        return operator.fail(`Looks like you forget to define name of a stub, use: stub().withName('functionName')`);
+    
+    if (!fn1.called)
+        return operator.fail(`Expected function '${fn1.name}' to be called before '${fn2.name}' but '${fn1.name}' not called at all`);
+    
+    if (!fn2.called)
+        return operator.fail(`Expected function '${fn1.name}' to be called before '${fn2.name}' but '${fn2.name}' not called at all`);
+    
+    return operator.ok(fn1.calledBefore(fn2), message);
+};
+
+export const calledAfter = (operator) => (fn1, fn2, message) => {
+    message = message || `should call '${fn1.name}' after '${fn2.name}'`;
+    
+    if (!isStub(fn1))
+        return operator.fail(getExpectedStubMessage(fn1));
+    
+    if (!isStub(fn2))
+        return operator.fail(getExpectedStubMessage(fn2));
+    
+    if (noName(fn1) || noName(fn2))
+        return operator.fail(`Looks like you forget to define name of a stub, use: stub().withName('functionName')`);
+    
+    if (!fn1.called)
+        return operator.fail(`Expected function '${fn1.name}' to be called after '${fn2.name}' but '${fn1.name}' not called at all`);
+    
+    if (!fn2.called)
+        return operator.fail(`Expected function '${fn1.name}' to be called after '${fn2.name}' but '${fn2.name}' not called at all`);
+    
+    return operator.ok(fn1.calledAfter(fn2), message);
+};
+
+export const calledInOrder = (operator) => (fns, message = 'should call in order') => {
+    if (!isArray(fns))
+        return operator.fail(`Expected 'fns' to be 'array' but received: ${fns}`);
+    
+    let failMessage = '';
+    const fail = (message) => failMessage = message;
+    const ok = (result, message) => {
+        if (!result)
+            failMessage = message;
+    };
+    
+    const check = calledBefore({
+        fail,
+        ok,
+    });
+    
+    for (let i = 0; i < fns.length - 1; i++) {
+        const fn1 = fns[i];
+        const fn2 = fns[i + 1];
+        
+        check(fn1, fn2);
+        
+        if (failMessage)
+            return operator.fail(failMessage);
+    }
+    
+    return operator.pass(message);
+};
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supertape/operator-stub",
-  "version": "1.7.0",
+  "version": "1.10.0",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "supertape stub operator",
   "homepage": "http://github.com/coderaiser/supertape",
@@ -26,7 +26,7 @@
     "wisdom": "madrun wisdom"
   },
   "dependencies": {
-    "@cloudcmd/stub": "^3.6.0"
+    "@cloudcmd/stub": "^3.7.0"
   },
   "keywords": [
     "operator",
@@ -38,17 +38,17 @@
   ],
   "devDependencies": {
     "@babel/core": "^7.12.9",
-    "@babel/eslint-parser": "^7.12.1",
     "c8": "^7.3.5",
-    "check-dts": "^0.5.5",
+    "check-dts": "^0.6.5",
     "eslint": "^8.0.0-beta.0",
     "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-putout": "^10.0.1",
+    "eslint-plugin-putout": "^13.0.1",
     "madrun": "^8.0.0",
     "mock-require": "^3.0.2",
     "nodemon": "^2.0.2",
-    "putout": "^20.0.1",
-    "supertape": "^6.0.1"
+    "putout": "^24.1.0",
+    "supertape": "^6.0.1",
+    "typescript": "^4.4.4"
   },
   "license": "MIT",
   "engines": {