playwright-ai-reporter 0.0.4

package/dist/providers/pr/GitHubPRProvider.js

@@ -0,0 +1,320 @@
+"use strict";
+/**
+ * GitHub Pull Request Provider
+ */
+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.GitHubPRProvider = void 0;
+class GitHubPRProvider {
+    constructor(config) {
+        this.config = config;
+        this.initialized = this.initialize();
+    }
+    async initialize() {
+        const { Octokit } = await Promise.resolve().then(() => __importStar(require('@octokit/rest')));
+        this.octokit = new Octokit({ auth: this.config.token });
+    }
+    async createBranch(branchName, baseBranch) {
+        await this.initialized;
+        try {
+            // Get the reference of the base branch
+            const baseRef = await this.octokit.git.getRef({
+                owner: this.config.owner,
+                repo: this.config.repo,
+                ref: `heads/${baseBranch}`,
+            });
+            // Create new branch from base
+            await this.octokit.git.createRef({
+                owner: this.config.owner,
+                repo: this.config.repo,
+                ref: `refs/heads/${branchName}`,
+                sha: baseRef.data.object.sha,
+            });
+            console.log(`Created branch: ${branchName} from ${baseBranch}`);
+            return true;
+        }
+        catch (error) {
+            console.error('Error creating branch:', error.message);
+            return false;
+        }
+    }
+    async commitChanges(branchName, changes, commitMessage) {
+        await this.initialized;
+        try {
+            // Get the current commit SHA of the branch
+            const branchRef = await this.octokit.git.getRef({
+                owner: this.config.owner,
+                repo: this.config.repo,
+                ref: `heads/${branchName}`,
+            });
+            const currentCommitSha = branchRef.data.object.sha;
+            // Get the tree of the current commit
+            const currentCommit = await this.octokit.git.getCommit({
+                owner: this.config.owner,
+                repo: this.config.repo,
+                commit_sha: currentCommitSha,
+            });
+            const baseTreeSha = currentCommit.data.tree.sha;
+            // Create blobs for each file change
+            const tree = [];
+            for (const change of changes) {
+                if (change.action === 'delete') {
+                    tree.push({
+                        path: change.path,
+                        mode: '100644',
+                        type: 'blob',
+                        sha: null,
+                    });
+                }
+                else {
+                    const blob = await this.octokit.git.createBlob({
+                        owner: this.config.owner,
+                        repo: this.config.repo,
+                        content: Buffer.from(change.content).toString('base64'),
+                        encoding: 'base64',
+                    });
+                    tree.push({
+                        path: change.path,
+                        mode: '100644',
+                        type: 'blob',
+                        sha: blob.data.sha,
+                    });
+                }
+            }
+            // Create a new tree
+            const newTree = await this.octokit.git.createTree({
+                owner: this.config.owner,
+                repo: this.config.repo,
+                base_tree: baseTreeSha,
+                tree,
+            });
+            // Create a new commit
+            const newCommit = await this.octokit.git.createCommit({
+                owner: this.config.owner,
+                repo: this.config.repo,
+                message: commitMessage,
+                tree: newTree.data.sha,
+                parents: [currentCommitSha],
+            });
+            // Update the branch reference
+            await this.octokit.git.updateRef({
+                owner: this.config.owner,
+                repo: this.config.repo,
+                ref: `heads/${branchName}`,
+                sha: newCommit.data.sha,
+            });
+            console.log(`Committed changes to ${branchName}: ${newCommit.data.sha}`);
+            return newCommit.data.sha;
+        }
+        catch (error) {
+            console.error('Error committing changes:', error.message);
+            return null;
+        }
+    }
+    async createPullRequest(options) {
+        await this.initialized;
+        try {
+            const pr = await this.octokit.pulls.create({
+                owner: this.config.owner,
+                repo: this.config.repo,
+                title: options.title,
+                body: options.description,
+                head: options.sourceBranch,
+                base: options.targetBranch,
+                draft: options.draft,
+            });
+            // Add reviewers if specified
+            if (options.reviewers && options.reviewers.length > 0) {
+                await this.octokit.pulls.requestReviewers({
+                    owner: this.config.owner,
+                    repo: this.config.repo,
+                    pull_number: pr.data.number,
+                    reviewers: options.reviewers,
+                });
+            }
+            // Add labels if specified
+            if (options.labels && options.labels.length > 0) {
+                await this.octokit.issues.addLabels({
+                    owner: this.config.owner,
+                    repo: this.config.repo,
+                    issue_number: pr.data.number,
+                    labels: options.labels,
+                });
+            }
+            console.log(`Created pull request: #${pr.data.number}`);
+            return {
+                id: pr.data.id.toString(),
+                number: pr.data.number,
+                url: pr.data.html_url,
+                status: 'open',
+                sourceBranch: options.sourceBranch,
+                targetBranch: options.targetBranch,
+            };
+        }
+        catch (error) {
+            console.error('Error creating pull request:', error.message);
+            return null;
+        }
+    }
+    async updatePullRequest(prId, updates) {
+        await this.initialized;
+        try {
+            const prNumber = parseInt(prId);
+            const updateData = {};
+            if (updates.title)
+                updateData.title = updates.title;
+            if (updates.description)
+                updateData.body = updates.description;
+            const pr = await this.octokit.pulls.update({
+                owner: this.config.owner,
+                repo: this.config.repo,
+                pull_number: prNumber,
+                ...updateData,
+            });
+            return {
+                id: pr.data.id.toString(),
+                number: pr.data.number,
+                url: pr.data.html_url,
+                status: pr.data.state === 'closed' ? (pr.data.merged ? 'merged' : 'closed') : 'open',
+                sourceBranch: pr.data.head.ref,
+                targetBranch: pr.data.base.ref,
+            };
+        }
+        catch (error) {
+            console.error('Error updating pull request:', error.message);
+            return null;
+        }
+    }
+    async addComment(prId, comment) {
+        await this.initialized;
+        try {
+            const prNumber = parseInt(prId);
+            await this.octokit.issues.createComment({
+                owner: this.config.owner,
+                repo: this.config.repo,
+                issue_number: prNumber,
+                body: comment,
+            });
+            console.log(`Added comment to PR #${prNumber}`);
+            return true;
+        }
+        catch (error) {
+            console.error('Error adding comment to pull request:', error.message);
+            return false;
+        }
+    }
+    async closePullRequest(prId, comment) {
+        await this.initialized;
+        try {
+            const prNumber = parseInt(prId);
+            if (comment) {
+                await this.addComment(prId, comment);
+            }
+            await this.octokit.pulls.update({
+                owner: this.config.owner,
+                repo: this.config.repo,
+                pull_number: prNumber,
+                state: 'closed',
+            });
+            console.log(`Closed PR #${prNumber}`);
+            return true;
+        }
+        catch (error) {
+            console.error('Error closing pull request:', error.message);
+            return false;
+        }
+    }
+    async createAutoFixPR(failures, baseBranch) {
+        await this.initialized;
+        try {
+            const branchName = `autofix/test-failures-${Date.now()}`;
+            // Create branch
+            const branchCreated = await this.createBranch(branchName, baseBranch);
+            if (!branchCreated) {
+                throw new Error('Failed to create branch');
+            }
+            // Prepare file changes
+            const changes = failures.map(({ filePath, fixContent }) => ({
+                path: filePath,
+                content: fixContent,
+                action: 'modify',
+            }));
+            // Commit changes
+            const commitSha = await this.commitChanges(branchName, changes, `fix: Auto-fix for ${failures.length} failing test(s)`);
+            if (!commitSha) {
+                throw new Error('Failed to commit changes');
+            }
+            // Create PR description
+            const description = this.generateAutoFixPRDescription(failures);
+            // Create pull request
+            const pr = await this.createPullRequest({
+                sourceBranch: branchName,
+                targetBranch: baseBranch,
+                title: `🤖 Auto-fix: ${failures.length} failing test(s)`,
+                description,
+                labels: ['auto-fix', 'test-failure'],
+                draft: true, // Create as draft by default for review
+            });
+            return pr;
+        }
+        catch (error) {
+            console.error('Error creating auto-fix PR:', error.message);
+            return null;
+        }
+    }
+    generateAutoFixPRDescription(failures) {
+        let description = `## 🤖 Auto-generated Fix for Test Failures\n\n`;
+        description += `This PR contains AI-generated fixes for ${failures.length} failing test(s).\n\n`;
+        description += `⚠️ **Please review carefully before merging!**\n\n`;
+        description += `### Failed Tests\n\n`;
+        failures.forEach(({ failure }, index) => {
+            description += `${index + 1}. **${failure.testTitle}**\n`;
+            description += `   - Suite: ${failure.suiteTitle}\n`;
+            if (failure.testFile) {
+                description += `   - File: \`${failure.testFile}\`\n`;
+            }
+            description += `   - Error: ${failure.errorCategory}\n\n`;
+        });
+        description += `### Modified Files\n\n`;
+        const uniqueFiles = [...new Set(failures.map((f) => f.filePath))];
+        uniqueFiles.forEach((file) => {
+            description += `- \`${file}\`\n`;
+        });
+        description += `\n---\n`;
+        description += `_This PR was automatically created by the Playwright AI Test Reporter_`;
+        return description;
+    }
+}
+exports.GitHubPRProvider = GitHubPRProvider;

