detect-testing-library-utils.ts

import { ASTUtils, TSESLint, TSESTree } from '@typescript-eslint/utils';

import {
	findClosestVariableDeclaratorNode,
	findImportSpecifier,
	getAssertNodeInfo,
	getDeepestIdentifierNode,
	getImportModuleName,
	getPropertyIdentifierNode,
	getReferenceNode,
	hasImportMatch,
	ImportModuleNode,
	isCallExpression,
	isImportDeclaration,
	isImportDefaultSpecifier,
	isImportSpecifier,
	isLiteral,
	isMemberExpression,
} from '../node-utils';
import {
	ABSENCE_MATCHERS,
	ALL_QUERIES_COMBINATIONS,
	ASYNC_UTILS,
	DEBUG_UTILS,
	PRESENCE_MATCHERS,
} from '../utils';

const SETTING_OPTION_OFF = 'off' as const;

export type TestingLibrarySettings = {
	'testing-library/utils-module'?: string | typeof SETTING_OPTION_OFF;
	'testing-library/custom-renders'?: string[] | typeof SETTING_OPTION_OFF;
	'testing-library/custom-queries'?: string[] | typeof SETTING_OPTION_OFF;
};

export type TestingLibraryContext<
	TOptions extends readonly unknown[],
	TMessageIds extends string
> = Readonly<
	TSESLint.RuleContext<TMessageIds, TOptions> & {
		settings: TestingLibrarySettings;
	}
>;

export type EnhancedRuleCreate<
	TOptions extends readonly unknown[],
	TMessageIds extends string,
	TRuleListener extends TSESLint.RuleListener = TSESLint.RuleListener
> = (
	context: TestingLibraryContext<TOptions, TMessageIds>,
	optionsWithDefault: Readonly<TOptions>,
	detectionHelpers: Readonly<DetectionHelpers>
) => TRuleListener;

// Helpers methods
type GetTestingLibraryImportNodeFn = () => ImportModuleNode | null;
type GetTestingLibraryImportNodesFn = () => ImportModuleNode[];
type GetCustomModuleImportNodeFn = () => ImportModuleNode | null;
type GetTestingLibraryImportNameFn = () => string | undefined;
type GetCustomModuleImportNameFn = () => string | undefined;
type IsTestingLibraryImportedFn = (isStrict?: boolean) => boolean;
type IsGetQueryVariantFn = (node: TSESTree.Identifier) => boolean;
type IsQueryQueryVariantFn = (node: TSESTree.Identifier) => boolean;
type IsFindQueryVariantFn = (node: TSESTree.Identifier) => boolean;
type IsSyncQueryFn = (node: TSESTree.Identifier) => boolean;
type IsAsyncQueryFn = (node: TSESTree.Identifier) => boolean;
type IsQueryFn = (node: TSESTree.Identifier) => boolean;
type IsCustomQueryFn = (node: TSESTree.Identifier) => boolean;
type IsBuiltInQueryFn = (node: TSESTree.Identifier) => boolean;
type IsAsyncUtilFn = (
	node: TSESTree.Identifier,
	validNames?: readonly typeof ASYNC_UTILS[number][]
) => boolean;
type IsFireEventMethodFn = (node: TSESTree.Identifier) => boolean;
type IsUserEventMethodFn = (node: TSESTree.Identifier) => boolean;
type IsRenderUtilFn = (node: TSESTree.Identifier) => boolean;
type IsCreateEventUtil = (
	node: TSESTree.CallExpression | TSESTree.Identifier
) => boolean;
type IsRenderVariableDeclaratorFn = (
	node: TSESTree.VariableDeclarator
) => boolean;
type IsDebugUtilFn = (
	identifierNode: TSESTree.Identifier,
	validNames?: ReadonlyArray<typeof DEBUG_UTILS[number]>
) => boolean;
type IsPresenceAssertFn = (node: TSESTree.MemberExpression) => boolean;
type IsAbsenceAssertFn = (node: TSESTree.MemberExpression) => boolean;
type CanReportErrorsFn = () => boolean;
type FindImportedTestingLibraryUtilSpecifierFn = (
	specifierName: string
) => TSESTree.Identifier | TSESTree.ImportClause | undefined;
type IsNodeComingFromTestingLibraryFn = (
	node: TSESTree.Identifier | TSESTree.MemberExpression
) => boolean;

