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

provide/foundation/testing/logger.py

@@ -8,6 +8,9 @@ Provides utilities for resetting logger state, managing configurations,
 and ensuring test isolation for the Foundation logging system.
 """
 
+from unittest.mock import Mock
+
+import pytest
 import structlog
 
 from provide.foundation.logger.core import (
@@ -17,6 +20,78 @@ from provide.foundation.logger.core import (
 from provide.foundation.streams.file import reset_streams
 
 
+@pytest.fixture
+def mock_logger():
+    """
+    Comprehensive mock logger for testing.
+
+    Provides compatibility with both stdlib logging and structlog interfaces,
+    including method call tracking and common logger attributes.
+
+    Returns:
+        Mock logger with debug, info, warning, error methods and structlog compatibility.
+    """
+    logger = Mock()
+    logger.debug = Mock()
+    logger.info = Mock()
+    logger.warning = Mock()
+    logger.warn = Mock()  # Alias for warning
+    logger.error = Mock()
+    logger.exception = Mock()
+    logger.critical = Mock()
+    logger.fatal = Mock()  # Alias for critical
+
+    # Add common logger attributes
+    logger.name = "mock_logger"
+    logger.level = 10  # DEBUG level
+    logger.handlers = []
+    logger.disabled = False
+
+    # Add structlog compatibility methods
+    logger.bind = Mock(return_value=logger)
+    logger.unbind = Mock(return_value=logger)
+    logger.new = Mock(return_value=logger)
+    logger.msg = Mock()  # Alternative to info
+
+    # Add trace method for Foundation's extended logging
+    logger.trace = Mock()
+
+    return logger
+
+
+def mock_logger_factory():
+    """
+    Factory function to create mock loggers outside of pytest context.
+
+    Useful for unit tests that need a mock logger but aren't using pytest fixtures.
+
+    Returns:
+        Mock logger with the same interface as the pytest fixture.
+    """
+    logger = Mock()
+    logger.debug = Mock()
+    logger.info = Mock()
+    logger.warning = Mock()
+    logger.warn = Mock()
+    logger.error = Mock()
+    logger.exception = Mock()
+    logger.critical = Mock()
+    logger.fatal = Mock()
+
+    logger.name = "mock_logger"
+    logger.level = 10
+    logger.handlers = []
+    logger.disabled = False
+
+    logger.bind = Mock(return_value=logger)
+    logger.unbind = Mock(return_value=logger)
+    logger.new = Mock(return_value=logger)
+    logger.msg = Mock()
+    logger.trace = Mock()
+
+    return logger
+
+
 def _reset_opentelemetry_providers() -> None:
     """
     Reset OpenTelemetry providers to uninitialized state.
@@ -27,7 +102,7 @@ def _reset_opentelemetry_providers() -> None:
     try:
         # Reset tracing provider more thoroughly
         import opentelemetry.trace as otel_trace
-        
+
         # Reset the Once flag to allow re-initialization
         if hasattr(otel_trace, "_TRACER_PROVIDER_SET_ONCE"):
             once_obj = otel_trace._TRACER_PROVIDER_SET_ONCE
@@ -36,11 +111,12 @@ def _reset_opentelemetry_providers() -> None:
             if hasattr(once_obj, "_lock"):
                 with once_obj._lock:
                     once_obj._done = False
-        
+
         # Reset to NoOpTracerProvider
         from opentelemetry.trace import NoOpTracerProvider
+
         otel_trace.set_tracer_provider(NoOpTracerProvider())
-        
+
     except ImportError:
         # OpenTelemetry tracing not available
         pass
@@ -52,7 +128,7 @@ def _reset_opentelemetry_providers() -> None:
         # Reset metrics provider more thoroughly
         import opentelemetry.metrics as otel_metrics
         import opentelemetry.metrics._internal as otel_metrics_internal
-        
+
         # Reset the Once flag to allow re-initialization
         if hasattr(otel_metrics_internal, "_METER_PROVIDER_SET_ONCE"):
             once_obj = otel_metrics_internal._METER_PROVIDER_SET_ONCE
@@ -61,11 +137,12 @@ def _reset_opentelemetry_providers() -> None:
             if hasattr(once_obj, "_lock"):
                 with once_obj._lock:
                     once_obj._done = False
-        
+
         # Reset to NoOpMeterProvider
         from opentelemetry.metrics import NoOpMeterProvider
+
         otel_metrics.set_meter_provider(NoOpMeterProvider())
-        
+
     except ImportError:
         # OpenTelemetry metrics not available
         pass
