eslint-plugin-jest 25.5.0 → 26.1.0-next.1

package/lib/rules/no-export.js

@@ -5,11 +5,11 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _experimentalUtils = require("@typescript-eslint/experimental-utils");
+var _utils = require("@typescript-eslint/utils");
 
-var _utils = require("./utils");
+var _utils2 = require("./utils");
 
-var _default = (0, _utils.createRule)({
+var _default = (0, _utils2.createRule)({
   name: __filename,
   meta: {
     docs: {
@@ -41,7 +41,7 @@ var _default = (0, _utils.createRule)({
       },
 
       CallExpression(node) {
-        if ((0, _utils.isTestCaseCall)(node)) {
+        if ((0, _utils2.isTestCaseCall)(node)) {
           hasTestCase = true;
         }
       },
@@ -56,14 +56,14 @@ var _default = (0, _utils.createRule)({
           property
         } = node;
 
-        if (object.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression) {
+        if (object.type === _utils.AST_NODE_TYPES.MemberExpression) {
           ({
             object,
             property
           } = object);
         }
 
-        if ('name' in object && object.name === 'module' && property.type === _experimentalUtils.AST_NODE_TYPES.Identifier && /^exports?$/u.test(property.name)) {
+        if ('name' in object && object.name === 'module' && property.type === _utils.AST_NODE_TYPES.Identifier && /^exports?$/u.test(property.name)) {
           exportNodes.push(node);
         }
       }

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

@@ -5,21 +5,21 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _experimentalUtils = require("@typescript-eslint/experimental-utils");
+var _utils = require("@typescript-eslint/utils");
 
-var _utils = require("./utils");
+var _utils2 = require("./utils");
 
 const findOnlyNode = node => {
-  const callee = node.callee.type === _experimentalUtils.AST_NODE_TYPES.TaggedTemplateExpression ? node.callee.tag : node.callee.type === _experimentalUtils.AST_NODE_TYPES.CallExpression ? node.callee.callee : node.callee;
+  const callee = node.callee.type === _utils.AST_NODE_TYPES.TaggedTemplateExpression ? node.callee.tag : node.callee.type === _utils.AST_NODE_TYPES.CallExpression ? node.callee.callee : node.callee;
 
-  if (callee.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression) {
-    if (callee.object.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression) {
-      if ((0, _utils.isSupportedAccessor)(callee.object.property, 'only')) {
+  if (callee.type === _utils.AST_NODE_TYPES.MemberExpression) {
+    if (callee.object.type === _utils.AST_NODE_TYPES.MemberExpression) {
+      if ((0, _utils2.isSupportedAccessor)(callee.object.property, 'only')) {
         return callee.object.property;
       }
     }
 
-    if ((0, _utils.isSupportedAccessor)(callee.property, 'only')) {
+    if ((0, _utils2.isSupportedAccessor)(callee.property, 'only')) {
       return callee.property;
     }
   }
@@ -27,7 +27,7 @@ const findOnlyNode = node => {
   return null;
 };
 
-var _default = (0, _utils.createRule)({
+var _default = (0, _utils2.createRule)({
   name: __filename,
   meta: {
     docs: {
@@ -47,11 +47,11 @@ var _default = (0, _utils.createRule)({
   defaultOptions: [],
   create: context => ({
     CallExpression(node) {
-      if (!(0, _utils.isDescribeCall)(node) && !(0, _utils.isTestCaseCall)(node)) {
+      if (!(0, _utils2.isDescribeCall)(node) && !(0, _utils2.isTestCaseCall)(node)) {
         return;
       }
 
-      if ((0, _utils.getNodeName)(node).startsWith('f')) {
+      if ((0, _utils2.getNodeName)(node).startsWith('f')) {
         context.report({
           messageId: 'focusedTest',
           node,
@@ -74,7 +74,7 @@ var _default = (0, _utils.createRule)({
         node: onlyNode,
         suggest: [{
           messageId: 'suggestRemoveFocus',
-          fix: fixer => fixer.removeRange([onlyNode.range[0] - 1, onlyNode.range[1] + Number(onlyNode.type !== _experimentalUtils.AST_NODE_TYPES.Identifier)])
+          fix: fixer => fixer.removeRange([onlyNode.range[0] - 1, onlyNode.range[1] + Number(onlyNode.type !== _utils.AST_NODE_TYPES.Identifier)])
         }]
       });
     }

package/lib/rules/no-if.js

@@ -5,21 +5,21 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _experimentalUtils = require("@typescript-eslint/experimental-utils");
+var _utils = require("@typescript-eslint/utils");
 
-var _utils = require("./utils");
+var _utils2 = require("./utils");
 
-const testCaseNames = new Set([...Object.keys(_utils.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.concurrent.only', 'it.skip', 'it.concurrent.skip', 'test.only', 'test.concurrent.only', 'test.skip', 'test.concurrent.skip', 'fit.concurrent']);
 
-const isTestFunctionExpression = node => node.parent !== undefined && node.parent.type === _experimentalUtils.AST_NODE_TYPES.CallExpression && testCaseNames.has((0, _utils.getNodeName)(node.parent.callee));
+const isTestFunctionExpression = node => node.parent !== undefined && node.parent.type === _utils.AST_NODE_TYPES.CallExpression && testCaseNames.has((0, _utils2.getNodeName)(node.parent.callee));
 
 const conditionName = {
-  [_experimentalUtils.AST_NODE_TYPES.ConditionalExpression]: 'conditional',
-  [_experimentalUtils.AST_NODE_TYPES.SwitchStatement]: 'switch',
-  [_experimentalUtils.AST_NODE_TYPES.IfStatement]: 'if'
+  [_utils.AST_NODE_TYPES.ConditionalExpression]: 'conditional',
+  [_utils.AST_NODE_TYPES.SwitchStatement]: 'switch',
+  [_utils.AST_NODE_TYPES.IfStatement]: 'if'
 };
 
-var _default = (0, _utils.createRule)({
+var _default = (0, _utils2.createRule)({
   name: __filename,
   meta: {
     docs: {
@@ -56,10 +56,10 @@ var _default = (0, _utils.createRule)({
 
     return {
       CallExpression(node) {
-        if ((0, _utils.isTestCaseCall)(node)) {
+        if ((0, _utils2.isTestCaseCall)(node)) {
           stack.push(true);
 
-          if ((0, _utils.getNodeName)(node).endsWith('each')) {
+          if ((0, _utils2.getNodeName)(node).endsWith('each')) {
             stack.push(true);
           }
         }
@@ -71,7 +71,7 @@ var _default = (0, _utils.createRule)({
 
       FunctionDeclaration(node) {
         const declaredVariables = context.getDeclaredVariables(node);
-        const testCallExpressions = (0, _utils.getTestCallExpressionsFromDeclaredVariables)(declaredVariables);
+        const testCallExpressions = (0, _utils2.getTestCallExpressionsFromDeclaredVariables)(declaredVariables);
         stack.push(testCallExpressions.length > 0);
       },
 

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

@@ -5,11 +5,11 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _experimentalUtils = require("@typescript-eslint/experimental-utils");
+var _utils = require("@typescript-eslint/utils");
 
-var _utils = require("./utils");
+var _utils2 = require("./utils");
 
-var _default = (0, _utils.createRule)({
+var _default = (0, _utils2.createRule)({
   name: __filename,
   meta: {
     docs: {
@@ -28,13 +28,13 @@ var _default = (0, _utils.createRule)({
   create(context) {
     return {
       CallExpression(node) {
-        if (!(0, _utils.isExpectCall)(node)) {
+        if (!(0, _utils2.isExpectCall)(node)) {
           return;
         }
 
         const {
           matcher
-        } = (0, _utils.parseExpectCall)(node);
+        } = (0, _utils2.parseExpectCall)(node);
 
         if (!matcher) {
           return;
@@ -45,7 +45,7 @@ var _default = (0, _utils.createRule)({
 
           // 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 => {
-            if (argument.type === _experimentalUtils.AST_NODE_TYPES.TemplateLiteral && argument.expressions.length > 0) {
+            if (argument.type === _utils.AST_NODE_TYPES.TemplateLiteral && argument.expressions.length > 0) {
               context.report({
                 messageId: 'noInterpolation',
                 node: argument

package/lib/rules/no-jasmine-globals.js

@@ -5,11 +5,11 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _experimentalUtils = require("@typescript-eslint/experimental-utils");
+var _utils = require("@typescript-eslint/utils");
 
-var _utils = require("./utils");
+var _utils2 = require("./utils");
 
-var _default = (0, _utils.createRule)({
+var _default = (0, _utils2.createRule)({
   name: __filename,
   meta: {
     docs: {
@@ -36,14 +36,14 @@ var _default = (0, _utils.createRule)({
         const {
           callee
         } = node;
-        const calleeName = (0, _utils.getNodeName)(callee);
+        const calleeName = (0, _utils2.getNodeName)(callee);
 
         if (!calleeName) {
           return;
         }
 
         if (calleeName === 'spyOn' || calleeName === 'spyOnProperty' || calleeName === 'fail' || calleeName === 'pending') {
-          if ((0, _utils.scopeHasLocalReference)(context.getScope(), calleeName)) {
+          if ((0, _utils2.scopeHasLocalReference)(context.getScope(), calleeName)) {
             // It's a local variable, not a jasmine global.
             return;
           }
@@ -79,7 +79,7 @@ var _default = (0, _utils.createRule)({
           return;
         }
 
-        if (callee.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && calleeName.startsWith('jasmine.')) {
+        if (callee.type === _utils.AST_NODE_TYPES.MemberExpression && calleeName.startsWith('jasmine.')) {
           const functionName = calleeName.replace('jasmine.', '');
 
           if (functionName === 'any' || functionName === 'anything' || functionName === 'arrayContaining' || functionName === 'objectContaining' || functionName === 'stringMatching') {
@@ -127,19 +127,19 @@ var _default = (0, _utils.createRule)({
       },
 
       MemberExpression(node) {
-        if ((0, _utils.isSupportedAccessor)(node.object, 'jasmine')) {
+        if ((0, _utils2.isSupportedAccessor)(node.object, 'jasmine')) {
           const {
             parent,
             property
           } = node;
 
-          if (parent && parent.type === _experimentalUtils.AST_NODE_TYPES.AssignmentExpression) {
-            if ((0, _utils.isSupportedAccessor)(property, 'DEFAULT_TIMEOUT_INTERVAL')) {
+          if (parent && parent.type === _utils.AST_NODE_TYPES.AssignmentExpression) {
+            if ((0, _utils2.isSupportedAccessor)(property, 'DEFAULT_TIMEOUT_INTERVAL')) {
               const {
                 right
               } = parent;
 
-              if (right.type === _experimentalUtils.AST_NODE_TYPES.Literal) {
+              if (right.type === _utils.AST_NODE_TYPES.Literal) {
                 context.report({
                   fix: fixer => [fixer.replaceText(parent, `jest.setTimeout(${right.value})`)],
                   node,

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

@@ -7,9 +7,9 @@ exports.default = void 0;
 
 var _path = require("path");
 
-var _experimentalUtils = require("@typescript-eslint/experimental-utils");
+var _utils = require("@typescript-eslint/utils");
 
-var _utils = require("./utils");
+var _utils2 = require("./utils");
 
 const reportOnViolation = (context, node, {
   maxSize: lineLimit = 50,
@@ -26,12 +26,12 @@ const reportOnViolation = (context, node, {
 
   let isAllowed = false;
 
-  if (node.type === _experimentalUtils.AST_NODE_TYPES.ExpressionStatement && 'left' in node.expression && (0, _utils.isExpectMember)(node.expression.left)) {
+  if (node.type === _utils.AST_NODE_TYPES.ExpressionStatement && 'left' in node.expression && (0, _utils2.isExpectMember)(node.expression.left)) {
     const fileName = context.getFilename();
     const allowedSnapshotsInFile = allowedSnapshots[fileName];
 
     if (allowedSnapshotsInFile) {
-      const snapshotName = (0, _utils.getAccessorValue)(node.expression.left.property);
+      const snapshotName = (0, _utils2.getAccessorValue)(node.expression.left.property);
       isAllowed = allowedSnapshotsInFile.some(name => {
         if (name instanceof RegExp) {
           return name.test(snapshotName);
@@ -54,7 +54,7 @@ const reportOnViolation = (context, node, {
   }
 };
 
-var _default = (0, _utils.createRule)({
+var _default = (0, _utils2.createRule)({
   name: __filename,
   meta: {
     docs: {
@@ -102,15 +102,15 @@ var _default = (0, _utils.createRule)({
       CallExpression(node) {
         var _matcher$arguments;
 
-        if (!(0, _utils.isExpectCall)(node)) {
+        if (!(0, _utils2.isExpectCall)(node)) {
           return;
         }
 
         const {
           matcher
-        } = (0, _utils.parseExpectCall)(node);
+        } = (0, _utils2.parseExpectCall)(node);
 
-        if ((matcher === null || matcher === void 0 ? void 0 : matcher.node.parent.type) !== _experimentalUtils.AST_NODE_TYPES.CallExpression) {
+        if ((matcher === null || matcher === void 0 ? void 0 : matcher.node.parent.type) !== _utils.AST_NODE_TYPES.CallExpression) {
           return;
         }
 

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

@@ -5,9 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _experimentalUtils = require("@typescript-eslint/experimental-utils");
+var _utils = require("@typescript-eslint/utils");
 
-var _utils = require("./utils");
+var _utils2 = require("./utils");
 
 const getBlockType = statement => {
   const func = statement.parent;
@@ -18,19 +18,19 @@ const getBlockType = statement => {
   } // functionDeclaration: function func() {}
 
 
-  if (func.type === _experimentalUtils.AST_NODE_TYPES.FunctionDeclaration) {
+  if (func.type === _utils.AST_NODE_TYPES.FunctionDeclaration) {
     return 'function';
   }
 
-  if ((0, _utils.isFunction)(func) && func.parent) {
+  if ((0, _utils2.isFunction)(func) && func.parent) {
     const expr = func.parent; // arrow function or function expr
 
-    if (expr.type === _experimentalUtils.AST_NODE_TYPES.VariableDeclarator) {
+    if (expr.type === _utils.AST_NODE_TYPES.VariableDeclarator) {
       return 'function';
     } // if it's not a variable, it will be callExpr, we only care about describe
 
 
-    if (expr.type === _experimentalUtils.AST_NODE_TYPES.CallExpression && (0, _utils.isDescribeCall)(expr)) {
+    if (expr.type === _utils.AST_NODE_TYPES.CallExpression && (0, _utils2.isDescribeCall)(expr)) {
       return 'describe';
     }
   }
@@ -38,7 +38,7 @@ const getBlockType = statement => {
   return null;
 };
 
-var _default = (0, _utils.createRule)({
+var _default = (0, _utils2.createRule)({
   name: __filename,
   meta: {
     docs: {
@@ -71,16 +71,16 @@ var _default = (0, _utils.createRule)({
   }]) {
     const callStack = [];
 
-    const isCustomTestBlockFunction = node => additionalTestBlockFunctions.includes((0, _utils.getNodeName)(node) || '');
+    const isCustomTestBlockFunction = node => additionalTestBlockFunctions.includes((0, _utils2.getNodeName)(node) || '');
 
-    const isTestBlock = node => (0, _utils.isTestCaseCall)(node) || isCustomTestBlockFunction(node);
+    const isTestBlock = node => (0, _utils2.isTestCaseCall)(node) || isCustomTestBlockFunction(node);
 
     return {
       CallExpression(node) {
-        if ((0, _utils.isExpectCall)(node)) {
+        if ((0, _utils2.isExpectCall)(node)) {
           const parent = callStack[callStack.length - 1];
 
-          if (!parent || parent === _utils.DescribeAlias.describe) {
+          if (!parent || parent === _utils2.DescribeAlias.describe) {
             context.report({
               node,
               messageId: 'unexpectedExpect'
@@ -94,7 +94,7 @@ var _default = (0, _utils.createRule)({
           callStack.push('test');
         }
 
-        if (node.callee.type === _experimentalUtils.AST_NODE_TYPES.TaggedTemplateExpression) {
+        if (node.callee.type === _utils.AST_NODE_TYPES.TaggedTemplateExpression) {
           callStack.push('template');
         }
       },
@@ -102,7 +102,7 @@ var _default = (0, _utils.createRule)({
       'CallExpression:exit'(node) {
         const top = callStack[callStack.length - 1];
 
-        if (top === 'test' && isTestBlock(node) && node.callee.type !== _experimentalUtils.AST_NODE_TYPES.MemberExpression || top === 'template' && node.callee.type === _experimentalUtils.AST_NODE_TYPES.TaggedTemplateExpression) {
+        if (top === 'test' && isTestBlock(node) && node.callee.type !== _utils.AST_NODE_TYPES.MemberExpression || top === 'template' && node.callee.type === _utils.AST_NODE_TYPES.TaggedTemplateExpression) {
           callStack.pop();
         }
       },
@@ -124,7 +124,7 @@ var _default = (0, _utils.createRule)({
       ArrowFunctionExpression(node) {
         var _node$parent;
 
-        if (((_node$parent = node.parent) === null || _node$parent === void 0 ? void 0 : _node$parent.type) !== _experimentalUtils.AST_NODE_TYPES.CallExpression) {
+        if (((_node$parent = node.parent) === null || _node$parent === void 0 ? void 0 : _node$parent.type) !== _utils.AST_NODE_TYPES.CallExpression) {
           callStack.push('arrow');
         }
       },

package/lib/rules/no-test-prefixes.js

@@ -5,11 +5,11 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _experimentalUtils = require("@typescript-eslint/experimental-utils");
+var _utils = require("@typescript-eslint/utils");
 
-var _utils = require("./utils");
+var _utils2 = require("./utils");
 
-var _default = (0, _utils.createRule)({
+var _default = (0, _utils2.createRule)({
   name: __filename,
   meta: {
     docs: {
@@ -29,11 +29,11 @@ var _default = (0, _utils.createRule)({
   create(context) {
     return {
       CallExpression(node) {
-        const nodeName = (0, _utils.getNodeName)(node.callee);
-        if (!nodeName || !(0, _utils.isDescribeCall)(node) && !(0, _utils.isTestCaseCall)(node)) return;
+        const nodeName = (0, _utils2.getNodeName)(node.callee);
+        if (!nodeName || !(0, _utils2.isDescribeCall)(node) && !(0, _utils2.isTestCaseCall)(node)) return;
         const preferredNodeName = getPreferredNodeName(nodeName);
         if (!preferredNodeName) return;
-        const funcNode = node.callee.type === _experimentalUtils.AST_NODE_TYPES.TaggedTemplateExpression ? node.callee.tag : node.callee.type === _experimentalUtils.AST_NODE_TYPES.CallExpression ? node.callee.callee : node.callee;
+        const funcNode = node.callee.type === _utils.AST_NODE_TYPES.TaggedTemplateExpression ? node.callee.tag : node.callee.type === _utils.AST_NODE_TYPES.CallExpression ? node.callee.callee : node.callee;
         context.report({
           messageId: 'usePreferredName',
           node: node.callee,

package/lib/rules/no-test-return-statement.js

@@ -5,21 +5,21 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _experimentalUtils = require("@typescript-eslint/experimental-utils");
+var _utils = require("@typescript-eslint/utils");
 
-var _utils = require("./utils");
+var _utils2 = require("./utils");
 
 const getBody = args => {
   const [, secondArg] = args;
 
-  if (secondArg && (0, _utils.isFunction)(secondArg) && secondArg.body.type === _experimentalUtils.AST_NODE_TYPES.BlockStatement) {
+  if (secondArg && (0, _utils2.isFunction)(secondArg) && secondArg.body.type === _utils.AST_NODE_TYPES.BlockStatement) {
     return secondArg.body.body;
   }
 
   return [];
 };
 
-var _default = (0, _utils.createRule)({
+var _default = (0, _utils2.createRule)({
   name: __filename,
   meta: {
     docs: {
@@ -38,9 +38,9 @@ var _default = (0, _utils.createRule)({
   create(context) {
     return {
       CallExpression(node) {
-        if (!(0, _utils.isTestCaseCall)(node)) return;
+        if (!(0, _utils2.isTestCaseCall)(node)) return;
         const body = getBody(node.arguments);
-        const returnStmt = body.find(t => t.type === _experimentalUtils.AST_NODE_TYPES.ReturnStatement);
+        const returnStmt = body.find(t => t.type === _utils.AST_NODE_TYPES.ReturnStatement);
         if (!returnStmt) return;
         context.report({
           messageId: 'noReturnValue',
@@ -50,9 +50,9 @@ var _default = (0, _utils.createRule)({
 
       FunctionDeclaration(node) {
         const declaredVariables = context.getDeclaredVariables(node);
-        const testCallExpressions = (0, _utils.getTestCallExpressionsFromDeclaredVariables)(declaredVariables);
+        const testCallExpressions = (0, _utils2.getTestCallExpressionsFromDeclaredVariables)(declaredVariables);
         if (testCallExpressions.length === 0) return;
-        const returnStmt = node.body.body.find(t => t.type === _experimentalUtils.AST_NODE_TYPES.ReturnStatement);
+        const returnStmt = node.body.body.find(t => t.type === _utils.AST_NODE_TYPES.ReturnStatement);
         if (!returnStmt) return;
         context.report({
           messageId: 'noReturnValue',

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

@@ -0,0 +1,139 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+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;
+};
+
+const isComparingToString = expression => {
+  return isString(expression.left) || isString(expression.right);
+};
+
+const invertOperator = operator => {
+  switch (operator) {
+    case '>':
+      return '<=';
+
+    case '<':
+      return '>=';
+
+    case '>=':
+      return '<';
+
+    case '<=':
+      return '>';
+  }
+
+  return null;
+};
+
+const determineMatcher = (operator, negated) => {
+  const op = negated ? invertOperator(operator) : operator;
+
+  switch (op) {
+    case '>':
+      return 'toBeGreaterThan';
+
+    case '<':
+      return 'toBeLessThan';
+
+    case '>=':
+      return 'toBeGreaterThanOrEqual';
+
+    case '<=':
+      return 'toBeLessThanOrEqual';
+  }
+
+  return null;
+};
+
+var _default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      category: 'Best Practices',
+      description: 'Suggest using the built-in comparison matchers',
+      recommended: false
+    },
+    messages: {
+      useToBeComparison: 'Prefer using `{{ preferredMatcher }}` instead'
+    },
+    fixable: 'code',
+    type: 'suggestion',
+    schema: []
+  },
+  defaultOptions: [],
+
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (!(0, _utils2.isExpectCall)(node)) {
+          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 || isComparingToString(comparison) || !isBooleanEqualityMatcher(matcher)) {
+          return;
+        }
+
+        const preferredMatcher = determineMatcher(comparison.operator, (0, _utils2.followTypeAssertionChain)(matcher.arguments[0]).value === !!modifier);
+
+        if (!preferredMatcher) {
+          return;
+        }
+
+        context.report({
+          fix(fixer) {
+            const sourceCode = context.getSourceCode();
+            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]], `.${preferredMatcher}`), // replace the matcher argument with the right-hand side of the comparison
+            fixer.replaceText(matcher.arguments[0], sourceCode.getText(comparison.right))];
+          },
+
+          messageId: 'useToBeComparison',
+          data: {
+            preferredMatcher
+          },
+          node: (modifier || matcher).node.property
+        });
+      }
+
+    };
+  }
+
+});
+
+exports.default = _default;