moai-adk 0.8.0__py3-none-any.whl → 0.34.0__py3-none-any.whl

moai_adk/core/integration/__init__.py

@@ -0,0 +1,22 @@
+"""
+Integration Testing Framework
+
+Provides comprehensive integration testing capabilities for MoAI-ADK components.
+"""
+
+from .engine import TestEngine
+from .integration_tester import IntegrationTester
+from .models import IntegrationTestResult, TestComponent, TestStatus, TestSuite
+from .utils import ComponentDiscovery, TestEnvironment, TestResultAnalyzer
+
+__all__ = [
+    "IntegrationTester",
+    "IntegrationTestResult",
+    "TestComponent",
+    "TestSuite",
+    "TestStatus",
+    "TestEngine",
+    "ComponentDiscovery",
+    "TestResultAnalyzer",
+    "TestEnvironment",
+]

moai_adk/core/integration/engine.py

@@ -0,0 +1,157 @@
+"""
+Integration testing execution engine.
+
+This module contains the core test execution logic for running
+integration tests with timeout handling and concurrent execution.
+"""
+
+import asyncio
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import Callable, List, Optional
+
+from .models import IntegrationTestResult, TestStatus
+
+
+class TestEngine:
+    """
+    Core test execution engine for integration testing.
+
+    Handles test execution, timeout management, and concurrent execution.
+    """
+
+    def __init__(self, test_timeout: float = 30.0, max_workers: int = 4):
+        """
+        Initialize the test engine.
+
+        Args:
+            test_timeout: Maximum time (in seconds) for each test
+            max_workers: Maximum number of concurrent workers
+        """
+        if test_timeout <= 0:
+            raise ValueError("Test timeout must be positive")
+        if max_workers <= 0:
+            raise ValueError("Max workers must be positive")
+
+        self.test_timeout = test_timeout
+        self.max_workers = max_workers
+        self._test_counter = 0
+
+    def _generate_test_id(self) -> str:
+        """Generate a unique test ID."""
+        self._test_counter += 1
+        return f"test_{self._test_counter:04d}"
+
+    def execute_test(
+        self, test_func: Callable, test_name: str = None, components: List[str] = None
+    ) -> IntegrationTestResult:
+        """
+        Execute a single integration test.
+
+        Args:
+            test_func: Test function to execute
+            test_name: Optional test name
+            components: List of components being tested
+
+        Returns:
+            IntegrationTestResult: Test execution result
+        """
+        if test_name is None:
+            test_name = self._generate_test_id()
+
+        if components is None:
+            components = []
+
+        start_time = time.time()
+        result = IntegrationTestResult(test_name=test_name, passed=False, components_tested=components)
+
+        try:
+            # Execute test with timeout
+            with ThreadPoolExecutor(max_workers=1) as executor:
+                future = executor.submit(test_func)
+                try:
+                    test_result = future.result(timeout=self.test_timeout)
+                    result.passed = bool(test_result)
+                    result.status = TestStatus.PASSED if result.passed else TestStatus.FAILED
+
+                except TimeoutError:
+                    result.error_message = f"Test timed out after {self.test_timeout}s"
+                    result.status = TestStatus.FAILED
+
+        except Exception as e:
+            result.error_message = str(e)
+            result.status = TestStatus.FAILED
+
+        finally:
+            result.execution_time = time.time() - start_time
+
+        return result
+
+    async def execute_test_async(
+        self, test_func: Callable, test_name: str = None, components: List[str] = None
+    ) -> IntegrationTestResult:
+        """
+        Execute a single integration test asynchronously.
+
+        Args:
+            test_func: Test function to execute
+            test_name: Optional test name
+            components: List of components being tested
+
+        Returns:
+            IntegrationTestResult: Test execution result
+        """
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(None, self.execute_test, test_func, test_name, components)
+
+    def run_concurrent_tests(self, tests: List[tuple], timeout: Optional[float] = None) -> List[IntegrationTestResult]:
+        """
+        Run multiple tests concurrently.
+
+        Args:
+            tests: List of (test_func, test_name, components) tuples
+            timeout: Optional timeout for entire batch
+
+        Returns:
+            List of test results
+        """
+        if timeout is None:
+            timeout = self.test_timeout * 2
+
+        results = []
+
+        with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
+            # Submit all tests
+            future_to_test = {executor.submit(self.execute_test, *test): test for test in tests}
+
+            # Collect results as they complete
+            for future in as_completed(future_to_test, timeout=timeout):
+                try:
+                    result = future.result()
+                    results.append(result)
+                except Exception as e:
+                    test_info = future_to_test[future]
+                    error_result = IntegrationTestResult(
+                        test_name=test_info[1] if len(test_info) > 1 else "unknown",
+                        passed=False,
+                        error_message=f"Execution error: {str(e)}",
+                    )
+                    results.append(error_result)
+
+        return results
+
+    async def run_concurrent_tests_async(
+        self, tests: List[tuple], timeout: Optional[float] = None
+    ) -> List[IntegrationTestResult]:
+        """
+        Run multiple tests concurrently asynchronously.
+
+        Args:
+            tests: List of (test_func, test_name, components) tuples
+            timeout: Optional timeout for entire batch
+
+        Returns:
+            List of test results
+        """
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(None, self.run_concurrent_tests, tests, timeout)

