eslint-plugin-jest 26.8.3 → 26.8.6

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,8 +52,10 @@ var _default = (0, _utils2.createRule)({
     };
 
     return {
-      FunctionExpression: onFunctionExpressionEnter,
-      ArrowFunctionExpression: onFunctionExpressionEnter,
+      FunctionExpression: maybeResetCount,
+      'FunctionExpression:exit': maybeResetCount,
+      ArrowFunctionExpression: maybeResetCount,
+      'ArrowFunctionExpression:exit': maybeResetCount,
 
       CallExpression(node) {
         var _jestFnCall$head$node;

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

@@ -9,9 +9,23 @@ var _utils = require("@typescript-eslint/utils");
 
 var _utils2 = require("./utils");
 
-const isExpectAssertionsOrHasAssertionsCall = expression => expression.type === _utils.AST_NODE_TYPES.CallExpression && expression.callee.type === _utils.AST_NODE_TYPES.MemberExpression && (0, _utils2.isSupportedAccessor)(expression.callee.object, 'expect') && (0, _utils2.isSupportedAccessor)(expression.callee.property) && ['assertions', 'hasAssertions'].includes((0, _utils2.getAccessorValue)(expression.callee.property));
+const isFirstStatement = node => {
+  let parent = node;
 
-const isFirstLineExprStmt = functionBody => functionBody[0] && functionBody[0].type === _utils.AST_NODE_TYPES.ExpressionStatement;
+  while (parent) {
+    var _parent$parent;
+
+    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;
+    }
+
+    parent = parent.parent;
+  }
+  /* 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',
@@ -66,6 +80,7 @@ var _default = (0, _utils2.createRule)({
     let expressionDepth = 0;
     let hasExpectInCallback = false;
     let hasExpectInLoop = false;
+    let hasExpectAssertionsAsFirstStatement = false;
     let inTestCaseCall = false;
     let inForLoop = false;
 
@@ -95,6 +110,50 @@ var _default = (0, _utils2.createRule)({
       return false;
     };
 
+    const checkExpectHasAssertions = expectFnCall => {
+      if ((0, _utils2.getAccessorValue)(expectFnCall.members[0]) === 'hasAssertions') {
+        if (expectFnCall.args.length) {
+          context.report({
+            messageId: 'hasAssertionsTakesNoArguments',
+            node: expectFnCall.matcher,
+            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,
+          loc
+        });
+        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--;
@@ -124,6 +183,13 @@ var _default = (0, _utils2.createRule)({
         }
 
         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;
           }
@@ -157,74 +223,19 @@ var _default = (0, _utils2.createRule)({
 
         hasExpectInLoop = false;
         hasExpectInCallback = false;
-        const testFuncBody = testFn.body.body;
-
-        if (!isFirstLineExprStmt(testFuncBody)) {
-          context.report({
-            messageId: 'haveExpectAssertions',
-            node,
-            suggest: suggestions.map(([messageId, text]) => ({
-              messageId,
-              fix: fixer => fixer.insertTextBeforeRange([testFn.body.range[0] + 1, testFn.body.range[1]], text)
-            }))
-          });
-          return;
-        }
-
-        const testFuncFirstLine = testFuncBody[0].expression;
-
-        if (!isExpectAssertionsOrHasAssertionsCall(testFuncFirstLine)) {
-          context.report({
-            messageId: 'haveExpectAssertions',
-            node,
-            suggest: suggestions.map(([messageId, text]) => ({
-              messageId,
-              fix: fixer => fixer.insertTextBefore(testFuncBody[0], text)
-            }))
-          });
-          return;
-        }
-
-        if ((0, _utils2.isSupportedAccessor)(testFuncFirstLine.callee.property, 'hasAssertions')) {
-          if (testFuncFirstLine.arguments.length) {
-            context.report({
-              messageId: 'hasAssertionsTakesNoArguments',
-              node: testFuncFirstLine.callee.property,
-              suggest: [suggestRemovingExtraArguments(testFuncFirstLine.arguments, 0)]
-            });
-          }
-
-          return;
-        }
-
-        if (!(0, _utils2.hasOnlyOneArgument)(testFuncFirstLine)) {
-          let {
-            loc
-          } = testFuncFirstLine.callee.property;
-          const suggest = [];
-
-          if (testFuncFirstLine.arguments.length) {
-            loc = testFuncFirstLine.arguments[1].loc;
-            suggest.push(suggestRemovingExtraArguments(testFuncFirstLine.arguments, 1));
-          }
-
-          context.report({
-            messageId: 'assertionsRequiresOneArgument',
-            suggest,
-            loc
-          });
-          return;
-        }
-
-        const [arg] = testFuncFirstLine.arguments;
 
-        if (arg.type === _utils.AST_NODE_TYPES.Literal && typeof arg.value === 'number' && Number.isInteger(arg.value)) {
+        if (hasExpectAssertionsAsFirstStatement) {
+          hasExpectAssertionsAsFirstStatement = false;
           return;
         }
 
         context.report({
-          messageId: 'assertionsRequiresNumberArgument',
-          node: arg
+          messageId: 'haveExpectAssertions',
+          node,
+          suggest: suggestions.map(([messageId, text]) => ({
+            messageId,
+            fix: fixer => fixer.insertTextBeforeRange([testFn.body.range[0] + 1, testFn.body.range[1]], text)
+          }))
         });
       }
 

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

@@ -95,7 +95,7 @@ var _default = (0, _utils2.createRule)({
         } else if (mockFnName === withOnce('mockImplementation', isOnce)) {
           const [arg] = node.arguments;
 
-          if (!(0, _utils2.isFunction)(arg)) {
+          if (!(0, _utils2.isFunction)(arg) || arg.params.length !== 0) {
             return;
           }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-jest",
-  "version": "26.8.3",
+  "version": "26.8.6",
   "description": "ESLint rules for Jest",
   "keywords": [
     "eslint",