# Install required packages for AI-enhanced debugging
npm install openai dotenv

# Install additional analysis tools
npm install @playwright/test axios winston

# .env
OPENAI_API_KEY=your_api_key_here
OPENAI_MODEL=gpt-4

// ai-debug-config.js
import { Configuration, OpenAIApi } from 'openai';
import * as dotenv from 'dotenv';

dotenv.config();

export const aiConfig = {
  openai: new OpenAIApi(
    new Configuration({
      apiKey: process.env.OPENAI_API_KEY,
    })
  ),
  model: process.env.OPENAI_MODEL || 'gpt-4',
  maxTokens: 2000,
  temperature: 0.3, // Lower temperature for more deterministic debugging
};

export const debugConfig = {
  captureScreenshots: true,
  captureVideos: true,
  captureTraces: true,
  logLevel: 'verbose',
  retryFailures: true,
  maxRetries: 3,
};

// ai-test-analyzer.js
import { aiConfig } from './ai-debug-config.js';
import fs from 'fs/promises';

export class AITestAnalyzer {
  constructor() {
    this.openai = aiConfig.openai;
    this.model = aiConfig.model;
  }

  /**
   * Analyze test failure using AI
   * @param {Object} testResult - Test result object with error details
   * @returns {Object} Analysis with root cause and suggestions
   */
  async analyzeFailure(testResult) {
    const prompt = this.buildAnalysisPrompt(testResult);
    
    try {
      const response = await this.openai.createChatCompletion({
        model: this.model,
        messages: [
          {
            role: 'system',
            content: 'You are an expert test automation engineer specializing in debugging Playwright tests. Analyze failures and provide actionable solutions.'
          },
          {
            role: 'user',
            content: prompt
          }
        ],
        max_tokens: aiConfig.maxTokens,
        temperature: aiConfig.temperature,
      });

      const analysis = response.data.choices[0].message.content;
      return this.parseAnalysis(analysis);
    } catch (error) {
      console.error('AI Analysis failed:', error.message);
      return this.fallbackAnalysis(testResult);
    }
  }

  /**
   * Build comprehensive prompt for AI analysis
   */
  buildAnalysisPrompt(testResult) {
    return `
Analyze this test failure:

Test Name: ${testResult.testName}
Status: ${testResult.status}
Duration: ${testResult.duration}ms

Error Message:
${testResult.error?.message || 'No error message'}

Stack Trace:
${testResult.error?.stack || 'No stack trace'}

Test Code:
${testResult.testCode || 'Not available'}

Environment:
- Browser: ${testResult.browser}
- Viewport: ${testResult.viewport}
- URL: ${testResult.url}

Previous Runs: ${testResult.previousFailures || 0} failures in last 10 runs

Please provide:
1. Root cause analysis
2. Whether this is flaky (intermittent) or deterministic
3. Specific fix recommendations
4. Code examples if applicable
5. Related documentation links

Format your response as JSON with keys: rootCause, isFlaky, recommendations, codeExample, resources
    `.trim();
  }

  /**
   * Parse AI response into structured format
   */
  parseAnalysis(analysis) {
    try {
      // Try to extract JSON from markdown code blocks
      const jsonMatch = analysis.match(/```json\n([\s\S]*?)\n```/);
      if (jsonMatch) {
        return JSON.parse(jsonMatch[1]);
      }
      return JSON.parse(analysis);
    } catch (error) {
      // If not JSON, return as structured text
      return {
        rootCause: analysis,
        isFlaky: false,
        recommendations: ['Review the analysis above'],
        codeExample: null,
        resources: []
      };
    }
  }

  /**
   * Fallback analysis when AI is unavailable
   */
  fallbackAnalysis(testResult) {
    const errorMessage = testResult.error?.message || '';
    
    return {
      rootCause: 'AI analysis unavailable. Manual review required.',
      isFlaky: testResult.previousFailures > 0 && testResult.previousFailures < 5,
      recommendations: this.getBasicRecommendations(errorMessage),
      codeExample: null,
      resources: ['https://playwright.dev/docs/test-retries']
    };
  }