moai_adk/core/integration/integration_tester.py

@@ -0,0 +1,226 @@
+"""
+Integration Tester - Main Interface
+
+Provides a high-level interface for comprehensive integration testing
+of MoAI-ADK components. This module serves as the main entry point
+for integration testing functionality.
+"""
+
+from typing import Any, Callable, Dict, List, Optional, Union
+
+from .engine import TestEngine
+from .models import IntegrationTestResult, TestComponent, TestSuite
+from .utils import ComponentDiscovery, TestEnvironment, TestResultAnalyzer
+
+
+class IntegrationTester:
+    """
+    Comprehensive integration tester for MoAI-ADK components.
+
+    This class provides a high-level interface for testing multiple components
+    together to ensure they work correctly in integration scenarios.
+    """
+
+    def __init__(self, test_timeout: float = 30.0, max_workers: int = 4):
+        """
+        Initialize the integration tester.
+
+        Args:
+            test_timeout: Maximum time (in seconds) for each test
+            max_workers: Maximum number of concurrent workers
+        """
+        self.engine = TestEngine(test_timeout, max_workers)
+        self.test_results: List[IntegrationTestResult] = []
+        self.discovery = ComponentDiscovery()
+        self.analyzer = TestResultAnalyzer()
+
+    def add_test_result(self, result: IntegrationTestResult):
+        """
+        Add a test result to the results list.
+
+        Args:
+            result: Test result to add
+        """
+        self.test_results.append(result)
+
+    def clear_results(self):
+        """Clear all test results."""
+        self.test_results.clear()
+
+    def get_success_rate(self) -> float:
+        """
+        Get the success rate of all tests.
+
+        Returns:
+            Success rate as percentage (0-100)
+        """
+        return self.analyzer.calculate_success_rate(self.test_results)
+
+    def get_test_stats(self) -> Dict[str, Any]:
+        """
+        Get comprehensive test statistics.
+
+        Returns:
+            Dictionary with test statistics
+        """
+        return self.analyzer.get_execution_stats(self.test_results)
+
+    def run_test(
+        self, test_func: Callable, test_name: str = None, components: List[str] = None
+    ) -> IntegrationTestResult:
+        """
+        Run a single integration test.
+
+        Args:
+            test_func: Test function to execute
+            test_name: Optional test name
+            components: List of components being tested
+
+        Returns:
+            IntegrationTestResult: Test execution result
+        """
+        result = self.engine.execute_test(test_func, test_name, components)
+        self.add_test_result(result)
+        return result
+
+    async def run_test_async(
+        self, test_func: Callable, test_name: str = None, components: List[str] = None
+    ) -> IntegrationTestResult:
+        """
+        Run a single integration test asynchronously.
+
+        Args:
+            test_func: Test function to execute
+            test_name: Optional test name
+            components: List of components being tested
+
+        Returns:
+            IntegrationTestResult: Test execution result
+        """
+        result = await self.engine.execute_test_async(test_func, test_name, components)
+        self.add_test_result(result)
+        return result
+
+    def run_test_suite(self, test_suite: TestSuite) -> List[IntegrationTestResult]:
+        """
+        Run a complete test suite.
+
+        Args:
+            test_suite: Test suite to run
+
+        Returns:
+            List of test results
+        """
+        results = []
+
+        def placeholder_test():
+            """Placeholder test function"""
+            return True
+
+        for test_case_name in test_suite.test_cases:
+            # This is a simplified implementation
+            # In practice, you would map test case names to actual test functions
+            result = self.run_test(
+                placeholder_test,
+                test_case_name,
+                [c.name for c in test_suite.components],
+            )
+            results.append(result)
+
+        return results
+
+    def run_concurrent_tests(self, tests: List[tuple], timeout: Optional[float] = None) -> List[IntegrationTestResult]:
+        """
+        Run multiple tests concurrently.
+
+        Args:
+            tests: List of (test_func, test_name, components) tuples
+            timeout: Optional timeout for entire batch
+
+        Returns:
+            List of test results
+        """
+        results = self.engine.run_concurrent_tests(tests, timeout)
+        self.test_results.extend(results)
+        return results
+
+    async def run_concurrent_tests_async(
+        self, tests: List[tuple], timeout: Optional[float] = None
+    ) -> List[IntegrationTestResult]:
+        """
+        Run multiple tests concurrently asynchronously.
+
+        Args:
+            tests: List of (test_func, test_name, components) tuples
+            timeout: Optional timeout for entire batch
+
+        Returns:
+            List of test results
+        """
+        results = await self.engine.run_concurrent_tests_async(tests, timeout)
+        self.test_results.extend(results)
+        return results
+
+    def discover_components(self, base_path: str) -> List[TestComponent]:
+        """
+        Discover testable components in the given path.
+
+        Args:
+            base_path: Base path to search for components
+
+        Returns:
+            List of discovered components
+        """
+        return self.discovery.discover_components(base_path)
+
+    def create_test_environment(self, temp_dir: Optional[str] = None) -> TestEnvironment:
+        """
+        Create a test environment for integration testing.
+
+        Args:
+            temp_dir: Optional temporary directory path
+
+        Returns:
+            TestEnvironment instance
+        """
+        return TestEnvironment(temp_dir)
+
+    def export_results(self, format: str = "dict") -> Union[Dict, str]:
+        """
+        Export test results in specified format.
+
+        Args:
+            format: Export format ("dict", "json", "summary")
+
+        Returns:
+            Exported results
+        """
+        if format == "dict":
+            return [vars(result) for result in self.test_results]  # type: ignore[return-value]
+        elif format == "summary":
+            return {
+                "stats": self.get_test_stats(),
+                "failed_tests": self.analyzer.get_failed_tests(self.test_results),
+            }
+        else:
+            raise ValueError(f"Unsupported format: {format}")
+
+    def validate_test_environment(self) -> List[str]:
+        """
+        Validate the test environment.
+
+        Returns:
+            List of validation warnings
+        """
+        warnings = []
+
+        # Check if we have any test results
+        if not self.test_results:
+            warnings.append("No test results found")
+
+        # Check success rate
+        success_rate = self.get_success_rate()
+        if success_rate < 80.0:
+            warnings.append(f"Low success rate: {success_rate:.1f}%")
+
+        return warnings

