feat: add new settings for prefer-user-event pt1

Author: gndelia

lib/node-utils.ts

@@ -253,3 +253,22 @@ export function getImportModuleName(
     return node.arguments[0].value;
   }
 }
+
+export function getSpecifierFromImport(
+  node: ImportModuleNode,
+  specifierName: string
+) {
+  if (isImportDeclaration(node)) {
+    const namedExport = node.specifiers.find(
+      (node) => isImportSpecifier(node) && node.imported.name === specifierName
+    );
+    // it is "import { foo } from 'baz'""
+    if (namedExport) {
+      return namedExport;
+    }
+    // it could be "import * as rtl from 'baz'"
+    return node.specifiers.find((n) => isImportNamespaceSpecifier(n));
+  } else {
+    // TODO make it work for require
+  }
+}

lib/rules/prefer-user-event.ts

@@ -1,9 +1,9 @@
-import { ESLintUtils, TSESTree } from '@typescript-eslint/experimental-utils';
-import { getDocsUrl, hasTestingLibraryImportModule } from '../utils';
+import { TSESTree } from '@typescript-eslint/experimental-utils';
+import { createTestingLibraryRule } from '../create-testing-library-rule';
 import {
-  isImportSpecifier,
   isIdentifier,
   isMemberExpression,
+  getSpecifierFromImport,
 } from '../node-utils';
 
 export const RULE_NAME = 'prefer-user-event';
@@ -65,7 +65,7 @@ function buildErrorMessage(fireEventMethod: string) {
 
 const fireEventMappedMethods = Object.keys(MappingToUserEvent);
 
-export default ESLintUtils.RuleCreator(getDocsUrl)<Options, MessageIds>({
+export default createTestingLibraryRule<Options, MessageIds>({
   name: RULE_NAME,
   meta: {
     type: 'suggestion',
@@ -90,59 +90,38 @@ export default ESLintUtils.RuleCreator(getDocsUrl)<Options, MessageIds>({
   },
   defaultOptions: [{ allowedMethods: [] }],
 
-  create(context, [options]) {
+  create(context, [options], helpers) {
     const { allowedMethods } = options;
     const sourceCode = context.getSourceCode();
-    let hasNamedImportedFireEvent = false;
-    let hasImportedFireEvent = false;
-    let fireEventAlias: string | undefined;
-    let wildcardImportName: string | undefined;
 
     return {
-      // checks if import has shape:
-      // import { fireEvent } from '@testing-library/dom';
-      ImportDeclaration(node: TSESTree.ImportDeclaration) {
-        if (!hasTestingLibraryImportModule(node)) {
-          return;
-        }
-        const fireEventImport = node.specifiers.find(
-          (node) =>
-            isImportSpecifier(node) && node.imported.name === 'fireEvent'
-        );
-        hasNamedImportedFireEvent = !!fireEventImport;
-        if (!hasNamedImportedFireEvent) {
+      ['CallExpression > MemberExpression'](node: TSESTree.MemberExpression) {
+        if (!helpers.getIsTestingLibraryImported()) {
           return;
         }
-        fireEventAlias = fireEventImport.local.name;
-      },
+        const testingLibraryImportNode = helpers.getTestingLibraryImportNode();
+        const fireEventAliasOrWildcard = getSpecifierFromImport(
+          testingLibraryImportNode,
+          'fireEvent'
+        )?.local.name;
 
-      // checks if import has shape:
-      // import * as dom from '@testing-library/dom';
-      'ImportDeclaration ImportNamespaceSpecifier'(
-        node: TSESTree.ImportNamespaceSpecifier
-      ) {
-        const importDeclarationNode = node.parent as TSESTree.ImportDeclaration;
-        if (!hasTestingLibraryImportModule(importDeclarationNode)) {
+        if (!fireEventAliasOrWildcard) {
+          // testing library was imported, but fireEvent was not imported
           return;
         }
-        hasImportedFireEvent = !!node.local.name;
-        wildcardImportName = node.local.name;
-      },
-      ['CallExpression > MemberExpression'](node: TSESTree.MemberExpression) {
-        if (!hasImportedFireEvent && !hasNamedImportedFireEvent) {
-          return;
-        }
-        // check node is fireEvent or it's alias from the named import
         const fireEventUsed =
-          isIdentifier(node.object) && node.object.name === fireEventAlias;
+          isIdentifier(node.object) &&
+          node.object.name === fireEventAliasOrWildcard;
+
         const fireEventFromWildcardUsed =
           isMemberExpression(node.object) &&
           isIdentifier(node.object.object) &&
-          node.object.object.name === wildcardImportName &&
+          node.object.object.name === fireEventAliasOrWildcard &&
           isIdentifier(node.object.property) &&
           node.object.property.name === 'fireEvent';
 
         if (!fireEventUsed && !fireEventFromWildcardUsed) {
+          // fireEvent was imported but it was not used
           return;
         }