eslint-plugin-jest 26.2.2 → 26.4.1

package/lib/rules/utils/parseJestFnCall.js

@@ -0,0 +1,306 @@
+"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, scope, types) => {
+  const jestFnCall = parseJestFnCall(node, scope);
+  return jestFnCall !== null && types.includes(jestFnCall.type);
+};
+
+exports.isTypeOfJestFnCall = isTypeOfJestFnCall;
+
+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 [...getNodeChain(node.object), ...getNodeChain(node.property)];
+
+    case _utils.AST_NODE_TYPES.NewExpression:
+    case _utils.AST_NODE_TYPES.CallExpression:
+      return getNodeChain(node.callee);
+  }
+
+  return [];
+}
+
+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', // todo: check if actually valid (not in docs)
+'test.concurrent.skip', 'test.concurrent.only', 'it.concurrent.skip', 'it.concurrent.only'];
+
+const parseJestFnCall = (node, scope) => {
+  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.length === 0) {
+    return null;
+  } // ensure that the only call expression in the chain is at the end
+
+
+  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.CallExpression;
+  })) {
+    return null;
+  }
+
+  const [first, ...rest] = chain;
+  const lastNode = chain[chain.length - 1]; // if we're an `each()`, ensure we're the outer CallExpression (i.e `.each()()`)
+
+  if ((0, _utils2.isSupportedAccessor)(lastNode, 'each')) {
+    if (node.callee.type !== _utils.AST_NODE_TYPES.CallExpression && node.callee.type !== _utils.AST_NODE_TYPES.TaggedTemplateExpression) {
+      return null;
+    }
+  }
+
+  const resolved = resolveToJestFn(scope, (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 = (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 {
+        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: null,
+    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/utils.js

@@ -3,9 +3,33 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+var _exportNames = {
+  createRule: true,
+  followTypeAssertionChain: true,
+  isStringNode: true,
+  getStringValue: true,
+  hasOnlyOneArgument: true,
+  isIdentifier: true,
+  isSupportedAccessor: true,
+  getAccessorValue: true,
+  isExpectCall: true,
+  isExpectMember: true,
+  ModifierName: true,
+  EqualityMatcher: true,
+  isParsedEqualityMatcherCall: true,
+  parseExpectCall: true,
+  DescribeAlias: true,
+  TestCaseName: true,
+  HookName: true,
+  DescribeProperty: true,
+  TestCaseProperty: true,
+  getNodeName: true,
+  isFunction: true,
+  getTestCallExpressionsFromDeclaredVariables: true
+};
 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.isHookCall = exports.isFunction = exports.isExpectMember = exports.isExpectCall = exports.isDescribeCall = exports.hasOnlyOneArgument = exports.getTestCallExpressionsFromDeclaredVariables = exports.getStringValue = void 0;
+exports.parseExpectCall = exports.isSupportedAccessor = exports.isStringNode = exports.isParsedEqualityMatcherCall = exports.isIdentifier = exports.isFunction = exports.isExpectMember = exports.isExpectCall = exports.hasOnlyOneArgument = exports.getTestCallExpressionsFromDeclaredVariables = exports.getStringValue = void 0;
 
 var _path = require("path");
 
@@ -13,6 +37,19 @@ var _utils = require("@typescript-eslint/utils");
 
 var _package = require("../../package.json");
 
+var _parseJestFnCall = require("./utils/parseJestFnCall");
+
+Object.keys(_parseJestFnCall).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _parseJestFnCall[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _parseJestFnCall[key];
+    }
+  });
+});
 const REPO_URL = 'https://github.com/jest-community/eslint-plugin-jest';
 
 const createRule = _utils.ESLintUtils.RuleCreator(name => {
@@ -384,261 +421,12 @@ const isFunction = node => node.type === _utils.AST_NODE_TYPES.FunctionExpressio
 
 exports.isFunction = isFunction;
 
-const isHookCall = (node, scope) => {
-  let name = findFirstCallPropertyName(node, []);
-
-  if (!name) {
-    return false;
-  }
-
-  name = resolveToJestFn(scope, name);
-  return name !== null && HookName.hasOwnProperty(name);
-};
-
-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, scope))), []);
-};
-/**
- * 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.
- */
-
-
-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 && 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 null;
-    }
-
-    const nod = callee.object.type === _utils.AST_NODE_TYPES.MemberExpression ? callee.object.object : callee.object;
-
-    if (isSupportedAccessor(nod)) {
-      return getAccessorValue(nod);
-    }
-  }
-
-  return null;
-};
-/**
- * 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.
- */
-
-
-const isDescribeCall = (node, scope) => {
-  let name = findFirstCallPropertyName(node, Object.keys(DescribeProperty));
-
-  if (!name) {
-    return false;
-  }
-
-  name = resolveToJestFn(scope, name);
-  return name !== null && DescribeAlias.hasOwnProperty(name);
-};
-
-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 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 null;
+  }) => identifier.parent).filter(node => !!node && node.type === _utils.AST_NODE_TYPES.CallExpression && (0, _parseJestFnCall.isTypeOfJestFnCall)(node, scope, ['test']))), []);
 };
 
-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) {
-      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 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;
-
-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;
-};
+exports.getTestCallExpressionsFromDeclaredVariables = getTestCallExpressionsFromDeclaredVariables;

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, context.getScope())) {
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context.getScope());
+
+        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

@@ -53,11 +53,13 @@ const findTopMostCallExpression = node => {
 };
 
 const isTestCaseCallWithCallbackArg = (node, scope) => {
-  if (!(0, _utils2.isTestCaseCall)(node, scope)) {
+  const jestCallFn = (0, _utils2.parseJestFnCall)(node, scope);
+
+  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, scope) => {
     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) => {
@@ -262,7 +260,7 @@ const isDirectlyWithinTestCaseCall = (node, scope) => {
       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, scope));
+      return ((_parent = parent) === null || _parent === void 0 ? void 0 : _parent.type) === _utils.AST_NODE_TYPES.CallExpression && (0, _utils2.isTypeOfJestFnCall)(parent, scope, ['test']);
     }
 
     parent = parent.parent;
@@ -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, context.getScope())) {
+          if ((0, _utils2.isTypeOfJestFnCall)(node, context.getScope(), ['test'])) {
             inTestCaseWithDoneCallback = false;
           }