moai_adk/core/integration/models.py

@@ -0,0 +1,88 @@
+"""
+Integration testing data structures and utilities.
+
+This module contains common data structures and utility functions
+for integration testing across the MoAI-ADK system.
+"""
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import List, Optional
+
+
+class TestStatus(Enum):
+    """Test status enumeration"""
+
+    PENDING = "pending"
+    RUNNING = "running"
+    PASSED = "passed"
+    FAILED = "failed"
+    SKIPPED = "skipped"
+
+
+@dataclass
+class IntegrationTestResult:
+    """Test result data structure"""
+
+    test_name: str
+    passed: bool
+    error_message: Optional[str] = None
+    execution_time: float = 0.0
+    components_tested: Optional[List[str]] = None
+    status: Optional[TestStatus] = None
+
+    def __post_init__(self):
+        if self.components_tested is None:
+            self.components_tested = []
+        if self.passed:
+            self.status = TestStatus.PASSED
+        elif self.error_message:
+            self.status = TestStatus.FAILED
+        else:
+            self.status = TestStatus.PENDING
+
+
+@dataclass
+class TestComponent:
+    """Test component definition"""
+
+    name: str
+    component_type: str
+    version: str
+    dependencies: Optional[List[str]] = None
+
+    def __post_init__(self):
+        if self.dependencies is None:
+            self.dependencies = []
+
+
+@dataclass
+class TestSuite:
+    """Test suite definition"""
+
+    name: str
+    description: str
+    components: List[TestComponent]
+    test_cases: Optional[List[str]] = None
+
+    def __post_init__(self):
+        if self.test_cases is None:
+            self.test_cases = []
+
+
+class IntegrationTestError(Exception):
+    """Base exception for integration testing"""
+
+    pass
+
+
+class TestTimeoutError(IntegrationTestError):
+    """Test timeout exception"""
+
+    pass
+
+
+class ComponentNotFoundError(IntegrationTestError):
+    """Component not found exception"""
+
+    pass

moai_adk/core/integration/utils.py

