eslint-plugin-jest 26.8.5 → 26.9.0

package/README.md

@@ -226,6 +226,7 @@ installations requiring long-term consistency.
 | [no-test-return-statement](docs/rules/no-test-return-statement.md)           | Disallow explicitly returning from tests                            |                  |              |
 | [prefer-called-with](docs/rules/prefer-called-with.md)                       | Suggest using `toBeCalledWith()` or `toHaveBeenCalledWith()`        |                  |              |
 | [prefer-comparison-matcher](docs/rules/prefer-comparison-matcher.md)         | Suggest using the built-in comparison matchers                      |                  | ![fixable][] |
+| [prefer-each](docs/rules/prefer-each.md)                                     | Prefer using `.each` rather than manual loops                       |                  |              |
 | [prefer-equality-matcher](docs/rules/prefer-equality-matcher.md)             | Suggest using the built-in equality matchers                        |                  | ![suggest][] |
 | [prefer-expect-assertions](docs/rules/prefer-expect-assertions.md)           | Suggest using `expect.assertions()` OR `expect.hasAssertions()`     |                  | ![suggest][] |
 | [prefer-expect-resolves](docs/rules/prefer-expect-resolves.md)               | Prefer `await expect(...).resolves` over `expect(await ...)` syntax |                  | ![fixable][] |

package/docs/rules/prefer-each.md

@@ -0,0 +1,54 @@
+# Prefer using `.each` rather than manual loops (`prefer-each`)
+
+Reports where you might be able to use `.each` instead of native loops.
+
+## Rule details
+
+This rule triggers a warning if you use test case functions like `describe`,
+`test`, and `it`, in a native loop - generally you should be able to use `.each`
+instead which gives better output and makes it easier to run specific cases.
+
+Examples of **incorrect** code for this rule:
+
+```js
+for (const number of getNumbers()) {
+  it('is greater than five', function () {
+    expect(number).toBeGreaterThan(5);
+  });
+}
+
+for (const [input, expected] of data) {
+  beforeEach(() => setupSomething(input));
+
+  test(`results in ${expected}`, () => {
+    expect(doSomething()).toBe(expected);
+  });
+}
+```
+
+Examples of **correct** code for this rule:
+
+```js
+it.each(getNumbers())(
+  'only returns numbers that are greater than seven',
+  number => {
+    expect(number).toBeGreaterThan(7);
+  },
+);
+
+describe.each(data)('when input is %s', ([input, expected]) => {
+  beforeEach(() => setupSomething(input));
+
+  test(`results in ${expected}`, () => {
+    expect(doSomething()).toBe(expected);
+  });
+});
+
+// we don't warn on loops _in_ test functions because those typically involve
+// complex setup that is better done in the test function itself
+it('returns numbers that are greater than five', () => {
+  for (const number of getNumbers()) {
+    expect(number).toBeGreaterThan(5);
+  }
+});
+```

package/lib/rules/max-expects.js

