provide-foundation 0.0.0.dev1__py3-none-any.whl → 0.0.0.dev2__py3-none-any.whl

provide/foundation/testing/process/subprocess_fixtures.py

@@ -0,0 +1,209 @@
+"""
+Subprocess-specific test fixtures for process testing.
+
+Provides fixtures for mocking and testing subprocess operations,
+stream handling, and process communication.
+"""
+
+import asyncio
+from unittest.mock import AsyncMock, Mock
+
+import pytest
+
+
+@pytest.fixture
+def mock_async_process() -> AsyncMock:
+    """
+    Mock async subprocess for testing.
+    
+    Returns:
+        AsyncMock configured as a subprocess with common attributes.
+    """
+    mock_process = AsyncMock()
+    mock_process.communicate = AsyncMock(return_value=(b"output", b""))
+    mock_process.returncode = 0
+    mock_process.pid = 12345
+    mock_process.stdin = AsyncMock()
+    mock_process.stdout = AsyncMock()
+    mock_process.stderr = AsyncMock()
+    mock_process.wait = AsyncMock(return_value=0)
+    mock_process.kill = Mock()
+    mock_process.terminate = Mock()
+    
+    return mock_process
+
+
+@pytest.fixture
+async def async_stream_reader() -> AsyncMock:
+    """
+    Mock async stream reader for subprocess stdout/stderr.
+    
+    Returns:
+        AsyncMock configured as a stream reader.
+    """
+    reader = AsyncMock()
+    
+    # Simulate reading lines
+    async def readline_side_effect():
+        for line in [b"line1\n", b"line2\n", b""]:
+            yield line
+    
+    reader.readline = AsyncMock(side_effect=readline_side_effect().__anext__)
+    reader.read = AsyncMock(return_value=b"full content")
+    reader.at_eof = Mock(side_effect=[False, False, True])
+    
+    return reader
+
+
+@pytest.fixture
+def async_subprocess():
+    """
+    Create mock async subprocess for testing.
+    
+    Returns:
+        Function that creates mock subprocess with configurable behavior.
+    """
+    def _create_subprocess(
+        returncode: int = 0,
+        stdout: bytes = b"",
+        stderr: bytes = b"",
+        pid: int = 12345
+    ) -> AsyncMock:
+        """
+        Create a mock async subprocess.
+        
+        Args:
+            returncode: Process return code
+            stdout: Process stdout output
+            stderr: Process stderr output
+            pid: Process ID
+            
+        Returns:
+            AsyncMock configured as subprocess
+        """
+        process = AsyncMock()
+        process.returncode = returncode
+        process.pid = pid
+        process.communicate = AsyncMock(return_value=(stdout, stderr))
+        process.wait = AsyncMock(return_value=returncode)
+        process.kill = Mock()
+        process.terminate = Mock()
+        process.send_signal = Mock()
+        
+        # Add stdout/stderr as async stream readers
+        process.stdout = AsyncMock()
+        process.stdout.read = AsyncMock(return_value=stdout)
+        process.stdout.readline = AsyncMock(side_effect=[stdout, b""])
+        process.stdout.at_eof = Mock(side_effect=[False, True])
+        
+        process.stderr = AsyncMock()
+        process.stderr.read = AsyncMock(return_value=stderr)
+        process.stderr.readline = AsyncMock(side_effect=[stderr, b""])
+        process.stderr.at_eof = Mock(side_effect=[False, True])
+        
+        process.stdin = AsyncMock()
+        process.stdin.write = AsyncMock()
+        process.stdin.drain = AsyncMock()
+        process.stdin.close = Mock()
+        
+        return process
+    
+    return _create_subprocess
+
+
+@pytest.fixture
+def async_mock_server():
+    """
+    Create a mock async server for testing.
+    
+    Returns:
+        Mock server with async methods.
+    """
+    class AsyncMockServer:
+        def __init__(self):
+            self.started = False
+            self.connections = []
+            self.requests = []
+        
+        async def start(self, host: str = "localhost", port: int = 8080):
+            """Start the mock server."""
+            self.started = True
+            self.host = host
+            self.port = port
+        
+        async def stop(self):
+            """Stop the mock server."""
+            self.started = False
+            for conn in self.connections:
+                await conn.close()
+        
+        async def handle_connection(self, reader, writer):
+            """Mock connection handler."""
+            conn = {"reader": reader, "writer": writer}
+            self.connections.append(conn)
+            
+            # Mock reading request
+            data = await reader.read(1024)
+            self.requests.append(data)
+            
+            # Mock sending response
+            writer.write(b"HTTP/1.1 200 OK\r\n\r\nOK")
+            await writer.drain()
+            
+            writer.close()
+            await writer.wait_closed()
+        
+        def get_url(self) -> str:
+            """Get server URL."""
+            return f"http://{self.host}:{self.port}"
+    
+    return AsyncMockServer()
+
+
+@pytest.fixture
+def async_test_client():
+    """
+    Create an async HTTP test client.
+    
+    Returns:
+        Mock async HTTP client for testing.
+    """
+    class AsyncTestClient:
+        def __init__(self):
+            self.responses = {}
+            self.requests = []
+        
+        def set_response(self, url: str, response: dict):
+            """Set a mock response for a URL."""
+            self.responses[url] = response
+        
+        async def get(self, url: str, **kwargs) -> dict:
+            """Mock GET request."""
+            self.requests.append({"method": "GET", "url": url, "kwargs": kwargs})
+            return self.responses.get(url, {"status": 404, "body": "Not Found"})
+        
+        async def post(self, url: str, data=None, **kwargs) -> dict:
+            """Mock POST request."""
+            self.requests.append({"method": "POST", "url": url, "data": data, "kwargs": kwargs})
+            return self.responses.get(url, {"status": 200, "body": "OK"})
+        
+        async def close(self):
+            """Close the client."""
+            pass
+        
+        async def __aenter__(self):
+            return self
+        
+        async def __aexit__(self, *args):
+            await self.close()
+    
+    return AsyncTestClient()
+
+
+__all__ = [
+    "mock_async_process",
+    "async_stream_reader",
+    "async_subprocess",
+    "async_mock_server",
+    "async_test_client",
+]

