eslint-plugin-jest 26.1.3 → 26.2.0

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

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

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

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

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

@@ -9,8 +9,8 @@ var _utils = require("./utils");
 
 const hasStringAsFirstArgument = node => node.arguments[0] && (0, _utils.isStringNode)(node.arguments[0]);
 
-const findNodeNameAndArgument = node => {
-  if (!((0, _utils.isTestCaseCall)(node) || (0, _utils.isDescribeCall)(node))) {
+const findNodeNameAndArgument = (node, scope) => {
+  if (!((0, _utils.isTestCaseCall)(node, scope) || (0, _utils.isDescribeCall)(node, scope))) {
     return null;
   }
 
@@ -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) {
-        if ((0, _utils.isDescribeCall)(node)) {
+        if ((0, _utils.isDescribeCall)(node, scope)) {
           numberOfDescribeBlocks++;
 
           if (ignoreTopLevelDescribe && numberOfDescribeBlocks === 1) {
@@ -100,7 +101,7 @@ var _default = (0, _utils.createRule)({
           }
         }
 
-        const results = findNodeNameAndArgument(node);
+        const results = findNodeNameAndArgument(node, scope);
 
         if (!results) {
           return;
@@ -137,7 +138,7 @@ var _default = (0, _utils.createRule)({
       },
 
       'CallExpression:exit'(node) {
-        if ((0, _utils.isDescribeCall)(node)) {
+        if ((0, _utils.isDescribeCall)(node, scope)) {
           numberOfDescribeBlocks--;
         }
       }

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

@@ -58,7 +58,9 @@ var _default = (0, _utils.createRule)({
   defaultOptions: ['multi'],
 
   create(context, [mode]) {
+    const scope = context.getScope();
     const snapshotMatchers = [];
+    const depths = [];
     let expressionDepth = 0;
 
     const reportSnapshotMatchersWithoutHints = () => {
@@ -104,7 +106,21 @@ var _default = (0, _utils.createRule)({
       ArrowFunctionExpression: enterExpression,
       'ArrowFunctionExpression:exit': exitExpression,
 
+      'CallExpression:exit'(node) {
+        if ((0, _utils.isDescribeCall)(node, scope) || (0, _utils.isTestCaseCall)(node, scope)) {
+          var _depths$pop;
+
+          /* istanbul ignore next */
+          expressionDepth = (_depths$pop = depths.pop()) !== null && _depths$pop !== void 0 ? _depths$pop : 0;
+        }
+      },
+
       CallExpression(node) {
+        if ((0, _utils.isDescribeCall)(node, scope) || (0, _utils.isTestCaseCall)(node, scope)) {
+          depths.push(expressionDepth);
+          expressionDepth = 0;
+        }
+
         if (!(0, _utils.isExpectCall)(node)) {
           return;
         }

package/lib/rules/prefer-todo.js

@@ -22,7 +22,7 @@ function createTodoFixer(node, fixer) {
   return fixer.replaceText(node.callee, `${testName}.todo`);
 }
 
-const isTargetedTestCase = node => (0, _utils2.isTestCaseCall)(node) && [_utils2.TestCaseName.it, _utils2.TestCaseName.test, 'it.skip', 'test.skip'].includes((0, _utils2.getNodeName)(node));
+const isTargetedTestCase = (node, scope) => (0, _utils2.isTestCaseCall)(node, scope) && [_utils2.TestCaseName.it, _utils2.TestCaseName.test, 'it.skip', 'test.skip'].includes((0, _utils2.getNodeName)(node));
 
 var _default = (0, _utils2.createRule)({
   name: __filename,
@@ -43,11 +43,12 @@ var _default = (0, _utils2.createRule)({
   defaultOptions: [],
 
   create(context) {
+    const scope = context.getScope();
     return {
       CallExpression(node) {
         const [title, callback] = node.arguments;
 
-        if (!title || !isTargetedTestCase(node) || !(0, _utils2.isStringNode)(title)) {
+        if (!title || !isTargetedTestCase(node, scope) || !(0, _utils2.isStringNode)(title)) {
           return;
         }
 

package/lib/rules/require-hook.js

@@ -9,10 +9,10 @@ var _utils = require("@typescript-eslint/utils");
 
 var _utils2 = require("./utils");
 
-const isJestFnCall = node => {
+const isJestFnCall = (node, scope) => {
   var _getNodeName;
 
-  if ((0, _utils2.isDescribeCall)(node) || (0, _utils2.isTestCaseCall)(node) || (0, _utils2.isHook)(node)) {
+  if ((0, _utils2.isDescribeCall)(node, scope) || (0, _utils2.isTestCaseCall)(node, scope) || (0, _utils2.isHookCall)(node, scope)) {
     return true;
   }
 
@@ -23,13 +23,13 @@ const isNullOrUndefined = node => {
   return node.type === _utils.AST_NODE_TYPES.Literal && node.value === null || (0, _utils2.isIdentifier)(node, 'undefined');
 };
 
-const shouldBeInHook = (node, allowedFunctionCalls = []) => {
+const shouldBeInHook = (node, scope, allowedFunctionCalls = []) => {
   switch (node.type) {
     case _utils.AST_NODE_TYPES.ExpressionStatement:
-      return shouldBeInHook(node.expression, allowedFunctionCalls);
+      return shouldBeInHook(node.expression, scope, allowedFunctionCalls);
 
     case _utils.AST_NODE_TYPES.CallExpression:
-      return !(isJestFnCall(node) || allowedFunctionCalls.includes((0, _utils2.getNodeName)(node)));
+      return !(isJestFnCall(node, scope) || allowedFunctionCalls.includes((0, _utils2.getNodeName)(node)));
 
     case _utils.AST_NODE_TYPES.VariableDeclaration:
       {
@@ -79,13 +79,14 @@ 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, allowedFunctionCalls)) {
+        if (shouldBeInHook(statement, scope, allowedFunctionCalls)) {
           context.report({
             node: statement,
             messageId: 'useHook'
@@ -100,7 +101,7 @@ var _default = (0, _utils2.createRule)({
       },
 
       CallExpression(node) {
-        if (!(0, _utils2.isDescribeCall)(node) || node.arguments.length < 2) {
+        if (!(0, _utils2.isDescribeCall)(node, scope) || 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) {
-        if ((0, _utils.isDescribeCall)(node)) {
+        if ((0, _utils.isDescribeCall)(node, scope)) {
           numberOfDescribeBlocks++;
 
           if (numberOfDescribeBlocks === 1) {
@@ -68,7 +69,7 @@ var _default = (0, _utils.createRule)({
         }
 
         if (numberOfDescribeBlocks === 0) {
-          if ((0, _utils.isTestCaseCall)(node)) {
+          if ((0, _utils.isTestCaseCall)(node, scope)) {
             context.report({
               node,
               messageId: 'unexpectedTestCase'
@@ -76,7 +77,7 @@ var _default = (0, _utils.createRule)({
             return;
           }
 
-          if ((0, _utils.isHook)(node)) {
+          if ((0, _utils.isHookCall)(node, scope)) {
             context.report({
               node,
               messageId: 'unexpectedHook'
@@ -87,7 +88,7 @@ var _default = (0, _utils.createRule)({
       },
 
       'CallExpression:exit'(node) {
-        if ((0, _utils.isDescribeCall)(node)) {
+        if ((0, _utils.isDescribeCall)(node, scope)) {
           numberOfDescribeBlocks--;
         }
       }

package/lib/rules/utils.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.getAccessorValue = exports.followTypeAssertionChain = exports.createRule = exports.TestCaseProperty = exports.TestCaseName = exports.ModifierName = exports.HookName = exports.EqualityMatcher = exports.DescribeProperty = exports.DescribeAlias = void 0;
 exports.getNodeName = getNodeName;
-exports.scopeHasLocalReference = exports.parseExpectCall = exports.isTestCaseCall = exports.isSupportedAccessor = exports.isStringNode = exports.isParsedEqualityMatcherCall = exports.isIdentifier = exports.isHook = exports.isFunction = exports.isExpectMember = exports.isExpectCall = exports.isDescribeCall = exports.hasOnlyOneArgument = exports.getTestCallExpressionsFromDeclaredVariables = exports.getStringValue = void 0;
+exports.scopeHasLocalReference = exports.parseExpectCall = exports.isTestCaseCall = exports.isSupportedAccessor = exports.isStringNode = exports.isParsedEqualityMatcherCall = exports.isIdentifier = exports.isHookCall = exports.isFunction = exports.isExpectMember = exports.isExpectCall = exports.isDescribeCall = exports.hasOnlyOneArgument = exports.getTestCallExpressionsFromDeclaredVariables = exports.getStringValue = void 0;
 
 var _path = require("path");
 
@@ -384,108 +384,220 @@ const isFunction = node => node.type === _utils.AST_NODE_TYPES.FunctionExpressio
 
 exports.isFunction = isFunction;
 
-const isHook = node => node.callee.type === _utils.AST_NODE_TYPES.Identifier && HookName.hasOwnProperty(node.callee.name);
+const isHookCall = (node, scope) => {
+  let name = findFirstCallPropertyName(node, []);
 
-exports.isHook = isHook;
+  if (!name) {
+    return false;
+  }
+
+  name = resolveToJestFn(scope, name);
+  return name !== null && HookName.hasOwnProperty(name);
+};
 
-const getTestCallExpressionsFromDeclaredVariables = declaredVariables => {
+exports.isHookCall = isHookCall;
+
+const getTestCallExpressionsFromDeclaredVariables = (declaredVariables, scope) => {
   return declaredVariables.reduce((acc, {
     references
   }) => acc.concat(references.map(({
     identifier
-  }) => identifier.parent).filter(node => !!node && node.type === _utils.AST_NODE_TYPES.CallExpression && isTestCaseCall(node))), []);
+  }) => identifier.parent).filter(node => !!node && node.type === _utils.AST_NODE_TYPES.CallExpression && isTestCaseCall(node, scope))), []);
 };
-
-exports.getTestCallExpressionsFromDeclaredVariables = getTestCallExpressionsFromDeclaredVariables;
-
-const isTestCaseName = node => node.type === _utils.AST_NODE_TYPES.Identifier && TestCaseName.hasOwnProperty(node.name);
-
-const isTestCaseProperty = node => isSupportedAccessor(node) && TestCaseProperty.hasOwnProperty(getAccessorValue(node));
 /**
  * Checks if the given `node` is a *call* to a test case function that would
  * result in tests being run by `jest`.
  *
  * Note that `.each()` does not count as a call in this context, as it will not
  * result in `jest` running any tests.
- *
- * @param {TSESTree.CallExpression} node
- *
- * @return {node is JestFunctionCallExpression<TestCaseName>}
  */
 
 
-const isTestCaseCall = node => {
-  if (isTestCaseName(node.callee)) {
-    return true;
+exports.getTestCallExpressionsFromDeclaredVariables = getTestCallExpressionsFromDeclaredVariables;
+
+const isTestCaseCall = (node, scope) => {
+  let name = findFirstCallPropertyName(node, Object.keys(TestCaseProperty));
+
+  if (!name) {
+    return false;
+  }
+
+  name = resolveToJestFn(scope, name);
+  return name !== null && TestCaseName.hasOwnProperty(name);
+};
+
+exports.isTestCaseCall = isTestCaseCall;
+
+const findFirstCallPropertyName = (node, properties) => {
+  if (isIdentifier(node.callee)) {
+    return node.callee.name;
   }
 
   const callee = 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 (callee.type === _utils.AST_NODE_TYPES.MemberExpression && isTestCaseProperty(callee.property)) {
+  if (callee.type === _utils.AST_NODE_TYPES.MemberExpression && isSupportedAccessor(callee.property) && properties.includes(getAccessorValue(callee.property))) {
     // if we're an `each()`, ensure we're the outer CallExpression (i.e `.each()()`)
     if (getAccessorValue(callee.property) === 'each' && node.callee.type !== _utils.AST_NODE_TYPES.TaggedTemplateExpression && node.callee.type !== _utils.AST_NODE_TYPES.CallExpression) {
-      return false;
+      return null;
     }
 
-    return callee.object.type === _utils.AST_NODE_TYPES.MemberExpression ? isTestCaseName(callee.object.object) : isTestCaseName(callee.object);
+    const nod = callee.object.type === _utils.AST_NODE_TYPES.MemberExpression ? callee.object.object : callee.object;
+
+    if (isSupportedAccessor(nod)) {
+      return getAccessorValue(nod);
+    }
   }
 
-  return false;
+  return null;
 };
-
-exports.isTestCaseCall = isTestCaseCall;
-
-const isDescribeAlias = node => node.type === _utils.AST_NODE_TYPES.Identifier && DescribeAlias.hasOwnProperty(node.name);
-
-const isDescribeProperty = node => isSupportedAccessor(node) && DescribeProperty.hasOwnProperty(getAccessorValue(node));
 /**
  * Checks if the given `node` is a *call* to a `describe` function that would
  * result in a `describe` block being created by `jest`.
  *
  * Note that `.each()` does not count as a call in this context, as it will not
  * result in `jest` creating any `describe` blocks.
- *
- * @param {TSESTree.CallExpression} node
- *
- * @return {node is JestFunctionCallExpression<TestCaseName>}
  */
 
 
-const isDescribeCall = node => {
-  if (isDescribeAlias(node.callee)) {
-    return true;
+const isDescribeCall = (node, scope) => {
+  let name = findFirstCallPropertyName(node, Object.keys(DescribeProperty));
+
+  if (!name) {
+    return false;
   }
 
-  const callee = node.callee.type === _utils.AST_NODE_TYPES.TaggedTemplateExpression ? node.callee.tag : node.callee.type === _utils.AST_NODE_TYPES.CallExpression ? node.callee.callee : node.callee;
+  name = resolveToJestFn(scope, name);
+  return name !== null && DescribeAlias.hasOwnProperty(name);
+};
 
-  if (callee.type === _utils.AST_NODE_TYPES.MemberExpression && isDescribeProperty(callee.property)) {
-    // if we're an `each()`, ensure we're the outer CallExpression (i.e `.each()()`)
-    if (getAccessorValue(callee.property) === 'each' && node.callee.type !== _utils.AST_NODE_TYPES.TaggedTemplateExpression && node.callee.type !== _utils.AST_NODE_TYPES.CallExpression) {
-      return false;
+exports.isDescribeCall = isDescribeCall;
+
+const describeImportDefAsImport = def => {
+  if (def.parent.type === _utils.AST_NODE_TYPES.TSImportEqualsDeclaration) {
+    return null;
+  }
+
+  if (def.node.type !== _utils.AST_NODE_TYPES.ImportSpecifier) {
+    return null;
+  } // we only care about value imports
+
+
+  if (def.parent.importKind === 'type') {
+    return null;
+  }
+
+  return {
+    source: def.parent.source.value,
+    imported: def.node.imported.name,
+    local: def.node.local.name
+  };
+};
+/**
+ * Attempts to find the node that represents the import source for the
+ * given expression node, if it looks like it's an import.
+ *
+ * If no such node can be found (e.g. because the expression doesn't look
+ * like an import), then `null` is returned instead.
+ */
+
+
+const findImportSourceNode = node => {
+  if (node.type === _utils.AST_NODE_TYPES.AwaitExpression) {
+    if (node.argument.type === _utils.AST_NODE_TYPES.ImportExpression) {
+      return node.argument.source;
     }
 
-    return callee.object.type === _utils.AST_NODE_TYPES.MemberExpression ? isDescribeAlias(callee.object.object) : isDescribeAlias(callee.object);
+    return null;
+  }
+
+  if (node.type === _utils.AST_NODE_TYPES.CallExpression && isIdentifier(node.callee, 'require')) {
+    var _node$arguments$;
+
+    return (_node$arguments$ = node.arguments[0]) !== null && _node$arguments$ !== void 0 ? _node$arguments$ : null;
   }
 
-  return false;
+  return null;
 };
 
-exports.isDescribeCall = isDescribeCall;
+const describeVariableDefAsImport = def => {
+  var _def$name$parent;
+
+  // make sure that we've actually being assigned a value
+  if (!def.node.init) {
+    return null;
+  }
+
+  const sourceNode = findImportSourceNode(def.node.init);
+
+  if (!sourceNode || !isStringNode(sourceNode)) {
+    return null;
+  }
+
+  if (((_def$name$parent = def.name.parent) === null || _def$name$parent === void 0 ? void 0 : _def$name$parent.type) !== _utils.AST_NODE_TYPES.Property) {
+    return null;
+  }
+
+  if (!isSupportedAccessor(def.name.parent.key)) {
+    return null;
+  }
+
+  return {
+    source: getStringValue(sourceNode),
+    imported: getAccessorValue(def.name.parent.key),
+    local: def.name.name
+  };
+};
+/**
+ * Attempts to describe a definition as an import if possible.
+ *
+ * If the definition is an import binding, it's described as you'd expect.
+ * If the definition is a variable, then we try and determine if it's either
+ * a dynamic `import()` or otherwise a call to `require()`.
+ *
+ * If it's neither of these, `null` is returned to indicate that the definition
+ * is not describable as an import of any kind.
+ */
+
+
+const describePossibleImportDef = def => {
+  if (def.type === 'Variable') {
+    return describeVariableDefAsImport(def);
+  }
+
+  if (def.type === 'ImportBinding') {
+    return describeImportDefAsImport(def);
+  }
+
+  return null;
+};
 
 const collectReferences = scope => {
   const locals = new Set();
+  const imports = new Map();
   const unresolved = new Set();
   let currentScope = scope;
 
   while (currentScope !== null) {
     for (const ref of currentScope.variables) {
-      const isReferenceDefined = ref.defs.some(def => {
-        return def.type !== 'ImplicitGlobalVariable';
-      });
+      if (ref.defs.length === 0) {
+        continue;
+      }
+      /* istanbul ignore if */
 
-      if (isReferenceDefined) {
-        locals.add(ref.name);
+
+      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 importDetails = describePossibleImportDef(def);
+
+      if (importDetails) {
+        imports.set(importDetails.local, importDetails);
+        continue;
+      }
+
+      locals.add(ref.name);
     }
 
     for (const ref of currentScope.through) {
@@ -497,6 +609,7 @@ const collectReferences = scope => {
 
   return {
     locals,
+    imports,
     unresolved
   };
 };
@@ -504,10 +617,34 @@ const collectReferences = scope => {
 const scopeHasLocalReference = (scope, referenceName) => {
   const references = collectReferences(scope);
   return (// referenceName was found as a local variable or function declaration.
-    references.locals.has(referenceName) || // referenceName was not found as an unresolved reference,
+    references.locals.has(referenceName) || // referenceName was found as an imported identifier
+    references.imports.has(referenceName) || // referenceName was not found as an unresolved reference,
     // meaning it is likely not an implicit global reference.
     !references.unresolved.has(referenceName)
   );
 };
 
-exports.scopeHasLocalReference = scopeHasLocalReference;
+exports.scopeHasLocalReference = scopeHasLocalReference;
+
+const resolveToJestFn = (scope, identifier) => {
+  const references = collectReferences(scope);
+  const maybeImport = references.imports.get(identifier);
+
+  if (maybeImport) {
+    // the identifier is imported from @jest/globals,
+    // so return the original import name
+    if (maybeImport.source === '@jest/globals') {
+      return maybeImport.imported;
+    }
+
+    return null;
+  } // the identifier was found as a local variable or function declaration
+  // meaning it's not a function from jest
+
+
+  if (references.locals.has(identifier)) {
+    return null;
+  }
+
+  return identifier;
+};

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

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

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

@@ -52,8 +52,8 @@ const findTopMostCallExpression = node => {
   return topMostCallExpression;
 };
 
-const isTestCaseCallWithCallbackArg = node => {
-  if (!(0, _utils2.isTestCaseCall)(node)) {
+const isTestCaseCallWithCallbackArg = (node, scope) => {
+  if (!(0, _utils2.isTestCaseCall)(node, scope)) {
     return false;
   }
 
@@ -254,7 +254,7 @@ const findFirstBlockBodyUp = node => {
   throw new Error(`Could not find BlockStatement - please file a github issue at https://github.com/jest-community/eslint-plugin-jest`);
 };
 
-const isDirectlyWithinTestCaseCall = node => {
+const isDirectlyWithinTestCaseCall = (node, scope) => {
   let parent = node;
 
   while (parent) {
@@ -262,7 +262,7 @@ const isDirectlyWithinTestCaseCall = node => {
       var _parent;
 
       parent = parent.parent;
-      return !!(((_parent = parent) === null || _parent === void 0 ? void 0 : _parent.type) === _utils.AST_NODE_TYPES.CallExpression && (0, _utils2.isTestCaseCall)(parent));
+      return !!(((_parent = parent) === null || _parent === void 0 ? void 0 : _parent.type) === _utils.AST_NODE_TYPES.CallExpression && (0, _utils2.isTestCaseCall)(parent, scope));
     }
 
     parent = parent.parent;
@@ -299,6 +299,7 @@ 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.
@@ -312,7 +313,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)) {
+        if (isTestCaseCallWithCallbackArg(node, scope)) {
           inTestCaseWithDoneCallback = true;
           return;
         } // if this call expression is a promise chain, add it to the stack with
@@ -336,7 +337,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)) {
+          if ((0, _utils2.isTestCaseCall)(node, scope)) {
             inTestCaseWithDoneCallback = false;
           }
 
@@ -363,7 +364,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)) {
+        if (!parent || !isDirectlyWithinTestCaseCall(parent, scope)) {
           return;
         }
 

package/lib/rules/valid-title.js

@@ -123,6 +123,7 @@ 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 : {});
@@ -130,7 +131,7 @@ var _default = (0, _utils2.createRule)({
       CallExpression(node) {
         var _mustNotMatchPatterns, _mustMatchPatterns$je;
 
-        if (!(0, _utils2.isDescribeCall)(node) && !(0, _utils2.isTestCaseCall)(node)) {
+        if (!(0, _utils2.isDescribeCall)(node, scope) && !(0, _utils2.isTestCaseCall)(node, scope)) {
           return;
         }
 
@@ -145,7 +146,7 @@ var _default = (0, _utils2.createRule)({
             return;
           }
 
-          if (argument.type !== _utils.AST_NODE_TYPES.TemplateLiteral && !(ignoreTypeOfDescribeName && (0, _utils2.isDescribeCall)(node))) {
+          if (argument.type !== _utils.AST_NODE_TYPES.TemplateLiteral && !(ignoreTypeOfDescribeName && (0, _utils2.isDescribeCall)(node, scope))) {
             context.report({
               messageId: 'titleMustBeString',
               loc: argument.loc
@@ -161,7 +162,7 @@ var _default = (0, _utils2.createRule)({
           context.report({
             messageId: 'emptyTitle',
             data: {
-              jestFunctionName: (0, _utils2.isDescribeCall)(node) ? _utils2.DescribeAlias.describe : _utils2.TestCaseName.test
+              jestFunctionName: (0, _utils2.isDescribeCall)(node, scope) ? _utils2.DescribeAlias.describe : _utils2.TestCaseName.test
             },
             node
           });