test_pre_commit_setup.py

#!/usr/bin/env python3
"""
Test script to validate pre-commit hooks and CI setup for the Trading Platform.

This script tests:
1. JSON linting and formatting
2. Schema validation
3. Unit tests execution
4. Configuration loading
"""

import json
import subprocess
import sys
import tempfile
from pathlib import Path
from typing import Any, Dict, List


def run_command(cmd: List[str], cwd: str = None) -> tuple[bool, str, str]:
    """Run a command and return success status, stdout, stderr"""
    try:
        result = subprocess.run(
            cmd, capture_output=True, text=True, cwd=cwd, timeout=60
        )
        return result.returncode == 0, result.stdout, result.stderr
    except subprocess.TimeoutExpired:
        return False, "", "Command timed out"
    except Exception as e:
        return False, "", str(e)


def test_json_validation():
    """Test JSON file validation"""
    print("🔍 Testing JSON validation...")

    # Test valid JSON
    valid_json = {"test": "value", "number": 123, "array": [1, 2, 3]}

    with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
        json.dump(valid_json, f)
        temp_file = Path(f.name)

    try:
        # Test JSON syntax validation
        success, stdout, stderr = run_command(
            ["python", "-m", "json.tool", str(temp_file)]
        )

        if success:
            print("  ✅ JSON syntax validation passed")
        else:
            print(f"  ❌ JSON syntax validation failed: {stderr}")
            return False

    finally:
        temp_file.unlink()

    return True


def test_schema_validation():
    """Test JSON schema validation"""
    print("🔍 Testing schema validation...")

    schema_path = Path("trading_platform.schema.json")
    if not schema_path.exists():
        print("  ⚠️  Schema file not found, skipping schema validation")
        return True

    try:
        # Import required modules
        from jsonschema import Draft7Validator, ValidationError, validate

        # Load schema
        with open(schema_path, "r") as f:
            schema = json.load(f)

        # Validate schema itself
        try:
            Draft7Validator.check_schema(schema)
            print("  ✅ Schema is valid JSON Schema")
        except Exception as e:
            print(f"  ❌ Schema validation failed: {e}")
            return False

        # Test config files
        config_files = list(Path(".").glob("*example*.json"))
        for config_file in config_files:
            try:
                with open(config_file, "r") as f:
                    config = json.load(f)
                validate(instance=config, schema=schema)
                print(f"  ✅ {config_file.name} is valid")
            except ValidationError as e:
                print(f"  ❌ {config_file.name} validation failed: {e.message}")
                return False
            except Exception as e:
                print(f"  ❌ Error validating {config_file.name}: {str(e)}")
                return False

    except ImportError:
        print("  ⚠️  jsonschema not installed, installing...")
        success, _, stderr = run_command(
            [sys.executable, "-m", "pip", "install", "jsonschema"]
        )
        if not success:
            print(f"  ❌ Failed to install jsonschema: {stderr}")
            return False
        return test_schema_validation()  # Retry after installation

    return True


def test_unit_tests():
    """Test unit test execution"""
    print("🔍 Testing unit tests...")

    test_files = ["test_config_loader.py"]

    for test_file in test_files:
        if Path(test_file).exists():
            success, stdout, stderr = run_command(
                [sys.executable, "-m", "pytest", test_file, "-v", "--tb=short"]
            )

            if success:
                print(f"  ✅ Unit tests in {test_file} passed")
            else:
                print(f"  ❌ Unit tests in {test_file} failed:")
                print(f"    stdout: {stdout}")
                print(f"    stderr: {stderr}")
                return False
        else:
            print(f"  ⚠️  Test file {test_file} not found")

    return True


def test_config_loading():
    """Test configuration loading"""
    print("🔍 Testing configuration loading...")

    try:
        from config_loader import ConfigurationLoader, create_default_config

        # Test default config creation
        try:
            default_config = create_default_config()
            print("  ✅ Default config created successfully")
        except Exception as e:
            print(f"  ❌ Failed to create default config: {e}")
            return False

        # Test loading example configs
        example_configs = list(Path(".").glob("*example*.json"))
        for config_file in example_configs:
            try:
                loader = ConfigurationLoader(str(config_file))
                config = loader.load_config()
                print(f"  ✅ {config_file.name} loaded successfully")
            except Exception as e:
                print(f"  ❌ Failed to load {config_file.name}: {e}")
                return False

    except ImportError as e:
        print(f"  ⚠️  Could not import config_loader: {e}")

    return True


def test_linting():
    """Test code linting with flake8"""
    print("🔍 Testing code linting...")

    python_files = list(Path(".").glob("*.py"))
    if not python_files:
        print("  ⚠️  No Python files found")
        return True

    # Test flake8 (exclude virtual environment and cache directories)
    success, stdout, stderr = run_command(
        [
            "flake8",
            ".",
            "--count",
            "--select=E9,F63,F7,F82",
            "--show-source",
            "--statistics",
            "--exclude=trading_env,venv,.venv,.git,.pytest_cache,__pycache__",
        ]
    )

    if success:
        print("  ✅ Flake8 critical checks passed")
    else:
        print(f"  ❌ Flake8 critical checks failed: {stdout} {stderr}")
        return False

    return True


def test_formatting():
    """Test code formatting with black"""
    print("🔍 Testing code formatting...")

    success, stdout, stderr = run_command(["black", "--check", "--diff", "."])

    if success:
        print("  ✅ Code formatting is correct")
    else:
        print("  ⚠️  Code formatting issues found (not critical for testing)")

    return True


def run_pre_commit_test():
    """Run a subset of pre-commit hooks for testing"""
    print("🔍 Testing pre-commit hooks...")

    success, stdout, stderr = run_command(
        ["pre-commit", "run", "--all-files", "check-json"]
    )

    if success:
        print("  ✅ Pre-commit JSON check passed")
    else:
        print(f"  ❌ Pre-commit JSON check failed: {stdout} {stderr}")
        return False

    return True


def main():
    """Run all tests"""
    print("🚀 Testing Trading Platform Pre-commit and CI Setup\n")

    tests = [
        ("JSON Validation", test_json_validation),
        ("Schema Validation", test_schema_validation),
        ("Unit Tests", test_unit_tests),
        ("Configuration Loading", test_config_loading),
        ("Code Linting", test_linting),
        ("Code Formatting", test_formatting),
        ("Pre-commit Hooks", run_pre_commit_test),
    ]

    passed = 0
    failed = 0

    for test_name, test_func in tests:
        try:
            if test_func():
                passed += 1
            else:
                failed += 1
        except Exception as e:
            print(f"  ❌ {test_name} failed with exception: {e}")
            failed += 1
        print()

    print(f"📊 Test Results: {passed} passed, {failed} failed")

    if failed == 0:
        print("🎉 All tests passed! Pre-commit and CI setup is working correctly.")
        return 0
    else:
        print("💥 Some tests failed. Please review the setup.")
        return 1


if __name__ == "__main__":
    sys.exit(main())