eslint-plugin-jest 26.5.2 → 26.7.0

package/README.md

@@ -1,6 +1,6 @@
 <div align="center">
   <a href="https://eslint.org/">
-    <img width="150" height="150" src="https://eslint.org/assets/img/logo.svg">
+    <img width="150" height="150" src="https://eslint.org/assets/images/logo/eslint-logo-color.svg">
   </a>
   <a href="https://facebook.github.io/jest/">
     <img width="150" height="150" vspace="" hspace="25" src="https://jestjs.io/img/jest.png">
@@ -201,6 +201,7 @@ installations requiring long-term consistency.
 | ---------------------------------------------------------------------------- | ------------------------------------------------------------------- | ---------------- | ------------ |
 | [consistent-test-it](docs/rules/consistent-test-it.md)                       | Have control over `test` and `it` usages                            |                  | ![fixable][] |
 | [expect-expect](docs/rules/expect-expect.md)                                 | Enforce assertion to be made in a test body                         | ![recommended][] |              |
+| [max-expects](docs/rules/max-expects.md)                                     | Enforces a maximum number assertion calls in a test body            |                  |              |
 | [max-nested-describe](docs/rules/max-nested-describe.md)                     | Enforces a maximum depth to nested describe calls                   |                  |              |
 | [no-alias-methods](docs/rules/no-alias-methods.md)                           | Disallow alias methods                                              | ![style][]       | ![fixable][] |
 | [no-commented-out-tests](docs/rules/no-commented-out-tests.md)               | Disallow commented out tests                                        | ![recommended][] |              |
@@ -231,6 +232,7 @@ installations requiring long-term consistency.
 | [prefer-hooks-in-order](docs/rules/prefer-hooks-in-order.md)                 | Prefer having hooks in a consistent order                           |                  |              |
 | [prefer-hooks-on-top](docs/rules/prefer-hooks-on-top.md)                     | Suggest having hooks before any test cases                          |                  |              |
 | [prefer-lowercase-title](docs/rules/prefer-lowercase-title.md)               | Enforce lowercase test names                                        |                  | ![fixable][] |
+| [prefer-mock-promise-shorthand](docs/rules/prefer-mock-promise-shorthand.md) | Prefer mock resolved/rejected shorthands for promises               |                  | ![fixable][] |
 | [prefer-snapshot-hint](docs/rules/prefer-snapshot-hint.md)                   | Prefer including a hint with external snapshots                     |                  |              |
 | [prefer-spy-on](docs/rules/prefer-spy-on.md)                                 | Suggest using `jest.spyOn()`                                        |                  | ![fixable][] |
 | [prefer-strict-equal](docs/rules/prefer-strict-equal.md)                     | Suggest using `toStrictEqual()`                                     |                  | ![suggest][] |
@@ -267,9 +269,9 @@ as it extends the original `unbound-method` rule from that plugin.
 
 <!-- begin type rules list -->
 
-| Rule                                           | Description                                                   | Configurations | Fixable |
-| ---------------------------------------------- | ------------------------------------------------------------- | -------------- | ------- |
-| [unbound-method](docs/rules/unbound-method.md) | Enforces unbound methods are called with their expected scope |                |         |
+| Rule                                           | Description                                                  | Configurations | Fixable |
+| ---------------------------------------------- | ------------------------------------------------------------ | -------------- | ------- |
+| [unbound-method](docs/rules/unbound-method.md) | Enforce unbound methods are called with their expected scope |                |         |
 
 <!-- end type rules list -->
 

package/docs/rules/max-expects.md