provide/foundation/testing/threading/basic_fixtures.py

@@ -0,0 +1,101 @@
+"""
+Basic threading test fixtures.
+
+Core fixtures for creating threads, thread pools, mocks, and thread-local storage.
+"""
+
+import threading
+from concurrent.futures import ThreadPoolExecutor
+from typing import Any, Callable
+from unittest.mock import Mock
+
+import pytest
+
+
+@pytest.fixture
+def test_thread():
+    """
+    Create a test thread with automatic cleanup.
+    
+    Returns:
+        Function to create and manage test threads.
+    """
+    threads = []
+    
+    def _create_thread(target: Callable, args: tuple = (), kwargs: dict = None, daemon: bool = True) -> threading.Thread:
+        """
+        Create a test thread.
+        
+        Args:
+            target: Function to run in thread
+            args: Positional arguments for target
+            kwargs: Keyword arguments for target
+            daemon: Whether thread should be daemon
+            
+        Returns:
+            Started thread instance
+        """
+        kwargs = kwargs or {}
+        thread = threading.Thread(target=target, args=args, kwargs=kwargs, daemon=daemon)
+        threads.append(thread)
+        thread.start()
+        return thread
+    
+    yield _create_thread
+    
+    # Cleanup: wait for all threads to complete
+    for thread in threads:
+        if thread.is_alive():
+            thread.join(timeout=1.0)
+
+
+@pytest.fixture
+def thread_pool():
+    """
+    Create a thread pool executor for testing.
+    
+    Returns:
+        ThreadPoolExecutor instance with automatic cleanup.
+    """
+    executor = ThreadPoolExecutor(max_workers=4)
+    yield executor
+    executor.shutdown(wait=True, cancel_futures=True)
+
+
+@pytest.fixture
+def mock_thread():
+    """
+    Create a mock thread for testing without actual threading.
+    
+    Returns:
+        Mock thread object.
+    """
+    mock = Mock(spec=threading.Thread)
+    mock.is_alive.return_value = False
+    mock.daemon = False
+    mock.name = "MockThread"
+    mock.ident = 12345
+    mock.start = Mock()
+    mock.join = Mock()
+    mock.run = Mock()
+    
+    return mock
+
+
+@pytest.fixture
+def thread_local_storage():
+    """
+    Create thread-local storage for testing.
+    
+    Returns:
+        Thread-local storage object.
+    """
+    return threading.local()
+
+
+__all__ = [
+    "test_thread",
+    "thread_pool",
+    "mock_thread",
+    "thread_local_storage",
+]

provide/foundation/testing/threading/data_fixtures.py

