eslint-plugin-jest 26.7.0 → 26.8.7

package/README.md

@@ -1,6 +1,6 @@
 <div align="center">
   <a href="https://eslint.org/">
-    <img width="150" height="150" src="https://eslint.org/assets/images/logo/eslint-logo-color.svg">
+    <img height="150" src="https://eslint.org/assets/images/logo/eslint-logo-color.svg">
   </a>
   <a href="https://facebook.github.io/jest/">
     <img width="150" height="150" vspace="" hspace="25" src="https://jestjs.io/img/jest.png">
@@ -282,6 +282,14 @@ as it extends the original `unbound-method` rule from that plugin.
 
 ## Related Projects
 
+### eslint-plugin-jest-extended
+
+This is a sister plugin to `eslint-plugin-jest` that provides support for the
+matchers provided by
+[`jest-extended`](https://github.com/jest-community/jest-extended).
+
+https://github.com/jest-community/eslint-plugin-jest-extended
+
 ### eslint-plugin-jest-formatting
 
 This project aims to provide formatting rules (auto-fixable where possible) to

package/lib/rules/max-expects.js

@@ -41,7 +41,7 @@ var _default = (0, _utils2.createRule)({
   }]) {
     let count = 0;
 
-    const onFunctionExpressionEnter = node => {
+    const maybeResetCount = node => {
       var _node$parent;
 
       const isTestFn = ((_node$parent = node.parent) === null || _node$parent === void 0 ? void 0 : _node$parent.type) !== _utils.AST_NODE_TYPES.CallExpression || (0, _utils2.isTypeOfJestFnCall)(node.parent, context, ['test']);
@@ -52,11 +52,17 @@ var _default = (0, _utils2.createRule)({
     };
 
     return {
-      FunctionExpression: onFunctionExpressionEnter,
-      ArrowFunctionExpression: onFunctionExpressionEnter,
+      FunctionExpression: maybeResetCount,
+      'FunctionExpression:exit': maybeResetCount,
+      ArrowFunctionExpression: maybeResetCount,
+      'ArrowFunctionExpression:exit': maybeResetCount,
 
       CallExpression(node) {
-        if (!(0, _utils2.isExpectCall)(node)) {
+        var _jestFnCall$head$node;
+
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
+
+        if ((jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) !== 'expect' || ((_jestFnCall$head$node = jestFnCall.head.node.parent) === null || _jestFnCall$head$node === void 0 ? void 0 : _jestFnCall$head$node.type) === _utils.AST_NODE_TYPES.MemberExpression) {
           return;
         }
 

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

@@ -41,19 +41,16 @@ var _default = (0, _utils.createRule)({
     };
     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);
-
-        if (!matcher) {
-          return;
-        }
-
-        const alias = matcher.name;
+        } = jestFnCall;
+        const alias = (0, _utils.getAccessorValue)(matcher);
 
         if (alias in methodNames) {
           const canonical = methodNames[alias];
@@ -63,8 +60,8 @@ var _default = (0, _utils.createRule)({
               alias,
               canonical
             },
-            node: matcher.node.property,
-            fix: fixer => [(0, _utils.replaceAccessorFixer)(fixer, matcher.node.property, canonical)]
+            node: matcher,
+            fix: fixer => [(0, _utils.replaceAccessorFixer)(fixer, matcher, canonical)]
           });
         }
       }

package/lib/rules/no-conditional-expect.js

@@ -47,7 +47,13 @@ var _default = (0, _utils2.createRule)({
       },
 
       CallExpression(node) {
-        if ((0, _utils2.isTypeOfJestFnCall)(node, context, ['test'])) {
+        var _parseJestFnCall;
+
+        const {
+          type: jestFnCallType
+        } = (_parseJestFnCall = (0, _utils2.parseJestFnCall)(node, context)) !== null && _parseJestFnCall !== void 0 ? _parseJestFnCall : {};
+
+        if (jestFnCallType === 'test') {
           inTestCase = true;
         }
 
@@ -55,14 +61,14 @@ var _default = (0, _utils2.createRule)({
           inPromiseCatch = true;
         }
 
-        if (inTestCase && (0, _utils2.isExpectCall)(node) && conditionalDepth > 0) {
+        if (inTestCase && jestFnCallType === 'expect' && conditionalDepth > 0) {
           context.report({
             messageId: 'conditionalExpect',
             node
           });
         }
 
-        if (inPromiseCatch && (0, _utils2.isExpectCall)(node)) {
+        if (inPromiseCatch && jestFnCallType === 'expect') {
           context.report({
             messageId: 'conditionalExpect',
             node

package/lib/rules/no-interpolation-in-snapshots.js

@@ -28,23 +28,15 @@ var _default = (0, _utils2.createRule)({
   create(context) {
     return {
       CallExpression(node) {
-        if (!(0, _utils2.isExpectCall)(node)) {
-          return;
-        }
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
 
-        const {
-          matcher
-        } = (0, _utils2.parseExpectCall)(node);
-
-        if (!matcher) {
+        if ((jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) !== 'expect') {
           return;
         }
 
-        if (['toMatchInlineSnapshot', 'toThrowErrorMatchingInlineSnapshot'].includes(matcher.name)) {
-          var _matcher$arguments;
-
+        if (['toMatchInlineSnapshot', 'toThrowErrorMatchingInlineSnapshot'].includes((0, _utils2.getAccessorValue)(jestFnCall.matcher))) {
           // Check all since the optional 'propertyMatchers' argument might be present
-          (_matcher$arguments = matcher.arguments) === null || _matcher$arguments === void 0 ? void 0 : _matcher$arguments.forEach(argument => {
+          jestFnCall.args.forEach(argument => {
             if (argument.type === _utils.AST_NODE_TYPES.TemplateLiteral && argument.expressions.length > 0) {
               context.report({
                 messageId: 'noInterpolation',

package/lib/rules/no-large-snapshots.js

@@ -26,7 +26,7 @@ const reportOnViolation = (context, node, {
 
   let isAllowed = false;
 
-  if (node.type === _utils.AST_NODE_TYPES.ExpressionStatement && 'left' in node.expression && (0, _utils2.isExpectMember)(node.expression.left)) {
+  if (node.type === _utils.AST_NODE_TYPES.ExpressionStatement && 'left' in node.expression && node.expression.left.type === _utils.AST_NODE_TYPES.MemberExpression && (0, _utils2.isSupportedAccessor)(node.expression.left.property)) {
     const fileName = context.getFilename();
     const allowedSnapshotsInFile = allowedSnapshots[fileName];
 
@@ -100,24 +100,16 @@ var _default = (0, _utils2.createRule)({
 
     return {
       CallExpression(node) {
-        var _matcher$arguments;
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
 
-        if (!(0, _utils2.isExpectCall)(node)) {
+        if ((jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) !== 'expect') {
           return;
         }
 
-        const {
-          matcher
-        } = (0, _utils2.parseExpectCall)(node);
-
-        if ((matcher === null || matcher === void 0 ? void 0 : matcher.node.parent.type) !== _utils.AST_NODE_TYPES.CallExpression) {
-          return;
-        }
-
-        if (['toMatchInlineSnapshot', 'toThrowErrorMatchingInlineSnapshot'].includes(matcher.name) && (_matcher$arguments = matcher.arguments) !== null && _matcher$arguments !== void 0 && _matcher$arguments.length) {
+        if (['toMatchInlineSnapshot', 'toThrowErrorMatchingInlineSnapshot'].includes((0, _utils2.getAccessorValue)(jestFnCall.matcher)) && jestFnCall.args.length) {
           var _options$inlineMaxSiz;
 
-          reportOnViolation(context, matcher.arguments[0], { ...options,
+          reportOnViolation(context, jestFnCall.args[0], { ...options,
             maxSize: (_options$inlineMaxSiz = options.inlineMaxSize) !== null && _options$inlineMaxSiz !== void 0 ? _options$inlineMaxSiz : options.maxSize
           });
         }

package/lib/rules/no-restricted-matchers.js

@@ -30,65 +30,43 @@ var _default = (0, _utils.createRule)({
   defaultOptions: [{}],
 
   create(context, [restrictedChains]) {
-    const reportIfRestricted = (loc, chain) => {
-      if (!(chain in restrictedChains)) {
-        return false;
-      }
-
-      const message = restrictedChains[chain];
-      context.report({
-        messageId: message ? 'restrictedChainWithMessage' : 'restrictedChain',
-        data: {
-          message,
-          chain
-        },
-        loc
-      });
-      return true;
-    };
-
     return {
       CallExpression(node) {
-        if (!(0, _utils.isExpectCall)(node)) {
-          return;
-        }
+        const jestFnCall = (0, _utils.parseJestFnCall)(node, context);
 
-        const {
-          matcher,
-          modifier
-        } = (0, _utils.parseExpectCall)(node);
-
-        if (matcher && reportIfRestricted(matcher.node.property.loc, matcher.name)) {
+        if ((jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) !== 'expect') {
           return;
         }
 
-        if (modifier) {
-          if (reportIfRestricted(modifier.node.property.loc, modifier.name)) {
-            return;
-          }
+        const permutations = [jestFnCall.members];
 
-          if (modifier.negation) {
-            if (reportIfRestricted(modifier.negation.property.loc, 'not') || reportIfRestricted({
-              start: modifier.node.property.loc.start,
-              end: modifier.negation.property.loc.end
-            }, `${modifier.name}.not`)) {
-              return;
-            }
-          }
+        if (jestFnCall.members.length > 2) {
+          permutations.push([jestFnCall.members[0], jestFnCall.members[1]]);
+          permutations.push([jestFnCall.members[1], jestFnCall.members[2]]);
         }
 
-        if (matcher && modifier) {
-          let chain = modifier.name;
+        if (jestFnCall.members.length > 1) {
+          permutations.push(...jestFnCall.members.map(nod => [nod]));
+        }
 
-          if (modifier.negation) {
-            chain += '.not';
+        for (const permutation of permutations) {
+          const chain = permutation.map(nod => (0, _utils.getAccessorValue)(nod)).join('.');
+
+          if (chain in restrictedChains) {
+            const message = restrictedChains[chain];
+            context.report({
+              messageId: message ? 'restrictedChainWithMessage' : 'restrictedChain',
+              data: {
+                message,
+                chain
+              },
+              loc: {
+                start: permutation[0].loc.start,
+                end: permutation[permutation.length - 1].loc.end
+              }
+            });
+            break;
           }
-
-          chain += `.${matcher.name}`;
-          reportIfRestricted({
-            start: modifier.node.property.loc.start,
-            end: matcher.node.property.loc.end
-          }, chain);
         }
       }
 

package/lib/rules/no-standalone-expect.js

@@ -73,11 +73,17 @@ var _default = (0, _utils2.createRule)({
 
     const isCustomTestBlockFunction = node => additionalTestBlockFunctions.includes((0, _utils2.getNodeName)(node) || '');
 
-    const isTestBlock = node => (0, _utils2.isTypeOfJestFnCall)(node, context, ['test']) || isCustomTestBlockFunction(node);
-
     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') {
+          var _jestFnCall$head$node;
+
+          if (((_jestFnCall$head$node = jestFnCall.head.node.parent) === null || _jestFnCall$head$node === void 0 ? void 0 : _jestFnCall$head$node.type) === _utils.AST_NODE_TYPES.MemberExpression && jestFnCall.members.length === 1 && !['assertions', 'hasAssertions'].includes((0, _utils2.getAccessorValue)(jestFnCall.members[0]))) {
+            return;
+          }
+
           const parent = callStack[callStack.length - 1];
 
           if (!parent || parent === _utils2.DescribeAlias.describe) {
@@ -90,7 +96,7 @@ var _default = (0, _utils2.createRule)({
           return;
         }
 
-        if (isTestBlock(node)) {
+        if ((jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) === 'test' || isCustomTestBlockFunction(node)) {
           callStack.push('test');
         }
 
@@ -102,7 +108,7 @@ var _default = (0, _utils2.createRule)({
       'CallExpression:exit'(node) {
         const top = callStack[callStack.length - 1];
 
-        if (top === 'test' && isTestBlock(node) && node.callee.type !== _utils.AST_NODE_TYPES.MemberExpression || top === 'template' && node.callee.type === _utils.AST_NODE_TYPES.TaggedTemplateExpression) {
+        if (top === 'test' && ((0, _utils2.isTypeOfJestFnCall)(node, context, ['test']) || isCustomTestBlockFunction(node)) && node.callee.type !== _utils.AST_NODE_TYPES.MemberExpression || top === 'template' && node.callee.type === _utils.AST_NODE_TYPES.TaggedTemplateExpression) {
           callStack.pop();
         }
       },

package/lib/rules/prefer-called-with.js

@@ -26,26 +26,28 @@ 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 {
-          modifier,
-          matcher
-        } = (0, _utils.parseExpectCall)(node);
-
-        if (!matcher || (modifier === null || modifier === void 0 ? void 0 : modifier.name) === _utils.ModifierName.not || modifier !== null && modifier !== void 0 && modifier.negation) {
+        if (jestFnCall.modifiers.some(nod => (0, _utils.getAccessorValue)(nod) === 'not')) {
           return;
         }
 
-        if (['toBeCalled', 'toHaveBeenCalled'].includes(matcher.name)) {
+        const {
+          matcher
+        } = jestFnCall;
+        const matcherName = (0, _utils.getAccessorValue)(matcher);
+
+        if (['toBeCalled', 'toHaveBeenCalled'].includes(matcherName)) {
           context.report({
             data: {
-              matcherName: matcher.name
+              matcherName
             },
             messageId: 'preferCalledWith',
-            node: matcher.node.property
+            node: matcher
           });
         }
       }

package/lib/rules/prefer-comparison-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]));
-
 const isString = node => {
   return (0, _utils2.isStringNode)(node) || node.type === _utils.AST_NODE_TYPES.TemplateLiteral;
 };
@@ -91,27 +75,36 @@ 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);
+          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 (!matcher || (comparison === null || comparison === void 0 ? void 0 : comparison.type) !== _utils.AST_NODE_TYPES.BinaryExpression || isComparingToString(comparison) || !isBooleanEqualityMatcher(matcher)) {
+        if ((comparison === null || comparison === void 0 ? void 0 : comparison.type) !== _utils.AST_NODE_TYPES.BinaryExpression || isComparingToString(comparison) || !_utils2.EqualityMatcher.hasOwnProperty((0, _utils2.getAccessorValue)(matcher)) || !(0, _utils2.isBooleanLiteral)(matcherArg)) {
           return;
         }
 
-        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;
-        const preferredMatcher = determineMatcher(comparison.operator, (0, _utils2.followTypeAssertionChain)(matcher.arguments[0]).value === !!negation);
+        const [modifier] = jestFnCall.modifiers;
+        const hasNot = jestFnCall.modifiers.some(nod => (0, _utils2.getAccessorValue)(nod) === 'not');
+        const preferredMatcher = determineMatcher(comparison.operator, matcherArg.value === hasNot);
 
         if (!preferredMatcher) {
           return;
@@ -121,18 +114,18 @@ var _default = (0, _utils2.createRule)({
           fix(fixer) {
             const sourceCode = context.getSourceCode(); // preserve the existing modifier if it's not a negation
 
-            const modifierText = modifier && (modifier === null || modifier === void 0 ? void 0 : modifier.node) !== (negation === null || negation === void 0 ? void 0 : negation.node) ? `.${modifier.name}` : '';
+            const modifierText = modifier && (0, _utils2.getAccessorValue)(modifier) !== 'not' ? `.${(0, _utils2.getAccessorValue)(modifier)}` : '';
             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}.${preferredMatcher}`), // 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}.${preferredMatcher}`), // replace the matcher argument with the right-hand side of the comparison
+            fixer.replaceText(matcherArg, sourceCode.getText(comparison.right))];
           },
 
           messageId: 'useToBeComparison',
           data: {
             preferredMatcher
           },
-          node: matcher.node.property
+          node: matcher
         });
       }
 

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: matcher.node.property
+          node: matcher
         });
       }