@@ -113,17 +190,19 @@ def reset_foundation_setup_for_testing() -> None:
     """
     # Full reset but with improved OpenTelemetry handling
     reset_foundation_state()
-    
+
     # Clear and re-initialize the hub for test isolation
     try:
         from provide.foundation.hub.manager import clear_hub
+
         clear_hub()
     except ImportError:
         pass
-    
+
     # Re-register HTTP transport for tests that need it
     try:
         from provide.foundation.transport.http import _register_http_transport
+
         _register_http_transport()
     except ImportError:
         # Transport module not available
@@ -131,6 +210,8 @@ def reset_foundation_setup_for_testing() -> None:
 
 
 __all__ = [
+    "mock_logger",
+    "mock_logger_factory",
     "reset_foundation_setup_for_testing",
     "reset_foundation_state",
 ]

provide/foundation/testing/mocking/__init__.py

@@ -6,41 +6,41 @@ boilerplate and ensure consistent mocking across all tests.
 """
 
 from provide.foundation.testing.mocking.fixtures import (
-    Mock,
-    MagicMock,
+    ANY,
     AsyncMock,
+    MagicMock,
+    Mock,
     PropertyMock,
-    patch,
+    assert_mock_calls,
+    async_mock_factory,
+    auto_patch,
     call,
-    ANY,
-    mock_factory,
     magic_mock_factory,
-    async_mock_factory,
-    property_mock_factory,
+    mock_factory,
+    mock_open_fixture,
+    patch,
     patch_fixture,
     patch_multiple_fixture,
-    auto_patch,
-    mock_open_fixture,
+    property_mock_factory,
     spy_fixture,
-    assert_mock_calls,
 )
 
 __all__ = [
-    "Mock",
-    "MagicMock",
+    "ANY",
     "AsyncMock",
+    "MagicMock",
+    "Mock",
     "PropertyMock",
-    "patch",
+    "assert_mock_calls",
+    "async_mock_factory",
+    "auto_patch",
     "call",
-    "ANY",
-    "mock_factory",
     "magic_mock_factory",
-    "async_mock_factory",
-    "property_mock_factory",
+    "mock_factory",
+    "mock_open_fixture",
+    "patch",
     "patch_fixture",
     "patch_multiple_fixture",
-    "auto_patch",
-    "mock_open_fixture",
+    "property_mock_factory",
     "spy_fixture",
-    "assert_mock_calls",
-]
+]

provide/foundation/testing/mocking/fixtures.py

@@ -5,10 +5,8 @@ Standardized mocking patterns and fixtures for the provide-io ecosystem.
 Reduces boilerplate and ensures consistent mocking across all tests.
 """
 
-from unittest.mock import Mock, MagicMock, AsyncMock, PropertyMock, patch, call, ANY
-from typing import Any, Callable
-from collections.abc import Generator
-import sys
+from typing import Any
+from unittest.mock import ANY, AsyncMock, MagicMock, Mock, PropertyMock, call, patch
 
 import pytest
 
@@ -17,18 +15,19 @@ import pytest
 def mock_factory():
     """
     Factory for creating configured mock objects.
-    
+
     Returns:
         Function that creates mock objects with common configurations.
     """
-    def _create_mock(name: str = None, **kwargs) -> Mock:
+
+    def _create_mock(name: str | None = None, **kwargs) -> Mock:
         """
         Create a mock with standard configuration.
-        
+
         Args:
             name: Optional name for the mock
             **kwargs: Additional mock configuration
-            
+
         Returns:
             Configured Mock object
         """
@@ -36,10 +35,10 @@ def mock_factory():
             "spec_set": True if "spec" in kwargs else False,
         }
         defaults.update(kwargs)
-        
+
         mock = Mock(name=name, **defaults)
         return mock
-    
+
     return _create_mock
 
 
@@ -47,23 +46,24 @@ def mock_factory():
 def magic_mock_factory():
     """
     Factory for creating MagicMock objects.
-    
+
     Returns:
         Function that creates MagicMock objects with common configurations.
     """
-    def _create_magic_mock(name: str = None, **kwargs) -> MagicMock:
+
+    def _create_magic_mock(name: str | None = None, **kwargs) -> MagicMock:
         """
         Create a MagicMock with standard configuration.
-        
+
         Args:
             name: Optional name for the mock
             **kwargs: Additional mock configuration
-            
+
         Returns:
             Configured MagicMock object
         """
         return MagicMock(name=name, **kwargs)
-    
+
     return _create_magic_mock
 
 
@@ -71,20 +71,23 @@ def magic_mock_factory():
 def async_mock_factory():
     """
     Factory for creating AsyncMock objects.