  getBasicRecommendations(errorMessage) {
    const recommendations = [];
    
    if (errorMessage.includes('timeout')) {
      recommendations.push('Increase timeout values');
      recommendations.push('Check for slow network or animations');
    }
    if (errorMessage.includes('element not found')) {
      recommendations.push('Verify selector stability');
      recommendations.push('Add explicit waits');
    }
    if (errorMessage.includes('navigation')) {
      recommendations.push('Check network conditions');
      recommendations.push('Add waitForLoadState');
    }
    
    return recommendations.length > 0 ? recommendations : ['Review error logs manually'];
  }
}

// flaky-test-detector.js
export class FlakyTestDetector {
  constructor() {
    this.testHistory = new Map();
  }

  /**
   * Record test execution result
   */
  recordTestResult(testName, passed, duration, error = null) {
    if (!this.testHistory.has(testName)) {
      this.testHistory.set(testName, []);
    }
    
    const history = this.testHistory.get(testName);
    history.push({
      passed,
      duration,
      error,
      timestamp: new Date().toISOString()
    });

    // Keep only last 50 runs
    if (history.length > 50) {
      history.shift();
    }
  }

  /**
   * Analyze test for flakiness
   * @returns {Object} Flakiness metrics and classification
   */
  analyzeFlakiness(testName) {
    const history = this.testHistory.get(testName) || [];
    
    if (history.length < 5) {
      return {
        isFlaky: false,
        confidence: 'low',
        reason: 'Insufficient data'
      };
    }

    const totalRuns = history.length;
    const failures = history.filter(r => !r.passed).length;
    const failureRate = failures / totalRuns;

    // Flaky test characteristics
    const hasIntermittentFailures = failures > 0 && failures < totalRuns;
    const hasVariableDuration = this.calculateDurationVariance(history) > 0.3;
    const hasDifferentErrors = this.hasMultipleErrorTypes(history);

    const flakinessScore = this.calculateFlakinessScore({
      failureRate,
      hasIntermittentFailures,
      hasVariableDuration,
      hasDifferentErrors
    });

    return {
      isFlaky: flakinessScore > 0.4,
      flakinessScore: flakinessScore.toFixed(2),
      confidence: this.getConfidenceLevel(totalRuns),
      failureRate: (failureRate * 100).toFixed(1) + '%',
      metrics: {
        totalRuns,
        failures,
        hasVariableDuration,
        hasDifferentErrors
      },
      recommendation: this.getRecommendation(flakinessScore)
    };
  }

  calculateDurationVariance(history) {
    const durations = history.map(r => r.duration);
    const avg = durations.reduce((a, b) => a + b, 0) / durations.length;
    const variance = durations.reduce((sum, d) => sum + Math.pow(d - avg, 2), 0) / durations.length;
    const stdDev = Math.sqrt(variance);
    return stdDev / avg; // Coefficient of variation
  }

  hasMultipleErrorTypes(history) {
    const errorTypes = new Set(
      history
        .filter(r => !r.passed && r.error)
        .map(r => r.error.message.split('\n')[0])
    );
    return errorTypes.size > 1;
  }

  calculateFlakinessScore({ failureRate, hasIntermittentFailures, hasVariableDuration, hasDifferentErrors }) {
    let score = 0;
    
    // Intermittent failures are key indicator
    if (hasIntermittentFailures && failureRate > 0.1 && failureRate < 0.9) {
      score += 0.5;
    }
    
    // Variable duration suggests environmental issues
    if (hasVariableDuration) {
      score += 0.2;
    }
    
    // Multiple error types suggest instability
    if (hasDifferentErrors) {
      score += 0.3;
    }
    
    return Math.min(score, 1.0);
  }

  getConfidenceLevel(totalRuns) {
    if (totalRuns < 10) return 'low';
    if (totalRuns < 30) return 'medium';
    return 'high';
  }

  getRecommendation(flakinessScore) {
    if (flakinessScore > 0.7) {
      return 'High flakiness detected. Isolate and rewrite test with proper waits and assertions.';
    } else if (flakinessScore > 0.4) {
      return 'Moderate flakiness. Review selectors, add explicit waits, and increase timeouts.';
    } else {
      return 'Test appears stable. Monitor for future issues.';
    }
  }
}

// ai-enhanced-reporter.js
import { AITestAnalyzer } from './ai-test-analyzer.js';
import { FlakyTestDetector } from './flaky-test-detector.js';
import fs from 'fs/promises';

export class AIEnhancedReporter {
  constructor() {
    this.analyzer = new AITestAnalyzer();
    this.flakyDetector = new FlakyTestDetector();
    this.failures = [];
  }

