eslint-plugin-jest 25.5.0 → 26.1.0-next.1

package/README.md

@@ -158,6 +158,7 @@ installations requiring long-term consistency.
 | [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][] |              |
 | [no-conditional-expect](docs/rules/no-conditional-expect.md)                 | Prevent calling `expect` conditionally                              | ![recommended][] |              |
+| [no-conditional-in-test](docs/rules/no-conditional-in-test.md)               | Disallow conditional logic in tests                                 |                  |              |
 | [no-deprecated-functions](docs/rules/no-deprecated-functions.md)             | Disallow use of deprecated functions                                | ![recommended][] | ![fixable][] |
 | [no-disabled-tests](docs/rules/no-disabled-tests.md)                         | Disallow disabled tests                                             | ![recommended][] |              |
 | [no-done-callback](docs/rules/no-done-callback.md)                           | Avoid using a callback in asynchronous tests and hooks              | ![recommended][] | ![suggest][] |
@@ -177,6 +178,8 @@ installations requiring long-term consistency.
 | [no-test-prefixes](docs/rules/no-test-prefixes.md)                           | Use `.only` and `.skip` over `f` and `x`                            | ![recommended][] | ![fixable][] |
 | [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-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][] |
 | [prefer-hooks-on-top](docs/rules/prefer-hooks-on-top.md)                     | Suggest having hooks before any test cases                          |                  |              |

package/docs/rules/no-conditional-in-test.md

@@ -0,0 +1,79 @@
+# Disallow conditional logic in tests (`no-conditional-in-test`)
+
+Conditional logic in tests is usually an indication that a test is attempting to
+cover too much, and not testing the logic it intends to. Each branch of code
+executing within a conditional statement will usually be better served by a test
+devoted to it.
+
+## Rule Details
+
+This rule reports on any use of a conditional statement such as `if`, `switch`,
+and ternary expressions.
+
+Examples of **incorrect** code for this rule:
+
+```js
+it('foo', () => {
+  if (true) {
+    doTheThing();
+  }
+});
+
+it('bar', () => {
+  switch (mode) {
+    case 'none':
+      generateNone();
+    case 'single':
+      generateOne();
+    case 'multiple':
+      generateMany();
+  }
+
+  expect(fixtures.length).toBeGreaterThan(-1);
+});
+
+it('baz', async () => {
+  const promiseValue = () => {
+    return something instanceof Promise
+      ? something
+      : Promise.resolve(something);
+  };
+
+  await expect(promiseValue()).resolves.toBe(1);
+});
+```
+
+Examples of **correct** code for this rule:
+
+```js
+describe('my tests', () => {
+  if (true) {
+    it('foo', () => {
+      doTheThing();
+    });
+  }
+});
+
+beforeEach(() => {
+  switch (mode) {
+    case 'none':
+      generateNone();
+    case 'single':
+      generateOne();
+    case 'multiple':
+      generateMany();
+  }
+});
+
+it('bar', () => {
+  expect(fixtures.length).toBeGreaterThan(-1);
+});
+
+const promiseValue = something => {
+  return something instanceof Promise ? something : Promise.resolve(something);
+};
+
+it('baz', async () => {
+  await expect(promiseValue()).resolves.toBe(1);
+});
+```

package/docs/rules/prefer-comparison-matcher.md