@@ -0,0 +1,74 @@
+# Enforces a maximum number assertion calls in a test body (`max-expects`)
+
+As more assertions are made, there is a possible tendency for the test to be
+more likely to mix multiple objectives. To avoid this, this rule reports when
+the maximum number of assertions is exceeded.
+
+## Rule Details
+
+This rule enforces a maximum number of `expect()` calls.
+
+The following patterns are considered warnings (with the default option of
+`{ "max": 5 } `):
+
+```js
+test('should not pass', () => {
+  expect(true).toBeDefined();
+  expect(true).toBeDefined();
+  expect(true).toBeDefined();
+  expect(true).toBeDefined();
+  expect(true).toBeDefined();
+  expect(true).toBeDefined();
+});
+
+it('should not pass', () => {
+  expect(true).toBeDefined();
+  expect(true).toBeDefined();
+  expect(true).toBeDefined();
+  expect(true).toBeDefined();
+  expect(true).toBeDefined();
+  expect(true).toBeDefined();
+});
+```
+
+The following patterns are **not** considered warnings (with the default option
+of `{ "max": 5 } `):
+
+```js
+test('shout pass');
+
+test('shout pass', () => {});
+
+test.skip('shout pass', () => {});
+
+test('should pass', function () {
+  expect(true).toBeDefined();
+});
+
+test('should pass', () => {
+  expect(true).toBeDefined();
+  expect(true).toBeDefined();
+  expect(true).toBeDefined();
+  expect(true).toBeDefined();
+  expect(true).toBeDefined();
+});
+```
+
+## Options
+
+```json
+{
+  "jest/max-expects": [
+    "error",
+    {
+      "max": 5
+    }
+  ]
+}
+```
+
+### `max`
+
+Enforces a maximum number of `expect()`.
+
+This has a default value of `5`.

package/docs/rules/prefer-hooks-in-order.md

@@ -130,4 +130,4 @@ describe('foo', () => {
 
 ## Further Reading
 
-- [Order of execution of describe and test blocks](https://jestjs.io/docs/setup-teardown#order-of-execution-of-describe-and-test-blocks)
+- [Order of Execution](https://jestjs.io/docs/setup-teardown#order-of-execution)

package/docs/rules/prefer-mock-promise-shorthand.md

@@ -0,0 +1,34 @@
+# Prefer mock resolved/rejected shorthands for promises (`prefer-mock-promise-shorthand`)
+
+When working with mocks of functions that return promises, Jest provides some
+API sugar functions to reduce the amount of boilerplate you have to write.
+
+These methods should be preferred when possible.
+
+## Rule Details
+
+The following patterns are warnings:
+
+```js
+jest.fn().mockImplementation(() => Promise.resolve(123));
+jest
+  .spyOn(fs.promises, 'readFile')
+  .mockReturnValue(Promise.reject(new Error('oh noes!')));
+
+myFunction
+  .mockReturnValueOnce(Promise.resolve(42))
+  .mockImplementationOnce(() => Promise.resolve(42))
+  .mockReturnValue(Promise.reject(new Error('too many calls!')));
+```
+
+The following patterns are not warnings:
+
+```js
+jest.fn().mockResolvedValue(123);
+jest.spyOn(fs.promises, 'readFile').mockRejectedValue(new Error('oh noes!'));
+
+myFunction
+  .mockResolvedValueOnce(42)
+  .mockResolvedValueOnce(42)
+  .mockRejectedValue(new Error('too many calls!'));
+```

package/docs/rules/unbound-method.md

@@ -1,4 +1,4 @@
-# Enforces unbound methods are called with their expected scope (`unbound-method`)
+# Enforce unbound methods are called with their expected scope (`unbound-method`)
 
 ## Rule Details
 

package/lib/rules/max-expects.js

@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _utils = require("@typescript-eslint/utils");
+
+var _utils2 = require("./utils");
+
+var _default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      category: 'Best Practices',
+      description: 'Enforces a maximum number assertion calls in a test body',
+      recommended: false
+    },
+    messages: {
+      exceededMaxAssertion: 'Too many assertion calls ({{ count }}). Maximum allowed is {{ max }}.'
+    },
+    type: 'suggestion',
+    schema: [{
+      type: 'object',
+      properties: {
+        max: {
+          type: 'integer',
+          minimum: 1
+        }
+      },
+      additionalProperties: false
+    }]
+  },
+  defaultOptions: [{
+    max: 5
+  }],
+
+  create(context, [{
+    max
+  }]) {
+    let count = 0;
+
+    const onFunctionExpressionEnter = node => {
+      var _node$parent;
+
+      const isTestFn = ((_node$parent = node.parent) === null || _node$parent === void 0 ? void 0 : _node$parent.type) !== _utils.AST_NODE_TYPES.CallExpression || (0, _utils2.isTypeOfJestFnCall)(node.parent, context, ['test']);
+
+      if (isTestFn) {
+        count = 0;
+      }
+    };
+
+    return {
+      FunctionExpression: onFunctionExpressionEnter,
+      ArrowFunctionExpression: onFunctionExpressionEnter,
+
+      CallExpression(node) {
+        if (!(0, _utils2.isExpectCall)(node)) {
+          return;
+        }
+
+        count += 1;
+
+        if (count > max) {
+          context.report({
+            node,
+            messageId: 'exceededMaxAssertion',
+            data: {
+              count,
+              max
+            }
+          });
+        }
+      }
+
+    };
+  }
+
+});
+
+exports.default = _default;

