eslint-plugin-jest 26.4.1 → 26.4.4

package/lib/rules/no-alias-methods.js

@@ -64,7 +64,7 @@ var _default = (0, _utils.createRule)({
               canonical
             },
             node: matcher.node.property,
-            fix: fixer => [fixer.replaceText(matcher.node.property, canonical)]
+            fix: fixer => [(0, _utils.replaceAccessorFixer)(fixer, matcher.node.property, canonical)]
           });
         }
       }

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

@@ -7,8 +7,6 @@ exports.default = void 0;
 
 var _utils = require("@typescript-eslint/utils");
 
-var _detectJestVersion = require("./detectJestVersion");
-
 var _utils2 = require("./utils");
 
 const parseJestVersion = rawVersion => {
@@ -40,7 +38,7 @@ var _default = (0, _utils2.createRule)({
   create(context) {
     var _context$settings, _context$settings$jes;
 
-    const jestVersion = parseJestVersion(((_context$settings = context.settings) === null || _context$settings === void 0 ? void 0 : (_context$settings$jes = _context$settings.jest) === null || _context$settings$jes === void 0 ? void 0 : _context$settings$jes.version) || (0, _detectJestVersion.detectJestVersion)());
+    const jestVersion = parseJestVersion(((_context$settings = context.settings) === null || _context$settings === void 0 ? void 0 : (_context$settings$jes = _context$settings.jest) === null || _context$settings$jes === void 0 ? void 0 : _context$settings$jes.version) || (0, _utils2.detectJestVersion)());
     const deprecations = { ...(jestVersion >= 15 && {
         'jest.resetModuleRegistry': 'jest.resetModules'
       }),

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

@@ -32,13 +32,6 @@ var _default = (0, _utils.createRule)({
     let suiteDepth = 0;
     let testDepth = 0;
     return {
-      'CallExpression[callee.name=/^(it|test)$/][arguments.length<2]'(node) {
-        context.report({
-          messageId: 'missingFunction',
-          node
-        });
-      },
-
       CallExpression(node) {
         const jestFnCall = (0, _utils.parseJestFnCall)(node, context.getScope());
 
@@ -52,6 +45,13 @@ var _default = (0, _utils.createRule)({
 
         if (jestFnCall.type === 'test') {
           testDepth++;
+
+          if (node.arguments.length < 2) {
+            context.report({
+              messageId: 'missingFunction',
+              node
+            });
+          }
         }
 
         if ( // the only jest functions that are with "x" are "xdescribe", "xtest", and "xit"

package/lib/rules/no-if.js

@@ -9,7 +9,7 @@ var _utils = require("@typescript-eslint/utils");
 
 var _utils2 = require("./utils");
 
-const testCaseNames = new Set([...Object.keys(_utils2.TestCaseName), 'it.only', 'it.concurrent.only', 'it.skip', 'it.concurrent.skip', 'test.only', 'test.concurrent.only', 'test.skip', 'test.concurrent.skip', 'fit.concurrent']);
+const testCaseNames = new Set([...Object.keys(_utils2.TestCaseName), 'it.only', 'it.only', 'it.skip', 'it.skip', 'test.only', 'test.only', 'test.skip', 'test.skip', 'fit.concurrent']);
 
 const isTestFunctionExpression = node => node.parent !== undefined && node.parent.type === _utils.AST_NODE_TYPES.CallExpression && testCaseNames.has((0, _utils2.getNodeName)(node.parent.callee));
 

package/lib/rules/prefer-strict-equal.js

@@ -43,7 +43,7 @@ var _default = (0, _utils.createRule)({
             node: matcher.node.property,
             suggest: [{
               messageId: 'suggestReplaceWithStrictEqual',
-              fix: fixer => [fixer.replaceText(matcher.node.property, _utils.EqualityMatcher.toStrictEqual)]
+              fix: fixer => [(0, _utils.replaceAccessorFixer)(fixer, matcher.node.property, _utils.EqualityMatcher.toStrictEqual)]
             }]
           });
         }

package/lib/rules/prefer-to-be.js

@@ -44,7 +44,7 @@ const reportPreferToBe = (context, whatToBe, matcher, modifier) => {
     fix(fixer) {
       var _matcher$arguments;
 
-      const fixes = [fixer.replaceText(matcher.node.property, `toBe${whatToBe}`)];
+      const fixes = [(0, _utils2.replaceAccessorFixer)(fixer, matcher.node.property, `toBe${whatToBe}`)];
 
       if ((_matcher$arguments = matcher.arguments) !== null && _matcher$arguments !== void 0 && _matcher$arguments.length && whatToBe !== '') {
         fixes.push(fixer.remove(matcher.arguments[0]));

package/lib/rules/prefer-todo.js

@@ -18,13 +18,11 @@ function isEmptyFunction(node) {
 }
 
 function createTodoFixer(jestFnCall, fixer) {
-  const fixes = [fixer.replaceText(jestFnCall.head.node, `${jestFnCall.head.local}.todo`)];
-
   if (jestFnCall.members.length) {
-    fixes.unshift(fixer.removeRange([jestFnCall.head.node.range[1], jestFnCall.members[0].range[1]]));
+    return (0, _utils2.replaceAccessorFixer)(fixer, jestFnCall.members[0], 'todo');
   }
 
-  return fixes;
+  return fixer.replaceText(jestFnCall.head.node, `${jestFnCall.head.local}.todo`);
 }
 
 const isTargetedTestCase = jestFnCall => {
@@ -72,7 +70,7 @@ var _default = (0, _utils2.createRule)({
           context.report({
             messageId: 'emptyTest',
             node,
-            fix: fixer => [fixer.removeRange([title.range[1], callback.range[1]]), ...createTodoFixer(jestFnCall, fixer)]
+            fix: fixer => [fixer.removeRange([title.range[1], callback.range[1]]), createTodoFixer(jestFnCall, fixer)]
           });
         }
 

package/lib/rules/utils/accessors.js

@@ -0,0 +1,135 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isSupportedAccessor = exports.isStringNode = exports.isIdentifier = exports.getStringValue = exports.getAccessorValue = void 0;
+
+var _utils = require("@typescript-eslint/utils");
+
+/**
+ * Checks if the given `node` is a `StringLiteral`.
+ *
+ * If a `value` is provided & the `node` is a `StringLiteral`,
+ * the `value` will be compared to that of the `StringLiteral`.
+ *
+ * @param {Node} node
+ * @param {V} [value]
+ *
+ * @return {node is StringLiteral<V>}
+ *
+ * @template V
+ */
+const isStringLiteral = (node, value) => node.type === _utils.AST_NODE_TYPES.Literal && typeof node.value === 'string' && (value === undefined || node.value === value);
+
+/**
+ * Checks if the given `node` is a `TemplateLiteral`.
+ *
+ * Complex `TemplateLiteral`s are not considered specific, and so will return `false`.
+ *
+ * If a `value` is provided & the `node` is a `TemplateLiteral`,
+ * the `value` will be compared to that of the `TemplateLiteral`.
+ *
+ * @param {Node} node
+ * @param {V} [value]
+ *
+ * @return {node is TemplateLiteral<V>}
+ *
+ * @template V
+ */
+const isTemplateLiteral = (node, value) => node.type === _utils.AST_NODE_TYPES.TemplateLiteral && node.quasis.length === 1 && ( // bail out if not simple
+value === undefined || node.quasis[0].value.raw === value);
+
+/**
+ * Checks if the given `node` is a {@link StringNode}.
+ *
+ * @param {Node} node
+ * @param {V} [specifics]
+ *
+ * @return {node is StringNode}
+ *
+ * @template V
+ */
+const isStringNode = (node, specifics) => isStringLiteral(node, specifics) || isTemplateLiteral(node, specifics);
+/**
+ * Gets the value of the given `StringNode`.
+ *
+ * If the `node` is a `TemplateLiteral`, the `raw` value is used;
+ * otherwise, `value` is returned instead.
+ *
+ * @param {StringNode<S>} node
+ *
+ * @return {S}
+ *
+ * @template S
+ */
+
+
+exports.isStringNode = isStringNode;
+
+const getStringValue = node => isTemplateLiteral(node) ? node.quasis[0].value.raw : node.value;
+/**
+ * An `Identifier` with a known `name` value - i.e `expect`.
+ */
+
+
+exports.getStringValue = getStringValue;
+
+/**
+ * Checks if the given `node` is an `Identifier`.
+ *
+ * If a `name` is provided, & the `node` is an `Identifier`,
+ * the `name` will be compared to that of the `identifier`.
+ *
+ * @param {Node} node
+ * @param {V} [name]
+ *
+ * @return {node is KnownIdentifier<Name>}
+ *
+ * @template V
+ */
+const isIdentifier = (node, name) => node.type === _utils.AST_NODE_TYPES.Identifier && (name === undefined || node.name === name);
+/**
+ * Checks if the given `node` is a "supported accessor".
+ *
+ * This means that it's a node can be used to access properties,
+ * and who's "value" can be statically determined.
+ *
+ * `MemberExpression` nodes most commonly contain accessors,
+ * but it's possible for other nodes to contain them.
+ *
+ * If a `value` is provided & the `node` is an `AccessorNode`,
+ * the `value` will be compared to that of the `AccessorNode`.
+ *
+ * Note that `value` here refers to the normalised value.
+ * The property that holds the value is not always called `name`.
+ *
+ * @param {Node} node
+ * @param {V} [value]
+ *
+ * @return {node is AccessorNode<V>}
+ *
+ * @template V
+ */
+
+
+exports.isIdentifier = isIdentifier;
+
+const isSupportedAccessor = (node, value) => isIdentifier(node, value) || isStringNode(node, value);
+/**
+ * Gets the value of the given `AccessorNode`,
+ * account for the different node types.
+ *
+ * @param {AccessorNode<S>} accessor
+ *
+ * @return {S}
+ *
+ * @template S
+ */
+
+
+exports.isSupportedAccessor = isSupportedAccessor;
+
+const getAccessorValue = accessor => accessor.type === _utils.AST_NODE_TYPES.Identifier ? accessor.name : getStringValue(accessor);
+
+exports.getAccessorValue = getAccessorValue;

package/lib/rules/utils/followTypeAssertionChain.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.followTypeAssertionChain = void 0;
+
+var _utils = require("@typescript-eslint/utils");
+
+const isTypeCastExpression = node => node.type === _utils.AST_NODE_TYPES.TSAsExpression || node.type === _utils.AST_NODE_TYPES.TSTypeAssertion;
+
+const followTypeAssertionChain = expression => isTypeCastExpression(expression) ? followTypeAssertionChain(expression.expression) : expression;
+
+exports.followTypeAssertionChain = followTypeAssertionChain;

package/lib/rules/utils/index.js

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _accessors = require("./accessors");
+
+Object.keys(_accessors).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _accessors[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _accessors[key];
+    }
+  });
+});
+
+var _detectJestVersion = require("./detectJestVersion");
+
+Object.keys(_detectJestVersion).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _detectJestVersion[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _detectJestVersion[key];
+    }
+  });
+});
+
+var _followTypeAssertionChain = require("./followTypeAssertionChain");
+
+Object.keys(_followTypeAssertionChain).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _followTypeAssertionChain[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _followTypeAssertionChain[key];
+    }
+  });
+});
+
+var _misc = require("./misc");
+
+Object.keys(_misc).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _misc[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _misc[key];
+    }
+  });
+});
+
+var _parseJestFnCall = require("./parseJestFnCall");
+
+Object.keys(_parseJestFnCall).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _parseJestFnCall[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _parseJestFnCall[key];
+    }
+  });
+});
+
+var _parseExpectCall = require("./parseExpectCall");
+
+Object.keys(_parseExpectCall).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _parseExpectCall[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _parseExpectCall[key];
+    }
+  });
+});

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, scope) => {
+  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, scope, ['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

@@ -17,6 +17,8 @@ const isTypeOfJestFnCall = (node, scope, types) => {
 
 exports.isTypeOfJestFnCall = isTypeOfJestFnCall;
 
+const joinChains = (a, b) => a && b ? [...a, ...b] : null;
+
 function getNodeChain(node) {
   if ((0, _utils2.isSupportedAccessor)(node)) {
     return [node];
@@ -27,14 +29,13 @@ function getNodeChain(node) {
       return getNodeChain(node.tag);
 
     case _utils.AST_NODE_TYPES.MemberExpression:
-      return [...getNodeChain(node.object), ...getNodeChain(node.property)];
+      return joinChains(getNodeChain(node.object), getNodeChain(node.property));
 
-    case _utils.AST_NODE_TYPES.NewExpression:
     case _utils.AST_NODE_TYPES.CallExpression:
       return getNodeChain(node.callee);
   }
 
-  return [];
+  return null;
 }
 
 const determineJestFnType = name => {
@@ -64,8 +65,7 @@ const determineJestFnType = name => {
   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 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 parseJestFnCall = (node, scope) => {
   var _node$parent, _node$parent2, _resolved$original;
@@ -79,28 +79,32 @@ const parseJestFnCall = (node, scope) => {
 
   const chain = getNodeChain(node);
 
-  if (chain.length === 0) {
+  if (!(chain !== null && chain !== void 0 && chain.length)) {
     return null;
-  } // ensure that the only call expression in the chain is at the end
+  } // 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.CallExpression;
+    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 lastNode = chain[chain.length - 1]; // if we're an `each()`, ensure we're the outer CallExpression (i.e `.each()()`)
+  const lastLink = (0, _utils2.getAccessorValue)(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 (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(scope, (0, _utils2.getAccessorValue)(first)); // we're not a jest function
 
   if (!resolved) {

package/package.json

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

package/lib/rules/utils.js

@@ -1,432 +0,0 @@
-"use strict";
-
-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.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");
-
-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 => {
-  const ruleName = (0, _path.parse)(name).name;
-  return `${REPO_URL}/blob/v${_package.version}/docs/rules/${ruleName}.md`;
-});
-
-exports.createRule = createRule;
-
-const isTypeCastExpression = node => node.type === _utils.AST_NODE_TYPES.TSAsExpression || node.type === _utils.AST_NODE_TYPES.TSTypeAssertion;
-
-const followTypeAssertionChain = expression => isTypeCastExpression(expression) ? followTypeAssertionChain(expression.expression) : expression;
-/**
- * A `Literal` with a `value` of type `string`.
- */
-
-
-exports.followTypeAssertionChain = followTypeAssertionChain;
-
-/**
- * Checks if the given `node` is a `StringLiteral`.
- *
- * If a `value` is provided & the `node` is a `StringLiteral`,
- * the `value` will be compared to that of the `StringLiteral`.
- *
- * @param {Node} node
- * @param {V} [value]
- *
- * @return {node is StringLiteral<V>}
- *
- * @template V
- */
-const isStringLiteral = (node, value) => node.type === _utils.AST_NODE_TYPES.Literal && typeof node.value === 'string' && (value === undefined || node.value === value);
-
-/**
- * Checks if the given `node` is a `TemplateLiteral`.
- *
- * Complex `TemplateLiteral`s are not considered specific, and so will return `false`.
- *
- * If a `value` is provided & the `node` is a `TemplateLiteral`,
- * the `value` will be compared to that of the `TemplateLiteral`.
- *
- * @param {Node} node
- * @param {V} [value]
- *
- * @return {node is TemplateLiteral<V>}
- *
- * @template V
- */
-const isTemplateLiteral = (node, value) => node.type === _utils.AST_NODE_TYPES.TemplateLiteral && node.quasis.length === 1 && ( // bail out if not simple
-value === undefined || node.quasis[0].value.raw === value);
-
-/**
- * Checks if the given `node` is a {@link StringNode}.
- *
- * @param {Node} node
- * @param {V} [specifics]
- *
- * @return {node is StringNode}
- *
- * @template V
- */
-const isStringNode = (node, specifics) => isStringLiteral(node, specifics) || isTemplateLiteral(node, specifics);
-/**
- * Gets the value of the given `StringNode`.
- *
- * If the `node` is a `TemplateLiteral`, the `raw` value is used;
- * otherwise, `value` is returned instead.
- *
- * @param {StringNode<S>} node
- *
- * @return {S}
- *
- * @template S
- */
-
-
-exports.isStringNode = isStringNode;
-
-const getStringValue = node => isTemplateLiteral(node) ? node.quasis[0].value.raw : node.value;
-/**
- * Represents a `MemberExpression` with a "known" `property`.
- */
-
-
-exports.getStringValue = getStringValue;
-
-/**
- * Guards that the given `call` has only one `argument`.
- *
- * @param {CallExpression} call
- *
- * @return {call is CallExpressionWithSingleArgument}
- */
-const hasOnlyOneArgument = call => call.arguments.length === 1;
-/**
- * An `Identifier` with a known `name` value - i.e `expect`.
- */
-
-
-exports.hasOnlyOneArgument = hasOnlyOneArgument;
-
-/**
- * Checks if the given `node` is an `Identifier`.
- *
- * If a `name` is provided, & the `node` is an `Identifier`,
- * the `name` will be compared to that of the `identifier`.
- *
- * @param {Node} node
- * @param {V} [name]
- *
- * @return {node is KnownIdentifier<Name>}
- *
- * @template V
- */
-const isIdentifier = (node, name) => node.type === _utils.AST_NODE_TYPES.Identifier && (name === undefined || node.name === name);
-/**
- * Checks if the given `node` is a "supported accessor".
- *
- * This means that it's a node can be used to access properties,
- * and who's "value" can be statically determined.
- *
- * `MemberExpression` nodes most commonly contain accessors,
- * but it's possible for other nodes to contain them.
- *
- * If a `value` is provided & the `node` is an `AccessorNode`,
- * the `value` will be compared to that of the `AccessorNode`.
- *
- * Note that `value` here refers to the normalised value.
- * The property that holds the value is not always called `name`.
- *
- * @param {Node} node
- * @param {V} [value]
- *
- * @return {node is AccessorNode<V>}
- *
- * @template V
- */
-
-
-exports.isIdentifier = isIdentifier;
-
-const isSupportedAccessor = (node, value) => isIdentifier(node, value) || isStringNode(node, value);
-/**
- * Gets the value of the given `AccessorNode`,
- * account for the different node types.
- *
- * @param {AccessorNode<S>} accessor
- *
- * @return {S}
- *
- * @template S
- */
-
-
-exports.isSupportedAccessor = isSupportedAccessor;
-
-const getAccessorValue = accessor => accessor.type === _utils.AST_NODE_TYPES.Identifier ? accessor.name : getStringValue(accessor);
-
-exports.getAccessorValue = getAccessorValue;
-
-/**
- * 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 && isSupportedAccessor(node.callee, 'expect') && node.parent !== undefined;
-
-exports.isExpectCall = isExpectCall;
-
-const isExpectMember = (node, name) => node.type === _utils.AST_NODE_TYPES.MemberExpression && 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: 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;
-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 = {}));
-
-let DescribeProperty;
-exports.DescribeProperty = DescribeProperty;
-
-(function (DescribeProperty) {
-  DescribeProperty["each"] = "each";
-  DescribeProperty["only"] = "only";
-  DescribeProperty["skip"] = "skip";
-})(DescribeProperty || (exports.DescribeProperty = DescribeProperty = {}));
-
-let TestCaseProperty;
-exports.TestCaseProperty = TestCaseProperty;
-
-(function (TestCaseProperty) {
-  TestCaseProperty["each"] = "each";
-  TestCaseProperty["concurrent"] = "concurrent";
-  TestCaseProperty["only"] = "only";
-  TestCaseProperty["skip"] = "skip";
-  TestCaseProperty["todo"] = "todo";
-})(TestCaseProperty || (exports.TestCaseProperty = TestCaseProperty = {}));
-
-const joinNames = (a, b) => a && b ? `${a}.${b}` : null;
-
-function getNodeName(node) {
-  if (isSupportedAccessor(node)) {
-    return 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, scope) => {
-  return declaredVariables.reduce((acc, {
-    references
-  }) => acc.concat(references.map(({
-    identifier
-  }) => identifier.parent).filter(node => !!node && node.type === _utils.AST_NODE_TYPES.CallExpression && (0, _parseJestFnCall.isTypeOfJestFnCall)(node, scope, ['test']))), []);
-};
-
-exports.getTestCallExpressionsFromDeclaredVariables = getTestCallExpressionsFromDeclaredVariables;