@@ -41,7 +41,7 @@ var _default = (0, _utils2.createRule)({
   }]) {
     let count = 0;
 
-    const onFunctionExpressionEnter = node => {
+    const maybeResetCount = 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']);
@@ -52,8 +52,10 @@ var _default = (0, _utils2.createRule)({
     };
 
     return {
-      FunctionExpression: onFunctionExpressionEnter,
-      ArrowFunctionExpression: onFunctionExpressionEnter,
+      FunctionExpression: maybeResetCount,
+      'FunctionExpression:exit': maybeResetCount,
+      ArrowFunctionExpression: maybeResetCount,
+      'ArrowFunctionExpression:exit': maybeResetCount,
 
       CallExpression(node) {
         var _jestFnCall$head$node;

package/lib/rules/prefer-each.js

@@ -0,0 +1,102 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _utils = require("./utils");
+
+var _default = (0, _utils.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      category: 'Best Practices',
+      description: 'Prefer using `.each` rather than manual loops',
+      recommended: false
+    },
+    messages: {
+      preferEach: 'prefer using `{{ fn }}.each` rather than a manual loop'
+    },
+    type: 'suggestion',
+    schema: []
+  },
+  defaultOptions: [],
+
+  create(context) {
+    const jestFnCalls = [];
+    let inTestCaseCall = false;
+
+    const recommendFn = () => {
+      if (jestFnCalls.length === 1 && jestFnCalls[0] === 'test') {
+        return 'it';
+      }
+
+      return 'describe';
+    };
+
+    const enterForLoop = () => {
+      if (jestFnCalls.length === 0 || inTestCaseCall) {
+        return;
+      }
+
+      jestFnCalls.length = 0;
+    };
+
+    const exitForLoop = node => {
+      if (jestFnCalls.length === 0 || inTestCaseCall) {
+        return;
+      }
+
+      context.report({
+        node,
+        messageId: 'preferEach',
+        data: {
+          fn: recommendFn()
+        }
+      });
+      jestFnCalls.length = 0;
+    };
+
+    return {
+      ForStatement: enterForLoop,
+      'ForStatement:exit': exitForLoop,
+      ForInStatement: enterForLoop,
+      'ForInStatement:exit': exitForLoop,
+      ForOfStatement: enterForLoop,
+      'ForOfStatement:exit': exitForLoop,
+
+      CallExpression(node) {
+        var _parseJestFnCall;
+
+        const {
+          type: jestFnCallType
+        } = (_parseJestFnCall = (0, _utils.parseJestFnCall)(node, context)) !== null && _parseJestFnCall !== void 0 ? _parseJestFnCall : {};
+
+        if (jestFnCallType === 'hook' || jestFnCallType === 'describe' || jestFnCallType === 'test') {
+          jestFnCalls.push(jestFnCallType);
+        }
+
+        if (jestFnCallType === 'test') {
+          inTestCaseCall = true;
+        }
+      },
+
+      'CallExpression:exit'(node) {
+        var _parseJestFnCall2;
+
+        const {
+          type: jestFnCallType
+        } = (_parseJestFnCall2 = (0, _utils.parseJestFnCall)(node, context)) !== null && _parseJestFnCall2 !== void 0 ? _parseJestFnCall2 : {};
+
+        if (jestFnCallType === 'test') {
+          inTestCaseCall = false;
+        }
+      }
+
+    };
+  }
+
+});
+
+exports.default = _default;

package/lib/rules/prefer-expect-assertions.js

@@ -32,8 +32,10 @@ const suggestRemovingExtraArguments = (args, extraArgsStartAt) => ({
   fix: fixer => fixer.removeRange([args[extraArgsStartAt].range[0] - Math.sign(extraArgsStartAt), args[args.length - 1].range[1]])
 });
 
-const suggestions = [['suggestAddingHasAssertions', 'expect.hasAssertions();'], ['suggestAddingAssertions', 'expect.assertions();']];
-
+// const suggestions: Array<[MessageIds, string]> = [
+//   ['suggestAddingHasAssertions', 'expect.hasAssertions();'],
+//   ['suggestAddingAssertions', 'expect.assertions();'],
+// ];
 var _default = (0, _utils2.createRule)({
   name: __filename,
   meta: {
@@ -213,11 +215,7 @@ var _default = (0, _utils2.createRule)({
 
         const [, testFn] = node.arguments;
 
-        if (!(0, _utils2.isFunction)(testFn) || testFn.body.type !== _utils.AST_NODE_TYPES.BlockStatement) {
-          return;
-        }
-
-        if (!shouldCheckFunction(testFn)) {
+        if (!(0, _utils2.isFunction)(testFn) || !shouldCheckFunction(testFn)) {
           return;
         }
 
@@ -229,6 +227,12 @@ var _default = (0, _utils2.createRule)({
           return;
         }
 
+        const suggestions = [];
+
+        if (testFn.body.type === _utils.AST_NODE_TYPES.BlockStatement) {
+          suggestions.push(['suggestAddingHasAssertions', 'expect.hasAssertions();'], ['suggestAddingAssertions', 'expect.assertions();']);
+        }
+
         context.report({
           messageId: 'haveExpectAssertions',
           node,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-jest",
-  "version": "26.8.5",
+  "version": "26.9.0",
   "description": "ESLint rules for Jest",
   "keywords": [
     "eslint",
@@ -151,7 +151,7 @@
       "optional": true
     }
   },
-  "packageManager": "yarn@3.2.2",
+  "packageManager": "yarn@3.2.3",
   "engines": {
     "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
   }