first commit

packages/testing/janitor/src/rules/deduplication.rule.ts

@@ -0,0 +1,175 @@
+import { SyntaxKind, type Project, type SourceFile, type CallExpression } from 'ts-morph';
+
+import { BaseRule } from './base-rule.js';
+import { getConfig } from '../config.js';
+import type { Violation } from '../types.js';
+import { isComponentFile, getRelativePath } from '../utils/paths.js';
+
+interface TestIdUsage {
+	file: string;
+	line: number;
+	column: number;
+	root: string; // The locator root (e.g., "this.page", "this.container", "this.getPanel()")
+}
+
+/**
+ * Deduplication Rule
+ *
+ * Ensures getByTestId() calls accessing the SAME DOM element are consolidated.
+ * Uses AST analysis to determine the locator "root" - two calls are only duplicates
+ * if they have the same root AND the same test ID.
+ *
+ * Examples:
+ * - this.page.getByTestId('modal') in FileA and FileB → DUPLICATE (same root, same ID)
+ * - this.container.getByTestId('view') vs this.page.getByTestId('view') → NOT duplicate
+ * - this.getOutputPanel().getByTestId('view') vs this.getInputPanel().getByTestId('view') → NOT duplicate
+ *
+ * Scopes:
+ * - pages/ (excluding components) = one scope
+ * - pages/components/ = separate scope
+ *
+ * Only flags when the same {root}:{testId} combination appears in multiple files.
+ */
+export class DeduplicationRule extends BaseRule {
+	readonly id = 'deduplication';
+	readonly name = 'Deduplication';
+	readonly description = 'Test IDs should be unique within their scope';
+	readonly severity = 'warning' as const;
+
+	getTargetGlobs(): string[] {
+		const config = getConfig();
+		return config.patterns.pages;
+	}
+
+	analyze(_project: Project, files: SourceFile[]): Violation[] {
+		const { pagesScope, componentsScope } = this.buildSelectorMaps(files);
+
+		return [
+			...this.findDuplicates(pagesScope, 'pages', files),
+			...this.findDuplicates(componentsScope, 'components', files),
+		];
+	}
+
+	private buildSelectorMaps(files: SourceFile[]): {
+		pagesScope: Map<string, TestIdUsage[]>;
+		componentsScope: Map<string, TestIdUsage[]>;
+	} {
+		const pagesScope = new Map<string, TestIdUsage[]>();
+		const componentsScope = new Map<string, TestIdUsage[]>();
+
+		for (const file of files) {
+			const filePath = file.getFilePath();
+			const scope = isComponentFile(filePath) ? componentsScope : pagesScope;
+			this.collectTestIdUsages(file, scope);
+		}
+
+		return { pagesScope, componentsScope };
+	}
+
+	private collectTestIdUsages(file: SourceFile, scope: Map<string, TestIdUsage[]>): void {
+		const filePath = file.getFilePath();
+		const calls = file.getDescendantsOfKind(SyntaxKind.CallExpression);
+
+		for (const call of calls) {
+			const usage = this.extractTestIdUsage(call, filePath);
+			if (!usage) continue;
+
+			const key = `${usage.root}:${usage.testId}`;
+			const existing = scope.get(key) ?? [];
+			existing.push({
+				file: usage.file,
+				line: usage.line,
+				column: usage.column,
+				root: usage.root,
+			});
+			scope.set(key, existing);
+		}
+	}
+
+	private extractTestIdUsage(
+		call: CallExpression,
+		filePath: string,
+	): (TestIdUsage & { testId: string }) | null {
+		const expr = call.getExpression();
+		const text = expr.getText();
+
+		if (!text.endsWith('.getByTestId')) return null;
+
+		const args = call.getArguments();
+		if (args.length === 0) return null;
+
+		const firstArg = args[0];
+		if (firstArg.getKind() !== SyntaxKind.StringLiteral) return null;
+
+		const stringLit = firstArg.asKind(SyntaxKind.StringLiteral);
+		if (!stringLit) return null;
+
+		return {
+			file: filePath,
+			line: call.getStartLineNumber(),
+			column: call.getStart() - call.getStartLinePos(),
+			root: this.extractLocatorRoot(text),
+			testId: stringLit.getLiteralText(),
+		};
+	}
+
+	private findDuplicates(
+		scope: Map<string, TestIdUsage[]>,
+		scopeName: string,
+		files: SourceFile[],
+	): Violation[] {
+		const violations: Violation[] = [];
+
+		for (const [key, usages] of scope) {
+			// Only flag if same root:testId appears in multiple files
+			const uniqueFiles = new Set(usages.map((u) => u.file));
+			if (uniqueFiles.size <= 1) continue;
+
+			// Extract testId from key (format: "root:testId")
+			const testId = key.substring(key.lastIndexOf(':') + 1);
+			const root = usages[0].root;
+
+			// Create a violation for each usage except the first
+			const sortedUsages = [...usages].sort((a, b) => a.file.localeCompare(b.file));
+			const firstFile = getRelativePath(sortedUsages[0].file);
+
+			for (let i = 1; i < sortedUsages.length; i++) {
+				const usage = sortedUsages[i];
+				const file = files.find((f) => f.getFilePath() === usage.file);
+				if (!file) continue;
+
+				violations.push(
+					this.createViolation(
+						file,
+						usage.line,
+						usage.column,
+						`Duplicate locator: ${root}.getByTestId("${testId}") in ${scopeName} scope`,
+						`Also used in ${firstFile}. Consider consolidating to a shared component.`,
+					),
+				);
+			}
+		}
+
+		return violations;
+	}
+
+	/**
+	 * Extract the locator root from a getByTestId call expression.
+	 * E.g., "this.page.getByTestId" → "this.page"
+	 *       "this.container.getByTestId" → "this.container"
+	 *       "this.getPanel().getByTestId" → "this.getPanel()"
+	 */
+	private extractLocatorRoot(exprText: string): string {
+		// Remove the trailing .getByTestId
+		const root = exprText.replace(/\.getByTestId$/, '');
+
+		// Normalize common patterns for better grouping
+		// this.page.locator(...).* chains should be considered scoped
+		if (root.includes('.locator(')) {
+			return 'scoped'; // Mark as scoped - won't match other scoped calls
+		}
+
+		// Normalize method calls to include parentheses for clarity
+		return root;
+	}
+}