qa360 2.1.2 → 2.1.4

package/dist/core/repair/utils/error-analyzer.d.ts

@@ -1,28 +0,0 @@
-/**
- * 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 declare function analyzeTestError(testFile: string, testName: string, errorMessage: string, stack?: string): TestError;
-/**
- * Classify multiple test errors
- */
-export declare function classifyErrors(errors: string[]): Map<ErrorType, number>;
-/**
- * Check if error is auto-fixable
- */
-export declare function isAutoFixable(error: TestError): boolean;
-/**
- * Get fix suggestions for an error type
- */
-export declare function getCommonFixes(error: TestError): string[];

package/dist/core/repair/utils/error-analyzer.js

@@ -1,264 +0,0 @@
-/**
- * Error Analyzer
- *
- * Analyzes test errors to extract patterns and classify problems.
- */
-/**
- * Analyze a test error message and classify it
- */
-export function analyzeTestError(testFile, testName, errorMessage, stack) {
-    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, stack) {
-    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) {
-    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) {
-    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) {
-    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) {
-    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) {
-    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) {
-    const contexts = {
-        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) {
-    return parsed.type.toUpperCase().replace(/_/g, '-');
-}
-/**
- * Classify multiple test errors
- */
-export function classifyErrors(errors) {
-    const counts = new Map();
-    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) {
-    // 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) {
-    const fixes = {
-        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/dist/core/reporting/html-reporter.d.ts

@@ -1,119 +0,0 @@
-/**
- * QA360 HTML Reporter
- *
- * Generates interactive HTML reports with embedded screenshots,
- * videos, and traces for UI test results.
- */
-export interface ReportData {
-    title: string;
-    summary: {
-        total: number;
-        passed: number;
-        failed: number;
-        skipped: number;
-        duration: number;
-        timestamp: string;
-    };
-    tests: TestReport[];
-    artifacts?: {
-        screenshots: ReportScreenshotArtifact[];
-        videos: ReportVideoArtifact[];
-        traces: ReportTraceArtifact[];
-    };
-    environment?: {
-        browser?: string;
-        platform?: string;
-        nodeVersion?: string;
-        qa360Version?: string;
-    };
-}
-export interface TestReport {
-    id: string;
-    name: string;
-    status: 'passed' | 'failed' | 'skipped';
-    duration: number;
-    error?: string;
-    steps: StepReport[];
-    artifacts?: {
-        screenshots: string[];
-        video?: string;
-        trace?: string;
-    };
-}
-export interface StepReport {
-    name: string;
-    action: string;
-    selector?: string;
-    value?: string;
-    status: 'passed' | 'failed' | 'skipped';
-    duration: number;
-    error?: string;
-    screenshot?: string;
-}
-export interface ReportScreenshotArtifact {
-    path: string;
-    timestamp: string;
-    type: 'before' | 'after' | 'error' | 'initial';
-    stepIndex?: number;
-}
-export interface ReportVideoArtifact {
-    path: string;
-    duration: number;
-}
-export interface ReportTraceArtifact {
-    path: string;
-    format: string;
-}
-/**
- * HTML Report Generator
- */
-export declare class HTMLReporter {
-    /**
-     * Generate HTML report from test data
-     */
-    static generate(data: ReportData, outputPath: string): void;
-    /**
-     * Generate HTML content
-     */
-    private static generateHTML;
-    /**
-     * Get CSS styles
-     */
-    private static getCSS;
-    /**
-     * Generate header HTML
-     */
-    private static getHeader;
-    /**
-     * Generate summary HTML
-     */
-    private static getSummary;
-    /**
-     * Generate tests HTML
-     */
-    private static getTests;
-    /**
-     * Generate single test card HTML
-     */
-    private static getTestCard;
-    /**
-     * Generate step HTML
-     */
-    private static getStep;
-    /**
-     * Generate artifacts section HTML
-     */
-    private static getArtifacts;
-    /**
-     * Generate JavaScript
-     */
-    private static getJavaScript;
-    /**
-     * Escape HTML special characters
-     */
-    private static escapeHTML;
-}
-/**
- * Generate HTML report from Playwright test results
- */
-export declare function generateHTMLReport(title: string, results: any[], outputPath: string, artifacts?: any): void;