qa360 2.1.2 → 2.1.4

package/core/src/repair/utils/error-analyzer.ts

@@ -0,0 +1,308 @@
+/**
+ * Error Analyzer
+ *
+ * Analyzes test errors to extract patterns and classify problems.
+ */
+
+import type { TestError, ErrorType } from '../types.js';
+
+export interface ParsedError {
+  type: ErrorType;
+  message: string;
+  details: Record<string, unknown>;
+  fixable: boolean;
+}
+
+/**
+ * Analyze a test error message and classify it
+ */
+export function analyzeTestError(
+  testFile: string,
+  testName: string,
+  errorMessage: string,
+  stack?: string
+): TestError {
+  const parsed = parseErrorMessage(errorMessage, stack);
+
+  return {
+    testFile,
+    testName,
+    line: extractErrorLine(stack),
+    type: parsed.type,
+    message: parsed.message,
+    stack,
+    context: extractContext(parsed),
+    code: extractErrorCode(parsed)
+  };
+}
+
+/**
+ * Parse error message to extract type and details
+ */
+function parseErrorMessage(message: string, stack?: string): ParsedError {
+  const lower = message.toLowerCase();
+
+  // AssertionError
+  if (lower.includes('expected') || lower.includes('assertion')) {
+    return {
+      type: 'assertion_error',
+      message,
+      details: {
+        expected: extractExpected(message),
+        received: extractReceived(message),
+      },
+      fixable: true
+    };
+  }
+
+  // TimeoutError
+  if (lower.includes('timeout') || lower.includes('timed out')) {
+    return {
+      type: 'timeout_error',
+      message,
+      details: {},
+      fixable: true
+    };
+  }
+
+  // ReferenceError
+  if (lower.includes('is not defined') || lower.includes('reference error')) {
+    return {
+      type: 'reference_error',
+      message,
+      details: {
+        missingVar: extractMissingVariable(message)
+      },
+      fixable: true
+    };
+  }
+
+  // TypeError
+  if (lower.includes('is not a') || lower.includes('is not function') || lower.includes('type error')) {
+    return {
+      type: 'type_error',
+      message,
+      details: {},
+      fixable: true
+    };
+  }
+
+  // Import error
+  if (lower.includes("cannot find module") || lower.includes('unexpected token')) {
+    return {
+      type: 'import_error',
+      message,
+      details: {
+        missingModule: extractMissingModule(message)
+      },
+      fixable: true
+    };
+  }
+
+  // Async error
+  if (lower.includes('async') || lower.includes('promise')) {
+    return {
+      type: 'async_error',
+      message,
+      details: {},
+      fixable: true
+    };
+  }
+
+  return {
+    type: 'unknown',
+    message,
+    details: {},
+    fixable: false
+  };
+}
+
+/**
+ * Extract line number from stack trace
+ */
+function extractErrorLine(stack?: string): number {
+  if (!stack) return 0;
+
+  const lines = stack.split('\n');
+  for (const line of lines) {
+    const match = line.match(/:(\d+):(\d+)/);
+    if (match) {
+      return parseInt(match[1], 10);
+    }
+  }
+
+  return 0;
+}
+
+/**
+ * Extract expected value from error message
+ */
+function extractExpected(message: string): string {
+  const patterns = [
+    /expected\s+["']([^"']+)["']/i,
+    /to be\s+["']?([^"')\s]+)["']?/i,
+    /expected:\s*(.+?)(?:,|but)/i
+  ];
+
+  for (const pattern of patterns) {
+    const match = message.match(pattern);
+    if (match) return match[1].trim();
+  }
+
+  return '';
+}
+
+/**
+ * Extract received value from error message
+ */
+function extractReceived(message: string): string {
+  const patterns = [
+    /received\s+["']([^"']+)["']/i,
+    /but got\s+["']?([^"')\s]+)["']?/i,
+    /received:\s*(.+?)(?:,|\)|$)/i
+  ];
+
+  for (const pattern of patterns) {
+    const match = message.match(pattern);
+    if (match) return match[1].trim();
+  }
+
+  return '';
+}
+
+/**
+ * Extract missing variable from reference error
+ */
+function extractMissingVariable(message: string): string {
+  const match = message.match(/(\w+)\s+is not defined/i);
+  if (match) return match[1];
+
+  const refMatch = message.match(/ReferenceError:\s*(\w+)/i);
+  if (refMatch) return refMatch[1];
+
+  return '';
+}
+
+/**
+ * Extract missing module from import error
+ */
+function extractMissingModule(message: string): string {
+  const match = message.match(/Cannot find module ['"]([^'"]+)['"]/i);
+  if (match) return match[1];
+
+  const modMatch = message.match(/Cannot find module ['"](.+)['"]/);
+  if (modMatch) return modMatch[1];
+
+  return '';
+}
+
+/**
+ * Extract context from parsed error
+ */
+function extractContext(parsed: ParsedError): string {
+  const contexts: Record<ErrorType, string> = {
+    assertion_error: 'Assertion failed - check expected vs actual values',
+    timeout_error: 'Test took too long - increase timeout or fix performance',
+    reference_error: 'Undefined variable - check imports and spelling',
+    type_error: 'Type mismatch - check data types and conversions',
+    import_error: 'Module not found - check import path and dependencies',
+    async_error: 'Async issue - check promises and async/await usage',
+    mock_error: 'Mock not configured - check test setup and mocks',
+    unknown: 'Unknown error type'
+  };
+
+  return contexts[parsed.type] || contexts.unknown;
+}
+
+/**
+ * Extract error code if present
+ */
+function extractErrorCode(parsed: ParsedError): string {
+  return parsed.type.toUpperCase().replace(/_/g, '-');
+}
+
+/**
+ * Classify multiple test errors
+ */
+export function classifyErrors(errors: string[]): Map<ErrorType, number> {
+  const counts = new Map<ErrorType, number>();
+
+  for (const error of errors) {
+    const parsed = parseErrorMessage(error);
+    counts.set(parsed.type, (counts.get(parsed.type) || 0) + 1);
+  }
+
+  return counts;
+}
+
+/**
+ * Check if error is auto-fixable
+ */
+export function isAutoFixable(error: TestError): boolean {
+  // Most assertion and reference errors are auto-fixable
+  if (error.type === 'assertion_error' || error.type === 'reference_error') {
+    return true;
+  }
+
+  // Import errors and type errors are often fixable
+  if (error.type === 'import_error' || error.type === 'type_error') {
+    return true;
+  }
+
+  // Timeouts can sometimes be fixed by increasing timeout
+  if (error.type === 'timeout_error') {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Get fix suggestions for an error type
+ */
+export function getCommonFixes(error: TestError): string[] {
+  const fixes: Record<ErrorType, string[]> = {
+    assertion_error: [
+      'Update expected value to match actual',
+      'Add/modify mock to return expected value',
+      'Fix test data setup'
+    ],
+    timeout_error: [
+      'Increase test timeout',
+      'Optimize test execution',
+      'Remove unnecessary waits'
+    ],
+    reference_error: [
+      'Import missing module/variable',
+      'Fix typo in variable name',
+      'Define missing variable'
+    ],
+    type_error: [
+      'Add type conversion',
+      'Fix data type mismatch',
+      'Check API response structure'
+    ],
+    import_error: [
+      'Install missing dependency',
+      'Fix import path',
+      'Add module to dependencies'
+    ],
+    async_error: [
+      'Add await to async calls',
+      'Return promise from async function',
+      'Fix promise chain'
+    ],
+    mock_error: [
+      'Configure mock properly',
+      'Add mock setup in test',
+      'Reset mocks between tests'
+    ],
+    unknown: [
+      'Review test code',
+      'Check test setup',
+      'Verify test environment'
+    ]
+  };
+
+  return fixes[error.type] || fixes.unknown;
+}

package/core/src/reporting/README.md

@@ -0,0 +1,144 @@
+# QA360 Reporting Module
+
+Generates interactive HTML reports with embedded screenshots, videos, and traces for UI test results.
+
+## Features
+
+- **Dark Theme**: Modern, easy-on-eyes design
+- **Interactive Filtering**: Filter tests by status (passed/failed/skipped)
+- **Embedded Artifacts**: Screenshots, videos, traces directly in report
+- **Modal Viewers**: Click to view full-size screenshots
+- **Collapsible Tests**: Expand/collapse test details
+- **Summary Statistics**: Pass/fail counts, duration, progress bars
+- **Environment Info**: Browser, platform, Node version
+
+## Usage
+
+```typescript
+import { HTMLReporter } from 'qa360-core';
+
+const reportData = {
+  title: 'QA360 Test Report',
+  summary: {
+    total: 10,
+    passed: 8,
+    failed: 2,
+    skipped: 0,
+    duration: 15000,
+    timestamp: new Date().toISOString(),
+  },
+  tests: [
+    {
+      id: 'test-1',
+      name: 'Login Test',
+      status: 'passed',
+      duration: 1500,
+      error: undefined,
+      steps: [],
+    },
+    {
+      id: 'test-2',
+      name: 'Checkout Test',
+      status: 'failed',
+      duration: 3000,
+      error: 'Element not found: #checkout-btn',
+      steps: [
+        {
+          name: 'Click checkout',
+          action: 'click',
+          selector: '#checkout-btn',
+          status: 'failed',
+          duration: 1000,
+          error: 'Element not found',
+        },
+      ],
+    },
+  ],
+  artifacts: {
+    screenshots: [
+      {
+        path: '/path/to/screenshot.png',
+        timestamp: '2024-01-01T00:00:00.000Z',
+        type: 'error',
+      },
+    ],
+    videos: [],
+    traces: [],
+  },
+  environment: {
+    browser: 'chromium',
+    platform: 'darwin',
+    nodeVersion: 'v20.0.0',
+  },
+};
+
+HTMLReporter.generate(reportData, 'report.html');
+```
+
+## Report Features
+
+### Summary Section
+- Total tests, passed, failed, skipped counts
+- Total duration
+- Pass rate percentage
+- Progress bar visualization
+
+### Test Cards
+- Test name and status badge
+- Duration
+- Error message (if failed)
+- Expandable step details
+- Embedded screenshots/videos
+
+### Artifact Gallery
+- All screenshots with thumbnails
+- Video players for test recordings
+- Trace file links
+
+### Filtering
+- Click status badges to filter tests
+- "Show All" to reset filter
+
+## HTML Report Structure
+
+```
+report.html
+├── CSS Styles (dark theme, responsive)
+├── Header (title, summary stats)
+├── Filter Bar (status filters)
+├── Test List (collapsible cards)
+├── Artifact Gallery
+└── JavaScript (interactivity)
+```
+
+## Customization
+
+The report uses CSS variables for easy theming:
+
+```css
+:root {
+  --color-bg: #0f172a;
+  --color-card: #1e293b;
+  --color-success: #22c55e;
+  --color-error: #ef4444;
+  --color-warning: #f59e0b;
+}
+```
+
+## Integration with PlaywrightUiAdapter
+
+```typescript
+const adapter = new PlaywrightUiAdapter();
+
+const config = {
+  target: { baseUrl: 'https://example.com' },
+  htmlReport: './report.html',  // Enable HTML report
+  artifacts: {
+    screenshots: 'always',
+    video: 'on-failure',
+  },
+};
+
+await adapter.runSmokeTests(config);
+// Report automatically generated at ./report.html
+```