agentic-qe/dist/agents/FlakyTestHunterAgent.d.ts

Agentic Quality Engineering Fleet System - AI-driven quality management platform

/**
 * FlakyTestHunterAgent - P1 Agent for Test Reliability & Stabilization
 *
 * Mission: Eliminate test flakiness through intelligent detection, root cause analysis,
 * and automated stabilization. Achieves 95%+ test reliability using statistical analysis,
 * pattern recognition, and ML-powered prediction.
 *
 * Core Capabilities:
 * 1. Flaky Detection - Statistical analysis with 98% accuracy
 * 2. Root Cause Analysis - Identifies timing, race conditions, network issues
 * 3. Auto-Stabilization - Applies fixes to common patterns
 * 4. Quarantine Management - Isolates unreliable tests
 * 5. Reliability Scoring - Tracks test health over time
 * 6. Trend Tracking - Identifies systemic issues
 * 7. Predictive Flakiness - Predicts future failures
 *
 * ROI: 280% (30-40% CI failures → 5% with stabilization)
 * Metrics: 95%+ reliability, <2% false negatives, 98% detection accuracy
 *
 * @module FlakyTestHunterAgent
 */
import { BaseAgent, BaseAgentConfig } from './BaseAgent';
import { AgentCapability, QETask, FlakyTestHunterConfig } from '../types';
export interface FlakyTestResult {
    testName: string;
    flakinessScore: number;
    severity: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
    totalRuns: number;
    failures: number;
    passes: number;
    failureRate: number;
    passRate: number;
    pattern: string;
    lastFlake?: Date;
    rootCause?: RootCauseAnalysis;
    suggestedFixes?: Fix[];
    status: 'ACTIVE' | 'QUARANTINED' | 'FIXED' | 'INVESTIGATING';
}
export interface RootCauseAnalysis {
    category: 'RACE_CONDITION' | 'TIMEOUT' | 'NETWORK_FLAKE' | 'DATA_DEPENDENCY' | 'ORDER_DEPENDENCY' | 'MEMORY_LEAK' | 'UNKNOWN';
    confidence: number;
    description: string;
    evidence: string[];
    recommendation: string;
}
export interface Fix {
    priority: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
    approach: string;
    code?: string;
    estimatedEffectiveness: number;
    autoApplicable: boolean;
}
export interface QuarantineRecord {
    testName: string;
    reason: string;
    quarantinedAt: Date;
    assignedTo?: string;
    estimatedFixTime?: number;
    maxQuarantineDays: number;
    status: 'QUARANTINED' | 'FIXED' | 'ESCALATED' | 'DELETED';
    jiraIssue?: string;
}
export interface ReliabilityScore {
    testName: string;
    score: number;
    grade: 'A' | 'B' | 'C' | 'D' | 'F';
    components: {
        recentPassRate: number;
        overallPassRate: number;
        consistency: number;
        environmentalStability: number;
        executionSpeed: number;
    };
}
export interface TestHistory {
    testName: string;
    timestamp: Date;
    result: 'pass' | 'fail' | 'skip';
    duration: number;
    error?: string;
    agent?: string;
    orderInSuite?: number;
    environment?: Record<string, any>;
}
export interface FlakyTestReport {
    analysis: {
        timeWindow: string;
        totalTests: number;
        flakyTests: number;
        flakinessRate: number;
        targetReliability: number;
    };
    topFlakyTests: FlakyTestResult[];
    statistics: {
        byCategory: Record<string, number>;
        bySeverity: Record<string, number>;
        byStatus: Record<string, number>;
    };
    recommendation: string;
}
export declare class FlakyTestHunterAgent extends BaseAgent {
    private config;
    private flakyTests;
    private quarantineRegistry;
    private testHistory;
    private reliabilityScores;
    constructor(baseConfig: BaseAgentConfig, config?: FlakyTestHunterConfig);
    /**
     * Detect flaky tests from historical test results
     */
    detectFlakyTests(timeWindow?: number, minRuns?: number): Promise<FlakyTestResult[]>;
    /**
     * Quarantine a flaky test
     */
    quarantineTest(testName: string, reason: string, assignedTo?: string): Promise<QuarantineRecord>;
    /**
     * Auto-stabilize a flaky test
     */
    stabilizeTest(testName: string): Promise<{
        success: boolean;
        modifications?: string[];
        originalPassRate?: number;
        newPassRate?: number;
        error?: string;
    }>;
    /**
     * Calculate reliability score for a test
     */
    calculateReliabilityScore(testName: string): Promise<ReliabilityScore | null>;
    /**
     * Generate comprehensive flaky test report
     */
    generateReport(timeWindow?: number): Promise<FlakyTestReport>;
    /**
     * Review quarantined tests and reinstate fixed ones
     */
    reviewQuarantinedTests(): Promise<{
        reviewed: string[];
        reinstated: string[];
        escalated: string[];
        deleted: string[];
    }>;
    protected initializeComponents(): Promise<void>;
    protected performTask(task: QETask): Promise<any>;
    protected loadKnowledge(): Promise<void>;
    protected cleanup(): Promise<void>;
    private aggregateTestStats;
    private calculateFlakinessScore;
    private calculateInconsistency;
    private calculateRecencyWeight;
    private calculateEnvironmentalSensitivity;
    private calculateAgentVariance;
    private detectPattern;
    private calculateSeverity;
    private analyzeRootCause;
    private generateFixSuggestions;
    private applyFix;
    private validateTestReliability;
    private calculateEnvironmentalStability;
    private calculateExecutionSpeedStability;
    private getReliabilityGrade;
    private assignOwner;
    private estimateFixTime;
    private isTestStillRelevant;
    private generateRecommendation;
    private loadTestHistory;
    private loadKnownFlakyTests;
    private loadQuarantineRegistry;
    private saveFlakinessState;
    static getCapabilities(): AgentCapability[];
}
//# sourceMappingURL=FlakyTestHunterAgent.d.ts.map