export interface DetectionHelpers {
	getTestingLibraryImportNode: GetTestingLibraryImportNodeFn;
	getAllTestingLibraryImportNodes: GetTestingLibraryImportNodesFn;
	getCustomModuleImportNode: GetCustomModuleImportNodeFn;
	getTestingLibraryImportName: GetTestingLibraryImportNameFn;
	getCustomModuleImportName: GetCustomModuleImportNameFn;
	isTestingLibraryImported: IsTestingLibraryImportedFn;
	isTestingLibraryUtil: (node: TSESTree.Identifier) => boolean;
	isGetQueryVariant: IsGetQueryVariantFn;
	isQueryQueryVariant: IsQueryQueryVariantFn;
	isFindQueryVariant: IsFindQueryVariantFn;
	isSyncQuery: IsSyncQueryFn;
	isAsyncQuery: IsAsyncQueryFn;
	isQuery: IsQueryFn;
	isCustomQuery: IsCustomQueryFn;
	isBuiltInQuery: IsBuiltInQueryFn;
	isAsyncUtil: IsAsyncUtilFn;
	isFireEventUtil: (node: TSESTree.Identifier) => boolean;
	isUserEventUtil: (node: TSESTree.Identifier) => boolean;
	isFireEventMethod: IsFireEventMethodFn;
	isUserEventMethod: IsUserEventMethodFn;
	isRenderUtil: IsRenderUtilFn;
	isCreateEventUtil: IsCreateEventUtil;
	isRenderVariableDeclarator: IsRenderVariableDeclaratorFn;
	isDebugUtil: IsDebugUtilFn;
	isActUtil: (node: TSESTree.Identifier) => boolean;
	isPresenceAssert: IsPresenceAssertFn;
	isAbsenceAssert: IsAbsenceAssertFn;
	canReportErrors: CanReportErrorsFn;
	findImportedTestingLibraryUtilSpecifier: FindImportedTestingLibraryUtilSpecifierFn;
	isNodeComingFromTestingLibrary: IsNodeComingFromTestingLibraryFn;
}

const USER_EVENT_PACKAGE = '@testing-library/user-event';
const REACT_DOM_TEST_UTILS_PACKAGE = 'react-dom/test-utils';
const FIRE_EVENT_NAME = 'fireEvent';
const CREATE_EVENT_NAME = 'createEvent';
const USER_EVENT_NAME = 'userEvent';
const RENDER_NAME = 'render';
const EXCLUDED_FIND_BY_QUERIES = [
	//react-test-renderer utils
	'findByType',
	'findByProps',
	'findAll',
	'findAllByType',
	'findAllByProps',
];

export type DetectionOptions = {
	/**
	 * If true, force `detectTestingLibraryUtils` to skip `canReportErrors`
	 * so it doesn't opt-out rule listener.
	 *
	 * Useful when some rule apply to files other than testing ones
	 * (e.g. `consistent-data-testid`)
	 */
	skipRuleReportingCheck: boolean;
};

/**
 * Enhances a given rule `create` with helpers to detect Testing Library utils.
 */
export function detectTestingLibraryUtils<
	TOptions extends readonly unknown[],
	TMessageIds extends string,
	TRuleListener extends TSESLint.RuleListener = TSESLint.RuleListener
