test(await-async-query): increase coverage

Author: Belco90

lib/node-utils.ts

@@ -266,10 +266,17 @@ export function getVariableReferences(
   );
 }
 
+interface InnermostFunctionScope extends TSESLintScope.FunctionScope {
+  block:
+    | TSESTree.FunctionDeclaration
+    | TSESTree.FunctionExpression
+    | TSESTree.ArrowFunctionExpression;
+}
+
 export function getInnermostFunctionScope(
   context: RuleContext<string, []>,
   asyncQueryNode: TSESTree.Identifier
-): TSESLintScope.FunctionScope | null {
+): InnermostFunctionScope | null {
   const innermostScope = ASTUtils.getInnermostScope(
     context.getScope(),
     asyncQueryNode
@@ -279,7 +286,7 @@ export function getInnermostFunctionScope(
     innermostScope?.type === 'function' &&
     ASTUtils.isFunction(innermostScope.block)
   ) {
-    return (innermostScope as unknown) as TSESLintScope.FunctionScope;
+    return (innermostScope as unknown) as InnermostFunctionScope;
   }
 
   return null;
@@ -314,17 +321,12 @@ export function getIdentifierNode(
     return node;
   }
 
-  if (isCallExpression(node)) {
-    const callExpressionCallee = node.callee;
+  if (isMemberExpression(node) && ASTUtils.isIdentifier(node.property)) {
+    return node.property;
+  }
 
-    if (ASTUtils.isIdentifier(callExpressionCallee)) {
-      return callExpressionCallee;
-    } else if (
-      isMemberExpression(callExpressionCallee) &&
-      ASTUtils.isIdentifier(callExpressionCallee.property)
-    ) {
-      return callExpressionCallee.property;
-    }
+  if (isCallExpression(node)) {
+    return getIdentifierNode(node.callee);
   }
 
   return null;

lib/rules/await-async-query.ts

@@ -39,7 +39,7 @@ export default createTestingLibraryRule<Options, MessageIds>({
     function detectAsyncQueryWrapper(node: TSESTree.Identifier) {
       const functionScope = getInnermostFunctionScope(context, node);
 
-      if (functionScope && ASTUtils.isFunction(functionScope.block)) {
+      if (functionScope) {
         // save function wrapper calls rather than async calls to be reported later
         const returnStatementNode = getFunctionReturnStatementNode(
           functionScope.block
@@ -62,6 +62,7 @@ export default createTestingLibraryRule<Options, MessageIds>({
     return {
       'CallExpression Identifier'(node: TSESTree.Identifier) {
         if (helpers.isAsyncQuery(node)) {
+          // detect async query used within wrapper function for later analysis
           detectAsyncQueryWrapper(node);
 
           const closestCallExpressionNode = findClosestCallExpressionNode(
@@ -78,6 +79,8 @@ export default createTestingLibraryRule<Options, MessageIds>({
             closestCallExpressionNode.parent
           );
 
+          // check direct usage of async query:
+          //  const element = await findByRole('button')
           if (references && references.length === 0) {
             if (!isPromiseHandled(node)) {
               return context.report({
@@ -88,6 +91,9 @@ export default createTestingLibraryRule<Options, MessageIds>({
             }
           }
 
+          // check references usages of async query:
+          //  const promise = findByRole('button')
+          //  const element = await promise
           for (const reference of references) {
             if (
               ASTUtils.isIdentifier(reference.identifier) &&
@@ -101,6 +107,7 @@ export default createTestingLibraryRule<Options, MessageIds>({
             }
           }
         } else if (functionWrappersNames.includes(node.name)) {
+          // check async queries used within a wrapper previously detected
           if (!isPromiseHandled(node)) {
             return context.report({
               node,

tests/lib/rules/await-async-query.test.ts

@@ -125,8 +125,10 @@ ruleTester.run(RULE_NAME, rule, {
     // async queries are valid with promise in variable and returned in regular function
     ...createTestCase(
       (query) => `
-        const promise = ${query}('foo')
-        return promise
+        async function queryWrapper() {
+          const promise = ${query}('foo')
+          return promise
+        }
       `
     ),
 
@@ -169,10 +171,41 @@ ruleTester.run(RULE_NAME, rule, {
 
     // non-matching query is valid
     `
-    test('An example test', async () => {
+    test('An valid example test', async () => {
       const example = findText("my example")
     })
     `,
+
+    // unhandled promise from non-matching query is valid
+    `
+    async function findButton() {
+      const element = findByText('outer element')
+      return somethingElse(element)
+    }
+
+    test('An valid example test', async () => {
+      // findButton doesn't match async query pattern
+      const button = findButton()
+    })
+    `,
+
+    // edge case for coverage
+    // return non-matching query and other than Identifier or CallExpression
+    `
+    async function someSetup() {
+      const element = await findByText('outer element')
+      return element ? findSomethingElse(element) : null
+    }
+
+    test('An valid example test', async () => {
+      someSetup()
+    })
+    `,
+
+    // edge case for coverage
+    // valid async query usage without any function defined
+    // so there is no innermost function scope found
+    `const element = await findByRole('button')`,
   ],
 
   invalid: [