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

provide/foundation/testing/process/subprocess_fixtures.py

@@ -0,0 +1,210 @@
+"""
+Subprocess-specific test fixtures for process testing.
+
+Provides fixtures for mocking and testing subprocess operations,
+stream handling, and process communication.
+"""
+
+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__ = [
+    "async_mock_server",
+    "async_stream_reader",
+    "async_subprocess",
+    "async_test_client",
+    "mock_async_process",
+]

provide/foundation/testing/threading/__init__.py

@@ -6,33 +6,33 @@ and concurrent operations across any project that depends on provide.foundation.
 """
 
 from provide.foundation.testing.threading.fixtures import (
+    concurrent_executor,
+    deadlock_detector,
+    mock_thread,
     test_thread,
-    thread_pool,
     thread_barrier,
-    thread_safe_list,
-    thread_safe_counter,
-    thread_event,
     thread_condition,
-    mock_thread,
+    thread_event,
+    thread_exception_handler,
     thread_local_storage,
-    concurrent_executor,
+    thread_pool,
+    thread_safe_counter,
+    thread_safe_list,
     thread_synchronizer,
-    deadlock_detector,
-    thread_exception_handler,
 )
 
 __all__ = [
+    "concurrent_executor",
+    "deadlock_detector",
+    "mock_thread",
     "test_thread",
-    "thread_pool",
     "thread_barrier",
-    "thread_safe_list",
-    "thread_safe_counter",
-    "thread_event",
     "thread_condition",
-    "mock_thread",
+    "thread_event",
+    "thread_exception_handler",
     "thread_local_storage",
-    "concurrent_executor",
+    "thread_pool",
+    "thread_safe_counter",
+    "thread_safe_list",
     "thread_synchronizer",
-    "deadlock_detector",
-    "thread_exception_handler",
-]
+]

provide/foundation/testing/threading/basic_fixtures.py

@@ -0,0 +1,105 @@
+"""
+Basic threading test fixtures.
+
+Core fixtures for creating threads, thread pools, mocks, and thread-local storage.
+"""
+
+from concurrent.futures import ThreadPoolExecutor
+import threading
+from typing import 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__ = [
+    "mock_thread",
+    "test_thread",
+    "thread_local_storage",
+    "thread_pool",
+]

provide/foundation/testing/threading/data_fixtures.py

@@ -0,0 +1,101 @@
+"""
+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_counter",
+    "thread_safe_list",
+]