>(
	ruleCreate: EnhancedRuleCreate<TOptions, TMessageIds, TRuleListener>,
	{ skipRuleReportingCheck = false }: Partial<DetectionOptions> = {}
) {
	return (
		context: TestingLibraryContext<TOptions, TMessageIds>,
		optionsWithDefault: Readonly<TOptions>
	): TSESLint.RuleListener => {
		const importedTestingLibraryNodes: ImportModuleNode[] = [];
		let importedCustomModuleNode: ImportModuleNode | null = null;
		let importedUserEventLibraryNode: ImportModuleNode | null = null;
		let importedReactDomTestUtilsNode: ImportModuleNode | null = null;

		// Init options based on shared ESLint settings
		const customModuleSetting =
			context.settings['testing-library/utils-module'];
		const customRendersSetting =
			context.settings['testing-library/custom-renders'];
		const customQueriesSetting =
			context.settings['testing-library/custom-queries'];

		/**
		 * Small method to extract common checks to determine whether a node is
		 * related to Testing Library or not.
		 *
		 * To determine whether a node is a valid Testing Library util, there are
		 * two conditions to match:
		 * - it's named in a particular way (decided by given callback)
		 * - it's imported from valid Testing Library module (depends on aggressive
		 *    reporting)
		 */
		function isPotentialTestingLibraryFunction(
			node: TSESTree.Identifier | null | undefined,
			isPotentialFunctionCallback: (
				identifierNodeName: string,
				originalNodeName?: string
			) => boolean
		): boolean {
			if (!node) {
				return false;
			}

			const referenceNode = getReferenceNode(node);
			const referenceNodeIdentifier = getPropertyIdentifierNode(referenceNode);

			if (!referenceNodeIdentifier) {
				return false;
			}

			const importedUtilSpecifier = getTestingLibraryImportedUtilSpecifier(
				referenceNodeIdentifier
			);

			const originalNodeName =
				isImportSpecifier(importedUtilSpecifier) &&
				importedUtilSpecifier.local.name !== importedUtilSpecifier.imported.name
					? importedUtilSpecifier.imported.name
					: undefined;

			if (!isPotentialFunctionCallback(node.name, originalNodeName)) {
				return false;
			}

			if (isAggressiveModuleReportingEnabled()) {
				return true;
			}

			return isNodeComingFromTestingLibrary(referenceNodeIdentifier);
		}

		/**
		 * Determines whether aggressive module reporting is enabled or not.
		 *
		 * This aggressive reporting mechanism is considered as enabled when custom
		 * module is not set, so we need to assume everything matching Testing
		 * Library utils is related to Testing Library no matter from where module
		 * they are coming from. Otherwise, this aggressive reporting mechanism is
		 * opted-out in favour to report only those utils coming from Testing
		 * Library package or custom module set up on settings.
		 */
		const isAggressiveModuleReportingEnabled = () => !customModuleSetting;

		/**
		 * Determines whether aggressive render reporting is enabled or not.
		 *
		 * This aggressive reporting mechanism is considered as enabled when custom
		 * renders are not set, so we need to assume every method containing
		 * "render" is a valid Testing Library `render`. Otherwise, this aggressive
		 * reporting mechanism is opted-out in favour to report only `render` or
		 * names set up on custom renders setting.
		 */
		const isAggressiveRenderReportingEnabled = (): boolean => {
			const isSwitchedOff = customRendersSetting === SETTING_OPTION_OFF;
			const hasCustomOptions =
				Array.isArray(customRendersSetting) && customRendersSetting.length > 0;

			return !isSwitchedOff && !hasCustomOptions;
		};

		/**
		 * Determines whether Aggressive Reporting for queries is enabled or not.
		 *
		 * This Aggressive Reporting mechanism is considered as enabled when custom-queries setting is not set,
		 * so the plugin needs to report both built-in and custom queries.
		 * Otherwise, this Aggressive Reporting mechanism is opted-out in favour of reporting only built-in queries + those
		 * indicated in custom-queries setting.
		 */
		const isAggressiveQueryReportingEnabled = (): boolean => {
			const isSwitchedOff = customQueriesSetting === SETTING_OPTION_OFF;
			const hasCustomOptions =
				Array.isArray(customQueriesSetting) && customQueriesSetting.length > 0;

			return !isSwitchedOff && !hasCustomOptions;
		};

		const getCustomModule = (): string | undefined => {
			if (
				!isAggressiveModuleReportingEnabled() &&
				customModuleSetting !== SETTING_OPTION_OFF
			) {
				return customModuleSetting;
			}
			return undefined;
		};

		const getCustomRenders = (): string[] => {
			if (
				!isAggressiveRenderReportingEnabled() &&
				customRendersSetting !== SETTING_OPTION_OFF
			) {
				return customRendersSetting as string[];
			}

			return [];
		};

		const getCustomQueries = (): string[] => {
			if (
				!isAggressiveQueryReportingEnabled() &&
				customQueriesSetting !== SETTING_OPTION_OFF
			) {
				return customQueriesSetting as string[];
			}

			return [];
		};

		// Helpers for Testing Library detection.
		const getTestingLibraryImportNode: GetTestingLibraryImportNodeFn = () => {
			return importedTestingLibraryNodes[0];
		};

		const getAllTestingLibraryImportNodes: GetTestingLibraryImportNodesFn =
			() => {
				return importedTestingLibraryNodes;
			};

		const getCustomModuleImportNode: GetCustomModuleImportNodeFn = () => {
			return importedCustomModuleNode;
		};

		const getTestingLibraryImportName: GetTestingLibraryImportNameFn = () => {
			return getImportModuleName(importedTestingLibraryNodes[0]);
		};

		const getCustomModuleImportName: GetCustomModuleImportNameFn = () => {
			return getImportModuleName(importedCustomModuleNode);
		};

		/**
		 * Determines whether Testing Library utils are imported or not for
		 * current file being analyzed.
		 *
		 * By default, it is ALWAYS considered as imported. This is what we call
		 * "aggressive reporting" so we don't miss TL utils reexported from
		 * custom modules.
		 *
		 * However, there is a setting to customize the module where TL utils can
		 * be imported from: "testing-library/utils-module". If this setting is enabled,
		 * then this method will return `true` ONLY IF a testing-library package
		 * or custom module are imported.
		 */
		const isTestingLibraryImported: IsTestingLibraryImportedFn = (
			isStrict = false
		) => {
			const isSomeModuleImported =
				importedTestingLibraryNodes.length !== 0 || !!importedCustomModuleNode;

			return (
				(!isStrict && isAggressiveModuleReportingEnabled()) ||
				isSomeModuleImported
			);
		};

		/**
		 * Determines whether a given node is a reportable query,
		 * either a built-in or a custom one.
		 *
		 * Depending on Aggressive Query Reporting setting, custom queries will be
		 * reportable or not.
		 */
		const isQuery: IsQueryFn = (node) => {
			const hasQueryPattern = /^(get|query|find)(All)?By.+$/.test(node.name);
			if (!hasQueryPattern) {
				return false;
			}

			if (isAggressiveQueryReportingEnabled()) {
				return true;
			}

			const customQueries = getCustomQueries();
			const isBuiltInQuery = ALL_QUERIES_COMBINATIONS.includes(node.name);
			const isReportableCustomQuery = customQueries.some((pattern) =>
				new RegExp(pattern).test(node.name)
			);
			return isBuiltInQuery || isReportableCustomQuery;
		};

		/**
		 * Determines whether a given node is `get*` query variant or not.
		 */
		const isGetQueryVariant: IsGetQueryVariantFn = (node) => {
			return isQuery(node) && node.name.startsWith('get');
		};

		/**
		 * Determines whether a given node is `query*` query variant or not.
		 */
		const isQueryQueryVariant: IsQueryQueryVariantFn = (node) => {
			return isQuery(node) && node.name.startsWith('query');
		};

		/**
		 * Determines whether a given node is `find*` query variant or not.
		 */
		const isFindQueryVariant: IsFindQueryVariantFn = (node) => {
			return (
				isQuery(node) &&
				node.name.startsWith('find') &&
				!EXCLUDED_FIND_BY_QUERIES.includes(node.name)
			);
		};

		/**
		 * Determines whether a given node is sync query or not.
		 */
		const isSyncQuery: IsSyncQueryFn = (node) => {
			return isGetQueryVariant(node) || isQueryQueryVariant(node);
		};

		/**
		 * Determines whether a given node is async query or not.
		 */
		const isAsyncQuery: IsAsyncQueryFn = (node) => {
			return isFindQueryVariant(node);
		};

		const isCustomQuery: IsCustomQueryFn = (node) => {
			return (
				isQuery(node) &&
				!ALL_QUERIES_COMBINATIONS.includes(node.name) &&
				!EXCLUDED_FIND_BY_QUERIES.includes(node.name)
			);
		};

		const isBuiltInQuery = (node: TSESTree.Identifier): boolean => {
			return isQuery(node) && ALL_QUERIES_COMBINATIONS.includes(node.name);
		};

		/**
		 * Determines whether a given node is a valid async util or not.
		 *
		 * A node will be interpreted as a valid async util based on two conditions:
		 * the name matches with some Testing Library async util, and the node is
		 * coming from Testing Library module.
		 *
		 * The latter depends on Aggressive module reporting:
		 * if enabled, then it doesn't matter from where the given node was imported
		 * from as it will be considered part of Testing Library.
		 * Otherwise, it means `custom-module` has been set up, so only those nodes
		 * coming from Testing Library will be considered as valid.
		 */
		const isAsyncUtil: IsAsyncUtilFn = (node, validNames = ASYNC_UTILS) => {
			return isPotentialTestingLibraryFunction(
				node,
				(identifierNodeName, originalNodeName) => {
					return (
						(validNames as string[]).includes(identifierNodeName) ||
						(!!originalNodeName &&
							(validNames as string[]).includes(originalNodeName))
					);
				}
			);
		};

		/**
		 * Determines whether a given node is fireEvent util itself or not.
		 *
		 * Not to be confused with {@link isFireEventMethod}
		 */
		const isFireEventUtil = (node: TSESTree.Identifier): boolean => {
			return isPotentialTestingLibraryFunction(
				node,
				(identifierNodeName, originalNodeName) => {
					return [identifierNodeName, originalNodeName].includes('fireEvent');
				}
			);
		};

		/**
		 * Determines whether a given node is userEvent util itself or not.
		 *
		 * Not to be confused with {@link isUserEventMethod}
		 */
		const isUserEventUtil = (node: TSESTree.Identifier): boolean => {
			const userEvent = findImportedUserEventSpecifier();
			let userEventName: string | undefined;

			if (userEvent) {
				userEventName = userEvent.name;
			} else if (isAggressiveModuleReportingEnabled()) {
				userEventName = USER_EVENT_NAME;
			}

			if (!userEventName) {
				return false;
			}

			return node.name === userEventName;
		};

		/**
		 * Determines whether a given node is fireEvent method or not
		 */
		// eslint-disable-next-line complexity
		const isFireEventMethod: IsFireEventMethodFn = (node) => {
			const fireEventUtil =
				findImportedTestingLibraryUtilSpecifier(FIRE_EVENT_NAME);
			let fireEventUtilName: string | undefined;

			if (fireEventUtil) {
				fireEventUtilName = ASTUtils.isIdentifier(fireEventUtil)
					? fireEventUtil.name
					: fireEventUtil.local.name;
			} else if (isAggressiveModuleReportingEnabled()) {
				fireEventUtilName = FIRE_EVENT_NAME;
			}

			if (!fireEventUtilName) {
				return false;
			}

			const parentMemberExpression: TSESTree.MemberExpression | undefined =
				node.parent && isMemberExpression(node.parent)
					? node.parent
					: undefined;

			const parentCallExpression: TSESTree.CallExpression | undefined =
				node.parent && isCallExpression(node.parent) ? node.parent : undefined;

			if (!parentMemberExpression && !parentCallExpression) {
				return false;
			}

			// check fireEvent('method', node) usage
			if (parentCallExpression) {
				return [fireEventUtilName, FIRE_EVENT_NAME].includes(node.name);
			}

			// we know it's defined at this point, but TS seems to think it is not
			// so here I'm enforcing it once in order to avoid using "!" operator every time
			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
			const definedParentMemberExpression = parentMemberExpression!;

			// check fireEvent.click() usage
			const regularCall =
				ASTUtils.isIdentifier(definedParentMemberExpression.object) &&
				isCallExpression(definedParentMemberExpression.parent) &&
				definedParentMemberExpression.object.name === fireEventUtilName &&
				node.name !== FIRE_EVENT_NAME &&
				node.name !== fireEventUtilName;

			// check testingLibraryUtils.fireEvent.click() usage
			const wildcardCall =
				isMemberExpression(definedParentMemberExpression.object) &&
				ASTUtils.isIdentifier(definedParentMemberExpression.object.object) &&
				definedParentMemberExpression.object.object.name ===
					fireEventUtilName &&
				ASTUtils.isIdentifier(definedParentMemberExpression.object.property) &&
				definedParentMemberExpression.object.property.name ===
					FIRE_EVENT_NAME &&
				node.name !== FIRE_EVENT_NAME &&
				node.name !== fireEventUtilName;

			// check testingLibraryUtils.fireEvent('click')
			const wildcardCallWithCallExpression =
				ASTUtils.isIdentifier(definedParentMemberExpression.object) &&
				definedParentMemberExpression.object.name === fireEventUtilName &&
				ASTUtils.isIdentifier(definedParentMemberExpression.property) &&
				definedParentMemberExpression.property.name === FIRE_EVENT_NAME &&
				!isMemberExpression(definedParentMemberExpression.parent) &&
				node.name === FIRE_EVENT_NAME &&
				node.name !== fireEventUtilName;

			return regularCall || wildcardCall || wildcardCallWithCallExpression;
		};

		const isUserEventMethod: IsUserEventMethodFn = (node) => {
			const userEvent = findImportedUserEventSpecifier();
			let userEventName: string | undefined;

			if (userEvent) {
				userEventName = userEvent.name;
			} else if (isAggressiveModuleReportingEnabled()) {
				userEventName = USER_EVENT_NAME;
			}

			if (!userEventName) {
				return false;
			}

			const parentMemberExpression: TSESTree.MemberExpression | undefined =
				node.parent && isMemberExpression(node.parent)
					? node.parent
					: undefined;

			if (!parentMemberExpression) {
				return false;
			}

			// make sure that given node it's not userEvent object itself
			if (
				[userEventName, USER_EVENT_NAME].includes(node.name) ||
				(ASTUtils.isIdentifier(parentMemberExpression.object) &&
					parentMemberExpression.object.name === node.name)
			) {
				return false;
			}

			// check userEvent.click() usage
			return (
				ASTUtils.isIdentifier(parentMemberExpression.object) &&
				parentMemberExpression.object.name === userEventName
			);
		};

		/**
		 * Determines whether a given node is a valid render util or not.
		 *
		 * A node will be interpreted as a valid render based on two conditions:
		 * the name matches with a valid "render" option, and the node is coming
		 * from Testing Library module. This depends on:
		 *
		 * - Aggressive render reporting: if enabled, then every node name
		 * containing "render" will be assumed as Testing Library render util.
		 * Otherwise, it means `custom-modules` has been set up, so only those nodes
		 * named as "render" or some of the `custom-modules` options will be
		 * considered as Testing Library render util.
		 * - Aggressive module reporting: if enabled, then it doesn't matter from
		 * where the given node was imported from as it will be considered part of
		 * Testing Library. Otherwise, it means `custom-module` has been set up, so
		 * only those nodes coming from Testing Library will be considered as valid.
		 */
		const isRenderUtil: IsRenderUtilFn = (node) =>
			isPotentialTestingLibraryFunction(
				node,
				(identifierNodeName, originalNodeName) => {
					if (isAggressiveRenderReportingEnabled()) {
						return identifierNodeName.toLowerCase().includes(RENDER_NAME);
					}

					return [RENDER_NAME, ...getCustomRenders()].some(
						(validRenderName) =>
							validRenderName === identifierNodeName ||
							(Boolean(originalNodeName) &&
								validRenderName === originalNodeName)
					);
				}
			);

		const isCreateEventUtil: IsCreateEventUtil = (node) => {
			const isCreateEventCallback = (
				identifierNodeName: string,
				originalNodeName?: string
			) => [identifierNodeName, originalNodeName].includes(CREATE_EVENT_NAME);
			if (
				isCallExpression(node) &&
				isMemberExpression(node.callee) &&
				ASTUtils.isIdentifier(node.callee.object)
			) {
				return isPotentialTestingLibraryFunction(
					node.callee.object,
					isCreateEventCallback
				);
			}

			if (
				isCallExpression(node) &&
				isMemberExpression(node.callee) &&
				isMemberExpression(node.callee.object) &&
				ASTUtils.isIdentifier(node.callee.object.property)
			) {
				return isPotentialTestingLibraryFunction(
					node.callee.object.property,
					isCreateEventCallback
				);
			}
			const identifier = getDeepestIdentifierNode(node);
			return isPotentialTestingLibraryFunction(
				identifier,
				isCreateEventCallback
			);
		};

		const isRenderVariableDeclarator: IsRenderVariableDeclaratorFn = (node) => {
			if (!node.init) {
				return false;
			}
			const initIdentifierNode = getDeepestIdentifierNode(node.init);

			if (!initIdentifierNode) {
				return false;
			}

			return isRenderUtil(initIdentifierNode);
		};

		const isDebugUtil: IsDebugUtilFn = (
			identifierNode,
			validNames = DEBUG_UTILS
		) => {
			const isBuiltInConsole =
				isMemberExpression(identifierNode.parent) &&
				ASTUtils.isIdentifier(identifierNode.parent.object) &&
				identifierNode.parent.object.name === 'console';

			return (
				!isBuiltInConsole &&
				isPotentialTestingLibraryFunction(
					identifierNode,
					(identifierNodeName, originalNodeName) => {
						return (
							(validNames as string[]).includes(identifierNodeName) ||
							(!!originalNodeName &&
								(validNames as string[]).includes(originalNodeName))
						);
					}
				)
			);
		};

		/**
		 * Determines whether a given node is some reportable `act` util.
		 *
		 * An `act` is reportable if some of these conditions is met:
		 * - it's related to Testing Library module (this depends on Aggressive Reporting)
		 * - it's related to React DOM Test Utils
		 */
		const isActUtil = (node: TSESTree.Identifier): boolean => {
			const isTestingLibraryAct = isPotentialTestingLibraryFunction(
				node,
				(identifierNodeName, originalNodeName) => {
					return [identifierNodeName, originalNodeName]
						.filter(Boolean)
						.includes('act');
				}
			);

			const isReactDomTestUtilsAct = (() => {
				if (!importedReactDomTestUtilsNode) {
					return false;
				}
				const referenceNode = getReferenceNode(node);
				const referenceNodeIdentifier =
					getPropertyIdentifierNode(referenceNode);
				if (!referenceNodeIdentifier) {
					return false;
				}

				const importedUtilSpecifier = findImportSpecifier(
					node.name,
					importedReactDomTestUtilsNode
				);
				if (!importedUtilSpecifier) {
					return false;
				}

				const importDeclaration = (() => {
					if (isImportDeclaration(importedUtilSpecifier.parent)) {
						return importedUtilSpecifier.parent;
					}

					const variableDeclarator = findClosestVariableDeclaratorNode(
						importedUtilSpecifier
					);

					if (isCallExpression(variableDeclarator?.init)) {
						return variableDeclarator?.init;
					}

					return undefined;
				})();
				if (!importDeclaration) {
					return false;
				}

				const importDeclarationName = getImportModuleName(importDeclaration);
				if (!importDeclarationName) {
					return false;
				}

				if (importDeclarationName !== REACT_DOM_TEST_UTILS_PACKAGE) {
					return false;
				}

				return hasImportMatch(
					importedUtilSpecifier,
					referenceNodeIdentifier.name
				);
			})();

			return isTestingLibraryAct || isReactDomTestUtilsAct;
		};

		const isTestingLibraryUtil = (node: TSESTree.Identifier): boolean => {
			return (
				isAsyncUtil(node) ||
				isQuery(node) ||
				isRenderUtil(node) ||
				isFireEventMethod(node) ||
				isUserEventMethod(node) ||
				isActUtil(node) ||
				isCreateEventUtil(node)
			);
		};

		/**
		 * Determines whether a given MemberExpression node is a presence assert
		 *
		 * Presence asserts could have shape of:
		 *  - expect(element).toBeInTheDocument()
		 *  - expect(element).not.toBeNull()
		 */
		const isPresenceAssert: IsPresenceAssertFn = (node) => {
			const { matcher, isNegated } = getAssertNodeInfo(node);

			if (!matcher) {
				return false;
			}

			return isNegated
				? ABSENCE_MATCHERS.includes(matcher)
				: PRESENCE_MATCHERS.includes(matcher);
		};

		/**
		 * Determines whether a given MemberExpression node is an absence assert
		 *
		 * Absence asserts could have shape of:
		 *  - expect(element).toBeNull()
		 *  - expect(element).not.toBeInTheDocument()
		 */
		const isAbsenceAssert: IsAbsenceAssertFn = (node) => {
			const { matcher, isNegated } = getAssertNodeInfo(node);

			if (!matcher) {
				return false;
			}

			return isNegated
				? PRESENCE_MATCHERS.includes(matcher)
				: ABSENCE_MATCHERS.includes(matcher);
		};

		/**
		 * Finds the import util specifier related to Testing Library for a given name.
		 */
		const findImportedTestingLibraryUtilSpecifier: FindImportedTestingLibraryUtilSpecifierFn =
			(
				specifierName
			): TSESTree.Identifier | TSESTree.ImportClause | undefined => {
				const node =
					getCustomModuleImportNode() ?? getTestingLibraryImportNode();

				if (!node) {
					return undefined;
				}

				return findImportSpecifier(specifierName, node);
			};

		const findImportedUserEventSpecifier: () => TSESTree.Identifier | null =
			() => {
				if (!importedUserEventLibraryNode) {
					return null;
				}

				if (isImportDeclaration(importedUserEventLibraryNode)) {
					const userEventIdentifier =
						importedUserEventLibraryNode.specifiers.find((specifier) =>
							isImportDefaultSpecifier(specifier)
						);

					if (userEventIdentifier) {
						return userEventIdentifier.local;
					}
				} else {
					if (
						!ASTUtils.isVariableDeclarator(importedUserEventLibraryNode.parent)
					) {
						return null;
					}

					const requireNode = importedUserEventLibraryNode.parent;
					if (!ASTUtils.isIdentifier(requireNode.id)) {
						return null;
					}

					return requireNode.id;
				}

				return null;
			};

		const getTestingLibraryImportedUtilSpecifier = (
			node: TSESTree.Identifier | TSESTree.MemberExpression
		): TSESTree.Identifier | TSESTree.ImportClause | undefined => {
			const identifierName: string | undefined =
				getPropertyIdentifierNode(node)?.name;

			if (!identifierName) {
				return undefined;
			}

			return findImportedTestingLibraryUtilSpecifier(identifierName);
		};

		/**
		 * Determines if file inspected meets all conditions to be reported by rules or not.
		 */
		const canReportErrors: CanReportErrorsFn = () => {
			return skipRuleReportingCheck || isTestingLibraryImported();
		};

		/**
		 * Determines whether a node is imported from a valid Testing Library module
		 *
		 * This method will try to find any import matching the given node name,
		 * and also make sure the name is a valid match in case it's been renamed.
		 */
		const isNodeComingFromTestingLibrary: IsNodeComingFromTestingLibraryFn = (
			node
		) => {
			const importNode = getTestingLibraryImportedUtilSpecifier(node);

			if (!importNode) {
				return false;
			}

			const referenceNode = getReferenceNode(node);
			const referenceNodeIdentifier = getPropertyIdentifierNode(referenceNode);
			if (!referenceNodeIdentifier) {
				return false;
			}

			const importDeclaration = (() => {
				if (isImportDeclaration(importNode.parent)) {
					return importNode.parent;
				}

				const variableDeclarator =
					findClosestVariableDeclaratorNode(importNode);

				if (isCallExpression(variableDeclarator?.init)) {
					return variableDeclarator?.init;
				}

				return undefined;
			})();

			if (!importDeclaration) {
				return false;
			}

			const importDeclarationName = getImportModuleName(importDeclaration);
			if (!importDeclarationName) {
				return false;
			}

			const identifierName: string | undefined =
				getPropertyIdentifierNode(node)?.name;

			if (!identifierName) {
				return false;
			}

			const hasImportElementMatch = hasImportMatch(importNode, identifierName);
			const hasImportModuleMatch =
				/testing-library/g.test(importDeclarationName) ||
				(typeof customModuleSetting === 'string' &&
					importDeclarationName.endsWith(customModuleSetting));

			return hasImportElementMatch && hasImportModuleMatch;
		};

		const helpers: DetectionHelpers = {
			getTestingLibraryImportNode,
			getAllTestingLibraryImportNodes,
			getCustomModuleImportNode,
			getTestingLibraryImportName,
			getCustomModuleImportName,
			isTestingLibraryImported,
			isTestingLibraryUtil,
			isGetQueryVariant,
			isQueryQueryVariant,
			isFindQueryVariant,
			isSyncQuery,
			isAsyncQuery,
			isQuery,
			isCustomQuery,
			isBuiltInQuery,
			isAsyncUtil,
			isFireEventUtil,
			isUserEventUtil,
			isFireEventMethod,
			isUserEventMethod,
			isRenderUtil,
			isCreateEventUtil,
			isRenderVariableDeclarator,
			isDebugUtil,
			isActUtil,
			isPresenceAssert,
			isAbsenceAssert,
			canReportErrors,
			findImportedTestingLibraryUtilSpecifier,
			isNodeComingFromTestingLibrary,
		};

		// Instructions for Testing Library detection.
		const detectionInstructions: TSESLint.RuleListener = {
			/**
			 * This ImportDeclaration rule listener will check if Testing Library related
			 * modules are imported. Since imports happen first thing in a file, it's
			 * safe to use `isImportingTestingLibraryModule` and `isImportingCustomModule`
			 * since they will have corresponding value already updated when reporting other
			 * parts of the file.
			 */
			ImportDeclaration(node: TSESTree.ImportDeclaration) {
				if (typeof node.source.value !== 'string') {
					return;
				}
				// check only if testing library import not found yet so we avoid
				// to override importedTestingLibraryNodes after it's found
				if (/testing-library/g.test(node.source.value)) {
					importedTestingLibraryNodes.push(node);
				}

				// check only if custom module import not found yet so we avoid
				// to override importedCustomModuleNode after it's found
				const customModule = getCustomModule();
				if (
					customModule &&
					!importedCustomModuleNode &&
					node.source.value.endsWith(customModule)
				) {
					importedCustomModuleNode = node;
				}

				// check only if user-event import not found yet so we avoid
				// to override importedUserEventLibraryNode after it's found
				if (
					!importedUserEventLibraryNode &&
					node.source.value === USER_EVENT_PACKAGE
				) {
					importedUserEventLibraryNode = node;
				}

				// check only if react-dom/test-utils import not found yet so we avoid
				// to override importedReactDomTestUtilsNode after it's found
				if (
					!importedUserEventLibraryNode &&
					node.source.value === REACT_DOM_TEST_UTILS_PACKAGE
				) {
					importedReactDomTestUtilsNode = node;
				}
			},

			// Check if Testing Library related modules are loaded with required.
			[`CallExpression > Identifier[name="require"]`](
				node: TSESTree.Identifier
			) {
				const callExpression = node.parent as TSESTree.CallExpression;
				const { arguments: args } = callExpression;

				if (
					args.some(
						(arg) =>
							isLiteral(arg) &&
							typeof arg.value === 'string' &&
							/testing-library/g.test(arg.value)
					)
				) {
					importedTestingLibraryNodes.push(callExpression);
				}

				const customModule = getCustomModule();
				if (
					!importedCustomModuleNode &&
					args.some(
						(arg) =>
							customModule &&
							isLiteral(arg) &&
							typeof arg.value === 'string' &&
							arg.value.endsWith(customModule)
					)
				) {
					importedCustomModuleNode = callExpression;
				}

				if (
					!importedCustomModuleNode &&
					args.some(
						(arg) =>
							isLiteral(arg) &&
							typeof arg.value === 'string' &&
							arg.value === USER_EVENT_PACKAGE
					)
				) {
					importedUserEventLibraryNode = callExpression;
				}

				if (
					!importedReactDomTestUtilsNode &&
					args.some(
						(arg) =>
							isLiteral(arg) &&
							typeof arg.value === 'string' &&
							arg.value === REACT_DOM_TEST_UTILS_PACKAGE
					)
				) {
					importedReactDomTestUtilsNode = callExpression;
				}
			},
		};

		// update given rule to inject Testing Library detection
		const ruleInstructions = ruleCreate(context, optionsWithDefault, helpers);
		const enhancedRuleInstructions: TSESLint.RuleListener = {};

		const allKeys = new Set(
			Object.keys(detectionInstructions).concat(Object.keys(ruleInstructions))
		);

		// Iterate over ALL instructions keys so we can override original rule instructions
		// to prevent their execution if conditions to report errors are not met.
		allKeys.forEach((instruction) => {
			enhancedRuleInstructions[instruction] = (node) => {
				if (instruction in detectionInstructions) {
					detectionInstructions[instruction]?.(node);
				}

				if (canReportErrors() && ruleInstructions[instruction]) {
					return ruleInstructions[instruction]?.(node);
				}

				return undefined;
			};
		});

		return enhancedRuleInstructions;
	};
}