eslint-plugin-jest 24.4.2 → 26.1.0

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

@@ -5,100 +5,293 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _experimentalUtils = require("@typescript-eslint/experimental-utils");
+var _utils = require("@typescript-eslint/utils");
 
-var _utils = require("./utils");
+var _utils2 = require("./utils");
 
-const isThenOrCatchCall = node => node.type === _experimentalUtils.AST_NODE_TYPES.CallExpression && node.callee.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && (0, _utils.isSupportedAccessor)(node.callee.property) && ['then', 'catch'].includes((0, _utils.getAccessorValue)(node.callee.property));
+const isPromiseChainCall = node => {
+  if (node.type === _utils.AST_NODE_TYPES.CallExpression && node.callee.type === _utils.AST_NODE_TYPES.MemberExpression && (0, _utils2.isSupportedAccessor)(node.callee.property)) {
+    // promise methods should have at least 1 argument
+    if (node.arguments.length === 0) {
+      return false;
+    }
 
-const isExpectCallPresentInFunction = body => {
-  if (body.type === _experimentalUtils.AST_NODE_TYPES.BlockStatement) {
-    return body.body.find(line => {
-      if (line.type === _experimentalUtils.AST_NODE_TYPES.ExpressionStatement) {
-        return isFullExpectCall(line.expression);
-      }
+    switch ((0, _utils2.getAccessorValue)(node.callee.property)) {
+      case 'then':
+        return node.arguments.length < 3;
+
+      case 'catch':
+      case 'finally':
+        return node.arguments.length < 2;
+    }
+  }
+
+  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 => {
+  if (!(0, _utils2.isTestCaseCall)(node)) {
+    return false;
+  }
+
+  const isJestEach = (0, _utils2.getNodeName)(node).endsWith('.each');
+
+  if (isJestEach && node.callee.type !== _utils.AST_NODE_TYPES.TaggedTemplateExpression) {
+    // isJestEach but not a TaggedTemplateExpression, so this must be
+    // the `jest.each([])()` syntax which this rule doesn't support due
+    // to its complexity (see jest-community/eslint-plugin-jest#710)
+    // so we return true to trigger bailout
+    return true;
+  }
+
+  if (isJestEach || node.arguments.length >= 2) {
+    const [, callback] = node.arguments;
+    const callbackArgIndex = Number(isJestEach);
+    return callback && (0, _utils2.isFunction)(callback) && callback.params.length === 1 + callbackArgIndex;
+  }
+
+  return false;
+};
+
+const isPromiseMethodThatUsesValue = (node, identifier) => {
+  const {
+    name
+  } = identifier;
+
+  if (node.argument === null) {
+    return false;
+  }
+
+  if (node.argument.type === _utils.AST_NODE_TYPES.CallExpression && node.argument.arguments.length > 0) {
+    const nodeName = (0, _utils2.getNodeName)(node.argument);
 
-      if (line.type === _experimentalUtils.AST_NODE_TYPES.ReturnStatement && line.argument) {
-        return isFullExpectCall(line.argument);
+    if (['Promise.all', 'Promise.allSettled'].includes(nodeName)) {
+      const [firstArg] = node.argument.arguments;
+
+      if (firstArg.type === _utils.AST_NODE_TYPES.ArrayExpression && firstArg.elements.some(nod => (0, _utils2.isIdentifier)(nod, name))) {
+        return true;
       }
+    }
 
-      return false;
-    });
+    if (['Promise.resolve', 'Promise.reject'].includes(nodeName) && node.argument.arguments.length === 1) {
+      return (0, _utils2.isIdentifier)(node.argument.arguments[0], name);
+    }
   }
 
-  return isFullExpectCall(body);
+  return (0, _utils2.isIdentifier)(node.argument, name);
 };
+/**
+ * Attempts to determine if the runtime value represented by the given `identifier`
+ * is `await`ed within the given array of elements
+ */
 
-const isFullExpectCall = expression => expression.type === _experimentalUtils.AST_NODE_TYPES.CallExpression && (0, _utils.isExpectMember)(expression.callee);
 
-const reportReturnRequired = (context, node) => {
-  context.report({
-    loc: {
-      end: {
-        column: node.loc.end.column,
-        line: node.loc.end.line
-      },
-      start: node.loc.start
-    },
-    messageId: 'returnPromise',
-    node
-  });
+const isValueAwaitedInElements = (name, elements) => {
+  for (const element of elements) {
+    if (element.type === _utils.AST_NODE_TYPES.AwaitExpression && (0, _utils2.isIdentifier)(element.argument, name)) {
+      return true;
+    }
+
+    if (element.type === _utils.AST_NODE_TYPES.ArrayExpression && isValueAwaitedInElements(name, element.elements)) {
+      return true;
+    }
+  }
+
+  return false;
 };
+/**
+ * Attempts to determine if the runtime value represented by the given `identifier`
+ * is `await`ed as an argument along the given call expression
+ */
+
+
+const isValueAwaitedInArguments = (name, call) => {
+  let node = call;
+
+  while (node) {
+    if (node.type === _utils.AST_NODE_TYPES.CallExpression) {
+      if (isValueAwaitedInElements(name, node.arguments)) {
+        return true;
+      }
+
+      node = node.callee;
+    }
 
-const isPromiseReturnedLater = (node, testFunctionBody) => {
-  let promiseName;
+    if (node.type !== _utils.AST_NODE_TYPES.MemberExpression) {
+      break;
+    }
 
-  if (node.type === _experimentalUtils.AST_NODE_TYPES.ExpressionStatement && node.expression.type === _experimentalUtils.AST_NODE_TYPES.CallExpression && node.expression.callee.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && (0, _utils.isSupportedAccessor)(node.expression.callee.object)) {
-    promiseName = (0, _utils.getAccessorValue)(node.expression.callee.object);
-  } else if (node.type === _experimentalUtils.AST_NODE_TYPES.VariableDeclarator && node.id.type === _experimentalUtils.AST_NODE_TYPES.Identifier) {
-    promiseName = node.id.name;
+    node = node.object;
   }
 
-  const lastLineInTestFunc = testFunctionBody[testFunctionBody.length - 1];
-  return lastLineInTestFunc.type === _experimentalUtils.AST_NODE_TYPES.ReturnStatement && lastLineInTestFunc.argument && ('name' in lastLineInTestFunc.argument && lastLineInTestFunc.argument.name === promiseName || !promiseName);
+  return false;
 };
 
-const isTestFunc = node => node.type === _experimentalUtils.AST_NODE_TYPES.CallExpression && (0, _utils.isSupportedAccessor)(node.callee) && [_utils.TestCaseName.it, _utils.TestCaseName.test].includes((0, _utils.getAccessorValue)(node.callee));
+const getLeftMostCallExpression = call => {
+  let leftMostCallExpression = call;
+  let node = call;
 
-const findTestFunction = node => {
   while (node) {
-    if ((0, _utils.isFunction)(node) && node.parent && isTestFunc(node.parent)) {
-      return node;
+    if (node.type === _utils.AST_NODE_TYPES.CallExpression) {
+      leftMostCallExpression = node;
+      node = node.callee;
+    }
+
+    if (node.type !== _utils.AST_NODE_TYPES.MemberExpression) {
+      break;
     }
 
-    node = node.parent;
+    node = node.object;
   }
 
-  return null;
+  return leftMostCallExpression;
 };
+/**
+ * Attempts to determine if the runtime value represented by the given `identifier`
+ * is `await`ed or `return`ed within the given `body` of statements
+ */
+
 
-const isParentThenOrPromiseReturned = (node, testFunctionBody) => node.type === _experimentalUtils.AST_NODE_TYPES.ReturnStatement || isPromiseReturnedLater(node, testFunctionBody);
+const isValueAwaitedOrReturned = (identifier, body) => {
+  const {
+    name
+  } = identifier;
 
-const verifyExpectWithReturn = (promiseCallbacks, node, context, testFunctionBody) => {
-  promiseCallbacks.some(promiseCallback => {
-    if (promiseCallback && (0, _utils.isFunction)(promiseCallback)) {
-      if (isExpectCallPresentInFunction(promiseCallback.body) && node.parent.parent && !isParentThenOrPromiseReturned(node.parent.parent, testFunctionBody)) {
-        reportReturnRequired(context, node.parent.parent);
+  for (const node of body) {
+    // skip all nodes that are before this identifier, because they'd probably
+    // be affecting a different runtime value (e.g. due to reassignment)
+    if (node.range[0] <= identifier.range[0]) {
+      continue;
+    }
+
+    if (node.type === _utils.AST_NODE_TYPES.ReturnStatement) {
+      return isPromiseMethodThatUsesValue(node, identifier);
+    }
+
+    if (node.type === _utils.AST_NODE_TYPES.ExpressionStatement) {
+      // it's possible that we're awaiting the value as an argument
+      if (node.expression.type === _utils.AST_NODE_TYPES.CallExpression) {
+        if (isValueAwaitedInArguments(name, node.expression)) {
+          return true;
+        }
+
+        const leftMostCall = getLeftMostCallExpression(node.expression);
+
+        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) {
+            return true;
+          }
+        }
+      }
+
+      if (node.expression.type === _utils.AST_NODE_TYPES.AwaitExpression && isPromiseMethodThatUsesValue(node.expression, identifier)) {
         return true;
+      } // (re)assignment changes the runtime value, so if we've not found an
+      // await or return already we act as if we've reached the end of the body
+
+
+      if (node.expression.type === _utils.AST_NODE_TYPES.AssignmentExpression) {
+        var _getNodeName;
+
+        // unless we're assigning to the same identifier, in which case
+        // we might be chaining off the existing promise value
+        if ((0, _utils2.isIdentifier)(node.expression.left, name) && (_getNodeName = (0, _utils2.getNodeName)(node.expression.right)) !== null && _getNodeName !== void 0 && _getNodeName.startsWith(`${name}.`) && isPromiseChainCall(node.expression.right)) {
+          continue;
+        }
+
+        break;
       }
     }
 
-    return false;
-  });
+    if (node.type === _utils.AST_NODE_TYPES.BlockStatement && isValueAwaitedOrReturned(identifier, node.body)) {
+      return true;
+    }
+  }
+
+  return false;
+};
+
+const findFirstBlockBodyUp = node => {
+  let parent = node;
+
+  while (parent) {
+    if (parent.type === _utils.AST_NODE_TYPES.BlockStatement) {
+      return parent.body;
+    }
+
+    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 isDirectlyWithinTestCaseCall = node => {
+  let parent = node;
+
+  while (parent) {
+    if ((0, _utils2.isFunction)(parent)) {
+      var _parent;
+
+      parent = parent.parent;
+      return !!(((_parent = parent) === null || _parent === void 0 ? void 0 : _parent.type) === _utils.AST_NODE_TYPES.CallExpression && (0, _utils2.isTestCaseCall)(parent));
+    }
+
+    parent = parent.parent;
+  }
+
+  return false;
 };
 
-const isHavingAsyncCallBackParam = testFunction => testFunction.params[0] && testFunction.params[0].type === _experimentalUtils.AST_NODE_TYPES.Identifier;
+const isVariableAwaitedOrReturned = variable => {
+  const body = findFirstBlockBodyUp(variable); // it's pretty much impossible for us to track destructuring assignments,
+  // so we return true to bailout gracefully
+
+  if (!(0, _utils2.isIdentifier)(variable.id)) {
+    return true;
+  }
 
-var _default = (0, _utils.createRule)({
+  return isValueAwaitedOrReturned(variable.id, body);
+};
+
+var _default = (0, _utils2.createRule)({
   name: __filename,
   meta: {
     docs: {
       category: 'Best Practices',
-      description: 'Enforce having return statement when testing with promises',
+      description: 'Ensure promises that have expectations in their chain are valid',
       recommended: 'error'
     },
     messages: {
-      returnPromise: 'Promise should be returned to test its fulfillment or rejection'
+      expectInFloatingPromise: "This promise should either be returned or awaited to ensure the expects in it's chain are called"
     },
     type: 'suggestion',
     schema: []
@@ -106,30 +299,106 @@ var _default = (0, _utils.createRule)({
   defaultOptions: [],
 
   create(context) {
+    let inTestCaseWithDoneCallback = false; // an array of booleans representing each promise chain we enter, with the
+    // boolean value representing if we think a given chain contains an expect
+    // in it's body.
+    //
+    // since we only care about the inner-most chain, we represent the state in
+    // reverse with the inner-most being the first item, as that makes it
+    // slightly less code to assign to by not needing to know the length
+
+    const chains = [];
     return {
       CallExpression(node) {
-        if (!isThenOrCatchCall(node) || node.parent && node.parent.type === _experimentalUtils.AST_NODE_TYPES.AwaitExpression) {
+        // there are too many ways that the done argument could be used with
+        // promises that contain expect that would make the promise safe for us
+        if (isTestCaseCallWithCallbackArg(node)) {
+          inTestCaseWithDoneCallback = true;
           return;
-        }
+        } // if this call expression is a promise chain, add it to the stack with
+        // value of "false", as we assume there are no expect calls initially
 
-        const testFunction = findTestFunction(node);
 
-        if (testFunction && !isHavingAsyncCallBackParam(testFunction)) {
-          const {
-            body
-          } = testFunction;
+        if (isPromiseChainCall(node)) {
+          chains.unshift(false);
+          return;
+        } // if we're within a promise chain, and this call expression looks like
+        // an expect call, mark the deepest chain as having an expect call
 
-          if (body.type !== _experimentalUtils.AST_NODE_TYPES.BlockStatement) {
-            return;
+
+        if (chains.length > 0 && (0, _utils2.isExpectCall)(node)) {
+          chains[0] = true;
+        }
+      },
+
+      'CallExpression:exit'(node) {
+        // there are too many ways that the "done" argument could be used to
+        // make promises containing expects safe in a test for us to be able to
+        // accurately check, so we just bail out completely if it's present
+        if (inTestCaseWithDoneCallback) {
+          if ((0, _utils2.isTestCaseCall)(node)) {
+            inTestCaseWithDoneCallback = false;
           }
 
-          const testFunctionBody = body.body; // then block can have two args, fulfillment & rejection
-          // then block can have one args, fulfillment
-          // catch block can have one args, rejection
-          // ref: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise
+          return;
+        }
+
+        if (!isPromiseChainCall(node)) {
+          return;
+        } // since we're exiting this call expression (which is a promise chain)
+        // we remove it from the stack of chains, since we're unwinding
+
 
-          verifyExpectWithReturn(node.arguments.slice(0, 2), node.callee, context, testFunctionBody);
+        const hasExpectCall = chains.shift(); // if the promise chain we're exiting doesn't contain an expect,
+        // then we don't need to check it for anything
+
+        if (!hasExpectCall) {
+          return;
+        }
+
+        const {
+          parent
+        } = 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
+
+        if (!parent || !isDirectlyWithinTestCaseCall(parent)) {
+          return;
         }
+
+        switch (parent.type) {
+          case _utils.AST_NODE_TYPES.VariableDeclarator:
+            {
+              if (isVariableAwaitedOrReturned(parent)) {
+                return;
+              }
+
+              break;
+            }
+
+          case _utils.AST_NODE_TYPES.AssignmentExpression:
+            {
+              if (parent.left.type === _utils.AST_NODE_TYPES.Identifier && isValueAwaitedOrReturned(parent.left, findFirstBlockBodyUp(parent))) {
+                return;
+              }
+
+              break;
+            }
+
+          case _utils.AST_NODE_TYPES.ExpressionStatement:
+            break;
+
+          case _utils.AST_NODE_TYPES.ReturnStatement:
+          case _utils.AST_NODE_TYPES.AwaitExpression:
+          default:
+            return;
+        }
+
+        context.report({
+          messageId: 'expectInFloatingPromise',
+          node: parent
+        });
       }
 
     };

package/lib/rules/valid-expect.js

@@ -5,9 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _experimentalUtils = require("@typescript-eslint/experimental-utils");
+var _utils = require("@typescript-eslint/utils");
 
-var _utils = require("./utils");
+var _utils2 = require("./utils");
 
 /*
  * This implementation is ported from from eslint-plugin-jasmine.
@@ -22,23 +22,29 @@ var _utils = require("./utils");
  * @Returns CallExpressionNode
  */
 const getPromiseCallExpressionNode = node => {
-  if (node.type === _experimentalUtils.AST_NODE_TYPES.ArrayExpression && node.parent && node.parent.type === _experimentalUtils.AST_NODE_TYPES.CallExpression) {
+  if (node.type === _utils.AST_NODE_TYPES.ArrayExpression && node.parent && node.parent.type === _utils.AST_NODE_TYPES.CallExpression) {
     node = node.parent;
   }
 
-  if (node.type === _experimentalUtils.AST_NODE_TYPES.CallExpression && node.callee && node.callee.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && (0, _utils.isSupportedAccessor)(node.callee.object) && (0, _utils.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) && (0, _utils2.getAccessorValue)(node.callee.object) === 'Promise' && node.parent) {
     return node;
   }
 
   return null;
 };
 
-const findPromiseCallExpressionNode = node => node.parent && node.parent.parent && [_experimentalUtils.AST_NODE_TYPES.CallExpression, _experimentalUtils.AST_NODE_TYPES.ArrayExpression].includes(node.parent.type) ? getPromiseCallExpressionNode(node.parent) : null;
+const findPromiseCallExpressionNode = node => {
+  var _node$parent;
+
+  return (_node$parent = node.parent) !== null && _node$parent !== void 0 && _node$parent.parent && [_utils.AST_NODE_TYPES.CallExpression, _utils.AST_NODE_TYPES.ArrayExpression].includes(node.parent.type) ? getPromiseCallExpressionNode(node.parent) : null;
+};
 
 const getParentIfThenified = node => {
-  const grandParentNode = node.parent && node.parent.parent;
+  var _node$parent2;
+
+  const grandParentNode = (_node$parent2 = node.parent) === null || _node$parent2 === void 0 ? void 0 : _node$parent2.parent;
 
-  if (grandParentNode && grandParentNode.type === _experimentalUtils.AST_NODE_TYPES.CallExpression && grandParentNode.callee && (0, _utils.isExpectMember)(grandParentNode.callee) && ['then', 'catch'].includes((0, _utils.getAccessorValue)(grandParentNode.callee.property)) && grandParentNode.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) {
     // Just in case `then`s are chained look one above.
     return getParentIfThenified(grandParentNode);
   }
@@ -47,25 +53,27 @@ const getParentIfThenified = node => {
 };
 
 const isAcceptableReturnNode = (node, allowReturn) => {
-  if (allowReturn && node.type === _experimentalUtils.AST_NODE_TYPES.ReturnStatement) {
+  if (allowReturn && node.type === _utils.AST_NODE_TYPES.ReturnStatement) {
     return true;
   }
 
-  if (node.type === _experimentalUtils.AST_NODE_TYPES.ConditionalExpression && node.parent) {
+  if (node.type === _utils.AST_NODE_TYPES.ConditionalExpression && node.parent) {
     return isAcceptableReturnNode(node.parent, allowReturn);
   }
 
-  return [_experimentalUtils.AST_NODE_TYPES.ArrowFunctionExpression, _experimentalUtils.AST_NODE_TYPES.AwaitExpression].includes(node.type);
+  return [_utils.AST_NODE_TYPES.ArrowFunctionExpression, _utils.AST_NODE_TYPES.AwaitExpression].includes(node.type);
 };
 
-const isNoAssertionsParentNode = node => node.type === _experimentalUtils.AST_NODE_TYPES.ExpressionStatement || node.type === _experimentalUtils.AST_NODE_TYPES.AwaitExpression && node.parent !== undefined && node.parent.type === _experimentalUtils.AST_NODE_TYPES.ExpressionStatement;
+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
 }) => `${start.line}:${start.column}-${end.line}:${end.column}`;
 
-var _default = (0, _utils.createRule)({
+const defaultAsyncMatchers = ['toReject', 'toResolve'];
+
+var _default = (0, _utils2.createRule)({
   name: __filename,
   meta: {
     docs: {
@@ -90,6 +98,12 @@ var _default = (0, _utils.createRule)({
           type: 'boolean',
           default: false
         },
+        asyncMatchers: {
+          type: 'array',
+          items: {
+            type: 'string'
+          }
+        },
         minArgs: {
           type: 'number',
           minimum: 1
@@ -104,12 +118,14 @@ var _default = (0, _utils.createRule)({
   },
   defaultOptions: [{
     alwaysAwait: false,
+    asyncMatchers: defaultAsyncMatchers,
     minArgs: 1,
     maxArgs: 1
   }],
 
   create(context, [{
     alwaysAwait,
+    asyncMatchers = defaultAsyncMatchers,
     minArgs = 1,
     maxArgs = 1
   }]) {
@@ -130,7 +146,7 @@ var _default = (0, _utils.createRule)({
 
     return {
       CallExpression(node) {
-        if (!(0, _utils.isExpectCall)(node)) {
+        if (!(0, _utils2.isExpectCall)(node)) {
           return;
         }
 
@@ -138,10 +154,10 @@ var _default = (0, _utils.createRule)({
           expect,
           modifier,
           matcher
-        } = (0, _utils.parseExpectCall)(node);
+        } = (0, _utils2.parseExpectCall)(node);
 
         if (expect.arguments.length < minArgs) {
-          const expectLength = (0, _utils.getAccessorValue)(expect.callee).length;
+          const expectLength = (0, _utils2.getAccessorValue)(expect.callee).length;
           const loc = {
             start: {
               column: node.loc.start.column + expectLength,
@@ -200,7 +216,7 @@ var _default = (0, _utils.createRule)({
           return;
         }
 
-        if ((0, _utils.isExpectMember)(matcher.node.parent)) {
+        if ((0, _utils2.isExpectMember)(matcher.node.parent)) {
           context.report({
             messageId: 'modifierUnknown',
             data: {
@@ -219,8 +235,9 @@ var _default = (0, _utils.createRule)({
         }
 
         const parentNode = matcher.node.parent;
+        const shouldBeAwaited = modifier && modifier.name !== _utils2.ModifierName.not || asyncMatchers.includes(matcher.name);
 
-        if (!parentNode.parent || !modifier || modifier.name === _utils.ModifierName.not) {
+        if (!parentNode.parent || !shouldBeAwaited) {
           return;
         }
         /**
@@ -229,7 +246,7 @@ var _default = (0, _utils.createRule)({
          */
 
 
-        const isParentArrayExpression = parentNode.parent.type === _experimentalUtils.AST_NODE_TYPES.ArrayExpression;
+        const isParentArrayExpression = parentNode.parent.type === _utils.AST_NODE_TYPES.ArrayExpression;
         const orReturned = alwaysAwait ? '' : ' or returned';
         /**
          * An async assertion can be chained with `then` or `catch` statements.
@@ -260,7 +277,7 @@ var _default = (0, _utils.createRule)({
 
       // nothing called on "expect()"
       'CallExpression:exit'(node) {
-        if ((0, _utils.isExpectCall)(node) && isNoAssertionsParentNode(node.parent)) {
+        if ((0, _utils2.isExpectCall)(node) && isNoAssertionsParentNode(node.parent)) {
           context.report({
             messageId: 'matcherNotFound',
             node