validate_implementations.py

#!/usr/bin/env python3
"""
Validation script for the handwritten text transcription application
Tests all major implementations and services
"""

import sys
import os
import asyncio
import tempfile
import traceback
from datetime import datetime
from pathlib import Path

# Add backend to path
sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'backend'))

def print_section(title):
    """Print a formatted section header"""
    print(f"\n{'='*60}")
    print(f"  {title}")
    print(f"{'='*60}")

def print_result(test_name, success, error=None):
    """Print test result"""
    status = "✓ PASS" if success else "✗ FAIL"
    print(f"{status:<8} {test_name}")
    if error:
        print(f"         Error: {error}")

async def validate_error_handler():
    """Test the error handler service"""
    print_section("VALIDATING ERROR HANDLER")
    
    try:
        from services.error_handler import ErrorHandler, ApplicationError, ValidationError, ErrorCategory, ErrorSeverity
        
        # Test 1: Basic initialization
        handler = ErrorHandler()
        print_result("Error handler initialization", True)
        
        # Test 2: Error classification
        test_error = ValueError("Test error")
        classified = handler.classify_exception(test_error, {"test": "context"})
        print_result("Error classification", isinstance(classified, ApplicationError))
        
        # Test 3: Custom application error
        app_error = ApplicationError(
            "Test application error",
            ErrorCategory.VALIDATION,
            ErrorSeverity.MEDIUM,
            user_message="User friendly message"
        )
        print_result("Custom application error creation", app_error.user_message == "User friendly message")
        
        # Test 4: Error statistics
        stats = handler.get_error_stats()
        print_result("Error statistics retrieval", isinstance(stats, dict))
        
        return True
        
    except Exception as e:
        print_result("Error handler validation", False, str(e))
        return False

async def validate_resource_manager():
    """Test the resource manager service"""
    print_section("VALIDATING RESOURCE MANAGER")
    
    try:
        from services.resource_manager import ResourceManager
        
        # Test 1: Basic initialization
        manager = ResourceManager()
        print_result("Resource manager initialization", True)
        
        # Test 2: Temp file management
        async with manager.managed_temp_file(suffix='.txt', prefix='test_') as temp_path:
            # Write test data
            with open(temp_path, 'w') as f:
                f.write("Test data")
            exists_during = os.path.exists(temp_path)
        
        exists_after = os.path.exists(temp_path)
        print_result("Managed temp file creation/cleanup", exists_during and not exists_after)
        
        # Test 3: Resource statistics
        stats = await manager.get_resource_stats()
        print_result("Resource statistics", isinstance(stats, dict))
        
        return True
        
    except Exception as e:
        print_result("Resource manager validation", False, str(e))
        return False

async def validate_security_service():
    """Test the security service"""
    print_section("VALIDATING SECURITY SERVICE")
    
    try:
        from services.security_service import SecurityService
        
        # Test 1: Basic initialization
        security = SecurityService()
        print_result("Security service initialization", True)
        
        # Test 2: Rate limiting
        result = await security.check_rate_limit("test_client", "api_calls")
        print_result("Rate limiting check", isinstance(result, bool))
        
        # Test 3: Secure token generation
        token = security.generate_secure_token(16)
        print_result("Secure token generation", len(token) > 0)
        
        # Test 4: Data hashing
        hash_result, salt = security.hash_data("test_data")
        print_result("Data hashing", len(hash_result) > 0 and len(salt) > 0)
        
        # Test 5: Hash verification
        is_valid = security.verify_hash("test_data", hash_result, salt)
        print_result("Hash verification", is_valid)
        
        # Test 6: Security statistics
        stats = security.get_security_stats()
        print_result("Security statistics", isinstance(stats, dict))
        
        return True
        
    except Exception as e:
        print_result("Security service validation", False, str(e))
        return False

async def validate_data_protection():
    """Test the data protection service"""
    print_section("VALIDATING DATA PROTECTION")
    
    try:
        from services.data_protection_service import DataProtectionService
        
        # Test 1: Basic initialization
        protection = DataProtectionService()
        print_result("Data protection initialization", True)
        
        # Test 2: Data encryption/decryption
        test_data = b"This is sensitive test data"
        encrypted_data, data_id = await protection.encrypt_data(test_data, {"type": "test"})
        print_result("Data encryption", len(encrypted_data) > 0 and len(data_id) > 0)
        
        decrypted_data, metadata = await protection.decrypt_data(data_id)
        print_result("Data decryption", decrypted_data == test_data)
        
        # Test 3: Text anonymization
        test_text = "Contact me at john.doe@email.com or 555-123-4567"
        anonymized = await protection.anonymize_text_data(test_text)
        print_result("Text anonymization", "[EMAIL]" in anonymized and "[PHONE]" in anonymized)
        
        # Test 4: Retention tracking
        await protection.track_data_retention(data_id, "test_data")
        print_result("Data retention tracking", True)
        
        # Test 5: Protection statistics
        stats = protection.get_protection_stats()
        print_result("Protection statistics", isinstance(stats, dict))
        
        return True
        
    except Exception as e:
        print_result("Data protection validation", False, str(e))
        return False

