feat(prefer-find-by): add fixer for waitFor wrapping findBy queries

lib/rules/prefer-find-by.ts

@@ -2,12 +2,15 @@
 
 import { createTestingLibraryRule } from '../create-testing-library-rule';
 import {
+	getDeepestIdentifierNode,
 	isArrowFunctionExpression,
+	isBlockStatement,
 	isCallExpression,
 	isMemberExpression,
 	isObjectExpression,
 	isObjectPattern,
 	isProperty,
+	isVariableDeclaration,
 } from '../node-utils';
 import { getScope, getSourceCode } from '../utils';
 
@@ -21,6 +24,10 @@
 	return queryMethod.includes('All') ? 'findAllBy' : 'findBy';
 }
 
+function isFindByQuery(name: string): boolean {
+	return /^find(All)?By/.test(name);
+}
+
 function findRenderDefinitionDeclaration(
 	scope: TSESLint.Scope.Scope | null,
 	query: string
@@ -329,20 +336,82 @@
 		}
 
 		return {
-			'AwaitExpression > CallExpression'(node: TSESTree.CallExpression) {
+			'AwaitExpression > CallExpression'(
+				node: TSESTree.CallExpression & { parent: TSESTree.AwaitExpression }
+			) {
 				if (
 					!ASTUtils.isIdentifier(node.callee) ||
 					!helpers.isAsyncUtil(node.callee, ['waitFor'])
 				) {
 					return;
 				}
-				// ensure the only argument is an arrow function expression - if the arrow function is a block
-				// we skip it
+				// ensure the only argument is an arrow function expression
 				const argument = node.arguments[0];
-				if (
-					!isArrowFunctionExpression(argument) ||
-					!isCallExpression(argument.body)
-				) {
+
+				if (!isArrowFunctionExpression(argument)) {
+					return;
+				}
+
+				if (isBlockStatement(argument.body) && argument.async) {
+					const { body } = argument.body;
+					const declarations = body
+						.filter(isVariableDeclaration)
+						?.flatMap((declaration) => declaration.declarations);
+
+					const findByDeclarator = declarations.find((declaration) => {
+						if (
+							!ASTUtils.isAwaitExpression(declaration.init) ||
+							!isCallExpression(declaration.init.argument)
+						) {
+							return false;
+						}
+
+						const { callee } = declaration.init.argument;
+
+						const name = getDeepestIdentifierNode(callee)?.name;
+						return name ? isFindByQuery(name) : false;
+					});
+
+					const init = ASTUtils.isAwaitExpression(findByDeclarator?.init)
+						? findByDeclarator.init?.argument
+						: null;
+
+					if (!isCallExpression(init)) {
+						return;
+					}
+					const queryIdentifier = getDeepestIdentifierNode(init.callee);
+
+					if (!queryIdentifier || !helpers.isAsyncQuery(queryIdentifier)) {
+						return;
+					}
+
+					const fullQueryMethod = queryIdentifier.name;
+					const queryMethod = fullQueryMethod.split('By')[1];
+					const queryVariant = getFindByQueryVariant(fullQueryMethod);
+
+					reportInvalidUsage(node, {
+						queryMethod,
+						queryVariant,
+						prevQuery: fullQueryMethod,
+						fix(fixer) {
+							const { parent: expressionStatement } = node.parent;
+							const bodyText = sourceCode
+								.getText(argument.body)
+								.slice(1, -1)
+								.trim();
+							const { line, column } = expressionStatement.loc.start;
+							const indent = sourceCode.getLines()[line - 1].slice(0, column);
+							const newText = bodyText
+								.split('\n')
+								.map((line) => line.trim())
+								.join(`\n${indent}`);
+							return fixer.replaceText(expressionStatement, newText);
+						},
+					});
+					return;
+				}
+
+				if (!isCallExpression(argument.body)) {
 					return;
 				}
 

tests/lib/rules/prefer-find-by.test.ts

@@ -689,6 +689,35 @@ ruleTester.run(RULE_NAME, rule, {
 		  const button = await screen.${buildFindByMethod(
 				queryMethod
 			)}('Count is: 0', { timeout: 100, interval: 200 })
+        `,
+		})),
+		...ASYNC_QUERIES_COMBINATIONS.map((queryMethod) => ({
+			code: `
+				import {waitFor} from '${testingFramework}';
+				it('tests', async () => {
+					await waitFor(async () => {
+						const button = await screen.${queryMethod}("button", { name: "Submit" })
+						expect(button).toBeInTheDocument()
+					})
+				})
+        `,
+			errors: [
+				{
+					messageId: 'preferFindBy',
+					data: {
+						queryVariant: getFindByQueryVariant(queryMethod),
+						queryMethod: queryMethod.split('By')[1],
+						prevQuery: queryMethod,
+						waitForMethodName: 'waitFor',
+					},
+				},
+			],
+			output: `
+				import {waitFor} from '${testingFramework}';
+				it('tests', async () => {
+					const button = await screen.${queryMethod}("button", { name: "Submit" })
+					expect(button).toBeInTheDocument()
+				})
         `,
 		})),
 	]),