@@ -0,0 +1,99 @@
+"""
+Thread-safe data structure test fixtures.
+
+Fixtures for thread-safe lists, counters, and other data structures for testing.
+"""
+
+import threading
+from typing import Any
+
+import pytest
+
+
+@pytest.fixture
+def thread_safe_list():
+    """
+    Create a thread-safe list for collecting results.
+    
+    Returns:
+        Thread-safe list implementation.
+    """
+    class ThreadSafeList:
+        def __init__(self):
+            self._list = []
+            self._lock = threading.Lock()
+        
+        def append(self, item: Any):
+            """Thread-safe append."""
+            with self._lock:
+                self._list.append(item)
+        
+        def extend(self, items):
+            """Thread-safe extend."""
+            with self._lock:
+                self._list.extend(items)
+        
+        def get_all(self) -> list:
+            """Get copy of all items."""
+            with self._lock:
+                return self._list.copy()
+        
+        def clear(self):
+            """Clear the list."""
+            with self._lock:
+                self._list.clear()
+        
+        def __len__(self) -> int:
+            with self._lock:
+                return len(self._list)
+        
+        def __getitem__(self, index):
+            with self._lock:
+                return self._list[index]
+    
+    return ThreadSafeList()
+
+
+@pytest.fixture
+def thread_safe_counter():
+    """
+    Create a thread-safe counter.
+    
+    Returns:
+        Thread-safe counter implementation.
+    """
+    class ThreadSafeCounter:
+        def __init__(self, initial: int = 0):
+            self._value = initial
+            self._lock = threading.Lock()
+        
+        def increment(self, amount: int = 1) -> int:
+            """Thread-safe increment."""
+            with self._lock:
+                self._value += amount
+                return self._value
+        
+        def decrement(self, amount: int = 1) -> int:
+            """Thread-safe decrement."""
+            with self._lock:
+                self._value -= amount
+                return self._value
+        
+        @property
+        def value(self) -> int:
+            """Get current value."""
+            with self._lock:
+                return self._value
+        
+        def reset(self, value: int = 0):
+            """Reset counter."""
+            with self._lock:
+                self._value = value
+    
+    return ThreadSafeCounter()
+
+
+__all__ = [
+    "thread_safe_list",
+    "thread_safe_counter",
+]

provide/foundation/testing/threading/execution_fixtures.py

