eslint-plugin-jest 27.0.0-next.2 → 27.0.2

package/README.md

@@ -225,6 +225,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/no-deprecated-functions.md

@@ -20,13 +20,12 @@ This rule can also autofix a number of these deprecations for you.
 
 ### `jest.resetModuleRegistry`
 
-This function was renamed to `resetModules` in Jest 15, and is scheduled for
-removal in Jest 27.
+This function was renamed to `resetModules` in Jest 15 and removed in Jest 27.
 
 ### `jest.addMatchers`
 
-This function was replaced with `expect.extend` in Jest 17, and is scheduled for
-removal in Jest 27.
+This function was replaced with `expect.extend` in Jest 17 and removed in
+Jest 27.
 
 ### `require.requireActual` & `require.requireMock`
 
@@ -41,10 +40,10 @@ the release of Jest 26 saw them removed from the `require` function altogether.
 
 ### `jest.runTimersToTime`
 
-This function was renamed to `advanceTimersByTime` in Jest 22, and is scheduled
-for removal in Jest 27.
+This function was renamed to `advanceTimersByTime` in Jest 22 and removed in
+Jest 27.
 
 ### `jest.genMockFromModule`
 
 This function was renamed to `createMockFromModule` in Jest 26, and is scheduled
-for removal in a future version of Jest.
+for removal in Jest 30.

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/no-done-callback.js

@@ -33,8 +33,7 @@ var _default = (0, _utils2.createRule)({
     docs: {
       category: 'Best Practices',
       description: 'Avoid using a callback in asynchronous tests and hooks',
-      recommended: 'error',
-      suggestion: true
+      recommended: 'error'
     },
     messages: {
       noDoneCallback: 'Return a Promise instead of relying on callback parameter',

package/lib/rules/no-focused-tests.js

@@ -15,8 +15,7 @@ var _default = (0, _utils2.createRule)({
     docs: {
       category: 'Best Practices',
       description: 'Disallow focused tests',
-      recommended: 'error',
-      suggestion: true
+      recommended: 'error'
     },
     messages: {
       focusedTest: 'Unexpected focused test.',

package/lib/rules/no-restricted-matchers.js

@@ -7,6 +7,14 @@ exports.default = void 0;
 
 var _utils = require("./utils");
 
+const isChainRestricted = (chain, restriction) => {
+  if (_utils.ModifierName.hasOwnProperty(restriction) || restriction.endsWith('.not')) {
+    return chain.startsWith(restriction);
+  }
+
+  return chain === restriction;
+};
+
 var _default = (0, _utils.createRule)({
   name: __filename,
   meta: {
@@ -41,7 +49,7 @@ var _default = (0, _utils.createRule)({
         const chain = jestFnCall.members.map(nod => (0, _utils.getAccessorValue)(nod)).join('.');
 
         for (const [restriction, message] of Object.entries(restrictedChains)) {
-          if (chain.startsWith(restriction)) {
+          if (isChainRestricted(chain, restriction)) {
             context.report({
               messageId: message ? 'restrictedChainWithMessage' : 'restrictedChain',
               data: {

package/lib/rules/prefer-each.js

@@ -0,0 +1,98 @@
+"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) {
+        const {
+          type: jestFnCallType
+        } = (0, _utils.parseJestFnCall)(node, context) ?? {};
+
+        if (jestFnCallType === 'hook' || jestFnCallType === 'describe' || jestFnCallType === 'test') {
+          jestFnCalls.push(jestFnCallType);
+        }
+
+        if (jestFnCallType === 'test') {
+          inTestCaseCall = true;
+        }
+      },
+
+      'CallExpression:exit'(node) {
+        const {
+          type: jestFnCallType
+        } = (0, _utils.parseJestFnCall)(node, context) ?? {};
+
+        if (jestFnCallType === 'test') {
+          inTestCaseCall = false;
+        }
+      }
+
+    };
+  }
+
+});
+
+exports.default = _default;

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

@@ -15,8 +15,7 @@ var _default = (0, _utils2.createRule)({
     docs: {
       category: 'Best Practices',
       description: 'Suggest using the built-in equality matchers',
-      recommended: false,
-      suggestion: true
+      recommended: false
     },
     messages: {
       useEqualityMatcher: 'Prefer using one of the equality matchers instead',

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

@@ -13,10 +13,16 @@ const isFirstStatement = node => {
   let parent = node;
 
   while (parent) {
-    var _parent$parent;
+    var _parent$parent, _parent$parent2;
 
     if (((_parent$parent = parent.parent) === null || _parent$parent === void 0 ? void 0 : _parent$parent.type) === _utils.AST_NODE_TYPES.BlockStatement) {
       return parent.parent.body[0] === parent;
+    } // if we've hit an arrow function, then it must have a single expression
+    // as its body, as otherwise we would have hit the block statement already
+
+
+    if (((_parent$parent2 = parent.parent) === null || _parent$parent2 === void 0 ? void 0 : _parent$parent2.type) === _utils.AST_NODE_TYPES.ArrowFunctionExpression) {
+      return true;
     }
 
     parent = parent.parent;
@@ -32,18 +38,13 @@ const suggestRemovingExtraArguments = (args, extraArgsStartAt) => ({
   fix: fixer => fixer.removeRange([args[extraArgsStartAt].range[0] - Math.sign(extraArgsStartAt), args[args.length - 1].range[1]])
 });
 
-// const suggestions: Array<[MessageIds, string]> = [
-//   ['suggestAddingHasAssertions', 'expect.hasAssertions();'],
-//   ['suggestAddingAssertions', 'expect.assertions();'],
-// ];
 var _default = (0, _utils2.createRule)({
   name: __filename,
   meta: {
     docs: {
       category: 'Best Practices',
       description: 'Suggest using `expect.assertions()` OR `expect.hasAssertions()`',
-      recommended: false,
-      suggestion: true
+      recommended: false
     },
     messages: {
       hasAssertionsTakesNoArguments: '`expect.hasAssertions` expects no arguments',

package/lib/rules/prefer-strict-equal.js

@@ -13,8 +13,7 @@ var _default = (0, _utils.createRule)({
     docs: {
       category: 'Best Practices',
       description: 'Suggest using `toStrictEqual()`',
-      recommended: false,
-      suggestion: true
+      recommended: false
     },
     messages: {
       useToStrictEqual: 'Use `toStrictEqual()` instead',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-jest",
-  "version": "27.0.0-next.2",
+  "version": "27.0.2",
   "description": "ESLint rules for Jest",
   "keywords": [
     "eslint",
@@ -109,7 +109,7 @@
     "@semantic-release/changelog": "^6.0.0",
     "@semantic-release/git": "^10.0.0",
     "@types/dedent": "^0.7.0",
-    "@types/jest": "^28.0.0",
+    "@types/jest": "^29.0.0",
     "@types/node": "^14.18.26",
     "@types/prettier": "^2.0.0",
     "@typescript-eslint/eslint-plugin": "^5.0.0",
@@ -151,7 +151,7 @@
       "optional": true
     }
   },
-  "packageManager": "yarn@3.2.2",
+  "packageManager": "yarn@3.2.3",
   "engines": {
     "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
   }