eslint-plugin-jest 26.5.3 → 26.8.0

package/lib/rules/require-to-throw-message.js

@@ -26,25 +26,25 @@ var _default = (0, _utils.createRule)({
   create(context) {
     return {
       CallExpression(node) {
-        var _matcher$arguments;
+        const jestFnCall = (0, _utils.parseJestFnCall)(node, context);
 
-        if (!(0, _utils.isExpectCall)(node)) {
+        if ((jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) !== 'expect') {
           return;
         }
 
         const {
-          matcher,
-          modifier
-        } = (0, _utils.parseExpectCall)(node);
+          matcher
+        } = jestFnCall;
+        const matcherName = (0, _utils.getAccessorValue)(matcher);
 
-        if ((matcher === null || matcher === void 0 ? void 0 : (_matcher$arguments = matcher.arguments) === null || _matcher$arguments === void 0 ? void 0 : _matcher$arguments.length) === 0 && ['toThrow', 'toThrowError'].includes(matcher.name) && (!modifier || !(modifier.name === _utils.ModifierName.not || modifier.negation))) {
+        if (jestFnCall.args.length === 0 && ['toThrow', 'toThrowError'].includes(matcherName) && !jestFnCall.modifiers.some(nod => (0, _utils.getAccessorValue)(nod) === 'not')) {
           // Look for `toThrow` calls with no arguments.
           context.report({
             messageId: 'addErrorMessage',
             data: {
-              matcherName: matcher.name
+              matcherName
             },
-            node: matcher.node.property
+            node: matcher
           });
         }
       }

package/lib/rules/unbound-method.js

@@ -5,25 +5,11 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _utils = require("./utils");
+var _utils = require("@typescript-eslint/utils");
 
-const toThrowMatchers = ['toThrow', 'toThrowError', 'toThrowErrorMatchingSnapshot', 'toThrowErrorMatchingInlineSnapshot'];
-
-const isJestExpectToThrowCall = node => {
-  if (!(0, _utils.isExpectCall)(node)) {
-    return false;
-  }
-
-  const {
-    matcher
-  } = (0, _utils.parseExpectCall)(node);
-
-  if (!matcher) {
-    return false;
-  }
+var _utils2 = require("./utils");
 
-  return !toThrowMatchers.includes(matcher.name);
-};
+const toThrowMatchers = ['toThrow', 'toThrowError', 'toThrowErrorMatchingSnapshot', 'toThrowErrorMatchingInlineSnapshot'];
 
 const baseRule = (() => {
   try {
@@ -52,7 +38,7 @@ const tryCreateBaseRule = context => {
 
 const DEFAULT_MESSAGE = 'This rule requires `@typescript-eslint/eslint-plugin`';
 
-var _default = (0, _utils.createRule)({
+var _default = (0, _utils2.createRule)({
   defaultOptions: [{
     ignoreStatic: false
   }],
@@ -60,7 +46,9 @@ var _default = (0, _utils.createRule)({
   name: __filename,
   meta: {
     messages: {
+      // eslint-disable-next-line eslint-plugin/no-unused-message-ids
       unbound: DEFAULT_MESSAGE,
+      // eslint-disable-next-line eslint-plugin/no-unused-message-ids
       unboundWithoutThisAnnotation: DEFAULT_MESSAGE
     },
     schema: [],
@@ -68,7 +56,7 @@ var _default = (0, _utils.createRule)({
     ...(baseRule === null || baseRule === void 0 ? void 0 : baseRule.meta),
     docs: {
       category: 'Best Practices',
-      description: 'Enforces unbound methods are called with their expected scope',
+      description: 'Enforce unbound methods are called with their expected scope',
       requiresTypeChecking: true,
       ...(baseRule === null || baseRule === void 0 ? void 0 : baseRule.meta.docs),
       recommended: false
@@ -82,24 +70,23 @@ var _default = (0, _utils.createRule)({
       return {};
     }
 
-    let inExpectToThrowCall = false;
     return { ...baseSelectors,
 
-      CallExpression(node) {
-        inExpectToThrowCall = isJestExpectToThrowCall(node);
-      },
+      MemberExpression(node) {
+        var _node$parent, _baseSelectors$Member;
 
-      'CallExpression:exit'(node) {
-        if (inExpectToThrowCall && isJestExpectToThrowCall(node)) {
-          inExpectToThrowCall = false;
-        }
-      },
+        if (((_node$parent = node.parent) === null || _node$parent === void 0 ? void 0 : _node$parent.type) === _utils.AST_NODE_TYPES.CallExpression) {
+          const jestFnCall = (0, _utils2.parseJestFnCall)((0, _utils2.findTopMostCallExpression)(node.parent), context);
 
-      MemberExpression(node) {
-        var _baseSelectors$Member;
+          if ((jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) === 'expect') {
+            const {
+              matcher
+            } = jestFnCall;
 
-        if (inExpectToThrowCall) {
-          return;
+            if (!toThrowMatchers.includes((0, _utils2.getAccessorValue)(matcher))) {
+              return;
+            }
+          }
         }
 
         (_baseSelectors$Member = baseSelectors.MemberExpression) === null || _baseSelectors$Member === void 0 ? void 0 : _baseSelectors$Member.call(baseSelectors, node);

package/lib/rules/utils/index.js

@@ -67,17 +67,4 @@ Object.keys(_parseJestFnCall).forEach(function (key) {
       return _parseJestFnCall[key];
     }
   });
-});
-
-var _parseExpectCall = require("./parseExpectCall");
-
-Object.keys(_parseExpectCall).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _parseExpectCall[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _parseExpectCall[key];
-    }
-  });
 });

package/lib/rules/utils/misc.js

@@ -3,9 +3,9 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.createRule = exports.TestCaseName = exports.HookName = exports.DescribeAlias = void 0;
+exports.getFirstMatcherArg = exports.findTopMostCallExpression = exports.createRule = exports.TestCaseName = exports.ModifierName = exports.HookName = exports.EqualityMatcher = exports.DescribeAlias = void 0;
 exports.getNodeName = getNodeName;
-exports.replaceAccessorFixer = exports.isFunction = exports.hasOnlyOneArgument = exports.getTestCallExpressionsFromDeclaredVariables = void 0;
+exports.replaceAccessorFixer = exports.isFunction = exports.isBooleanLiteral = exports.hasOnlyOneArgument = exports.getTestCallExpressionsFromDeclaredVariables = void 0;
 
 var _path = require("path");
 
@@ -15,6 +15,8 @@ var _package = require("../../../package.json");
 
 var _accessors = require("./accessors");
 
+var _followTypeAssertionChain = require("./followTypeAssertionChain");
+
 var _parseJestFnCall = require("./parseJestFnCall");
 
 const REPO_URL = 'https://github.com/jest-community/eslint-plugin-jest';
@@ -70,6 +72,24 @@ exports.HookName = HookName;
   HookName["afterEach"] = "afterEach";
 })(HookName || (exports.HookName = HookName = {}));
 
+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 joinNames = (a, b) => a && b ? `${a}.${b}` : null;
 
 function getNodeName(node) {
@@ -117,4 +137,45 @@ const replaceAccessorFixer = (fixer, node, text) => {
   return fixer.replaceText(node, node.type === _utils.AST_NODE_TYPES.Identifier ? text : `'${text}'`);
 };
 
-exports.replaceAccessorFixer = replaceAccessorFixer;
+exports.replaceAccessorFixer = replaceAccessorFixer;
+
+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;
+};
+
+exports.findTopMostCallExpression = findTopMostCallExpression;
+
+const isBooleanLiteral = node => node.type === _utils.AST_NODE_TYPES.Literal && typeof node.value === 'boolean';
+
+exports.isBooleanLiteral = isBooleanLiteral;
+
+const getFirstMatcherArg = expectFnCall => {
+  const [firstArg] = expectFnCall.args;
+
+  if (firstArg.type === _utils.AST_NODE_TYPES.SpreadElement) {
+    return firstArg;
+  }
+
+  return (0, _followTypeAssertionChain.followTypeAssertionChain)(firstArg);
+};
+
+exports.getFirstMatcherArg = getFirstMatcherArg;

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;
               }