eslint-plugin-jest 26.7.0 → 26.8.0

package/lib/rules/utils/parseJestFnCall.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getNodeChain = getNodeChain;
-exports.scopeHasLocalReference = exports.parseJestFnCall = exports.isTypeOfJestFnCall = void 0;
+exports.scopeHasLocalReference = exports.parseJestFnCallWithReason = exports.parseJestFnCall = exports.isTypeOfJestFnCall = void 0;
 
 var _utils = require("@typescript-eslint/utils");
 
@@ -39,9 +39,10 @@ function getNodeChain(node) {
 }
 
 const determineJestFnType = name => {
-  // if (name === 'expect') {
-  //   return 'expect';
-  // }
+  if (name === 'expect') {
+    return 'expect';
+  }
+
   if (name === 'jest') {
     return 'jest';
   }
@@ -81,27 +82,23 @@ const resolvePossibleAliasedGlobal = (global, context) => {
 };
 
 const parseJestFnCall = (node, context) => {
-  var _node$parent, _node$parent2, _resolved$original;
+  const jestFnCall = parseJestFnCallWithReason(node, context);
 
-  // ensure that we're at the "top" of the function call chain otherwise when
-  // parsing e.g. x().y.z(), we'll incorrectly find & parse "x()" even though
-  // the full chain is not a valid jest function call chain
-  if (((_node$parent = node.parent) === null || _node$parent === void 0 ? void 0 : _node$parent.type) === _utils.AST_NODE_TYPES.CallExpression || ((_node$parent2 = node.parent) === null || _node$parent2 === void 0 ? void 0 : _node$parent2.type) === _utils.AST_NODE_TYPES.MemberExpression) {
+  if (typeof jestFnCall === 'string') {
     return null;
   }
 
-  const chain = getNodeChain(node);
+  return jestFnCall;
+};
 
-  if (!(chain !== null && chain !== void 0 && chain.length)) {
-    return null;
-  } // check that every link in the chain except the last is a member expression
+exports.parseJestFnCall = parseJestFnCall;
 
+const parseJestFnCallWithReason = (node, context) => {
+  var _resolved$original, _node$parent2, _node$parent3;
 
-  if (chain.slice(0, chain.length - 1).some(nod => {
-    var _nod$parent;
+  const chain = getNodeChain(node);
 
-    return ((_nod$parent = nod.parent) === null || _nod$parent === void 0 ? void 0 : _nod$parent.type) !== _utils.AST_NODE_TYPES.MemberExpression;
-  })) {
+  if (!(chain !== null && chain !== void 0 && chain.length)) {
     return null;
   }
 
@@ -127,21 +124,121 @@ const parseJestFnCall = (node, context) => {
   const name = (_resolved$original = resolved.original) !== null && _resolved$original !== void 0 ? _resolved$original : resolved.local;
   const links = [name, ...rest.map(link => (0, _utils2.getAccessorValue)(link))];
 
-  if (name !== 'jest' && !ValidJestFnCallChains.includes(links.join('.'))) {
+  if (name !== 'jest' && name !== 'expect' && !ValidJestFnCallChains.includes(links.join('.'))) {
     return null;
   }
 
-  return {
+  const parsedJestFnCall = {
     name,
-    type: determineJestFnType(name),
     head: { ...resolved,
       node: first
     },
+    // every member node must have a member expression as their parent
+    // in order to be part of the call chain we're parsing
     members: rest
   };
+  const type = determineJestFnType(name);
+
+  if (type === 'expect') {
+    const result = parseJestExpectCall(parsedJestFnCall); // if the `expect` call chain is not valid, only report on the topmost node
+    // since all members in the chain are likely to get flagged for some reason
+
+    if (typeof result === 'string' && (0, _utils2.findTopMostCallExpression)(node) !== node) {
+      return null;
+    }
+
+    if (result === 'matcher-not-found') {
+      var _node$parent;
+
+      if (((_node$parent = node.parent) === null || _node$parent === void 0 ? void 0 : _node$parent.type) === _utils.AST_NODE_TYPES.MemberExpression) {
+        return 'matcher-not-called';
+      }
+    }
+
+    return result;
+  } // check that every link in the chain except the last is a member expression
+
+
+  if (chain.slice(0, chain.length - 1).some(nod => {
+    var _nod$parent;
+
+    return ((_nod$parent = nod.parent) === null || _nod$parent === void 0 ? void 0 : _nod$parent.type) !== _utils.AST_NODE_TYPES.MemberExpression;
+  })) {
+    return null;
+  } // ensure that we're at the "top" of the function call chain otherwise when
+  // parsing e.g. x().y.z(), we'll incorrectly find & parse "x()" even though
+  // the full chain is not a valid jest function call chain
+
+
+  if (((_node$parent2 = node.parent) === null || _node$parent2 === void 0 ? void 0 : _node$parent2.type) === _utils.AST_NODE_TYPES.CallExpression || ((_node$parent3 = node.parent) === null || _node$parent3 === void 0 ? void 0 : _node$parent3.type) === _utils.AST_NODE_TYPES.MemberExpression) {
+    return null;
+  }
+
+  return { ...parsedJestFnCall,
+    type
+  };
 };
 
-exports.parseJestFnCall = parseJestFnCall;
+exports.parseJestFnCallWithReason = parseJestFnCallWithReason;
+
+const findModifiersAndMatcher = members => {
+  const modifiers = [];
+
+  for (const member of members) {
+    var _member$parent, _member$parent$parent;
+
+    // check if the member is being called, which means it is the matcher
+    // (and also the end of the entire "expect" call chain)
+    if (((_member$parent = member.parent) === null || _member$parent === void 0 ? void 0 : _member$parent.type) === _utils.AST_NODE_TYPES.MemberExpression && ((_member$parent$parent = member.parent.parent) === null || _member$parent$parent === void 0 ? void 0 : _member$parent$parent.type) === _utils.AST_NODE_TYPES.CallExpression) {
+      return {
+        matcher: member,
+        args: member.parent.parent.arguments,
+        modifiers
+      };
+    } // otherwise, it should be a modifier
+
+
+    const name = (0, _utils2.getAccessorValue)(member);
+
+    if (modifiers.length === 0) {
+      // the first modifier can be any of the three modifiers
+      if (!_utils2.ModifierName.hasOwnProperty(name)) {
+        return 'modifier-unknown';
+      }
+    } else if (modifiers.length === 1) {
+      // the second modifier can only be "not"
+      if (name !== _utils2.ModifierName.not) {
+        return 'modifier-unknown';
+      }
+
+      const firstModifier = (0, _utils2.getAccessorValue)(modifiers[0]); // and the first modifier has to be either "resolves" or "rejects"
+
+      if (firstModifier !== _utils2.ModifierName.resolves && firstModifier !== _utils2.ModifierName.rejects) {
+        return 'modifier-unknown';
+      }
+    } else {
+      return 'modifier-unknown';
+    }
+
+    modifiers.push(member);
+  } // this will only really happen if there are no members
+
+
+  return 'matcher-not-found';
+};
+
+const parseJestExpectCall = typelessParsedJestFnCall => {
+  const modifiersAndMatcher = findModifiersAndMatcher(typelessParsedJestFnCall.members);
+
+  if (typeof modifiersAndMatcher === 'string') {
+    return modifiersAndMatcher;
+  }
+
+  return { ...typelessParsedJestFnCall,
+    type: 'expect',
+    ...modifiersAndMatcher
+  };
+};
 
 const describeImportDefAsImport = def => {
   if (def.parent.type === _utils.AST_NODE_TYPES.TSImportEqualsDeclaration) {

package/lib/rules/valid-expect-in-promise.js

@@ -29,29 +29,6 @@ const isPromiseChainCall = node => {
   return false;
 };
 
-const findTopMostCallExpression = node => {
-  let topMostCallExpression = node;
-  let {
-    parent
-  } = node;
-
-  while (parent) {
-    if (parent.type === _utils.AST_NODE_TYPES.CallExpression) {
-      topMostCallExpression = parent;
-      parent = parent.parent;
-      continue;
-    }
-
-    if (parent.type !== _utils.AST_NODE_TYPES.MemberExpression) {
-      break;
-    }
-
-    parent = parent.parent;
-  }
-
-  return topMostCallExpression;
-};
-
 const isTestCaseCallWithCallbackArg = (node, context) => {
   const jestCallFn = (0, _utils2.parseJestFnCall)(node, context);
 
@@ -173,7 +150,7 @@ const getLeftMostCallExpression = call => {
  */
 
 
-const isValueAwaitedOrReturned = (identifier, body) => {
+const isValueAwaitedOrReturned = (identifier, body, context) => {
   const {
     name
   } = identifier;
@@ -197,13 +174,13 @@ const isValueAwaitedOrReturned = (identifier, body) => {
         }
 
         const leftMostCall = getLeftMostCallExpression(node.expression);
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node.expression, context);
 
-        if ((0, _utils2.isExpectCall)(leftMostCall) && leftMostCall.arguments.length > 0 && (0, _utils2.isIdentifier)(leftMostCall.arguments[0], name)) {
-          const {
-            modifier
-          } = (0, _utils2.parseExpectCall)(leftMostCall);
-
-          if ((modifier === null || modifier === void 0 ? void 0 : modifier.name) === _utils2.ModifierName.resolves || (modifier === null || modifier === void 0 ? void 0 : modifier.name) === _utils2.ModifierName.rejects) {
+        if ((jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) === 'expect' && leftMostCall.arguments.length > 0 && (0, _utils2.isIdentifier)(leftMostCall.arguments[0], name)) {
+          if (jestFnCall.members.some(m => {
+            const v = (0, _utils2.getAccessorValue)(m);
+            return v === _utils2.ModifierName.resolves || v === _utils2.ModifierName.rejects;
+          })) {
             return true;
           }
         }
@@ -228,7 +205,7 @@ const isValueAwaitedOrReturned = (identifier, body) => {
       }
     }
 
-    if (node.type === _utils.AST_NODE_TYPES.BlockStatement && isValueAwaitedOrReturned(identifier, node.body)) {
+    if (node.type === _utils.AST_NODE_TYPES.BlockStatement && isValueAwaitedOrReturned(identifier, node.body, context)) {
       return true;
     }
   }
@@ -269,7 +246,7 @@ const isDirectlyWithinTestCaseCall = (node, context) => {
   return false;
 };
 
-const isVariableAwaitedOrReturned = variable => {
+const isVariableAwaitedOrReturned = (variable, context) => {
   const body = findFirstBlockBodyUp(variable); // it's pretty much impossible for us to track destructuring assignments,
   // so we return true to bailout gracefully
 
@@ -277,7 +254,7 @@ const isVariableAwaitedOrReturned = variable => {
     return true;
   }
 
-  return isValueAwaitedOrReturned(variable.id, body);
+  return isValueAwaitedOrReturned(variable.id, body, context);
 };
 
 var _default = (0, _utils2.createRule)({
@@ -324,7 +301,7 @@ var _default = (0, _utils2.createRule)({
         // an expect call, mark the deepest chain as having an expect call
 
 
-        if (chains.length > 0 && (0, _utils2.isExpectCall)(node)) {
+        if (chains.length > 0 && (0, _utils2.isTypeOfJestFnCall)(node, context, ['expect'])) {
           chains[0] = true;
         }
       },
@@ -356,7 +333,7 @@ var _default = (0, _utils2.createRule)({
 
         const {
           parent
-        } = findTopMostCallExpression(node); // if we don't have a parent (which is technically impossible at runtime)
+        } = (0, _utils2.findTopMostCallExpression)(node); // if we don't have a parent (which is technically impossible at runtime)
         // or our parent is not directly within the test case, we stop checking
         // because we're most likely in the body of a function being defined
         // within the test, which we can't track
@@ -368,7 +345,7 @@ var _default = (0, _utils2.createRule)({
         switch (parent.type) {
           case _utils.AST_NODE_TYPES.VariableDeclarator:
             {
-              if (isVariableAwaitedOrReturned(parent)) {
+              if (isVariableAwaitedOrReturned(parent, context)) {
                 return;
               }
 
@@ -377,7 +354,7 @@ var _default = (0, _utils2.createRule)({
 
           case _utils.AST_NODE_TYPES.AssignmentExpression:
             {
-              if (parent.left.type === _utils.AST_NODE_TYPES.Identifier && isValueAwaitedOrReturned(parent.left, findFirstBlockBodyUp(parent))) {
+              if (parent.left.type === _utils.AST_NODE_TYPES.Identifier && isValueAwaitedOrReturned(parent.left, findFirstBlockBodyUp(parent), context)) {
                 return;
               }
 

package/lib/rules/valid-expect.js

@@ -44,7 +44,7 @@ const getParentIfThenified = node => {
 
   const grandParentNode = (_node$parent2 = node.parent) === null || _node$parent2 === void 0 ? void 0 : _node$parent2.parent;
 
-  if (grandParentNode && grandParentNode.type === _utils.AST_NODE_TYPES.CallExpression && (0, _utils2.isExpectMember)(grandParentNode.callee) && ['then', 'catch'].includes((0, _utils2.getAccessorValue)(grandParentNode.callee.property)) && grandParentNode.parent) {
+  if (grandParentNode && grandParentNode.type === _utils.AST_NODE_TYPES.CallExpression && grandParentNode.callee.type === _utils.AST_NODE_TYPES.MemberExpression && (0, _utils2.isSupportedAccessor)(grandParentNode.callee.property) && ['then', 'catch'].includes((0, _utils2.getAccessorValue)(grandParentNode.callee.property)) && grandParentNode.parent) {
     // Just in case `then`s are chained look one above.
     return getParentIfThenified(grandParentNode);
   }
@@ -64,8 +64,6 @@ const isAcceptableReturnNode = (node, allowReturn) => {
   return [_utils.AST_NODE_TYPES.ArrowFunctionExpression, _utils.AST_NODE_TYPES.AwaitExpression].includes(node.type);
 };
 
-const isNoAssertionsParentNode = node => node.type === _utils.AST_NODE_TYPES.ExpressionStatement || node.type === _utils.AST_NODE_TYPES.AwaitExpression && node.parent !== undefined && node.parent.type === _utils.AST_NODE_TYPES.ExpressionStatement;
-
 const promiseArrayExceptionKey = ({
   start,
   end
@@ -84,7 +82,7 @@ var _default = (0, _utils2.createRule)({
     messages: {
       tooManyArgs: 'Expect takes at most {{ amount }} argument{{ s }}.',
       notEnoughArgs: 'Expect requires at least {{ amount }} argument{{ s }}.',
-      modifierUnknown: 'Expect has no modifier named "{{ modifierName }}".',
+      modifierUnknown: 'Expect has an unknown modifier.',
       matcherNotFound: 'Expect must have a corresponding matcher call.',
       matcherNotCalled: 'Matchers must be called to assert.',
       asyncMustBeAwaited: 'Async assertions must be awaited{{ orReturned }}.',
@@ -144,28 +142,79 @@ var _default = (0, _utils2.createRule)({
 
     const promiseArrayExceptionExists = loc => arrayExceptions.has(promiseArrayExceptionKey(loc));
 
+    const findTopMostMemberExpression = node => {
+      let topMostMemberExpression = node;
+      let {
+        parent
+      } = node;
+
+      while (parent) {
+        if (parent.type !== _utils.AST_NODE_TYPES.MemberExpression) {
+          break;
+        }
+
+        topMostMemberExpression = parent;
+        parent = parent.parent;
+      }
+
+      return topMostMemberExpression;
+    };
+
     return {
       CallExpression(node) {
-        if (!(0, _utils2.isExpectCall)(node)) {
+        const jestFnCall = (0, _utils2.parseJestFnCallWithReason)(node, context);
+
+        if (typeof jestFnCall === 'string') {
+          var _node$parent3;
+
+          const reportingNode = ((_node$parent3 = node.parent) === null || _node$parent3 === void 0 ? void 0 : _node$parent3.type) === _utils.AST_NODE_TYPES.MemberExpression ? findTopMostMemberExpression(node.parent).property : node;
+
+          if (jestFnCall === 'matcher-not-found') {
+            context.report({
+              messageId: 'matcherNotFound',
+              node: reportingNode
+            });
+            return;
+          }
+
+          if (jestFnCall === 'matcher-not-called') {
+            context.report({
+              messageId: (0, _utils2.isSupportedAccessor)(reportingNode) && _utils2.ModifierName.hasOwnProperty((0, _utils2.getAccessorValue)(reportingNode)) ? 'matcherNotFound' : 'matcherNotCalled',
+              node: reportingNode
+            });
+          }
+
+          if (jestFnCall === 'modifier-unknown') {
+            context.report({
+              messageId: 'modifierUnknown',
+              node: reportingNode
+            });
+            return;
+          }
+
+          return;
+        } else if ((jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) !== 'expect') {
           return;
         }
 
         const {
-          expect,
-          modifier,
-          matcher
-        } = (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;
+        }
 
         if (expect.arguments.length < minArgs) {
-          const expectLength = (0, _utils2.getAccessorValue)(expect.callee).length;
+          const expectLength = (0, _utils2.getAccessorValue)(jestFnCall.head.node).length;
           const loc = {
             start: {
-              column: node.loc.start.column + expectLength,
-              line: node.loc.start.line
+              column: expect.loc.start.column + expectLength,
+              line: expect.loc.start.line
             },
             end: {
-              column: node.loc.start.column + expectLength + 1,
-              line: node.loc.start.line
+              column: expect.loc.start.column + expectLength + 1,
+              line: expect.loc.start.line
             }
           };
           context.report({
@@ -174,7 +223,7 @@ var _default = (0, _utils2.createRule)({
               amount: minArgs,
               s: minArgs === 1 ? '' : 's'
             },
-            node,
+            node: expect,
             loc
           });
         }
@@ -185,7 +234,7 @@ var _default = (0, _utils2.createRule)({
           } = expect.arguments[maxArgs].loc;
           const {
             end
-          } = expect.arguments[node.arguments.length - 1].loc;
+          } = expect.arguments[expect.arguments.length - 1].loc;
           const loc = {
             start,
             end: {
@@ -199,45 +248,18 @@ var _default = (0, _utils2.createRule)({
               amount: maxArgs,
               s: maxArgs === 1 ? '' : 's'
             },
-            node,
+            node: expect,
             loc
           });
-        } // something was called on `expect()`
-
-
-        if (!matcher) {
-          if (modifier) {
-            context.report({
-              messageId: 'matcherNotFound',
-              node: modifier.node.property
-            });
-          }
-
-          return;
-        }
-
-        if ((0, _utils2.isExpectMember)(matcher.node.parent)) {
-          context.report({
-            messageId: 'modifierUnknown',
-            data: {
-              modifierName: matcher.name
-            },
-            node: matcher.node.property
-          });
-          return;
         }
 
-        if (!matcher.arguments) {
-          context.report({
-            messageId: 'matcherNotCalled',
-            node: matcher.node.property
-          });
-        }
-
-        const parentNode = matcher.node.parent;
-        const shouldBeAwaited = modifier && modifier.name !== _utils2.ModifierName.not || asyncMatchers.includes(matcher.name);
+        const {
+          matcher
+        } = jestFnCall;
+        const parentNode = matcher.parent.parent;
+        const shouldBeAwaited = jestFnCall.modifiers.some(nod => (0, _utils2.getAccessorValue)(nod) !== 'not') || asyncMatchers.includes((0, _utils2.getAccessorValue)(matcher));
 
-        if (!parentNode.parent || !shouldBeAwaited) {
+        if (!(parentNode !== null && parentNode !== void 0 && parentNode.parent) || !shouldBeAwaited) {
           return;
         }
         /**
@@ -273,16 +295,6 @@ var _default = (0, _utils2.createRule)({
             pushPromiseArrayException(finalNode.loc);
           }
         }
-      },
-
-      // nothing called on "expect()"
-      'CallExpression:exit'(node) {
-        if ((0, _utils2.isExpectCall)(node) && isNoAssertionsParentNode(node.parent)) {
-          context.report({
-            messageId: 'matcherNotFound',
-            node
-          });
-        }
       }
 
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-jest",
-  "version": "26.7.0",
+  "version": "26.8.0",
   "description": "ESLint rules for Jest",
   "keywords": [
     "eslint",
@@ -21,16 +21,16 @@
   ],
   "scripts": {
     "build": "babel --extensions .js,.ts src --out-dir lib --copy-files && rimraf lib/__tests__ 'lib/**/__tests__'",
+    "_postinstall": "is-ci || husky install",
     "lint": "eslint . --ignore-pattern '!.eslintrc.js' --ext js,ts",
     "prepack": "rimraf lib && yarn build",
+    "prepublishOnly": "pinst --disable",
     "prettier:check": "prettier --check 'docs/**/*.md' README.md '.github/**' package.json tsconfig.json src/globals.json .yarnrc.yml",
     "prettier:write": "prettier --write 'docs/**/*.md' README.md '.github/**' package.json tsconfig.json src/globals.json .yarnrc.yml",
+    "postpublish": "pinst --enable",
     "test": "jest",
     "tools:regenerate-docs": "ts-node -T tools/regenerate-docs",
-    "typecheck": "tsc -p .",
-    "_postinstall": "is-ci || husky install",
-    "prepublishOnly": "pinst --disable",
-    "postpublish": "pinst --enable"
+    "typecheck": "tsc -p ."
   },
   "commitlint": {
     "extends": [
@@ -48,6 +48,23 @@
     "singleQuote": true,
     "trailingComma": "all"
   },
+  "release": {
+    "branches": [
+      "main",
+      {
+        "name": "next",
+        "prerelease": true
+      }
+    ],
+    "plugins": [
+      "@semantic-release/commit-analyzer",
+      "@semantic-release/release-notes-generator",
+      "@semantic-release/changelog",
+      "@semantic-release/npm",
+      "@semantic-release/git",
+      "@semantic-release/github"
+    ]
+  },
   "jest": {
     "coverageThreshold": {
       "global": {
@@ -103,7 +120,6 @@
     "eslint": "^6.0.0 || ^7.0.0 || ^8.0.0",
     "eslint-config-prettier": "^8.3.0",
     "eslint-plugin-eslint-comments": "^3.1.2",
-    "eslint-plugin-eslint-config": "^2.0.0",
     "eslint-plugin-eslint-plugin": "^5.0.0",
     "eslint-plugin-import": "^2.25.1",
     "eslint-plugin-node": "^11.0.0",
@@ -135,28 +151,8 @@
       "optional": true
     }
   },
+  "packageManager": "yarn@3.2.2",
   "engines": {
     "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
-  },
-  "release": {
-    "branches": [
-      "main",
-      {
-        "name": "next",
-        "prerelease": true
-      }
-    ],
-    "plugins": [
-      "@semantic-release/commit-analyzer",
-      "@semantic-release/release-notes-generator",
-      "@semantic-release/changelog",
-      "@semantic-release/npm",
-      "@semantic-release/git",
-      "@semantic-release/github"
-    ]
-  },
-  "resolutions": {
-    "@typescript-eslint/experimental-utils": "^5.0.0"
-  },
-  "packageManager": "yarn@3.2.2"
+  }
 }