testlens-playwright-reporter 0.2.7 → 0.2.9

package/README.md

@@ -0,0 +1,87 @@
+# TestLens Playwright Reporter
+
+A Playwright reporter for [TestLens](https://testlens.qa-path.com) - real-time test monitoring dashboard.
+
+## Features
+
+- 🚀 **Real-time streaming** - Watch test results as they happen in the dashboard
+- 📸 **Artifact support** - Shows screenshots, videos, and traces
+- 🔄 **Retry tracking** - Monitor test retries and identify flaky tests
+- ⚡ **Cross-platform** - Works on Windows, macOS, and Linux
+
+## Installation
+
+```bash
+npm install testlens-playwright-reporter
+```
+
+## Configuration
+
+### TypeScript (`playwright.config.ts`)
+
+```typescript
+import { defineConfig } from '@playwright/test';
+
+export default defineConfig({
+  use: {
+    // Enable these for better debugging and artifact capture
+    screenshot: 'on',
+    video: 'on',
+    trace: 'on',
+  },
+  reporter: [
+    ['testlens-playwright-reporter', {
+      apiKey: 'your-api-key-here',
+    }]
+  ],
+});
+```
+
+### JavaScript (`playwright.config.js`)
+
+```javascript
+const { defineConfig } = require('@playwright/test');
+
+module.exports = defineConfig({
+  use: {
+    // Enable these for better debugging and artifact capture
+    screenshot: 'on',
+    video: 'on',
+    trace: 'on',
+  },
+  reporter: [
+    ['testlens-playwright-reporter', {
+      apiKey: 'your-api-key-here',
+    }]
+  ],
+});
+```
+
+> 💡 **Tip:** Keep `screenshot`, `video`, and `trace` set to `'on'` for better debugging experience. TestLens automatically uploads these artifacts for failed tests, making it easier to identify issues.
+
+### Configuration Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `apiKey` | `string` | **Required** | Your TestLens API key |
+
+## Artifacts
+
+TestLens automatically captures and uploads:
+
+| Artifact | Description |
+|----------|-------------|
+| **Screenshots** | Visual snapshots of test failures |
+| **Videos** | Full video recording of test execution |
+| **Traces** | Playwright trace files for step-by-step debugging |
+
+These artifacts are viewable directly in the TestLens dashboard for easy debugging.
+
+## Requirements
+
+- Node.js >= 16.0.0
+- Playwright >= 1.40.0
+
+## License
+
+MIT License

package/index.d.ts

@@ -70,6 +70,46 @@ export interface GitInfo {
   remoteUrl: string;
 }
 
+/** Rich error details from Playwright */
+export interface TestError {
+  message: string;
+  stack?: string;
+  location?: {
+    file: string;
+    line: number;
+    column: number;
+  };
+  snippet?: string;
+  expected?: string;
+  actual?: string;
+  diff?: string;
+  matcherName?: string;
+  timeout?: number;
+}
+
+export interface TestData {
+  id: string;
+  name: string;
+  status: string;
+  originalStatus?: string;
+  duration: number;
+  startTime: string;
+  endTime: string;
+  errorMessages: string[];
+  errors?: TestError[];
+  retryAttempts: number;
+  currentRetry: number;
+  annotations: Array<{ type: string; description?: string }>;
+  projectName: string;
+  workerIndex?: number;
+  parallelIndex?: number;
+  location?: {
+    file: string;
+    line: number;
+    column: number;
+  };
+}
+
 export default class TestLensReporter implements Reporter {
   constructor(options: TestLensReporterOptions);
   

package/index.js

@@ -213,6 +213,7 @@ class TestLensReporter {
         startTime: new Date().toISOString(),
         endTime: '',
         errorMessages: [],
+        errors: [],
         retryAttempts: test.retries,
         currentRetry: result.retry,
         annotations: test.annotations.map(ann => ({
@@ -221,7 +222,12 @@ class TestLensReporter {
         })),
         projectName: test.parent.project()?.name || 'default',
         workerIndex: result.workerIndex,
-        parallelIndex: result.parallelIndex
+        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);
@@ -244,7 +250,73 @@ class TestLensReporter {
 
   async onTestEnd(test, result) {
     const testId = this.getTestId(test);
-    const testData = this.testMap.get(testId);
+    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
@@ -254,12 +326,103 @@ class TestLensReporter {
       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',
@@ -645,7 +808,9 @@ class TestLensReporter {
 
   getTestId(test) {
     const cleanTitle = test.title.replace(/@[\w-]+/g, '').trim();
-    return `${test.location.file}:${test.location.line}:${cleanTitle}`;
+    // Normalize path separators to forward slashes for cross-platform consistency
+    const normalizedFile = test.location.file.replace(/\\/g, '/');
+    return `${normalizedFile}:${test.location.line}:${cleanTitle}`;
   }
 
   getFileSize(filePath) {

package/index.ts

@@ -123,6 +123,22 @@ export interface RunMetadata {
   status?: string;
 }
 
+export interface TestError {
+  message: string;
+  stack?: string;
+  location?: {
+    file: string;
+    line: number;
+    column: number;
+  };
+  snippet?: string;
+  expected?: string;
+  actual?: string;
+  diff?: string;
+  matcherName?: string;
+  timeout?: number;
+}
+
 export interface TestData {
   id: string;
   name: string;
@@ -132,12 +148,18 @@ export interface TestData {
   startTime: string;
   endTime: string;
   errorMessages: string[];
+  errors?: TestError[]; // Rich error details
   retryAttempts: number;
   currentRetry: number;
   annotations: Array<{ type: string; description?: string }>;
   projectName: string;
   workerIndex?: number;
   parallelIndex?: number;
+  location?: {
+    file: string;
+    line: number;
+    column: number;
+  };
 }
 
 export interface SpecData {
@@ -350,6 +372,7 @@ export class TestLensReporter implements Reporter {
         startTime: new Date().toISOString(),
         endTime: '',
         errorMessages: [],
+        errors: [],
         retryAttempts: test.retries,
         currentRetry: result.retry,
         annotations: test.annotations.map((ann: any) => ({
@@ -358,7 +381,12 @@ export class TestLensReporter implements Reporter {
         })),
         projectName: test.parent.project()?.name || 'default',
         workerIndex: result.workerIndex,
-        parallelIndex: result.parallelIndex
+        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);
@@ -381,7 +409,73 @@ export class TestLensReporter implements Reporter {
 
   async onTestEnd(test: TestCase, result: TestResult): Promise<void> {
     const testId = this.getTestId(test);
-    const testData = this.testMap.get(testId);
+    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: 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: any) => ({
+          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
@@ -391,12 +485,103 @@ export class TestLensReporter implements Reporter {
       testData.endTime = new Date().toISOString();
       testData.errorMessages = result.errors.map((error: any) => 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: any) => {
+        const testError: 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',
@@ -761,7 +946,9 @@ export class TestLensReporter implements Reporter {
 
   private getTestId(test: TestCase): string {
     const cleanTitle = test.title.replace(/@[\w-]+/g, '').trim();
-    return `${test.location.file}:${test.location.line}:${cleanTitle}`;
+    // Normalize path separators to forward slashes for cross-platform consistency
+    const normalizedFile = test.location.file.replace(/\\/g, '/');
+    return `${normalizedFile}:${test.location.line}:${cleanTitle}`;
   }
 
 

package/lib/index.js

@@ -229,6 +229,7 @@ class TestLensReporter {
                 startTime: new Date().toISOString(),
                 endTime: '',
                 errorMessages: [],
+                errors: [],
                 retryAttempts: test.retries,
                 currentRetry: result.retry,
                 annotations: test.annotations.map((ann) => ({
@@ -237,7 +238,12 @@ class TestLensReporter {
                 })),
                 projectName: test.parent.project()?.name || 'default',
                 workerIndex: result.workerIndex,
-                parallelIndex: result.parallelIndex
+                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
@@ -258,7 +264,66 @@ class TestLensReporter {
     }
     async onTestEnd(test, result) {
         const testId = this.getTestId(test);
-        const testData = this.testMap.get(testId);
+        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;
@@ -267,10 +332,87 @@ class TestLensReporter {
             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',
@@ -599,7 +741,9 @@ class TestLensReporter {
     }
     getTestId(test) {
         const cleanTitle = test.title.replace(/@[\w-]+/g, '').trim();
-        return `${test.location.file}:${test.location.line}:${cleanTitle}`;
+        // 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 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testlens-playwright-reporter",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "Universal Playwright reporter for TestLens - works with both TypeScript and JavaScript projects",
   "main": "index.js",
   "types": "index.d.ts",