eslint-plugin-jest 26.5.1 → 26.6.0

package/README.md

@@ -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][] |              |
@@ -267,9 +268,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/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-comparison-matcher.js

@@ -108,7 +108,10 @@ var _default = (0, _utils2.createRule)({
           return;
         }
 
-        const preferredMatcher = determineMatcher(comparison.operator, (0, _utils2.followTypeAssertionChain)(matcher.arguments[0]).value === !!modifier);
+        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;
+        const preferredMatcher = determineMatcher(comparison.operator, (0, _utils2.followTypeAssertionChain)(matcher.arguments[0]).value === !!negation);
 
         if (!preferredMatcher) {
           return;
@@ -116,10 +119,12 @@ var _default = (0, _utils2.createRule)({
 
         context.report({
           fix(fixer) {
-            const sourceCode = context.getSourceCode();
+            const sourceCode = context.getSourceCode(); // preserve the existing modifier if it's not a negation
+
+            const modifierText = modifier && (modifier === null || modifier === void 0 ? void 0 : modifier.node) !== (negation === null || negation === void 0 ? void 0 : negation.node) ? `.${modifier.name}` : '';
             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]], `.${preferredMatcher}`), // replace the matcher argument with the right-hand side of the comparison
+            fixer.replaceTextRange([expectCallEnd, matcher.node.range[1]], `${modifierText}.${preferredMatcher}`), // replace the matcher argument with the right-hand side of the comparison
             fixer.replaceText(matcher.arguments[0], sourceCode.getText(comparison.right))];
           },
 
@@ -127,7 +132,7 @@ var _default = (0, _utils2.createRule)({
           data: {
             preferredMatcher
           },
-          node: (modifier || matcher).node.property
+          node: (negation || 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: (negation || 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-jest",
-  "version": "26.5.1",
+  "version": "26.6.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"
 }