eslint-plugin-jest 26.5.3 → 26.8.0

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/img/logo.svg">
+    <img width="150" 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">
@@ -201,6 +201,7 @@ installations requiring long-term consistency.
 | ---------------------------------------------------------------------------- | ------------------------------------------------------------------- | ---------------- | ------------ |
 | [consistent-test-it](docs/rules/consistent-test-it.md)                       | Have control over `test` and `it` usages                            |                  | ![fixable][] |
 | [expect-expect](docs/rules/expect-expect.md)                                 | Enforce assertion to be made in a test body                         | ![recommended][] |              |
+| [max-expects](docs/rules/max-expects.md)                                     | Enforces a maximum number assertion calls in a test body            |                  |              |
 | [max-nested-describe](docs/rules/max-nested-describe.md)                     | Enforces a maximum depth to nested describe calls                   |                  |              |
 | [no-alias-methods](docs/rules/no-alias-methods.md)                           | Disallow alias methods                                              | ![style][]       | ![fixable][] |
 | [no-commented-out-tests](docs/rules/no-commented-out-tests.md)               | Disallow commented out tests                                        | ![recommended][] |              |
@@ -231,6 +232,7 @@ installations requiring long-term consistency.
 | [prefer-hooks-in-order](docs/rules/prefer-hooks-in-order.md)                 | Prefer having hooks in a consistent order                           |                  |              |
 | [prefer-hooks-on-top](docs/rules/prefer-hooks-on-top.md)                     | Suggest having hooks before any test cases                          |                  |              |
 | [prefer-lowercase-title](docs/rules/prefer-lowercase-title.md)               | Enforce lowercase test names                                        |                  | ![fixable][] |
+| [prefer-mock-promise-shorthand](docs/rules/prefer-mock-promise-shorthand.md) | Prefer mock resolved/rejected shorthands for promises               |                  | ![fixable][] |
 | [prefer-snapshot-hint](docs/rules/prefer-snapshot-hint.md)                   | Prefer including a hint with external snapshots                     |                  |              |
 | [prefer-spy-on](docs/rules/prefer-spy-on.md)                                 | Suggest using `jest.spyOn()`                                        |                  | ![fixable][] |
 | [prefer-strict-equal](docs/rules/prefer-strict-equal.md)                     | Suggest using `toStrictEqual()`                                     |                  | ![suggest][] |
@@ -267,9 +269,9 @@ as it extends the original `unbound-method` rule from that plugin.
 
 <!-- begin type rules list -->
 
-| Rule                                           | Description                                                   | Configurations | Fixable |
-| ---------------------------------------------- | ------------------------------------------------------------- | -------------- | ------- |
-| [unbound-method](docs/rules/unbound-method.md) | Enforces unbound methods are called with their expected scope |                |         |
+| Rule                                           | Description                                                  | Configurations | Fixable |
+| ---------------------------------------------- | ------------------------------------------------------------ | -------------- | ------- |
+| [unbound-method](docs/rules/unbound-method.md) | Enforce unbound methods are called with their expected scope |                |         |
 
 <!-- end type rules list -->
 

package/docs/rules/max-expects.md

@@ -0,0 +1,74 @@
+# Enforces a maximum number assertion calls in a test body (`max-expects`)
+
+As more assertions are made, there is a possible tendency for the test to be
+more likely to mix multiple objectives. To avoid this, this rule reports when
+the maximum number of assertions is exceeded.
+
+## Rule Details
+
+This rule enforces a maximum number of `expect()` calls.
+
+The following patterns are considered warnings (with the default option of
+`{ "max": 5 } `):
+
+```js
+test('should not pass', () => {
+  expect(true).toBeDefined();
+  expect(true).toBeDefined();
+  expect(true).toBeDefined();
+  expect(true).toBeDefined();
+  expect(true).toBeDefined();
+  expect(true).toBeDefined();
+});
+
+it('should not pass', () => {
+  expect(true).toBeDefined();
+  expect(true).toBeDefined();
+  expect(true).toBeDefined();
+  expect(true).toBeDefined();
+  expect(true).toBeDefined();
+  expect(true).toBeDefined();
+});
+```
+
+The following patterns are **not** considered warnings (with the default option
+of `{ "max": 5 } `):
+
+```js
+test('shout pass');
+
+test('shout pass', () => {});
+
+test.skip('shout pass', () => {});
+
+test('should pass', function () {
+  expect(true).toBeDefined();
+});
+
+test('should pass', () => {
+  expect(true).toBeDefined();
+  expect(true).toBeDefined();
+  expect(true).toBeDefined();
+  expect(true).toBeDefined();
+  expect(true).toBeDefined();
+});
+```
+
+## Options
+
+```json
+{
+  "jest/max-expects": [
+    "error",
+    {
+      "max": 5
+    }
+  ]
+}
+```
+
+### `max`
+
+Enforces a maximum number of `expect()`.
+
+This has a default value of `5`.

