validate.py

#!/usr/bin/env python3
"""
Voodoo Box Validation Script

This script validates that all voodoo-box modules can be imported and used
independently without the source projects (extendo and NadeStacked).

Run this script to ensure the voodoo-box is properly structured and functional.
"""

import sys
import traceback
import importlib
from typing import Dict, Any
from pathlib import Path


class VoodooBoxValidator:
    """Validates voodoo-box module integrity and functionality."""
    
    def __init__(self):
        self.results: Dict[str, Dict[str, Any]] = {}
        self.voodoo_box_path = Path(__file__).parent
        
    def validate_all(self) -> Dict[str, Dict[str, Any]]:
        """Run all validation checks."""
        print("[VB] Voodoo Box Validation Starting...")
        print("=" * 50)
        
        # Core structure validation
        self.validate_structure()
        
        # Module import validation
        self.validate_imports()
        
        # Basic functionality validation
        self.validate_functionality()
        
        # Integration validation
        self.validate_integration()
        
        return self.results
    
    def validate_structure(self):
        """Validate directory structure and required files."""
        print("\nValidating structure...")
        
        required_dirs = [
            "api", "data", "files", "web", "gaming", "utils", "testing"
        ]
        
        required_files = [
            "__init__.py", "README.md", "REQUIREMENTS.md"
        ]
        
        structure_results = {
            "directories": {},
            "files": {},
            "status": "success"
        }
        
        # Check directories
        for dir_name in required_dirs:
            dir_path = self.voodoo_box_path / dir_name
            if dir_path.exists() and dir_path.is_dir():
                structure_results["directories"][dir_name] = "[+] Found"
                
                # Check for __init__.py or README.md in each directory
                has_init = (dir_path / "__init__.py").exists()
                has_readme = (dir_path / "README.md").exists()
                
                if has_init or has_readme:
                    structure_results["directories"][dir_name] += " (documented)"
                else:
                    structure_results["directories"][dir_name] += " (minimal docs)"
            else:
                structure_results["directories"][dir_name] = "[-] Missing"
                structure_results["status"] = "warning"
        
        # Check files
        for file_name in required_files:
            file_path = self.voodoo_box_path / file_name
            if file_path.exists():
                structure_results["files"][file_name] = "[+] Found"
            else:
                structure_results["files"][file_name] = "[-] Missing"
                structure_results["status"] = "warning"
        
        self.results["structure"] = structure_results
        self._print_results("Structure", structure_results)
    
    def validate_imports(self):
        """Validate that modules can be imported without errors."""
        print("\nValidating imports...")
        
        import_tests = [
            # Utils module
            ("utils.logging", "LoggerSetup"),
            ("utils.caching", "TimedLRUCache"),
            ("utils.error_handling", "ErrorHandler"),
            
            # API module  
            ("api.base_client", "BaseAPIClient"),
            ("api.faceit_client", "FaceitClient"),
            
            # Data module
            ("data.stats_aggregators", "StatsAggregator"),
            ("data.transformers", "DataCleaner"),
            
            # Files module
            ("files.file_manager", "FileManager"),
            
            # Gaming module
            ("gaming.demo_analyzer", "DemoPositionAnalyzer"),
        ]
        
        import_results = {
            "modules": {},
            "status": "success"
        }
        
        for module_path, class_name in import_tests:
            try:
                # Try to import directly from the module
                module = importlib.import_module(module_path)
                
                # Check if the expected class exists
                if hasattr(module, class_name):
                    import_results["modules"][module_path] = f"[+] {class_name} available"
                else:
                    import_results["modules"][module_path] = f"[!] Module imported but {class_name} not found"
                    import_results["status"] = "warning"
                    
            except ImportError as e:
                import_results["modules"][module_path] = f"[-] Import failed: {str(e)}"
                import_results["status"] = "error"
            except Exception as e:
                import_results["modules"][module_path] = f"[-] Error: {str(e)}"
                import_results["status"] = "error"
        
        self.results["imports"] = import_results
        self._print_results("Imports", import_results)
    
    def validate_functionality(self):
        """Test basic functionality of key components."""
        print("\nValidating functionality...")
        
        functionality_results = {
            "tests": {},
            "status": "success"
        }
        
        # Test logging setup
        try:
            from utils.logging import LoggerSetup
            logger = LoggerSetup.setup_logger("validation_test", level="INFO", log_to_file=False)
            logger.info("Test log message")
            functionality_results["tests"]["logging"] = "[+] Logger created and used successfully"
        except Exception as e:
            functionality_results["tests"]["logging"] = f"[-] Logging test failed: {str(e)}"
            functionality_results["status"] = "error"
        
        # Test caching
        try:
            from utils.caching import simple_cache
            
            @simple_cache(maxsize=10)
            def test_cache_function(x):
                return x * 2
            
            result1 = test_cache_function(5)
            result2 = test_cache_function(5)  # Should be cached
            
            if result1 == result2 == 10:
                functionality_results["tests"]["caching"] = "[+] Cache function works correctly"
            else:
                functionality_results["tests"]["caching"] = "[-] Cache function returned incorrect results"
                functionality_results["status"] = "error"
                
        except Exception as e:
            functionality_results["tests"]["caching"] = f"[-] Caching test failed: {str(e)}"
            functionality_results["status"] = "error"
        
        # Test error handling
        try:
            from utils.error_handling import ErrorHandler
            
            error_handler = ErrorHandler()
            
            try:
                raise ValueError("Test error")
            except ValueError as e:
                error_handler.handle_error(e, reraise=False)
            
            stats = error_handler.get_error_stats()
            if "ValueError" in stats and stats["ValueError"] == 1:
                functionality_results["tests"]["error_handling"] = "[+] Error handler tracks errors correctly"
            else:
                functionality_results["tests"]["error_handling"] = "[-] Error handler stats incorrect"
                functionality_results["status"] = "error"
                
        except Exception as e:
            functionality_results["tests"]["error_handling"] = f"[-] Error handling test failed: {str(e)}"
            functionality_results["status"] = "error"
        
        # Test file operations
        try:
            import tempfile
            from files.file_manager import FileManager, JSONHandler
            
            with tempfile.TemporaryDirectory() as temp_dir:
                test_data = {"test": "data"}
                test_file = Path(temp_dir) / "test.json"
                
                # Save and load JSON using static methods
                JSONHandler.save_json(test_data, test_file)
                loaded_data = JSONHandler.load_json(test_file)
                
                if loaded_data == test_data:
                    functionality_results["tests"]["file_operations"] = "[+] JSON save/load works correctly"
                else:
                    functionality_results["tests"]["file_operations"] = "[-] JSON data mismatch"
                    functionality_results["status"] = "error"
                    
        except Exception as e:
            functionality_results["tests"]["file_operations"] = f"[-] File operations test failed: {str(e)}"
            functionality_results["status"] = "error"
        
        self.results["functionality"] = functionality_results
        self._print_results("Functionality", functionality_results)
    
    def validate_integration(self):
        """Test integration between modules."""
        print("\nValidating integration...")
        
        integration_results = {
            "tests": {},
            "status": "success"
        }
        
        # Test quick_setup function
        try:
            # Try to use the functions directly from their modules
            from utils.logging import setup_project_logging
            from utils.error_handling import ErrorHandler, retry_with_backoff
            from utils.caching import TimedLRUCache
            
            # Manually recreate quick_setup functionality
            project_name = "validation_test"
            loggers = setup_project_logging(project_name, debug=False)
            error_handler = ErrorHandler(loggers['main'])
            
            utils = {
                'loggers': loggers,
                'logger': loggers['main'],
                'error_handler': error_handler,
                'cache': TimedLRUCache,
                'retry': retry_with_backoff,
            }
            
            required_keys = ["loggers", "logger", "error_handler", "cache", "retry"]
            missing_keys = [key for key in required_keys if key not in utils]
            
            if not missing_keys:
                integration_results["tests"]["quick_setup"] = "[+] Quick setup components available and working"
            else:
                integration_results["tests"]["quick_setup"] = f"[-] Missing keys: {missing_keys}"
                integration_results["status"] = "error"
                
        except Exception as e:
            integration_results["tests"]["quick_setup"] = f"[-] Quick setup failed: {str(e)}"
            integration_results["status"] = "error"
        
        # Test module status function
        try:
            # Test the module discovery functionality directly
            modules = {
                'api': 'Faceit API client and generic HTTP utilities',
                'data': 'Data processing, aggregation, and transformation utilities', 
                'files': 'File management, JSON handling, and output organization',
                'web': 'Browser extension utilities and DOM manipulation',
                'gaming': 'CS2 demo analysis and gaming-specific utilities',
                'utils': 'Cross-cutting utilities (logging, caching, error handling)'
            }
            
            available_modules = {}
            for module_name, description in modules.items():
                try:
                    importlib.import_module(module_name)
                    available_modules[module_name] = {
                        'description': description,
                        'status': 'available'
                    }
                except ImportError as e:
                    available_modules[module_name] = {
                        'description': description,
                        'status': f'unavailable ({str(e)})'
                    }
            
            if isinstance(available_modules, dict) and len(available_modules) > 0:
                available_count = sum(1 for mod in available_modules.values() if mod['status'] == 'available')
                integration_results["tests"]["module_info"] = f"[+] Module discovery works correctly ({available_count}/{len(available_modules)} modules available)"
            else:
                integration_results["tests"]["module_info"] = "[-] Module info returned invalid data"
                integration_results["status"] = "error"
                
        except Exception as e:
            integration_results["tests"]["module_info"] = f"[-] Module info test failed: {str(e)}"
            integration_results["status"] = "error"
        
        self.results["integration"] = integration_results
        self._print_results("Integration", integration_results)
    
    def _print_results(self, category: str, results: Dict[str, Any]):
        """Print results for a validation category."""
        status = results.get("status", "unknown")
        status_icon = {"success": "[+]", "warning": "[!]", "error": "[-]"}.get(status, "[?]")
        
        print(f"{status_icon} {category}: {status}")
        
        # Print details
        for section_name, section_data in results.items():
            if section_name == "status":
                continue
                
            if isinstance(section_data, dict):
                for key, value in section_data.items():
                    print(f"  {key}: {value}")
            else:
                print(f"  {section_name}: {section_data}")
    
    def generate_report(self) -> str:
        """Generate a summary report of validation results."""
        report_lines = [
            "[VB] Voodoo Box Validation Report",
            "=" * 40,
            ""
        ]
        
        overall_status = "success"
        total_tests = 0
        passed_tests = 0
        
        for category, results in self.results.items():
            status = results.get("status", "unknown")
            if status == "error":
                overall_status = "error"
            elif status == "warning" and overall_status != "error":
                overall_status = "warning"
            
            # Count tests
            for section_name, section_data in results.items():
                if isinstance(section_data, dict) and section_name != "status":
                    for key, value in section_data.items():
                        total_tests += 1
                        if "[+]" in str(value):
                            passed_tests += 1
        
        report_lines.extend([
            f"Overall Status: {overall_status.upper()}",
            f"Tests Passed: {passed_tests}/{total_tests}",
            f"Success Rate: {(passed_tests/total_tests*100):.1f}%" if total_tests > 0 else "No tests run",
            ""
        ])
        
        # Detailed results
        for category, results in self.results.items():
            status_icon = {"success": "[+]", "warning": "[!]", "error": "[-]"}.get(results.get("status"), "[?]")
            report_lines.append(f"{status_icon} {category.title()}: {results.get('status', 'unknown')}")
        
        return "\n".join(report_lines)


def main():
    """Run validation and print results."""
    try:
        # Add voodoo-box to Python path for imports
        voodoo_box_path = Path(__file__).parent
        sys.path.insert(0, str(voodoo_box_path.parent))
        
        validator = VoodooBoxValidator()
        results = validator.validate_all()
        
        print("\n" + "=" * 50)
        print(validator.generate_report())
        
        # Return appropriate exit code
        overall_status = "success"
        for category_results in results.values():
            if category_results.get("status") == "error":
                overall_status = "error"
                break
            elif category_results.get("status") == "warning":
                overall_status = "warning"
        
        if overall_status == "error":
            print("\n[-] Validation completed with errors!")
            sys.exit(1)
        elif overall_status == "warning":
            print("\n[!] Validation completed with warnings!")
            sys.exit(0)
        else:
            print("\n[+] Validation completed successfully!")
            sys.exit(0)
            
    except Exception as e:
        print(f"\n[!] Validation script failed: {e}")
        traceback.print_exc()
        sys.exit(1)


if __name__ == "__main__":
    main()