fix: silence false positive await-async-events reports

Author: Chamion

lib/node-utils/index.ts

@@ -258,6 +258,46 @@ export function isPromiseHandled(nodeIdentifier: TSESTree.Identifier): boolean {
 	return false;
 }
 
+/**
+ * For an expression in a parent expression that evaluates to the expression or another child returns the parent node recursively.
+ */
+function getRootExpression(
+	expression: TSESTree.Expression
+): TSESTree.Expression {
+	const { parent } = expression;
+	if (parent == null) return expression;
+	switch (parent.type) {
+		case AST_NODE_TYPES.ConditionalExpression:
+		case AST_NODE_TYPES.LogicalExpression:
+			return getRootExpression(parent);
+		case AST_NODE_TYPES.SequenceExpression:
+			return parent.expressions[parent.expressions.length - 1] === expression
+				? getRootExpression(parent)
+				: expression;
+		default:
+			return expression;
+	}
+}
+
+/**
+ * Determines whether a given promise expression is considered unhandled.
+ *
+ * It will be considered unhandled if an ancestor voids the expression.
+ */
+export function isPromiseUnhandled(expression: TSESTree.Expression): boolean {
+	const { parent } = getRootExpression(expression);
+	if (parent == null) return false;
+	switch (parent.type) {
+		case AST_NODE_TYPES.ExpressionStatement:
+		case AST_NODE_TYPES.SequenceExpression:
+		case AST_NODE_TYPES.UnaryExpression:
+		case AST_NODE_TYPES.VariableDeclarator:
+			return true;
+		default:
+			return false;
+	}
+}
+
 export function getVariableReferences(
 	context: TSESLint.RuleContext<string, unknown[]>,
 	node: TSESTree.Node

lib/rules/await-async-events.ts

@@ -8,7 +8,7 @@ import {
 	getInnermostReturningFunction,
 	getVariableReferences,
 	isMemberExpression,
-	isPromiseHandled,
+	isPromiseUnhandled,
 } from '../node-utils';
 import { EVENTS_SIMULATORS } from '../utils';
 
@@ -91,7 +91,7 @@ export default createTestingLibraryRule<Options, MessageIds>({
 			messageId?: MessageIds;
 			fix?: TSESLint.ReportFixFunction;
 		}): void {
-			if (!isPromiseHandled(node)) {
+			if (isPromiseUnhandled(closestCallExpression)) {
 				context.report({
 					node: closestCallExpression.callee,
 					messageId,
@@ -176,13 +176,17 @@ export default createTestingLibraryRule<Options, MessageIds>({
 							},
 						});
 					} else {
-						for (const reference of references) {
-							if (ASTUtils.isIdentifier(reference.identifier)) {
-								reportUnhandledNode({
-									node: reference.identifier,
-									closestCallExpression,
-								});
-							}
+						const referenceIdentifiers = references
+							.map(({ identifier }) => identifier)
+							.filter(ASTUtils.isIdentifier);
+						if (referenceIdentifiers.every(isPromiseUnhandled)) {
+							referenceIdentifiers.forEach(
+								(id) =>
+									void reportUnhandledNode({
+										node: id,
+										closestCallExpression,
+									})
+							);
 						}
 					}
 				} else if (functionWrappersNames.includes(node.name)) {

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

@@ -311,6 +311,17 @@ ruleTester.run(RULE_NAME, rule, {
   
           await triggerEvent()
         })
+        `,
+				options: [{ eventModule: 'userEvent' }] as const,
+			})),
+			...USER_EVENT_ASYNC_FUNCTIONS.map((eventMethod) => ({
+				code: `
+        import userEvent from '${testingFramework}'
+        test('await expression that evaluates to promise is valid', async () => {
+          await (null, userEvent.${eventMethod}(getByLabelText('username')));
+		  await (condition ? null : userEvent.${eventMethod}(getByLabelText('username')));
+		  await (condition && userEvent.${eventMethod}(getByLabelText('username')));
+        })
         `,
 				options: [{ eventModule: 'userEvent' }] as const,
 			})),
@@ -960,6 +971,66 @@ ruleTester.run(RULE_NAME, rule, {
       }
 
       triggerEvent()
+      `,
+					} as const)
+			),
+			...USER_EVENT_ASYNC_FUNCTIONS.map(
+				(eventMethod) =>
+					({
+						code: `
+		import userEvent from '${testingFramework}'
+		test('unhandled expression that evaluates to promise is invalid', () => {
+			condition ? null : (null, true && userEvent.${eventMethod}(getByLabelText('username')));
+		});
+      `,
+						errors: [
+							{
+								line: 4,
+								column: 38,
+								messageId: 'awaitAsyncEvent',
+								data: { name: eventMethod },
+							},
+						],
+						options: [{ eventModule: 'userEvent' }],
+						output: `
+		import userEvent from '${testingFramework}'
+		test('unhandled expression that evaluates to promise is invalid', async () => {
+			condition ? null : (null, true && await userEvent.${eventMethod}(getByLabelText('username')));
+		});
+      `,
+					} as const)
+			),
+			...USER_EVENT_ASYNC_FUNCTIONS.map(
+				(eventMethod) =>
+					({
+						code: `
+		import userEvent from '${testingFramework}'
+		test('voided promise is invalid', async () => {
+			await void userEvent.${eventMethod}(getByLabelText('username'));
+			await (userEvent.${eventMethod}(getByLabelText('username')), null);
+		});
+      `,
+						errors: [
+							{
+								line: 4,
+								column: 15,
+								messageId: 'awaitAsyncEvent',
+								data: { name: eventMethod },
+							},
+							{
+								line: 5,
+								column: 11,
+								messageId: 'awaitAsyncEvent',
+								data: { name: eventMethod },
+							},
+						],
+						options: [{ eventModule: 'userEvent' }],
+						output: `
+		import userEvent from '${testingFramework}'
+		test('voided promise is invalid', async () => {
+			await void await userEvent.${eventMethod}(getByLabelText('username'));
+			await (await userEvent.${eventMethod}(getByLabelText('username')), null);
+		});
       `,
 					} as const)
 			),