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

provide/foundation/streams/console.py

@@ -9,6 +9,7 @@ Handles console-specific stream operations and formatting.
 import sys
 from typing import TextIO
 
+from provide.foundation.streams.config import get_stream_config
 from provide.foundation.streams.core import get_log_stream
 
 
@@ -25,14 +26,12 @@ def is_tty() -> bool:
 
 def supports_color() -> bool:
     """Check if the current stream supports color output."""
-    import os
+    config = get_stream_config()
 
-    # Check NO_COLOR environment variable
-    if os.getenv("NO_COLOR"):
+    if config.no_color:
         return False
 
-    # Check FORCE_COLOR environment variable
-    if os.getenv("FORCE_COLOR"):
+    if config.force_color:
         return True
 
     # Check if we're in a TTY

provide/foundation/streams/core.py

@@ -10,6 +10,8 @@ import sys
 import threading
 from typing import TextIO
 
+from provide.foundation.streams.config import get_stream_config
+
 _PROVIDE_LOG_STREAM: TextIO = sys.stderr
 _LOG_FILE_HANDLE: TextIO | None = None
 _STREAM_LOCK = threading.Lock()
@@ -18,10 +20,11 @@ _STREAM_LOCK = threading.Lock()
 def _is_in_click_testing() -> bool:
     """Check if we're running inside Click's testing framework."""
     import inspect
-    import os
+
+    config = get_stream_config()
 
     # Check environment variables for Click testing
-    if os.getenv("CLICK_TESTING"):
+    if config.click_testing:
         return True
 
     # Check the call stack for Click's testing module or CLI integration tests

provide/foundation/streams/file.py