@@ -0,0 +1,55 @@
+# Suggest using the built-in comparison matchers (`prefer-comparison-matcher`)
+
+Jest has a number of built-in matchers for comparing numbers which allow for
+more readable tests and error messages if an expectation fails.
+
+## Rule details
+
+This rule checks for comparisons in tests that could be replaced with one of the
+following built-in comparison matchers:
+
+- `toBeGreaterThan`
+- `toBeGreaterThanOrEqual`
+- `toBeLessThan`
+- `toBeLessThanOrEqual`
+
+Examples of **incorrect** code for this rule:
+
+```js
+expect(x > 5).toBe(true);
+expect(x < 7).not.toEqual(true);
+expect(x <= y).toStrictEqual(true);
+```
+
+Examples of **correct** code for this rule:
+
+```js
+expect(x).toBeGreaterThan(5);
+expect(x).not.toBeLessThanOrEqual(7);
+expect(x).toBeLessThanOrEqual(y);
+
+// special case - see below
+expect(x < 'Carl').toBe(true);
+```
+
+Note that these matchers only work with numbers and bigints, and that the rule
+assumes that any variables on either side of the comparison operator are of one
+of those types - this means if you're using the comparison operator with
+strings, the fix applied by this rule will result in an error.
+
+```js
+expect(myName).toBeGreaterThanOrEqual(theirName); // Matcher error: received value must be a number or bigint
+```
+
+The reason for this is that comparing strings with these operators is expected
+to be very rare and would mean not being able to have an automatic fixer for
+this rule.
+
+If for some reason you are using these operators to compare strings, you can
+disable this rule using an inline
+[configuration comment](https://eslint.org/docs/user-guide/configuring/rules#disabling-rules):
+
+```js
+// eslint-disable-next-line jest/prefer-comparison-matcher
+expect(myName > theirName).toBe(true);
+```

package/docs/rules/prefer-equality-matcher.md

@@ -0,0 +1,29 @@
+# Suggest using the built-in equality matchers (`prefer-equality-matcher`)
+
+Jest has built-in matchers for expecting equality which allow for more readable
+tests and error messages if an expectation fails.
+
+## Rule details
+
+This rule checks for _strict_ equality checks (`===` & `!==`) in tests that
+could be replaced with one of the following built-in equality matchers:
+
+- `toBe`
+- `toEqual`
+- `toStrictEqual`
+
+Examples of **incorrect** code for this rule:
+
+```js
+expect(x === 5).toBe(true);
+expect(name === 'Carl').not.toEqual(true);
+expect(myObj !== thatObj).toStrictEqual(true);
+```
+
+Examples of **correct** code for this rule:
+
+```js
+expect(x).toBe(5);
+expect(name).not.toEqual('Carl');
+expect(myObj).toStrictEqual(thatObj);
+```

package/docs/rules/valid-expect.md

@@ -38,6 +38,11 @@ This rule is enabled by default.
       type: 'boolean',
       default: false,
     },
