import os
import json
import time
import logging
from pathlib import Path
from typing import List, Dict, Optional
from anthropic import Anthropic, APIError, RateLimitError

# Configure logging for audit trails
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s",
    handlers=[logging.FileHandler("test_gen.log"), logging.StreamHandler()]
)
logger = logging.getLogger(__name__)

# Configuration constants - loaded from env vars for security
ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")
MODEL_NAME = "claude-2.0-code"  # Claude Code 2.0 model identifier
MAX_TOKENS = 4096
TEMPERATURE = 0.2  # Low temperature for deterministic test generation
RETRY_MAX = 3
RETRY_DELAY = 5  # Seconds between retries
TEST_OUTPUT_DIR = Path("./generated_tests")
SOURCE_DIR = Path("./src")  # Directory containing production code to test

class TestGenerator:
    def __init__(self):
        if not ANTHROPIC_API_KEY:
            raise ValueError("ANTHROPIC_API_KEY environment variable not set")
        self.client = Anthropic(api_key=ANTHROPIC_API_KEY)
        TEST_OUTPUT_DIR.mkdir(exist_ok=True)
        logger.info(f"Initialized TestGenerator with model {MODEL_NAME}")

    def _build_prompt(self, source_code: str, file_path: str) -> str:
        """Construct the prompt for Claude Code 2.0 to generate pytest tests."""
        return f"""You are a senior Python engineer writing pytest unit tests. Generate comprehensive unit tests for the following code from {file_path}.

Requirements:
1. Use pytest and the unittest.mock library for patching
2. Cover all edge cases, error paths, and happy paths
3. Include docstrings for each test method
4. Do not include any extraneous text, only valid Python test code
5. Import all required modules

Source code:
{source_code}

Generate only the test code, no explanations:"""

    def _write_test_file(self, test_code: str, source_file: Path) -> Path:
        """Write generated test code to a file, appending _test to the source filename."""
        test_filename = f"test_{source_file.stem}.py"
        test_path = TEST_OUTPUT_DIR / test_filename
        with open(test_path, "w") as f:
            f.write(test_code)
        logger.info(f"Wrote test file to {test_path}")
        return test_path

    def generate_tests_for_file(self, source_file: Path) -> Optional[Path]:
        """Generate tests for a single source file with retry logic."""
        for attempt in range(RETRY_MAX):
            try:
                with open(source_file, "r") as f:
                    source_code = f.read()
                logger.info(f"Generating tests for {source_file} (attempt {attempt + 1})")

                response = self.client.messages.create(
                    model=MODEL_NAME,
                    max_tokens=MAX_TOKENS,
                    temperature=TEMPERATURE,
                    messages=[{"role": "user", "content": self._build_prompt(source_code, str(source_file))}]
                )

                test_code = response.content[0].text
                # Strip any markdown code fences Claude might add
                test_code = test_code.replace("python", "").replace("", "").strip()
                return self._write_test_file(test_code, source_file)

            except (APIError, RateLimitError) as e:
                logger.warning(f"API error on attempt {attempt + 1} for {source_file}: {e}")
                if attempt < RETRY_MAX - 1:
                    time.sleep(RETRY_DELAY * (2 ** attempt))  # Exponential backoff
            except Exception as e:
                logger.error(f"Unexpected error processing {source_file}: {e}")
                return None
        logger.error(f"Failed to generate tests for {source_file} after {RETRY_MAX} attempts")
        return None

    def batch_generate(self) -> List[Path]:
        """Generate tests for all Python files in the source directory."""
        generated_files = []
        source_files = list(SOURCE_DIR.glob("**/*.py"))
        logger.info(f"Found {len(source_files)} source files to process")
        for source_file in source_files:
            if source_file.stem.startswith("test_"):
                continue  # Skip existing test files
            result = self.generate_tests_for_file(source_file)
            if result:
                generated_files.append(result)
        logger.info(f"Generated {len(generated_files)} test files total")
        return generated_files

if __name__ == "__main__":
    try:
        generator = TestGenerator()
        generated = generator.batch_generate()
        print(f"Successfully generated {len(generated)} test files")
    except Exception as e:
        logger.critical(f"Fatal error in test generation: {e}")
        exit(1)

import ast
import subprocess
import sys
import logging
from pathlib import Path
from typing import List, Tuple

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s"
)
logger = logging.getLogger(__name__)

TEST_DIR = Path("./generated_tests")
VALID_TEST_DIR = Path("./valid_tests")
PYTHON_EXEC = sys.executable  # Use the same Python interpreter that runs the script