@@ -18,6 +18,16 @@ from provide.foundation.streams.core import (
 from provide.foundation.utils.streams import get_safe_stderr
 
 
+def _safe_error_output(message: str) -> None:
+    """
+    Output error message to stderr using basic print to avoid circular dependencies.
+
+    This function intentionally uses print() instead of Foundation's perr() to prevent
+    circular import issues during stream initialization and teardown phases.
+    """
+    print(message, file=sys.stderr)
+
+
 def configure_file_logging(log_file_path: str | None) -> None:
     """
     Configure file logging if a path is provided.
@@ -56,7 +66,7 @@ def configure_file_logging(log_file_path: str | None) -> None:
                 _PROVIDE_LOG_STREAM = _LOG_FILE_HANDLE
             except Exception as e:
                 # Log error to stderr and fall back
-                print(f"Failed to open log file {log_file_path}: {e}", file=sys.stderr)
+                _safe_error_output(f"Failed to open log file {log_file_path}: {e}")
                 _PROVIDE_LOG_STREAM = get_safe_stderr()
         elif not is_test_stream:
             _PROVIDE_LOG_STREAM = get_safe_stderr()
@@ -71,7 +81,7 @@ def flush_log_streams() -> None:
             try:
                 _LOG_FILE_HANDLE.flush()
             except Exception as e:
-                print(f"Failed to flush log file handle: {e}", file=sys.stderr)
+                _safe_error_output(f"Failed to flush log file handle: {e}")
 
 
 def close_log_streams() -> None:

provide/foundation/testing/__init__.py

@@ -66,15 +66,20 @@ def __getattr__(name: str) -> Any:
         "isolated_cli_runner",
         "temp_config_file",
         "create_test_cli",
-        "mock_logger",
         "CliTestCase",
+        "click_testing_mode",
     ]:
         import provide.foundation.testing.cli as cli_module
 
         return getattr(cli_module, name)
 
     # Logger testing utilities
-    elif name in ["reset_foundation_setup_for_testing", "reset_foundation_state"]:
+    elif name in [
+        "reset_foundation_setup_for_testing",
+        "reset_foundation_state",
+        "mock_logger",
+        "mock_logger_factory",
+    ]:
         import provide.foundation.testing.logger as logger_module
 
         return getattr(logger_module, name)
@@ -93,12 +98,22 @@ def __getattr__(name: str) -> Any:
         import provide.foundation.testing.fixtures as fixtures_module
 
         return getattr(fixtures_module, name)
-    
+
     # Import submodules directly
-    elif name in ["archive", "common", "file", "process", "transport", "mocking", "time", "threading"]:
+    elif name in [
+        "archive",
+        "common",
+        "file",
+        "process",
+        "transport",
+        "mocking",
+        "time",
+        "threading",
+    ]:
         import importlib
+
         return importlib.import_module(f"provide.foundation.testing.{name}")
-    
+
     # File testing utilities (backward compatibility)
     elif name in [
         "temp_directory",
@@ -110,8 +125,9 @@ def __getattr__(name: str) -> Any:
         "readonly_file",
     ]:
         import provide.foundation.testing.file.fixtures as file_module
+
         return getattr(file_module, name)
-    
+
     # Process/async testing utilities (backward compatibility)
     elif name in [
         "clean_event_loop",
@@ -126,8 +142,9 @@ def __getattr__(name: str) -> Any:
         "mock_async_sleep",
     ]:
         import provide.foundation.testing.process.fixtures as process_module
+
         return getattr(process_module, name)
-    
+
     # Common mock utilities (backward compatibility)
     elif name in [
         "mock_http_config",
@@ -142,8 +159,9 @@ def __getattr__(name: str) -> Any:
         "mock_subprocess",
     ]:
         import provide.foundation.testing.common.fixtures as common_module
+
         return getattr(common_module, name)
-    
+
     # Transport/network testing utilities (backward compatibility)
     elif name in [
         "free_port",
@@ -157,8 +175,9 @@ def __getattr__(name: str) -> Any:
         "mock_http_headers",
     ]:
         import provide.foundation.testing.transport.fixtures as transport_module
+
         return getattr(transport_module, name)
-    
+
     # Archive testing utilities
     elif name in [
         "archive_test_content",
@@ -169,6 +188,7 @@ def __getattr__(name: str) -> Any:
         "archive_stress_test_files",
     ]:
         import provide.foundation.testing.archive.fixtures as archive_module
+
         return getattr(archive_module, name)
 
     # Crypto fixtures (many fixtures)

provide/foundation/testing/archive/__init__.py

@@ -6,19 +6,19 @@ across any project that depends on provide.foundation.
 """
 
 from provide.foundation.testing.archive.fixtures import (
+    archive_stress_test_files,
     archive_test_content,
-    large_file_for_compression,
-    multi_format_archives,
     archive_with_permissions,
     corrupted_archives,
-    archive_stress_test_files,
+    large_file_for_compression,
+    multi_format_archives,
 )
 
 __all__ = [
+    "archive_stress_test_files",
     "archive_test_content",
-    "large_file_for_compression",
-    "multi_format_archives",
     "archive_with_permissions",
     "corrupted_archives",
-    "archive_stress_test_files",
-]
+    "large_file_for_compression",
+    "multi_format_archives",
+]

provide/foundation/testing/archive/fixtures.py

@@ -5,8 +5,8 @@ Fixtures specific to testing archive operations like tar, zip, gzip, bzip2.
 Builds on top of file fixtures for archive-specific test scenarios.
 """
 
-from pathlib import Path
 from collections.abc import Generator
+from pathlib import Path
 
 import pytest
 
@@ -17,10 +17,10 @@ from provide.foundation.testing.file.fixtures import temp_directory
 def archive_test_content() -> Generator[tuple[Path, dict[str, str]], None, None]:
     """
     Create a standard set of files for archive testing.
-    
+
     Creates multiple files with different types of content to ensure
     proper compression and extraction testing.
-    
+
     Yields:
         Tuple of (source_dir, content_map) where content_map maps
         relative paths to their expected content.
@@ -28,26 +28,28 @@ def archive_test_content() -> Generator[tuple[Path, dict[str, str]], None, None]
     with temp_directory() as temp_dir:
         source = temp_dir / "archive_source"
         source.mkdir()
