eslint-plugin-jest 26.2.0 → 26.3.0

package/README.md

@@ -209,6 +209,7 @@ installations requiring long-term consistency.
 | [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-in-order](docs/rules/prefer-hooks-in-order.md)                 | Prefer having hooks in a consistent order                           |                  |              |
 | [prefer-hooks-on-top](docs/rules/prefer-hooks-on-top.md)                     | Suggest having hooks before any test cases                          |                  |              |
 | [prefer-lowercase-title](docs/rules/prefer-lowercase-title.md)               | Enforce lowercase test names                                        |                  | ![fixable][] |
 | [prefer-snapshot-hint](docs/rules/prefer-snapshot-hint.md)                   | Prefer including a hint with external snapshots                     |                  |              |

package/docs/rules/prefer-hooks-in-order.md

@@ -0,0 +1,133 @@
+# Prefer having hooks in a consistent order (`prefer-hooks-in-order`)
+
+While hooks can be setup in any order, they're always called by `jest` in this
+specific order:
+
+1. `beforeAll`
+1. `beforeEach`
+1. `afterEach`
+1. `afterAll`
+
+This rule aims to make that more obvious by enforcing grouped hooks be setup in
+that order within tests.
+
+## Rule Details
+
+Examples of **incorrect** code for this rule
+
+```js
+/* eslint jest/prefer-hooks-in-order: "error" */
+
+describe('foo', () => {
+  beforeEach(() => {
+    seedMyDatabase();
+  });
+
+  beforeAll(() => {
+    createMyDatabase();
+  });
+
+  it('accepts this input', () => {
+    // ...
+  });
+
+  it('returns that value', () => {
+    // ...
+  });
+
+  describe('when the database has specific values', () => {
+    const specificValue = '...';
+
+    beforeEach(() => {
+      seedMyDatabase(specificValue);
+    });
+
+    it('accepts that input', () => {
+      // ...
+    });
+
+    it('throws an error', () => {
+      // ...
+    });
+
+    afterEach(() => {
+      clearLogger();
+    });
+    beforeEach(() => {
+      mockLogger();
+    });
+
+    it('logs a message', () => {
+      // ...
+    });
+  });
+
+  afterAll(() => {
+    removeMyDatabase();
+  });
+});
+```
+
+Examples of **correct** code for this rule
+
+```js
+/* eslint jest/prefer-hooks-in-order: "error" */
+
+describe('foo', () => {
+  beforeAll(() => {
+    createMyDatabase();
+  });
+
+  beforeEach(() => {
+    seedMyDatabase();
+  });
+
+  it('accepts this input', () => {
+    // ...
+  });
+
+  it('returns that value', () => {
+    // ...
+  });
+
+  describe('when the database has specific values', () => {
+    const specificValue = '...';
+
+    beforeEach(() => {
+      seedMyDatabase(specificValue);
+    });
+
+    it('accepts that input', () => {
+      // ...
+    });
+
+    it('throws an error', () => {
+      // ...
+    });
+
+    beforeEach(() => {
+      mockLogger();
+    });
+
+    afterEach(() => {
+      clearLogger();
+    });
+
+    it('logs a message', () => {
+      // ...
+    });
+  });
+
+  afterAll(() => {
+    removeMyDatabase();
+  });
+});
+```
+
+## Also See
+
+- [`prefer-hooks-on-top`](prefer-hooks-on-top.md)
+
+## Further Reading
+
+- [Order of execution of describe and test blocks](https://jestjs.io/docs/setup-teardown#order-of-execution-of-describe-and-test-blocks)

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

@@ -44,13 +44,13 @@ var _default = (0, _utils2.createRule)({
   }],
 
   create(context) {
-    const scope = context.getScope();
     const configObj = context.options[0] || {};
     const testKeyword = configObj.fn || _utils2.TestCaseName.test;
     const testKeywordWithinDescribe = configObj.withinDescribe || configObj.fn || _utils2.TestCaseName.it;
     let describeNestingLevel = 0;
     return {
       CallExpression(node) {
+        const scope = context.getScope();
         const nodeName = (0, _utils2.getNodeName)(node.callee);
 
         if (!nodeName) {
@@ -91,7 +91,7 @@ var _default = (0, _utils2.createRule)({
       },
 
       'CallExpression:exit'(node) {
-        if ((0, _utils2.isDescribeCall)(node, scope)) {
+        if ((0, _utils2.isDescribeCall)(node, context.getScope())) {
           describeNestingLevel--;
         }
       }

package/lib/rules/expect-expect.js

@@ -68,7 +68,6 @@ var _default = (0, _utils2.createRule)({
     assertFunctionNames = ['expect'],
     additionalTestBlockFunctions = []
   }]) {
-    const scope = context.getScope();
     const unchecked = [];
 
     function checkCallExpressionUsed(nodes) {
@@ -77,7 +76,7 @@ var _default = (0, _utils2.createRule)({
 
         if (node.type === _utils.AST_NODE_TYPES.FunctionDeclaration) {
           const declaredVariables = context.getDeclaredVariables(node);
-          const testCallExpressions = (0, _utils2.getTestCallExpressionsFromDeclaredVariables)(declaredVariables, scope);
+          const testCallExpressions = (0, _utils2.getTestCallExpressionsFromDeclaredVariables)(declaredVariables, context.getScope());
           checkCallExpressionUsed(testCallExpressions);
         }
 
@@ -94,7 +93,7 @@ var _default = (0, _utils2.createRule)({
 
         const name = (_getNodeName = (0, _utils2.getNodeName)(node.callee)) !== null && _getNodeName !== void 0 ? _getNodeName : '';
 
-        if ((0, _utils2.isTestCaseCall)(node, scope) || additionalTestBlockFunctions.includes(name)) {
+        if ((0, _utils2.isTestCaseCall)(node, context.getScope()) || 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

@@ -39,7 +39,6 @@ var _default = (0, _utils2.createRule)({
   create(context, [{
     max
   }]) {
-    const scope = context.getScope();
     const describeCallbackStack = [];
 
     function pushDescribeCallback(node) {
@@ -47,7 +46,7 @@ var _default = (0, _utils2.createRule)({
         parent
       } = node;
 
-      if ((parent === null || parent === void 0 ? void 0 : parent.type) !== _utils.AST_NODE_TYPES.CallExpression || !(0, _utils2.isDescribeCall)(parent, scope)) {
+      if ((parent === null || parent === void 0 ? void 0 : parent.type) !== _utils.AST_NODE_TYPES.CallExpression || !(0, _utils2.isDescribeCall)(parent, context.getScope())) {
         return;
       }
 
@@ -70,7 +69,7 @@ var _default = (0, _utils2.createRule)({
         parent
       } = node;
 
-      if ((parent === null || parent === void 0 ? void 0 : parent.type) === _utils.AST_NODE_TYPES.CallExpression && (0, _utils2.isDescribeCall)(parent, scope)) {
+      if ((parent === null || parent === void 0 ? void 0 : parent.type) === _utils.AST_NODE_TYPES.CallExpression && (0, _utils2.isDescribeCall)(parent, context.getScope())) {
         describeCallbackStack.pop();
       }
     }

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

@@ -28,7 +28,6 @@ var _default = (0, _utils2.createRule)({
   defaultOptions: [],
 
   create(context) {
-    const scope = context.getScope();
     let conditionalDepth = 0;
     let inTestCase = false;
     let inPromiseCatch = false;
@@ -40,7 +39,7 @@ var _default = (0, _utils2.createRule)({
     return {
       FunctionDeclaration(node) {
         const declaredVariables = context.getDeclaredVariables(node);
-        const testCallExpressions = (0, _utils2.getTestCallExpressionsFromDeclaredVariables)(declaredVariables, scope);
+        const testCallExpressions = (0, _utils2.getTestCallExpressionsFromDeclaredVariables)(declaredVariables, context.getScope());
 
         if (testCallExpressions.length > 0) {
           inTestCase = true;
@@ -48,7 +47,7 @@ var _default = (0, _utils2.createRule)({
       },
 
       CallExpression(node) {
-        if ((0, _utils2.isTestCaseCall)(node, scope)) {
+        if ((0, _utils2.isTestCaseCall)(node, context.getScope())) {
           inTestCase = true;
         }
 
@@ -72,7 +71,7 @@ var _default = (0, _utils2.createRule)({
       },
 
       'CallExpression:exit'(node) {
-        if ((0, _utils2.isTestCaseCall)(node, scope)) {
+        if ((0, _utils2.isTestCaseCall)(node, context.getScope())) {
           inTestCase = false;
         }
 

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

@@ -24,7 +24,6 @@ var _default = (0, _utils.createRule)({
   defaultOptions: [],
 
   create(context) {
-    const scope = context.getScope();
     let inTestCase = false;
 
     const maybeReportConditional = node => {
@@ -38,13 +37,13 @@ var _default = (0, _utils.createRule)({
 
     return {
       CallExpression(node) {
-        if ((0, _utils.isTestCaseCall)(node, scope)) {
+        if ((0, _utils.isTestCaseCall)(node, context.getScope())) {
           inTestCase = true;
         }
       },
 
       'CallExpression:exit'(node) {
-        if ((0, _utils.isTestCaseCall)(node, scope)) {
+        if ((0, _utils.isTestCaseCall)(node, context.getScope())) {
           inTestCase = false;
         }
       },

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

@@ -46,7 +46,6 @@ var _default = (0, _utils2.createRule)({
   defaultOptions: [],
 
   create(context) {
-    const scope = context.getScope();
     return {
       CallExpression(node) {
         var _getNodeName$endsWith, _getNodeName;
@@ -61,7 +60,7 @@ var _default = (0, _utils2.createRule)({
           return;
         }
 
-        const callback = findCallbackArg(node, isJestEach, scope);
+        const callback = findCallbackArg(node, isJestEach, context.getScope());
         const callbackArgIndex = Number(isJestEach);
 
         if (!callback || !(0, _utils2.isFunction)(callback) || callback.params.length !== 1 + callbackArgIndex) {

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

@@ -31,10 +31,11 @@ var _default = (0, _utils.createRule)({
   defaultOptions: [],
 
   create(context) {
-    const scope = context.getScope();
     const hookContexts = [newHookContext()];
     return {
       CallExpression(node) {
+        const scope = context.getScope();
+
         if ((0, _utils.isDescribeCall)(node, scope)) {
           hookContexts.push(newHookContext());
         }
@@ -56,7 +57,7 @@ var _default = (0, _utils.createRule)({
       },
 
       'CallExpression:exit'(node) {
-        if ((0, _utils.isDescribeCall)(node, scope)) {
+        if ((0, _utils.isDescribeCall)(node, context.getScope())) {
           hookContexts.pop();
         }
       }

package/lib/rules/no-export.js

@@ -26,7 +26,6 @@ var _default = (0, _utils2.createRule)({
   defaultOptions: [],
 
   create(context) {
-    const scope = context.getScope();
     const exportNodes = [];
     let hasTestCase = false;
     return {
@@ -42,7 +41,7 @@ var _default = (0, _utils2.createRule)({
       },
 
       CallExpression(node) {
-        if ((0, _utils2.isTestCaseCall)(node, scope)) {
+        if ((0, _utils2.isTestCaseCall)(node, context.getScope())) {
           hasTestCase = true;
         }
       },

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

@@ -47,9 +47,10 @@ var _default = (0, _utils2.createRule)({
   defaultOptions: [],
 
   create(context) {
-    const scope = context.getScope();
     return {
       CallExpression(node) {
+        const scope = context.getScope();
+
         if (!(0, _utils2.isDescribeCall)(node, scope) && !(0, _utils2.isTestCaseCall)(node, scope)) {
           return;
         }

package/lib/rules/no-hooks.js

@@ -37,10 +37,9 @@ var _default = (0, _utils.createRule)({
   create(context, [{
     allow = []
   }]) {
-    const scope = context.getScope();
     return {
       CallExpression(node) {
-        if ((0, _utils.isHookCall)(node, scope) && !allow.includes(node.callee.name)) {
+        if ((0, _utils.isHookCall)(node, context.getScope()) && !allow.includes(node.callee.name)) {
           context.report({
             node,
             messageId: 'unexpectedHook',

package/lib/rules/no-identical-title.js

@@ -30,12 +30,12 @@ var _default = (0, _utils.createRule)({
   defaultOptions: [],
 
   create(context) {
-    const scope = context.getScope();
     const contexts = [newDescribeContext()];
     return {
       CallExpression(node) {
         var _getNodeName;
 
+        const scope = context.getScope();
         const currentLayer = contexts[contexts.length - 1];
 
         if ((0, _utils.isDescribeCall)(node, scope)) {
@@ -80,7 +80,7 @@ var _default = (0, _utils.createRule)({
       },
 
       'CallExpression:exit'(node) {
-        if ((0, _utils.isDescribeCall)(node, scope)) {
+        if ((0, _utils.isDescribeCall)(node, context.getScope())) {
           contexts.pop();
         }
       }

package/lib/rules/no-if.js

@@ -38,7 +38,6 @@ var _default = (0, _utils2.createRule)({
   defaultOptions: [],
 
   create(context) {
-    const scope = context.getScope();
     const stack = [];
 
     function validate(node) {
@@ -59,7 +58,7 @@ var _default = (0, _utils2.createRule)({
 
     return {
       CallExpression(node) {
-        if ((0, _utils2.isTestCaseCall)(node, scope)) {
+        if ((0, _utils2.isTestCaseCall)(node, context.getScope())) {
           stack.push(true);
 
           if ((0, _utils2.getNodeName)(node).endsWith('each')) {
@@ -74,7 +73,7 @@ var _default = (0, _utils2.createRule)({
 
       FunctionDeclaration(node) {
         const declaredVariables = context.getDeclaredVariables(node);
-        const testCallExpressions = (0, _utils2.getTestCallExpressionsFromDeclaredVariables)(declaredVariables, scope);
+        const testCallExpressions = (0, _utils2.getTestCallExpressionsFromDeclaredVariables)(declaredVariables, context.getScope());
         stack.push(testCallExpressions.length > 0);
       },
 

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

@@ -69,12 +69,11 @@ var _default = (0, _utils2.createRule)({
   create(context, [{
     additionalTestBlockFunctions = []
   }]) {
-    const scope = context.getScope();
     const callStack = [];
 
     const isCustomTestBlockFunction = node => additionalTestBlockFunctions.includes((0, _utils2.getNodeName)(node) || '');
 
-    const isTestBlock = node => (0, _utils2.isTestCaseCall)(node, scope) || isCustomTestBlockFunction(node);
+    const isTestBlock = node => (0, _utils2.isTestCaseCall)(node, context.getScope()) || isCustomTestBlockFunction(node);
 
     return {
       CallExpression(node) {
@@ -109,7 +108,7 @@ var _default = (0, _utils2.createRule)({
       },
 
       BlockStatement(statement) {
-        const blockType = getBlockType(statement, scope);
+        const blockType = getBlockType(statement, context.getScope());
 
         if (blockType) {
           callStack.push(blockType);
@@ -117,7 +116,7 @@ var _default = (0, _utils2.createRule)({
       },
 
       'BlockStatement:exit'(statement) {
-        if (callStack[callStack.length - 1] === getBlockType(statement, scope)) {
+        if (callStack[callStack.length - 1] === getBlockType(statement, context.getScope())) {
           callStack.pop();
         }
       },

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

@@ -27,9 +27,9 @@ var _default = (0, _utils2.createRule)({
   defaultOptions: [],
 
   create(context) {
-    const scope = context.getScope();
     return {
       CallExpression(node) {
+        const scope = context.getScope();
         const nodeName = (0, _utils2.getNodeName)(node.callee);
         if (!nodeName || !(0, _utils2.isDescribeCall)(node, scope) && !(0, _utils2.isTestCaseCall)(node, scope)) return;
         const preferredNodeName = getPreferredNodeName(nodeName);

package/lib/rules/no-test-return-statement.js

@@ -36,10 +36,9 @@ var _default = (0, _utils2.createRule)({
   defaultOptions: [],
 
   create(context) {
-    const scope = context.getScope();
     return {
       CallExpression(node) {
-        if (!(0, _utils2.isTestCaseCall)(node, scope)) return;
+        if (!(0, _utils2.isTestCaseCall)(node, context.getScope())) return;
         const body = getBody(node.arguments);
         const returnStmt = body.find(t => t.type === _utils.AST_NODE_TYPES.ReturnStatement);
         if (!returnStmt) return;
@@ -51,7 +50,7 @@ var _default = (0, _utils2.createRule)({
 
       FunctionDeclaration(node) {
         const declaredVariables = context.getDeclaredVariables(node);
-        const testCallExpressions = (0, _utils2.getTestCallExpressionsFromDeclaredVariables)(declaredVariables, scope);
+        const testCallExpressions = (0, _utils2.getTestCallExpressionsFromDeclaredVariables)(declaredVariables, context.getScope());
         if (testCallExpressions.length === 0) return;
         const returnStmt = node.body.body.find(t => t.type === _utils.AST_NODE_TYPES.ReturnStatement);
         if (!returnStmt) return;

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

@@ -63,7 +63,6 @@ var _default = (0, _utils2.createRule)({
   }],
 
   create(context, [options]) {
-    const scope = context.getScope();
     let expressionDepth = 0;
     let hasExpectInCallback = false;
     let hasExpectInLoop = false;
@@ -117,7 +116,7 @@ var _default = (0, _utils2.createRule)({
       'ForOfStatement:exit': exitForLoop,
 
       CallExpression(node) {
-        if ((0, _utils2.isTestCaseCall)(node, scope)) {
+        if ((0, _utils2.isTestCaseCall)(node, context.getScope())) {
           inTestCaseCall = true;
           return;
         }
@@ -134,7 +133,7 @@ var _default = (0, _utils2.createRule)({
       },
 
       'CallExpression:exit'(node) {
-        if (!(0, _utils2.isTestCaseCall)(node, scope)) {
+        if (!(0, _utils2.isTestCaseCall)(node, context.getScope())) {
           return;
         }
 

package/lib/rules/prefer-hooks-in-order.js

@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _utils = require("./utils");
+
+const HooksOrder = ['beforeAll', 'beforeEach', 'afterEach', 'afterAll'];
+
+var _default = (0, _utils.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      category: 'Best Practices',
+      description: 'Prefer having hooks in a consistent order',
+      recommended: false
+    },
+    messages: {
+      reorderHooks: `\`{{ currentHook }}\` hooks should be before any \`{{ previousHook }}\` hooks`
+    },
+    schema: [],
+    type: 'suggestion'
+  },
+  defaultOptions: [],
+
+  create(context) {
+    let previousHookIndex = -1;
+    let inHook = false;
+    return {
+      CallExpression(node) {
+        if (inHook) {
+          // Ignore everything that is passed into a hook
+          return;
+        }
+
+        if (!(0, _utils.isHookCall)(node, context.getScope())) {
+          // Reset the previousHookIndex when encountering something different from a hook
+          previousHookIndex = -1;
+          return;
+        }
+
+        inHook = true;
+        const currentHook = node.callee.name;
+        const currentHookIndex = HooksOrder.indexOf(currentHook);
+
+        if (currentHookIndex < previousHookIndex) {
+          context.report({
+            messageId: 'reorderHooks',
+            node,
+            data: {
+              previousHook: HooksOrder[previousHookIndex],
+              currentHook
+            }
+          });
+          return;
+        }
+
+        previousHookIndex = currentHookIndex;
+      },
+
+      'CallExpression:exit'(node) {
+        if ((0, _utils.isHookCall)(node, context.getScope())) {
+          inHook = false;
+          return;
+        }
+
+        if (inHook) {
+          return;
+        } // Reset the previousHookIndex when encountering something different from a hook
+
+
+        previousHookIndex = -1;
+      }
+
+    };
+  }
+
+});
+
+exports.default = _default;

package/lib/rules/prefer-hooks-on-top.js

@@ -24,10 +24,11 @@ var _default = (0, _utils.createRule)({
   defaultOptions: [],
 
   create(context) {
-    const scope = context.getScope();
     const hooksContext = [false];
     return {
       CallExpression(node) {
+        const scope = context.getScope();
+
         if (!(0, _utils.isHookCall)(node, scope) && (0, _utils.isTestCaseCall)(node, scope)) {
           hooksContext[hooksContext.length - 1] = true;
         }

package/lib/rules/prefer-lowercase-title.js

@@ -88,11 +88,12 @@ var _default = (0, _utils.createRule)({
     allowedPrefixes = [],
     ignoreTopLevelDescribe
   }]) {
-    const scope = context.getScope();
     const ignores = populateIgnores(ignore);
     let numberOfDescribeBlocks = 0;
     return {
       CallExpression(node) {
+        const scope = context.getScope();
+
         if ((0, _utils.isDescribeCall)(node, scope)) {
           numberOfDescribeBlocks++;
 
@@ -138,7 +139,7 @@ var _default = (0, _utils.createRule)({
       },
 
       'CallExpression:exit'(node) {
-        if ((0, _utils.isDescribeCall)(node, scope)) {
+        if ((0, _utils.isDescribeCall)(node, context.getScope())) {
           numberOfDescribeBlocks--;
         }
       }

package/lib/rules/prefer-snapshot-hint.js

@@ -58,7 +58,6 @@ var _default = (0, _utils.createRule)({
   defaultOptions: ['multi'],
 
   create(context, [mode]) {
-    const scope = context.getScope();
     const snapshotMatchers = [];
     const depths = [];
     let expressionDepth = 0;
@@ -107,6 +106,8 @@ var _default = (0, _utils.createRule)({
       'ArrowFunctionExpression:exit': exitExpression,
 
       'CallExpression:exit'(node) {
+        const scope = context.getScope();
+
         if ((0, _utils.isDescribeCall)(node, scope) || (0, _utils.isTestCaseCall)(node, scope)) {
           var _depths$pop;
 
@@ -116,6 +117,8 @@ var _default = (0, _utils.createRule)({
       },
 
       CallExpression(node) {
+        const scope = context.getScope();
+
         if ((0, _utils.isDescribeCall)(node, scope) || (0, _utils.isTestCaseCall)(node, scope)) {
           depths.push(expressionDepth);
           expressionDepth = 0;

package/lib/rules/prefer-todo.js

@@ -43,12 +43,11 @@ var _default = (0, _utils2.createRule)({
   defaultOptions: [],
 
   create(context) {
-    const scope = context.getScope();
     return {
       CallExpression(node) {
         const [title, callback] = node.arguments;
 
-        if (!title || !isTargetedTestCase(node, scope) || !(0, _utils2.isStringNode)(title)) {
+        if (!title || !isTargetedTestCase(node, context.getScope()) || !(0, _utils2.isStringNode)(title)) {
           return;
         }
 

package/lib/rules/require-hook.js

@@ -79,14 +79,13 @@ var _default = (0, _utils2.createRule)({
   create(context) {
     var _context$options$;
 
-    const scope = context.getScope();
     const {
       allowedFunctionCalls
     } = (_context$options$ = context.options[0]) !== null && _context$options$ !== void 0 ? _context$options$ : {};
 
     const checkBlockBody = body => {
       for (const statement of body) {
-        if (shouldBeInHook(statement, scope, allowedFunctionCalls)) {
+        if (shouldBeInHook(statement, context.getScope(), allowedFunctionCalls)) {
           context.report({
             node: statement,
             messageId: 'useHook'
@@ -101,7 +100,7 @@ var _default = (0, _utils2.createRule)({
       },
 
       CallExpression(node) {
-        if (!(0, _utils2.isDescribeCall)(node, scope) || node.arguments.length < 2) {
+        if (!(0, _utils2.isDescribeCall)(node, context.getScope()) || node.arguments.length < 2) {
           return;
         }
 

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

@@ -42,11 +42,12 @@ var _default = (0, _utils.createRule)({
     const {
       maxNumberOfTopLevelDescribes = Infinity
     } = (_context$options$ = context.options[0]) !== null && _context$options$ !== void 0 ? _context$options$ : {};
-    const scope = context.getScope();
     let numberOfTopLevelDescribeBlocks = 0;
     let numberOfDescribeBlocks = 0;
     return {
       CallExpression(node) {
+        const scope = context.getScope();
+
         if ((0, _utils.isDescribeCall)(node, scope)) {
           numberOfDescribeBlocks++;
 
@@ -88,7 +89,7 @@ var _default = (0, _utils.createRule)({
       },
 
       'CallExpression:exit'(node) {
-        if ((0, _utils.isDescribeCall)(node, scope)) {
+        if ((0, _utils.isDescribeCall)(node, context.getScope())) {
           numberOfDescribeBlocks--;
         }
       }

package/lib/rules/utils.js

@@ -582,14 +582,8 @@ const collectReferences = scope => {
       if (ref.defs.length === 0) {
         continue;
       }
-      /* istanbul ignore if */
 
-
-      if (ref.defs.length > 1) {
-        throw new Error(`Reference unexpected had more than one definition - please file a github issue at https://github.com/jest-community/eslint-plugin-jest`);
-      }
-
-      const [def] = ref.defs;
+      const def = ref.defs[ref.defs.length - 1];
       const importDetails = describePossibleImportDef(def);
 
       if (importDetails) {

package/lib/rules/valid-describe-callback.js

@@ -39,10 +39,9 @@ var _default = (0, _utils2.createRule)({
   defaultOptions: [],
 
   create(context) {
-    const scope = context.getScope();
     return {
       CallExpression(node) {
-        if (!(0, _utils2.isDescribeCall)(node, scope)) {
+        if (!(0, _utils2.isDescribeCall)(node, context.getScope())) {
           return;
         }
 

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

@@ -299,7 +299,6 @@ var _default = (0, _utils2.createRule)({
   defaultOptions: [],
 
   create(context) {
-    const scope = context.getScope();
     let inTestCaseWithDoneCallback = false; // an array of booleans representing each promise chain we enter, with the
     // boolean value representing if we think a given chain contains an expect
     // in it's body.
@@ -313,7 +312,7 @@ var _default = (0, _utils2.createRule)({
       CallExpression(node) {
         // there are too many ways that the done argument could be used with
         // promises that contain expect that would make the promise safe for us
-        if (isTestCaseCallWithCallbackArg(node, scope)) {
+        if (isTestCaseCallWithCallbackArg(node, context.getScope())) {
           inTestCaseWithDoneCallback = true;
           return;
         } // if this call expression is a promise chain, add it to the stack with
@@ -337,7 +336,7 @@ var _default = (0, _utils2.createRule)({
         // make promises containing expects safe in a test for us to be able to
         // accurately check, so we just bail out completely if it's present
         if (inTestCaseWithDoneCallback) {
-          if ((0, _utils2.isTestCaseCall)(node, scope)) {
+          if ((0, _utils2.isTestCaseCall)(node, context.getScope())) {
             inTestCaseWithDoneCallback = false;
           }
 
@@ -364,7 +363,7 @@ var _default = (0, _utils2.createRule)({
         // because we're most likely in the body of a function being defined
         // within the test, which we can't track
 
-        if (!parent || !isDirectlyWithinTestCaseCall(parent, scope)) {
+        if (!parent || !isDirectlyWithinTestCaseCall(parent, context.getScope())) {
           return;
         }
 

package/lib/rules/valid-title.js

@@ -123,7 +123,6 @@ var _default = (0, _utils2.createRule)({
     mustNotMatch,
     mustMatch
   }]) {
-    const scope = context.getScope();
     const disallowedWordsRegexp = new RegExp(`\\b(${disallowedWords.join('|')})\\b`, 'iu');
     const mustNotMatchPatterns = compileMatcherPatterns(mustNotMatch !== null && mustNotMatch !== void 0 ? mustNotMatch : {});
     const mustMatchPatterns = compileMatcherPatterns(mustMatch !== null && mustMatch !== void 0 ? mustMatch : {});
@@ -131,6 +130,8 @@ var _default = (0, _utils2.createRule)({
       CallExpression(node) {
         var _mustNotMatchPatterns, _mustMatchPatterns$je;
 
+        const scope = context.getScope();
+
         if (!(0, _utils2.isDescribeCall)(node, scope) && !(0, _utils2.isTestCaseCall)(node, scope)) {
           return;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-jest",
-  "version": "26.2.0",
+  "version": "26.3.0",
   "description": "ESLint rules for Jest",
   "keywords": [
     "eslint",