+    asyncMatchers: {
+      type: 'array',
+      items: { type: 'string' },
+      default: ['toResolve', 'toReject'],
+    },
     minArgs: {
       type: 'number',
       minimum: 1,
@@ -78,6 +83,14 @@ test('test1', async () => {
 test('test2', () => expect(Promise.resolve(2)).resolves.toBe(2));
 ```
 
+### `asyncMatchers`
+
+Allows specifying which matchers return promises, and so should be considered
+async when checking if an `expect` should be returned or awaited.
+
+By default, this has a list of all the async matchers provided by
+`jest-extended` (namely, `toResolve` and `toReject`).
+
 ### `minArgs` & `maxArgs`
 
 Enforces the minimum and maximum number of arguments that `expect` can take, and

package/lib/rules/consistent-test-it.js

@@ -5,13 +5,13 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _experimentalUtils = require("@typescript-eslint/experimental-utils");
+var _utils = require("@typescript-eslint/utils");
 
-var _utils = require("./utils");
+var _utils2 = require("./utils");
 
-const buildFixer = (callee, nodeName, preferredTestKeyword) => fixer => [fixer.replaceText(callee.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression ? callee.object : callee, getPreferredNodeName(nodeName, preferredTestKeyword))];
+const buildFixer = (callee, nodeName, preferredTestKeyword) => fixer => [fixer.replaceText(callee.type === _utils.AST_NODE_TYPES.MemberExpression ? callee.object : callee, getPreferredNodeName(nodeName, preferredTestKeyword))];
 
-var _default = (0, _utils.createRule)({
+var _default = (0, _utils2.createRule)({
   name: __filename,
   meta: {
     docs: {
@@ -28,10 +28,10 @@ var _default = (0, _utils.createRule)({
       type: 'object',
       properties: {
         fn: {
-          enum: [_utils.TestCaseName.it, _utils.TestCaseName.test]
+          enum: [_utils2.TestCaseName.it, _utils2.TestCaseName.test]
         },
         withinDescribe: {
-          enum: [_utils.TestCaseName.it, _utils.TestCaseName.test]
+          enum: [_utils2.TestCaseName.it, _utils2.TestCaseName.test]
         }
       },
       additionalProperties: false
@@ -39,30 +39,30 @@ var _default = (0, _utils.createRule)({
     type: 'suggestion'
   },
   defaultOptions: [{
-    fn: _utils.TestCaseName.test,
-    withinDescribe: _utils.TestCaseName.it
+    fn: _utils2.TestCaseName.test,
+    withinDescribe: _utils2.TestCaseName.it
   }],
 
   create(context) {
     const configObj = context.options[0] || {};
-    const testKeyword = configObj.fn || _utils.TestCaseName.test;
-    const testKeywordWithinDescribe = configObj.withinDescribe || configObj.fn || _utils.TestCaseName.it;
+    const testKeyword = configObj.fn || _utils2.TestCaseName.test;
+    const testKeywordWithinDescribe = configObj.withinDescribe || configObj.fn || _utils2.TestCaseName.it;
     let describeNestingLevel = 0;
     return {
       CallExpression(node) {
-        const nodeName = (0, _utils.getNodeName)(node.callee);
+        const nodeName = (0, _utils2.getNodeName)(node.callee);
 
         if (!nodeName) {
           return;
         }
 
-        if ((0, _utils.isDescribeCall)(node)) {
+        if ((0, _utils2.isDescribeCall)(node)) {
           describeNestingLevel++;
         }
 
-        const funcNode = node.callee.type === _experimentalUtils.AST_NODE_TYPES.TaggedTemplateExpression ? node.callee.tag : node.callee.type === _experimentalUtils.AST_NODE_TYPES.CallExpression ? node.callee.callee : node.callee;
+        const funcNode = node.callee.type === _utils.AST_NODE_TYPES.TaggedTemplateExpression ? node.callee.tag : node.callee.type === _utils.AST_NODE_TYPES.CallExpression ? node.callee.callee : node.callee;
 
-        if ((0, _utils.isTestCaseCall)(node) && describeNestingLevel === 0 && !nodeName.includes(testKeyword)) {
+        if ((0, _utils2.isTestCaseCall)(node) && describeNestingLevel === 0 && !nodeName.includes(testKeyword)) {
           const oppositeTestKeyword = getOppositeTestKeyword(testKeyword);
           context.report({
             messageId: 'consistentMethod',
@@ -75,7 +75,7 @@ var _default = (0, _utils.createRule)({
           });
         }
 
-        if ((0, _utils.isTestCaseCall)(node) && describeNestingLevel > 0 && !nodeName.includes(testKeywordWithinDescribe)) {
+        if ((0, _utils2.isTestCaseCall)(node) && describeNestingLevel > 0 && !nodeName.includes(testKeywordWithinDescribe)) {
           const oppositeTestKeyword = getOppositeTestKeyword(testKeywordWithinDescribe);
           context.report({
             messageId: 'consistentMethodWithinDescribe',
@@ -90,7 +90,7 @@ var _default = (0, _utils.createRule)({
       },
 
       'CallExpression:exit'(node) {
-        if ((0, _utils.isDescribeCall)(node)) {
+        if ((0, _utils2.isDescribeCall)(node)) {
           describeNestingLevel--;
         }
       }
@@ -103,7 +103,7 @@ var _default = (0, _utils.createRule)({
 exports.default = _default;
 
 function getPreferredNodeName(nodeName, preferredTestKeyword) {
-  if (nodeName === _utils.TestCaseName.fit) {
+  if (nodeName === _utils2.TestCaseName.fit) {
     return 'test.only';
   }
 
@@ -111,9 +111,9 @@ function getPreferredNodeName(nodeName, preferredTestKeyword) {
 }
 
 function getOppositeTestKeyword(test) {
-  if (test === _utils.TestCaseName.test) {
-    return _utils.TestCaseName.it;
+  if (test === _utils2.TestCaseName.test) {
+    return _utils2.TestCaseName.it;
   }
 
-  return _utils.TestCaseName.test;
+  return _utils2.TestCaseName.test;
 }

package/lib/rules/expect-expect.js

@@ -5,9 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _experimentalUtils = require("@typescript-eslint/experimental-utils");
+var _utils = require("@typescript-eslint/utils");
 
-var _utils = require("./utils");
+var _utils2 = require("./utils");
 
 /*
  * This implementation is adapted from eslint-plugin-jasmine.
@@ -28,7 +28,7 @@ function matchesAssertFunctionName(nodeName, patterns) {
   }).join('\\.')}(\\.|$)`, 'ui').test(nodeName));
 }
 
