qa360 2.1.2 → 2.1.4

package/dist/core/reporting/index.d.ts

@@ -1,6 +0,0 @@
-/**
- * QA360 Reporting Module
- *
- * Generates test reports in various formats (HTML, JSON, JUnit)
- */
-export { HTMLReporter, generateHTMLReport, type ReportData, type TestReport, type StepReport, type ReportScreenshotArtifact as ScreenshotArtifact, type ReportVideoArtifact as VideoArtifact, type ReportTraceArtifact as TraceArtifact, } from './html-reporter.js';

package/dist/core/reporting/index.js

@@ -1,6 +0,0 @@
-/**
- * QA360 Reporting Module
- *
- * Generates test reports in various formats (HTML, JSON, JUnit)
- */
-export { HTMLReporter, generateHTMLReport, } from './html-reporter.js';

package/dist/core/retry/flakiness-integration.d.ts

@@ -1,60 +0,0 @@
-/**
- * Flakiness Integration for Smart Retry
- *
- * Integrates Smart Retry with the Flakiness Detection Engine
- * to make intelligent retry decisions based on historical data.
- */
-import type { FlakinessResult, TestResult as FlakinessTestResult } from '../flakiness/index.js';
-import type { RetryConfig, RetryRecommendation } from './types.js';
-/**
- * Enhanced retry config with flakiness awareness
- */
-export interface FlakinessAwareRetryConfig extends RetryConfig {
-    /** Use flakiness score to determine retry strategy */
-    useFlakinessScore?: boolean;
-    /** Minimum historical runs before using flakiness data */
-    minHistoricalRuns?: number;
-    /** Boost retry attempts for known flaky tests */
-    boostRetriesForFlaky?: boolean;
-    /** Reduce retries for known stable tests */
-    reduceRetriesForStable?: boolean;
-}
-/**
- * Flakiness-aware retry engine
- */
-export declare class FlakinessAwareRetryEngine {
-    private flakinessHistory;
-    private testHistory;
-    /**
-     * Load flakiness data
-     */
-    loadFlakinessData(results: FlakinessResult[]): void;
-    /**
-     * Add test result to history
-     */
-    addTestResult(testId: string, result: FlakinessTestResult): void;
-    /**
-     * Get retry config for a specific test based on flakiness
-     */
-    getRetryConfigForTest(testId: string, baseConfig: FlakinessAwareRetryConfig): RetryConfig;
-    /**
-     * Get comprehensive retry recommendation
-     */
-    getRetryRecommendation(testId: string): RetryRecommendation;
-    /**
-     * Check if test should be skipped (too flaky)
-     */
-    shouldSkipTest(testId: string): boolean;
-    /**
-     * Get flakiness history
-     */
-    getFlakinessHistory(): Map<string, FlakinessResult>;
-    /**
-     * Clear all history
-     */
-    clearHistory(): void;
-}
-/**
- * Create a flakiness-aware retry engine
- */
-export declare function createFlakinessAwareRetryEngine(): FlakinessAwareRetryEngine;

package/dist/core/retry/flakiness-integration.js