-        
+
         content_map = {
             "text_file.txt": "This is a text file for archive testing.\n" * 10,
             "data.json": '{"test": "data", "array": [1, 2, 3]}',
             "script.py": "#!/usr/bin/env python\nprint('Hello from archive')\n",
             "nested/dir/file.md": "# Nested File\nContent in nested directory",
-            "binary.dat": "Binary\x00\x01\x02\x03\xFF\xFE data",
+            "binary.dat": "Binary\x00\x01\x02\x03\xff\xfe data",
             "empty.txt": "",
         }
-        
+
         # Create all files
         for rel_path, content in content_map.items():
             file_path = source / rel_path
             file_path.parent.mkdir(parents=True, exist_ok=True)
-            
+
             if isinstance(content, str):
                 file_path.write_text(content)
             else:
-                file_path.write_bytes(content.encode() if isinstance(content, str) else content)
-        
+                file_path.write_bytes(
+                    content.encode() if isinstance(content, str) else content
+                )
+
         yield source, content_map
 
 
@@ -55,19 +57,19 @@ def archive_test_content() -> Generator[tuple[Path, dict[str, str]], None, None]
 def large_file_for_compression() -> Generator[Path, None, None]:
     """
     Create a large file suitable for compression testing.
-    
+
     The file contains repetitive content that compresses well.
-    
+
     Yields:
         Path to a large file with compressible content.
     """
     with temp_directory() as temp_dir:
         large_file = temp_dir / "large_compressible.txt"
-        
+
         # Create 10MB of highly compressible content
         content = "This is a line of text that will be repeated many times.\n" * 100
         large_content = content * 1000  # ~6MB of repetitive text
-        
+
         large_file.write_text(large_content)
         yield large_file
 
@@ -76,46 +78,48 @@ def large_file_for_compression() -> Generator[Path, None, None]:
 def multi_format_archives() -> Generator[dict[str, Path], None, None]:
     """
     Create sample archives in different formats for format detection testing.
-    
+
     Yields:
         Dict mapping format names to paths of sample archives.
     """
     with temp_directory() as temp_dir:
         archives = {}
-        
+
         # Create minimal valid archives in different formats
         # Note: These are minimal headers, not full valid archives
-        
+
         # GZIP file (magic: 1f 8b)
         gzip_file = temp_dir / "sample.gz"
-        gzip_file.write_bytes(b'\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\x03' + b'compressed data')
+        gzip_file.write_bytes(
+            b"\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\x03" + b"compressed data"
+        )
         archives["gzip"] = gzip_file
-        
+
         # BZIP2 file (magic: BZh)
         bzip2_file = temp_dir / "sample.bz2"
-        bzip2_file.write_bytes(b'BZh91AY&SY' + b'compressed data')
+        bzip2_file.write_bytes(b"BZh91AY&SY" + b"compressed data")
         archives["bzip2"] = bzip2_file
-        
+
         # ZIP file (magic: PK\x03\x04)
         zip_file = temp_dir / "sample.zip"
-        zip_file.write_bytes(b'PK\x03\x04' + b'\x00' * 16 + b'zipfile')
+        zip_file.write_bytes(b"PK\x03\x04" + b"\x00" * 16 + b"zipfile")
         archives["zip"] = zip_file
-        
+
         # TAR file (has specific header structure)
         tar_file = temp_dir / "sample.tar"
         # Minimal tar header (512 bytes)
-        tar_header = b'testfile.txt' + b'\x00' * 88  # name
-        tar_header += b'0000644\x00'  # mode
-        tar_header += b'0000000\x00'  # uid
-        tar_header += b'0000000\x00'  # gid
-        tar_header += b'00000000000\x00'  # size
-        tar_header += b'00000000000\x00'  # mtime
-        tar_header += b'        '  # checksum placeholder
-        tar_header += b'0'  # typeflag
-        tar_header += b'\x00' * 355  # padding to 512 bytes
+        tar_header = b"testfile.txt" + b"\x00" * 88  # name
+        tar_header += b"0000644\x00"  # mode
+        tar_header += b"0000000\x00"  # uid
+        tar_header += b"0000000\x00"  # gid
+        tar_header += b"00000000000\x00"  # size
+        tar_header += b"00000000000\x00"  # mtime
+        tar_header += b"        "  # checksum placeholder
+        tar_header += b"0"  # typeflag
+        tar_header += b"\x00" * 355  # padding to 512 bytes
         tar_file.write_bytes(tar_header[:512])
         archives["tar"] = tar_file