-    
+
     Returns:
         Function that creates AsyncMock objects with common configurations.
     """
-    def _create_async_mock(name: str = None, return_value=None, side_effect=None, **kwargs) -> AsyncMock:
+
+    def _create_async_mock(
+        name: str | None = None, return_value: object = None, side_effect: object = None, **kwargs
+    ) -> AsyncMock:
         """
         Create an AsyncMock with standard configuration.
-        
+
         Args:
             name: Optional name for the mock
             return_value: Return value for the async mock
             side_effect: Side effect for the async mock
             **kwargs: Additional mock configuration
-            
+
         Returns:
             Configured AsyncMock object
         """
@@ -94,7 +97,7 @@ def async_mock_factory():
         if side_effect is not None:
             mock.side_effect = side_effect
         return mock
-    
+
     return _create_async_mock
 
 
@@ -102,24 +105,29 @@ def async_mock_factory():
 def property_mock_factory():
     """
     Factory for creating PropertyMock objects.
-    
+
     Returns:
         Function that creates PropertyMock objects.
     """
-    def _create_property_mock(return_value=None, side_effect=None, **kwargs) -> PropertyMock:
+
+    def _create_property_mock(
+        return_value=None, side_effect=None, **kwargs
+    ) -> PropertyMock:
         """
         Create a PropertyMock.
-        
+
         Args:
             return_value: Return value for the property
             side_effect: Side effect for the property
             **kwargs: Additional mock configuration
-            
+
         Returns:
             Configured PropertyMock object
         """
-        return PropertyMock(return_value=return_value, side_effect=side_effect, **kwargs)
-    
+        return PropertyMock(
+            return_value=return_value, side_effect=side_effect, **kwargs
+        )
+
     return _create_property_mock
 
 
@@ -127,20 +135,20 @@ def property_mock_factory():
 def patch_fixture():
     """
     Fixture for patching objects with automatic cleanup.
-    
+
     Returns:
         Function that patches objects and returns the mock.
     """
     patches = []
-    
+
     def _patch(target: str, **kwargs) -> Mock:
         """
         Patch a target with automatic cleanup.
-        
+
         Args:
             target: The target to patch (module.Class.attribute)
             **kwargs: Additional patch configuration
-            
+
         Returns:
             The mock object
         """
@@ -148,9 +156,9 @@ def patch_fixture():
         mock = patcher.start()
         patches.append(patcher)
         return mock
-    
+
     yield _patch
-    
+
     # Cleanup all patches
     for patcher in patches:
         patcher.stop()
@@ -160,31 +168,32 @@ def patch_fixture():
 def patch_multiple_fixture():
     """
     Fixture for patching multiple objects at once.
-    
+
     Returns:
         Function that patches multiple targets.
     """
     patches = []
-    
+
     def _patch_multiple(target_module: str, **kwargs) -> dict[str, Mock]:
         """
         Patch multiple attributes in a module.
-        
+
         Args:
             target_module: The module to patch in
             **kwargs: Mapping of attribute names to mock objects or DEFAULT
-            
+
         Returns:
             Dict mapping attribute names to mock objects
         """
         from unittest.mock import patch as mock_patch
+
         patcher = mock_patch.multiple(target_module, **kwargs)
         mocks = patcher.start()
         patches.append(patcher)
         return mocks
-    
+
     yield _patch_multiple
-    
+
     # Cleanup all patches
     for patcher in patches:
         patcher.stop()
@@ -194,39 +203,41 @@ def patch_multiple_fixture():
 def auto_patch():
     """
     Context manager for automatic patching with cleanup.
-    
+
     Returns:
         Patch context manager class.
     """
+
     class AutoPatch:
         def __init__(self):
             self.patches = []
-        
+
         def object(self, target: Any, attribute: str, **kwargs) -> Mock:
             """Patch an object's attribute."""
             patcher = patch.object(target, attribute, **kwargs)
             mock = patcher.start()
             self.patches.append(patcher)
             return mock
-        
+
         def dict(self, target: dict, values: dict, **kwargs) -> None:
             """Patch a dictionary."""
             patcher = patch.dict(target, values, **kwargs)
             patcher.start()
             self.patches.append(patcher)
-        
+
         def env(self, **env_vars) -> None:
             """Patch environment variables."""
             import os
+
             patcher = patch.dict(os.environ, env_vars)
             patcher.start()
             self.patches.append(patcher)
-        
+
         def cleanup(self):
             """Stop all patches."""
             for patcher in self.patches:
                 patcher.stop()
