testlens-playwright-reporter 0.3.2 → 0.3.4

package/lib/index.js

@@ -1,908 +0,0 @@
-"use strict";
-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;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TestLensReporter = void 0;
-const crypto_1 = require("crypto");
-const os = __importStar(require("os"));
-const path = __importStar(require("path"));
-const fs = __importStar(require("fs"));
-const https = __importStar(require("https"));
-const axios_1 = __importDefault(require("axios"));
-const child_process_1 = require("child_process");
-// Lazy-load mime module to support ESM
-let mimeModule = null;
-async function getMime() {
-    if (!mimeModule) {
-        const imported = await Promise.resolve().then(() => __importStar(require('mime')));
-        // Handle both default export and named exports
-        mimeModule = imported.default || imported;
-    }
-    return mimeModule;
-}
-class TestLensReporter {
-    constructor(options) {
-        this.config = {
-            apiEndpoint: options.apiEndpoint || 'https://testlens.qa-path.com/api/v1/webhook/playwright',
-            apiKey: options.apiKey, // API key must come from config file
-            enableRealTimeStream: options.enableRealTimeStream !== undefined ? options.enableRealTimeStream : true,
-            enableGitInfo: options.enableGitInfo !== undefined ? options.enableGitInfo : true,
-            enableArtifacts: options.enableArtifacts !== undefined ? options.enableArtifacts : true,
-            enableVideo: options.enableVideo !== undefined ? options.enableVideo : true, // Default to true, override from config
-            enableScreenshot: options.enableScreenshot !== undefined ? options.enableScreenshot : true, // Default to true, override from config
-            batchSize: options.batchSize || 10,
-            flushInterval: options.flushInterval || 5000,
-            retryAttempts: options.retryAttempts !== undefined ? options.retryAttempts : 0,
-            timeout: options.timeout || 60000
-        };
-        if (!this.config.apiKey) {
-            throw new Error('API_KEY is required for TestLensReporter. Pass it as apiKey option in your playwright config.');
-        }
-        // Determine SSL validation behavior
-        let rejectUnauthorized = true; // Default to secure
-        // Check various ways SSL validation can be disabled (in order of precedence)
-        if (this.config.ignoreSslErrors) {
-            // Explicit configuration option
-            rejectUnauthorized = false;
-            console.log('⚠️  SSL certificate validation disabled via ignoreSslErrors option');
-        }
-        else if (this.config.rejectUnauthorized === false) {
-            // Explicit configuration option
-            rejectUnauthorized = false;
-            console.log('⚠️  SSL certificate validation disabled via rejectUnauthorized option');
-        }
-        else if (process.env.NODE_TLS_REJECT_UNAUTHORIZED === '0') {
-            // Environment variable override
-            rejectUnauthorized = false;
-            console.log('⚠️  SSL certificate validation disabled via NODE_TLS_REJECT_UNAUTHORIZED environment variable');
-        }
-        // Set up axios instance with retry logic and enhanced SSL handling
-        this.axiosInstance = axios_1.default.create({
-            baseURL: this.config.apiEndpoint,
-            timeout: this.config.timeout,
-            headers: {
-                'Content-Type': 'application/json',
-                ...(this.config.apiKey && { 'X-API-Key': this.config.apiKey }),
-            },
-            // Enhanced SSL handling with flexible TLS configuration
-            httpsAgent: new https.Agent({
-                rejectUnauthorized: rejectUnauthorized,
-                // Allow any TLS version for better compatibility
-                minVersion: 'TLSv1.2',
-                maxVersion: 'TLSv1.3'
-            })
-        });
-        // Add retry interceptor
-        this.axiosInstance.interceptors.response.use((response) => response, async (error) => {
-            const originalRequest = error.config;
-            if (!originalRequest._retry && error.response?.status >= 500) {
-                originalRequest._retry = true;
-                originalRequest._retryCount = (originalRequest._retryCount || 0) + 1;
-                if (originalRequest._retryCount <= this.config.retryAttempts) {
-                    // Exponential backoff
-                    const delay = Math.pow(2, originalRequest._retryCount) * 1000;
-                    await new Promise(resolve => setTimeout(resolve, delay));
-                    return this.axiosInstance(originalRequest);
-                }
-            }
-            return Promise.reject(error);
-        });
-        this.runId = (0, crypto_1.randomUUID)();
-        this.runMetadata = this.initializeRunMetadata();
-        this.specMap = new Map();
-        this.testMap = new Map();
-    }
-    initializeRunMetadata() {
-        return {
-            id: this.runId,
-            startTime: new Date().toISOString(),
-            environment: 'production',
-            browser: 'multiple',
-            os: `${os.type()} ${os.release()}`,
-            playwrightVersion: this.getPlaywrightVersion(),
-            nodeVersion: process.version
-        };
-    }
-    getPlaywrightVersion() {
-        try {
-            const playwrightPackage = require('@playwright/test/package.json');
-            return playwrightPackage.version;
-        }
-        catch (error) {
-            return 'unknown';
-        }
-    }
-    normalizeTestStatus(status) {
-        // Treat timeout as failed for consistency with analytics
-        if (status === 'timedOut') {
-            return 'failed';
-        }
-        return status;
-    }
-    normalizeRunStatus(status, hasTimeouts) {
-        // If run has timeouts, treat as failed
-        if (hasTimeouts && status === 'passed') {
-            return 'failed';
-        }
-        // Treat timeout status as failed
-        if (status === 'timedOut') {
-            return 'failed';
-        }
-        return status;
-    }
-    async onBegin(config, suite) {
-        console.log(`🚀 TestLens Reporter starting - Run ID: ${this.runId}`);
-        // Collect Git information if enabled
-        if (this.config.enableGitInfo) {
-            this.runMetadata.gitInfo = await this.collectGitInfo();
-            if (this.runMetadata.gitInfo) {
-                console.log(`📦 Git info collected: branch=${this.runMetadata.gitInfo.branch}, commit=${this.runMetadata.gitInfo.shortCommit}, author=${this.runMetadata.gitInfo.author}`);
-            }
-            else {
-                console.log(`⚠️  Git info collection returned null - not in a git repository or git not available`);
-            }
-        }
-        else {
-            console.log(`ℹ️  Git info collection disabled (enableGitInfo: false)`);
-        }
-        // Add shard information if available
-        if (config.shard) {
-            this.runMetadata.shardInfo = {
-                current: config.shard.current,
-                total: config.shard.total
-            };
-        }
-        // Send run start event to API
-        await this.sendToApi({
-            type: 'runStart',
-            runId: this.runId,
-            timestamp: new Date().toISOString(),
-            metadata: this.runMetadata
-        });
-    }
-    async onTestBegin(test, result) {
-        const specPath = test.location.file;
-        const specKey = `${specPath}-${test.parent.title}`;
-        // Create or update spec data
-        if (!this.specMap.has(specKey)) {
-            const specData = {
-                filePath: path.relative(process.cwd(), specPath),
-                testSuiteName: test.parent.title,
-                tags: this.extractTags(test),
-                startTime: new Date().toISOString(),
-                status: 'running'
-            };
-            this.specMap.set(specKey, specData);
-            // Send spec start event to API
-            await this.sendToApi({
-                type: 'specStart',
-                runId: this.runId,
-                timestamp: new Date().toISOString(),
-                spec: specData
-            });
-        }
-        const testId = this.getTestId(test);
-        // Only send testStart event on first attempt (retry 0)
-        if (result.retry === 0) {
-            // Create test data
-            const testData = {
-                id: testId,
-                name: test.title,
-                status: 'running',
-                originalStatus: 'running',
-                duration: 0,
-                startTime: new Date().toISOString(),
-                endTime: '',
-                errorMessages: [],
-                errors: [],
-                retryAttempts: test.retries,
-                currentRetry: result.retry,
-                annotations: test.annotations.map((ann) => ({
-                    type: ann.type,
-                    description: ann.description
-                })),
-                projectName: test.parent.project()?.name || 'default',
-                workerIndex: result.workerIndex,
-                parallelIndex: result.parallelIndex,
-                location: {
-                    file: path.relative(process.cwd(), test.location.file),
-                    line: test.location.line,
-                    column: test.location.column
-                }
-            };
-            this.testMap.set(testData.id, testData);
-            // Send test start event to API
-            await this.sendToApi({
-                type: 'testStart',
-                runId: this.runId,
-                timestamp: new Date().toISOString(),
-                test: testData
-            });
-        }
-        else {
-            // For retries, just update the existing test data
-            const existingTestData = this.testMap.get(testId);
-            if (existingTestData) {
-                existingTestData.currentRetry = result.retry;
-            }
-        }
-    }
-    async onTestEnd(test, result) {
-        const testId = this.getTestId(test);
-        let testData = this.testMap.get(testId);
-        console.log(`[TestLens] onTestEnd called for test: ${test.title}, status: ${result.status}, testData exists: ${!!testData}`);
-        // For skipped tests, onTestBegin might not be called, so we need to create the test data here
-        if (!testData) {
-            console.log(`[TestLens] Creating test data for skipped/uncreated test: ${test.title}`);
-            // Create spec data if not exists (skipped tests might not have spec data either)
-            const specPath = test.location.file;
-            const specKey = `${specPath}-${test.parent.title}`;
-            if (!this.specMap.has(specKey)) {
-                const specData = {
-                    filePath: path.relative(process.cwd(), specPath),
-                    testSuiteName: test.parent.title,
-                    tags: this.extractTags(test),
-                    startTime: new Date().toISOString(),
-                    status: 'skipped'
-                };
-                this.specMap.set(specKey, specData);
-                // Send spec start event to API
-                await this.sendToApi({
-                    type: 'specStart',
-                    runId: this.runId,
-                    timestamp: new Date().toISOString(),
-                    spec: specData
-                });
-            }
-            // Create test data for skipped test
-            testData = {
-                id: testId,
-                name: test.title,
-                status: 'skipped',
-                originalStatus: 'skipped',
-                duration: 0,
-                startTime: new Date().toISOString(),
-                endTime: new Date().toISOString(),
-                errorMessages: [],
-                errors: [],
-                retryAttempts: test.retries,
-                currentRetry: 0,
-                annotations: test.annotations.map((ann) => ({
-                    type: ann.type,
-                    description: ann.description
-                })),
-                projectName: test.parent.project()?.name || 'default',
-                workerIndex: result.workerIndex,
-                parallelIndex: result.parallelIndex,
-                location: {
-                    file: path.relative(process.cwd(), test.location.file),
-                    line: test.location.line,
-                    column: test.location.column
-                }
-            };
-            this.testMap.set(testId, testData);
-            // Send test start event first (so the test gets created in DB)
-            await this.sendToApi({
-                type: 'testStart',
-                runId: this.runId,
-                timestamp: new Date().toISOString(),
-                test: testData
-            });
-        }
-        if (testData) {
-            // Update test data with latest result
-            testData.originalStatus = result.status;
-            testData.status = this.normalizeTestStatus(result.status);
-            testData.duration = result.duration;
-            testData.endTime = new Date().toISOString();
-            testData.errorMessages = result.errors.map((error) => error.message || error.toString());
-            testData.currentRetry = result.retry;
-            // Capture test location
-            testData.location = {
-                file: path.relative(process.cwd(), test.location.file),
-                line: test.location.line,
-                column: test.location.column
-            };
-            // Capture rich error details like Playwright's HTML report
-            testData.errors = result.errors.map((error) => {
-                const testError = {
-                    message: error.message || error.toString()
-                };
-                // Capture stack trace
-                if (error.stack) {
-                    testError.stack = error.stack;
-                }
-                // Capture error location
-                if (error.location) {
-                    testError.location = {
-                        file: path.relative(process.cwd(), error.location.file),
-                        line: error.location.line,
-                        column: error.location.column
-                    };
-                }
-                // Capture code snippet around error - from Playwright error object
-                if (error.snippet) {
-                    testError.snippet = error.snippet;
-                }
-                // Capture expected/actual values for assertion failures
-                // Playwright stores these as specially formatted strings in the message
-                const message = error.message || '';
-                // Try to parse expected pattern from toHaveURL and similar assertions
-                const expectedPatternMatch = message.match(/Expected pattern:\s*(.+?)(?:\n|$)/);
-                if (expectedPatternMatch) {
-                    testError.expected = expectedPatternMatch[1].trim();
-                }
-                // Also try "Expected string:" format
-                if (!testError.expected) {
-                    const expectedStringMatch = message.match(/Expected string:\s*["']?(.+?)["']?(?:\n|$)/);
-                    if (expectedStringMatch) {
-                        testError.expected = expectedStringMatch[1].trim();
-                    }
-                }
-                // Try to parse received/actual value
-                const receivedMatch = message.match(/Received (?:string|value):\s*["']?(.+?)["']?(?:\n|$)/);
-                if (receivedMatch) {
-                    testError.actual = receivedMatch[1].trim();
-                }
-                // Parse call log entries for debugging info (timeouts, retries, etc.)
-                const callLogMatch = message.match(/Call log:([\s\S]*?)(?=\n\n|\n\s*\d+\s*\||$)/);
-                if (callLogMatch) {
-                    // Store call log separately for display
-                    const callLog = callLogMatch[1].trim();
-                    if (callLog) {
-                        testError.diff = callLog; // Reuse diff field for call log
-                    }
-                }
-                // Parse timeout information - multiple formats
-                const timeoutMatch = message.match(/(?:with timeout|Timeout:?)\s*(\d+)ms/i);
-                if (timeoutMatch) {
-                    testError.timeout = parseInt(timeoutMatch[1], 10);
-                }
-                // Parse matcher name (e.g., toHaveURL, toBeVisible)
-                const matcherMatch = message.match(/expect\([^)]+\)\.(\w+)/);
-                if (matcherMatch) {
-                    testError.matcherName = matcherMatch[1];
-                }
-                // Extract code snippet from message if not already captured
-                // Look for lines like "  9 |      await page.click..." or "> 11 |      await expect..."
-                if (!testError.snippet) {
-                    const codeSnippetMatch = message.match(/((?:\s*>?\s*\d+\s*\|.*\n?)+)/);
-                    if (codeSnippetMatch) {
-                        testError.snippet = codeSnippetMatch[1].trim();
-                    }
-                }
-                return testError;
-            });
-            // Only send testEnd event after final retry attempt
-            // If test passed or this is the last retry, send the event
-            const isFinalAttempt = result.status === 'passed' || result.status === 'skipped' || result.retry >= test.retries;
-            if (isFinalAttempt) {
-                console.log(`[TestLens] Sending testEnd - testId: ${testData.id}, status: ${testData.status}, originalStatus: ${testData.originalStatus}`);
-                // Send test end event to API
-                await this.sendToApi({
-                    type: 'testEnd',
-                    runId: this.runId,
-                    timestamp: new Date().toISOString(),
-                    test: testData
-                });
-                // Handle artifacts
-                if (this.config.enableArtifacts) {
-                    await this.processArtifacts(testId, result);
-                }
-            }
-        }
-        // Update spec status
-        const specPath = test.location.file;
-        const specKey = `${specPath}-${test.parent.title}`;
-        const specData = this.specMap.get(specKey);
-        if (specData) {
-            const normalizedStatus = this.normalizeTestStatus(result.status);
-            if (normalizedStatus === 'failed' && specData.status !== 'failed') {
-                specData.status = 'failed';
-            }
-            else if (result.status === 'skipped' && specData.status === 'passed') {
-                specData.status = 'skipped';
-            }
-            // Check if all tests in spec are complete
-            const remainingTests = test.parent.tests.filter((t) => {
-                const tId = this.getTestId(t);
-                const tData = this.testMap.get(tId);
-                return !tData || !tData.endTime;
-            });
-            if (remainingTests.length === 0) {
-                specData.endTime = new Date().toISOString();
-                // Send spec end event to API
-                await this.sendToApi({
-                    type: 'specEnd',
-                    runId: this.runId,
-                    timestamp: new Date().toISOString(),
-                    spec: specData
-                });
-                // Send spec code blocks to API
-                await this.sendSpecCodeBlocks(specPath);
-            }
-        }
-    }
-    async onEnd(result) {
-        this.runMetadata.endTime = new Date().toISOString();
-        this.runMetadata.duration = Date.now() - new Date(this.runMetadata.startTime).getTime();
-        // Calculate final stats
-        const totalTests = Array.from(this.testMap.values()).length;
-        const passedTests = Array.from(this.testMap.values()).filter(t => t.status === 'passed').length;
-        // failedTests already includes timedOut tests since normalizeTestStatus converts 'timedOut' to 'failed'
-        const failedTests = Array.from(this.testMap.values()).filter(t => t.status === 'failed').length;
-        const skippedTests = Array.from(this.testMap.values()).filter(t => t.status === 'skipped').length;
-        // Track timedOut separately for reporting purposes only (not for count)
-        const timedOutTests = Array.from(this.testMap.values()).filter(t => t.originalStatus === 'timedOut').length;
-        // Normalize run status - if there are timeouts, treat run as failed
-        const hasTimeouts = timedOutTests > 0;
-        const normalizedRunStatus = this.normalizeRunStatus(result.status, hasTimeouts);
-        // Send run end event to API
-        await this.sendToApi({
-            type: 'runEnd',
-            runId: this.runId,
-            timestamp: new Date().toISOString(),
-            metadata: {
-                ...this.runMetadata,
-                totalTests,
-                passedTests,
-                failedTests, // Already includes timedOut tests (normalized to 'failed')
-                skippedTests,
-                timedOutTests, // For informational purposes
-                status: normalizedRunStatus
-            }
-        });
-        console.log(`📊 TestLens Report completed - Run ID: ${this.runId}`);
-        console.log(`🎯 Results: ${passedTests} passed, ${failedTests} failed (${timedOutTests} timeouts), ${skippedTests} skipped`);
-    }
-    async sendToApi(payload) {
-        try {
-            console.log(`📤 Sending ${payload.type} event to ${this.config.apiEndpoint}`);
-            const response = await this.axiosInstance.post('', payload, {
-                headers: {
-                    'X-API-Key': this.config.apiKey
-                }
-            });
-            if (this.config.enableRealTimeStream) {
-                console.log(`✅ Sent ${payload.type} event to TestLens (HTTP ${response.status})`);
-            }
-        }
-        catch (error) {
-            console.error(`❌ Failed to send ${payload.type} event to TestLens:`, {
-                message: error?.message || 'Unknown error',
-                status: error?.response?.status,
-                statusText: error?.response?.statusText,
-                data: error?.response?.data,
-                code: error?.code,
-                url: error?.config?.url,
-                method: error?.config?.method
-            });
-            // Don't throw error to avoid breaking test execution
-        }
-    }
-    async processArtifacts(testId, result) {
-        const attachments = result.attachments;
-        for (const attachment of attachments) {
-            if (attachment.path) {
-                // Check if attachment should be processed based on config
-                const artifactType = this.getArtifactType(attachment.name);
-                const isVideo = artifactType === 'video' || attachment.contentType?.startsWith('video/');
-                const isScreenshot = artifactType === 'screenshot' || attachment.contentType?.startsWith('image/');
-                // Skip video if disabled in config
-                if (isVideo && !this.config.enableVideo) {
-                    console.log(`⏭️  Skipping video artifact ${attachment.name} - video capture disabled in config`);
-                    continue;
-                }
-                // Skip screenshot if disabled in config
-                if (isScreenshot && !this.config.enableScreenshot) {
-                    console.log(`⏭️  Skipping screenshot artifact ${attachment.name} - screenshot capture disabled in config`);
-                    continue;
-                }
-                try {
-                    // Determine proper filename with extension
-                    // Playwright attachment.name often doesn't have extension, so we need to derive it
-                    let fileName = attachment.name;
-                    const existingExt = path.extname(fileName);
-                    if (!existingExt) {
-                        // Get extension from the actual file path
-                        const pathExt = path.extname(attachment.path);
-                        if (pathExt) {
-                            fileName = `${fileName}${pathExt}`;
-                        }
-                        else if (attachment.contentType) {
-                            // Fallback: derive extension from contentType
-                            const mimeToExt = {
-                                'image/png': '.png',
-                                'image/jpeg': '.jpg',
-                                'image/gif': '.gif',
-                                'image/webp': '.webp',
-                                'video/webm': '.webm',
-                                'video/mp4': '.mp4',
-                                'application/zip': '.zip',
-                                'application/json': '.json',
-                                'text/plain': '.txt'
-                            };
-                            const ext = mimeToExt[attachment.contentType];
-                            if (ext) {
-                                fileName = `${fileName}${ext}`;
-                            }
-                        }
-                    }
-                    // Upload to S3 first
-                    const s3Data = await this.uploadArtifactToS3(attachment.path, testId, fileName);
-                    // Skip if upload failed or file was too large
-                    if (!s3Data) {
-                        console.log(`⏭️  Skipping artifact ${attachment.name} - upload failed or file too large`);
-                        continue;
-                    }
-                    const artifactData = {
-                        testId,
-                        type: this.getArtifactType(attachment.name),
-                        path: attachment.path,
-                        name: fileName,
-                        contentType: attachment.contentType,
-                        fileSize: this.getFileSize(attachment.path),
-                        storageType: 's3',
-                        s3Key: s3Data.key,
-                        s3Url: s3Data.url
-                    };
-                    // Send artifact data to API
-                    await this.sendToApi({
-                        type: 'artifact',
-                        runId: this.runId,
-                        timestamp: new Date().toISOString(),
-                        artifact: artifactData
-                    });
-                    console.log(`📎 Processed artifact: ${fileName} (uploaded to S3)`);
-                }
-                catch (error) {
-                    console.error(`❌ Failed to process artifact ${attachment.name}:`, error.message);
-                }
-            }
-        }
-    }
-    async sendSpecCodeBlocks(specPath) {
-        try {
-            // Extract code blocks using built-in parser
-            const testBlocks = this.extractTestBlocks(specPath);
-            // Transform blocks to match backend API expectations
-            const codeBlocks = testBlocks.map(block => ({
-                type: block.type, // 'test' or 'describe'
-                name: block.name, // test/describe name
-                content: block.content, // full code content
-                summary: null, // optional
-                describe: block.describe // parent describe block name
-            }));
-            // Send to dedicated spec code blocks API endpoint
-            const baseUrl = this.config.apiEndpoint.replace('/webhook/playwright', '');
-            const specEndpoint = `${baseUrl}/webhook/playwright/spec-code-blocks`;
-            await this.axiosInstance.post(specEndpoint, {
-                filePath: path.relative(process.cwd(), specPath),
-                codeBlocks,
-                testSuiteName: path.basename(specPath).replace(/\.(spec|test)\.(js|ts)$/, '')
-            });
-            console.log(`📝 Sent ${codeBlocks.length} code blocks for: ${path.basename(specPath)}`);
-        }
-        catch (error) {
-            console.error('Failed to send spec code blocks:', error?.response?.data || error?.message || 'Unknown error');
-        }
-    }
-    extractTestBlocks(filePath) {
-        try {
-            const content = fs.readFileSync(filePath, 'utf-8');
-            const blocks = [];
-            const lines = content.split('\n');
-            let currentDescribe = null;
-            let braceCount = 0;
-            let inBlock = false;
-            let blockStart = -1;
-            let blockType = 'test';
-            let blockName = '';
-            for (let i = 0; i < lines.length; i++) {
-                const line = lines[i];
-                const trimmedLine = line.trim();
-                // Check for describe blocks
-                const describeMatch = trimmedLine.match(/describe\s*\(\s*['"`]([^'"`]+)['"`]/);
-                if (describeMatch) {
-                    currentDescribe = describeMatch[1];
-                }
-                // Check for test blocks
-                const testMatch = trimmedLine.match(/test\s*\(\s*['"`]([^'"`]+)['"`]/);
-                if (testMatch && !inBlock) {
-                    blockType = 'test';
-                    blockName = testMatch[1];
-                    blockStart = i;
-                    braceCount = 0;
-                    inBlock = true;
-                }
-                // Count braces when in a block
-                if (inBlock) {
-                    for (const char of line) {
-                        if (char === '{')
-                            braceCount++;
-                        if (char === '}')
-                            braceCount--;
-                        if (braceCount === 0 && blockStart !== -1 && i > blockStart) {
-                            // End of block found
-                            const blockContent = lines.slice(blockStart, i + 1).join('\n');
-                            blocks.push({
-                                type: blockType,
-                                name: blockName,
-                                content: blockContent,
-                                describe: currentDescribe || undefined,
-                                startLine: blockStart + 1,
-                                endLine: i + 1
-                            });
-                            inBlock = false;
-                            blockStart = -1;
-                            break;
-                        }
-                    }
-                }
-            }
-            return blocks;
-        }
-        catch (error) {
-            console.error(`Failed to extract test blocks from ${filePath}:`, error.message);
-            return [];
-        }
-    }
-    async collectGitInfo() {
-        try {
-            const branch = (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD', { encoding: 'utf-8' }).trim();
-            const commit = (0, child_process_1.execSync)('git rev-parse HEAD', { encoding: 'utf-8' }).trim();
-            const shortCommit = commit.substring(0, 7);
-            const author = (0, child_process_1.execSync)('git log -1 --pretty=format:"%an"', { encoding: 'utf-8' }).trim();
-            const commitMessage = (0, child_process_1.execSync)('git log -1 --pretty=format:"%s"', { encoding: 'utf-8' }).trim();
-            const commitTimestamp = (0, child_process_1.execSync)('git log -1 --pretty=format:"%ci"', { encoding: 'utf-8' }).trim();
-            let remoteName = 'origin';
-            let remoteUrl = '';
-            try {
-                const remotes = (0, child_process_1.execSync)('git remote', { encoding: 'utf-8' }).trim();
-                if (remotes) {
-                    remoteName = remotes.split('\n')[0] || 'origin';
-                    remoteUrl = (0, child_process_1.execSync)(`git remote get-url ${remoteName}`, { encoding: 'utf-8' }).trim();
-                }
-            }
-            catch (e) {
-                // Remote info is optional - handle gracefully
-                console.log('ℹ️  No git remote configured, skipping remote info');
-            }
-            const isDirty = (0, child_process_1.execSync)('git status --porcelain', { encoding: 'utf-8' }).trim().length > 0;
-            return {
-                branch,
-                commit,
-                shortCommit,
-                author,
-                message: commitMessage,
-                timestamp: commitTimestamp,
-                isDirty,
-                remoteName,
-                remoteUrl
-            };
-        }
-        catch (error) {
-            console.warn('Could not collect Git information:', error.message);
-            return null;
-        }
-    }
-    getArtifactType(name) {
-        if (name.includes('screenshot'))
-            return 'screenshot';
-        if (name.includes('video'))
-            return 'video';
-        if (name.includes('trace'))
-            return 'trace';
-        return 'attachment';
-    }
-    extractTags(test) {
-        const tags = [];
-        test.annotations.forEach((annotation) => {
-            if (annotation.type === 'tag' && annotation.description) {
-                tags.push(annotation.description);
-            }
-        });
-        const tagMatches = test.title.match(/@[\w-]+/g);
-        if (tagMatches) {
-            tags.push(...tagMatches);
-        }
-        return tags;
-    }
-    getTestId(test) {
-        const cleanTitle = test.title.replace(/@[\w-]+/g, '').trim();
-        // Normalize path separators to forward slashes for cross-platform consistency
-        const normalizedFile = test.location.file.replace(/\\/g, '/');
-        return `${normalizedFile}:${test.location.line}:${cleanTitle}`;
-    }
-    async uploadArtifactToS3(filePath, testId, fileName) {
-        try {
-            // Check file size first
-            const fileSize = this.getFileSize(filePath);
-            const fileSizeMB = (fileSize / (1024 * 1024)).toFixed(2);
-            console.log(`📤 Uploading ${fileName} (${fileSizeMB}MB) directly to S3...`);
-            const baseUrl = this.config.apiEndpoint.replace('/api/v1/webhook/playwright', '');
-            // Step 1: Request pre-signed URL from server
-            const presignedUrlEndpoint = `${baseUrl}/api/v1/artifacts/public/presigned-url`;
-            const presignedResponse = await this.axiosInstance.post(presignedUrlEndpoint, {
-                apiKey: this.config.apiKey,
-                testRunId: this.runId,
-                testId: testId,
-                fileName: fileName,
-                fileType: await this.getContentType(fileName),
-                fileSize: fileSize,
-                artifactType: this.getArtifactType(fileName)
-            }, {
-                timeout: 10000 // Quick timeout for metadata request
-            });
-            if (!presignedResponse.data.success) {
-                throw new Error(`Failed to get presigned URL: ${presignedResponse.data.error || 'Unknown error'}`);
-            }
-            const { uploadUrl, s3Key, metadata } = presignedResponse.data;
-            // Step 2: Upload directly to S3 using presigned URL
-            console.log(`⬆️  Uploading ${fileName} directly to S3 (bypass server)...`);
-            const fileBuffer = fs.readFileSync(filePath);
-            // IMPORTANT: When using presigned URLs, we MUST include exactly the headers that were signed
-            // The backend signs with ServerSideEncryption:'AES256', so we must send that header
-            // AWS presigned URLs are very strict about header matching
-            const uploadResponse = await axios_1.default.put(uploadUrl, fileBuffer, {
-                headers: {
-                    'x-amz-server-side-encryption': 'AES256'
-                },
-                maxContentLength: Infinity,
-                maxBodyLength: Infinity,
-                timeout: Math.max(600000, Math.ceil(fileSize / (1024 * 1024)) * 10000), // 10s per MB, min 10 minutes - increased for large trace files
-                // Don't use custom HTTPS agent for S3 uploads
-                httpsAgent: undefined
-            });
-            if (uploadResponse.status !== 200) {
-                throw new Error(`S3 upload failed with status ${uploadResponse.status}`);
-            }
-            console.log(`✅ S3 direct upload completed for ${fileName}`);
-            // Step 3: Confirm upload with server to save metadata
-            const confirmEndpoint = `${baseUrl}/api/v1/artifacts/public/confirm-upload`;
-            const confirmResponse = await this.axiosInstance.post(confirmEndpoint, {
-                apiKey: this.config.apiKey,
-                testRunId: this.runId,
-                testId: testId,
-                s3Key: s3Key,
-                fileName: fileName,
-                fileType: await this.getContentType(fileName),
-                fileSize: fileSize,
-                artifactType: this.getArtifactType(fileName)
-            }, {
-                timeout: 10000
-            });
-            if (confirmResponse.status === 201 && confirmResponse.data.success) {
-                const artifact = confirmResponse.data.artifact;
-                console.log(`✅ Upload confirmed and saved to database`);
-                return {
-                    key: s3Key,
-                    url: artifact.s3Url,
-                    presignedUrl: artifact.presignedUrl,
-                    fileSize: artifact.fileSize,
-                    contentType: artifact.contentType
-                };
-            }
-            else {
-                throw new Error(`Upload confirmation failed: ${confirmResponse.data.error || 'Unknown error'}`);
-            }
-        }
-        catch (error) {
-            // Better error messages for common issues
-            let errorMsg = error.message;
-            if (error.code === 'ECONNABORTED' && error.message.includes('timeout')) {
-                errorMsg = `Upload timeout - file may be too large or connection is slow`;
-            }
-            else if (error.response?.status === 413) {
-                errorMsg = `File too large (413) - server rejected the upload`;
-            }
-            else if (error.response?.status === 400) {
-                errorMsg = `Bad request (400) - ${error.response.data?.error || 'check file format'}`;
-            }
-            else if (error.response?.status === 403) {
-                errorMsg = `Access denied (403) - presigned URL may have expired`;
-            }
-            console.error(`❌ Failed to upload ${fileName} to S3:`, errorMsg);
-            if (error.response?.data) {
-                console.error('Error details:', error.response.data);
-            }
-            // Don't throw, just return null to continue with other artifacts
-            return null;
-        }
-    }
-    async getContentType(fileName) {
-        const ext = path.extname(fileName).toLowerCase();
-        try {
-            const mime = await getMime();
-            // Try different ways to access getType method
-            const getType = mime.getType || mime.default?.getType;
-            if (typeof getType === 'function') {
-                const mimeType = getType.call(mime, ext) || getType.call(mime.default, ext);
-                return mimeType || 'application/octet-stream';
-            }
-        }
-        catch (error) {
-            console.warn(`Failed to get MIME type for ${fileName}:`, error.message);
-        }
-        // Fallback to basic content type mapping
-        const contentTypes = {
-            '.mp4': 'video/mp4',
-            '.webm': 'video/webm',
-            '.png': 'image/png',
-            '.jpg': 'image/jpeg',
-            '.jpeg': 'image/jpeg',
-            '.gif': 'image/gif',
-            '.json': 'application/json',
-            '.txt': 'text/plain',
-            '.html': 'text/html',
-            '.xml': 'application/xml',
-            '.zip': 'application/zip',
-            '.pdf': 'application/pdf'
-        };
-        return contentTypes[ext] || 'application/octet-stream';
-    }
-    generateS3Key(runId, testId, fileName) {
-        const date = new Date().toISOString().slice(0, 10);
-        const safeTestId = this.sanitizeForS3(testId);
-        const safeFileName = this.sanitizeForS3(fileName);
-        const ext = path.extname(fileName);
-        const baseName = path.basename(fileName, ext);
-        return `test-artifacts/${date}/${runId}/${safeTestId}/${safeFileName}${ext}`;
-    }
-    sanitizeForS3(value) {
-        return value
-            .replace(/[\/:*?"<>|]/g, '-')
-            .replace(/[-\u001f\u007f]/g, '-')
-            .replace(/[^-~]/g, '-')
-            .replace(/\s+/g, '-')
-            .replace(/[_]/g, '-')
-            .replace(/-+/g, '-')
-            .replace(/^-|-$/g, '');
-    }
-    getFileSize(filePath) {
-        try {
-            const stats = fs.statSync(filePath);
-            return stats.size;
-        }
-        catch (error) {
-            console.warn(`Could not get file size for ${filePath}:`, error.message);
-            return 0;
-        }
-    }
-}
-exports.TestLensReporter = TestLensReporter;
-exports.default = TestLensReporter;