testlens-playwright-reporter 0.1.0

package/lib/index.js

@@ -0,0 +1,642 @@
+"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");
+const client_s3_1 = require("@aws-sdk/client-s3");
+const s3_request_presigner_1 = require("@aws-sdk/s3-request-presigner");
+// Embedded configuration from .env file (generated during build)
+const EMBEDDED_CONFIG = {
+    "AWS_ACCESS_KEY_ID": "AKIA5QK76YZKWA2P5V4E",
+    "AWS_SECRET_ACCESS_KEY": "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",
+    "AWS_REGION": "eu-north-1",
+    "S3_BUCKET_NAME": "testlenss3",
+    "S3_ACL": "private",
+    "TEST_API_ENDPOINT": "https://testlens.qa-path.com/api/v1/webhook/playwright"
+};
+class TestLensReporter {
+    constructor(options) {
+        this.config = {
+            apiEndpoint: EMBEDDED_CONFIG.TEST_API_ENDPOINT || options.apiEndpoint || '',
+            apiKey: options.apiKey, // API key must come from config file
+            enableRealTimeStream: options.enableRealTimeStream !== false,
+            enableGitInfo: options.enableGitInfo !== false,
+            enableArtifacts: options.enableArtifacts !== false,
+            enableS3Upload: options.enableS3Upload !== false,
+            batchSize: options.batchSize || 10,
+            flushInterval: options.flushInterval || 5000,
+            retryAttempts: options.retryAttempts || 3,
+            timeout: options.timeout || 30000,
+            rejectUnauthorized: options.rejectUnauthorized !== false, // Default to true for security
+            ignoreSslErrors: options.ignoreSslErrors === true // Explicit opt-in to ignore SSL errors
+        };
+        if (!this.config.apiEndpoint) {
+            throw new Error('TEST_API_ENDPOINT is required for TestLensReporter. Set it in environment variable or pass as option.');
+        }
+        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
+            httpsAgent: new https.Agent({
+                rejectUnauthorized: rejectUnauthorized,
+                // Additional SSL options for better compatibility
+                secureProtocol: 'TLSv1_2_method',
+                ciphers: 'ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA384'
+            })
+        });
+        // 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);
+        });
+        // Initialize S3 client if S3 upload is enabled
+        this.s3Client = null;
+        this.s3Enabled = this.config.enableS3Upload && !!EMBEDDED_CONFIG.S3_BUCKET_NAME;
+        if (this.s3Enabled) {
+            try {
+                const s3Config = {
+                    region: EMBEDDED_CONFIG.AWS_REGION || 'us-east-1',
+                    maxAttempts: 3
+                };
+                if (EMBEDDED_CONFIG.AWS_ACCESS_KEY_ID && EMBEDDED_CONFIG.AWS_SECRET_ACCESS_KEY) {
+                    s3Config.credentials = {
+                        accessKeyId: EMBEDDED_CONFIG.AWS_ACCESS_KEY_ID,
+                        secretAccessKey: EMBEDDED_CONFIG.AWS_SECRET_ACCESS_KEY
+                    };
+                }
+                this.s3Client = new client_s3_1.S3Client(s3Config);
+                console.log('✅ S3 client initialized for artifact uploads');
+            }
+            catch (error) {
+                console.error('❌ Failed to initialize S3 client:', error.message);
+                this.s3Enabled = false;
+            }
+        }
+        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();
+        }
+        // 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: 'passed'
+            };
+            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
+        const testData = {
+            id: this.getTestId(test),
+            name: test.title,
+            status: 'passed',
+            originalStatus: 'passed',
+            duration: 0,
+            startTime: new Date().toISOString(),
+            endTime: '',
+            errorMessages: [],
+            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
+        };
+        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
+        });
+    }
+    async onTestEnd(test, result) {
+        const testId = this.getTestId(test);
+        const testData = this.testMap.get(testId);
+        if (testData) {
+            // Preserve original status for detailed reporting, but normalize for consistency
+            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());
+            // 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;
+        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;
+        const timedOutTests = Array.from(this.testMap.values()).filter(t => t.status === '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: failedTests + timedOutTests, // Include timeouts in failed count
+                skippedTests,
+                timedOutTests,
+                status: normalizedRunStatus
+            }
+        });
+        console.log(`📊 TestLens Report completed - Run ID: ${this.runId}`);
+        console.log(`🎯 Results: ${passedTests} passed, ${failedTests + timedOutTests} failed (${timedOutTests} timeouts), ${skippedTests} skipped`);
+    }
+    async sendToApi(payload) {
+        try {
+            const response = await this.axiosInstance.post('', payload);
+            if (this.config.enableRealTimeStream) {
+                console.log(`✅ Sent ${payload.type} event to TestLens`);
+            }
+        }
+        catch (error) {
+            console.error(`❌ Failed to send ${payload.type} event to TestLens:`, {
+                message: error?.message || 'Unknown error',
+                status: error?.response?.status,
+                data: error?.response?.data
+            });
+            // 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) {
+                try {
+                    let s3Data = null;
+                    // Upload to S3 if enabled
+                    if (this.s3Enabled && this.s3Client) {
+                        s3Data = await this.uploadArtifactToS3(attachment.path, testId, attachment.name);
+                    }
+                    const artifactData = {
+                        testId,
+                        type: this.getArtifactType(attachment.name),
+                        path: attachment.path,
+                        name: attachment.name,
+                        contentType: attachment.contentType,
+                        fileSize: s3Data ? s3Data.fileSize : this.getFileSize(attachment.path),
+                        ...(s3Data && {
+                            s3Key: s3Data.key,
+                            s3Url: s3Data.url,
+                            presignedUrl: s3Data.presignedUrl,
+                            storageType: 's3'
+                        })
+                    };
+                    // Send artifact data to API
+                    await this.sendToApi({
+                        type: 'artifact',
+                        runId: this.runId,
+                        timestamp: new Date().toISOString(),
+                        artifact: artifactData
+                    });
+                    console.log(`📎 Processed artifact: ${attachment.name}${s3Data ? ' (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,
+                commitMessage,
+                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();
+        return `${test.location.file}:${test.location.line}:${cleanTitle}`;
+    }
+    async uploadArtifactToS3(filePath, testId, fileName) {
+        try {
+            const fileContent = fs.readFileSync(filePath);
+            const fileSize = fileContent.length;
+            // Get content type based on file extension
+            const ext = path.extname(filePath).toLowerCase();
+            const contentType = this.getContentType(ext);
+            // Generate S3 key
+            const s3Key = this.generateS3Key(this.runId, testId, fileName);
+            const uploadParams = {
+                Bucket: EMBEDDED_CONFIG.S3_BUCKET_NAME,
+                Key: s3Key,
+                Body: fileContent,
+                ContentType: contentType,
+                ACL: EMBEDDED_CONFIG.S3_ACL || 'private',
+            };
+            await this.s3Client.send(new client_s3_1.PutObjectCommand(uploadParams));
+            // Generate presigned URL for frontend access (expires in 7 days)
+            const getCommand = new client_s3_1.GetObjectCommand({
+                Bucket: EMBEDDED_CONFIG.S3_BUCKET_NAME,
+                Key: s3Key
+            });
+            const presignedUrl = await (0, s3_request_presigner_1.getSignedUrl)(this.s3Client, getCommand, {
+                expiresIn: 604800 // 7 days
+            });
+            const s3Url = `https://${EMBEDDED_CONFIG.S3_BUCKET_NAME}.s3.${EMBEDDED_CONFIG.AWS_REGION || 'us-east-1'}.amazonaws.com/${s3Key}`;
+            return {
+                key: s3Key,
+                url: s3Url,
+                presignedUrl: presignedUrl,
+                fileSize,
+                contentType
+            };
+        }
+        catch (error) {
+            console.error(`❌ Failed to upload ${fileName} to S3:`, error.message);
+            throw error;
+        }
+    }
+    getContentType(ext) {
+        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;