package/docs/rules/prefer-hooks-in-order.md

@@ -130,4 +130,4 @@ describe('foo', () => {
 
 ## Further Reading
 
-- [Order of execution of describe and test blocks](https://jestjs.io/docs/setup-teardown#order-of-execution-of-describe-and-test-blocks)
+- [Order of Execution](https://jestjs.io/docs/setup-teardown#order-of-execution)

package/docs/rules/prefer-mock-promise-shorthand.md

@@ -0,0 +1,34 @@
+# Prefer mock resolved/rejected shorthands for promises (`prefer-mock-promise-shorthand`)
+
+When working with mocks of functions that return promises, Jest provides some
+API sugar functions to reduce the amount of boilerplate you have to write.
+
+These methods should be preferred when possible.
+
+## Rule Details
+
+The following patterns are warnings:
+
+```js
+jest.fn().mockImplementation(() => Promise.resolve(123));
+jest
+  .spyOn(fs.promises, 'readFile')
+  .mockReturnValue(Promise.reject(new Error('oh noes!')));
+
+myFunction
+  .mockReturnValueOnce(Promise.resolve(42))
+  .mockImplementationOnce(() => Promise.resolve(42))
+  .mockReturnValue(Promise.reject(new Error('too many calls!')));
+```
+
+The following patterns are not warnings:
+
+```js
+jest.fn().mockResolvedValue(123);
+jest.spyOn(fs.promises, 'readFile').mockRejectedValue(new Error('oh noes!'));
+
+myFunction
+  .mockResolvedValueOnce(42)
+  .mockResolvedValueOnce(42)
+  .mockRejectedValue(new Error('too many calls!'));
+```

package/docs/rules/unbound-method.md

@@ -1,4 +1,4 @@
-# Enforces unbound methods are called with their expected scope (`unbound-method`)
+# Enforce unbound methods are called with their expected scope (`unbound-method`)
 
 ## Rule Details
 

package/lib/rules/max-expects.js

@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _utils = require("@typescript-eslint/utils");
+
+var _utils2 = require("./utils");
+
+var _default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      category: 'Best Practices',
+      description: 'Enforces a maximum number assertion calls in a test body',
+      recommended: false
+    },
+    messages: {
+      exceededMaxAssertion: 'Too many assertion calls ({{ count }}). Maximum allowed is {{ max }}.'
+    },
+    type: 'suggestion',
+    schema: [{
+      type: 'object',
+      properties: {
+        max: {
+          type: 'integer',
+          minimum: 1
+        }
+      },
+      additionalProperties: false
+    }]
+  },
+  defaultOptions: [{
+    max: 5
+  }],
+
+  create(context, [{
+    max
+  }]) {
+    let count = 0;
+
+    const onFunctionExpressionEnter = 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']);
+
+      if (isTestFn) {
+        count = 0;
+      }
+    };
+
+    return {
+      FunctionExpression: onFunctionExpressionEnter,
+      ArrowFunctionExpression: onFunctionExpressionEnter,
+
+      CallExpression(node) {
+        if (!(0, _utils2.isTypeOfJestFnCall)(node, context, ['expect'])) {
+          return;
+        }
+
+        count += 1;
+
+        if (count > max) {
+          context.report({
+            node,
+            messageId: 'exceededMaxAssertion',
+            data: {
+              count,
+              max
+            }
+          });
+        }
+      }
+
+    };
+  }
+
+});
+
+exports.default = _default;

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,15 @@ 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)) {
+        var _parseJestFnCall;
+
+        const {
+          type: jestFnCallType
+        } = (_parseJestFnCall = (0, _utils2.parseJestFnCall)(node, context)) !== null && _parseJestFnCall !== void 0 ? _parseJestFnCall : {};
+
+        if (jestFnCallType === 'expect') {
           const parent = callStack[callStack.length - 1];
 
           if (!parent || parent === _utils2.DescribeAlias.describe) {
@@ -90,7 +94,7 @@ var _default = (0, _utils2.createRule)({
           return;
         }
 
-        if (isTestBlock(node)) {
+        if (jestFnCallType === 'test' || isCustomTestBlockFunction(node)) {
           callStack.push('test');
         }
 
@@ -102,7 +106,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

@@ -16,7 +16,7 @@ var _default = (0, _utils.createRule)({
       recommended: false
     },
     messages: {
-      preferCalledWith: 'Prefer {{name}}With(/* expected args */)'
+      preferCalledWith: 'Prefer {{ matcherName }}With(/* expected args */)'
     },
     type: 'suggestion',
     schema: []
@@ -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: {
-              name: 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: (negation || matcher).node.property
+          node: matcher
         });
       }