eslint-plugin-jest 26.8.7 → 27.1.5

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

@@ -4,17 +4,14 @@ 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: 'Use `.only` and `.skip` over `f` and `x`',
+      description: 'Require using `.only` and `.skip` over `f` and `x`',
       recommended: 'error'
     },
     messages: {
@@ -25,20 +22,16 @@ var _default = (0, _utils2.createRule)({
     type: 'suggestion'
   },
   defaultOptions: [],
-
   create(context) {
     return {
       CallExpression(node) {
         const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
-
         if ((jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) !== 'describe' && (jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) !== 'test') {
           return;
         }
-
         if (jestFnCall.name[0] !== 'f' && jestFnCall.name[0] !== 'x') {
           return;
         }
-
         const preferredNodeName = [jestFnCall.name.slice(1), jestFnCall.name[0] === 'f' ? 'only' : 'skip', ...jestFnCall.members.map(s => (0, _utils2.getAccessorValue)(s))].join('.');
         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({
@@ -47,17 +40,12 @@ var _default = (0, _utils2.createRule)({
           data: {
             preferredNodeName
           },
-
           fix(fixer) {
             return [fixer.replaceText(funcNode, preferredNodeName)];
           }
-
         });
       }
-
     };
   }
-
 });
-
 exports.default = _default;

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

@@ -4,21 +4,15 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-
 var _utils = require("@typescript-eslint/utils");
-
 var _utils2 = require("./utils");
-
 const getBody = args => {
   const [, secondArg] = args;
-
   if (secondArg && (0, _utils2.isFunction)(secondArg) && secondArg.body.type === _utils.AST_NODE_TYPES.BlockStatement) {
     return secondArg.body.body;
   }
-
   return [];
 };
-
 var _default = (0, _utils2.createRule)({
   name: __filename,
   meta: {
@@ -34,14 +28,12 @@ var _default = (0, _utils2.createRule)({
     type: 'suggestion'
   },
   defaultOptions: [],
-
   create(context) {
     return {
       CallExpression(node) {
         if (!(0, _utils2.isTypeOfJestFnCall)(node, context, ['test'])) {
           return;
         }
-
         const body = getBody(node.arguments);
         const returnStmt = body.find(t => t.type === _utils.AST_NODE_TYPES.ReturnStatement);
         if (!returnStmt) return;
@@ -50,7 +42,6 @@ var _default = (0, _utils2.createRule)({
           node: returnStmt
         });
       },
-
       FunctionDeclaration(node) {
         const declaredVariables = context.getDeclaredVariables(node);
         const testCallExpressions = (0, _utils2.getTestCallExpressionsFromDeclaredVariables)(declaredVariables, context);
@@ -62,10 +53,7 @@ var _default = (0, _utils2.createRule)({
           node: returnStmt
         });
       }
-
     };
   }
-
 });
-
 exports.default = _default;

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

@@ -4,9 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-
 var _utils = require("./utils");
-
 var _default = (0, _utils.createRule)({
   name: __filename,
   meta: {
@@ -22,25 +20,20 @@ var _default = (0, _utils.createRule)({
     schema: []
   },
   defaultOptions: [],
-
   create(context) {
     return {
       CallExpression(node) {
         const jestFnCall = (0, _utils.parseJestFnCall)(node, context);
-
         if ((jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) !== 'expect') {
           return;
         }
-
         if (jestFnCall.modifiers.some(nod => (0, _utils.getAccessorValue)(nod) === 'not')) {
           return;
         }
-
         const {
           matcher
         } = jestFnCall;
         const matcherName = (0, _utils.getAccessorValue)(matcher);
-
         if (['toBeCalled', 'toHaveBeenCalled'].includes(matcherName)) {
           context.report({
             data: {
@@ -51,10 +44,7 @@ var _default = (0, _utils.createRule)({
           });
         }
       }
-
     };
   }
-
 });
-
 exports.default = _default;

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

@@ -4,57 +4,41 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-
 var _utils = require("@typescript-eslint/utils");
-
 var _utils2 = require("./utils");
-
 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: {
@@ -71,24 +55,19 @@ var _default = (0, _utils2.createRule)({
     schema: []
   },
   defaultOptions: [],
-
   create(context) {
     return {
       CallExpression(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 {
           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]
@@ -97,30 +76,29 @@ var _default = (0, _utils2.createRule)({
           matcher
         } = jestFnCall;
         const matcherArg = (0, _utils2.getFirstMatcherArg)(jestFnCall);
-
         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 [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;
         }
-
         context.report({
           fix(fixer) {
-            const sourceCode = context.getSourceCode(); // preserve the existing modifier if it's not a negation
+            const sourceCode = context.getSourceCode();
 
+            // preserve the existing modifier if it's not a negation
             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.parent.range[1]], `${modifierText}.${preferredMatcher}`), // replace the matcher argument with the right-hand side of the comparison
+            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.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
@@ -128,10 +106,7 @@ var _default = (0, _utils2.createRule)({
           node: matcher
         });
       }
-
     };
   }
-
 });
-
 exports.default = _default;

package/lib/rules/prefer-each.js

@@ -0,0 +1,80 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("./utils");
+var _default = (0, _utils.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      category: 'Best Practices',
+      description: 'Prefer using `.each` rather than manual loops',
+      recommended: false
+    },
+    messages: {
+      preferEach: 'prefer using `{{ fn }}.each` rather than a manual loop'
+    },
+    type: 'suggestion',
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const jestFnCalls = [];
+    let inTestCaseCall = false;
+    const recommendFn = () => {
+      if (jestFnCalls.length === 1 && jestFnCalls[0] === 'test') {
+        return 'it';
+      }
+      return 'describe';
+    };
+    const enterForLoop = () => {
+      if (jestFnCalls.length === 0 || inTestCaseCall) {
+        return;
+      }
+      jestFnCalls.length = 0;
+    };
+    const exitForLoop = node => {
+      if (jestFnCalls.length === 0 || inTestCaseCall) {
+        return;
+      }
+      context.report({
+        node,
+        messageId: 'preferEach',
+        data: {
+          fn: recommendFn()
+        }
+      });
+      jestFnCalls.length = 0;
+    };
+    return {
+      ForStatement: enterForLoop,
+      'ForStatement:exit': exitForLoop,
+      ForInStatement: enterForLoop,
+      'ForInStatement:exit': exitForLoop,
+      ForOfStatement: enterForLoop,
+      'ForOfStatement:exit': exitForLoop,
+      CallExpression(node) {
+        const {
+          type: jestFnCallType
+        } = (0, _utils.parseJestFnCall)(node, context) ?? {};
+        if (jestFnCallType === 'hook' || jestFnCallType === 'describe' || jestFnCallType === 'test') {
+          jestFnCalls.push(jestFnCallType);
+        }
+        if (jestFnCallType === 'test') {
+          inTestCaseCall = true;
+        }
+      },
+      'CallExpression:exit'(node) {
+        const {
+          type: jestFnCallType
+        } = (0, _utils.parseJestFnCall)(node, context) ?? {};
+        if (jestFnCallType === 'test') {
+          inTestCaseCall = false;
+        }
+      }
+    };
+  }
+});
+exports.default = _default;

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

@@ -4,19 +4,15 @@ 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: 'Suggest using the built-in equality matchers',
-      recommended: false,
-      suggestion: true
+      recommended: false
     },
     messages: {
       useEqualityMatcher: 'Prefer using one of the equality matchers instead',
@@ -27,24 +23,19 @@ var _default = (0, _utils2.createRule)({
     schema: []
   },
   defaultOptions: [],
-
   create(context) {
     return {
       CallExpression(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 {
           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]
@@ -53,33 +44,32 @@ var _default = (0, _utils2.createRule)({
           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 = 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 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) === hasNot;
-
         const buildFixer = equalityMatcher => fixer => {
-          const sourceCode = context.getSourceCode(); // preserve the existing modifier if it's not a negation
+          const sourceCode = context.getSourceCode();
 
+          // preserve the existing modifier if it's not a negation
           let modifierText = modifier && (0, _utils2.getAccessorValue)(modifier) !== 'not' ? `.${(0, _utils2.getAccessorValue)(modifier)}` : '';
-
           if (addNotModifier) {
             modifierText += `.${_utils2.ModifierName.not}`;
           }
-
-          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.parent.range[1]], `${modifierText}.${equalityMatcher}`), // replace the matcher argument with the right-hand side of the comparison
+          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.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({
           messageId: 'useEqualityMatcher',
           suggest: ['toBe', 'toEqual', 'toStrictEqual'].map(equalityMatcher => ({
@@ -92,10 +82,7 @@ var _default = (0, _utils2.createRule)({
           node: matcher
         });
       }
-
     };
   }
-
 });
-
 exports.default = _default;

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

@@ -4,46 +4,38 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-
 var _utils = require("@typescript-eslint/utils");
-
 var _utils2 = require("./utils");
-
 const isFirstStatement = node => {
   let parent = node;
-
   while (parent) {
-    var _parent$parent;
-
+    var _parent$parent, _parent$parent2;
     if (((_parent$parent = parent.parent) === null || _parent$parent === void 0 ? void 0 : _parent$parent.type) === _utils.AST_NODE_TYPES.BlockStatement) {
       return parent.parent.body[0] === parent;
     }
 
+    // if we've hit an arrow function, then it must have a single expression
+    // as its body, as otherwise we would have hit the block statement already
+    if (((_parent$parent2 = parent.parent) === null || _parent$parent2 === void 0 ? void 0 : _parent$parent2.type) === _utils.AST_NODE_TYPES.ArrowFunctionExpression) {
+      return true;
+    }
     parent = parent.parent;
   }
-  /* istanbul ignore next */
-
 
+  /* istanbul ignore next */
   throw new Error(`Could not find BlockStatement - please file a github issue at https://github.com/jest-community/eslint-plugin-jest`);
 };
-
 const suggestRemovingExtraArguments = (args, extraArgsStartAt) => ({
   messageId: 'suggestRemovingExtraArguments',
   fix: fixer => fixer.removeRange([args[extraArgsStartAt].range[0] - Math.sign(extraArgsStartAt), args[args.length - 1].range[1]])
 });
-
-// const suggestions: Array<[MessageIds, string]> = [
-//   ['suggestAddingHasAssertions', 'expect.hasAssertions();'],
-//   ['suggestAddingAssertions', 'expect.assertions();'],
-// ];
 var _default = (0, _utils2.createRule)({
   name: __filename,
   meta: {
     docs: {
       category: 'Best Practices',
       description: 'Suggest using `expect.assertions()` OR `expect.hasAssertions()`',
-      recommended: false,
-      suggestion: true
+      recommended: false
     },
     messages: {
       hasAssertionsTakesNoArguments: '`expect.hasAssertions` expects no arguments',
@@ -77,7 +69,6 @@ var _default = (0, _utils2.createRule)({
     onlyFunctionsWithExpectInLoop: false,
     onlyFunctionsWithExpectInCallback: false
   }],
-
   create(context, [options]) {
     let expressionDepth = 0;
     let hasExpectInCallback = false;
@@ -85,33 +76,27 @@ var _default = (0, _utils2.createRule)({
     let hasExpectAssertionsAsFirstStatement = false;
     let inTestCaseCall = false;
     let inForLoop = false;
-
     const shouldCheckFunction = testFunction => {
       if (!options.onlyFunctionsWithAsyncKeyword && !options.onlyFunctionsWithExpectInLoop && !options.onlyFunctionsWithExpectInCallback) {
         return true;
       }
-
       if (options.onlyFunctionsWithAsyncKeyword) {
         if (testFunction.async) {
           return true;
         }
       }
-
       if (options.onlyFunctionsWithExpectInLoop) {
         if (hasExpectInLoop) {
           return true;
         }
       }
-
       if (options.onlyFunctionsWithExpectInCallback) {
         if (hasExpectInCallback) {
           return true;
         }
       }
-
       return false;
     };
-
     const checkExpectHasAssertions = expectFnCall => {
       if ((0, _utils2.getAccessorValue)(expectFnCall.members[0]) === 'hasAssertions') {
         if (expectFnCall.args.length) {
@@ -121,21 +106,17 @@ var _default = (0, _utils2.createRule)({
             suggest: [suggestRemovingExtraArguments(expectFnCall.args, 0)]
           });
         }
-
         return;
       }
-
       if (expectFnCall.args.length !== 1) {
         let {
           loc
         } = expectFnCall.matcher;
         const suggest = [];
-
         if (expectFnCall.args.length) {
           loc = expectFnCall.args[1].loc;
           suggest.push(suggestRemovingExtraArguments(expectFnCall.args, 1));
         }
-
         context.report({
           messageId: 'assertionsRequiresOneArgument',
           suggest,
@@ -143,27 +124,19 @@ var _default = (0, _utils2.createRule)({
         });
         return;
       }
-
       const [arg] = expectFnCall.args;
-
       if (arg.type === _utils.AST_NODE_TYPES.Literal && typeof arg.value === 'number' && Number.isInteger(arg.value)) {
         return;
       }
-
       context.report({
         messageId: 'assertionsRequiresNumberArgument',
         node: arg
       });
     };
-
     const enterExpression = () => inTestCaseCall && expressionDepth++;
-
     const exitExpression = () => inTestCaseCall && expressionDepth--;
-
     const enterForLoop = () => inForLoop = true;
-
     const exitForLoop = () => inForLoop = false;
-
     return {
       FunctionExpression: enterExpression,
       'FunctionExpression:exit': exitExpression,
@@ -175,64 +148,48 @@ var _default = (0, _utils2.createRule)({
       'ForInStatement:exit': exitForLoop,
       ForOfStatement: enterForLoop,
       'ForOfStatement:exit': exitForLoop,
-
       CallExpression(node) {
         const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
-
         if ((jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) === 'test') {
           inTestCaseCall = true;
           return;
         }
-
         if ((jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) === 'expect' && inTestCaseCall) {
           var _jestFnCall$head$node;
-
           if (expressionDepth === 1 && isFirstStatement(node) && ((_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]))) {
             checkExpectHasAssertions(jestFnCall);
             hasExpectAssertionsAsFirstStatement = true;
           }
-
           if (inForLoop) {
             hasExpectInLoop = true;
           }
-
           if (expressionDepth > 1) {
             hasExpectInCallback = true;
           }
         }
       },
-
       'CallExpression:exit'(node) {
         if (!(0, _utils2.isTypeOfJestFnCall)(node, context, ['test'])) {
           return;
         }
-
         inTestCaseCall = false;
-
         if (node.arguments.length < 2) {
           return;
         }
-
         const [, testFn] = node.arguments;
-
         if (!(0, _utils2.isFunction)(testFn) || !shouldCheckFunction(testFn)) {
           return;
         }
-
         hasExpectInLoop = false;
         hasExpectInCallback = false;
-
         if (hasExpectAssertionsAsFirstStatement) {
           hasExpectAssertionsAsFirstStatement = false;
           return;
         }
-
         const suggestions = [];
-
         if (testFn.body.type === _utils.AST_NODE_TYPES.BlockStatement) {
           suggestions.push(['suggestAddingHasAssertions', 'expect.hasAssertions();'], ['suggestAddingAssertions', 'expect.assertions();']);
         }
-
         context.report({
           messageId: 'haveExpectAssertions',
           node,
@@ -242,10 +199,7 @@ var _default = (0, _utils2.createRule)({
           }))
         });
       }
-
     };
   }
-
 });
-
 exports.default = _default;