@@ -0,0 +1,211 @@
+"""
+Integration testing utilities and helper functions.
+
+This module contains utility functions for component discovery,
+dependency resolution, and test result analysis.
+"""
+
+import shutil
+import tempfile
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from .models import IntegrationTestResult, TestComponent
+
+
+class ComponentDiscovery:
+    """
+    Component discovery utilities for integration testing.
+    """
+
+    @staticmethod
+    def discover_components(base_path: str) -> List[TestComponent]:
+        """
+        Discover testable components in the given path.
+
+        Args:
+            base_path: Base path to search for components
+
+        Returns:
+            List of discovered components
+        """
+        components: List[TestComponent] = []
+        base_dir = Path(base_path)
+
+        if not base_dir.exists():
+            return components
+
+        # Look for Python modules
+        for py_file in base_dir.rglob("*.py"):
+            if py_file.name.startswith("__"):
+                continue
+
+            relative_path = py_file.relative_to(base_dir)
+            module_name = str(relative_path.with_suffix("")).replace("/", ".")
+
+            component = TestComponent(
+                name=module_name,
+                component_type="python_module",
+                version="1.0.0",  # Default version
+            )
+            components.append(component)
+
+        return components
+
+    @staticmethod
+    def resolve_dependencies(components: List[TestComponent]) -> Dict[str, List[str]]:
+        """
+        Resolve dependencies between components.
+
+        Args:
+            components: List of components to analyze
+
+        Returns:
+            Dictionary mapping component names to their dependencies
+        """
+        dependency_map = {}
+
+        for component in components:
+            try:
+                # Try to import and analyze dependencies
+                dependencies = ComponentDiscovery._analyze_imports(component)
+                dependency_map[component.name] = dependencies
+            except Exception:
+                dependency_map[component.name] = component.dependencies
+
+        return dependency_map
+
+    @staticmethod
+    def _analyze_imports(component: TestComponent) -> List[str]:
+        """
+        Analyze imports for a component to determine dependencies.
+
+        Args:
+            component: Component to analyze
+
+        Returns:
+            List of dependency names
+        """
+        # This is a simplified implementation
+        # In a real scenario, you would parse the source code
+        return component.dependencies
+
+
+class TestResultAnalyzer:
+    """
+    Test result analysis utilities.
+    """
+
+    @staticmethod
+    def calculate_success_rate(results: List[IntegrationTestResult]) -> float:
+        """
+        Calculate the success rate of test results.
+
+        Args:
+            results: List of test results
+
+        Returns:
+            Success rate as percentage (0-100)
+        """
+        if not results:
+            return 0.0
+
+        passed = sum(1 for result in results if result.passed)
+        return (passed / len(results)) * 100
+
+    @staticmethod
+    def get_failed_tests(
+        results: List[IntegrationTestResult],
+    ) -> List[IntegrationTestResult]:
+        """
+        Get list of failed tests.
+
+        Args:
+            results: List of test results
+
+        Returns:
+            List of failed test results
+        """
+        return [result for result in results if not result.passed]
+
+    @staticmethod
+    def get_execution_stats(results: List[IntegrationTestResult]) -> Dict[str, Any]:
+        """
+        Get execution statistics for test results.
+
+        Args:
+            results: List of test results
+
+        Returns:
+            Dictionary with execution statistics
+        """
+        if not results:
+            return {
+                "total": 0,
+                "passed": 0,
+                "failed": 0,
+                "success_rate": 0.0,
+                "total_time": 0.0,
+                "avg_time": 0.0,
+            }
+
+        passed = sum(1 for result in results if result.passed)
+        failed = len(results) - passed
+        total_time = sum(result.execution_time for result in results)
+
+        return {
+            "total": len(results),
+            "passed": passed,
+            "failed": failed,
+            "success_rate": TestResultAnalyzer.calculate_success_rate(results),
+            "total_time": total_time,
+            "avg_time": total_time / len(results),
+        }
+
+
+class TestEnvironment:
+    """
+    Test environment management utilities.
+    """
+
+    def __init__(self, temp_dir: Optional[str] = None):
+        """
+        Initialize test environment.
+
+        Args:
+            temp_dir: Optional temporary directory path
+        """
+        self.temp_dir = temp_dir
+        self.created_temp = False
+
+        if self.temp_dir is None:
+            self.temp_dir = tempfile.mkdtemp(prefix="moai_integration_test_")
+            self.created_temp = True
+
+    def cleanup(self):
+        """Clean up test environment."""
+        if self.created_temp and self.temp_dir:
+            try:
+                shutil.rmtree(self.temp_dir)
+            except Exception:
+                pass  # Ignore cleanup errors
+
+    def get_temp_path(self, name: str) -> str:
+        """
+        Get a temporary file path.
+
+        Args:
+            name: File name
+
+        Returns:
+            Full path to temporary file
+        """
+        return str(Path(self.temp_dir) / name)
+
+    def __enter__(self):
+        """Context manager entry."""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit."""
+        self.cleanup()