@@ -0,0 +1,263 @@
+"""
+Thread execution and testing helper fixtures.
+
+Advanced fixtures for concurrent execution, synchronization testing, deadlock detection,
+and exception handling in threaded code.
+"""
+
+import threading
+import time
+from typing import Any, Callable, Optional
+from concurrent.futures import ThreadPoolExecutor
+
+import pytest
+
+
+@pytest.fixture
+def concurrent_executor():
+    """
+    Helper for executing functions concurrently in tests.
+    
+    Returns:
+        Concurrent execution helper.
+    """
+    class ConcurrentExecutor:
+        def __init__(self):
+            self.results = []
+            self.exceptions = []
+        
+        def run_concurrent(self, func: Callable, args_list: list[tuple], max_workers: int = 4) -> list[Any]:
+            """
+            Run function concurrently with different arguments.
+            
+            Args:
+                func: Function to execute
+                args_list: List of argument tuples
+                max_workers: Maximum concurrent workers
+                
+            Returns:
+                List of results in order
+            """
+            with ThreadPoolExecutor(max_workers=max_workers) as executor:
+                futures = []
+                for args in args_list:
+                    if isinstance(args, tuple):
+                        future = executor.submit(func, *args)
+                    else:
+                        future = executor.submit(func, args)
+                    futures.append(future)
+                
+                results = []
+                for future in futures:
+                    try:
+                        result = future.result(timeout=10)
+                        results.append(result)
+                        self.results.append(result)
+                    except Exception as e:
+                        self.exceptions.append(e)
+                        results.append(None)
+                
+                return results
+        
+        def run_parallel(self, funcs: list[Callable], timeout: float = 10) -> list[Any]:
+            """
+            Run different functions in parallel.
+            
+            Args:
+                funcs: List of functions to execute
+                timeout: Timeout for each function
+                
+            Returns:
+                List of results
+            """
+            with ThreadPoolExecutor(max_workers=len(funcs)) as executor:
+                futures = [executor.submit(func) for func in funcs]
+                results = []
+                
+                for future in futures:
+                    try:
+                        result = future.result(timeout=timeout)
+                        results.append(result)
+                    except Exception as e:
+                        self.exceptions.append(e)
+                        results.append(None)
+                
+                return results
+    
+    return ConcurrentExecutor()
+
+
+@pytest.fixture
+def thread_synchronizer():
+    """
+    Helper for synchronizing test threads.
+    
+    Returns:
+        Thread synchronization helper.
+    """
+    class ThreadSynchronizer:
+        def __init__(self):
+            self.checkpoints = {}
+        
+        def checkpoint(self, name: str, thread_id: Optional[int] = None):
+            """
+            Record that a thread reached a checkpoint.
+            
+            Args:
+                name: Checkpoint name
+                thread_id: Optional thread ID (uses current if None)
+            """
+            thread_id = thread_id or threading.get_ident()
+            if name not in self.checkpoints:
+                self.checkpoints[name] = []
+            self.checkpoints[name].append((thread_id, time.time()))
+        
+        def wait_for_checkpoint(self, name: str, count: int, timeout: float = 5.0) -> bool:
+            """
+            Wait for N threads to reach a checkpoint.
+            
+            Args:
+                name: Checkpoint name
+                count: Number of threads to wait for
+                timeout: Maximum wait time
+                
+            Returns:
+                True if checkpoint reached, False if timeout
+            """
+            start = time.time()
+            while time.time() - start < timeout:
+                if name in self.checkpoints and len(self.checkpoints[name]) >= count:
+                    return True
+                time.sleep(0.01)
+            return False
+        
+        def get_order(self, checkpoint: str) -> list[int]:
+            """
+            Get order in which threads reached checkpoint.
+            
+            Args:
+                checkpoint: Checkpoint name
+                
+            Returns:
+                List of thread IDs in order
+            """
+            if checkpoint not in self.checkpoints:
+                return []
+            return [tid for tid, _ in sorted(self.checkpoints[checkpoint], key=lambda x: x[1])]
+        
+        def clear(self):
+            """Clear all checkpoints."""
+            self.checkpoints.clear()
+    
+    return ThreadSynchronizer()
+
+
+@pytest.fixture
+def deadlock_detector():
+    """
+    Helper for detecting potential deadlocks in tests.
+    
+    Returns:
+        Deadlock detection helper.
+    """
+    class DeadlockDetector:
+        def __init__(self):
+            self.locks_held = {}  # thread_id -> set of locks
+            self.lock = threading.Lock()
+        
+        def acquire(self, lock_name: str, thread_id: Optional[int] = None):
+            """Record lock acquisition."""
+            thread_id = thread_id or threading.get_ident()
+            with self.lock:
+                if thread_id not in self.locks_held:
+                    self.locks_held[thread_id] = set()
+                self.locks_held[thread_id].add(lock_name)
+        
+        def release(self, lock_name: str, thread_id: Optional[int] = None):
+            """Record lock release."""
+            thread_id = thread_id or threading.get_ident()
+            with self.lock:
+                if thread_id in self.locks_held:
+                    self.locks_held[thread_id].discard(lock_name)
+        
+        def check_circular_wait(self) -> bool:
+            """
+            Check for potential circular wait conditions.
+            
+            Returns:
+                True if potential deadlock detected
+            """
+            # Simplified check - in practice would need wait-for graph
+            with self.lock:
+                # Check if multiple threads hold multiple locks
+                multi_lock_threads = [
+                    tid for tid, locks in self.locks_held.items()
+                    if len(locks) > 1
+                ]
+                return len(multi_lock_threads) > 1
+        
+        def get_held_locks(self) -> dict[int, set[str]]:
+            """Get current lock holdings."""
+            with self.lock:
+                return self.locks_held.copy()
+    
+    return DeadlockDetector()
+
+
+@pytest.fixture
+def thread_exception_handler():
+    """
+    Capture exceptions from threads for testing.
+    
+    Returns:
+        Exception handler for threads.
+    """
+    class ThreadExceptionHandler:
+        def __init__(self):
+            self.exceptions = []
+            self.lock = threading.Lock()
+        
+        def handle(self, func: Callable) -> Callable:
+            """
+            Wrap function to capture exceptions.
+            
+            Args:
+                func: Function to wrap
+                
+            Returns:
+                Wrapped function
+            """
+            def wrapper(*args, **kwargs):
+                try:
+                    return func(*args, **kwargs)
+                except Exception as e:
+                    with self.lock:
+                        self.exceptions.append({
+                            'thread': threading.current_thread().name,
+                            'exception': e,
+                            'time': time.time()
+                        })
+                    raise
+            
+            return wrapper
+        
+        def get_exceptions(self) -> list[dict]:
+            """Get all captured exceptions."""
+            with self.lock:
+                return self.exceptions.copy()
+        
+        def assert_no_exceptions(self):
+            """Assert no exceptions were raised."""
+            with self.lock:
+                if self.exceptions:
+                    raise AssertionError(f"Thread exceptions occurred: {self.exceptions}")
+    
+    return ThreadExceptionHandler()
+
+
+__all__ = [
+    "concurrent_executor",
+    "thread_synchronizer",
+    "deadlock_detector",
+    "thread_exception_handler",
+]