-        
+
         yield archives
 
 
@@ -123,34 +127,34 @@ def multi_format_archives() -> Generator[dict[str, Path], None, None]:
 def archive_with_permissions() -> Generator[Path, None, None]:
     """
     Create files with specific permissions for archive permission testing.
-    
+
     Yields:
         Path to directory containing files with various permission modes.
     """
     with temp_directory() as temp_dir:
         source = temp_dir / "permissions_test"
         source.mkdir()
-        
+
         # Regular file
         regular = source / "regular.txt"
         regular.write_text("Regular file")
         regular.chmod(0o644)
-        
+
         # Executable file
         executable = source / "script.sh"
         executable.write_text("#!/bin/bash\necho 'Hello'")
         executable.chmod(0o755)
-        
+
         # Read-only file
         readonly = source / "readonly.txt"
         readonly.write_text("Read only content")
         readonly.chmod(0o444)
-        
+
         # Directory with specific permissions
         special_dir = source / "special"
         special_dir.mkdir()
         special_dir.chmod(0o700)
-        
+
         yield source
 
 
@@ -158,33 +162,33 @@ def archive_with_permissions() -> Generator[Path, None, None]:
 def corrupted_archives() -> Generator[dict[str, Path], None, None]:
     """
     Create corrupted archive files for error handling testing.
-    
+
     Yields:
         Dict mapping format names to paths of corrupted archives.
     """
     with temp_directory() as temp_dir:
         corrupted = {}
-        
+
         # Corrupted GZIP (invalid header)
         bad_gzip = temp_dir / "corrupted.gz"
-        bad_gzip.write_bytes(b'\x1f\x8c' + b'not really gzip data')
+        bad_gzip.write_bytes(b"\x1f\x8c" + b"not really gzip data")
         corrupted["gzip"] = bad_gzip
-        
+
         # Corrupted ZIP (incomplete header)
         bad_zip = temp_dir / "corrupted.zip"
-        bad_zip.write_bytes(b'PK\x03')  # Incomplete magic
+        bad_zip.write_bytes(b"PK\x03")  # Incomplete magic
         corrupted["zip"] = bad_zip
-        
+
         # Corrupted BZIP2 (wrong magic)
         bad_bzip2 = temp_dir / "corrupted.bz2"
-        bad_bzip2.write_bytes(b'BZX' + b'not bzip2')
+        bad_bzip2.write_bytes(b"BZX" + b"not bzip2")
         corrupted["bzip2"] = bad_bzip2
-        
+
         # Empty file claiming to be archive
         empty_archive = temp_dir / "empty.tar.gz"
-        empty_archive.write_bytes(b'')
+        empty_archive.write_bytes(b"")
         corrupted["empty"] = empty_archive
-        
+
         yield corrupted
 
 
@@ -192,26 +196,26 @@ def corrupted_archives() -> Generator[dict[str, Path], None, None]:
 def archive_stress_test_files() -> Generator[Path, None, None]:
     """
     Create a large number of files for stress testing archive operations.
-    
+
     Yields:
         Path to directory with many files for stress testing.
     """
     with temp_directory() as temp_dir:
         stress_dir = temp_dir / "stress_test"
         stress_dir.mkdir()
-        
+
         # Create 100 files in various subdirectories
         for i in range(10):
             subdir = stress_dir / f"subdir_{i}"
             subdir.mkdir()
-            
+
             for j in range(10):
                 file_path = subdir / f"file_{j}.txt"
                 file_path.write_text(f"Content of file {i}_{j}\n" * 10)
