eslint-plugin-jest 26.5.3 → 26.8.0

package/lib/rules/prefer-equality-matcher.js

@@ -9,22 +9,6 @@ var _utils = require("@typescript-eslint/utils");
 
 var _utils2 = require("./utils");
 
-const isBooleanLiteral = node => node.type === _utils.AST_NODE_TYPES.Literal && typeof node.value === 'boolean';
-
-/**
- * Checks if the given `ParsedExpectMatcher` is a call to one of the equality matchers,
- * with a boolean literal as the sole argument.
- *
- * @example javascript
- * toBe(true);
- * toEqual(false);
- *
- * @param {ParsedExpectMatcher} matcher
- *
- * @return {matcher is ParsedBooleanEqualityMatcher}
- */
-const isBooleanEqualityMatcher = matcher => (0, _utils2.isParsedEqualityMatcherCall)(matcher) && isBooleanLiteral((0, _utils2.followTypeAssertionChain)(matcher.arguments[0]));
-
 var _default = (0, _utils2.createRule)({
   name: __filename,
   meta: {
@@ -47,35 +31,44 @@ var _default = (0, _utils2.createRule)({
   create(context) {
     return {
       CallExpression(node) {
-        if (!(0, _utils2.isExpectCall)(node)) {
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
+
+        if ((jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) !== 'expect' || jestFnCall.args.length === 0) {
           return;
         }
 
         const {
-          expect: {
-            arguments: [comparison],
-            range: [, expectCallEnd]
-          },
-          matcher,
-          modifier
-        } = (0, _utils2.parseExpectCall)(node);
-
-        if (!matcher || (comparison === null || comparison === void 0 ? void 0 : comparison.type) !== _utils.AST_NODE_TYPES.BinaryExpression || comparison.operator !== '===' && comparison.operator !== '!==' || !isBooleanEqualityMatcher(matcher)) {
+          parent: expect
+        } = jestFnCall.head.node;
+
+        if ((expect === null || expect === void 0 ? void 0 : expect.type) !== _utils.AST_NODE_TYPES.CallExpression) {
+          return;
+        }
+
+        const {
+          arguments: [comparison],
+          range: [, expectCallEnd]
+        } = expect;
+        const {
+          matcher
+        } = jestFnCall;
+        const matcherArg = (0, _utils2.getFirstMatcherArg)(jestFnCall);
+
+        if ((comparison === null || comparison === void 0 ? void 0 : comparison.type) !== _utils.AST_NODE_TYPES.BinaryExpression || comparison.operator !== '===' && comparison.operator !== '!==' || !_utils2.EqualityMatcher.hasOwnProperty((0, _utils2.getAccessorValue)(matcher)) || !(0, _utils2.isBooleanLiteral)(matcherArg)) {
           return;
         }
 
-        const matcherValue = (0, _utils2.followTypeAssertionChain)(matcher.arguments[0]).value;
-        const negation = modifier !== null && modifier !== void 0 && modifier.negation ? {
-          node: modifier.negation
-        } : (modifier === null || modifier === void 0 ? void 0 : modifier.name) === _utils2.ModifierName.not ? modifier : null; // we need to negate the expectation if the current expected
+        const matcherValue = matcherArg.value;
+        const [modifier] = jestFnCall.modifiers;
+        const hasNot = jestFnCall.modifiers.some(nod => (0, _utils2.getAccessorValue)(nod) === 'not'); // we need to negate the expectation if the current expected
         // value is itself negated by the "not" modifier
 
-        const addNotModifier = (comparison.operator === '!==' ? !matcherValue : matcherValue) === !!negation;
+        const addNotModifier = (comparison.operator === '!==' ? !matcherValue : matcherValue) === hasNot;
 
         const buildFixer = equalityMatcher => fixer => {
           const sourceCode = context.getSourceCode(); // preserve the existing modifier if it's not a negation
 
-          let modifierText = modifier && (modifier === null || modifier === void 0 ? void 0 : modifier.node) !== (negation === null || negation === void 0 ? void 0 : negation.node) ? `.${modifier.name}` : '';
+          let modifierText = modifier && (0, _utils2.getAccessorValue)(modifier) !== 'not' ? `.${(0, _utils2.getAccessorValue)(modifier)}` : '';
 
           if (addNotModifier) {
             modifierText += `.${_utils2.ModifierName.not}`;
@@ -83,8 +76,8 @@ var _default = (0, _utils2.createRule)({
 
           return [// replace the comparison argument with the left-hand side of the comparison
           fixer.replaceText(comparison, sourceCode.getText(comparison.left)), // replace the current matcher & modifier with the preferred matcher
-          fixer.replaceTextRange([expectCallEnd, matcher.node.range[1]], `${modifierText}.${equalityMatcher}`), // replace the matcher argument with the right-hand side of the comparison
-          fixer.replaceText(matcher.arguments[0], sourceCode.getText(comparison.right))];
+          fixer.replaceTextRange([expectCallEnd, matcher.parent.range[1]], `${modifierText}.${equalityMatcher}`), // replace the matcher argument with the right-hand side of the comparison
+          fixer.replaceText(matcherArg, sourceCode.getText(comparison.right))];
         };
 
         context.report({
@@ -96,7 +89,7 @@ var _default = (0, _utils2.createRule)({
             },
             fix: buildFixer(equalityMatcher)
           })),
-          node: (negation || matcher).node.property
+          node: matcher
         });
       }
 

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

@@ -116,12 +116,14 @@ var _default = (0, _utils2.createRule)({
       'ForOfStatement:exit': exitForLoop,
 
       CallExpression(node) {
-        if ((0, _utils2.isTypeOfJestFnCall)(node, context, ['test'])) {
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
+
+        if ((jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) === 'test') {
           inTestCaseCall = true;
           return;
         }
 
-        if ((0, _utils2.isExpectCall)(node) && inTestCaseCall) {
+        if ((jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) === 'expect' && inTestCaseCall) {
           if (inForLoop) {
             hasExpectInLoop = true;
           }

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

@@ -27,15 +27,29 @@ var _default = (0, _utils2.createRule)({
   defaultOptions: [],
   create: context => ({
     CallExpression(node) {
-      const [awaitNode] = node.arguments;
+      const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
 
-      if ((0, _utils2.isExpectCall)(node) && (awaitNode === null || awaitNode === void 0 ? void 0 : awaitNode.type) === _utils.AST_NODE_TYPES.AwaitExpression) {
+      if ((jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) !== 'expect') {
+        return;
+      }
+
+      const {
+        parent
+      } = jestFnCall.head.node;
+
+      if ((parent === null || parent === void 0 ? void 0 : parent.type) !== _utils.AST_NODE_TYPES.CallExpression) {
+        return;
+      }
+
+      const [awaitNode] = parent.arguments;
+
+      if ((awaitNode === null || awaitNode === void 0 ? void 0 : awaitNode.type) === _utils.AST_NODE_TYPES.AwaitExpression) {
         context.report({
-          node: node.arguments[0],
+          node: awaitNode,
           messageId: 'expectResolves',
 
           fix(fixer) {
-            return [fixer.insertTextBefore(node, 'await '), fixer.removeRange([awaitNode.range[0], awaitNode.argument.range[0]]), fixer.insertTextAfter(node, '.resolves')];
+            return [fixer.insertTextBefore(parent, 'await '), fixer.removeRange([awaitNode.range[0], awaitNode.argument.range[0]]), fixer.insertTextAfter(parent, '.resolves')];
           }
 
         });

package/lib/rules/prefer-mock-promise-shorthand.js

@@ -0,0 +1,111 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _utils = require("@typescript-eslint/utils");
+
+var _utils2 = require("./utils");
+
+const withOnce = (name, addOnce) => {
+  return `${name}${addOnce ? 'Once' : ''}`;
+};
+
+const findSingleReturnArgumentNode = fnNode => {
+  var _fnNode$body$body$;
+
+  if (fnNode.body.type !== _utils.AST_NODE_TYPES.BlockStatement) {
+    return fnNode.body;
+  }
+
+  if (((_fnNode$body$body$ = fnNode.body.body[0]) === null || _fnNode$body$body$ === void 0 ? void 0 : _fnNode$body$body$.type) === _utils.AST_NODE_TYPES.ReturnStatement) {
+    return fnNode.body.body[0].argument;
+  }
+
+  return null;
+};
+
+var _default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      category: 'Best Practices',
+      description: 'Prefer mock resolved/rejected shorthands for promises',
+      recommended: false
+    },
+    messages: {
+      useMockShorthand: 'Prefer {{ replacement }}'
+    },
+    schema: [],
+    type: 'suggestion',
+    fixable: 'code'
+  },
+  defaultOptions: [],
+
+  create(context) {
+    const report = (property, isOnce, outerArgNode, innerArgNode = outerArgNode) => {
+      if ((innerArgNode === null || innerArgNode === void 0 ? void 0 : innerArgNode.type) !== _utils.AST_NODE_TYPES.CallExpression) {
+        return;
+      }
+
+      const argName = (0, _utils2.getNodeName)(innerArgNode);
+
+      if (argName !== 'Promise.resolve' && argName !== 'Promise.reject') {
+        return;
+      }
+
+      const replacement = withOnce(argName.endsWith('reject') ? 'mockRejectedValue' : 'mockResolvedValue', isOnce);
+      context.report({
+        node: property,
+        messageId: 'useMockShorthand',
+        data: {
+          replacement
+        },
+
+        fix(fixer) {
+          const sourceCode = context.getSourceCode(); // there shouldn't be more than one argument, but if there is don't try
+          // fixing since we have no idea what to do with the extra arguments
+
+          if (innerArgNode.arguments.length > 1) {
+            return null;
+          }
+
+          return [fixer.replaceText(property, replacement), fixer.replaceText(outerArgNode, // the value argument for both Promise methods is optional,
+          // whereas for Jest they're required so use an explicit undefined
+          // if no argument is being passed to the call we're replacing
+          innerArgNode.arguments.length === 1 ? sourceCode.getText(innerArgNode.arguments[0]) : 'undefined')];
+        }
+
+      });
+    };
+
+    return {
+      CallExpression(node) {
+        if (node.callee.type !== _utils.AST_NODE_TYPES.MemberExpression || !(0, _utils2.isSupportedAccessor)(node.callee.property) || node.arguments.length === 0) {
+          return;
+        }
+
+        const mockFnName = (0, _utils2.getAccessorValue)(node.callee.property);
+        const isOnce = mockFnName.endsWith('Once');
+
+        if (mockFnName === withOnce('mockReturnValue', isOnce)) {
+          report(node.callee.property, isOnce, node.arguments[0]);
+        } else if (mockFnName === withOnce('mockImplementation', isOnce)) {
+          const [arg] = node.arguments;
+
+          if (!(0, _utils2.isFunction)(arg)) {
+            return;
+          }
+
+          report(node.callee.property, isOnce, arg, findSingleReturnArgumentNode(arg));
+        }
+      }
+
+    };
+  }
+
+});
+
+exports.default = _default;

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

@@ -8,28 +8,25 @@ exports.default = void 0;
 var _utils = require("./utils");
 
 const snapshotMatchers = ['toMatchSnapshot', 'toThrowErrorMatchingSnapshot'];
+const snapshotMatcherNames = snapshotMatchers;
 
-const isSnapshotMatcher = matcher => {
-  return snapshotMatchers.includes(matcher.name);
-};
-
-const isSnapshotMatcherWithoutHint = matcher => {
-  if (!matcher.arguments || matcher.arguments.length === 0) {
+const isSnapshotMatcherWithoutHint = expectFnCall => {
+  if (expectFnCall.args.length === 0) {
     return true;
   } // this matcher only supports one argument which is the hint
 
 
-  if (matcher.name !== 'toMatchSnapshot') {
-    return matcher.arguments.length !== 1;
+  if (!(0, _utils.isSupportedAccessor)(expectFnCall.matcher, 'toMatchSnapshot')) {
+    return expectFnCall.args.length !== 1;
   } // if we're being passed two arguments,
   // the second one should be the hint
 
 
-  if (matcher.arguments.length === 2) {
+  if (expectFnCall.args.length === 2) {
     return false;
   }
 
-  const [arg] = matcher.arguments; // the first argument to `toMatchSnapshot` can be _either_ a snapshot hint or
+  const [arg] = expectFnCall.args; // the first argument to `toMatchSnapshot` can be _either_ a snapshot hint or
   // an object with asymmetric matchers, so we can't just assume that the first
   // argument is a hint when it's by itself.
 
@@ -67,7 +64,7 @@ var _default = (0, _utils.createRule)({
         if (isSnapshotMatcherWithoutHint(snapshotMatcher)) {
           context.report({
             messageId: 'missingHint',
-            node: snapshotMatcher.node.property
+            node: snapshotMatcher.matcher
           });
         }
       }
@@ -115,24 +112,24 @@ var _default = (0, _utils.createRule)({
       },
 
       CallExpression(node) {
-        if ((0, _utils.isTypeOfJestFnCall)(node, context, ['describe', 'test'])) {
-          depths.push(expressionDepth);
-          expressionDepth = 0;
-        }
+        const jestFnCall = (0, _utils.parseJestFnCall)(node, context);
+
+        if ((jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) !== 'expect') {
+          if ((jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) === 'describe' || (jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) === 'test') {
+            depths.push(expressionDepth);
+            expressionDepth = 0;
+          }
 
-        if (!(0, _utils.isExpectCall)(node)) {
           return;
         }
 
-        const {
-          matcher
-        } = (0, _utils.parseExpectCall)(node);
+        const matcherName = (0, _utils.getAccessorValue)(jestFnCall.matcher);
 
-        if (!matcher || !isSnapshotMatcher(matcher)) {
+        if (!snapshotMatcherNames.includes(matcherName)) {
           return;
         }
 
-        snapshotMatchers.push(matcher);
+        snapshotMatchers.push(jestFnCall);
       }
 
     };

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

@@ -29,21 +29,23 @@ var _default = (0, _utils.createRule)({
   create(context) {
     return {
       CallExpression(node) {
-        if (!(0, _utils.isExpectCall)(node)) {
+        const jestFnCall = (0, _utils.parseJestFnCall)(node, context);
+
+        if ((jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) !== 'expect') {
           return;
         }
 
         const {
           matcher
-        } = (0, _utils.parseExpectCall)(node);
+        } = jestFnCall;
 
-        if (matcher && (0, _utils.isParsedEqualityMatcherCall)(matcher, _utils.EqualityMatcher.toEqual)) {
+        if ((0, _utils.isSupportedAccessor)(matcher, 'toEqual')) {
           context.report({
             messageId: 'useToStrictEqual',
-            node: matcher.node.property,
+            node: matcher,
             suggest: [{
               messageId: 'suggestReplaceWithStrictEqual',
-              fix: fixer => [(0, _utils.replaceAccessorFixer)(fixer, matcher.node.property, _utils.EqualityMatcher.toStrictEqual)]
+              fix: fixer => [(0, _utils.replaceAccessorFixer)(fixer, matcher, _utils.EqualityMatcher.toStrictEqual)]
             }]
           });
         }

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

@@ -16,12 +16,12 @@ const isNullLiteral = node => node.type === _utils.AST_NODE_TYPES.Literal && nod
  */
 
 
-const isNullEqualityMatcher = matcher => isNullLiteral(getFirstArgument(matcher));
+const isNullEqualityMatcher = expectFnCall => isNullLiteral((0, _utils2.getFirstMatcherArg)(expectFnCall));
 
-const isFirstArgumentIdentifier = (matcher, name) => (0, _utils2.isIdentifier)(getFirstArgument(matcher), name);
+const isFirstArgumentIdentifier = (expectFnCall, name) => (0, _utils2.isIdentifier)((0, _utils2.getFirstMatcherArg)(expectFnCall), name);
 
-const shouldUseToBe = matcher => {
-  const firstArg = getFirstArgument(matcher);
+const shouldUseToBe = expectFnCall => {
+  const firstArg = (0, _utils2.getFirstMatcherArg)(expectFnCall);
 
   if (firstArg.type === _utils.AST_NODE_TYPES.Literal) {
     // regex literals are classed as literals, but they're actually objects
@@ -32,32 +32,27 @@ const shouldUseToBe = matcher => {
   return firstArg.type === _utils.AST_NODE_TYPES.TemplateLiteral;
 };
 
-const getFirstArgument = matcher => {
-  return (0, _utils2.followTypeAssertionChain)(matcher.arguments[0]);
-};
-
-const reportPreferToBe = (context, whatToBe, matcher, modifier) => {
-  const modifierNode = (modifier === null || modifier === void 0 ? void 0 : modifier.negation) || (modifier === null || modifier === void 0 ? void 0 : modifier.name) === _utils2.ModifierName.not && (modifier === null || modifier === void 0 ? void 0 : modifier.node);
+const reportPreferToBe = (context, whatToBe, expectFnCall, modifierNode) => {
   context.report({
     messageId: `useToBe${whatToBe}`,
 
     fix(fixer) {
-      var _matcher$arguments;
+      var _expectFnCall$args;
 
-      const fixes = [(0, _utils2.replaceAccessorFixer)(fixer, matcher.node.property, `toBe${whatToBe}`)];
+      const fixes = [(0, _utils2.replaceAccessorFixer)(fixer, expectFnCall.matcher, `toBe${whatToBe}`)];
 
-      if ((_matcher$arguments = matcher.arguments) !== null && _matcher$arguments !== void 0 && _matcher$arguments.length && whatToBe !== '') {
-        fixes.push(fixer.remove(matcher.arguments[0]));
+      if ((_expectFnCall$args = expectFnCall.args) !== null && _expectFnCall$args !== void 0 && _expectFnCall$args.length && whatToBe !== '') {
+        fixes.push(fixer.remove(expectFnCall.args[0]));
       }
 
       if (modifierNode) {
-        fixes.push(fixer.removeRange([modifierNode.property.range[0] - 1, modifierNode.property.range[1]]));
+        fixes.push(fixer.removeRange([modifierNode.range[0] - 1, modifierNode.range[1]]));
       }
 
       return fixes;
     },
 
-    node: matcher.node.property
+    node: expectFnCall.matcher
   });
 };
 
@@ -85,46 +80,42 @@ var _default = (0, _utils2.createRule)({
   create(context) {
     return {
       CallExpression(node) {
-        if (!(0, _utils2.isExpectCall)(node)) {
-          return;
-        }
-
-        const {
-          matcher,
-          modifier
-        } = (0, _utils2.parseExpectCall)(node);
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
 
-        if (!matcher) {
+        if ((jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) !== 'expect') {
           return;
         }
 
-        if (((modifier === null || modifier === void 0 ? void 0 : modifier.name) === _utils2.ModifierName.not || modifier !== null && modifier !== void 0 && modifier.negation) && ['toBeUndefined', 'toBeDefined'].includes(matcher.name)) {
-          reportPreferToBe(context, matcher.name === 'toBeDefined' ? 'Undefined' : 'Defined', matcher, modifier);
+        const matcherName = (0, _utils2.getAccessorValue)(jestFnCall.matcher);
+        const notModifier = jestFnCall.modifiers.find(nod => (0, _utils2.getAccessorValue)(nod) === 'not');
+
+        if (notModifier && ['toBeUndefined', 'toBeDefined'].includes(matcherName)) {
+          reportPreferToBe(context, matcherName === 'toBeDefined' ? 'Undefined' : 'Defined', jestFnCall, notModifier);
           return;
         }
 
-        if (!(0, _utils2.isParsedEqualityMatcherCall)(matcher)) {
+        if (!_utils2.EqualityMatcher.hasOwnProperty(matcherName) || jestFnCall.args.length === 0) {
           return;
         }
 
-        if (isNullEqualityMatcher(matcher)) {
-          reportPreferToBe(context, 'Null', matcher);
+        if (isNullEqualityMatcher(jestFnCall)) {
+          reportPreferToBe(context, 'Null', jestFnCall);
           return;
         }
 
-        if (isFirstArgumentIdentifier(matcher, 'undefined')) {
-          const name = (modifier === null || modifier === void 0 ? void 0 : modifier.name) === _utils2.ModifierName.not || modifier !== null && modifier !== void 0 && modifier.negation ? 'Defined' : 'Undefined';
-          reportPreferToBe(context, name, matcher, modifier);
+        if (isFirstArgumentIdentifier(jestFnCall, 'undefined')) {
+          const name = notModifier ? 'Defined' : 'Undefined';
+          reportPreferToBe(context, name, jestFnCall, notModifier);
           return;
         }
 
-        if (isFirstArgumentIdentifier(matcher, 'NaN')) {
-          reportPreferToBe(context, 'NaN', matcher);
+        if (isFirstArgumentIdentifier(jestFnCall, 'NaN')) {
+          reportPreferToBe(context, 'NaN', jestFnCall);
           return;
         }
 
-        if (shouldUseToBe(matcher) && matcher.name !== _utils2.EqualityMatcher.toBe) {
-          reportPreferToBe(context, '', matcher);
+        if (shouldUseToBe(jestFnCall) && matcherName !== _utils2.EqualityMatcher.toBe) {
+          reportPreferToBe(context, '', jestFnCall);
         }
       }
 

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

@@ -9,22 +9,6 @@ var _utils = require("@typescript-eslint/utils");
 
 var _utils2 = require("./utils");
 
-const isBooleanLiteral = node => node.type === _utils.AST_NODE_TYPES.Literal && typeof node.value === 'boolean';
-
-/**
- * Checks if the given `ParsedExpectMatcher` is a call to one of the equality matchers,
- * with a boolean literal as the sole argument.
- *
- * @example javascript
- * toBe(true);
- * toEqual(false);
- *
- * @param {ParsedExpectMatcher} matcher
- *
- * @return {matcher is ParsedBooleanEqualityMatcher}
- */
-const isBooleanEqualityMatcher = matcher => (0, _utils2.isParsedEqualityMatcherCall)(matcher) && isBooleanLiteral((0, _utils2.followTypeAssertionChain)(matcher.arguments[0]));
-
 /**
  * Checks if the given `node` is a `CallExpression` representing the calling
  * of an `includes`-like method that can be 'fixed' (using `toContain`).
@@ -33,7 +17,7 @@ const isBooleanEqualityMatcher = matcher => (0, _utils2.isParsedEqualityMatcherC
  *
  * @return {node is FixableIncludesCallExpression}
  */
-const isFixableIncludesCallExpression = node => node.type === _utils.AST_NODE_TYPES.CallExpression && node.callee.type === _utils.AST_NODE_TYPES.MemberExpression && (0, _utils2.isSupportedAccessor)(node.callee.property, 'includes') && (0, _utils2.hasOnlyOneArgument)(node); // expect(array.includes(<value>)[not.]{toBe,toEqual}(<boolean>)
+const isFixableIncludesCallExpression = node => node.type === _utils.AST_NODE_TYPES.CallExpression && node.callee.type === _utils.AST_NODE_TYPES.MemberExpression && (0, _utils2.isSupportedAccessor)(node.callee.property, 'includes') && (0, _utils2.hasOnlyOneArgument)(node) && node.arguments[0].type !== _utils.AST_NODE_TYPES.SpreadElement; // expect(array.includes(<value>)[not.]{toBe,toEqual}(<boolean>)
 
 
 var _default = (0, _utils2.createRule)({
@@ -56,37 +40,48 @@ var _default = (0, _utils2.createRule)({
   create(context) {
     return {
       CallExpression(node) {
-        if (!(0, _utils2.isExpectCall)(node)) {
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
+
+        if ((jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) !== 'expect' || jestFnCall.args.length === 0) {
           return;
         }
 
         const {
-          expect: {
-            arguments: [includesCall],
-            range: [, expectCallEnd]
-          },
-          matcher,
-          modifier
-        } = (0, _utils2.parseExpectCall)(node);
+          parent: expect
+        } = jestFnCall.head.node;
+
+        if ((expect === null || expect === void 0 ? void 0 : expect.type) !== _utils.AST_NODE_TYPES.CallExpression) {
+          return;
+        }
+
+        const {
+          arguments: [includesCall],
+          range: [, expectCallEnd]
+        } = expect;
+        const {
+          matcher
+        } = jestFnCall;
+        const matcherArg = (0, _utils2.getFirstMatcherArg)(jestFnCall);
 
-        if (!matcher || !includesCall || modifier && modifier.name !== _utils2.ModifierName.not || !isBooleanEqualityMatcher(matcher) || !isFixableIncludesCallExpression(includesCall)) {
+        if (!includesCall || matcherArg.type === _utils.AST_NODE_TYPES.SpreadElement || !_utils2.EqualityMatcher.hasOwnProperty((0, _utils2.getAccessorValue)(matcher)) || !(0, _utils2.isBooleanLiteral)(matcherArg) || !isFixableIncludesCallExpression(includesCall)) {
           return;
         }
 
+        const hasNot = jestFnCall.modifiers.some(nod => (0, _utils2.getAccessorValue)(nod) === 'not');
         context.report({
           fix(fixer) {
             const sourceCode = context.getSourceCode(); // we need to negate the expectation if the current expected
             // value is itself negated by the "not" modifier
 
-            const addNotModifier = (0, _utils2.followTypeAssertionChain)(matcher.arguments[0]).value === !!modifier;
+            const addNotModifier = matcherArg.value === hasNot;
             return [// remove the "includes" call entirely
             fixer.removeRange([includesCall.callee.property.range[0] - 1, includesCall.range[1]]), // replace the current matcher with "toContain", adding "not" if needed
-            fixer.replaceTextRange([expectCallEnd, matcher.node.range[1]], addNotModifier ? `.${_utils2.ModifierName.not}.toContain` : '.toContain'), // replace the matcher argument with the value from the "includes"
-            fixer.replaceText(matcher.arguments[0], sourceCode.getText(includesCall.arguments[0]))];
+            fixer.replaceTextRange([expectCallEnd, matcher.parent.range[1]], addNotModifier ? `.${_utils2.ModifierName.not}.toContain` : '.toContain'), // replace the matcher argument with the value from the "includes"
+            fixer.replaceText(jestFnCall.args[0], sourceCode.getText(includesCall.arguments[0]))];
           },
 
           messageId: 'useToContain',
-          node: (modifier || matcher).node.property
+          node: matcher
         });
       }
 

package/lib/rules/prefer-to-have-length.js

@@ -29,18 +29,26 @@ var _default = (0, _utils2.createRule)({
   create(context) {
     return {
       CallExpression(node) {
-        if (!(0, _utils2.isExpectCall)(node)) {
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
+
+        if ((jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) !== 'expect') {
           return;
         }
 
         const {
-          expect: {
-            arguments: [argument]
-          },
+          parent: expect
+        } = jestFnCall.head.node;
+
+        if ((expect === null || expect === void 0 ? void 0 : expect.type) !== _utils.AST_NODE_TYPES.CallExpression) {
+          return;
+        }
+
+        const [argument] = expect.arguments;
+        const {
           matcher
-        } = (0, _utils2.parseExpectCall)(node);
+        } = jestFnCall;
 
-        if (!matcher || !(0, _utils2.isParsedEqualityMatcherCall)(matcher) || (argument === null || argument === void 0 ? void 0 : argument.type) !== _utils.AST_NODE_TYPES.MemberExpression || !(0, _utils2.isSupportedAccessor)(argument.property, 'length')) {
+        if (!_utils2.EqualityMatcher.hasOwnProperty((0, _utils2.getAccessorValue)(matcher)) || (argument === null || argument === void 0 ? void 0 : argument.type) !== _utils.AST_NODE_TYPES.MemberExpression || !(0, _utils2.isSupportedAccessor)(argument.property, 'length')) {
           return;
         }
 
@@ -48,11 +56,11 @@ var _default = (0, _utils2.createRule)({
           fix(fixer) {
             return [// remove the "length" property accessor
             fixer.removeRange([argument.property.range[0] - 1, argument.range[1]]), // replace the current matcher with "toHaveLength"
-            fixer.replaceTextRange([matcher.node.object.range[1], matcher.node.range[1]], '.toHaveLength')];
+            fixer.replaceTextRange([matcher.parent.object.range[1], matcher.parent.range[1]], '.toHaveLength')];
           },
 
           messageId: 'useToHaveLength',
-          node: matcher.node.property
+          node: matcher
         });
       }