expect-matcher-node-mock 1.0.0

package/.eslintrc.js

@@ -0,0 +1,82 @@
+module.exports = {
+  root: true,
+  ignorePatterns: [
+    '**/node_modules/**',
+    '**/dist/**',
+    '**/build/**',
+    '**/docs/**',
+    '**/.docusaurus/**',
+    '**/coverage/**',
+  ],
+  extends: [
+    'eslint:recommended',
+    'plugin:prettier/recommended',
+    'plugin:import/recommended',
+  ],
+  rules: {
+    'no-console': [
+      'error',
+      {
+        allow: ['warn', 'error'],
+      },
+    ],
+    'no-unused-vars': [
+      'error',
+      {
+        argsIgnorePattern: '^_',
+        varsIgnorePattern: '^_',
+        destructuredArrayIgnorePattern: '^_',
+        ignoreRestSiblings: true,
+      },
+    ],
+
+    // Prettier
+    'prettier/prettier': [
+      'error',
+      {
+        singleQuote: true,
+        semi: true,
+        trailingComma: 'es5',
+        jsxSingleQuote: true,
+        bracketSameLine: false,
+        arrowParens: 'avoid',
+      },
+    ],
+
+    // Import plugin
+    'import/no-unresolved': [
+      'warn',
+      {
+        ignore: [
+          '^@\\/', // ignore @/* aliases
+          '@(docusaurus|theme)',
+        ],
+      },
+    ],
+    'import/order': [
+      'error',
+      {
+        groups: ['builtin', 'external', 'internal'],
+        'newlines-between': 'always',
+        alphabetize: {
+          order: 'asc',
+          caseInsensitive: true,
+        },
+      },
+    ],
+  },
+  settings: {
+    'import/resolver': {
+      node: {
+        extensions: ['.js', '.jsx', '.mjs', '.json'],
+      },
+    },
+  },
+  parserOptions: {
+    sourceType: 'module',
+    requireConfigFile: false,
+  },
+  env: {
+    node: true,
+  },
+};

package/.nvmrc

@@ -0,0 +1 @@
+22

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Seznam.cz a.s.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,26 @@
+# 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.
+
+## Content:
+
+### toHaveBeenCalled
+https://jestjs.io/docs/expect#tohavebeencalled
+
+### toHaveBeenCalledTimes
+https://jestjs.io/docs/expect#tohavebeencalledtimesnumber
+
+### toHaveBeenCalledWith
+https://jestjs.io/docs/expect#tohavebeencalledwitharg1-arg2-
+
+### toHaveBeenLastCalledWith
+https://jestjs.io/docs/expect#tohavebeenlastcalledwitharg1-arg2-
+
+### toHaveBeenNthCalledWith
+https://jestjs.io/docs/expect#tohavebeennthcalledwithnthcall-arg1-arg2-
+
+### TODO
+add all toHaveReturnedXX methods
+

package/lib/__tests__/mockMethodMatchers.test.mjs

@@ -0,0 +1,58 @@
+import { describe, it, mock } from 'node:test';
+
+import { expect } from 'expect';
+
+import '../index.mjs';
+
+describe('mockMethodMatchers', () => {
+  it('toHaveBeenCalled', () => {
+    const method = mock.fn();
+    const notCalledMethod = mock.fn();
+
+    method();
+
+    expect(method).toHaveBeenCalled();
+    expect(notCalledMethod).not.toHaveBeenCalled();
+  });
+
+  it('toHaveBeenCalledTimes', () => {
+    const method = mock.fn();
+    const notCalledMethod = mock.fn();
+
+    method();
+    method();
+
+    expect(method).toHaveBeenCalledTimes(2);
+    expect(notCalledMethod).not.toHaveBeenCalledTimes(1);
+  });
+
+  it('toHaveBeenCalledWith', () => {
+    const method = mock.fn();
+
+    method('foo', 'bar');
+
+    expect(method).toHaveBeenCalledWith('foo', 'bar');
+    expect(method).not.toHaveBeenCalledWith('bar', 'foo');
+  });
+
+  it('toHaveBeenLastCalledWith', () => {
+    const method = mock.fn();
+
+    method('foo');
+    method('bar');
+
+    expect(method).toHaveBeenLastCalledWith('bar');
+    expect(method).not.toHaveBeenLastCalledWith('foo');
+  });
+
+  it('toHaveBeenNthCalledWith', () => {
+    const method = mock.fn();
+
+    method('foo');
+    method('bar');
+
+    expect(method).toHaveBeenNthCalledWith(1, 'foo');
+    expect(method).toHaveBeenNthCalledWith(2, 'bar');
+    expect(method).not.toHaveBeenNthCalledWith(1, 'bar');
+  });
+});