package/lib/rules/prefer-called-with.js

@@ -16,7 +16,7 @@ var _default = (0, _utils.createRule)({
       recommended: false
     },
     messages: {
-      preferCalledWith: 'Prefer {{name}}With(/* expected args */)'
+      preferCalledWith: 'Prefer {{ matcherName }}With(/* expected args */)'
     },
     type: 'suggestion',
     schema: []
@@ -42,7 +42,7 @@ var _default = (0, _utils.createRule)({
         if (['toBeCalled', 'toHaveBeenCalled'].includes(matcher.name)) {
           context.report({
             data: {
-              name: matcher.name
+              matcherName: matcher.name
             },
             messageId: 'preferCalledWith',
             node: matcher.node.property

package/lib/rules/prefer-comparison-matcher.js

@@ -132,7 +132,7 @@ var _default = (0, _utils2.createRule)({
           data: {
             preferredMatcher
           },
-          node: (negation || matcher).node.property
+          node: matcher.node.property
         });
       }
 

package/lib/rules/prefer-equality-matcher.js

@@ -64,16 +64,26 @@ var _default = (0, _utils2.createRule)({
           return;
         }
 
-        const matcherValue = (0, _utils2.followTypeAssertionChain)(matcher.arguments[0]).value; // we need to negate the expectation if the current expected
+        const matcherValue = (0, _utils2.followTypeAssertionChain)(matcher.arguments[0]).value;
+        const negation = modifier !== null && modifier !== void 0 && modifier.negation ? {
+          node: modifier.negation
+        } : (modifier === null || modifier === void 0 ? void 0 : modifier.name) === _utils2.ModifierName.not ? modifier : null; // we need to negate the expectation if the current expected
         // value is itself negated by the "not" modifier
 
-        const addNotModifier = (comparison.operator === '!==' ? !matcherValue : matcherValue) === !!modifier;
+        const addNotModifier = (comparison.operator === '!==' ? !matcherValue : matcherValue) === !!negation;
 
         const buildFixer = equalityMatcher => fixer => {
-          const sourceCode = context.getSourceCode();
+          const sourceCode = context.getSourceCode(); // preserve the existing modifier if it's not a negation
+
+          let modifierText = modifier && (modifier === null || modifier === void 0 ? void 0 : modifier.node) !== (negation === null || negation === void 0 ? void 0 : negation.node) ? `.${modifier.name}` : '';
+
+          if (addNotModifier) {
+            modifierText += `.${_utils2.ModifierName.not}`;
+          }
+
           return [// replace the comparison argument with the left-hand side of the comparison
           fixer.replaceText(comparison, sourceCode.getText(comparison.left)), // replace the current matcher & modifier with the preferred matcher
-          fixer.replaceTextRange([expectCallEnd, matcher.node.range[1]], addNotModifier ? `.${_utils2.ModifierName.not}.${equalityMatcher}` : `.${equalityMatcher}`), // replace the matcher argument with the right-hand side of the comparison
+          fixer.replaceTextRange([expectCallEnd, matcher.node.range[1]], `${modifierText}.${equalityMatcher}`), // replace the matcher argument with the right-hand side of the comparison
           fixer.replaceText(matcher.arguments[0], sourceCode.getText(comparison.right))];
         };
 
@@ -86,7 +96,7 @@ var _default = (0, _utils2.createRule)({
             },
             fix: buildFixer(equalityMatcher)
           })),
-          node: (modifier || matcher).node.property
+          node: matcher.node.property
         });
       }
 

package/lib/rules/prefer-mock-promise-shorthand.js

@@ -0,0 +1,111 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _utils = require("@typescript-eslint/utils");
+
+var _utils2 = require("./utils");
+
+const withOnce = (name, addOnce) => {
+  return `${name}${addOnce ? 'Once' : ''}`;
+};
+
+const findSingleReturnArgumentNode = fnNode => {
+  var _fnNode$body$body$;
+
+  if (fnNode.body.type !== _utils.AST_NODE_TYPES.BlockStatement) {
+    return fnNode.body;
+  }
+
+  if (((_fnNode$body$body$ = fnNode.body.body[0]) === null || _fnNode$body$body$ === void 0 ? void 0 : _fnNode$body$body$.type) === _utils.AST_NODE_TYPES.ReturnStatement) {
+    return fnNode.body.body[0].argument;
+  }
+
+  return null;
+};
+
+var _default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      category: 'Best Practices',
+      description: 'Prefer mock resolved/rejected shorthands for promises',
+      recommended: false
+    },
+    messages: {
+      useMockShorthand: 'Prefer {{ replacement }}'
+    },
+    schema: [],
+    type: 'suggestion',
+    fixable: 'code'
+  },
+  defaultOptions: [],
+
+  create(context) {
+    const report = (property, isOnce, outerArgNode, innerArgNode = outerArgNode) => {
+      if ((innerArgNode === null || innerArgNode === void 0 ? void 0 : innerArgNode.type) !== _utils.AST_NODE_TYPES.CallExpression) {
+        return;
+      }
+
+      const argName = (0, _utils2.getNodeName)(innerArgNode);
+
+      if (argName !== 'Promise.resolve' && argName !== 'Promise.reject') {
+        return;
+      }
+
+      const replacement = withOnce(argName.endsWith('reject') ? 'mockRejectedValue' : 'mockResolvedValue', isOnce);
+      context.report({
+        node: property,
+        messageId: 'useMockShorthand',
+        data: {
+          replacement
+        },
+
+        fix(fixer) {
+          const sourceCode = context.getSourceCode(); // there shouldn't be more than one argument, but if there is don't try
+          // fixing since we have no idea what to do with the extra arguments
+
+          if (innerArgNode.arguments.length > 1) {
+            return null;
+          }
+
+          return [fixer.replaceText(property, replacement), fixer.replaceText(outerArgNode, // the value argument for both Promise methods is optional,
+          // whereas for Jest they're required so use an explicit undefined
+          // if no argument is being passed to the call we're replacing
+          innerArgNode.arguments.length === 1 ? sourceCode.getText(innerArgNode.arguments[0]) : 'undefined')];
+        }
+
+      });
+    };
+
+    return {
+      CallExpression(node) {
+        if (node.callee.type !== _utils.AST_NODE_TYPES.MemberExpression || !(0, _utils2.isSupportedAccessor)(node.callee.property) || node.arguments.length === 0) {
+          return;
+        }
+
+        const mockFnName = (0, _utils2.getAccessorValue)(node.callee.property);
+        const isOnce = mockFnName.endsWith('Once');
+
+        if (mockFnName === withOnce('mockReturnValue', isOnce)) {
+          report(node.callee.property, isOnce, node.arguments[0]);
+        } else if (mockFnName === withOnce('mockImplementation', isOnce)) {
+          const [arg] = node.arguments;
+
+          if (!(0, _utils2.isFunction)(arg)) {
+            return;
+          }
+
+          report(node.callee.property, isOnce, arg, findSingleReturnArgumentNode(arg));
+        }
+      }
+
+    };
+  }
+
+});
+
+exports.default = _default;