  /**
   * Process test result with AI analysis
   */
  async onTestEnd(test, result) {
    // Record for flakiness detection
    this.flakyDetector.recordTestResult(
      test.title,
      result.status === 'passed',
      result.duration,
      result.error
    );

    // Analyze failures with AI
    if (result.status === 'failed') {
      console.log(`\n🔍 Analyzing failure: ${test.title}`);
      
      const testResult = {
        testName: test.title,
        status: result.status,
        duration: result.duration,
        error: result.error,
        testCode: await this.extractTestCode(test),
        browser: test.parent.project().name,
        viewport: test.parent.project().use?.viewport,
        url: result.attachments.find(a => a.name === 'url')?.body?.toString(),
        previousFailures: this.getPreviousFailures(test.title)
      };

      const aiAnalysis = await this.analyzer.analyzeFailure(testResult);
      const flakinessAnalysis = this.flakyDetector.analyzeFlakiness(test.title);

      this.failures.push({
        test: testResult,
        aiAnalysis,
        flakinessAnalysis,
        timestamp: new Date().toISOString()
      });

      this.printAnalysis(test.title, aiAnalysis, flakinessAnalysis);
    }
  }

  /**
   * Extract test code for analysis
   */
  async extractTestCode(test) {
    try {
      const location = test.location;
      const fileContent = await fs.readFile(location.file, 'utf-8');
      const lines = fileContent.split('\n');
      // Extract test function (simplified)
      return lines.slice(location.line - 1, location.line + 20).join('\n');
    } catch (error) {
      return 'Test code not available';
    }
  }

  getPreviousFailures(testName) {
    const history = this.flakyDetector.testHistory.get(testName) || [];
    return history.filter(r => !r.passed).length;
  }

  /**
   * Print formatted analysis to console
   */
  printAnalysis(testName, aiAnalysis, flakinessAnalysis) {
    console.log('\n' + '='.repeat(80));
    console.log(`📊 AI Analysis for: ${testName}`);
    console.log('='.repeat(80));
    
    console.log('\n🎯 Root Cause:');
    console.log(aiAnalysis.rootCause);
    
    console.log('\n🔄 Flakiness Assessment:');
    console.log(`  Status: ${flakinessAnalysis.isFlaky ? '⚠️  FLAKY' : '✅ STABLE'}`);
    console.log(`  Score: ${flakinessAnalysis.flakinessScore}`);
    console.log(`  Confidence: ${flakinessAnalysis.confidence}`);
    console.log(`  Failure Rate: ${flakinessAnalysis.failureRate}`);
    
    console.log('\n💡 Recommendations:');
    aiAnalysis.recommendations.forEach((rec, i) => {
      console.log(`  ${i + 1}. ${rec}`);
    });

    if (aiAnalysis.codeExample) {
      console.log('\n📝 Suggested Fix:');
      console.log(aiAnalysis.codeExample);
    }

    console.log('\n' + '='.repeat(80) + '\n');
  }

  /**
   * Generate comprehensive HTML report
   */
  async generateReport(outputPath = './ai-test-report.html') {
    const html = this.buildHTMLReport();
    await fs.writeFile(outputPath, html);
    console.log(`\n📄 AI-Enhanced Report generated: ${outputPath}`);
  }

