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

provide/foundation/testing/process/subprocess_fixtures.py

@@ -5,7 +5,6 @@ Provides fixtures for mocking and testing subprocess operations,
 stream handling, and process communication.
 """
 
-import asyncio
 from unittest.mock import AsyncMock, Mock
 
 import pytest
@@ -15,7 +14,7 @@ import pytest
 def mock_async_process() -> AsyncMock:
     """
     Mock async subprocess for testing.
-    
+
     Returns:
         AsyncMock configured as a subprocess with common attributes.
     """
@@ -29,7 +28,7 @@ def mock_async_process() -> AsyncMock:
     mock_process.wait = AsyncMock(return_value=0)
     mock_process.kill = Mock()
     mock_process.terminate = Mock()
-    
+
     return mock_process
 
 
@@ -37,21 +36,21 @@ def mock_async_process() -> AsyncMock:
 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
 
 
@@ -59,25 +58,23 @@ async def async_stream_reader() -> AsyncMock:
 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
+        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
         """
@@ -89,25 +86,25 @@ def async_subprocess():
         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
 
 
@@ -115,48 +112,49 @@ def async_subprocess():
 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()
 
 
@@ -164,46 +162,49 @@ def async_mock_server():
 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})
+            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_mock_server",
     "async_stream_reader",
     "async_subprocess",
-    "async_mock_server",
     "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

@@ -4,9 +4,9 @@ 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
+import threading
+from typing import Callable
 from unittest.mock import Mock
 
 import pytest
@@ -16,33 +16,37 @@ import pytest
 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:
+
+    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)
+        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():
@@ -53,7 +57,7 @@ def test_thread():
 def thread_pool():
     """
     Create a thread pool executor for testing.
-    
+
     Returns:
         ThreadPoolExecutor instance with automatic cleanup.
     """
@@ -66,7 +70,7 @@ def thread_pool():
 def mock_thread():
     """
     Create a mock thread for testing without actual threading.
-    
+
     Returns:
         Mock thread object.
     """
@@ -78,7 +82,7 @@ def mock_thread():
     mock.start = Mock()
     mock.join = Mock()
     mock.run = Mock()
-    
+
     return mock
 
 
@@ -86,7 +90,7 @@ def mock_thread():
 def thread_local_storage():
     """
     Create thread-local storage for testing.
-    
+
     Returns:
         Thread-local storage object.
     """
@@ -94,8 +98,8 @@ def thread_local_storage():
 
 
 __all__ = [
-    "test_thread",
-    "thread_pool",
     "mock_thread",
+    "test_thread",
     "thread_local_storage",
-]
+    "thread_pool",
+]

provide/foundation/testing/threading/data_fixtures.py

@@ -14,43 +14,44 @@ import pytest
 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()
 
 
@@ -58,42 +59,43 @@ def thread_safe_list():
 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",
-]
+    "thread_safe_list",
+]