-        
+
         # Add some binary files
         for i in range(5):
             bin_file = stress_dir / f"binary_{i}.dat"
             bin_file.write_bytes(bytes(range(256)) * 10)
-        
-        yield stress_dir
+
+        yield stress_dir

provide/foundation/testing/cli.py

@@ -11,18 +11,18 @@ import os
 from pathlib import Path
 import tempfile
 from typing import Any
-from unittest.mock import MagicMock
 
 import click
 from click.testing import CliRunner
+import pytest
 
-from provide.foundation.context import Context
+from provide.foundation.context import CLIContext
 from provide.foundation.logger import get_logger
 
 log = get_logger(__name__)
 
 
-class MockContext(Context):
+class MockContext(CLIContext):
     """Mock context for testing that tracks method calls."""
 
     def __init__(self, **kwargs) -> None:
@@ -157,7 +157,7 @@ def create_test_cli(
     @click.pass_context
     def cli(ctx, **kwargs) -> None:
         """Test CLI for testing."""
-        ctx.obj = Context(**{k: v for k, v in kwargs.items() if v is not None})
+        ctx.obj = CLIContext(**{k: v for k, v in kwargs.items() if v is not None})
 
     if commands:
         for cmd in commands:
@@ -166,22 +166,6 @@ def create_test_cli(
     return cli
 
 
-def mock_logger():
-    """
-    Create a mock logger for testing.
-
-    Returns:
-        MagicMock with common logger methods
-    """
-    mock = MagicMock()
-    mock.debug = MagicMock()
-    mock.info = MagicMock()
-    mock.warning = MagicMock()
-    mock.error = MagicMock()
-    mock.critical = MagicMock()
-    return mock
-
-
 class CliTestCase:
     """Base class for CLI test cases with common utilities."""
 
@@ -225,3 +209,29 @@ class CliTestCase:
             assert output[key] == value, (
                 f"Value mismatch for '{key}': {output[key]} != {value}"
             )
+
+
+@pytest.fixture
+def click_testing_mode():
+    """
+    Pytest fixture to enable Click testing mode.
+
+    Sets CLICK_TESTING=1 environment variable for the duration of the test,
+    then restores the original value. This fixture makes it easy to enable
+    Click testing mode without manual environment variable management.
+
+    Usage:
+        def test_my_cli(click_testing_mode):
+            # Test CLI code here - CLICK_TESTING is automatically set
+            pass
+    """
+    original_value = os.environ.get("CLICK_TESTING")
+    os.environ["CLICK_TESTING"] = "1"
+
+    try:
+        yield
+    finally:
+        if original_value is None:
+            os.environ.pop("CLICK_TESTING", None)
+        else:
+            os.environ["CLICK_TESTING"] = original_value

provide/foundation/testing/common/__init__.py

@@ -6,29 +6,27 @@ in any project that depends on provide.foundation.
 """
 
 from provide.foundation.testing.common.fixtures import (
-    mock_http_config,
-    mock_logger,
-    mock_telemetry_config,
-    mock_config_source,
-    mock_event_emitter,
-    mock_transport,
-    mock_metrics_collector,
     mock_cache,
+    mock_config_source,
     mock_database,
+    mock_event_emitter,
     mock_file_system,
+    mock_http_config,
+    mock_metrics_collector,
     mock_subprocess,
+    mock_telemetry_config,
+    mock_transport,
 )
 
 __all__ = [
-    "mock_http_config",
-    "mock_logger",
-    "mock_telemetry_config",
-    "mock_config_source",
-    "mock_event_emitter",
-    "mock_transport",
-    "mock_metrics_collector",
     "mock_cache",
+    "mock_config_source",
     "mock_database",
+    "mock_event_emitter",
     "mock_file_system",
+    "mock_http_config",
+    "mock_metrics_collector",
     "mock_subprocess",
-]
+    "mock_telemetry_config",
+    "mock_transport",
+]