class TestValidator:
    def __init__(self):
        VALID_TEST_DIR.mkdir(exist_ok=True)
        logger.info(f"Initialized TestValidator, valid tests will be written to {VALID_TEST_DIR}")

    def _check_syntax(self, test_path: Path) -> bool:
        """Check if the test file has valid Python syntax."""
        try:
            with open(test_path, "r") as f:
                ast.parse(f.read())
            return True
        except SyntaxError as e:
            logger.warning(f"Syntax error in {test_path}: {e}")
            return False

    def _run_test(self, test_path: Path) -> Tuple[bool, str]:
        """Run the test file with pytest and return pass/fail status and output."""
        try:
            result = subprocess.run(
                [PYTHON_EXEC, "-m", "pytest", str(test_path), "--tb=short", "-q"],
                capture_output=True,
                text=True,
                timeout=30  # Timeout after 30 seconds per test file
            )
            if result.returncode == 0:
                return True, result.stdout
            else:
                return False, result.stderr
        except subprocess.TimeoutExpired:
            logger.warning(f"Test {test_path} timed out")
            return False, "Timeout expired"
        except Exception as e:
            logger.error(f"Error running test {test_path}: {e}")
            return False, str(e)

    def _fix_common_issues(self, test_code: str, test_path: Path) -> str:
        """Fix common issues in generated test code, e.g., missing imports."""
        fixed_code = test_code
        # Add missing pytest import if not present
        if "import pytest" not in fixed_code:
            fixed_code = "import pytest
" + fixed_code
        # Add missing unittest.mock import if needed
        if "from unittest.mock import" in fixed_code and "import unittest" not in fixed_code:
            fixed_code = "import unittest
" + fixed_code
        # Remove any remaining markdown fences
        fixed_code = fixed_code.replace("python", "").replace("", "")
        return fixed_code

    def validate_all(self) -> List[Path]:
        """Validate all test files in the generated_tests directory."""
        valid_files = []
        test_files = list(TEST_DIR.glob("*.py"))
        logger.info(f"Validating {len(test_files)} test files")

        for test_file in test_files:
            logger.info(f"Processing {test_file}")
            # Step 1: Check syntax
            if not self._check_syntax(test_file):
                continue
            # Step 2: Fix common issues
            with open(test_file, "r") as f:
                original_code = f.read()
            fixed_code = self._fix_common_issues(original_code, test_file)
            # Write fixed code back to temp file for testing
            temp_path = TEST_DIR / f"temp_{test_file.name}"
            with open(temp_path, "w") as f:
                f.write(fixed_code)
            # Step 3: Run the test
            passed, output = self._run_test(temp_path)
            temp_path.unlink()  # Clean up temp file
            if passed:
                # Write valid test to final directory
                valid_path = VALID_TEST_DIR / test_file.name
                with open(valid_path, "w") as f:
                    f.write(fixed_code)
                valid_files.append(valid_path)
                logger.info(f"Test {test_file} passed validation")
            else:
                logger.warning(f"Test {test_file} failed validation: {output[:200]}")

        logger.info(f"Validated {len(valid_files)}/{len(test_files)} test files")
        return valid_files

    def generate_report(self, valid_files: List[Path]) -> None:
        """Generate a validation report with metrics."""
        report_path = Path("./validation_report.json")
        report = {
            "total_tested": len(list(TEST_DIR.glob("*.py"))),
            "valid_tests": len(valid_files),
            "validity_rate": len(valid_files) / len(list(TEST_DIR.glob("*.py"))) if list(TEST_DIR.glob("*.py")) else 0,
            "valid_test_paths": [str(p) for p in valid_files]
        }
        with open(report_path, "w") as f:
            json.dump(report, f, indent=2)
        logger.info(f"Wrote validation report to {report_path}")

if __name__ == "__main__":
    validator = TestValidator()
    valid = validator.validate_all()
    validator.generate_report(valid)
    print(f"Validation complete: {len(valid)} valid tests")

import json
import subprocess
import logging
from pathlib import Path
from datetime import datetime
from typing import Dict, List

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s"
)
logger = logging.getLogger(__name__)

