eslint-plugin-jest 26.1.1 → 26.5.3

package/lib/rules/utils/misc.js

@@ -0,0 +1,120 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createRule = exports.TestCaseName = exports.HookName = exports.DescribeAlias = void 0;
+exports.getNodeName = getNodeName;
+exports.replaceAccessorFixer = exports.isFunction = exports.hasOnlyOneArgument = exports.getTestCallExpressionsFromDeclaredVariables = void 0;
+
+var _path = require("path");
+
+var _utils = require("@typescript-eslint/utils");
+
+var _package = require("../../../package.json");
+
+var _accessors = require("./accessors");
+
+var _parseJestFnCall = require("./parseJestFnCall");
+
+const REPO_URL = 'https://github.com/jest-community/eslint-plugin-jest';
+
+const createRule = _utils.ESLintUtils.RuleCreator(name => {
+  const ruleName = (0, _path.parse)(name).name;
+  return `${REPO_URL}/blob/v${_package.version}/docs/rules/${ruleName}.md`;
+});
+/**
+ * Represents a `MemberExpression` with a "known" `property`.
+ */
+
+
+exports.createRule = createRule;
+
+/**
+ * Guards that the given `call` has only one `argument`.
+ *
+ * @param {CallExpression} call
+ *
+ * @return {call is CallExpressionWithSingleArgument}
+ */
+const hasOnlyOneArgument = call => call.arguments.length === 1;
+
+exports.hasOnlyOneArgument = hasOnlyOneArgument;
+let DescribeAlias;
+exports.DescribeAlias = DescribeAlias;
+
+(function (DescribeAlias) {
+  DescribeAlias["describe"] = "describe";
+  DescribeAlias["fdescribe"] = "fdescribe";
+  DescribeAlias["xdescribe"] = "xdescribe";
+})(DescribeAlias || (exports.DescribeAlias = DescribeAlias = {}));
+
+let TestCaseName;
+exports.TestCaseName = TestCaseName;
+
+(function (TestCaseName) {
+  TestCaseName["fit"] = "fit";
+  TestCaseName["it"] = "it";
+  TestCaseName["test"] = "test";
+  TestCaseName["xit"] = "xit";
+  TestCaseName["xtest"] = "xtest";
+})(TestCaseName || (exports.TestCaseName = TestCaseName = {}));
+
+let HookName;
+exports.HookName = HookName;
+
+(function (HookName) {
+  HookName["beforeAll"] = "beforeAll";
+  HookName["beforeEach"] = "beforeEach";
+  HookName["afterAll"] = "afterAll";
+  HookName["afterEach"] = "afterEach";
+})(HookName || (exports.HookName = HookName = {}));
+
+const joinNames = (a, b) => a && b ? `${a}.${b}` : null;
+
+function getNodeName(node) {
+  if ((0, _accessors.isSupportedAccessor)(node)) {
+    return (0, _accessors.getAccessorValue)(node);
+  }
+
+  switch (node.type) {
+    case _utils.AST_NODE_TYPES.TaggedTemplateExpression:
+      return getNodeName(node.tag);
+
+    case _utils.AST_NODE_TYPES.MemberExpression:
+      return joinNames(getNodeName(node.object), getNodeName(node.property));
+
+    case _utils.AST_NODE_TYPES.NewExpression:
+    case _utils.AST_NODE_TYPES.CallExpression:
+      return getNodeName(node.callee);
+  }
+
+  return null;
+}
+
+const isFunction = node => node.type === _utils.AST_NODE_TYPES.FunctionExpression || node.type === _utils.AST_NODE_TYPES.ArrowFunctionExpression;
+
+exports.isFunction = isFunction;
+
+const getTestCallExpressionsFromDeclaredVariables = (declaredVariables, context) => {
+  return declaredVariables.reduce((acc, {
+    references
+  }) => acc.concat(references.map(({
+    identifier
+  }) => identifier.parent).filter(node => (node === null || node === void 0 ? void 0 : node.type) === _utils.AST_NODE_TYPES.CallExpression && (0, _parseJestFnCall.isTypeOfJestFnCall)(node, context, ['test']))), []);
+};
+/**
+ * Replaces an accessor node with the given `text`, surrounding it in quotes if required.
+ *
+ * This ensures that fixes produce valid code when replacing both dot-based and
+ * bracket-based property accessors.
+ */
+
+
+exports.getTestCallExpressionsFromDeclaredVariables = getTestCallExpressionsFromDeclaredVariables;
+
+const replaceAccessorFixer = (fixer, node, text) => {
+  return fixer.replaceText(node, node.type === _utils.AST_NODE_TYPES.Identifier ? text : `'${text}'`);
+};
+
+exports.replaceAccessorFixer = replaceAccessorFixer;

