refactor(await-fire-event): reuse fire event detection helpers

lib/detect-testing-library-utils.ts

@@ -189,7 +189,6 @@ export function detectTestingLibraryUtils<
 
  /**
  * Determines whether a given node is fireEvent method or not
- * @param node
  */
  const isFireEventMethod: DetectionHelpers['isFireEventMethod'] = (node) => {
  const fireEventUtil = findImportedUtilSpecifier(FIRE_EVENT_NAME);
@@ -204,31 +203,39 @@ export function detectTestingLibraryUtils<
  }
 
  if (!fireEventUtilName) {
- return;
+ return false;
  }
 
  const parentMemberExpression:
  | TSESTree.MemberExpression
  | undefined = isMemberExpression(node.parent) ? node.parent : undefined;
 
- if (parentMemberExpression) {
- // checking fireEvent.click() usage
- const regularCall =
- ASTUtils.isIdentifier(parentMemberExpression.object) &&
- parentMemberExpression.object.name === fireEventUtilName;
-
- // checking testingLibraryUtils.fireEvent.click() usage
- const wildcardCall =
- isMemberExpression(parentMemberExpression.object) &&
- ASTUtils.isIdentifier(parentMemberExpression.object.object) &&
- parentMemberExpression.object.object.name === fireEventUtilName &&
- ASTUtils.isIdentifier(parentMemberExpression.object.property) &&
- parentMemberExpression.object.property.name === FIRE_EVENT_NAME;
-
- return regularCall || wildcardCall;
+ if (!parentMemberExpression) {
+ return false;
  }
 
- return false;
+ // make sure that given node it's not fireEvent util itself
+ if (
+ ASTUtils.isIdentifier(parentMemberExpression.object) &&
+ parentMemberExpression.object.name === node.name
+ ) {
+ return false;
+ }
+
+ // check fireEvent.click() usage
+ const regularCall =
+ ASTUtils.isIdentifier(parentMemberExpression.object) &&
+ parentMemberExpression.object.name === fireEventUtilName;
+
+ // check testingLibraryUtils.fireEvent.click() usage
+ const wildcardCall =
+ isMemberExpression(parentMemberExpression.object) &&
+ ASTUtils.isIdentifier(parentMemberExpression.object.object) &&
+ parentMemberExpression.object.object.name === fireEventUtilName &&
+ ASTUtils.isIdentifier(parentMemberExpression.object.property) &&
+ parentMemberExpression.object.property.name === FIRE_EVENT_NAME;
+
+ return regularCall || wildcardCall;
  };
 
  /**

lib/rules/await-fire-event.ts

@@ -1,5 +1,9 @@
-import { ASTUtils, TSESTree } from '@typescript-eslint/experimental-utils';
-import { isPromiseHandled } from '../node-utils';
+import { TSESTree } from '@typescript-eslint/experimental-utils';
+import {
+ findClosestCallExpressionNode,
+ getVariableReferences,
+ isPromiseHandled,
+} from '../node-utils';
 import { createTestingLibraryRule } from '../create-testing-library-rule';
 
 export const RULE_NAME = 'await-fire-event';
@@ -19,32 +23,55 @@ export default createTestingLibraryRule<Options, MessageIds>({
  awaitFireEvent:
  'Promise returned from `fireEvent.{{ methodName }}` must be handled',
  fireEventWrapper:
- 'Promise returned from `{{ wrapperName }}` wrapper over fire event method must be handled',
+ 'Promise returned from `fireEvent.{{ wrapperName }}` wrapper over fire event method must be handled',
  },
  fixable: null,
  schema: [],
  },
  defaultOptions: [],
 
- create: function (context) {
+ create: function (context, _, helpers) {
+ function reportUnhandledNode(
+ node: TSESTree.Identifier,
+ closestCallExpressionNode: TSESTree.CallExpression,
+ messageId: MessageIds = 'awaitFireEvent'
+ ): void {
+ if (!isPromiseHandled(node)) {
+ context.report({
+ node: closestCallExpressionNode.callee,
+ messageId,
+ data: { name: node.name },
+ });
+ }
+ }
+
  return {
- 'CallExpression > MemberExpression > Identifier[name=fireEvent]'(
- node: TSESTree.Identifier
- ) {
- const memberExpression = node.parent as TSESTree.MemberExpression;
- const fireEventMethodNode = memberExpression.property;
-
- if (
- ASTUtils.isIdentifier(fireEventMethodNode) &&
- !isPromiseHandled(node)
- ) {
- context.report({
- node: fireEventMethodNode,
- messageId: 'awaitFireEvent',
- data: {
- methodName: fireEventMethodNode.name,
- },
- });
+ 'CallExpression Identifier'(node: TSESTree.Identifier) {
+ if (helpers.isFireEventMethod(node)) {
+ // TODO: detectFireEventMethodWrapper
+
+ const closestCallExpression = findClosestCallExpressionNode(
+ node,
+ true
+ );
+
+ if (!closestCallExpression) {
+ return;
+ }
+
+ const references = getVariableReferences(
+ context,
+ closestCallExpression.parent
+ );
+
+ if (!references || references.length === 0) {
+ return reportUnhandledNode(node, closestCallExpression);
+ } else {
+ for (const reference of references) {
+ const referenceNode = reference.identifier as TSESTree.Identifier;
+ return reportUnhandledNode(referenceNode, closestCallExpression);
+ }
+ }
  }
  },
  };