-var _default = (0, _utils.createRule)({
+var _default = (0, _utils2.createRule)({
   name: __filename,
   meta: {
     docs: {
@@ -72,11 +72,11 @@ var _default = (0, _utils.createRule)({
 
     function checkCallExpressionUsed(nodes) {
       for (const node of nodes) {
-        const index = node.type === _experimentalUtils.AST_NODE_TYPES.CallExpression ? unchecked.indexOf(node) : -1;
+        const index = node.type === _utils.AST_NODE_TYPES.CallExpression ? unchecked.indexOf(node) : -1;
 
-        if (node.type === _experimentalUtils.AST_NODE_TYPES.FunctionDeclaration) {
+        if (node.type === _utils.AST_NODE_TYPES.FunctionDeclaration) {
           const declaredVariables = context.getDeclaredVariables(node);
-          const testCallExpressions = (0, _utils.getTestCallExpressionsFromDeclaredVariables)(declaredVariables);
+          const testCallExpressions = (0, _utils2.getTestCallExpressionsFromDeclaredVariables)(declaredVariables);
           checkCallExpressionUsed(testCallExpressions);
         }
 
@@ -91,10 +91,10 @@ var _default = (0, _utils.createRule)({
       CallExpression(node) {
         var _getNodeName;
 
-        const name = (_getNodeName = (0, _utils.getNodeName)(node.callee)) !== null && _getNodeName !== void 0 ? _getNodeName : '';
+        const name = (_getNodeName = (0, _utils2.getNodeName)(node.callee)) !== null && _getNodeName !== void 0 ? _getNodeName : '';
 
-        if ((0, _utils.isTestCaseCall)(node) || additionalTestBlockFunctions.includes(name)) {
-          if (node.callee.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && (0, _utils.isSupportedAccessor)(node.callee.property, 'todo')) {
+        if ((0, _utils2.isTestCaseCall)(node) || additionalTestBlockFunctions.includes(name)) {
+          if (node.callee.type === _utils.AST_NODE_TYPES.MemberExpression && (0, _utils2.isSupportedAccessor)(node.callee.property, 'todo')) {
             return;
           }
 

package/lib/rules/max-nested-describe.js

@@ -5,11 +5,11 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _experimentalUtils = require("@typescript-eslint/experimental-utils");
+var _utils = require("@typescript-eslint/utils");
 
-var _utils = require("./utils");
+var _utils2 = require("./utils");
 
-var _default = (0, _utils.createRule)({
+var _default = (0, _utils2.createRule)({
   name: __filename,
   meta: {
     docs: {
@@ -46,7 +46,7 @@ var _default = (0, _utils.createRule)({
         parent
       } = node;
 
-      if ((parent === null || parent === void 0 ? void 0 : parent.type) !== _experimentalUtils.AST_NODE_TYPES.CallExpression || !(0, _utils.isDescribeCall)(parent)) {
+      if ((parent === null || parent === void 0 ? void 0 : parent.type) !== _utils.AST_NODE_TYPES.CallExpression || !(0, _utils2.isDescribeCall)(parent)) {
         return;
       }
 
@@ -69,7 +69,7 @@ var _default = (0, _utils.createRule)({
         parent
       } = node;
 
-      if ((parent === null || parent === void 0 ? void 0 : parent.type) === _experimentalUtils.AST_NODE_TYPES.CallExpression && (0, _utils.isDescribeCall)(parent)) {
+      if ((parent === null || parent === void 0 ? void 0 : parent.type) === _utils.AST_NODE_TYPES.CallExpression && (0, _utils2.isDescribeCall)(parent)) {
         describeCallbackStack.pop();
       }
     }

package/lib/rules/no-conditional-expect.js

@@ -5,13 +5,13 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _experimentalUtils = require("@typescript-eslint/experimental-utils");
+var _utils = require("@typescript-eslint/utils");
 
-var _utils = require("./utils");
+var _utils2 = require("./utils");
 
-const isCatchCall = node => node.callee.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && (0, _utils.isSupportedAccessor)(node.callee.property, 'catch');
+const isCatchCall = node => node.callee.type === _utils.AST_NODE_TYPES.MemberExpression && (0, _utils2.isSupportedAccessor)(node.callee.property, 'catch');
 
-var _default = (0, _utils.createRule)({
+var _default = (0, _utils2.createRule)({
   name: __filename,
   meta: {
     docs: {
@@ -39,7 +39,7 @@ var _default = (0, _utils.createRule)({
     return {
       FunctionDeclaration(node) {
         const declaredVariables = context.getDeclaredVariables(node);
-        const testCallExpressions = (0, _utils.getTestCallExpressionsFromDeclaredVariables)(declaredVariables);
+        const testCallExpressions = (0, _utils2.getTestCallExpressionsFromDeclaredVariables)(declaredVariables);
 
         if (testCallExpressions.length > 0) {
           inTestCase = true;
@@ -47,7 +47,7 @@ var _default = (0, _utils.createRule)({
       },
 
       CallExpression(node) {
-        if ((0, _utils.isTestCaseCall)(node)) {
+        if ((0, _utils2.isTestCaseCall)(node)) {
           inTestCase = true;
         }
 
@@ -55,14 +55,14 @@ var _default = (0, _utils.createRule)({
           inPromiseCatch = true;
         }
 
-        if (inTestCase && (0, _utils.isExpectCall)(node) && conditionalDepth > 0) {
+        if (inTestCase && (0, _utils2.isExpectCall)(node) && conditionalDepth > 0) {
           context.report({
             messageId: 'conditionalExpect',
             node
           });
         }
 
-        if (inPromiseCatch && (0, _utils.isExpectCall)(node)) {
+        if (inPromiseCatch && (0, _utils2.isExpectCall)(node)) {
           context.report({
             messageId: 'conditionalExpect',
             node
@@ -71,7 +71,7 @@ var _default = (0, _utils.createRule)({
       },
 
       'CallExpression:exit'(node) {
-        if ((0, _utils.isTestCaseCall)(node)) {
+        if ((0, _utils2.isTestCaseCall)(node)) {
           inTestCase = false;
         }
 

package/lib/rules/no-conditional-in-test.js

@@ -0,0 +1,60 @@
+"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: {
+      description: 'Disallow conditional logic in tests',
+      category: 'Best Practices',
+      recommended: false
+    },
+    messages: {
+      conditionalInTest: 'Avoid having conditionals in tests'
+    },
+    type: 'problem',
+    schema: []
+  },
+  defaultOptions: [],
+
+  create(context) {
+    let inTestCase = false;
+
+    const maybeReportConditional = node => {
+      if (inTestCase) {
+        context.report({
+          messageId: 'conditionalInTest',
+          node
+        });
+      }
+    };
+
+    return {
+      CallExpression(node) {
+        if ((0, _utils.isTestCaseCall)(node)) {
+          inTestCase = true;
+        }
+      },
+
+      'CallExpression:exit'(node) {
+        if ((0, _utils.isTestCaseCall)(node)) {
+          inTestCase = false;
+        }
+      },
+
+      IfStatement: maybeReportConditional,
+      SwitchStatement: maybeReportConditional,
+      ConditionalExpression: maybeReportConditional,
+      LogicalExpression: maybeReportConditional
+    };
+  }
+
+});
+
+exports.default = _default;

package/lib/rules/no-deprecated-functions.js

@@ -5,11 +5,11 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _experimentalUtils = require("@typescript-eslint/experimental-utils");
+var _utils = require("@typescript-eslint/utils");
 
 var _detectJestVersion = require("./detectJestVersion");
 
-var _utils = require("./utils");
+var _utils2 = require("./utils");
 
 const parseJestVersion = rawVersion => {
   if (typeof rawVersion === 'number') {
@@ -20,7 +20,7 @@ const parseJestVersion = rawVersion => {
   return parseInt(majorVersion, 10);
 };
 
-var _default = (0, _utils.createRule)({
+var _default = (0, _utils2.createRule)({
   name: __filename,
   meta: {
     docs: {
@@ -60,11 +60,11 @@ var _default = (0, _utils.createRule)({
     };
     return {
       CallExpression(node) {
-        if (node.callee.type !== _experimentalUtils.AST_NODE_TYPES.MemberExpression) {
+        if (node.callee.type !== _utils.AST_NODE_TYPES.MemberExpression) {
           return;
         }
 
-        const deprecation = (0, _utils.getNodeName)(node);
+        const deprecation = (0, _utils2.getNodeName)(node);
 
         if (!deprecation || !(deprecation in deprecations)) {
           return;
@@ -85,7 +85,7 @@ var _default = (0, _utils.createRule)({
           fix(fixer) {
             let [name, func] = replacement.split('.');
 
-            if (callee.property.type === _experimentalUtils.AST_NODE_TYPES.Literal) {
+            if (callee.property.type === _utils.AST_NODE_TYPES.Literal) {
               func = `'${func}'`;
             }
 

package/lib/rules/no-done-callback.js

@@ -5,27 +5,27 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _experimentalUtils = require("@typescript-eslint/experimental-utils");
+var _utils = require("@typescript-eslint/utils");
 
-var _utils = require("./utils");
+var _utils2 = require("./utils");
 
 const findCallbackArg = (node, isJestEach) => {
   if (isJestEach) {
     return node.arguments[1];
   }
 
-  if ((0, _utils.isHook)(node) && node.arguments.length >= 1) {
+  if ((0, _utils2.isHook)(node) && node.arguments.length >= 1) {
     return node.arguments[0];
   }
 
-  if ((0, _utils.isTestCaseCall)(node) && node.arguments.length >= 2) {
+  if ((0, _utils2.isTestCaseCall)(node) && node.arguments.length >= 2) {
     return node.arguments[1];
   }
 
   return null;
 };
 
-var _default = (0, _utils.createRule)({
+var _default = (0, _utils2.createRule)({
   name: __filename,
   meta: {
     docs: {
@@ -51,9 +51,9 @@ var _default = (0, _utils.createRule)({
         var _getNodeName$endsWith, _getNodeName;
 
         // done is the second argument for it.each, not the first
-        const isJestEach = (_getNodeName$endsWith = (_getNodeName = (0, _utils.getNodeName)(node.callee)) === null || _getNodeName === void 0 ? void 0 : _getNodeName.endsWith('.each')) !== null && _getNodeName$endsWith !== void 0 ? _getNodeName$endsWith : false;
+        const isJestEach = (_getNodeName$endsWith = (_getNodeName = (0, _utils2.getNodeName)(node.callee)) === null || _getNodeName === void 0 ? void 0 : _getNodeName.endsWith('.each')) !== null && _getNodeName$endsWith !== void 0 ? _getNodeName$endsWith : false;
 
-        if (isJestEach && node.callee.type !== _experimentalUtils.AST_NODE_TYPES.TaggedTemplateExpression) {
+        if (isJestEach && node.callee.type !== _utils.AST_NODE_TYPES.TaggedTemplateExpression) {
           // isJestEach but not a TaggedTemplateExpression, so this must be
           // the `jest.each([])()` syntax which this rule doesn't support due
           // to its complexity (see jest-community/eslint-plugin-jest#710)
@@ -63,13 +63,13 @@ var _default = (0, _utils.createRule)({
         const callback = findCallbackArg(node, isJestEach);
         const callbackArgIndex = Number(isJestEach);
 
-        if (!callback || !(0, _utils.isFunction)(callback) || callback.params.length !== 1 + callbackArgIndex) {
+        if (!callback || !(0, _utils2.isFunction)(callback) || callback.params.length !== 1 + callbackArgIndex) {
           return;
         }
 
         const argument = callback.params[callbackArgIndex];
 
-        if (argument.type !== _experimentalUtils.AST_NODE_TYPES.Identifier) {
+        if (argument.type !== _utils.AST_NODE_TYPES.Identifier) {
           context.report({
             node: argument,
             messageId: 'noDoneCallback'
@@ -126,7 +126,7 @@ var _default = (0, _utils.createRule)({
               let afterReplacement = ')';
               let replaceBefore = true;
 
-              if (body.type === _experimentalUtils.AST_NODE_TYPES.BlockStatement) {
+              if (body.type === _utils.AST_NODE_TYPES.BlockStatement) {
                 const keyword = 'return';
                 beforeReplacement = `${keyword} ${beforeReplacement}{`;
                 afterReplacement += '}';