eslint-plugin-jest 24.3.4 → 24.4.0

package/CHANGELOG.md

@@ -1,3 +1,33 @@
+# [24.4.0](https://github.com/jest-community/eslint-plugin-jest/compare/v24.3.7...v24.4.0) (2021-07-21)
+
+
+### Features
+
+* create `max-nested-describe` rule ([#845](https://github.com/jest-community/eslint-plugin-jest/issues/845)) ([8067405](https://github.com/jest-community/eslint-plugin-jest/commit/8067405deb609cc1800bce596e929c1840d290ab))
+
+## [24.3.7](https://github.com/jest-community/eslint-plugin-jest/compare/v24.3.6...v24.3.7) (2021-07-21)
+
+
+### Bug Fixes
+
+* **valid-describe:** report on concise-body arrow functions ([#863](https://github.com/jest-community/eslint-plugin-jest/issues/863)) ([71c5299](https://github.com/jest-community/eslint-plugin-jest/commit/71c5299b14cac6d85ba8f8bd939461503a60468f))
+
+## [24.3.6](https://github.com/jest-community/eslint-plugin-jest/compare/v24.3.5...v24.3.6) (2021-04-26)
+
+
+### Bug Fixes
+
+* **no-conditional-expect:** check for expects in `catch`s on promises ([#819](https://github.com/jest-community/eslint-plugin-jest/issues/819)) ([1fee973](https://github.com/jest-community/eslint-plugin-jest/commit/1fee973429a74c60b14eead6a335623b4349b5f2))
+* **valid-expect:** support async `expect` in ternary statements ([#833](https://github.com/jest-community/eslint-plugin-jest/issues/833)) ([7b7a396](https://github.com/jest-community/eslint-plugin-jest/commit/7b7a396e12c46d3087b467227887ed64854480c0))
+* improve handling of `.each` calls and with tagged literals ([#814](https://github.com/jest-community/eslint-plugin-jest/issues/814)) ([040c605](https://github.com/jest-community/eslint-plugin-jest/commit/040c605cf7929a00980b3fa58331cd78ac6274f6))
+
+## [24.3.5](https://github.com/jest-community/eslint-plugin-jest/compare/v24.3.4...v24.3.5) (2021-04-10)
+
+
+### Bug Fixes
+
+* **valid-describe:** support using `each` with modifiers ([#820](https://github.com/jest-community/eslint-plugin-jest/issues/820)) ([cbdbcef](https://github.com/jest-community/eslint-plugin-jest/commit/cbdbcef47984eb01509493bd5b2423f518a2663d))
+
 ## [24.3.4](https://github.com/jest-community/eslint-plugin-jest/compare/v24.3.3...v24.3.4) (2021-04-05)
 
 

package/README.md

@@ -13,8 +13,8 @@
 
 ## Installation
 
-```
-$ yarn add --dev eslint eslint-plugin-jest
+```bash
+yarn add --dev eslint eslint-plugin-jest
 ```
 
 **Note:** If you installed ESLint globally then you must also install
@@ -135,6 +135,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][] |              |
 | [lowercase-name](docs/rules/lowercase-name.md)                               | Enforce lowercase test names                                    |                  | ![fixable][] |
+| [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][] |              |
 | [no-conditional-expect](docs/rules/no-conditional-expect.md)                 | Prevent calling `expect` conditionally                          | ![recommended][] |              |
@@ -214,6 +215,13 @@ ensure consistency and readability in jest test suites.
 
 https://github.com/dangreenisrael/eslint-plugin-jest-formatting
 
+### eslint-plugin-istanbul
+
+A set of rules to enforce good practices for Istanbul, one of the code coverage
+tools used by Jest.
+
+https://github.com/istanbuljs/eslint-plugin-istanbul
+
 [recommended]: https://img.shields.io/badge/-recommended-lightgrey.svg
 [suggest]: https://img.shields.io/badge/-suggest-yellow.svg
 [fixable]: https://img.shields.io/badge/-fixable-green.svg

package/docs/rules/expect-expect.md

@@ -87,10 +87,10 @@ it('is money-like', () => {
 
 Examples of **correct** code for working with the HTTP assertions library
 [SuperTest](https://www.npmjs.com/package/supertest) with the
-`{ "assertFunctionNames": ["expect", "request.*.expect"] }` option:
+`{ "assertFunctionNames": ["expect", "request.**.expect"] }` option:
 
 ```js
-/* eslint jest/expect-expect: ["error", { "assertFunctionNames": ["expect", "request.*.expect"] }] */
+/* eslint jest/expect-expect: ["error", { "assertFunctionNames": ["expect", "request.**.expect"] }] */
 const request = require('supertest');
 const express = require('express');
 

package/docs/rules/max-nested-describe.md

@@ -0,0 +1,131 @@
+# Enforces a maximum depth to nested describe calls (`max-nested-describe`)
+
+While it's useful to be able to group your tests together within the same file
+using `describe()`, having too many levels of nesting throughout your tests make
+them difficult to read.
+
+## Rule Details
+
+This rule enforces a maximum depth to nested `describe()` calls to improve code
+clarity in your tests.
+
+The following patterns are considered warnings (with the default option of
+`{ "max": 5 } `):
+
+```js
+describe('foo', () => {
+  describe('bar', () => {
+    describe('baz', () => {
+      describe('qux', () => {
+        describe('quxx', () => {
+          describe('too many', () => {
+            it('should get something', () => {
+              expect(getSomething()).toBe('Something');
+            });
+          });
+        });
+      });
+    });
+  });
+});
+
+describe('foo', function () {
+  describe('bar', function () {
+    describe('baz', function () {
+      describe('qux', function () {
+        describe('quxx', function () {
+          describe('too many', function () {
+            it('should get something', () => {
+              expect(getSomething()).toBe('Something');
+            });
+          });
+        });
+      });
+    });
+  });
+});
+```
+
+The following patterns are **not** considered warnings (with the default option
+of `{ "max": 5 } `):
+
+```js
+describe('foo', () => {
+  describe('bar', () => {
+    it('should get something', () => {
+      expect(getSomething()).toBe('Something');
+    });
+  });
+
+  describe('qux', () => {
+    it('should get something', () => {
+      expect(getSomething()).toBe('Something');
+    });
+  });
+});
+
+describe('foo2', function () {
+  it('should get something', () => {
+    expect(getSomething()).toBe('Something');
+  });
+});
+
+describe('foo', function () {
+  describe('bar', function () {
+    describe('baz', function () {
+      describe('qux', function () {
+        describe('this is the limit', function () {
+          it('should get something', () => {
+            expect(getSomething()).toBe('Something');
+          });
+        });
+      });
+    });
+  });
+});
+```
+
+## Options
+
+```json
+{
+  "jest/max-nested-describe": [
+    "error",
+    {
+      "max": 5
+    }
+  ]
+}
+```
+
+### `max`
+
+Enforces a maximum depth for nested `describe()`.
+
+This has a default value of `5`.
+
+Examples of patterns **not** considered warnings with options set to
+`{ "max": 2 }`:
+
+```js
+describe('foo', () => {
+  describe('bar', () => {
+    it('should get something', () => {
+      expect(getSomething()).toBe('Something');
+    });
+  });
+});
+
+describe('foo2', function()) {
+  describe('bar2', function() {
+    it('should get something', function() {
+      expect(getSomething()).toBe('Something');
+    });
+
+    it('should get  else', function() {
+      expect(getSomething()).toBe('Something');
+    });
+  });
+});
+
+```

package/docs/rules/no-conditional-expect.md

@@ -3,6 +3,9 @@
 This rule prevents the use of `expect` in conditional blocks, such as `if`s &
 `catch`s.
 
+This includes using `expect` in callbacks to functions named `catch`, which are
+assumed to be promises.
+
 ## Rule Details
 
 Jest considered a test to have failed if it throws an error, rather than on if
@@ -37,6 +40,10 @@ it('baz', async () => {
     expect(err).toMatchObject({ code: 'MODULE_NOT_FOUND' });
   }
 });
+
+it('throws an error', async () => {
+  await foo().catch(error => expect(error).toBeInstanceOf(error));
+});
 ```
 
 The following patterns are not warnings:
@@ -67,4 +74,8 @@ it('validates the request', () => {
     expect(validRequest).toHaveBeenCalledWith(request);
   }
 });
+
+it('throws an error', async () => {
+  await expect(foo).rejects.toThrow(Error);
+});
 ```

package/docs/rules/no-focused-tests.md

@@ -12,7 +12,7 @@ whenever you are using the exclusivity feature.
 ## Rule Details
 
 This rule looks for every `describe.only`, `it.only`, `test.only`, `fdescribe`,
-`fit` and `ftest` occurrences within the source code. Of course there are some
+and `fit` occurrences within the source code. Of course there are some
 edge-cases which can’t be detected by this rule e.g.:
 
 ```js
@@ -31,13 +31,9 @@ test.only('foo', () => {});
 test['only']('bar', () => {});
 fdescribe('foo', () => {});
 fit('foo', () => {});
-ftest('bar', () => {});
 fit.each`
   table
 `();
-ftest.each`
-  table
-`();
 ```
 
 These patterns would not be considered warnings:

package/docs/rules/unbound-method.md

@@ -27,7 +27,7 @@ are not using TypeScript.
   overrides: [
     {
       files: ['test/**'],
-      extends: ['jest'],
+      plugins: ['jest'],
       rules: {
         // you should turn the original rule off *only* for test files
         '@typescript-eslint/unbound-method': 'off',

package/docs/rules/valid-describe.md

@@ -43,6 +43,12 @@ describe('myFunction', () => {
     });
   });
 });
+
+// Returning a value from a describe block is not allowed
+describe('myFunction', () =>
+  it('returns a truthy value', () => {
+    expect(myFunction()).toBeTruthy();
+  }));
 ```
 
 The following patterns are not considered warnings:

package/lib/index.js

@@ -8,9 +8,9 @@ var _globals = _interopRequireDefault(require("./globals.json"));
 
 var snapshotProcessor = _interopRequireWildcard(require("./processors/snapshot-processor"));
 
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 

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

@@ -60,7 +60,7 @@ var _default = (0, _utils.createRule)({
           describeNestingLevel++;
         }
 
-        const funcNode = node.callee.type === _experimentalUtils.AST_NODE_TYPES.TaggedTemplateExpression ? node.callee.tag : node.callee;
+        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;
 
         if ((0, _utils.isTestCaseCall)(node) && describeNestingLevel === 0 && !nodeName.includes(testKeyword)) {
           const oppositeTestKeyword = getOppositeTestKeyword(testKeyword);
@@ -90,7 +90,7 @@ var _default = (0, _utils.createRule)({
       },
 
       'CallExpression:exit'(node) {
-        if ((0, _utils.isDescribeCall)(node) && !(0, _utils.isEachCall)(node)) {
+        if ((0, _utils.isDescribeCall)(node)) {
           describeNestingLevel--;
         }
       }

package/lib/rules/lowercase-name.js

@@ -5,8 +5,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _experimentalUtils = require("@typescript-eslint/experimental-utils");
-
 var _utils = require("./utils");
 
 const hasStringAsFirstArgument = node => node.arguments[0] && (0, _utils.isStringNode)(node.arguments[0]);
@@ -16,19 +14,11 @@ const findNodeNameAndArgument = node => {
     return null;
   }
 
-  if ((0, _utils.isEachCall)(node)) {
-    if (node.parent.arguments.length > 0 && (0, _utils.isStringNode)(node.parent.arguments[0])) {
-      return [node.callee.object.name, node.parent.arguments[0]];
-    }
-
-    return null;
-  }
-
-  if (node.callee.type !== _experimentalUtils.AST_NODE_TYPES.Identifier || !hasStringAsFirstArgument(node)) {
+  if (!hasStringAsFirstArgument(node)) {
     return null;
   }
 
-  return [node.callee.name, node.arguments[0]];
+  return [(0, _utils.getNodeName)(node).split('.')[0], node.arguments[0]];
 };
 
 var _default = (0, _utils.createRule)({

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

@@ -0,0 +1,87 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _experimentalUtils = require("@typescript-eslint/experimental-utils");
+
+var _utils = require("./utils");
+
+var _default = (0, _utils.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      category: 'Best Practices',
+      description: 'Enforces a maximum depth to nested describe calls',
+      recommended: false
+    },
+    messages: {
+      exceededMaxDepth: 'Too many nested describe calls ({{ depth }}). Maximum allowed is {{ max }}.'
+    },
+    type: 'suggestion',
+    schema: [{
+      type: 'object',
+      properties: {
+        max: {
+          type: 'integer',
+          minimum: 0
+        }
+      },
+      additionalProperties: false
+    }]
+  },
+  defaultOptions: [{
+    max: 5
+  }],
+
+  create(context, [{
+    max
+  }]) {
+    const describeCallbackStack = [];
+
+    function pushDescribeCallback(node) {
+      const {
+        parent
+      } = node;
+
+      if ((parent === null || parent === void 0 ? void 0 : parent.type) !== _experimentalUtils.AST_NODE_TYPES.CallExpression || !(0, _utils.isDescribeCall)(parent)) {
+        return;
+      }
+
+      describeCallbackStack.push(0);
+
+      if (describeCallbackStack.length > max) {
+        context.report({
+          node: parent,
+          messageId: 'exceededMaxDepth',
+          data: {
+            depth: describeCallbackStack.length,
+            max
+          }
+        });
+      }
+    }
+
+    function popDescribeCallback(node) {
+      const {
+        parent
+      } = node;
+
+      if ((parent === null || parent === void 0 ? void 0 : parent.type) === _experimentalUtils.AST_NODE_TYPES.CallExpression && (0, _utils.isDescribeCall)(parent)) {
+        describeCallbackStack.pop();
+      }
+    }
+
+    return {
+      FunctionExpression: pushDescribeCallback,
+      'FunctionExpression:exit': popDescribeCallback,
+      ArrowFunctionExpression: pushDescribeCallback,
+      'ArrowFunctionExpression:exit': popDescribeCallback
+    };
+  }
+
+});
+
+exports.default = _default;

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

@@ -5,8 +5,12 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
+var _experimentalUtils = require("@typescript-eslint/experimental-utils");
+
 var _utils = require("./utils");
 
+const isCatchCall = node => node.callee.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && (0, _utils.isSupportedAccessor)(node.callee.property, 'catch');
+
 var _default = (0, _utils.createRule)({
   name: __filename,
   meta: {
@@ -26,6 +30,7 @@ var _default = (0, _utils.createRule)({
   create(context) {
     let conditionalDepth = 0;
     let inTestCase = false;
+    let inPromiseCatch = false;
 
     const increaseConditionalDepth = () => inTestCase && conditionalDepth++;
 
@@ -46,18 +51,33 @@ var _default = (0, _utils.createRule)({
           inTestCase = true;
         }
 
+        if (isCatchCall(node)) {
+          inPromiseCatch = true;
+        }
+
         if (inTestCase && (0, _utils.isExpectCall)(node) && conditionalDepth > 0) {
           context.report({
             messageId: 'conditionalExpect',
             node
           });
         }
+
+        if (inPromiseCatch && (0, _utils.isExpectCall)(node)) {
+          context.report({
+            messageId: 'conditionalExpect',
+            node
+          });
+        }
       },
 
       'CallExpression:exit'(node) {
         if ((0, _utils.isTestCaseCall)(node)) {
           inTestCase = false;
         }
+
+        if (isCatchCall(node)) {
+          inPromiseCatch = false;
+        }
       },
 
       CatchClause: increaseConditionalDepth,

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

@@ -24,10 +24,10 @@ const detectJestVersion = () => {
   try {
     const jestPath = require.resolve('jest/package.json', {
       paths: [process.cwd()]
-    }); // eslint-disable-next-line @typescript-eslint/no-require-imports
+    });
 
-
-    const jestPackageJson = require(jestPath);
+    const jestPackageJson = // eslint-disable-next-line @typescript-eslint/no-require-imports
+    require(jestPath);
 
     if (jestPackageJson.version) {
       const [majorVersion] = jestPackageJson.version.split('.');

package/lib/rules/no-duplicate-hooks.js

@@ -55,7 +55,7 @@ var _default = (0, _utils.createRule)({
       },
 
       'CallExpression:exit'(node) {
-        if ((0, _utils.isDescribeCall)(node) && !(0, _utils.isEachCall)(node)) {
+        if ((0, _utils.isDescribeCall)(node)) {
           hookContexts.pop();
         }
       }

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

@@ -9,16 +9,23 @@ var _experimentalUtils = require("@typescript-eslint/experimental-utils");
 
 var _utils = require("./utils");
 
-const validTestCaseNames = [_utils.TestCaseName.test, _utils.TestCaseName.it];
-const testFunctions = new Set([_utils.DescribeAlias.describe, ...validTestCaseNames]);
+const findOnlyNode = node => {
+  const callee = 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 isConcurrentExpression = expression => (0, _utils.isSupportedAccessor)(expression.property, _utils.TestCaseProperty.concurrent) && !!expression.parent && expression.parent.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression;
-
-const matchesTestFunction = object => 'name' in object && typeof object.name === 'string' && (object.name in _utils.TestCaseName || object.name in _utils.DescribeAlias);
+  if (callee.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression) {
+    if (callee.object.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression) {
+      if ((0, _utils.isSupportedAccessor)(callee.object.property, 'only')) {
+        return callee.object.property;
+      }
+    }
 
-const isCallToFocusedTestFunction = object => object.name.startsWith('f') && testFunctions.has(object.name.substring(1));
+    if ((0, _utils.isSupportedAccessor)(callee.property, 'only')) {
+      return callee.property;
+    }
+  }
 
-const isCallToTestOnlyFunction = callee => matchesTestFunction(callee.object) && (0, _utils.isSupportedAccessor)(isConcurrentExpression(callee) ? callee.parent.property : callee.property, 'only');
+  return null;
+};
 
 var _default = (0, _utils.createRule)({
   name: __filename,
@@ -39,78 +46,36 @@ var _default = (0, _utils.createRule)({
   defaultOptions: [],
   create: context => ({
     CallExpression(node) {
-      const callee = node.callee.type === _experimentalUtils.AST_NODE_TYPES.TaggedTemplateExpression ? node.callee.tag : node.callee;
-
-      if (callee.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression) {
-        const calleeObject = callee.object;
-
-        if (calleeObject.type === _experimentalUtils.AST_NODE_TYPES.Identifier && isCallToFocusedTestFunction(calleeObject)) {
-          context.report({
-            messageId: 'focusedTest',
-            node: calleeObject,
-            suggest: [{
-              messageId: 'suggestRemoveFocus',
-
-              fix(fixer) {
-                return fixer.removeRange([calleeObject.range[0], calleeObject.range[0] + 1]);
-              }
-
-            }]
-          });
-          return;
-        }
-
-        if (calleeObject.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && isCallToTestOnlyFunction(calleeObject)) {
-          context.report({
-            messageId: 'focusedTest',
-            node: isConcurrentExpression(calleeObject) ? callee.property : calleeObject.property,
-            suggest: [{
-              messageId: 'suggestRemoveFocus',
-
-              fix(fixer) {
-                if (calleeObject.property.type === _experimentalUtils.AST_NODE_TYPES.Identifier && calleeObject.property.name === 'only') {
-                  return fixer.removeRange([calleeObject.object.range[1], calleeObject.range[1]]);
-                }
-
-                return fixer.removeRange([calleeObject.range[1], callee.range[1]]);
-              }
-
-            }]
-          });
-          return;
-        }
-
-        if (isCallToTestOnlyFunction(callee)) {
-          context.report({
-            messageId: 'focusedTest',
-            node: callee.property,
-            suggest: [{
-              messageId: 'suggestRemoveFocus',
-
-              fix(fixer) {
-                return fixer.removeRange([calleeObject.range[1], callee.range[1]]);
-              }
-
-            }]
-          });
-          return;
-        }
+      if (!(0, _utils.isDescribeCall)(node) && !(0, _utils.isTestCaseCall)(node)) {
+        return;
       }
 
-      if (callee.type === _experimentalUtils.AST_NODE_TYPES.Identifier && isCallToFocusedTestFunction(callee)) {
+      if ((0, _utils.getNodeName)(node).startsWith('f')) {
         context.report({
           messageId: 'focusedTest',
-          node: callee,
+          node,
           suggest: [{
             messageId: 'suggestRemoveFocus',
-
-            fix(fixer) {
-              return fixer.removeRange([callee.range[0], callee.range[0] + 1]);
-            }
-
+            fix: fixer => fixer.removeRange([node.range[0], node.range[0] + 1])
           }]
         });
+        return;
       }
+
+      const onlyNode = findOnlyNode(node);
+
+      if (!onlyNode) {
+        return;
+      }
+
+      context.report({
+        messageId: 'focusedTest',
+        node: onlyNode,
+        suggest: [{
+          messageId: 'suggestRemoveFocus',
+          fix: fixer => fixer.removeRange([onlyNode.range[0] - 1, onlyNode.range[1] + Number(onlyNode.type !== _experimentalUtils.AST_NODE_TYPES.Identifier)])
+        }]
+      });
     }
 
   })

package/lib/rules/no-if.js

@@ -58,6 +58,10 @@ var _default = (0, _utils.createRule)({
       CallExpression(node) {
         if ((0, _utils.isTestCaseCall)(node)) {
           stack.push(true);
+
+          if ((0, _utils.getNodeName)(node).endsWith('each')) {
+            stack.push(true);
+          }
         }
       },
 

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

@@ -38,8 +38,6 @@ const getBlockType = statement => {
   return null;
 };
 
-const isEach = node => node.callee.type === _experimentalUtils.AST_NODE_TYPES.CallExpression && node.callee.callee.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && node.callee.callee.property.type === _experimentalUtils.AST_NODE_TYPES.Identifier && node.callee.callee.property.name === 'each' && node.callee.callee.object.type === _experimentalUtils.AST_NODE_TYPES.Identifier && _utils.TestCaseName.hasOwnProperty(node.callee.callee.object.name);
-
 var _default = (0, _utils.createRule)({
   name: __filename,
   meta: {
@@ -104,7 +102,7 @@ var _default = (0, _utils.createRule)({
       'CallExpression:exit'(node) {
         const top = callStack[callStack.length - 1];
 
-        if (top === 'test' && (isEach(node) || isTestBlock(node) && node.callee.type !== _experimentalUtils.AST_NODE_TYPES.MemberExpression) || top === 'template' && node.callee.type === _experimentalUtils.AST_NODE_TYPES.TaggedTemplateExpression) {
+        if (top === 'test' && isTestBlock(node) && node.callee.type !== _experimentalUtils.AST_NODE_TYPES.MemberExpression || top === 'template' && node.callee.type === _experimentalUtils.AST_NODE_TYPES.TaggedTemplateExpression) {
           callStack.pop();
         }
       },

package/lib/rules/no-test-prefixes.js

@@ -33,7 +33,7 @@ var _default = (0, _utils.createRule)({
         if (!nodeName || !(0, _utils.isDescribeCall)(node) && !(0, _utils.isTestCaseCall)(node)) return;
         const preferredNodeName = getPreferredNodeName(nodeName);
         if (!preferredNodeName) return;
-        const funcNode = node.callee.type === _experimentalUtils.AST_NODE_TYPES.TaggedTemplateExpression ? node.callee.tag : node.callee;
+        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;
         context.report({
           messageId: 'usePreferredName',
           node: node.callee,

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

@@ -60,13 +60,11 @@ var _default = (0, _utils.createRule)({
           return;
         }
 
-        const args = (0, _utils.isEachCall)(node) ? node.parent.arguments : node.arguments;
-
-        if (args.length < 2) {
+        if (node.arguments.length < 2) {
           return;
         }
 
-        const [, testFn] = args;
+        const [, testFn] = node.arguments;
 
         if (!(0, _utils.isFunction)(testFn) || testFn.body.type !== _experimentalUtils.AST_NODE_TYPES.BlockStatement || options.onlyFunctionsWithAsyncKeyword && !testFn.async) {
           return;

package/lib/rules/prefer-todo.js

@@ -18,11 +18,11 @@ function isEmptyFunction(node) {
 }
 
 function createTodoFixer(node, fixer) {
-  const testName = (0, _utils.getNodeName)(node.callee).split('.').shift();
+  const testName = (0, _utils.getNodeName)(node).split('.').shift();
   return fixer.replaceText(node.callee, `${testName}.todo`);
 }
 
-const isTargetedTestCase = node => (0, _utils.isTestCaseCall)(node) && [_utils.TestCaseName.it, _utils.TestCaseName.test, 'it.skip', 'test.skip'].includes((0, _utils.getNodeName)(node.callee));
+const isTargetedTestCase = node => (0, _utils.isTestCaseCall)(node) && [_utils.TestCaseName.it, _utils.TestCaseName.test, 'it.skip', 'test.skip'].includes((0, _utils.getNodeName)(node));
 
 var _default = (0, _utils.createRule)({
   name: __filename,

package/lib/rules/require-top-level-describe.js

@@ -53,7 +53,7 @@ var _default = (0, _utils.createRule)({
       },
 
       'CallExpression:exit'(node) {
-        if ((0, _utils.isDescribeCall)(node) && !(0, _utils.isEachCall)(node)) {
+        if ((0, _utils.isDescribeCall)(node)) {
           numberOfDescribeBlocks--;
         }
       }

package/lib/rules/utils.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getNodeName = getNodeName;
-exports.scopeHasLocalReference = exports.getJestFunctionArguments = exports.isEachCall = exports.isDescribe = exports.isDescribeCall = exports.isTestCaseCall = exports.getTestCallExpressionsFromDeclaredVariables = exports.isHook = exports.isFunction = exports.TestCaseProperty = exports.DescribeProperty = exports.HookName = exports.TestCaseName = exports.DescribeAlias = exports.parseExpectCall = exports.isParsedEqualityMatcherCall = exports.EqualityMatcher = exports.ModifierName = exports.isExpectMember = exports.isExpectCall = exports.getAccessorValue = exports.isSupportedAccessor = exports.hasOnlyOneArgument = exports.getStringValue = exports.isStringNode = exports.followTypeAssertionChain = exports.createRule = void 0;
+exports.scopeHasLocalReference = exports.isDescribeCall = exports.isTestCaseCall = exports.getTestCallExpressionsFromDeclaredVariables = exports.isHook = exports.isFunction = exports.TestCaseProperty = exports.DescribeProperty = exports.HookName = exports.TestCaseName = exports.DescribeAlias = exports.parseExpectCall = exports.isParsedEqualityMatcherCall = exports.EqualityMatcher = exports.ModifierName = exports.isExpectMember = exports.isExpectCall = exports.getAccessorValue = exports.isSupportedAccessor = exports.hasOnlyOneArgument = exports.getStringValue = exports.isStringNode = exports.followTypeAssertionChain = exports.createRule = void 0;
 
 var _path = require("path");
 
@@ -416,13 +416,11 @@ const isTestCaseCall = node => {
     return true;
   }
 
-  const callee = node.callee.type === _experimentalUtils.AST_NODE_TYPES.TaggedTemplateExpression ? node.callee.tag : node.callee;
+  const callee = node.callee.type === _experimentalUtils.AST_NODE_TYPES.TaggedTemplateExpression ? node.callee.tag : node.callee.type === _experimentalUtils.AST_NODE_TYPES.CallExpression ? node.callee.callee : node.callee;
 
   if (callee.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && isTestCaseProperty(callee.property)) {
-    var _node$parent;
-
-    // if we're an `each()`, ensure we're being called (i.e `.each()()`)
-    if (node.callee.type !== _experimentalUtils.AST_NODE_TYPES.TaggedTemplateExpression && ((_node$parent = node.parent) === null || _node$parent === void 0 ? void 0 : _node$parent.type) !== _experimentalUtils.AST_NODE_TYPES.CallExpression && getAccessorValue(callee.property) === 'each') {
+    // if we're an `each()`, ensure we're the outer CallExpression (i.e `.each()()`)
+    if (getAccessorValue(callee.property) === 'each' && node.callee.type !== _experimentalUtils.AST_NODE_TYPES.TaggedTemplateExpression && node.callee.type !== _experimentalUtils.AST_NODE_TYPES.CallExpression) {
       return false;
     }
 
@@ -455,13 +453,11 @@ const isDescribeCall = node => {
     return true;
   }
 
-  const callee = node.callee.type === _experimentalUtils.AST_NODE_TYPES.TaggedTemplateExpression ? node.callee.tag : node.callee;
+  const callee = node.callee.type === _experimentalUtils.AST_NODE_TYPES.TaggedTemplateExpression ? node.callee.tag : node.callee.type === _experimentalUtils.AST_NODE_TYPES.CallExpression ? node.callee.callee : node.callee;
 
   if (callee.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && isDescribeProperty(callee.property)) {
-    var _node$parent2;
-
-    // if we're an `each()`, ensure we're being called (i.e `.each()()`)
-    if (node.callee.type !== _experimentalUtils.AST_NODE_TYPES.TaggedTemplateExpression && ((_node$parent2 = node.parent) === null || _node$parent2 === void 0 ? void 0 : _node$parent2.type) !== _experimentalUtils.AST_NODE_TYPES.CallExpression && getAccessorValue(callee.property) === 'each') {
+    // if we're an `each()`, ensure we're the outer CallExpression (i.e `.each()()`)
+    if (getAccessorValue(callee.property) === 'each' && node.callee.type !== _experimentalUtils.AST_NODE_TYPES.TaggedTemplateExpression && node.callee.type !== _experimentalUtils.AST_NODE_TYPES.CallExpression) {
       return false;
     }
 
@@ -473,42 +469,6 @@ const isDescribeCall = node => {
 
 exports.isDescribeCall = isDescribeCall;
 
-const isDescribe = node => node.callee.type === _experimentalUtils.AST_NODE_TYPES.Identifier && DescribeAlias.hasOwnProperty(node.callee.name) || node.callee.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && node.callee.object.type === _experimentalUtils.AST_NODE_TYPES.Identifier && DescribeAlias.hasOwnProperty(node.callee.object.name) && node.callee.property.type === _experimentalUtils.AST_NODE_TYPES.Identifier && DescribeProperty.hasOwnProperty(node.callee.property.name) || node.callee.type === _experimentalUtils.AST_NODE_TYPES.TaggedTemplateExpression && node.callee.tag.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && node.callee.tag.object.type === _experimentalUtils.AST_NODE_TYPES.Identifier && DescribeAlias.hasOwnProperty(node.callee.tag.object.name);
-/**
- * Checks if the given node` is a call to `<describe|test|it>.each(...)()`.
- * If `true`, the code must look like `<method>.each(...)()`.
- *
- * @param {JestFunctionCallExpression<DescribeAlias | TestCaseName>} node
- *
- * @return {node is JestFunctionCallExpressionWithMemberExpressionCallee<DescribeAlias | TestCaseName, DescribeProperty.each | TestCaseProperty.each> & {parent: TSESTree.CallExpression}}
- */
-
-
-exports.isDescribe = isDescribe;
-
-const isEachCall = node => {
-  var _node$parent3;
-
-  return ((_node$parent3 = node.parent) === null || _node$parent3 === void 0 ? void 0 : _node$parent3.type) === _experimentalUtils.AST_NODE_TYPES.CallExpression && node.callee.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && isSupportedAccessor(node.callee.property, DescribeProperty.each);
-};
-/**
- * Gets the arguments of the given `JestFunctionCallExpression`.
- *
- * If the `node` is an `each` call, then the arguments of the actual suite
- * are returned, rather then the `each` array argument.
- *
- * @param {JestFunctionCallExpression<DescribeAlias | TestCaseName>} node
- *
- * @return {Expression[]}
- */
-
-
-exports.isEachCall = isEachCall;
-
-const getJestFunctionArguments = node => node.callee.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && isSupportedAccessor(node.callee.property, DescribeProperty.each) && node.parent && node.parent.type === _experimentalUtils.AST_NODE_TYPES.CallExpression ? node.parent.arguments : node.arguments;
-
-exports.getJestFunctionArguments = getJestFunctionArguments;
-
 const collectReferences = scope => {
   const locals = new Set();
   const unresolved = new Set();

package/lib/rules/valid-describe.js

@@ -41,25 +41,23 @@ var _default = (0, _utils.createRule)({
   create(context) {
     return {
       CallExpression(node) {
-        if (!(0, _utils.isDescribe)(node) || node.callee.type === _experimentalUtils.AST_NODE_TYPES.TaggedTemplateExpression) {
+        if (!(0, _utils.isDescribeCall)(node)) {
           return;
         }
 
-        const nodeArguments = (0, _utils.getJestFunctionArguments)(node);
-
-        if (nodeArguments.length < 1) {
+        if (node.arguments.length < 1) {
           return context.report({
             messageId: 'nameAndCallback',
             loc: node.loc
           });
         }
 
-        const [, callback] = nodeArguments;
+        const [, callback] = node.arguments;
 
         if (!callback) {
           context.report({
             messageId: 'nameAndCallback',
-            loc: paramsLocation(nodeArguments)
+            loc: paramsLocation(node.arguments)
           });
           return;
         }
@@ -67,7 +65,7 @@ var _default = (0, _utils.createRule)({
         if (!(0, _utils.isFunction)(callback)) {
           context.report({
             messageId: 'secondArgumentMustBeFunction',
-            loc: paramsLocation(nodeArguments)
+            loc: paramsLocation(node.arguments)
           });
           return;
         }
@@ -79,13 +77,20 @@ var _default = (0, _utils.createRule)({
           });
         }
 
-        if (!(0, _utils.isEachCall)(node) && callback.params.length) {
+        if (!(0, _utils.getNodeName)(node).endsWith('each') && callback.params.length) {
           context.report({
             messageId: 'unexpectedDescribeArgument',
             loc: paramsLocation(callback.params)
           });
         }
 
+        if (callback.body.type === _experimentalUtils.AST_NODE_TYPES.CallExpression) {
+          context.report({
+            messageId: 'unexpectedReturnInDescribe',
+            node: callback
+          });
+        }
+
         if (callback.body.type === _experimentalUtils.AST_NODE_TYPES.BlockStatement) {
           callback.body.body.forEach(node => {
             if (node.type === _experimentalUtils.AST_NODE_TYPES.ReturnStatement) {

package/lib/rules/valid-expect-in-promise.js

@@ -123,13 +123,12 @@ var _default = (0, _utils.createRule)({
             return;
           }
 
-          const testFunctionBody = body.body;
-          const [fulfillmentCallback, rejectionCallback] = node.arguments; // then block can have two args, fulfillment & rejection
+          const testFunctionBody = body.body; // then block can have two args, fulfillment & rejection
           // then block can have one args, fulfillment
           // catch block can have one args, rejection
           // ref: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise
 
-          verifyExpectWithReturn([fulfillmentCallback, rejectionCallback], node.callee, context, testFunctionBody);
+          verifyExpectWithReturn(node.arguments.slice(0, 2), node.callee, context, testFunctionBody);
         }
       }
 

package/lib/rules/valid-expect.js

@@ -46,7 +46,17 @@ const getParentIfThenified = node => {
   return node;
 };
 
-const isAcceptableReturnNode = (node, allowReturn) => allowReturn && node.type === _experimentalUtils.AST_NODE_TYPES.ReturnStatement || [_experimentalUtils.AST_NODE_TYPES.ArrowFunctionExpression, _experimentalUtils.AST_NODE_TYPES.AwaitExpression].includes(node.type);
+const isAcceptableReturnNode = (node, allowReturn) => {
+  if (allowReturn && node.type === _experimentalUtils.AST_NODE_TYPES.ReturnStatement) {
+    return true;
+  }
+
+  if (node.type === _experimentalUtils.AST_NODE_TYPES.ConditionalExpression && node.parent) {
+    return isAcceptableReturnNode(node.parent, allowReturn);
+  }
+
+  return [_experimentalUtils.AST_NODE_TYPES.ArrowFunctionExpression, _experimentalUtils.AST_NODE_TYPES.AwaitExpression].includes(node.type);
+};
 
 const isNoAssertionsParentNode = node => node.type === _experimentalUtils.AST_NODE_TYPES.ExpressionStatement || node.type === _experimentalUtils.AST_NODE_TYPES.AwaitExpression && node.parent !== undefined && node.parent.type === _experimentalUtils.AST_NODE_TYPES.ExpressionStatement;
 

package/lib/rules/valid-title.js

@@ -136,7 +136,7 @@ var _default = (0, _utils.createRule)({
           return;
         }
 
-        const [argument] = (0, _utils.getJestFunctionArguments)(node);
+        const [argument] = node.arguments;
 
         if (!argument) {
           return;
@@ -193,7 +193,7 @@ var _default = (0, _utils.createRule)({
           });
         }
 
-        const nodeName = trimFXprefix((0, _utils.getNodeName)(node.callee));
+        const nodeName = trimFXprefix((0, _utils.getNodeName)(node));
         const [firstWord] = title.split(' ');
 
         if (firstWord.toLowerCase() === nodeName) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-jest",
-  "version": "24.3.4",
+  "version": "24.4.0",
   "description": "Eslint rules for Jest",
   "keywords": [
     "eslint",
@@ -97,7 +97,7 @@
     "@types/prettier": "^2.0.0",
     "@typescript-eslint/eslint-plugin": "^4.0.1",
     "@typescript-eslint/parser": "^4.0.1",
-    "babel-jest": "^26.0.1",
+    "babel-jest": "^27.0.0",
     "babel-plugin-replace-ts-export-assignment": "^0.0.2",
     "dedent": "^0.7.0",
     "eslint": "^5.1.0 || ^6.0.0 || ^7.0.0",
@@ -110,7 +110,7 @@
     "eslint-plugin-prettier": "^3.0.0",
     "husky": "^6.0.0",
     "is-ci": "^3.0.0",
-    "jest": "^26.0.1",
+    "jest": "^27.0.0",
     "jest-runner-eslint": "^0.10.0",
     "lint-staged": "^10.2.2",
     "pinst": "^2.0.0",