expect-matcher-node-mock 1.0.0 → 1.1.0

package/README.md

@@ -21,6 +21,18 @@ https://jestjs.io/docs/expect#tohavebeenlastcalledwitharg1-arg2-
 ### toHaveBeenNthCalledWith
 https://jestjs.io/docs/expect#tohavebeennthcalledwithnthcall-arg1-arg2-
 
-### TODO
-add all toHaveReturnedXX methods
+### toHaveReturned
+alias `toReturn`
+https://jestjs.io/docs/expect#tohavereturned
 
+### toHaveReturnedTimes
+https://jestjs.io/docs/expect#tohavereturnedtimesnumber
+
+### toHaveReturnedWith
+https://jestjs.io/docs/expect#tohavereturnedwithvalue
+
+### toHaveLastReturnedWith
+https://jestjs.io/docs/expect#tohavelastreturnedwithvalue
+
+### toHaveNthReturnedWith
+https://jestjs.io/docs/expect#tohaventhreturnedwithnthcall-value

package/lib/__tests__/mockMethodMatchers.test.mjs

@@ -5,7 +5,7 @@ import { expect } from 'expect';
 import '../index.mjs';
 
 describe('mockMethodMatchers', () => {
-  it('toHaveBeenCalled', () => {
+  it('toHaveBeenCalled - should test pass and not pass', () => {
     const method = mock.fn();
     const notCalledMethod = mock.fn();
 
@@ -15,7 +15,7 @@ describe('mockMethodMatchers', () => {
     expect(notCalledMethod).not.toHaveBeenCalled();
   });
 
-  it('toHaveBeenCalledTimes', () => {
+  it('toHaveBeenCalledTimes - should test pass and not pass', () => {
     const method = mock.fn();
     const notCalledMethod = mock.fn();
 
@@ -26,7 +26,7 @@ describe('mockMethodMatchers', () => {
     expect(notCalledMethod).not.toHaveBeenCalledTimes(1);
   });
 
-  it('toHaveBeenCalledWith', () => {
+  it('toHaveBeenCalledWith - should test pass and not pass', () => {
     const method = mock.fn();
 
     method('foo', 'bar');
@@ -35,7 +35,7 @@ describe('mockMethodMatchers', () => {
     expect(method).not.toHaveBeenCalledWith('bar', 'foo');
   });
 
-  it('toHaveBeenLastCalledWith', () => {
+  it('toHaveBeenLastCalledWith - should test pass and not pass', () => {
     const method = mock.fn();
 
     method('foo');
@@ -45,7 +45,7 @@ describe('mockMethodMatchers', () => {
     expect(method).not.toHaveBeenLastCalledWith('foo');
   });
 
-  it('toHaveBeenNthCalledWith', () => {
+  it('toHaveBeenNthCalledWith - should test pass and not pass', () => {
     const method = mock.fn();
 
     method('foo');
@@ -55,4 +55,115 @@ describe('mockMethodMatchers', () => {
     expect(method).toHaveBeenNthCalledWith(2, 'bar');
     expect(method).not.toHaveBeenNthCalledWith(1, 'bar');
   });
+
+  it('toHaveReturned - should test pass and not pass', () => {
+    const method = mock.fn();
+    const notCalledMethod = mock.fn();
+
+    method();
+
+    expect(method).toHaveReturned();
+    expect(notCalledMethod).not.toHaveReturned();
+  });
+
+  it('toHaveReturned - should not pass when mock method thorws an error', () => {
+    const method = mock.fn(() => {
+      throw new Error();
+    });
+
+    expect(() => {
+      method();
+    }).toThrow();
+
+    expect(method).not.toHaveReturned();
+  });
+
+  it('toHaveReturnedTimes - should test pass and not pass', () => {
+    const method = mock.fn();
+    const notCalledMethod = mock.fn();
+
+    method();
+    method();
+
+    expect(method).toHaveReturnedTimes(2);
+    expect(notCalledMethod).not.toHaveReturnedTimes(1);
+  });
+
+  it('toHaveReturnedTimes - should not pass when mock method thorws an error', () => {
+    const method = mock.fn(() => {
+      throw new Error();
+    });
+
+    expect(() => {
+      method();
+    }).toThrow();
+
+    expect(method).not.toHaveReturnedTimes(1);
+  });
+
+  it('toHaveReturnedWith - should test pass and not pass', () => {
+    const method = mock.fn(arg => arg);
+
+    method('foo', 'bar');
+
+    expect(method).toHaveReturnedWith('foo', 'bar');
+    expect(method).not.toHaveReturnedWith('bar', 'foo');
+  });
+
+  it('toHaveReturnedWith - should not pass when mock method thorws an error', () => {
+    const method = mock.fn(() => {
+      throw new Error();
+    });
+
+    expect(() => {
+      method();
+    }).toThrow();
+
+    expect(method).not.toHaveReturnedWith('foo');
+  });
+
+  it('toHaveLastReturnedWith - should test pass and not pass', () => {
+    const method = mock.fn(arg => arg);
+
+    method('foo');
+    method('bar');
+
+    expect(method).toHaveLastReturnedWith('bar');
+    expect(method).not.toHaveLastReturnedWith('foo');
+  });
+
+  it('toHaveLastReturnedWith - should not pass when mock method thorws an error', () => {
+    const method = mock.fn(() => {
+      throw new Error();
+    });
+
+    expect(() => {
+      method();
+    }).toThrow();
+
+    expect(method).not.toHaveLastReturnedWith('foo');
+  });
+
+  it('toHaveNthReturnedWith - should test pass and not pass', () => {
+    const method = mock.fn(arg => arg);
+
+    method('foo');
+    method('bar');
+
+    expect(method).toHaveNthReturnedWith(1, 'foo');
+    expect(method).toHaveNthReturnedWith(2, 'bar');
+    expect(method).not.toHaveNthReturnedWith(1, 'bar');
+  });
+
+  it('toHaveNthReturnedWith - should not pass when mock method thorws an error', () => {
+    const method = mock.fn(() => {
+      throw new Error();
+    });
+
+    expect(() => {
+      method();
+    }).toThrow();
+
+    expect(method).not.toHaveNthReturnedWith(1, 'foo');
+  });
 });

package/lib/__tests__/returnSnaps.test.mjs

@@ -0,0 +1,276 @@
+import { describe, it, mock } from 'node:test';
+
+import { expect } from 'expect';
+
+import {
+  toHaveBeenCalled,
+  toHaveBeenCalledTimes,
+  toHaveBeenCalledWith,
+  toHaveBeenLastCalledWith,
+  toHaveBeenNthCalledWith,
+  toReturn,
+  toHaveReturned,
+  toHaveReturnedTimes,
+  toHaveReturnedWith,
+  toHaveLastReturnedWith,
+  toHaveNthReturnedWith,
+} from '../mockMethodMatchers.mjs';
+
+const stripAnsi = str =>
+  str.replace(
+    /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g,
+    ''
+  );
+
+describe('mockMethodMatchers return snapshots', () => {
+  describe('toHaveBeenCalled', () => {
+    it('fail', () => {
+      const options = {
+        isNot: false,
+        promise: false,
+        toHaveBeenCalled,
+      };
+
+      const method = mock.fn();
+
+      const result = options.toHaveBeenCalled(method);
+      const message = stripAnsi(result.message());
+
+      expect(result).toEqual({ message: expect.any(Function), pass: false });
+      expect(message).toStrictEqual(
+        expect.stringContaining('expect(mock.fn()).false.toHaveBeenCalled()')
+      );
+      expect(message).toStrictEqual(
+        expect.stringContaining('Expected number of calls: >= 1')
+      );
+      expect(message).toStrictEqual(
+        expect.stringContaining('Received number of calls:    0')
+      );
+    });
+
+    it('not pass', () => {
+      const options = {
+        isNot: true,
+        promise: false,
+        toHaveBeenCalled,
+      };
+      const method = mock.fn();
+
+      const result = options.toHaveBeenCalled(method);
+      const message = stripAnsi(result.message());
+
+      expect(result).toEqual({ message: expect.any(Function), pass: false });
+      expect(message).toStrictEqual(
+        expect.stringContaining(
+          'expect(mock.fn()).false.not.toHaveBeenCalled()'
+        )
+      );
+      expect(message).toStrictEqual(
+        expect.stringContaining('Expected number of calls: >= 1')
+      );
+      expect(message).toStrictEqual(
+        expect.stringContaining('Received number of calls:    0')
+      );
+    });
+  });
+
+  describe('toHaveBeenCalledTimes', () => {
+    it('fail', () => {
+      const options = {
+        isNot: false,
+        promise: false,
+        toHaveBeenCalledTimes,
+      };
+
+      const method = mock.fn();
+
+      const result = options.toHaveBeenCalledTimes(method, 1);
+      const message = stripAnsi(result.message());
+
+      expect(result).toEqual({ message: expect.any(Function), pass: false });
+      expect(message).toStrictEqual(
+        expect.stringContaining(
+          'expect(mock.fn()).false.toHaveBeenCalledTimes(expected)'
+        )
+      );
+      expect(message).toStrictEqual(
+        expect.stringContaining('Expected number of calls: 1')
+      );
+      expect(message).toStrictEqual(
+        expect.stringContaining('Received number of calls: 0')
+      );
+    });
+
+    it('not pass', () => {
+      const options = {
+        isNot: true,
+        promise: false,
+        toHaveBeenCalledTimes,
+      };
+      const method = mock.fn();
+
+      const result = options.toHaveBeenCalledTimes(method, 1);
+      const message = stripAnsi(result.message());
+
+      expect(result).toEqual({ message: expect.any(Function), pass: false });
+      expect(message).toStrictEqual(
+        expect.stringContaining(
+          'expect(mock.fn()).false.not.toHaveBeenCalledTimes(expected)'
+        )
+      );
+      expect(message).toStrictEqual(
+        expect.stringContaining('Expected number of calls: 1')
+      );
+      expect(message).toStrictEqual(
+        expect.stringContaining('Received number of calls: 0')
+      );
+    });
+  });
+
+  describe('toHaveBeenCalledWith', () => {
+    it('fail', () => {
+      const options = {
+        isNot: false,
+        promise: false,
+        toHaveBeenCalledWith,
+      };
+
+      const method = mock.fn();
+
+      const result = options.toHaveBeenCalledWith(method, 1);
+      const message = stripAnsi(result.message());
+
+      expect(result).toEqual({ message: expect.any(Function), pass: false });
+      expect(message).toStrictEqual(
+        expect.stringContaining(
+          'expect(mock.fn()).false.toHaveBeenCalledWith(...expected)'
+        )
+      );
+      expect(message).toStrictEqual(expect.stringContaining('Expected: 1'));
+      expect(message).toStrictEqual(
+        expect.stringContaining('Number of calls: 0')
+      );
+    });
+
+    it('not pass', () => {
+      const options = {
+        isNot: true,
+        promise: false,
+        toHaveBeenCalledWith,
+      };
+      const method = mock.fn();
+
+      const result = options.toHaveBeenCalledWith(method, 1);
+      const message = stripAnsi(result.message());
+
+      expect(result).toEqual({ message: expect.any(Function), pass: false });
+      expect(message).toStrictEqual(
+        expect.stringContaining(
+          'expect(mock.fn()).false.not.toHaveBeenCalledWith(...expected)'
+        )
+      );
+      expect(message).toStrictEqual(expect.stringContaining('Expected: 1'));
+      expect(message).toStrictEqual(
+        expect.stringContaining('Number of calls: 0')
+      );
+    });
+  });
+
+  describe('toHaveBeenLastCalledWith', () => {
+    it('fail', () => {
+      const options = {
+        isNot: false,
+        promise: false,
+        toHaveBeenLastCalledWith,
+      };
+
+      const method = mock.fn();
+
+      const result = options.toHaveBeenLastCalledWith(method, 1);
+      const message = stripAnsi(result.message());
+
+      expect(result).toEqual({ message: expect.any(Function), pass: false });
+      expect(message).toStrictEqual(
+        expect.stringContaining(
+          'expect(mock.fn()).false.toHaveBeenLastCalledWith(...expected)'
+        )
+      );
+      expect(message).toStrictEqual(expect.stringContaining('Expected: 1'));
+      expect(message).toStrictEqual(
+        expect.stringContaining('Number of calls: 0')
+      );
+    });
+
+    it('not pass', () => {
+      const options = {
+        isNot: true,
+        promise: false,
+        toHaveBeenLastCalledWith,
+      };
+      const method = mock.fn();
+
+      const result = options.toHaveBeenLastCalledWith(method, 1);
+      const message = stripAnsi(result.message());
+
+      expect(result).toEqual({ message: expect.any(Function), pass: false });
+      expect(message).toStrictEqual(
+        expect.stringContaining(
+          'expect(mock.fn()).false.not.toHaveBeenLastCalledWith(...expected)'
+        )
+      );
+      expect(message).toStrictEqual(expect.stringContaining('Expected: 1'));
+      expect(message).toStrictEqual(
+        expect.stringContaining('Number of calls: 0')
+      );
+    });
+  });
+
+  describe('toHaveBeenNthCalledWith', () => {
+    it('fail', () => {
+      const options = {
+        isNot: false,
+        promise: false,
+        toHaveBeenNthCalledWith,
+      };
+
+      const method = mock.fn();
+
+      const result = options.toHaveBeenNthCalledWith(method, 1, 1);
+      const message = stripAnsi(result.message());
+
+      expect(result).toEqual({ message: expect.any(Function), pass: false });
+      expect(message).toStrictEqual(
+        expect.stringContaining(
+          'expect(mock.fn()).false.toHaveBeenNthCalledWith(...expected)'
+        )
+      );
+      expect(message).toStrictEqual(expect.stringContaining('Expected: 1'));
+      expect(message).toStrictEqual(
+        expect.stringContaining('Number of calls: 0')
+      );
+    });
+
+    it('not pass', () => {
+      const options = {
+        isNot: true,
+        promise: false,
+        toHaveBeenNthCalledWith,
+      };
+      const method = mock.fn();
+
+      const result = options.toHaveBeenNthCalledWith(method, 1, 1);
+      const message = stripAnsi(result.message());
+
+      expect(result).toEqual({ message: expect.any(Function), pass: false });
+      expect(message).toStrictEqual(
+        expect.stringContaining(
+          'expect(mock.fn()).false.not.toHaveBeenNthCalledWith(...expected)'
+        )
+      );
+      expect(message).toStrictEqual(expect.stringContaining('Expected: 1'));
+      expect(message).toStrictEqual(
+        expect.stringContaining('Number of calls: 0')
+      );
+    });
+  });
+});

package/lib/index.mjs

@@ -6,6 +6,12 @@ import {
   toHaveBeenCalledWith,
   toHaveBeenLastCalledWith,
   toHaveBeenNthCalledWith,
+  toReturn,
+  toHaveReturned,
+  toHaveReturnedTimes,
+  toHaveReturnedWith,
+  toHaveLastReturnedWith,
+  toHaveNthReturnedWith,
 } from './mockMethodMatchers.mjs';
 
 expect.extend({
@@ -14,4 +20,10 @@ expect.extend({
   toHaveBeenCalledWith,
   toHaveBeenLastCalledWith,
   toHaveBeenNthCalledWith,
+  toReturn,
+  toHaveReturned,
+  toHaveReturnedTimes,
+  toHaveReturnedWith,
+  toHaveLastReturnedWith,
+  toHaveNthReturnedWith,
 });

package/lib/mockMethodMatchers.mjs

@@ -1,21 +1,389 @@
+import chalk from 'chalk';
 import { expect } from 'expect';
-import { matcherHint, printExpected, printReceived } from 'jest-matcher-utils';
+import {
+  matcherErrorMessage,
+  matcherHint,
+  printExpected,
+  printReceived,
+} from 'jest-matcher-utils';
+
+export const EXPECTED_COLOR = chalk.green;
+export const RECEIVED_COLOR = chalk.red;
+export const INVERTED_COLOR = chalk.inverse;
+export const BOLD_WEIGHT = chalk.bold;
+export const DIM_COLOR = chalk.dim;
+
+/**
+ * Function to ensure that the received value is a mock function
+ * @param {Function} received
+ * @param {string} matcherName
+ * @param {Object} options
+ * @returns {boolean}
+ * @throws {TypeError}
+ */
+function ensureReceivedIsNodeMock(received, matcherName, options = {}) {
+  if (typeof received !== 'function') {
+    throw new TypeError(
+      matcherErrorMessage(
+        matcherHint(matcherName, typeof received, 'function', options),
+        `${RECEIVED_COLOR('received')} value must be a function`
+      )
+    );
+  }
+
+  return typeof received.mock === 'object';
+}
+
+/**
+ * Factory function to create a matcher object
+ * @param {string} matcherName
+ * @param {Object} options
+ * @param {boolean} options.isNot
+ * @param {boolean} options.promise
+ * @returns {Object}
+ */
+function matcherFactory(matcherName, { isNot, promise } = {}) {
+  return {
+    matcherName,
+    options: {
+      comment: `${matcherName} of Node.js mock.fn()`,
+      isNot,
+      promise,
+    },
+    receivedText: 'mock.fn()',
+  };
+}
 
 /**
  * toHaveBeenCalled
+ *
+ * https://jestjs.io/docs/expect#tohavebeencalled
+ */
+function toHaveBeenCalled(receivedMethod, ...args) {
+  const { matcherName, options, receivedText } = matcherFactory(
+    'toHaveBeenCalled',
+    this
+  );
+
+  if (ensureReceivedIsNodeMock(receivedMethod, matcherName, options)) {
+    let message = `\n${matcherHint(
+      matcherName,
+      receivedText,
+      '',
+      options
+    )}\n\n`;
+    let pass = false;
+
+    if (args && args[0]) {
+      message += `Matcher error: this matcher must not have an expected argument
+          \nExpected has type:  ${typeof args[0]}\nExpected has value: ${EXPECTED_COLOR(
+        args[0]
+      )}\n`;
+    } else {
+      pass = receivedMethod.mock.calls.length > 0;
+      if (pass) {
+        message += `Expected number of calls: ${EXPECTED_COLOR(
+          '0'
+        )}\nReceived number of calls: ${RECEIVED_COLOR(
+          receivedMethod.mock.calls.length
+        )}\n`;
+      } else {
+        message += `Expected number of calls: >= ${EXPECTED_COLOR(
+          '1'
+        )}\nReceived number of calls:    ${RECEIVED_COLOR('0')}\n`;
+      }
+    }
+
+    return {
+      pass,
+      message: () => message,
+    };
+  }
+
+  return expect(receivedMethod).toHaveBeenCalled();
+}
+
+/**
+ * toHaveBeenCalledTimes
+ *
+ * https://jestjs.io/docs/expect#tohavebeencalledtimesnumber
+ */
+function toHaveBeenCalledTimes(receivedMethod, expected) {
+  const { matcherName, options, receivedText } = matcherFactory(
+    'toHaveBeenCalledTimes',
+    this
+  );
+  const received = receivedMethod.mock.calls.length;
+
+  if (ensureReceivedIsNodeMock(receivedMethod, matcherName, options)) {
+    let message = `\n${matcherHint(
+      matcherName,
+      receivedText,
+      'expected',
+      options
+    )}\n\n`;
+    const pass = received === expected;
+
+    if (pass) {
+      message += `Expected number of calls: not ${EXPECTED_COLOR(received)}\n`;
+    } else {
+      message += `Expected number of calls: ${EXPECTED_COLOR(
+        expected
+      )}\nReceived number of calls: ${RECEIVED_COLOR(received)}\n`;
+    }
+
+    return {
+      pass,
+      message: () => message,
+    };
+  }
+
+  return expect(receivedMethod).toHaveBeenCalledTimes(expected);
+}
+
+/**
+ * toHaveBeenCalledWith
+ *
+ * https://jestjs.io/docs/expect#tohavebeencalledwitharg1-arg2-
+ */
+function toHaveBeenCalledWith(receivedMethod, ...args) {
+  const { matcherName, options, receivedText } = matcherFactory(
+    'toHaveBeenCalledWith',
+    this
+  );
+
+  if (ensureReceivedIsNodeMock(receivedMethod, matcherName, options)) {
+    const argsCount = args.length;
+    const receivedArgs = [];
+    let pass = false;
+    let message = '';
+
+    if (!receivedMethod.mock.calls.length) {
+      pass = false;
+      message = `Expected: `;
+      if (argsCount === 0) {
+        message += `called with 0 arguments`;
+      } else {
+        message += `${args.map(arg => printExpected(arg)).join(', ')}`;
+      }
+    } else {
+      pass = receivedMethod.mock.calls.some(call => {
+        receivedArgs.push(call.arguments);
+        return (
+          argsCount &&
+          args.every((arg, index) => {
+            try {
+              expect(call.arguments[index]).toEqual(arg);
+              return true;
+            } catch (_) {
+              return false;
+            }
+          })
+        );
+      });
+
+      message = `Expected: ${pass ? 'not ' : ''}`;
+
+      if (argsCount === 0) {
+        message += `called with 0 arguments`;
+      } else {
+        message += `${args.map(arg => printExpected(arg)).join(', ')}`;
+      }
+
+      message += `\n\nReceived\n${receivedArgs.reduce(
+        (receivedText, args, index) =>
+          (receivedText +=
+            args.length === 0
+              ? '\t' + index + ': called with 0 arguments\n'
+              : '\t' +
+                index +
+                ': ' +
+                args.map(arg => printReceived(arg)).join(', ') +
+                '\n'),
+        ''
+      )}`;
+    }
+
+    return {
+      pass,
+      message: () =>
+        `\n${matcherHint(
+          matcherName,
+          receivedText,
+          '...expected',
+          options
+        )}\n\n${message}\n\nNumber of calls: ${RECEIVED_COLOR(
+          receivedMethod.mock.calls.length
+        )}\n`,
+    };
+  }
+
+  return expect(receivedMethod).toHaveBeenCalledWith(...args);
+}
+
+/**
+ * toHaveBeenLastCalledWith
+ *
+ * https://jestjs.io/docs/expect#tohavebeenlastcalledwitharg1-arg2-
+ */
+function toHaveBeenLastCalledWith(receivedMethod, ...args) {
+  const { matcherName, options, receivedText } = matcherFactory(
+    'toHaveBeenLastCalledWith',
+    this
+  );
+
+  if (ensureReceivedIsNodeMock(receivedMethod, matcherName, options)) {
+    const argsCount = args.length;
+    const receivedArgs = [];
+    let pass = false;
+    let message = '';
+    const callsCount = receivedMethod.mock.calls.length;
+
+    if (!callsCount) {
+      pass = false;
+      message = `Expected: `;
+      if (argsCount === 0) {
+        message += `called with 0 arguments`;
+      } else {
+        message += `${args.map(arg => printExpected(arg)).join(', ')}`;
+      }
+    } else {
+      const lastCall = receivedMethod.mock.calls[callsCount - 1];
+      receivedArgs.push(lastCall.arguments);
+      pass =
+        argsCount &&
+        args.every((arg, index) => {
+          try {
+            expect(lastCall.arguments[index]).toEqual(arg);
+            return true;
+          } catch (_) {
+            return false;
+          }
+        });
+
+      message = `Expected: ${pass ? 'not ' : ''}`;
+
+      if (argsCount === 0) {
+        message += `called with 0 arguments`;
+      } else {
+        message += `${args.map(arg => printExpected(arg)).join(', ')}`;
+      }
+
+      message += `\n\n\nReceived: ${receivedArgs.map(args =>
+        args.map(arg => printReceived(arg)).join(', ')
+      )}`;
+    }
+
+    return {
+      pass,
+      message: () =>
+        `${matcherHint(
+          matcherName,
+          receivedText,
+          '...expected',
+          options
+        )}\n\n${message}\n\nNumber of calls: ${RECEIVED_COLOR(
+          receivedMethod.mock.calls.length
+        )}\n`,
+    };
+  }
+
+  return expect(receivedMethod).toHaveBeenLastCalledWith(...args);
+}
+
+/**
+ * toHaveBeenNthCalledWith
+ *
+ * https://jestjs.io/docs/expect#tohavebeennthcalledwithnthcall-arg1-arg2-
  */
-function toHaveBeenCalled(method) {
-  expect(typeof method).toBe('function');
+function toHaveBeenNthCalledWith(receivedMethod, nthCallIndex, ...args) {
+  const { matcherName, options, receivedText } = matcherFactory(
+    'toHaveBeenNthCalledWith',
+    this
+  );
+
+  if (ensureReceivedIsNodeMock(receivedMethod, matcherName, options)) {
+    const argsCount = args.length;
+    const receivedArgs = [];
+    let pass = false;
+    let message = `n: ${nthCallIndex}\n`;
+    const callsCount = receivedMethod.mock.calls.length;
+
+    if (!callsCount || nthCallIndex > callsCount) {
+      pass = false;
+      message += `Expected: `;
+      if (argsCount === 0) {
+        message += `called with 0 arguments`;
+      } else {
+        message += `${args.map(arg => printExpected(arg)).join(', ')}`;
+      }
+    } else {
+      const nthCall = receivedMethod.mock.calls[nthCallIndex - 1];
+      receivedArgs.push(nthCall.arguments);
+      pass =
+        argsCount &&
+        args.every((arg, index) => {
+          try {
+            expect(nthCall.arguments[index]).toEqual(arg);
+            return true;
+          } catch (_) {
+            return false;
+          }
+        });
+
+      message += `Expected: ${pass ? 'not ' : ''}`;
+
+      if (argsCount === 0) {
+        message += `called with 0 arguments`;
+      } else {
+        message += `${args.map(arg => printExpected(arg)).join(', ')}`;
+      }
+
+      message += `\nReceived: ${
+        receivedArgs.length
+          ? receivedArgs.map(args =>
+              args.map(arg => printReceived(arg)).join(', ')
+            )
+          : 'called with 0 arguments'
+      }`;
+    }
+
+    return {
+      pass,
+      message: () =>
+        `${matcherHint(
+          matcherName,
+          receivedText,
+          '...expected',
+          options
+        )}\n\n${message}\n\nNumber of calls: ${RECEIVED_COLOR(
+          receivedMethod.mock.calls.length
+        )}\n`,
+    };
+  }
+
+  return expect(receivedMethod).toHaveBeenNthCalledWith(nthCallIndex, ...args);
+}
+
+/**
+ * toHaveReturned
+ *
+ * https://jestjs.io/docs/expect#tohavereturned
+ */
+function toHaveReturned(receivedMethod) {
+  expect(typeof receivedMethod).toBe('function');
 
   // detect native node test runner mock
-  if (typeof method.mock === 'object') {
-    const matcherName = 'toHaveBeenCalled';
+  if (typeof receivedMethod.mock === 'object') {
+    const matcherName = 'toHaveReturned';
     const options = {
       isNot: this.isNot,
       promise: this.promise,
     };
 
-    const pass = method.mock.calls.length > 0;
+    const pass = receivedMethod.mock.calls.some(
+      call => call.error === undefined
+    );
 
     if (pass) {
       return {
@@ -26,38 +394,58 @@ function toHaveBeenCalled(method) {
             undefined,
             undefined,
             options
-          )}\nexpected ${method.name} not to be called`,
+          )}\nExpected: ${printExpected(
+            'not to return an error'
+          )}\nReceived: ${printReceived('returned without error')}`,
+      };
+    } else {
+      return {
+        pass,
+        message: () =>
+          `${matcherHint(
+            matcherName,
+            undefined,
+            undefined,
+            options
+          )}\nExpected: ${printExpected(
+            'not to return an error'
+          )}\nReceived: ${printReceived('returned with error')}`,
       };
     }
-
-    return {
-      pass,
-      message: () =>
-        `${matcherHint(matcherName, undefined, undefined, options)}\nexpected ${
-          method.name
-        }  to be called`,
-    };
   }
 
-  return expect(method).toHaveBeenCalled();
+  return expect(receivedMethod).toHaveReturned();
 }
 
 /**
- * toHaveBeenCalledTimes
+ * toReturn
+ *
+ * https://jestjs.io/docs/expect#tohavereturned
+ */
+function toReturn(receivedMethod) {
+  return toHaveReturned(receivedMethod);
+}
+
+/**
+ * toHaveReturnedTimes
+ *
+ * https://jestjs.io/docs/expect#tohavereturnedtimesnumber
  */
-function toHaveBeenCalledTimes(method, expected) {
-  expect(typeof method).toBe('function');
+function toHaveReturnedTimes(receivedMethod, times) {
+  expect(typeof receivedMethod).toBe('function');
 
-  // detect native node test runßßner mock
-  if (typeof method.mock === 'object') {
-    const matcherName = 'toHaveBeenCalledTimes';
+  // detect native node test runner mock
+  if (typeof receivedMethod.mock === 'object') {
+    const matcherName = 'toHaveReturnedTimes';
     const options = {
       isNot: this.isNot,
       promise: this.promise,
     };
-    const received = method.mock.calls.length;
 
-    const pass = received === expected;
+    const noErrorCalls = receivedMethod.mock.calls.filter(
+      call => call.error === undefined
+    );
+    const pass = noErrorCalls.length === times;
 
     if (pass) {
       return {
@@ -68,8 +456,8 @@ function toHaveBeenCalledTimes(method, expected) {
             undefined,
             undefined,
             options
-          )}\nExpected: ${printExpected(expected)}\nReceived: ${printReceived(
-            received
+          )}\nExpected: ${printExpected(times)}\nReceived: ${printReceived(
+            receivedMethod.mock.calls.length
           )}`,
       };
     }
@@ -82,36 +470,34 @@ function toHaveBeenCalledTimes(method, expected) {
           undefined,
           undefined,
           options
-        )}\nExpected: ${printExpected(expected)}\nReceived: ${printReceived(
-          received
+        )}\nExpected: ${printExpected(times)}\nReceived: ${printReceived(
+          receivedMethod.mock.calls.length
         )}`,
     };
   }
 
-  return expect(method).toHaveBeenCalledTimes(expected);
+  return expect(receivedMethod).toHaveReturnedTimes(times);
 }
 
 /**
- * toHaveBeenCalledWith
+ * toHaveReturnedWith
+ *
+ * https://jestjs.io/docs/expect#tohavereturnedwithvalue
  */
-function toHaveBeenCalledWith(method, ...args) {
-  expect(typeof method).toBe('function');
+function toHaveReturnedWith(receivedMethod, expected) {
+  expect(typeof receivedMethod).toBe('function');
 
   // detect native node test runner mock
-  if (typeof method.mock === 'object') {
-    expect(method.mock.calls.length).toBeGreaterThan(0);
-
-    const matcherName = 'toHaveBeenCalledWith';
+  if (typeof receivedMethod.mock === 'object') {
+    const matcherName = 'toHaveReturnedWith';
     const options = {
       isNot: this.isNot,
       promise: this.promise,
     };
-    const receivedArgs = [];
 
-    const pass = method.mock.calls.some(call => {
-      receivedArgs.push(call.arguments);
-      return args.every((arg, index) => call.arguments[index] === arg);
-    });
+    const pass = receivedMethod.mock.calls.some(
+      call => call.result === expected
+    );
 
     if (pass) {
       return {
@@ -122,8 +508,8 @@ function toHaveBeenCalledWith(method, ...args) {
             undefined,
             undefined,
             options
-          )}\nExpected: ${printExpected(...args)}\nReceived: ${receivedArgs.map(
-            args => args.map(arg => printReceived(arg)).join(', ')
+          )}\nExpected: ${printExpected(expected)}\nReceived: ${printReceived(
+            receivedMethod.mock.calls.map(call => call.result)
           )}`,
       };
     }
@@ -136,33 +522,34 @@ function toHaveBeenCalledWith(method, ...args) {
           undefined,
           undefined,
           options
-        )}\nExpected: ${printExpected(...args)}\nReceived: ${receivedArgs.map(
-          args => args.map(arg => printReceived(arg)).join(', ')
+        )}\nExpected: ${printExpected(expected)}\nReceived: ${printReceived(
+          receivedMethod.mock.calls.map(call => call.result)
         )}`,
     };
   }
 
-  return expect(method).toHaveBeenCalledWith(...args);
+  return expect(receivedMethod).toHaveReturnedWith(expected);
 }
 
 /**
- * toHaveBeenLastCalledWith
+ * toHaveLastReturnedWith
+ *
+ * https://jestjs.io/docs/expect#tohavelastreturnedwithvalue
  */
-function toHaveBeenLastCalledWith(method, ...args) {
-  expect(typeof method).toBe('function');
+function toHaveLastReturnedWith(receivedMethod, expected) {
+  expect(typeof receivedMethod).toBe('function');
 
   // detect native node test runner mock
-  if (typeof method.mock === 'object') {
-    expect(method.mock.calls.length).toBeGreaterThan(0);
-
-    const matcherName = 'toHaveBeenLastCalledWith';
+  if (typeof receivedMethod.mock === 'object') {
+    const matcherName = 'toHaveLastReturnedWith';
     const options = {
       isNot: this.isNot,
       promise: this.promise,
     };
-    const lastCall = method.mock.calls[method.mock.calls.length - 1];
 
-    const pass = args.every((arg, index) => lastCall.arguments[index] === arg);
+    const lastCall =
+      receivedMethod.mock.calls[receivedMethod.mock.calls.length - 1];
+    const pass = lastCall.result === expected;
 
     if (pass) {
       return {
@@ -173,9 +560,9 @@ function toHaveBeenLastCalledWith(method, ...args) {
             undefined,
             undefined,
             options
-          )}\nExpected: ${printExpected(
-            ...args
-          )}\nReceived: ${lastCall.arguments.map(arg => printReceived(arg))}`,
+          )}\nExpected: ${printExpected(expected)}\nReceived: ${printReceived(
+            lastCall.result
+          )}`,
       };
     }
 
@@ -187,33 +574,33 @@ function toHaveBeenLastCalledWith(method, ...args) {
           undefined,
           undefined,
           options
-        )}\nExpected: ${printExpected(
-          ...args
-        )}\nReceived: ${lastCall.arguments.map(arg => printReceived(arg))}`,
+        )}\nExpected: ${printExpected(expected)}\nReceived: ${printReceived(
+          lastCall.result
+        )}`,
     };
   }
 
-  return expect(method).toHaveBeenLastCalledWith(...args);
+  return expect(receivedMethod).toHaveLastReturnedWith(expected);
 }
 
 /**
- * toHaveBeenNthCalledWith
+ * toHaveNthReturnedWith
+ *
+ * https://jestjs.io/docs/expect#tohaventhreturnedwithnthcall-value
  */
-function toHaveBeenNthCalledWith(method, nthCall, ...args) {
-  expect(typeof method).toBe('function');
+function toHaveNthReturnedWith(receivedMethod, nthCall, expected) {
+  expect(typeof receivedMethod).toBe('function');
 
   // detect native node test runner mock
-  if (typeof method.mock === 'object') {
-    expect(method.mock.calls.length).toBeGreaterThan(nthCall - 1);
-
-    const matcherName = 'toHaveBeenNthCalledWith';
+  if (typeof receivedMethod.mock === 'object') {
+    const matcherName = 'toHaveNthReturnedWith';
     const options = {
       isNot: this.isNot,
       promise: this.promise,
     };
-    const lastCall = method.mock.calls[nthCall - 1];
 
-    const pass = args.every((arg, index) => lastCall.arguments[index] === arg);
+    const nthCallResult = receivedMethod.mock.calls[nthCall - 1].result;
+    const pass = nthCallResult === expected;
 
     if (pass) {
       return {
@@ -224,9 +611,9 @@ function toHaveBeenNthCalledWith(method, nthCall, ...args) {
             undefined,
             undefined,
             options
-          )}\nExpected: ${printExpected(
-            ...args
-          )}\nReceived: ${lastCall.arguments.map(arg => printReceived(arg))}`,
+          )}\nExpected: ${printExpected(expected)}\nReceived: ${printReceived(
+            nthCallResult
+          )}`,
       };
     }
 
@@ -238,13 +625,13 @@ function toHaveBeenNthCalledWith(method, nthCall, ...args) {
           undefined,
           undefined,
           options
-        )}\nExpected: ${printExpected(
-          ...args
-        )}\nReceived: ${lastCall.arguments.map(arg => printReceived(arg))}`,
+        )}\nExpected: ${printExpected(expected)}\nReceived: ${printReceived(
+          nthCallResult
+        )}`,
     };
   }
 
-  return expect(method).toHaveBeenNthCalledWith(nthCall, ...args);
+  return expect(receivedMethod).toHaveNthReturnedWith(nthCall, expected);
 }
 
 export {
@@ -253,4 +640,10 @@ export {
   toHaveBeenCalledWith,
   toHaveBeenLastCalledWith,
   toHaveBeenNthCalledWith,
+  toReturn,
+  toHaveReturned,
+  toHaveReturnedTimes,
+  toHaveReturnedWith,
+  toHaveLastReturnedWith,
+  toHaveNthReturnedWith,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expect-matcher-node-mock",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Jest matcher for Node.js mock objects",
   "main": "lib/index.mjs",
   "bugs": {