package/dist/reporter.d.ts

@@ -0,0 +1,138 @@
+import { Reporter, TestCase, TestResult, FullConfig, Suite } from '@playwright/test/reporter';
+import { ReporterConfig } from './types';
+/**
+ * PlaywrightTestReporter is a modern, maintainable reporter for Playwright tests.
+ * It provides detailed, colorized output of test results with comprehensive metrics
+ * and configurable options for better visibility into test execution.
+ *
+ * Features:
+ * - Colorized output for different test states (passed, failed, skipped, retried)
+ * - Detailed metrics including test duration and slow test identification
+ * - Configurable thresholds for slow tests and timeouts
+ * - Comprehensive error reporting with stack traces
+ * - Support for test retries with clear status indication
+ * - Complete monitoring of all error types including setup/teardown errors
+ * - JSON output files for CI integration and historical tracking
+ */
+export default class PlaywrightTestReporter implements Reporter {
+    private suite;
+    private outputDir;
+    private readonly _testRecords;
+    private _startTime;
+    private readonly _config;
+    private _nonTestErrors;
+    private _hasInterruptedTests;
+    private _fileHandler;
+    /**
+     * Creates a new instance of the PlaywrightTestReporter.
+     *
+     * @param config - Optional configuration object to customize reporter behavior
+     */
+    constructor(config?: ReporterConfig);
+    /**
+     * Called when the test run begins.
+     * Initializes the start time and displays a start message.
+     *
+     * @param config - The full Playwright configuration
+     * @param suite - The root test suite
+     */
+    onBegin(config: FullConfig, suite: Suite): void;
+    /**
+     * Recursively counts the total number of tests in a suite and its children
+     *
+     * @param suite - The test suite to count tests from
+     * @returns The total number of tests
+     * @private
+     */
+    private _countTests;
+    /**
+     * Called when an error occurs during test setup or teardown.
+     * Logs the error with optional stack trace based on configuration.
+     * Now tracks errors to ensure they affect final exit code.
+     *
+     * @param error - The error that occurred
+     */
+    onError(error: Error): void;
+    /**
+     * Called when a test completes (whether passed, failed, or skipped).
+     * Records the test result and logs appropriate output based on the test status.
+     * Now tracks all test statuses including interrupted ones.
+     *
+     * @param test - The test case that completed
+     * @param result - The result of the test execution
+     */
+    onTestEnd(test: TestCase, result: TestResult): void;
+    /**
+     * Called when all tests have completed.
+     * Processes results, displays summary statistics, and sets appropriate exit code.
+     * Now properly handles all error conditions including non-test errors.
+     */
+    onEnd(): Promise<void>;
+    /**
+     * Exits the process with a success code.
+     * Extracted to a method to make the flow clearer and more maintainable.
+     * @private
+     */
+    private _exitWithSuccess;
+    /**
+     * Exits the process with an error code.
+     * Extracted to a method to make the flow clearer and more maintainable.
+     * @private
+     */
+    private _exitWithError;
+    /**
+     * Formats and logs the outcome of a single test with appropriate coloring.
+     * Handles different test states (passed, failed, skipped) and retry attempts.
+     * Now includes handling for interrupted tests and other unexpected statuses.
+     *
+     * @param title - The title of the test
+     * @param result - The result of the test execution
+     * @param timeTakenSec - The time taken by the test in seconds
+     * @private
+     */
+    private _logTestOutcome;
+    /**
+     * Records the status of the last test run in a JSON file
+     * @param hasFailed - Whether any tests failed
+     */
+    private saveLastRunStatus;
+    /**
+     * Generates AI-powered fix suggestions for test failures
+     *
+     * @param failures - Array of test failures
+     * @private
+     */
+    private _generateFixSuggestions;
+    /**
+     * Generates a pull request with the AI-generated fix
+     *
+     * @param failure - The test failure information
+     * @param fixResult - The result from GenAIUtils containing prompt and fix paths
+     * @private
+     */
+    private _generatePullRequest;
+    /**
+     * Creates bugs in the configured bug tracker for test failures
+     *
+     * @param failures - Array of test failures
+     * @private
+     */
+    private _createBugsForFailures;
+    /**
+     * Publishes test results to database
+     *
+     * @param summary - Test run summary
+     * @param allTestCases - All test cases details
+     * @param failures - Test failures
+     * @private
+     */
+    private _publishToDatabase;
+    /**
+     * Sends email notification with test results
+     *
+     * @param summary - Test run summary
+     * @param failures - Test failures
+     * @private
+     */
+    private _sendEmailNotification;
+}