Merge branch 'main' into fix/no-node-access-assignment-case

Author: Belco90

lib/rules/await-async-utils.ts

@@ -121,20 +121,29 @@ export default createTestingLibraryRule<Options, MessageIds>({
 					functionWrappersNames.push((node.id as TSESTree.Identifier).name);
 				}
 			},
-			'CallExpression Identifier'(node: TSESTree.Identifier) {
+			CallExpression(node: TSESTree.CallExpression) {
+				const callExpressionIdentifier = getDeepestIdentifierNode(node);
+
+				if (!callExpressionIdentifier) {
+					return;
+				}
+
 				const isAsyncUtilOrKnownAliasAroundIt =
-					helpers.isAsyncUtil(node) ||
-					functionWrappersNames.includes(node.name);
+					helpers.isAsyncUtil(callExpressionIdentifier) ||
+					functionWrappersNames.includes(callExpressionIdentifier.name);
 				if (!isAsyncUtilOrKnownAliasAroundIt) {
 					return;
 				}
 
 				// detect async query used within wrapper function for later analysis
-				if (helpers.isAsyncUtil(node)) {
-					detectAsyncUtilWrapper(node);
+				if (helpers.isAsyncUtil(callExpressionIdentifier)) {
+					detectAsyncUtilWrapper(callExpressionIdentifier);
 				}
 
-				const closestCallExpression = findClosestCallExpressionNode(node, true);
+				const closestCallExpression = findClosestCallExpressionNode(
+					callExpressionIdentifier,
+					true
+				);
 
 				if (!closestCallExpression?.parent) {
 					return;
@@ -146,12 +155,12 @@ export default createTestingLibraryRule<Options, MessageIds>({
 				);
 
 				if (references.length === 0) {
-					if (!isPromiseHandled(node)) {
+					if (!isPromiseHandled(callExpressionIdentifier)) {
 						context.report({
-							node,
-							messageId: getMessageId(node),
+							node: callExpressionIdentifier,
+							messageId: getMessageId(callExpressionIdentifier),
 							data: {
-								name: node.name,
+								name: callExpressionIdentifier.name,
 							},
 						});
 					}
@@ -160,10 +169,10 @@ export default createTestingLibraryRule<Options, MessageIds>({
 						const referenceNode = reference.identifier as TSESTree.Identifier;
 						if (!isPromiseHandled(referenceNode)) {
 							context.report({
-								node,
-								messageId: getMessageId(node),
+								node: callExpressionIdentifier,
+								messageId: getMessageId(callExpressionIdentifier),
 								data: {
-									name: node.name,
+									name: callExpressionIdentifier.name,
 								},
 							});
 							return;

lib/rules/no-node-access.ts

@@ -1,10 +1,20 @@
+import {
+	DefinitionType,
+	type ScopeVariable,
+} from '@typescript-eslint/scope-manager';
 import { TSESTree, ASTUtils } from '@typescript-eslint/utils';
 
 import { createTestingLibraryRule } from '../create-testing-library-rule';
-import { isCallExpression, isMemberExpression } from '../node-utils';
+import {
+	getDeepestIdentifierNode,
+	getPropertyIdentifierNode,
+	isCallExpression,
+	isMemberExpression,
+} from '../node-utils';
 import {
 	ALL_RETURNING_NODES,
 	EVENT_HANDLER_METHODS,
+	getScope,
 	resolveToTestingLibraryFn,
 } from '../utils';
 
@@ -89,24 +99,39 @@ export default createTestingLibraryRule<Options, MessageIds>({
 			}
 		}
 
+		function detectTestingLibraryFn(
+			node: TSESTree.CallExpression,
+			variable: ScopeVariable | null
+		) {
+			if (variable && variable.defs.length > 0) {
+				const def = variable.defs[0];
+				if (
+					def.type === DefinitionType.Variable &&
+					isCallExpression(def.node.init)
+				) {
+					return resolveToTestingLibraryFn(def.node.init, context);
+				}
+			}
+
+			return resolveToTestingLibraryFn(node, context);
+		}
+
 		return {
 			CallExpression(node: TSESTree.CallExpression) {
-				const { callee } = node;
-				const property = isMemberExpression(callee) ? callee.property : null;
-				const object = isMemberExpression(callee) ? callee.object : null;
-
-				const propertyName = ASTUtils.isIdentifier(property)
-					? property.name
-					: null;
-				const objectName = ASTUtils.isIdentifier(object) ? object.name : null;
+				const property = getDeepestIdentifierNode(node);
+				const identifier = getPropertyIdentifierNode(node);
 
 				const isEventHandlerMethod = EVENT_HANDLER_METHODS.some(
-					(method) => method === propertyName
+					(method) => method === property?.name
 				);
 				const hasUserEventInstanceName = userEventInstanceNames.has(
-					objectName ?? ''
+					identifier?.name ?? ''
 				);
-				const testingLibraryFn = resolveToTestingLibraryFn(node, context);
+
+				const variable = identifier
+					? ASTUtils.findVariable(getScope(context, node), identifier)
+					: null;
+				const testingLibraryFn = detectTestingLibraryFn(node, variable);
 
 				if (
 					!testingLibraryFn &&

package.json

@@ -82,7 +82,7 @@
 		"is-ci": "^3.0.1",
 		"jest": "^29.7.0",
 		"lint-staged": "^15.2.10",
-		"prettier": "3.3.3",
+		"prettier": "3.6.2",
 		"semantic-release": "^24.2.0",
 		"semver": "^7.6.3",
 		"ts-node": "^10.9.2",

pnpm-lock.yaml

@@ -113,6 +113,11 @@ ruleTester.run(RULE_NAME, rule, {
 			testingFramework: '@marko/testing-library',
 		}),
 
+		// async queries not called are valid
+		...createTestCase((query) => `expect(screen.${query}).toBeDefined()`, {
+			isAsync: false,
+		}),
+
 		// async queries are valid with await operator
 		...createTestCase(
 			(query) => `

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

@@ -31,6 +31,14 @@ ruleTester.run(RULE_NAME, rule, {
           const aPromise = ${asyncUtil}(() => getByLabelText('email'));
           await aPromise;
         });
+      `,
+		})),
+		...ASYNC_UTILS.map((asyncUtil) => ({
+			code: `
+        import { ${asyncUtil} } from '${testingFramework}';
+        test('${asyncUtil} util not called is valid', () => {
+          expect(${asyncUtil}).toBeDefined();
+        });
       `,
 		})),
 		...ASYNC_UTILS.map((asyncUtil) => ({
@@ -286,6 +294,23 @@ ruleTester.run(RULE_NAME, rule, {
         test('edge case for no innermost function scope', () => {
           const foo = waitFor
         })
+      `,
+		},
+		{
+			// edge case for coverage: CallExpressions without deepest identifiers
+			code: `
+        import { waitFor } from '${testingFramework}';
+        test('coverage test for CallExpressions without identifiers', () => {
+          const asyncUtil = waitFor
+
+          // These CallExpressions have no deepest identifier:
+          const funcs = [() => console.log('test')]
+          const obj = { [Symbol.iterator]: () => 'symbol' }
+
+          funcs[0]()
+          obj[Symbol.iterator]()
+          (function() { return 'iife' })()
+        });
       `,
 		},
 		...ASYNC_UTILS.map((asyncUtil) => ({

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

@@ -181,6 +181,16 @@ ruleTester.run(RULE_NAME, rule, {
         const buttonText = screen.getByText('submit');
 				const userAlias = userEvent.setup();
 				userAlias.click(buttonText);
+      `,
+			},
+			{
+				code: `
+				import userEvent from '@testing-library/user-event';
+				import { screen } from '${testingFramework}';
+				test('...', () => {
+					const buttonText = screen.getByText('submit');
+					(() => { click: userEvent.click(buttonText); })();
+				});
       `,
 			},
 			{
@@ -278,7 +288,6 @@ ruleTester.run(RULE_NAME, rule, {
 			},
 			{
 				code: `
-				// case: custom module set but not imported using ${testingFramework} (aggressive reporting limited)
 				import { screen } from '${testingFramework}';
 
         const ui = {
@@ -288,6 +297,48 @@ ruleTester.run(RULE_NAME, rule, {
 					const select = ui.select.get();
 					expect(select).toHaveClass(selectClasses.select);
 				});
+      `,
+			},
+			{
+				settings: { 'testing-library/utils-module': 'test-utils' },
+				code: `
+				// case: custom module set but not imported using ${testingFramework} (aggressive reporting limited)
+        import { screen, render } from 'test-utils';
+				import MyComponent from './MyComponent'
+
+				test('...', async () => {
+					const { user } = render(<MyComponent />)
+					await user.click(screen.getByRole("button"))
+				});
+      `,
+			},
+			{
+				settings: { 'testing-library/utils-module': 'test-utils' },
+				code: `
+				// case: custom module set but not imported using ${testingFramework} (aggressive reporting limited)
+        import { screen, render } from 'test-utils';
+				import MyComponent from './MyComponent'
+
+				test('...', async () => {
+					const result = render(<MyComponent />)
+					await result.user.click(screen.getByRole("button"))
+				});
+      `,
+			},
+			{
+				settings: {
+					'testing-library/utils-module': 'TestUtils',
+					'testing-library/custom-renders': ['renderComponent'],
+				},
+				code: `
+				// case: custom module set but not imported using ${testingFramework} (aggressive reporting limited)
+        import { screen, renderComponent } from './TestUtils';
+				import MyComponent from './MyComponent'
+
+				test('...', async () => {
+					const result = renderComponent(<MyComponent />)
+					await result.user.click(screen.getByRole("button"))
+				});
       `,
 			},
 		]