expect-matcher-node-mock 1.0.0 → 1.1.1

package/README.md

@@ -1,8 +1,16 @@
 # Extend jest-expect matcher by native node test runner mock matchers
 Extend for Jest [expect library](https://jestjs.io/docs/expect#expectextendmatchers).
 
+Native node test runner does have diffrent mock structure from jest.mock therefore the extension of current methods is necessary.yst
+
+## Usage:
+
+Since native node test runner doesn't have any global setup, use this extension by import package:
+```js
+import 'expect-matcher-node-mock';
+```
+The extend of expect matchers is included in this import.
 
-Native node test runner does have diffrent mock structure from jest.mock therefore the extension of current methods is necessary.
 
 ## Content:
 
@@ -21,6 +29,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

@@ -1,11 +1,28 @@
 import { describe, it, mock } from 'node:test';
 
 import { expect } from 'expect';
+import stripAnsi from 'strip-ansi';
 
 import '../index.mjs';
 
 describe('mockMethodMatchers', () => {
-  it('toHaveBeenCalled', () => {
+  it('toHaveBeenCalled - should fail to test when method is not node mock', () => {
+    const method = () => {};
+
+    method();
+
+    try {
+      expect(method).toHaveBeenCalled();
+    } catch (error) {
+      expect(stripAnsi(error.message)).toEqual(
+        expect.stringContaining(
+          'Matcher error: received value must be a node mock function'
+        )
+      );
+    }
+  });
+
+  it('toHaveBeenCalled - should test pass and not pass', () => {
     const method = mock.fn();
     const notCalledMethod = mock.fn();
 
@@ -15,7 +32,23 @@ describe('mockMethodMatchers', () => {
     expect(notCalledMethod).not.toHaveBeenCalled();
   });
 
-  it('toHaveBeenCalledTimes', () => {
+  it('toHaveBeenCalledTimes - should fail to test when method is not node mock', () => {
+    const method = () => {};
+
+    method();
+
+    try {
+      expect(method).toHaveBeenCalledTimes();
+    } catch (error) {
+      expect(stripAnsi(error.message)).toEqual(
+        expect.stringContaining(
+          'Matcher error: received value must be a node mock function'
+        )
+      );
+    }
+  });
+
+  it('toHaveBeenCalledTimes - should test pass and not pass', () => {
     const method = mock.fn();
     const notCalledMethod = mock.fn();
 
@@ -26,7 +59,23 @@ describe('mockMethodMatchers', () => {
     expect(notCalledMethod).not.toHaveBeenCalledTimes(1);
   });
 
-  it('toHaveBeenCalledWith', () => {
+  it('toHaveBeenCalledWith - should fail to test when method is not node mock', () => {
+    const method = () => {};
+
+    method();
+
+    try {
+      expect(method).toHaveBeenCalledWith();
+    } catch (error) {
+      expect(stripAnsi(error.message)).toEqual(
+        expect.stringContaining(
+          'Matcher error: received value must be a node mock function'
+        )
+      );
+    }
+  });
+
+  it('toHaveBeenCalledWith - should test pass and not pass', () => {
     const method = mock.fn();
 
     method('foo', 'bar');
@@ -35,7 +84,23 @@ describe('mockMethodMatchers', () => {
     expect(method).not.toHaveBeenCalledWith('bar', 'foo');
   });
 
-  it('toHaveBeenLastCalledWith', () => {
+  it('toHaveBeenLastCalledWith - should fail to test when method is not node mock', () => {
+    const method = () => {};
+
+    method();
+
+    try {
+      expect(method).toHaveBeenLastCalledWith();
+    } catch (error) {
+      expect(stripAnsi(error.message)).toEqual(
+        expect.stringContaining(
+          'Matcher error: received value must be a node mock function'
+        )
+      );
+    }
+  });
+
+  it('toHaveBeenLastCalledWith - should test pass and not pass', () => {
     const method = mock.fn();
 
     method('foo');
@@ -45,7 +110,23 @@ describe('mockMethodMatchers', () => {
     expect(method).not.toHaveBeenLastCalledWith('foo');
   });
 
-  it('toHaveBeenNthCalledWith', () => {
+  it('toHaveBeenNthCalledWith - should fail to test when method is not node mock', () => {
+    const method = () => {};
+
+    method();
+
+    try {
+      expect(method).toHaveBeenNthCalledWith();
+    } catch (error) {
+      expect(stripAnsi(error.message)).toEqual(
+        expect.stringContaining(
+          'Matcher error: received value must be a node mock function'
+        )
+      );
+    }
+  });
+
+  it('toHaveBeenNthCalledWith - should test pass and not pass', () => {
     const method = mock.fn();
 
     method('foo');
@@ -55,4 +136,195 @@ describe('mockMethodMatchers', () => {
     expect(method).toHaveBeenNthCalledWith(2, 'bar');
     expect(method).not.toHaveBeenNthCalledWith(1, 'bar');
   });
+
+  it('toHaveReturned - should fail to test when method is not node mock', () => {
+    const method = () => {};
+
+    method();
+
+    try {
+      expect(method).toHaveReturned();
+    } catch (error) {
+      expect(stripAnsi(error.message)).toEqual(
+        expect.stringContaining(
+          'Matcher error: received value must be a node mock function'
+        )
+      );
+    }
+  });
+
+  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 fail to test when method is not node mock', () => {
+    const method = () => {};
+
+    method();
+
+    try {
+      expect(method).toHaveReturnedTimes();
+    } catch (error) {
+      expect(stripAnsi(error.message)).toEqual(
+        expect.stringContaining(
+          'Matcher error: received value must be a node mock function'
+        )
+      );
+    }
+  });
+
+  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 fail to test when method is not node mock', () => {
+    const method = () => {};
+
+    method();
+
+    try {
+      expect(method).toHaveReturnedWith();
+    } catch (error) {
+      expect(stripAnsi(error.message)).toEqual(
+        expect.stringContaining(
+          'Matcher error: received value must be a node mock function'
+        )
+      );
+    }
+  });
+
+  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 fail to test when method is not node mock', () => {
+    const method = () => {};
+
+    method();
+
+    try {
+      expect(method).toHaveLastReturnedWith();
+    } catch (error) {
+      expect(stripAnsi(error.message)).toEqual(
+        expect.stringContaining(
+          'Matcher error: received value must be a node mock function'
+        )
+      );
+    }
+  });
+
+  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 fail to test when method is not node mock', () => {
+    const method = () => {};
+
+    method();
+
+    try {
+      expect(method).toHaveNthReturnedWith();
+    } catch (error) {
+      expect(stripAnsi(error.message)).toEqual(
+        expect.stringContaining(
+          'Matcher error: received value must be a node mock function'
+        )
+      );
+    }
+  });
+
+  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,265 @@
+import { describe, it, mock } from 'node:test';
+
+import { expect } from 'expect';
+import stripAnsi from 'strip-ansi';
+
+import {
+  toHaveBeenCalled,
+  toHaveBeenCalledTimes,
+  toHaveBeenCalledWith,
+  toHaveBeenLastCalledWith,
+  toHaveBeenNthCalledWith,
+} from '../mockMethodMatchers.mjs';
+
+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,
 });