playwright-ai-reporter 0.0.4

package/dist/utils/utils.js

@@ -0,0 +1,371 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = exports.TestUtils = void 0;
+const colors_1 = require("../colors");
+// Adding required enum or interface definitions for Team
+var Team;
+(function (Team) {
+    Team["Frontend"] = "Frontend";
+    Team["Backend"] = "Backend";
+    Team["QA"] = "QA";
+    Team["DevOps"] = "DevOps";
+    Team["Performance"] = "Performance";
+    Team["Security"] = "Security";
+    Team["Accessibility"] = "Accessibility";
+    Team["Mobile"] = "Mobile";
+    Team["API"] = "API";
+    Team["Database"] = "Database";
+    Team["Analytics"] = "Analytics";
+    Team["Infrastructure"] = "Infrastructure";
+    Team["Monitoring"] = "Monitoring";
+    Team["Documentation"] = "Documentation";
+    Team["Support"] = "Support";
+    Team["Marketing"] = "Marketing";
+    Team["Sales"] = "Sales";
+    Team["Training"] = "Training";
+    Team["Research"] = "Research";
+    Team["Compliance"] = "Compliance";
+    Team["Legal"] = "Legal";
+    Team["Product"] = "Product";
+    Team["Design"] = "Design";
+    Team["UserExperience"] = "User Experience";
+    Team["UserInterface"] = "User Interface";
+    Team["BusinessIntelligence"] = "Business Intelligence";
+    Team["DataScience"] = "Data Science";
+    Team["DataEngineering"] = "Data Engineering";
+    Team["DataAnalytics"] = "Data Analytics";
+    Team["DataVisualization"] = "Data Visualization";
+    Team["DataGovernance"] = "Data Governance";
+    Team["DataQuality"] = "Data Quality";
+    // Add other teams as needed
+})(Team || (Team = {}));
+const FallbackTeam = 'Unknown'; // Default fallback when no team is identified
+/**
+ * Utility class containing static methods for test result processing and calculations.
+ * Provides functionality for formatting time, calculating statistics, and processing test results.
+ */
+class TestUtils {
+    /**
+     * Formats a time duration from seconds into a human-readable string.
+     * Converts to minutes if the duration is longer than 60 seconds.
+     *
+     * @param timeInSeconds - The time duration to format in seconds
+     * @returns A formatted string with appropriate units (e.g., "1.23s" or "2.50min")
+     */
+    static formatTime(timeInSeconds) {
+        return timeInSeconds < 60 ? `${timeInSeconds.toFixed(2)}s` : `${(timeInSeconds / 60).toFixed(2)}min`;
+    }
+    /**
+     * Calculates the average duration from an array of time measurements.
+     *
+     * @param durations - Array of durations in seconds
+     * @returns The average duration in seconds, or 0 if the array is empty
+     */
+    static calculateAverageTime(durations) {
+        return durations.length === 0 ? 0 : durations.reduce((sum, duration) => sum + duration, 0) / durations.length;
+    }
+    /**
+     * Finds the slowest tests from all test records.
+     * Only considers passed tests when calculating the slowest ones.
+     *
+     * @param testRecords - Map of all test records
+     * @param limit - Maximum number of slow tests to return
+     * @returns Array of the slowest tests, sorted by duration
+     */
+    static findSlowestTests(testRecords, limit) {
+        return Array.from(testRecords.values())
+            .flatMap(({ test, attempts }) => attempts
+            .filter((a) => a.status === 'passed')
+            .map((a) => ({
+            testTitle: test.testTitle,
+            duration: a.duration,
+        })))
+            .sort((a, b) => b.duration - a.duration)
+            .slice(0, limit);
+    }
+    /**
+     * Categorizes the error message into predefined types
+     * @param message - Error message
+     * @returns Error category
+     */
+    static categorizeError(message) {
+        if (message.includes('No node found') || message.includes('not visible')) {
+            return 'ElementNotFound';
+        }
+        else if (message.includes('Timeout') || message.includes('timed out')) {
+            return 'Timeout/DelayedElement';
+        }
+        else if (message.includes('selector') || message.includes('locator')) {
+            return 'SelectorChanged';
+        }
+        else if (message.includes('expect(') || message.includes('assertion failed')) {
+            return 'AssertionFailure';
+        }
+        else if (message.includes('Network') || message.includes('fetch failed') || message.includes('status=')) {
+            return 'NetworkError';
+        }
+        else if (message.includes('javascript error') ||
+            message.includes('undefined is not') ||
+            message.includes('null')) {
+            return 'JavaScriptError';
+        }
+        else if (message.includes('navigation') || message.includes('page.goto')) {
+            return 'NavigationError';
+        }
+        else if (message.includes('element is not clickable') || message.includes('intercepted')) {
+            return 'ElementInteractionError';
+        }
+        else if (message.includes('permission') || message.includes('access denied')) {
+            return 'PermissionError';
+        }
+        else {
+            return 'Unknown';
+        }
+    }
+    /**
+     * Convert test outcome to status
+     * @param outcome - Test outcome
+     * @returns Standardized status
+     */
+    static outcomeToStatus(outcome) {
+        switch (outcome) {
+            case 'skipped':
+                return 'skipped';
+            case 'expected':
+                return 'passed';
+            case 'unexpected':
+                return 'failed';
+            case 'flaky':
+                return 'failed';
+            default:
+                return outcome;
+        }
+    }
+    /**
+     * Determines the team that owns a test based on test name and annotations
+     * @param test - Test case to analyze
+     * @returns Name of the team that owns the test
+     */
+    static getOwningTeam(test) {
+        const testName = test.title || '';
+        for (const team in Team) {
+            if (testName.includes(this.wrap(team))) {
+                return team;
+            }
+        }
+        const teamName = test.annotations.find((a) => a.type === 'team')?.description;
+        if (teamName && teamName in Team) {
+            return teamName;
+        }
+        const ownerName = test.annotations.find((a) => a.type === 'owner')?.description;
+        if (ownerName && ownerName in Team) {
+            return ownerName;
+        }
+        if (process.env.FALLBACK_TEAM && process.env.FALLBACK_TEAM !== '' && process.env.FALLBACK_TEAM in Team) {
+            return process.env.FALLBACK_TEAM;
+        }
+        return FallbackTeam;
+    }
+    /**
+     * Helper method to wrap a string for team name matching
+     * @param text - Text to wrap
+     * @returns Wrapped text
+     */
+    static wrap(text) {
+        return `[${text}]`;
+    }
+    /**
+     * Processes all test records to generate comprehensive test results.
+     * Calculates passed, failed, and skipped test counts, and collects timing information.
+     *
+     * @param testRecords - Map of all test records
+     * @returns Object containing test counts, failures, and timing information
+     */
+    static processTestResults(testRecords) {
+        let passedCount = 0;
+        let testCount = 0;
+        let skippedCount = 0;
+        let failedCount = 0;
+        const failures = [];
+        const passedDurations = [];
+        for (const { test, attempts } of testRecords.values()) {
+            testCount++;
+            const finalOutcome = test.outcome;
+            const finalAttempt = attempts[attempts.length - 1];
+            if (finalOutcome === 'expected' || finalOutcome === 'flaky') {
+                passedCount++;
+                passedDurations.push(...attempts.filter((a) => a.status === 'passed').map((a) => a.duration));
+            }
+            else if (finalOutcome === 'unexpected') {
+                const isTimeout = finalAttempt.errors.some((e) => e.message.includes('timeout'));
+                const combinedStack = finalAttempt.errors.map((e) => e.stack || '').join('\n');
+                const errorMessage = finalAttempt.errors[0]?.message || '';
+                const errorCategory = this.categorizeError(errorMessage);
+                failures.push({
+                    testId: test.testId,
+                    testTitle: test.testTitle,
+                    suiteTitle: test.suiteTitle || 'Unknown Suite',
+                    errorMessage: errorMessage,
+                    errorStack: combinedStack,
+                    duration: finalAttempt.duration,
+                    owningTeam: test.owningTeam || 'Unknown Team',
+                    isTimeout,
+                    errorCategory,
+                    testFile: test.testFile,
+                    location: test.location,
+                });
+            }
+            else if (finalOutcome === 'skipped') {
+                skippedCount++;
+            }
+            else {
+                const errorMessage = finalAttempt.status === 'interrupted' ? 'Test was interrupted' : `Unknown outcome: ${finalOutcome}`;
+                const errorCategory = this.categorizeError(errorMessage);
+                failures.push({
+                    testId: test.testId,
+                    testTitle: test.testTitle,
+                    suiteTitle: test.suiteTitle || 'Unknown Suite',
+                    errorMessage: errorMessage,
+                    errorStack: '',
+                    duration: finalAttempt.duration,
+                    owningTeam: test.owningTeam || 'Unknown Team',
+                    isTimeout: false,
+                    errorCategory,
+                    testFile: test.testFile,
+                    location: test.location,
+                });
+            }
+        }
+        failedCount = failures.length;
+        return {
+            passedCount,
+            testCount,
+            skippedCount,
+            failedCount,
+            failures,
+            passedDurations,
+        };
+    }
+}
+exports.TestUtils = TestUtils;
+/**
+ * Logger class responsible for formatting and outputting test results.
+ * Provides methods for logging test summaries, metrics, and failures with appropriate formatting.
+ */
+class Logger {
+    /**
+     * Logs the overall test run summary with appropriate coloring.
+     * Includes total tests, passed tests, skipped tests, and total time.
+     *
+     * @param summary - The test summary to log
+     */
+    static logSummary(summary) {
+        console.log('\n');
+        console.log(`${colors_1.colors.fgBlue}===============================================${colors_1.colors.reset}`);
+        console.log(`${colors_1.colors.fgCyan}Test Summary:${colors_1.colors.reset}`);
+        console.log(`${colors_1.colors.fgBlue}===============================================${colors_1.colors.reset}`);
+        if (summary.failures.length > 0) {
+            console.log(`${colors_1.colors.fgRed}❌ ${summary.failures.length} of ${summary.testCount} tests failed | ` +
+                `${summary.passedCount} passed | ${summary.skippedCount} skipped | ⏱ Total: ${summary.totalTimeDisplay}${colors_1.colors.reset}`);
+        }
+        else {
+            console.log(`${colors_1.colors.fgGreen}✅ All ${summary.testCount} tests passed | ` +
+                `${summary.skippedCount} skipped | ⏱ Total: ${summary.totalTimeDisplay}${colors_1.colors.reset}`);
+        }
+        // Display build information if available
+        if (summary.buildInfo) {
+            this.logBuildInfo(summary.buildInfo);
+        }
+        this.logMetrics(summary);
+        // Add warning for skipped tests
+        if (summary.skippedCount > 0) {
+            console.log(`\n${colors_1.colors.fgYellow}⚠️  Warning: ${summary.skippedCount} test${summary.skippedCount === 1 ? ' was' : 's were'} skipped.${colors_1.colors.reset}`);
+            console.log(`${colors_1.colors.fgYellow}   Please ensure to test the skipped scenarios manually before deployment.${colors_1.colors.reset}`);
+        }
+        console.log(`${colors_1.colors.fgBlue}===============================================${colors_1.colors.reset}`);
+    }
+    /**
+     * Logs build information if available
+     *
+     * @param buildInfo - The build information to log
+     */
+    static logBuildInfo(buildInfo) {
+        if (!buildInfo.isPipeline) {
+            console.log(`${colors_1.colors.fgMagenta}🖥️ Running locally${colors_1.colors.reset}`);
+            return;
+        }
+        console.log(`${colors_1.colors.fgMagenta}\nBuild Information:${colors_1.colors.reset}`);
+        console.log(`${colors_1.colors.fgMagenta}- CI System: ${buildInfo.executionSystem || 'Unknown CI'}${colors_1.colors.reset}`);
+        if (buildInfo.buildNumber) {
+            console.log(`${colors_1.colors.fgMagenta}- Build: ${buildInfo.buildNumber}${colors_1.colors.reset}`);
+        }
+        if (buildInfo.buildBranch) {
+            console.log(`${colors_1.colors.fgMagenta}- Branch: ${buildInfo.buildBranch}${colors_1.colors.reset}`);
+        }
+        if (buildInfo.commitId) {
+            console.log(`${colors_1.colors.fgMagenta}- Commit: ${buildInfo.commitId.substring(0, 8)}${colors_1.colors.reset}`);
+        }
+        if (buildInfo.commitId) {
+            console.log(`${colors_1.colors.fgMagenta}- Commit: ${buildInfo.commitId.substring(0, 8)}${colors_1.colors.reset}`);
+        }
+        if (buildInfo.buildLink) {
+            console.log(`${colors_1.colors.fgMagenta}- Build link: ${buildInfo.buildLink}${colors_1.colors.reset}`);
+        }
+        if (buildInfo.artifactsLink) {
+            console.log(`${colors_1.colors.fgMagenta}- Artifacts: ${buildInfo.artifactsLink}${colors_1.colors.reset}`);
+        }
+        // Only show test link for Azure Pipelines, as this is specific to that system
+        if (buildInfo.testLink && buildInfo.executionSystem === 'Azure Pipelines') {
+            console.log(`${colors_1.colors.fgMagenta}- Test Results: ${buildInfo.testLink}${colors_1.colors.reset}`);
+        }
+        if (buildInfo.commitLink && buildInfo.executionSystem === 'GitHub Actions') {
+            console.log(`${colors_1.colors.fgMagenta}- Commit: ${buildInfo.commitLink}${colors_1.colors.reset}`);
+        }
+    }
+    /**
+     * Logs detailed metrics about the test run.
+     * Includes average test time and information about slow tests.
+     *
+     * @param summary - The test summary containing metrics to log
+     */
+    static logMetrics(summary) {
+        console.log(`${colors_1.colors.fgMagenta}\nAdditional Metrics:${colors_1.colors.reset}`);
+        console.log(`${colors_1.colors.fgMagenta}- Average passed test time: ${summary.averageTime.toFixed(2)}s${colors_1.colors.reset}`);
+        if (summary.slowestTest > 0) {
+            console.log(`${colors_1.colors.fgMagenta}- Slowest test took: ${summary.slowestTest.toFixed(2)}s${colors_1.colors.reset}`);
+            console.log(`${colors_1.colors.fgMagenta}- Top 3 slowest tests:${colors_1.colors.reset}`);
+            summary.slowestTests.forEach((test, index) => {
+                console.log(`  ${index + 1}. ${test.testTitle}: ` +
+                    `${colors_1.colors.fgYellow}${test.duration.toFixed(2)}s${colors_1.colors.reset}`);
+            });
+        }
+    }
+    /**
+     * Logs detailed information about test failures.
+     * Includes test title, stack trace, and timeout information.
+     *
+     * @param failures - Array of test failures to log
+     */
+    static logFailures(failures) {
+        console.log('\n');
+        console.log(`${colors_1.colors.fgRed}===============================================${colors_1.colors.reset}`);
+        console.log(`${colors_1.colors.fgRed}Test Failures:${colors_1.colors.reset}`);
+        console.log(`${colors_1.colors.fgRed}===============================================${colors_1.colors.reset}`);
+        failures.forEach((failure, index) => {
+            console.log('\n');
+            console.group(`--- Failure #${index + 1} ---`);
+            console.log(`  Test: ${failure.testTitle}`);
+            console.log(`  ${colors_1.colors.fgGreen}Category: ${failure.errorCategory}${colors_1.colors.reset}`);
+            if (failure.errorStack) {
+                console.log(`  Stack Trace:\n${failure.errorStack}`);
+            }
+            if (failure.isTimeout) {
+                console.log(`${colors_1.colors.fgYellow}  (This failure involved a timeout.)${colors_1.colors.reset}`);
+            }
+            console.groupEnd();
+        });
+        console.log(`${colors_1.colors.fgRed}\n❌ Tests failed with exit code 1${colors_1.colors.reset}`);
+        console.log(`${colors_1.colors.fgRed}===============================================${colors_1.colors.reset}`);
+    }
+}
+exports.Logger = Logger;