@@ -1,228 +0,0 @@
-/**
- * Flakiness Integration for Smart Retry
- *
- * Integrates Smart Retry with the Flakiness Detection Engine
- * to make intelligent retry decisions based on historical data.
- */
-import { RetryStrategy } from './types.js';
-/**
- * Flakiness-aware retry engine
- */
-export class FlakinessAwareRetryEngine {
-    flakinessHistory = new Map();
-    testHistory = new Map();
-    /**
-     * Load flakiness data
-     */
-    loadFlakinessData(results) {
-        for (const result of results) {
-            this.flakinessHistory.set(result.testId, result);
-        }
-    }
-    /**
-     * Add test result to history
-     */
-    addTestResult(testId, result) {
-        if (!this.testHistory.has(testId)) {
-            this.testHistory.set(testId, []);
-        }
-        this.testHistory.get(testId).push(result);
-    }
-    /**
-     * Get retry config for a specific test based on flakiness
-     */
-    getRetryConfigForTest(testId, baseConfig) {
-        const flakiness = this.flakinessHistory.get(testId);
-        const recentResults = this.testHistory.get(testId);
-        // If no flakiness data, return base config
-        const minRuns = baseConfig.minHistoricalRuns ?? 0;
-        if (!flakiness || !recentResults || recentResults.length < minRuns) {
-            return baseConfig;
-        }
-        const config = { ...baseConfig };
-        // Adjust based on flakiness score
-        if (baseConfig.useFlakinessScore) {
-            const score = flakiness.score;
-            if (score >= 90) {
-                // Legendary/Solid - reduce retries
-                if (baseConfig.reduceRetriesForStable) {
-                    config.maxRetries = Math.max(0, baseConfig.maxRetries - 1);
-                    config.strategy = RetryStrategy.FIXED;
-                }
-            }
-            else if (score >= 75) {
-                // Good - keep base config
-                config.strategy = RetryStrategy.FIXED;
-            }
-            else if (score >= 50) {
-                // Shaky - increase retries slightly
-                if (baseConfig.boostRetriesForFlaky) {
-                    config.maxRetries = baseConfig.maxRetries + 1;
-                    config.strategy = RetryStrategy.ADAPTIVE;
-                }
-            }
-            else {
-                // Unstable - aggressive retry
-                if (baseConfig.boostRetriesForFlaky) {
-                    config.maxRetries = baseConfig.maxRetries + 2;
-                    config.strategy = RetryStrategy.INTELLIGENT;
-                }
-            }
-        }
-        // Adjust based on pattern type
-        if (flakiness.patternType) {
-            switch (flakiness.patternType) {
-                case 'timing':
-                    config.initialDelayMs = Math.max(config.initialDelayMs, 2000);
-                    config.retryOnTimeout = true;
-                    break;
-                case 'external_dependency':
-                    config.initialDelayMs = Math.max(config.initialDelayMs, 3000);
-                    config.strategy = RetryStrategy.EXPONENTIAL;
-                    break;
-                case 'race_condition':
-                    config.strategy = RetryStrategy.EXPONENTIAL;
-                    config.jitterFactor = Math.max(config.jitterFactor, 0.2);
-                    break;
-                case 'selector_issue':
-                    config.strategy = RetryStrategy.FIXED;
-                    config.maxRetries = Math.min(config.maxRetries, 3);
-                    break;
-            }
-        }
-        // Adjust based on recent streak
-        if (flakiness.currentStreak && flakiness.currentStreak > 3) {
-            if (flakiness.streakType === 'fail') {
-                // Long fail streak - boost retries
-                config.maxRetries = config.maxRetries + 1;
-            }
-            else {
-                // Long pass streak - reduce retries
-                config.maxRetries = Math.max(1, config.maxRetries - 1);
-            }
-        }
-        return config;
-    }
-    /**
-     * Get comprehensive retry recommendation
-     */
-    getRetryRecommendation(testId) {
-        const flakiness = this.flakinessHistory.get(testId);
-        const recentResults = this.testHistory.get(testId);
-        if (!flakiness || !recentResults || recentResults.length < 3) {
-            return {
-                shouldRetry: true,
-                strategy: RetryStrategy.ADAPTIVE,
-                maxRetries: 3,
-                initialDelayMs: 1000,
-                confidence: 0.5,
-                reason: 'Insufficient historical data, using default adaptive retry'
-            };
-        }
-        // Analyze recent failures
-        const recentFailures = recentResults.slice(-10).filter(r => !r.success);
-        const failureRate = recentFailures.length / Math.min(recentResults.length, 10);
-        // Build recommendation
-        let strategy;
-        let maxRetries;
-        let initialDelayMs;
-        let confidence;
-        const reasons = [];
-        // Base recommendation on flakiness score
-        if (flakiness.score >= 90) {
-            strategy = RetryStrategy.NONE;
-            maxRetries = 0;
-            initialDelayMs = 0;
-            confidence = 0.9;
-            reasons.push('Test is highly reliable');
-        }
-        else if (flakiness.score >= 75) {
-            strategy = RetryStrategy.FIXED;
-            maxRetries = 2;
-            initialDelayMs = 1000;
-            confidence = 0.75;
-            reasons.push('Test is occasionally flaky');
-        }
-        else if (flakiness.score >= 50) {
-            strategy = RetryStrategy.ADAPTIVE;
-            maxRetries = 3;
-            initialDelayMs = 1000;
-            confidence = 0.85;
-            reasons.push('Test is often flaky');
-        }
-        else {
-            strategy = RetryStrategy.INTELLIGENT;
-            maxRetries = 5;
-            initialDelayMs = 2000;
-            confidence = 0.9;
-            reasons.push('Test is very flaky, aggressive retry recommended');
-        }
-        // Adjust based on pattern
-        if (flakiness.patternType) {
-            reasons.push(`Pattern: ${flakiness.patternType}`);
-            switch (flakiness.patternType) {
-                case 'timing':
-                    initialDelayMs = Math.max(initialDelayMs, 2000);
-                    strategy = flakiness.score < 75 ? RetryStrategy.EXPONENTIAL : strategy;
-                    break;
-                case 'external_dependency':
-                    initialDelayMs = Math.max(initialDelayMs, 3000);
-                    break;
-                case 'selector_issue':
-                    strategy = RetryStrategy.FIXED;
-                    maxRetries = Math.min(maxRetries, 3);
-                    break;
-            }
-        }
-        // Adjust based on recent failure rate
-        if (failureRate > 0.5) {
-            maxRetries = Math.min(maxRetries + 1, 5);
-            reasons.push(`High recent failure rate (${Math.round(failureRate * 100)}%)`);
-        }
-        else if (failureRate < 0.1 && flakiness.score >= 75) {
-            // For highly reliable tests (score >= 90), keep maxRetries at 0
-            if (flakiness.score < 90) {
-                maxRetries = Math.max(maxRetries - 1, 1);
-            }
-            reasons.push('Low recent failure rate');
-        }
-        return {
-            shouldRetry: maxRetries > 0,
-            strategy,
-            maxRetries,
-            initialDelayMs,
-            confidence,
-            reason: reasons.join('; '),
-            pattern: flakiness.patternType
-        };
-    }
-    /**
-     * Check if test should be skipped (too flaky)
-     */
-    shouldSkipTest(testId) {
-        const flakiness = this.flakinessHistory.get(testId);
-        if (!flakiness)
-            return false;
-        // Skip if score is very low and has many runs
-        return flakiness.score < 30 && flakiness.totalRuns >= 10;
-    }
-    /**
-     * Get flakiness history
-     */
-    getFlakinessHistory() {
-        return new Map(this.flakinessHistory);
-    }
-    /**
-     * Clear all history
-     */
-    clearHistory() {
-        this.flakinessHistory.clear();
-        this.testHistory.clear();
-    }
-}
-/**
- * Create a flakiness-aware retry engine
- */
-export function createFlakinessAwareRetryEngine() {
-    return new FlakinessAwareRetryEngine();
-}