package/lib/rules/prefer-to-contain.js

@@ -86,7 +86,7 @@ var _default = (0, _utils2.createRule)({
           },
 
           messageId: 'useToContain',
-          node: (modifier || matcher).node.property
+          node: matcher.node.property
         });
       }
 

package/lib/rules/unbound-method.js

@@ -60,7 +60,9 @@ var _default = (0, _utils.createRule)({
   name: __filename,
   meta: {
     messages: {
+      // eslint-disable-next-line eslint-plugin/no-unused-message-ids
       unbound: DEFAULT_MESSAGE,
+      // eslint-disable-next-line eslint-plugin/no-unused-message-ids
       unboundWithoutThisAnnotation: DEFAULT_MESSAGE
     },
     schema: [],
@@ -68,7 +70,7 @@ var _default = (0, _utils.createRule)({
     ...(baseRule === null || baseRule === void 0 ? void 0 : baseRule.meta),
     docs: {
       category: 'Best Practices',
-      description: 'Enforces unbound methods are called with their expected scope',
+      description: 'Enforce unbound methods are called with their expected scope',
       requiresTypeChecking: true,
       ...(baseRule === null || baseRule === void 0 ? void 0 : baseRule.meta.docs),
       recommended: false

package/lib/rules/valid-expect.js

@@ -26,7 +26,7 @@ const getPromiseCallExpressionNode = node => {
     node = node.parent;
   }
 
-  if (node.type === _utils.AST_NODE_TYPES.CallExpression && node.callee.type === _utils.AST_NODE_TYPES.MemberExpression && (0, _utils2.isSupportedAccessor)(node.callee.object) && (0, _utils2.getAccessorValue)(node.callee.object) === 'Promise' && node.parent) {
+  if (node.type === _utils.AST_NODE_TYPES.CallExpression && node.callee.type === _utils.AST_NODE_TYPES.MemberExpression && (0, _utils2.isSupportedAccessor)(node.callee.object, 'Promise') && node.parent) {
     return node;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-jest",
-  "version": "26.5.2",
+  "version": "26.7.0",
   "description": "ESLint rules for Jest",
   "keywords": [
     "eslint",
@@ -104,12 +104,12 @@
     "eslint-config-prettier": "^8.3.0",
     "eslint-plugin-eslint-comments": "^3.1.2",
     "eslint-plugin-eslint-config": "^2.0.0",
-    "eslint-plugin-eslint-plugin": "^4.0.1",
+    "eslint-plugin-eslint-plugin": "^5.0.0",
     "eslint-plugin-import": "^2.25.1",
     "eslint-plugin-node": "^11.0.0",
     "eslint-plugin-prettier": "^3.4.1",
-    "eslint-remote-tester": "^2.1.3",
-    "eslint-remote-tester-repositories": "^0.0.5",
+    "eslint-remote-tester": "^3.0.0",
+    "eslint-remote-tester-repositories": "~0.0.5",
     "husky": "^7.0.2",
     "is-ci": "^3.0.0",
     "jest": "^28.0.0",
@@ -156,9 +156,7 @@
     ]
   },
   "resolutions": {
-    "@semantic-release/npm/npm": "7.20.6",
-    "@typescript-eslint/experimental-utils": "^5.0.0",
-    "fsevents/node-gyp": "^7.0.0"
+    "@typescript-eslint/experimental-utils": "^5.0.0"
   },
-  "packageManager": "yarn@3.2.1"
+  "packageManager": "yarn@3.2.2"
 }