class MetricsCollector:
    def __init__(self, repo_path: Path = Path(".")):
        self.repo_path = repo_path
        self.metrics_file = Path("./metrics_history.json")
        self.metrics_history = self._load_history()

    def _load_history(self) -> List[Dict]:
        """Load historical metrics from disk."""
        if self.metrics_file.exists():
            with open(self.metrics_file, "r") as f:
                return json.load(f)
        return []

    def _save_history(self) -> None:
        """Save metrics history to disk."""
        with open(self.metrics_file, "w") as f:
            json.dump(self.metrics_history, f, indent=2)

    def collect_coverage(self) -> float:
        """Collect test coverage using pytest-cov."""
        try:
            result = subprocess.run(
                [sys.executable, "-m", "pytest", "--cov=src", "--cov-report=json", "-q"],
                capture_output=True,
                text=True,
                cwd=self.repo_path,
                timeout=120
            )
            cov_file = self.repo_path / "coverage.json"
            if cov_file.exists():
                with open(cov_file, "r") as f:
                    cov_data = json.load(f)
                coverage = cov_data.get("totals", {}).get("percent_covered", 0.0)
                logger.info(f"Collected test coverage: {coverage:.2f}%")
                return coverage
            else:
                logger.warning("Coverage file not found after pytest run")
                return 0.0
        except subprocess.TimeoutExpired:
            logger.error("Coverage collection timed out")
            return 0.0
        except Exception as e:
            logger.error(f"Error collecting coverage: {e}")
            return 0.0

    def collect_bug_rate(self) -> float:
        """Collect bug rate from Sentry or local log analysis. For this example, use Sentry API."""
        sentry_dsn = os.getenv("SENTRY_DSN")
        if not sentry_dsn:
            logger.warning("SENTRY_DSN not set, using dummy bug rate")
            # Return dummy value for demo: 1.57 bugs per 1000 LOC pre-migration, 0.86 post
            return 1.57 if len(self.metrics_history) == 0 else 0.86
        try:
            # Use sentry-sdk to fetch issue count
            import sentry_sdk
            from sentry_sdk import capture_exception
            # Simplified: count issues in last 30 days
            # In real implementation, use Sentry API to count new issues
            # Dummy value for demo
            return 0.86
        except Exception as e:
            logger.error(f"Error collecting bug rate: {e}")
            return 0.0

    def collect_loc(self) -> int:
        """Count lines of code in src directory."""
        src_path = self.repo_path / "src"
        if not src_path.exists():
            logger.warning("src directory not found")
            return 0
        loc = 0
        for py_file in src_path.glob("**/*.py"):
            with open(py_file, "r") as f:
                loc += len([line for line in f if line.strip()])  # Count non-empty lines
        logger.info(f"Collected LOC: {loc}")
        return loc

    def collect_qa_time(self) -> int:
        """Collect QA cycle time in days. Dummy value for demo."""
        return 14 if len(self.metrics_history) == 0 else 3

    def collect_metrics(self) -> Dict:
        """Collect all metrics and save to history."""
        metrics = {
            "timestamp": datetime.utcnow().isoformat(),
            "coverage_percent": self.collect_coverage(),
            "bug_rate_per_1000_loc": self.collect_bug_rate(),
            "loc": self.collect_loc(),
            "qa_cycle_days": self.collect_qa_time(),
            "total_tests": len(list(Path("./valid_tests").glob("*.py"))) * 10  # Estimate 10 tests per file
        }
        self.metrics_history.append(metrics)
        self._save_history()
        logger.info(f"Collected metrics: {metrics}")
        return metrics

    def print_comparison(self) -> None:
        """Print a comparison of first and last metrics entry."""
        if len(self.metrics_history) < 2:
            logger.warning("Not enough metrics history to compare")
            return
        first = self.metrics_history[0]
        last = self.metrics_history[-1]
        print("\n=== Metrics Comparison ===")
        print(f"Coverage: {first['coverage_percent']:.2f}% -> {last['coverage_percent']:.2f}%")
        print(f"Bug Rate: {first['bug_rate_per_1000_loc']:.2f} -> {last['bug_rate_per_1000_loc']:.2f} per 1000 LOC")
        print(f"QA Cycle: {first['qa_cycle_days']} days -> {last['qa_cycle_days']} days")
        print(f"Total Tests: {first['total_tests']} -> {last['total_tests']}")
        print("==========================\n")

if __name__ == "__main__":
    import sys, os
    collector = MetricsCollector()
    metrics = collector.collect_metrics()
    collector.print_comparison()
    print(f"Metrics collected: {metrics}")

# From our test generator configuration
TEMPERATURE = 0.2  # Low temperature for deterministic test generation

response = self.client.messages.create(
    model=MODEL_NAME,
    max_tokens=MAX_TOKENS,
    temperature=TEMPERATURE,  # Explicitly set low temperature
    messages=[{"role": "user", "content": prompt}]
)

# From our test validator: syntax check pass
def _check_syntax(self, test_path: Path) -> bool:
    """Check if the test file has valid Python syntax."""
    try:
        with open(test_path, "r") as f:
            ast.parse(f.read())
        return True
    except SyntaxError as e:
        logger.warning(f"Syntax error in {test_path}: {e}")
        return False

# GitHub Actions workflow snippet for test generation
- name: Generate tests for modified files
  run: |
    pip install anthropic pytest pytest-cov
    python test_generator.py --modified-only
    python test_validator.py
    coverage report --fail-under=85