package/dist/core/retry/index.d.ts

@@ -1,14 +0,0 @@
-/**
- * QA360 Smart Retry Module (F8)
- *
- * Intelligent retry strategies based on flakiness scoring and pattern detection.
- * Completes the flakiness system: Detection → Scoring → Quarantine → Smart Retry
- *
- * @module retry
- */
-export { RetryStrategy, DEFAULT_RETRY_CONFIG } from './types.js';
-export type { RetryAttempt, RetryResult, RetryConfig, RetryRecommendation, RetryHistoryRecord, RetryStatistics } from './types.js';
-export { SmartRetryEngine, createSmartRetryEngine, type TestExecutor } from './retry-engine.js';
-export { FlakinessAwareRetryEngine, createFlakinessAwareRetryEngine, type FlakinessAwareRetryConfig } from './flakiness-integration.js';
-export { RetryVault } from './vault.js';
-export type { FlakinessResult, FlakinessCategory, TestResult as FlakinessTestResult } from '../flakiness/index.js';

package/dist/core/retry/index.js

@@ -1,16 +0,0 @@
-/**
- * QA360 Smart Retry Module (F8)
- *
- * Intelligent retry strategies based on flakiness scoring and pattern detection.
- * Completes the flakiness system: Detection → Scoring → Quarantine → Smart Retry
- *
- * @module retry
- */
-// Types
-export { RetryStrategy, DEFAULT_RETRY_CONFIG } from './types.js';
-// Core engine
-export { SmartRetryEngine, createSmartRetryEngine } from './retry-engine.js';
-// Flakiness integration
-export { FlakinessAwareRetryEngine, createFlakinessAwareRetryEngine } from './flakiness-integration.js';
-// Vault integration
-export { RetryVault } from './vault.js';

package/dist/core/retry/retry-engine.d.ts

@@ -1,80 +0,0 @@
-/**
- * Smart Retry Engine
- *
- * Core retry logic with multiple strategies and adaptive behavior.
- */
-import type { RetryConfig, RetryResult, RetryRecommendation } from './types.js';
-/**
- * Test execution function type
- */
-export type TestExecutor<T = unknown> = () => Promise<T>;
-/**
- * Smart Retry Engine
- */
-export declare class SmartRetryEngine {
-    private config;
-    constructor(config?: Partial<RetryConfig>);
-    /**
-     * Execute a test with retry logic
-     */
-    executeWithRetry(testId: string, executor: TestExecutor, context?: {
-        testName?: string;
-        gate?: string;
-        flakinessScore?: number;
-        patternType?: string;
-    }): Promise<RetryResult>;
-    /**
-     * Get retry recommendation based on flakiness and pattern
-     */
-    getRetryRecommendation(params: {
-        flakinessScore?: number;
-        patternType?: string;
-        errorType?: string;
-        errorCount?: number;
-        recentAttempts?: number;
-    }): RetryRecommendation;
-    /**
-     * Calculate delay before retry attempt
-     */
-    private calculateDelay;
-    /**
-     * Get effective strategy based on context
-     */
-    private getEffectiveStrategy;
-    /**
-     * Calculate intelligent delay based on common patterns
-     */
-    private getIntelligentDelay;
-    /**
-     * Apply jitter to delay to avoid thundering herd
-     */
-    private applyJitter;
-    /**
-     * Check if error type is non-retriable
-     */
-    private isNonRetriableError;
-    /**
-     * Check if error is an assertion failure
-     */
-    private isAssertionError;
-    /**
-     * Check if error is a timeout
-     */
-    private isTimeoutError;
-    /**
-     * Delay for specified milliseconds
-     */
-    private delay;
-    /**
-     * Update retry configuration
-     */
-    updateConfig(config: Partial<RetryConfig>): void;
-    /**
-     * Get current configuration
-     */
-    getConfig(): RetryConfig;
-}
-/**
- * Create a smart retry engine
- */
-export declare function createSmartRetryEngine(config?: Partial<RetryConfig>): SmartRetryEngine;