def validate_frontend_structure():
    """Validate frontend file structure and TypeScript types"""
    print_section("VALIDATING FRONTEND STRUCTURE")
    
    try:
        # Check key frontend files exist
        frontend_files = [
            'src/types/index.ts',
            'src/store/appStore.ts', 
            'src/App.tsx',
            'src/components/NotificationSystem.tsx',
            'src/components/EnhancedProgressCard.tsx',
            'jest.config.json'
        ]
        
        missing_files = []
        for file_path in frontend_files:
            full_path = os.path.join(os.path.dirname(__file__), file_path)
            if not os.path.exists(full_path):
                missing_files.append(file_path)
        
        print_result("Frontend files exist", len(missing_files) == 0, f"Missing: {missing_files}" if missing_files else None)
        
        # Check package.json for required dependencies
        package_json_path = os.path.join(os.path.dirname(__file__), 'package.json')
        if os.path.exists(package_json_path):
            import json
            with open(package_json_path, 'r') as f:
                package_data = json.load(f)
            
            required_deps = ['react', 'zustand', '@mui/material']
            has_deps = all(dep in package_data.get('dependencies', {}) for dep in required_deps)
            print_result("Required dependencies", has_deps)
        else:
            print_result("Package.json exists", False)
        
        return len(missing_files) == 0
        
    except Exception as e:
        print_result("Frontend structure validation", False, str(e))
        return False

def validate_backend_structure():
    """Validate backend file structure"""
    print_section("VALIDATING BACKEND STRUCTURE")
    
    try:
        # Check backend files exist
        backend_files = [
            'backend/main.py',
            'backend/services/error_handler.py',
            'backend/services/resource_manager.py',
            'backend/services/security_service.py',
            'backend/services/data_protection_service.py',
            'backend/tests/test_error_handler.py',
            'backend/tests/test_resource_manager.py',
            'backend/tests/test_integration.py'
        ]
        
        missing_files = []
        for file_path in backend_files:
            full_path = os.path.join(os.path.dirname(__file__), file_path)
            if not os.path.exists(full_path):
                missing_files.append(file_path)
        
        print_result("Backend files exist", len(missing_files) == 0, f"Missing: {missing_files}" if missing_files else None)
        
        return len(missing_files) == 0
        
    except Exception as e:
        print_result("Backend structure validation", False, str(e))
        return False

async def run_comprehensive_validation():
    """Run all validation tests"""
    print_section("STARTING COMPREHENSIVE VALIDATION")
    print(f"Timestamp: {datetime.now().isoformat()}")
    print(f"Python version: {sys.version}")
    
    results = []
    
    # Backend structure validation
    results.append(validate_backend_structure())
    
    # Frontend structure validation  
    results.append(validate_frontend_structure())
    
    # Service validations
    results.append(await validate_error_handler())
    results.append(await validate_resource_manager())
    results.append(await validate_security_service())
    results.append(await validate_data_protection())
    
    # Summary
    print_section("VALIDATION SUMMARY")
    passed = sum(results)
    total = len(results)
    success_rate = (passed / total) * 100
    
    print(f"Tests passed: {passed}/{total} ({success_rate:.1f}%)")
    
    if passed == total:
        print("🎉 ALL VALIDATIONS PASSED!")
        print("The handwritten text transcription application has been successfully enhanced with:")
        print("  ✓ Comprehensive error handling and resource management")
        print("  ✓ Security enhancements and data protection")
        print("  ✓ Enhanced frontend with notifications and progress tracking")
        print("  ✓ Comprehensive unit and integration tests")
        print("  ✓ Memory leak prevention and adaptive processing")
    else:
        print("⚠️  Some validations failed. Please review the errors above.")
    
    return passed == total

if __name__ == "__main__":
    try:
        result = asyncio.run(run_comprehensive_validation())
        sys.exit(0 if result else 1)
    except KeyboardInterrupt:
        print("\n\nValidation interrupted by user")
        sys.exit(1)
    except Exception as e:
        print(f"\n\nUnexpected error during validation: {e}")
        traceback.print_exc()
        sys.exit(1)