package/lib/rules/utils/parseExpectCall.js

@@ -0,0 +1,145 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseExpectCall = exports.isParsedEqualityMatcherCall = exports.isExpectMember = exports.isExpectCall = exports.ModifierName = exports.EqualityMatcher = void 0;
+
+var _utils = require("@typescript-eslint/utils");
+
+var _utils2 = require("../utils");
+
+/**
+ * Checks if the given `node` is a valid `ExpectCall`.
+ *
+ * In order to be an `ExpectCall`, the `node` must:
+ *  * be a `CallExpression`,
+ *  * have an accessor named 'expect',
+ *  * have a `parent`.
+ *
+ * @param {Node} node
+ *
+ * @return {node is ExpectCall}
+ */
+const isExpectCall = node => node.type === _utils.AST_NODE_TYPES.CallExpression && (0, _utils2.isSupportedAccessor)(node.callee, 'expect') && node.parent !== undefined;
+
+exports.isExpectCall = isExpectCall;
+
+const isExpectMember = (node, name) => node.type === _utils.AST_NODE_TYPES.MemberExpression && (0, _utils2.isSupportedAccessor)(node.property, name);
+/**
+ * Represents all the jest matchers.
+ */
+
+
+exports.isExpectMember = isExpectMember;
+let ModifierName;
+exports.ModifierName = ModifierName;
+
+(function (ModifierName) {
+  ModifierName["not"] = "not";
+  ModifierName["rejects"] = "rejects";
+  ModifierName["resolves"] = "resolves";
+})(ModifierName || (exports.ModifierName = ModifierName = {}));
+
+let EqualityMatcher;
+exports.EqualityMatcher = EqualityMatcher;
+
+(function (EqualityMatcher) {
+  EqualityMatcher["toBe"] = "toBe";
+  EqualityMatcher["toEqual"] = "toEqual";
+  EqualityMatcher["toStrictEqual"] = "toStrictEqual";
+})(EqualityMatcher || (exports.EqualityMatcher = EqualityMatcher = {}));
+
+const isParsedEqualityMatcherCall = (matcher, name) => (name ? matcher.name === name : EqualityMatcher.hasOwnProperty(matcher.name)) && matcher.arguments !== null && matcher.arguments.length === 1;
+/**
+ * Represents a parsed expect matcher, such as `toBe`, `toContain`, and so on.
+ */
+
+
+exports.isParsedEqualityMatcherCall = isParsedEqualityMatcherCall;
+
+const parseExpectMember = expectMember => ({
+  name: (0, _utils2.getAccessorValue)(expectMember.property),
+  node: expectMember
+});
+
+const reparseAsMatcher = parsedMember => ({ ...parsedMember,
+
+  /**
+   * The arguments being passed to this `Matcher`, if any.
+   *
+   * If this matcher isn't called, this will be `null`.
+   */
+  arguments: parsedMember.node.parent.type === _utils.AST_NODE_TYPES.CallExpression ? parsedMember.node.parent.arguments : null
+});
+/**
+ * Re-parses the given `parsedMember` as a `ParsedExpectModifier`.
+ *
+ * If the given `parsedMember` does not have a `name` of a valid `Modifier`,
+ * an exception will be thrown.
+ *
+ * @param {ParsedExpectMember<ModifierName>} parsedMember
+ *
+ * @return {ParsedExpectModifier}
+ */
+
+
+const reparseMemberAsModifier = parsedMember => {
+  if (isSpecificMember(parsedMember, ModifierName.not)) {
+    return parsedMember;
+  }
+  /* istanbul ignore if */
+
+
+  if (!isSpecificMember(parsedMember, ModifierName.resolves) && !isSpecificMember(parsedMember, ModifierName.rejects)) {
+    // ts doesn't think that the ModifierName.not check is the direct inverse as the above two checks
+    // todo: impossible at runtime, but can't be typed w/o negation support
+    throw new Error(`modifier name must be either "${ModifierName.resolves}" or "${ModifierName.rejects}" (got "${parsedMember.name}")`);
+  }
+
+  const negation = isExpectMember(parsedMember.node.parent, ModifierName.not) ? parsedMember.node.parent : undefined;
+  return { ...parsedMember,
+    negation
+  };
+};
+
+const isSpecificMember = (member, specific) => member.name === specific;
+/**
+ * Checks if the given `ParsedExpectMember` should be re-parsed as an `ParsedExpectModifier`.
+ *
+ * @param {ParsedExpectMember} member
+ *
+ * @return {member is ParsedExpectMember<ModifierName>}
+ */
+
+
+const shouldBeParsedExpectModifier = member => ModifierName.hasOwnProperty(member.name);
+
+const parseExpectCall = expect => {
+  const expectation = {
+    expect
+  };
+
+  if (!isExpectMember(expect.parent)) {
+    return expectation;
+  }
+
+  const parsedMember = parseExpectMember(expect.parent);
+
+  if (!shouldBeParsedExpectModifier(parsedMember)) {
+    expectation.matcher = reparseAsMatcher(parsedMember);
+    return expectation;
+  }
+
+  const modifier = expectation.modifier = reparseMemberAsModifier(parsedMember);
+  const memberNode = modifier.negation || modifier.node;
+
+  if (!isExpectMember(memberNode.parent)) {
+    return expectation;
+  }
+
+  expectation.matcher = reparseAsMatcher(parseExpectMember(memberNode.parent));
+  return expectation;
+};
+
+exports.parseExpectCall = parseExpectCall;

