@empline/preflight 1.1.11 → 1.1.13

package/dist/checks/consolidated/e2e-validation.js

@@ -0,0 +1,1001 @@
+#!/usr/bin/env tsx
+"use strict";
+/**
+ * Consolidated E2E Validation Preflight
+ *
+ * MASTER module for all E2E test validation. Consolidates 18+ separate preflights into one.
+ *
+ * Sub-checks included (10 total):
+ * 1. Best Practices - No hardcoded waits, force clicks, page.pause, .only tests
+ * 2. Outcome Validation - Critical actions have outcome verification
+ * 3. Flake Patterns - Patterns that cause flaky tests
+ * 4. Timeout Limits - Playwright config timeout limits
+ * 5. Performance - Slow patterns and excessive timeouts
+ * 6. Test Organization - test.describe blocks and imports
+ * 7. Assertion Quality - Detects weak assertions (visibility-only tests)
+ * 8. Test Isolation - Shared state and beforeAll issues
+ * 9. Selector Stability - Brittle selectors (class, nth-child, nested divs)
+ * 10. Critical Route Coverage - Ensures critical paths have E2E tests
+ *
+ * Usage:
+ *   pnpm preflight:e2e                    # All checks
+ *   pnpm preflight:e2e best-practices     # Best practices only
+ *   pnpm preflight:e2e outcomes           # Outcome validation only
+ *   pnpm preflight:e2e flakes             # Flake patterns only
+ *   pnpm preflight:e2e timeouts           # Timeout limits only
+ *   pnpm preflight:e2e performance        # Performance patterns only
+ *   pnpm preflight:e2e organization       # Test organization only
+ *   pnpm preflight:e2e assertions         # Assertion quality only
+ *   pnpm preflight:e2e isolation          # Test isolation only
+ *   pnpm preflight:e2e selectors          # Selector stability only
+ *   pnpm preflight:e2e coverage           # Critical route coverage only
+ *   pnpm preflight:e2e --warn             # All checks as warnings
+ *   pnpm preflight:e2e --verbose          # Show all issues
+ *
+ * Replaces:
+ *   - e2e/e2e-outcome-validation.ts
+ *   - e2e/e2e-interaction-regression.ts
+ *   - e2e/e2e-interaction-coverage-scan.ts
+ *   - e2e/e2e-action-outcome-validator.ts
+ *   - e2e/e2e-button-functionality-audit.ts
+ *   - e2e/e2e-performance-regression.ts
+ *   - e2e/e2e-performance-baseline.ts
+ *   - e2e/e2e-performance-patterns.ts
+ *   - e2e/e2e-resource-monitoring.ts
+ *   - testing/e2e-best-practices.ts
+ *   - testing/e2e-flake-patterns.ts
+ *   - testing/e2e-timeouts.ts
+ *   - testing/e2e-slow-tests.ts
+ *   - testing/e2e-redundant-visibility-checks.ts
+ *   - consolidated/e2e-regression-coverage.ts
+ *   - consolidated/regression-hygiene.ts (E2E parts)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.E2EValidationModule = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const console_chars_1 = require("../../utils/console-chars");
+const file_cache_1 = require("../../shared/file-cache");
+const glob_patterns_1 = require("../../shared/glob-patterns");
+const concurrency_config_1 = require("../../shared/concurrency-config");
+// CACHED FILE LISTS - Scan once, use everywhere
+let _cachedE2ESpecFiles = null;
+async function getE2ESpecFiles() {
+    if (!_cachedE2ESpecFiles) {
+        _cachedE2ESpecFiles = await file_cache_1.fileCache.getE2ESpecFiles();
+    }
+    return _cachedE2ESpecFiles;
+}
+// CONFIGURATION
+const EXCLUDED = [...glob_patterns_1.STANDARD_EXCLUDES];
+const E2E_TEST_GLOB = "tests/e2e/**/*.spec.ts";
+// Best practices rules
+// NOTE: These are all warnings (non-blocking) because the original e2e-best-practices.ts
+// was NOT included in preflight:all. Making them blocking would be a regression.
+// To make blocking in future: change severity to 'error' and fix all violations first.
+const BEST_PRACTICE_RULES = {
+    "no-hardcoded-waits": {
+        pattern: /waitForTimeout\s*\(\s*(\d+)\s*\)/g,
+        threshold: 500,
+        severity: "warning", // Non-blocking - original preflight wasn't in all.ts
+        message: (timeout) => `Hardcoded wait of ${timeout}ms found`,
+        suggestion: "Use waitForSelector, waitForLoadState, or expect().toBeVisible()",
+    },
+    "no-force-click": {
+        pattern: /force:\s*true/g,
+        contextPattern: /click/,
+        severity: "warning", // Non-blocking - sometimes needed for mobile tests
+        message: "Using force: true bypasses actionability checks",
+        suggestion: "Fix element visibility/interactability instead of using force: true",
+    },
+    "no-page-pause": {
+        pattern: /page\.pause\(\)/g,
+        severity: "error",
+        message: "page.pause() should not be committed to tests",
+        suggestion: "Remove page.pause() - it's only for debugging",
+    },
+    "no-only-tests": {
+        pattern: /test\.only\(|\.only\(/g,
+        severity: "error",
+        message: "test.only() should not be committed",
+        suggestion: "Remove .only() to run all tests in CI",
+    },
+    "no-skip-without-reason": {
+        pattern: /test\.skip\(/g,
+        checkPrevLineForTodo: true, // Special handling - check for TODO/FIXME on previous line
+        severity: "warning",
+        message: "test.skip() should have a reason comment",
+        suggestion: 'Add a TODO comment on the line before, or use test.skip("reason", ...)',
+    },
+};
+// Critical actions that MUST have outcome verification
+const CRITICAL_ACTIONS = [
+    {
+        pattern: /\.click\s*\([^)]*(?:delete|remove|trash)/i,
+        name: "Delete",
+        severity: "critical",
+    },
+    {
+        pattern: /\.click\s*\([^)]*(?:checkout|place.*order|pay|purchase)/i,
+        name: "Checkout",
+        severity: "critical",
+    },
+    { pattern: /\.click\s*\([^)]*(?:refund)/i, name: "Refund", severity: "critical" },
+    {
+        pattern: /\.click\s*\([^)]*(?:submit|save|confirm)/i,
+        name: "Submit",
+        severity: "high",
+    },
+    {
+        pattern: /\.click\s*\([^)]*(?:approve|reject)/i,
+        name: "Approve/Reject",
+        severity: "high",
+    },
+    { pattern: /\.click\s*\([^)]*(?:ship|fulfill)/i, name: "Ship", severity: "high" },
+    { pattern: /\.click\s*\([^)]*(?:cancel)/i, name: "Cancel", severity: "high" },
+    {
+        pattern: /\.click\s*\([^)]*(?:add.*cart|buy)/i,
+        name: "Add to Cart",
+        severity: "high",
+    },
+];
+// Strong outcome patterns
+const STRONG_OUTCOMES = [
+    /toHaveURL\s*\(/,
+    /toHaveText\s*\(/,
+    /toContainText\s*\(/,
+    /toHaveValue\s*\(/,
+    /toHaveCount\s*\(/,
+    /not\.toBeVisible\s*\(/,
+    /toBeHidden\s*\(/,
+    /waitForResponse\s*\(/,
+    /waitForRequest\s*\(/,
+    /waitForURL\s*\(/,
+    /expect\.poll\s*\(/,
+];
+// Flake patterns
+const FLAKE_PATTERNS = [
+    {
+        pattern: /:text\s*\(/g,
+        name: "text-selector",
+        message: "Text selectors are brittle",
+        suggestion: "Use getByRole, getByTestId, or getByLabel",
+    },
+    {
+        pattern: /\.catch\s*\(\s*\(\s*\)\s*=>\s*\{\s*\}\s*\)/g,
+        name: "empty-catch",
+        message: "Empty catch swallows errors",
+        suggestion: "Log or rethrow the error",
+    },
+    {
+        pattern: /page\.content\(\)/g,
+        name: "page-content",
+        message: "page.content() is brittle for assertions",
+        suggestion: "Use specific element assertions",
+    },
+];
+// Timeout limits
+const TIMEOUT_LIMITS = {
+    testTimeoutMs: 90_000,
+    actionTimeoutMs: 15_000,
+    expectTimeoutMs: 30_000,
+    navigationTimeoutMs: 60_000,
+};
+// Performance patterns
+const SLOW_PATTERNS = [
+    {
+        pattern: /timeout:\s*(1[2-9]\d{4,}|[2-9]\d{5,}|\d{6,})/g,
+        severity: "error",
+        message: "Very excessive timeout (120s+)",
+    },
+    {
+        pattern: /timeout:\s*([6-9]\d{4}|1[01]\d{4})/g,
+        severity: "warning",
+        message: "Long timeout (60s+)",
+    },
+    {
+        pattern: /waitForTimeout\(\s*([2-9]\d{3,}|\d{5,})\s*\)/g,
+        severity: "error",
+        message: "Very long waitForTimeout (2s+)",
+    },
+    {
+        pattern: /page\.waitForSelector\(/g,
+        severity: "warning",
+        message: "waitForSelector is deprecated",
+    },
+];
+// ENHANCEMENT: Missing Test Coverage Detection
+// Routes that MUST have E2E coverage (critical user paths)
+const CRITICAL_ROUTES_REQUIRING_TESTS = [
+    { route: "/checkout", minTests: 1, severity: "critical" },
+    { route: "/login", minTests: 1, severity: "critical" },
+    { route: "/register", minTests: 1, severity: "critical" },
+    { route: "/store", minTests: 1, severity: "high" },
+    { route: "/marketplace", minTests: 1, severity: "high" },
+    { route: "/cart", minTests: 1, severity: "high" },
+    { route: "/account", minTests: 1, severity: "medium" },
+];
+// Assertion patterns that indicate test completeness
+const ASSERTION_QUALITY_PATTERNS = {
+    // Strong assertions - actually verify functionality
+    strong: [
+        /toHaveURL\s*\(/,
+        /toHaveText\s*\(/,
+        /toContainText\s*\(/,
+        /toHaveValue\s*\(/,
+        /toHaveCount\s*\(/,
+        /toBeChecked\s*\(/,
+        /not\.toBeVisible\s*\(/,
+        /toBeHidden\s*\(/,
+        /waitForResponse\s*\(/,
+        /waitForURL\s*\(/,
+        /expect\.poll\s*\(/,
+    ],
+    // Weak assertions - may pass even when broken
+    weak: [
+        /toBeVisible\s*\(\s*\)\s*;?\s*$/, // Just visibility check with no content
+        /toBeTruthy\s*\(\s*\)/, // Too generic
+        /toBeDefined\s*\(\s*\)/, // Too generic
+    ],
+};
+// Test isolation patterns - detecting shared state issues
+const ISOLATION_ANTI_PATTERNS = [
+    {
+        pattern: /let\s+\w+\s*=\s*[^;]+;[\s\S]*test\(/g,
+        name: "module-level-variable",
+        message: "Module-level variable may cause test pollution",
+    },
+    {
+        pattern: /beforeAll\s*\([^)]*\)\s*=>\s*\{[\s\S]*page\./g,
+        name: "beforeAll-page-access",
+        message: "Accessing page in beforeAll can cause isolation issues",
+    },
+];
+// E2E VALIDATION MODULE
+// Get concurrency from shared config (respects PREFLIGHT_CONCURRENCY env var)
+const concurrencyConfig = (0, concurrency_config_1.getConcurrencyConfig)();
+class E2EValidationModule {
+    warnOnly;
+    constructor(options = {}) {
+        this.warnOnly = options.warnOnly ?? false;
+    }
+    /**
+     * Check 1: Best Practices
+     */
+    async checkBestPractices() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await getE2ESpecFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            // Check each rule
+            for (const [ruleName, rule] of Object.entries(BEST_PRACTICE_RULES)) {
+                if ("threshold" in rule) {
+                    // Pattern with threshold (e.g., waitForTimeout)
+                    let match;
+                    while ((match = rule.pattern.exec(content)) !== null) {
+                        const value = parseInt(match[1] ?? "0", 10);
+                        if (value > rule.threshold) {
+                            const lineNum = content.substring(0, match.index).split("\n").length;
+                            issues.push({
+                                file,
+                                line: lineNum,
+                                type: ruleName,
+                                severity: this.warnOnly ? "warning" : rule.severity,
+                                message: rule.message(value),
+                                suggestion: rule.suggestion,
+                                rule: ruleName,
+                            });
+                        }
+                    }
+                }
+                else if ("contextPattern" in rule) {
+                    // Pattern with context check
+                    lines.forEach((line, index) => {
+                        if (rule.pattern.test(line) && rule.contextPattern.test(line)) {
+                            issues.push({
+                                file,
+                                line: index + 1,
+                                type: ruleName,
+                                severity: this.warnOnly ? "warning" : rule.severity,
+                                message: rule.message,
+                                suggestion: rule.suggestion,
+                                rule: ruleName,
+                            });
+                        }
+                    });
+                }
+                else if ("checkPrevLineForTodo" in rule && rule.checkPrevLineForTodo) {
+                    // test.skip() pattern - check for TODO/FIXME on previous line or inline reason
+                    lines.forEach((line, index) => {
+                        if (rule.pattern.test(line) && !line.trim().startsWith("//")) {
+                            const prevLine = index > 0 ? (lines[index - 1] ?? "") : "";
+                            // Allow if previous line has TODO or FIXME
+                            if (prevLine.includes("TODO") || prevLine.includes("FIXME")) {
+                                return;
+                            }
+                            // Allow if line has inline comment
+                            if (line.includes("//") || line.includes("/*")) {
+                                return;
+                            }
+                            // Allow if previous line has any comment
+                            if (prevLine.trim().startsWith("//")) {
+                                return;
+                            }
+                            // Check for inline reason string in various formats:
+                            // test.skip("reason", async () => {
+                            // test.skip(condition, "reason")
+                            // test.skip(!visible, "Reason text")
+                            // test.skip(await emptyState.isVisible().catch(() => false), "No posts")
+                            const lookahead = [
+                                lines[index] ?? "",
+                                lines[index + 1] ?? "",
+                                lines[index + 2] ?? "",
+                                lines[index + 3] ?? "",
+                            ].join("\n");
+                            // Check for test.skip with a reason string - look for pattern with comma followed by string
+                            // Handle complex expressions by looking for ", " or ",\n" followed by a quote
+                            const hasInlineReason = /test\.skip\([\s\S]*?,\s*['"`][^'"`]+['"`]/.test(lookahead) ||
+                                /test\.skip\(\s*['"`][^'"`]+['"`]\s*,/.test(lookahead);
+                            if (hasInlineReason) {
+                                return;
+                            }
+                            issues.push({
+                                file,
+                                line: index + 1,
+                                type: ruleName,
+                                severity: this.warnOnly ? "warning" : rule.severity,
+                                message: rule.message,
+                                suggestion: rule.suggestion,
+                                rule: ruleName,
+                            });
+                        }
+                    });
+                }
+                else {
+                    // Simple pattern match
+                    lines.forEach((line, index) => {
+                        if (rule.pattern.test(line) && !line.trim().startsWith("//")) {
+                            issues.push({
+                                file,
+                                line: index + 1,
+                                type: ruleName,
+                                severity: this.warnOnly ? "warning" : rule.severity,
+                                message: rule.message,
+                                suggestion: rule.suggestion,
+                                rule: ruleName,
+                            });
+                        }
+                    });
+                }
+            }
+        }
+        const hasErrors = issues.some((i) => i.severity === "error");
+        return {
+            name: "E2E Best Practices",
+            passed: !hasErrors,
+            blocking: !this.warnOnly,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Check 2: Outcome Validation
+     */
+    async checkOutcomeValidation() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await getE2ESpecFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i] ?? "";
+                for (const action of CRITICAL_ACTIONS) {
+                    if (action.pattern.test(line)) {
+                        // Check if there's an outcome assertion within 10 lines
+                        const contextEnd = Math.min(i + 10, lines.length);
+                        const context = lines.slice(i, contextEnd).join("\n");
+                        const hasOutcome = STRONG_OUTCOMES.some((p) => p.test(context));
+                        if (!hasOutcome) {
+                            issues.push({
+                                file,
+                                line: i + 1,
+                                type: "missing-outcome",
+                                severity: action.severity === "critical" ? "error" : "warning",
+                                message: `${action.name} action without outcome verification`,
+                                suggestion: "Add toHaveURL, toHaveText, waitForResponse, or similar assertion",
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        const hasErrors = issues.some((i) => i.severity === "error");
+        return {
+            name: "E2E Outcome Validation",
+            passed: !hasErrors || this.warnOnly,
+            blocking: !this.warnOnly,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Check 3: Flake Patterns
+     */
+    async checkFlakePatterns() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await getE2ESpecFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (const flake of FLAKE_PATTERNS) {
+                let match;
+                while ((match = flake.pattern.exec(content)) !== null) {
+                    const lineNum = content.substring(0, match.index).split("\n").length;
+                    // Check for suppression comment
+                    // lineNum is 1-indexed, but slice is 0-indexed, so use lineNum - 1
+                    // Look 4 lines before to catch multi-line locators where comment is before const
+                    const lineIndex = lineNum - 1;
+                    const contextStart = Math.max(0, lineIndex - 4);
+                    const contextEnd = Math.min(lineIndex + 1, lines.length);
+                    const context = lines.slice(contextStart, contextEnd).join("\n");
+                    if (!context.includes("e2e-allow-flake-pattern")) {
+                        issues.push({
+                            file,
+                            line: lineNum,
+                            type: flake.name,
+                            severity: "warning",
+                            message: flake.message,
+                            suggestion: flake.suggestion,
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            name: "E2E Flake Patterns",
+            passed: true, // Non-blocking
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Check 4: Timeout Limits
+     */
+    async checkTimeoutLimits() {
+        const startTime = Date.now();
+        const issues = [];
+        try {
+            // Dynamic import of playwright config
+            const configPath = path.join(process.cwd(), "playwright.config.ts");
+            if (!fs.existsSync(configPath)) {
+                return {
+                    name: "E2E Timeout Limits",
+                    passed: true,
+                    blocking: false,
+                    issues: [
+                        {
+                            file: "playwright.config.ts",
+                            line: 0,
+                            type: "missing-config",
+                            severity: "info",
+                            message: "No playwright.config.ts found",
+                        },
+                    ],
+                    duration: Date.now() - startTime,
+                };
+            }
+            // Read and parse config (simplified check)
+            const configContent = fs.readFileSync(configPath, "utf8");
+            // Check for excessive timeouts in config
+            const timeoutMatch = configContent.match(/timeout:\s*(\d+)/);
+            if (timeoutMatch) {
+                const timeout = parseInt(timeoutMatch[1] ?? "0", 10);
+                if (timeout > TIMEOUT_LIMITS.testTimeoutMs) {
+                    issues.push({
+                        file: "playwright.config.ts",
+                        line: 1,
+                        type: "excessive-timeout",
+                        severity: "error",
+                        message: `Test timeout ${timeout}ms exceeds limit of ${TIMEOUT_LIMITS.testTimeoutMs}ms`,
+                        suggestion: "Reduce timeout or break tests into smaller units",
+                    });
+                }
+            }
+        }
+        catch {
+            // Config parsing failed, skip this check
+        }
+        const hasErrors = issues.some((i) => i.severity === "error");
+        return {
+            name: "E2E Timeout Limits",
+            passed: !hasErrors,
+            blocking: true,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Check 5: Performance Patterns
+     */
+    async checkPerformancePatterns() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await getE2ESpecFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            for (const slow of SLOW_PATTERNS) {
+                let match;
+                while ((match = slow.pattern.exec(content)) !== null) {
+                    const lineNum = content.substring(0, match.index).split("\n").length;
+                    issues.push({
+                        file,
+                        line: lineNum,
+                        type: "slow-pattern",
+                        severity: slow.severity,
+                        message: slow.message,
+                    });
+                }
+            }
+        }
+        const hasErrors = issues.some((i) => i.severity === "error");
+        return {
+            name: "E2E Performance Patterns",
+            passed: !hasErrors || this.warnOnly,
+            blocking: false, // Performance is non-blocking
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Check 6: Test Organization
+     */
+    async checkTestOrganization() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await getE2ESpecFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            // Check for test.describe usage (also accept .skip, .serial, .parallel variants)
+            const hasDescribe = /test\.describe(\.(skip|serial|parallel|only|fixme))?\s*\(/.test(content);
+            if (!hasDescribe && content.includes("test(")) {
+                issues.push({
+                    file,
+                    line: 1,
+                    type: "missing-describe",
+                    severity: "warning",
+                    message: "Tests should be organized with test.describe()",
+                    suggestion: "Wrap related tests in test.describe() blocks",
+                });
+            }
+            // Check for proper imports
+            if (!content.includes("from '@playwright/test'") &&
+                !content.includes('from "@playwright/test"')) {
+                issues.push({
+                    file,
+                    line: 1,
+                    type: "missing-import",
+                    severity: "warning",
+                    message: "Missing Playwright test import",
+                    suggestion: "Add: import { test, expect } from '@playwright/test'",
+                });
+            }
+        }
+        return {
+            name: "E2E Test Organization",
+            passed: true, // Non-blocking
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Check 7: Assertion Quality
+     * Detects tests that only use weak assertions (toBeVisible only) without verifying actual content/state
+     */
+    async checkAssertionQuality() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await getE2ESpecFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            // Split into test blocks
+            const testBlocks = content.split(/\btest\s*\(/);
+            testBlocks.forEach((block, blockIndex) => {
+                if (blockIndex === 0)
+                    return; // Skip before first test
+                // Extract test name
+                const nameMatch = block.match(/^["'`]([^"'`]+)["'`]/);
+                const testName = nameMatch ? nameMatch[1] : `test #${blockIndex}`;
+                // Get test body (up to closing of test)
+                const testBody = block.substring(0, Math.min(block.length, 2000));
+                // Count assertion types
+                const strongAssertions = ASSERTION_QUALITY_PATTERNS.strong.filter((p) => p.test(testBody)).length;
+                const weakAssertions = ASSERTION_QUALITY_PATTERNS.weak.filter((p) => p.test(testBody)).length;
+                const totalExpects = (testBody.match(/expect\s*\(/g) ?? []).length;
+                // Flag tests with only weak assertions
+                if (totalExpects > 0 && strongAssertions === 0 && weakAssertions > 0) {
+                    // Skip display/render tests
+                    const isDisplayTest = /\b(display|render|show|visible|appear|load)\b/i.test(testName);
+                    if (!isDisplayTest) {
+                        issues.push({
+                            file,
+                            line: 1,
+                            type: "weak-assertions-only",
+                            severity: "warning",
+                            message: `Test "${testName}" uses only weak assertions (visibility checks)`,
+                            suggestion: "Add content verification: toHaveText, toContainText, toHaveValue, or toHaveURL",
+                        });
+                    }
+                }
+            });
+        }
+        return {
+            name: "E2E Assertion Quality",
+            passed: true, // Non-blocking
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Check 8: Test Isolation
+     * Detects patterns that can cause flaky tests due to shared state
+     */
+    async checkTestIsolation() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await getE2ESpecFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            // Track if we're inside a function/block
+            let braceDepth = 0;
+            let inDescribeOrTest = false;
+            // Check for module-level mutable state
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i] ?? "";
+                // Track brace depth to detect module-level vs function-level variables
+                const openBraces = (line.match(/\{/g) ?? []).length;
+                const closeBraces = (line.match(/\}/g) ?? []).length;
+                // Check if entering a describe/test block
+                if (/test\.describe\s*\(|test\s*\(/.test(line)) {
+                    inDescribeOrTest = true;
+                }
+                braceDepth += openBraces - closeBraces;
+                // Only flag module-level let (braceDepth 0 and not yet in test blocks)
+                if (braceDepth === 0 && !inDescribeOrTest && i < 50) {
+                    // Detect: let someVar = ... at module level (not inside function)
+                    if (/^let\s+\w+\s*=/.test(line.trim()) &&
+                        !line.includes("readonly") &&
+                        !line.includes("// isolation-ok")) {
+                        // Check if this is before any test block
+                        const remainingContent = lines.slice(i).join("\n");
+                        if (remainingContent.includes("test(") || remainingContent.includes("test.describe(")) {
+                            issues.push({
+                                file,
+                                line: i + 1,
+                                type: "mutable-module-state",
+                                severity: "warning",
+                                message: "Mutable module-level variable may cause test pollution",
+                                suggestion: "Use test.beforeEach() to reset state, or use const/readonly, or add // isolation-ok",
+                            });
+                        }
+                    }
+                }
+                // Detect beforeAll with page access (can cause isolation issues)
+                if (/beforeAll\s*\(\s*async/.test(line)) {
+                    const blockEnd = Math.min(i + 20, lines.length);
+                    const beforeAllBlock = lines.slice(i, blockEnd).join("\n");
+                    if (/page\./.test(beforeAllBlock) && !beforeAllBlock.includes("// isolation-ok")) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "beforeAll-page-access",
+                            severity: "warning",
+                            message: "Accessing page in beforeAll can cause parallel execution issues",
+                            suggestion: "Use beforeEach for page setup, or add // isolation-ok comment if intentional",
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            name: "E2E Test Isolation",
+            passed: true, // Non-blocking
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Check 9: Selector Stability
+     * Detects brittle selectors that can cause flaky tests
+     */
+    async checkSelectorStability() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await getE2ESpecFiles();
+        const brittlePatterns = [
+            {
+                pattern: /locator\s*\(\s*['"`]\.[\w-]+['"`]\s*\)/g,
+                name: "class-selector",
+                message: "Class selectors are brittle",
+            },
+            {
+                pattern: /locator\s*\(\s*['"`]div\s*>\s*div/g,
+                name: "nested-div",
+                message: "Nested div selectors are very brittle",
+            },
+            {
+                pattern: /locator\s*\(\s*['"`]#(?!root|app|__next)[\w-]+['"`]\s*\)/g,
+                name: "id-selector",
+                message: "ID selectors can be brittle (prefer data-testid)",
+            },
+            {
+                pattern: /:nth-child\s*\(/g,
+                name: "nth-child",
+                message: "nth-child selectors break when order changes",
+            },
+            {
+                pattern: /\[class\*?=/g,
+                name: "class-attribute",
+                message: "Class attribute selectors are brittle",
+            },
+        ];
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (const { pattern, name, message } of brittlePatterns) {
+                let match;
+                const regex = new RegExp(pattern.source, pattern.flags);
+                while ((match = regex.exec(content)) !== null) {
+                    const lineNum = content.substring(0, match.index).split("\n").length;
+                    // Allow suppression with comment on same line or up to 3 lines before
+                    const lineIndex = lineNum - 1;
+                    const contextStart = Math.max(0, lineIndex - 3);
+                    const contextEnd = Math.min(lineIndex + 1, lines.length);
+                    const context = lines.slice(contextStart, contextEnd).join("\n");
+                    if (context.includes("selector-ok") || context.includes("e2e-allow")) {
+                        continue;
+                    }
+                    issues.push({
+                        file,
+                        line: lineNum,
+                        type: name,
+                        severity: "info",
+                        message,
+                        suggestion: "Use getByRole, getByLabel, getByTestId, or getByText instead",
+                    });
+                }
+            }
+        }
+        return {
+            name: "E2E Selector Stability",
+            passed: true, // Non-blocking (info only)
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Check 10: Critical Route Coverage
+     * Ensures critical user paths have E2E test coverage
+     */
+    async checkCriticalRouteCoverage() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await getE2ESpecFiles();
+        // Build a map of routes tested
+        const testedRoutes = new Map();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            // Find goto() calls - supports both page.goto() and goto(page, url) patterns
+            // Pattern 1: page.goto("/route") or page.goto('/route') or page.goto(`/route`)
+            // Pattern 2: goto(page, "/route") - custom helper pattern
+            const gotoPatterns = [
+                /page\.goto\s*\(\s*['"`]([^'"`]+)['"`]/g,
+                /goto\s*\(\s*page\s*,\s*['"`]([^'"`]+)['"`]/g,
+                /goto\s*\(\s*['"`]([^'"`]+)['"`]/g,
+            ];
+            for (const pattern of gotoPatterns) {
+                const gotoMatches = Array.from(content.matchAll(pattern));
+                for (const match of gotoMatches) {
+                    const route = match[1] ?? "";
+                    for (const criticalRoute of CRITICAL_ROUTES_REQUIRING_TESTS) {
+                        if (route.startsWith(criticalRoute.route) || route.includes(criticalRoute.route)) {
+                            testedRoutes.set(criticalRoute.route, (testedRoutes.get(criticalRoute.route) ?? 0) + 1);
+                        }
+                    }
+                }
+            }
+        }
+        // Check which critical routes lack coverage
+        for (const { route, minTests, severity } of CRITICAL_ROUTES_REQUIRING_TESTS) {
+            const testCount = testedRoutes.get(route) ?? 0;
+            if (testCount < minTests) {
+                issues.push({
+                    file: "tests/e2e/",
+                    line: 0,
+                    type: "missing-route-coverage",
+                    severity: severity === "critical" ? "error" : "warning",
+                    message: `Critical route "${route}" has ${testCount}/${minTests} required E2E tests`,
+                    suggestion: `Add E2E tests that navigate to and verify ${route} functionality`,
+                });
+            }
+        }
+        const hasErrors = issues.some((i) => i.severity === "error");
+        return {
+            name: "E2E Critical Route Coverage",
+            passed: !hasErrors || this.warnOnly,
+            blocking: !this.warnOnly,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Run all checks
+     */
+    async runAll() {
+        const checks = [];
+        checks.push(await this.checkBestPractices());
+        checks.push(await this.checkOutcomeValidation());
+        checks.push(await this.checkFlakePatterns());
+        checks.push(await this.checkTimeoutLimits());
+        checks.push(await this.checkPerformancePatterns());
+        checks.push(await this.checkTestOrganization());
+        checks.push(await this.checkAssertionQuality());
+        checks.push(await this.checkTestIsolation());
+        checks.push(await this.checkSelectorStability());
+        checks.push(await this.checkCriticalRouteCoverage());
+        const passed = checks.every((c) => c.passed || !c.blocking);
+        const totalDuration = checks.reduce((sum, c) => sum + c.duration, 0);
+        const allIssues = checks.flatMap((c) => c.issues);
+        const errors = allIssues.filter((i) => i.severity === "error").length;
+        const warnings = allIssues.filter((i) => i.severity === "warning").length;
+        return {
+            module: "E2E Validation",
+            passed,
+            totalDuration,
+            checks,
+            summary: {
+                total: checks.length,
+                passed: checks.filter((c) => c.passed).length,
+                failed: checks.filter((c) => !c.passed).length,
+                errors,
+                warnings,
+            },
+        };
+    }
+}
+exports.E2EValidationModule = E2EValidationModule;
+// CLI
+async function main() {
+    const args = process.argv.slice(2);
+    const subCommand = args.find((a) => !a.startsWith("--"));
+    const warnOnly = args.includes("--warn");
+    const verbose = args.includes("--verbose");
+    console.log(`\n${console_chars_1.emoji.search} E2E Validation Preflight (Consolidated)\n`);
+    console.log((0, console_chars_1.createDivider)(70, "heavy"));
+    const module = new E2EValidationModule({ verbose, warnOnly });
+    let result;
+    switch (subCommand) {
+        case "best-practices":
+            result = await module.checkBestPractices();
+            break;
+        case "outcomes":
+            result = await module.checkOutcomeValidation();
+            break;
+        case "flakes":
+            result = await module.checkFlakePatterns();
+            break;
+        case "timeouts":
+            result = await module.checkTimeoutLimits();
+            break;
+        case "performance":
+            result = await module.checkPerformancePatterns();
+            break;
+        case "organization":
+            result = await module.checkTestOrganization();
+            break;
+        case "assertions":
+        case "assertion-quality":
+            result = await module.checkAssertionQuality();
+            break;
+        case "isolation":
+            result = await module.checkTestIsolation();
+            break;
+        case "selectors":
+        case "selector-stability":
+            result = await module.checkSelectorStability();
+            break;
+        case "coverage":
+        case "route-coverage":
+            result = await module.checkCriticalRouteCoverage();
+            break;
+        default:
+            result = await module.runAll();
+    }
+    // Report results
+    if ("checks" in result) {
+        // Full module result
+        const moduleResult = result;
+        for (const check of moduleResult.checks) {
+            const status = check.passed ? console_chars_1.emoji.success : check.blocking ? console_chars_1.emoji.error : console_chars_1.emoji.warning;
+            console.log(`\n${status} ${check.name} (${check.duration}ms)`);
+            if (check.issues.length > 0 && (verbose || !check.passed)) {
+                const displayIssues = verbose ? check.issues : check.issues.slice(0, 5);
+                for (const issue of displayIssues) {
+                    const icon = issue.severity === "error" ? console_chars_1.emoji.error : console_chars_1.emoji.warning;
+                    console.log(`   ${icon} ${path.basename(issue.file)}:${issue.line} - ${issue.message}`);
+                }
+                if (!verbose && check.issues.length > 5) {
+                    console.log(`   ... and ${check.issues.length - 5} more issues`);
+                }
+            }
+        }
+        console.log(`\n${(0, console_chars_1.createDivider)(70, "heavy")}`);
+        console.log(`${console_chars_1.emoji.chart} Summary: ${moduleResult.summary.passed}/${moduleResult.summary.total} checks passed`);
+        console.log(`   Errors: ${moduleResult.summary.errors}, Warnings: ${moduleResult.summary.warnings}`);
+        console.log(`   Duration: ${moduleResult.totalDuration}ms`);
+        if (!moduleResult.passed) {
+            console.log(`\n${console_chars_1.emoji.error} E2E validation failed\n`);
+            process.exit(1);
+        }
+        else {
+            console.log(`\n${console_chars_1.emoji.success} E2E validation passed\n`);
+        }
+    }
+    else {
+        // Single check result
+        const checkResult = result;
+        const status = checkResult.passed ? console_chars_1.emoji.success : console_chars_1.emoji.error;
+        console.log(`\n${status} ${checkResult.name} (${checkResult.duration}ms)`);
+        console.log(`   Issues: ${checkResult.issues.length}`);
+        if (!checkResult.passed) {
+            process.exit(1);
+        }
+    }
+}
+main().catch((err) => {
+    console.error(`${console_chars_1.emoji.error} E2E validation crashed:`, err);
+    process.exit(1);
+});
+//# sourceMappingURL=e2e-validation.js.map