package/lib/index.mjs

@@ -0,0 +1,17 @@
+import { expect } from 'expect';
+
+import {
+  toHaveBeenCalled,
+  toHaveBeenCalledTimes,
+  toHaveBeenCalledWith,
+  toHaveBeenLastCalledWith,
+  toHaveBeenNthCalledWith,
+} from './mockMethodMatchers.mjs';
+
+expect.extend({
+  toHaveBeenCalled,
+  toHaveBeenCalledTimes,
+  toHaveBeenCalledWith,
+  toHaveBeenLastCalledWith,
+  toHaveBeenNthCalledWith,
+});

package/lib/mockMethodMatchers.mjs

@@ -0,0 +1,256 @@
+import { expect } from 'expect';
+import { matcherHint, printExpected, printReceived } from 'jest-matcher-utils';
+
+/**
+ * toHaveBeenCalled
+ */
+function toHaveBeenCalled(method) {
+  expect(typeof method).toBe('function');
+
+  // detect native node test runner mock
+  if (typeof method.mock === 'object') {
+    const matcherName = 'toHaveBeenCalled';
+    const options = {
+      isNot: this.isNot,
+      promise: this.promise,
+    };
+
+    const pass = method.mock.calls.length > 0;
+
+    if (pass) {
+      return {
+        pass,
+        message: () =>
+          `${matcherHint(
+            matcherName,
+            undefined,
+            undefined,
+            options
+          )}\nexpected ${method.name} not to be called`,
+      };
+    }
+
+    return {
+      pass,
+      message: () =>
+        `${matcherHint(matcherName, undefined, undefined, options)}\nexpected ${
+          method.name
+        }  to be called`,
+    };
+  }
+
+  return expect(method).toHaveBeenCalled();
+}
+
+/**
+ * toHaveBeenCalledTimes
+ */
+function toHaveBeenCalledTimes(method, expected) {
+  expect(typeof method).toBe('function');
+
+  // detect native node test runßßner mock
+  if (typeof method.mock === 'object') {
+    const matcherName = 'toHaveBeenCalledTimes';
+    const options = {
+      isNot: this.isNot,
+      promise: this.promise,
+    };
+    const received = method.mock.calls.length;
+
+    const pass = received === expected;
+
+    if (pass) {
+      return {
+        pass,
+        message: () =>
+          `${matcherHint(
+            matcherName,
+            undefined,
+            undefined,
+            options
+          )}\nExpected: ${printExpected(expected)}\nReceived: ${printReceived(
+            received
+          )}`,
+      };
+    }
+
+    return {
+      pass,
+      message: () =>
+        `${matcherHint(
+          matcherName,
+          undefined,
+          undefined,
+          options
+        )}\nExpected: ${printExpected(expected)}\nReceived: ${printReceived(
+          received
+        )}`,
+    };
+  }
+
+  return expect(method).toHaveBeenCalledTimes(expected);
+}
+
+/**
+ * toHaveBeenCalledWith
+ */
+function toHaveBeenCalledWith(method, ...args) {
+  expect(typeof method).toBe('function');
+
+  // detect native node test runner mock
+  if (typeof method.mock === 'object') {
+    expect(method.mock.calls.length).toBeGreaterThan(0);
+
+    const matcherName = 'toHaveBeenCalledWith';
+    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);
+    });
+
+    if (pass) {
+      return {
+        pass,
+        message: () =>
+          `${matcherHint(
+            matcherName,
+            undefined,
+            undefined,
+            options
+          )}\nExpected: ${printExpected(...args)}\nReceived: ${receivedArgs.map(
+            args => args.map(arg => printReceived(arg)).join(', ')
+          )}`,
+      };
+    }
+
+    return {
+      pass,
+      message: () =>
+        `${matcherHint(
+          matcherName,
+          undefined,
+          undefined,
+          options
+        )}\nExpected: ${printExpected(...args)}\nReceived: ${receivedArgs.map(
+          args => args.map(arg => printReceived(arg)).join(', ')
+        )}`,
+    };
+  }
+
+  return expect(method).toHaveBeenCalledWith(...args);
+}
+
+/**
+ * toHaveBeenLastCalledWith
+ */
+function toHaveBeenLastCalledWith(method, ...args) {
+  expect(typeof method).toBe('function');
+
+  // detect native node test runner mock
+  if (typeof method.mock === 'object') {
+    expect(method.mock.calls.length).toBeGreaterThan(0);
+
+    const matcherName = 'toHaveBeenLastCalledWith';
+    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);
+
+    if (pass) {
+      return {
+        pass,
+        message: () =>
+          `${matcherHint(
+            matcherName,
+            undefined,
+            undefined,
+            options
+          )}\nExpected: ${printExpected(
+            ...args
+          )}\nReceived: ${lastCall.arguments.map(arg => printReceived(arg))}`,
+      };
+    }
+
+    return {
+      pass,
+      message: () =>
+        `${matcherHint(
+          matcherName,
+          undefined,
+          undefined,
+          options
+        )}\nExpected: ${printExpected(
+          ...args
+        )}\nReceived: ${lastCall.arguments.map(arg => printReceived(arg))}`,
+    };
+  }
+
+  return expect(method).toHaveBeenLastCalledWith(...args);
+}
+
+/**
+ * toHaveBeenNthCalledWith
+ */
+function toHaveBeenNthCalledWith(method, nthCall, ...args) {
+  expect(typeof method).toBe('function');
+
+  // detect native node test runner mock
+  if (typeof method.mock === 'object') {
+    expect(method.mock.calls.length).toBeGreaterThan(nthCall - 1);
+
+    const matcherName = 'toHaveBeenNthCalledWith';
+    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);
+
+    if (pass) {
+      return {
+        pass,
+        message: () =>
+          `${matcherHint(
+            matcherName,
+            undefined,
+            undefined,
+            options
+          )}\nExpected: ${printExpected(
+            ...args
+          )}\nReceived: ${lastCall.arguments.map(arg => printReceived(arg))}`,
+      };
+    }
+
+    return {
+      pass,
+      message: () =>
+        `${matcherHint(
+          matcherName,
+          undefined,
+          undefined,
+          options
+        )}\nExpected: ${printExpected(
+          ...args
+        )}\nReceived: ${lastCall.arguments.map(arg => printReceived(arg))}`,
+    };
+  }
+
+  return expect(method).toHaveBeenNthCalledWith(nthCall, ...args);
+}
+
+export {
+  toHaveBeenCalled,
+  toHaveBeenCalledTimes,
+  toHaveBeenCalledWith,
+  toHaveBeenLastCalledWith,
+  toHaveBeenNthCalledWith,
+};

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "expect-matcher-node-mock",
+  "version": "1.0.0",
+  "description": "Jest matcher for Node.js mock objects",
+  "main": "lib/index.mjs",
+  "bugs": {
+    "url": "https://github.com/crysadrak/expect-matcher-node-mock/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/crysadrak/expect-matcher-node-mock"
+  },
+  "license": "MIT",
+  "author": "Crysa Drak <cd@l33t.cz>",
+  "scripts": {
+    "lint": "eslint --cache --cache-location=node_modules/.cache/ './**/*.{js,jsx,ts,tsx,mjs}'",
+    "test": "node --test --test-reporter=spec"
+  },
+  "devDependencies": {
+    "eslint": "^8.27.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-import": "^2.27.5",
+    "eslint-plugin-prettier": "^4.2.1",
+    "prettier": "^2.8.4"
+  },
+  "dependencies": {
+    "expect": "29.7.0",
+    "jest-matcher-utils": "29.7.0"
+  }
+}