package/lib/rules/utils/parseJestFnCall.js

@@ -0,0 +1,323 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getNodeChain = getNodeChain;
+exports.scopeHasLocalReference = exports.parseJestFnCall = exports.isTypeOfJestFnCall = void 0;
+
+var _utils = require("@typescript-eslint/utils");
+
+var _utils2 = require("../utils");
+
+const isTypeOfJestFnCall = (node, context, types) => {
+  const jestFnCall = parseJestFnCall(node, context);
+  return jestFnCall !== null && types.includes(jestFnCall.type);
+};
+
+exports.isTypeOfJestFnCall = isTypeOfJestFnCall;
+
+const joinChains = (a, b) => a && b ? [...a, ...b] : null;
+
+function getNodeChain(node) {
+  if ((0, _utils2.isSupportedAccessor)(node)) {
+    return [node];
+  }
+
+  switch (node.type) {
+    case _utils.AST_NODE_TYPES.TaggedTemplateExpression:
+      return getNodeChain(node.tag);
+
+    case _utils.AST_NODE_TYPES.MemberExpression:
+      return joinChains(getNodeChain(node.object), getNodeChain(node.property));
+
+    case _utils.AST_NODE_TYPES.CallExpression:
+      return getNodeChain(node.callee);
+  }
+
+  return null;
+}
+
+const determineJestFnType = name => {
+  // if (name === 'expect') {
+  //   return 'expect';
+  // }
+  if (name === 'jest') {
+    return 'jest';
+  }
+
+  if (_utils2.DescribeAlias.hasOwnProperty(name)) {
+    return 'describe';
+  }
+
+  if (_utils2.TestCaseName.hasOwnProperty(name)) {
+    return 'test';
+  }
+  /* istanbul ignore else */
+
+
+  if (_utils2.HookName.hasOwnProperty(name)) {
+    return 'hook';
+  }
+  /* istanbul ignore next */
+
+
+  return 'unknown';
+};
+
+const ValidJestFnCallChains = ['afterAll', 'afterEach', 'beforeAll', 'beforeEach', 'describe', 'describe.each', 'describe.only', 'describe.only.each', 'describe.skip', 'describe.skip.each', 'fdescribe', 'fdescribe.each', 'xdescribe', 'xdescribe.each', 'it', 'it.concurrent', 'it.concurrent.each', 'it.concurrent.only.each', 'it.concurrent.skip.each', 'it.each', 'it.failing', 'it.only', 'it.only.each', 'it.only.failing', 'it.skip', 'it.skip.each', 'it.skip.failing', 'it.todo', 'fit', 'fit.each', 'fit.failing', 'xit', 'xit.each', 'xit.failing', 'test', 'test.concurrent', 'test.concurrent.each', 'test.concurrent.only.each', 'test.concurrent.skip.each', 'test.each', 'test.failing', 'test.only', 'test.only.each', 'test.only.failing', 'test.skip', 'test.skip.each', 'test.skip.failing', 'test.todo', 'xtest', 'xtest.each', 'xtest.failing'];
+
+const resolvePossibleAliasedGlobal = (global, context) => {
+  var _context$settings$jes, _context$settings$jes2;
+
+  const globalAliases = (_context$settings$jes = (_context$settings$jes2 = context.settings.jest) === null || _context$settings$jes2 === void 0 ? void 0 : _context$settings$jes2.globalAliases) !== null && _context$settings$jes !== void 0 ? _context$settings$jes : {};
+  const alias = Object.entries(globalAliases).find(([, aliases]) => aliases.includes(global));
+
+  if (alias) {
+    return alias[0];
+  }
+
+  return null;
+};
+
+const parseJestFnCall = (node, context) => {
+  var _node$parent, _node$parent2, _resolved$original;
+
+  // ensure that we're at the "top" of the function call chain otherwise when
+  // parsing e.g. x().y.z(), we'll incorrectly find & parse "x()" even though
+  // the full chain is not a valid jest function call chain
+  if (((_node$parent = node.parent) === null || _node$parent === void 0 ? void 0 : _node$parent.type) === _utils.AST_NODE_TYPES.CallExpression || ((_node$parent2 = node.parent) === null || _node$parent2 === void 0 ? void 0 : _node$parent2.type) === _utils.AST_NODE_TYPES.MemberExpression) {
+    return null;
+  }
+
+  const chain = getNodeChain(node);
+
+  if (!(chain !== null && chain !== void 0 && chain.length)) {
+    return null;
+  } // check that every link in the chain except the last is a member expression
+
+
+  if (chain.slice(0, chain.length - 1).some(nod => {
+    var _nod$parent;
+
+    return ((_nod$parent = nod.parent) === null || _nod$parent === void 0 ? void 0 : _nod$parent.type) !== _utils.AST_NODE_TYPES.MemberExpression;
+  })) {
+    return null;
+  }
+
+  const [first, ...rest] = chain;
+  const lastLink = (0, _utils2.getAccessorValue)(chain[chain.length - 1]); // if we're an `each()`, ensure we're the outer CallExpression (i.e `.each()()`)
+
+  if (lastLink === 'each') {
+    if (node.callee.type !== _utils.AST_NODE_TYPES.CallExpression && node.callee.type !== _utils.AST_NODE_TYPES.TaggedTemplateExpression) {
+      return null;
+    }
+  }
+
+  if (node.callee.type === _utils.AST_NODE_TYPES.TaggedTemplateExpression && lastLink !== 'each') {
+    return null;
+  }
+
+  const resolved = resolveToJestFn(context, (0, _utils2.getAccessorValue)(first)); // we're not a jest function
+
+  if (!resolved) {
+    return null;
+  }
+
+  const name = (_resolved$original = resolved.original) !== null && _resolved$original !== void 0 ? _resolved$original : resolved.local;
+  const links = [name, ...rest.map(link => (0, _utils2.getAccessorValue)(link))];
+
+  if (name !== 'jest' && !ValidJestFnCallChains.includes(links.join('.'))) {
+    return null;
+  }
+
+  return {
+    name,
+    type: determineJestFnType(name),
+    head: { ...resolved,
+      node: first
+    },
+    members: rest
+  };
+};
+
+exports.parseJestFnCall = parseJestFnCall;
+
+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 null;
+  }
+
+  if (node.type === _utils.AST_NODE_TYPES.CallExpression && (0, _utils2.isIdentifier)(node.callee, 'require')) {
+    var _node$arguments$;
+
+    return (_node$arguments$ = node.arguments[0]) !== null && _node$arguments$ !== void 0 ? _node$arguments$ : null;
+  }
+
+  return null;
+};
+
+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 || !(0, _utils2.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 (!(0, _utils2.isSupportedAccessor)(def.name.parent.key)) {
+    return null;
+  }
+
+  return {
+    source: (0, _utils2.getStringValue)(sourceNode),
+    imported: (0, _utils2.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) {
+      if (ref.defs.length === 0) {
+        continue;
+      }
+
+      const def = ref.defs[ref.defs.length - 1];
+      const importDetails = describePossibleImportDef(def);
+
+      if (importDetails) {
+        imports.set(importDetails.local, importDetails);
+        continue;
+      }
+
+      locals.add(ref.name);
+    }
+
+    for (const ref of currentScope.through) {
+      unresolved.add(ref.identifier.name);
+    }
+
+    currentScope = currentScope.upper;
+  }
+
+  return {
+    locals,
+    imports,
+    unresolved
+  };
+};
+
+const resolveToJestFn = (context, identifier) => {
+  const references = collectReferences(context.getScope());
+  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 {
+        original: maybeImport.imported,
+        local: maybeImport.local,
+        type: 'import'
+      };
+    }
+
+    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 {
+    original: resolvePossibleAliasedGlobal(identifier, context),
+    local: identifier,
+    type: 'global'
+  };
+};
+
+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 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;

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

