eslint-plugin-jest 26.6.0 → 26.8.1

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

package/lib/rules/valid-expect.js

@@ -26,7 +26,7 @@ const getPromiseCallExpressionNode = node => {
     node = node.parent;
   }
 
-  if (node.type === _utils.AST_NODE_TYPES.CallExpression && node.callee.type === _utils.AST_NODE_TYPES.MemberExpression && (0, _utils2.isSupportedAccessor)(node.callee.object) && (0, _utils2.getAccessorValue)(node.callee.object) === 'Promise' && node.parent) {
+  if (node.type === _utils.AST_NODE_TYPES.CallExpression && node.callee.type === _utils.AST_NODE_TYPES.MemberExpression && (0, _utils2.isSupportedAccessor)(node.callee.object, 'Promise') && node.parent) {
     return node;
   }
 
@@ -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
-          });
-        }
       }
 
     };