-    
+
     patcher = AutoPatch()
     yield patcher
     patcher.cleanup()
@@ -236,24 +247,24 @@ def auto_patch():
 def mock_open_fixture():
     """
     Fixture for mocking file operations.
-    
+
     Returns:
         Function that creates a mock for open().
     """
     from unittest.mock import mock_open
-    
+
     def _mock_open(read_data: str = None) -> Mock:
         """
         Create a mock for the open() builtin.
-        
+
         Args:
             read_data: Optional data to return when reading
-            
+
         Returns:
             Mock object for open()
         """
         return mock_open(read_data=read_data)
-    
+
     return _mock_open
 
 
@@ -261,18 +272,19 @@ def mock_open_fixture():
 def spy_fixture():
     """
     Create a spy (mock that calls through to the original).
-    
+
     Returns:
         Function that creates spy objects.
     """
+
     def _create_spy(obj: Any, method_name: str) -> Mock:
         """
         Create a spy on a method.
-        
+
         Args:
             obj: The object to spy on
             method_name: The method name to spy on
-            
+
         Returns:
             Mock that wraps the original method
         """
@@ -280,7 +292,7 @@ def spy_fixture():
         mock = Mock(wraps=original)
         setattr(obj, method_name, mock)
         return mock
-    
+
     return _create_spy
 
 
@@ -288,14 +300,15 @@ def spy_fixture():
 def assert_mock_calls():
     """
     Helper for asserting mock calls with better error messages.
-    
+
     Returns:
         Function for asserting mock calls.
     """
+
     def _assert_calls(mock: Mock, expected_calls: list, any_order: bool = False):
         """
         Assert that a mock was called with expected calls.
-        
+
         Args:
             mock: The mock to check
             expected_calls: List of expected call objects
@@ -305,27 +318,27 @@ def assert_mock_calls():
             mock.assert_has_calls(expected_calls, any_order=True)
         else:
             mock.assert_has_calls(expected_calls)
-    
+
     return _assert_calls
 
 
 # Re-export commonly used mock utilities
 __all__ = [
-    "Mock",
-    "MagicMock", 
+    "ANY",
     "AsyncMock",
+    "MagicMock",
+    "Mock",
     "PropertyMock",
-    "patch",
+    "assert_mock_calls",
+    "async_mock_factory",
+    "auto_patch",
     "call",
-    "ANY",
-    "mock_factory",
     "magic_mock_factory",
-    "async_mock_factory",
-    "property_mock_factory",
+    "mock_factory",
+    "mock_open_fixture",
+    "patch",
     "patch_fixture",
     "patch_multiple_fixture",
-    "auto_patch",
-    "mock_open_fixture",
+    "property_mock_factory",
     "spy_fixture",
-    "assert_mock_calls",
-]
+]

provide/foundation/testing/process/__init__.py

@@ -6,43 +6,43 @@ event loop management across any project that depends on provide.foundation.
 """
 
 from provide.foundation.testing.process.fixtures import (
-    clean_event_loop,
-    async_timeout,
-    mock_async_process,
-    async_stream_reader,
-    event_loop_policy,
+    async_condition_waiter,
     async_context_manager,
+    async_gather_helper,
     async_iterator,
-    async_queue,
     async_lock,
-    mock_async_sleep,
-    async_subprocess,
-    async_gather_helper,
-    async_task_group,
-    async_condition_waiter,
     async_mock_server,
     async_pipeline,
+    async_queue,
     async_rate_limiter,
+    async_stream_reader,
+    async_subprocess,
+    async_task_group,
     async_test_client,
+    async_timeout,
+    clean_event_loop,
+    event_loop_policy,
+    mock_async_process,
+    mock_async_sleep,
 )
 
 __all__ = [
-    "clean_event_loop",
-    "async_timeout",
-    "mock_async_process",
-    "async_stream_reader",
-    "event_loop_policy",
+    "async_condition_waiter",
     "async_context_manager",
+    "async_gather_helper",
     "async_iterator",
-    "async_queue",
     "async_lock",
-    "mock_async_sleep",
-    "async_subprocess",
-    "async_gather_helper",
-    "async_task_group",
-    "async_condition_waiter",
     "async_mock_server",
     "async_pipeline",
+    "async_queue",
     "async_rate_limiter",
+    "async_stream_reader",
+    "async_subprocess",
+    "async_task_group",
     "async_test_client",
-]
+    "async_timeout",
+    "clean_event_loop",
+    "event_loop_policy",
+    "mock_async_process",
+    "mock_async_sleep",
+]