@@ -41,7 +41,9 @@ var _default = (0, _utils2.createRule)({
   create(context) {
     return {
       CallExpression(node) {
-        if (!(0, _utils2.isDescribeCall)(node)) {
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
+
+        if ((jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) !== 'describe') {
           return;
         }
 
@@ -77,7 +79,7 @@ var _default = (0, _utils2.createRule)({
           });
         }
 
-        if (!(0, _utils2.getNodeName)(node).endsWith('each') && callback.params.length) {
+        if (jestFnCall.members.every(s => (0, _utils2.getAccessorValue)(s) !== 'each') && callback.params.length) {
           context.report({
             messageId: 'unexpectedDescribeArgument',
             loc: paramsLocation(callback.params)

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

@@ -52,12 +52,14 @@ const findTopMostCallExpression = node => {
   return topMostCallExpression;
 };
 
-const isTestCaseCallWithCallbackArg = node => {
-  if (!(0, _utils2.isTestCaseCall)(node)) {
+const isTestCaseCallWithCallbackArg = (node, context) => {
+  const jestCallFn = (0, _utils2.parseJestFnCall)(node, context);
+
+  if ((jestCallFn === null || jestCallFn === void 0 ? void 0 : jestCallFn.type) !== 'test') {
     return false;
   }
 
-  const isJestEach = (0, _utils2.getNodeName)(node).endsWith('.each');
+  const isJestEach = jestCallFn.members.some(s => (0, _utils2.getAccessorValue)(s) === 'each');
 
   if (isJestEach && node.callee.type !== _utils.AST_NODE_TYPES.TaggedTemplateExpression) {
     // isJestEach but not a TaggedTemplateExpression, so this must be
@@ -67,13 +69,9 @@ const isTestCaseCallWithCallbackArg = node => {
     return true;
   }
 
-  if (isJestEach || node.arguments.length >= 2) {
-    const [, callback] = node.arguments;
-    const callbackArgIndex = Number(isJestEach);
-    return callback && (0, _utils2.isFunction)(callback) && callback.params.length === 1 + callbackArgIndex;
-  }
-
-  return false;
+  const [, callback] = node.arguments;
+  const callbackArgIndex = Number(isJestEach);
+  return callback && (0, _utils2.isFunction)(callback) && callback.params.length === 1 + callbackArgIndex;
 };
 
 const isPromiseMethodThatUsesValue = (node, identifier) => {
@@ -254,7 +252,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, context) => {
   let parent = node;
 
   while (parent) {
@@ -262,7 +260,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.isTypeOfJestFnCall)(parent, context, ['test']);
     }
 
     parent = parent.parent;
@@ -312,7 +310,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, context)) {
           inTestCaseWithDoneCallback = true;
           return;
         } // if this call expression is a promise chain, add it to the stack with
@@ -336,7 +334,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.isTypeOfJestFnCall)(node, context, ['test'])) {
             inTestCaseWithDoneCallback = false;
           }
 
@@ -363,7 +361,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, context)) {
           return;
         }