moai-adk 0.15.1__py3-none-any.whl → 0.25.4__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,169 @@
+"""
+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,225 @@
+"""
+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 = []
+
+        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
+            test_func = lambda: True  # Placeholder
+            result = self.run_test(
+                test_func, 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]
+        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