eslint-plugin-jest 26.7.0 → 26.8.7

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.7",
   "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,8 +120,7 @@
     "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-eslint-plugin": "^4.0.0",
     "eslint-plugin-import": "^2.25.1",
     "eslint-plugin-node": "^11.0.0",
     "eslint-plugin-prettier": "^3.4.1",
@@ -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"
+  }
 }

package/lib/rules/utils/parseExpectCall.js

@@ -1,145 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.parseExpectCall = exports.isParsedEqualityMatcherCall = exports.isExpectMember = exports.isExpectCall = exports.ModifierName = exports.EqualityMatcher = void 0;
-
-var _utils = require("@typescript-eslint/utils");
-
-var _utils2 = require("../utils");
-
-/**
- * Checks if the given `node` is a valid `ExpectCall`.
- *
- * In order to be an `ExpectCall`, the `node` must:
- *  * be a `CallExpression`,
- *  * have an accessor named 'expect',
- *  * have a `parent`.
- *
- * @param {Node} node
- *
- * @return {node is ExpectCall}
- */
-const isExpectCall = node => node.type === _utils.AST_NODE_TYPES.CallExpression && (0, _utils2.isSupportedAccessor)(node.callee, 'expect') && node.parent !== undefined;
-
-exports.isExpectCall = isExpectCall;
-
-const isExpectMember = (node, name) => node.type === _utils.AST_NODE_TYPES.MemberExpression && (0, _utils2.isSupportedAccessor)(node.property, name);
-/**
- * Represents all the jest matchers.
- */
-
-
-exports.isExpectMember = isExpectMember;
-let ModifierName;
-exports.ModifierName = ModifierName;
-
-(function (ModifierName) {
-  ModifierName["not"] = "not";
-  ModifierName["rejects"] = "rejects";
-  ModifierName["resolves"] = "resolves";
-})(ModifierName || (exports.ModifierName = ModifierName = {}));
-
-let EqualityMatcher;
-exports.EqualityMatcher = EqualityMatcher;
-
-(function (EqualityMatcher) {
-  EqualityMatcher["toBe"] = "toBe";
-  EqualityMatcher["toEqual"] = "toEqual";
-  EqualityMatcher["toStrictEqual"] = "toStrictEqual";
-})(EqualityMatcher || (exports.EqualityMatcher = EqualityMatcher = {}));
-
-const isParsedEqualityMatcherCall = (matcher, name) => (name ? matcher.name === name : EqualityMatcher.hasOwnProperty(matcher.name)) && matcher.arguments !== null && matcher.arguments.length === 1;
-/**
- * Represents a parsed expect matcher, such as `toBe`, `toContain`, and so on.
- */
-
-
-exports.isParsedEqualityMatcherCall = isParsedEqualityMatcherCall;
-
-const parseExpectMember = expectMember => ({
-  name: (0, _utils2.getAccessorValue)(expectMember.property),
-  node: expectMember
-});
-
-const reparseAsMatcher = parsedMember => ({ ...parsedMember,
-
-  /**
-   * The arguments being passed to this `Matcher`, if any.
-   *
-   * If this matcher isn't called, this will be `null`.
-   */
-  arguments: parsedMember.node.parent.type === _utils.AST_NODE_TYPES.CallExpression ? parsedMember.node.parent.arguments : null
-});
-/**
- * Re-parses the given `parsedMember` as a `ParsedExpectModifier`.
- *
- * If the given `parsedMember` does not have a `name` of a valid `Modifier`,
- * an exception will be thrown.
- *
- * @param {ParsedExpectMember<ModifierName>} parsedMember
- *
- * @return {ParsedExpectModifier}
- */
-
-
-const reparseMemberAsModifier = parsedMember => {
-  if (isSpecificMember(parsedMember, ModifierName.not)) {
-    return parsedMember;
-  }
-  /* istanbul ignore if */
-
-
-  if (!isSpecificMember(parsedMember, ModifierName.resolves) && !isSpecificMember(parsedMember, ModifierName.rejects)) {
-    // ts doesn't think that the ModifierName.not check is the direct inverse as the above two checks
-    // todo: impossible at runtime, but can't be typed w/o negation support
-    throw new Error(`modifier name must be either "${ModifierName.resolves}" or "${ModifierName.rejects}" (got "${parsedMember.name}")`);
-  }
-
-  const negation = isExpectMember(parsedMember.node.parent, ModifierName.not) ? parsedMember.node.parent : undefined;
-  return { ...parsedMember,
-    negation
-  };
-};
-
-const isSpecificMember = (member, specific) => member.name === specific;
-/**
- * Checks if the given `ParsedExpectMember` should be re-parsed as an `ParsedExpectModifier`.
- *
- * @param {ParsedExpectMember} member
- *
- * @return {member is ParsedExpectMember<ModifierName>}
- */
-
-
-const shouldBeParsedExpectModifier = member => ModifierName.hasOwnProperty(member.name);
-
-const parseExpectCall = expect => {
-  const expectation = {
-    expect
-  };
-
-  if (!isExpectMember(expect.parent)) {
-    return expectation;
-  }
-
-  const parsedMember = parseExpectMember(expect.parent);
-
-  if (!shouldBeParsedExpectModifier(parsedMember)) {
-    expectation.matcher = reparseAsMatcher(parsedMember);
-    return expectation;
-  }
-
-  const modifier = expectation.modifier = reparseMemberAsModifier(parsedMember);
-  const memberNode = modifier.negation || modifier.node;
-
-  if (!isExpectMember(memberNode.parent)) {
-    return expectation;
-  }
-
-  expectation.matcher = reparseAsMatcher(parseExpectMember(memberNode.parent));
-  return expectation;
-};
-
-exports.parseExpectCall = parseExpectCall;