  buildHTMLReport() {
    return `
<!DOCTYPE html>
<html>
<head>
  <title>AI-Enhanced Test Report</title>
  <style>
    body { font-family: Arial, sans-serif; margin: 20px; background: #f5f5f5; }
    .failure {



---

## Hands-On Practice

# AI-Enhanced Debugging and Test Failure Analysis

## 🎯 Learning Objectives

- Implement AI-powered log analysis to identify root causes of test failures
- Build automated failure pattern recognition systems
- Create intelligent test retry mechanisms with failure categorization
- Design AI-assisted debugging workflows that reduce investigation time

## 🛠️ Hands-On Exercise

### Exercise: Build an AI-Powered Test Failure Analysis System

**Scenario:** Your team runs 500+ automated tests daily, and analyzing failures manually takes hours. Build an AI-enhanced system that automatically categorizes failures, identifies patterns, and suggests fixes.

### Task

Create a test failure analyzer that:
1. Parses test logs and stack traces
2. Uses AI to categorize failure types
3. Identifies patterns across multiple failures
4. Suggests debugging steps and potential fixes
5. Implements smart retry logic based on failure category

### Step-by-Step Instructions

#### Step 1: Set Up Your Environment

```python
# requirements.txt
openai==1.3.0
pytest==7.4.0
python-dotenv==1.0.0
pandas==2.1.0

# failure_analyzer.py
import json
import os
from openai import OpenAI
from typing import Dict, List, Optional
from dataclasses import dataclass
from datetime import datetime

@dataclass
class TestFailure:
    test_name: str
    error_message: str
    stack_trace: str
    timestamp: datetime
    retry_count: int = 0

class AIFailureAnalyzer:
    def __init__(self):
        self.client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))
        self.failure_history: List[TestFailure] = []
    
    def analyze_failure(self, failure: TestFailure) -> Dict:
        """
        TODO: Implement AI-powered failure analysis
        - Send failure data to AI model
        - Get categorization, root cause, and suggestions
        - Return structured analysis
        """
        pass
    
    def detect_patterns(self, failures: List[TestFailure]) -> Dict:
        """
        TODO: Identify patterns across multiple failures
        - Group similar failures
        - Find common root causes
        - Detect flaky tests
        """
        pass
    
    def should_retry(self, failure: TestFailure, analysis: Dict) -> bool:
        """
        TODO: Implement intelligent retry logic
        - Don't retry code-level bugs
        - Retry infrastructure/timing issues
        - Limit retry attempts
        """
        pass

def analyze_failure(self, failure: TestFailure) -> Dict:
    prompt = f"""
    Analyze this test failure and provide structured output:
    
    Test: {failure.test_name}
    Error: {failure.error_message}
    Stack Trace: {failure.stack_trace[:1000]}
    
    Provide JSON with:
    1. category: (assertion_error|timeout|network_error|element_not_found|data_issue|infrastructure)
    2. severity: (critical|high|medium|low)
    3. root_cause: brief explanation
    4. is_flaky: boolean
    5. retry_recommended: boolean
    6. debugging_steps: array of 3-5 specific steps
    7. potential_fixes: array of 2-3 code suggestions
    """
    
    # TODO: Call OpenAI API and parse response
    pass

def detect_patterns(self, failures: List[TestFailure]) -> Dict:
    # Group failures by similarity
    failure_summaries = [
        f"{f.test_name}: {f.error_message[:100]}" 
        for f in failures
    ]
    
    prompt = f"""
    Analyze these {len(failures)} test failures and identify patterns:
    
    {json.dumps(failure_summaries, indent=2)}
    
    Provide JSON with:
    1. common_patterns: array of identified patterns
    2. affected_components: which parts of the system
    3. likely_root_causes: most probable causes
    4. priority_order: which to investigate first
    """
    
    # TODO: Implement pattern detection
    pass

# test_sample_app.py
import pytest
import random
import time

class TestSampleApp:
    def test_login_success(self):
        """Simulates occasional timeout"""
        if random.random() < 0.3:
            time.sleep(6)  # Simulate slow response
            raise TimeoutError("Login request timed out after 5s")
        assert True
    
    def test_user_profile_load(self):
        """Simulates missing element"""
        if random.random() < 0.2:
            raise Exception("Element not found: #user-profile")
        assert True
    
    def test_data_validation(self):
        """Simulates data mismatch"""
        expected = {"id": 123, "name": "Test User"}
        actual = {"id": 123, "name": "Test User2"}
        assert expected == actual, f"Data mismatch: {expected} != {actual}"
    
    def test_api_integration(self):
        """Simulates network issues"""
        if random.random() < 0.25:
            raise ConnectionError("Failed to connect to API: Connection refused")
        assert True

# smart_test_runner.py
import pytest
from failure_analyzer import AIFailureAnalyzer, TestFailure
from datetime import datetime

class SmartTestRunner:
    def __init__(self):
        self.analyzer = AIFailureAnalyzer()
        self.max_retries = 3
    
    def run_with_analysis(self, test_file: str):
        """
        TODO: 
        1. Run tests and capture failures
        2. Analyze each failure with AI
        3. Retry based on AI recommendations
        4. Generate comprehensive report
        """
        pass
    
    def generate_report(self, results: List[Dict]) -> str:
        """
        TODO: Create detailed failure analysis report
        """
        pass