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

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)

provide/foundation/testing/cli.py

@@ -15,14 +15,15 @@ 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 +158,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,20 +167,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:
@@ -225,3 +212,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

@@ -7,7 +7,6 @@ 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,
@@ -21,7 +20,6 @@ from provide.foundation.testing.common.fixtures import (
 
 __all__ = [
     "mock_http_config",
-    "mock_logger",
     "mock_telemetry_config",
     "mock_config_source",
     "mock_event_emitter",

provide/foundation/testing/common/fixtures.py

@@ -37,33 +37,6 @@ def mock_http_config():
     )
 
 
-@pytest.fixture
-def mock_logger():
-    """
-    Mock logger with captured method calls.
-    
-    Returns:
-        Mock logger with debug, info, warning, error methods.
-    """
-    logger = Mock()
-    logger.debug = Mock()
-    logger.info = Mock()
-    logger.warning = Mock()
-    logger.error = Mock()
-    logger.exception = Mock()
-    logger.critical = Mock()
-    
-    # Add common logger attributes
-    logger.name = "mock_logger"
-    logger.level = 10  # DEBUG level
-    logger.handlers = []
-    logger.disabled = False
-    
-    # Add bind method for structlog compatibility
-    logger.bind = Mock(return_value=logger)
-    logger.unbind = Mock(return_value=logger)
-    
-    return logger
 
 
 @pytest.fixture

provide/foundation/testing/file/content_fixtures.py

@@ -0,0 +1,316 @@
+"""
+Content-based file test fixtures.
+
+Fixtures for creating files with specific content types like text, binary,
+CSV, JSON, and other structured data.
+"""
+
+import csv
+import json
+import random
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from provide.foundation.file.safe import safe_delete
+
+
+@pytest.fixture
+def temp_file():
+    """
+    Create a temporary file factory with optional content.
+    
+    Returns:
+        A function that creates temporary files with specified content and suffix.
+    """
+    created_files = []
+    
+    def _make_temp_file(content: str = "test content", suffix: str = ".txt") -> Path:
+        """
+        Create a temporary file.
+        
+        Args:
+            content: Content to write to the file
+            suffix: File suffix/extension
+            
+        Returns:
+            Path to the created temporary file
+        """
+        with tempfile.NamedTemporaryFile(mode='w', suffix=suffix, delete=False) as f:
+            f.write(content)
+            path = Path(f.name)
+        created_files.append(path)
+        return path
+    
+    yield _make_temp_file
+    
+    # Cleanup all created files
+    for path in created_files:
+        safe_delete(path, missing_ok=True)
+
+
+@pytest.fixture
+def temp_named_file():
+    """
+    Create a named temporary file factory.
+    
+    Returns:
+        Function that creates named temporary files.
+    """
+    created_files = []
+    
+    def _make_named_file(
+        content: bytes | str = None,
+        suffix: str = "",
+        prefix: str = "tmp",
+        dir: Path | str = None,
+        mode: str = 'w+b',
+        delete: bool = False
+    ) -> Path:
+        """
+        Create a named temporary file.
+        
+        Args:
+            content: Optional content to write
+            suffix: File suffix
+            prefix: File prefix
+            dir: Directory for the file
+            mode: File mode
+            delete: Whether to delete on close
+            
+        Returns:
+            Path to the created file
+        """
+        if isinstance(dir, Path):
+            dir = str(dir)
+        
+        f = tempfile.NamedTemporaryFile(
+            mode=mode,
+            suffix=suffix,
+            prefix=prefix,
+            dir=dir,
+            delete=delete
+        )
+        
+        if content is not None:
+            if isinstance(content, str):
+                if 'b' in mode:
+                    f.write(content.encode())
+                else:
+                    f.write(content)
+            else:
+                f.write(content)
+            f.flush()
+        
+        path = Path(f.name)
+        f.close()
+        
+        if not delete:
+            created_files.append(path)
+        
+        return path
+    
+    yield _make_named_file
+    
+    # Cleanup
+    for path in created_files:
+        safe_delete(path, missing_ok=True)
+
+
+@pytest.fixture
+def temp_file_with_content():
+    """
+    Create temporary files with specific content.
+    
+    Returns:
+        Function that creates files with content.
+    """
+    created_files = []
+    
+    def _make_file(
+        content: str | bytes,
+        suffix: str = ".txt",
+        encoding: str = "utf-8"
+    ) -> Path:
+        """
+        Create a temporary file with content.
+        
+        Args:
+            content: Content to write
+            suffix: File suffix
+            encoding: Text encoding (for str content)
+            
+        Returns:
+            Path to created file
+        """
+        with tempfile.NamedTemporaryFile(
+            mode='wb' if isinstance(content, bytes) else 'w',
+            suffix=suffix,
+            delete=False,
+            encoding=None if isinstance(content, bytes) else encoding
+        ) as f:
+            f.write(content)
+            path = Path(f.name)
+        
+        created_files.append(path)
+        return path
+    
+    yield _make_file
+    
+    # Cleanup
+    for path in created_files:
+        safe_delete(path, missing_ok=True)
+
+
+@pytest.fixture
+def temp_binary_file():
+    """
+    Create temporary binary files.
+    
+    Returns:
+        Function that creates binary files.
+    """
+    created_files = []
+    
+    def _make_binary(
+        size: int = 1024,
+        pattern: bytes = None,
+        suffix: str = ".bin"
+    ) -> Path:
+        """
+        Create a temporary binary file.
+        
+        Args:
+            size: File size in bytes
+            pattern: Optional byte pattern to repeat
+            suffix: File suffix
+            
+        Returns:
+            Path to created binary file
+        """
+        if pattern is None:
+            # Create pseudo-random binary data
+            content = bytes(random.randint(0, 255) for _ in range(size))
+        else:
+            # Repeat pattern to reach size
+            repetitions = size // len(pattern) + 1
+            content = (pattern * repetitions)[:size]
+        
+        with tempfile.NamedTemporaryFile(
+            mode='wb',
+            suffix=suffix,
+            delete=False
+        ) as f:
+            f.write(content)
+            path = Path(f.name)
+        
+        created_files.append(path)
+        return path
+    
+    yield _make_binary
+    
+    # Cleanup
+    for path in created_files:
+        safe_delete(path, missing_ok=True)
+
+
+@pytest.fixture
+def temp_csv_file():
+    """
+    Create temporary CSV files for testing.
+    
+    Returns:
+        Function that creates CSV files.
+    """
+    created_files = []
+    
+    def _make_csv(
+        headers: list[str],
+        rows: list[list],
+        suffix: str = ".csv"
+    ) -> Path:
+        """
+        Create a temporary CSV file.
+        
+        Args:
+            headers: Column headers
+            rows: Data rows
+            suffix: File suffix
+            
+        Returns:
+            Path to created CSV file
+        """
+        with tempfile.NamedTemporaryFile(
+            mode='w',
+            suffix=suffix,
+            delete=False,
+            newline=''
+        ) as f:
+            writer = csv.writer(f)
+            writer.writerow(headers)
+            writer.writerows(rows)
+            path = Path(f.name)
+        
+        created_files.append(path)
+        return path
+    
+    yield _make_csv
+    
+    # Cleanup
+    for path in created_files:
+        safe_delete(path, missing_ok=True)
+
+
+@pytest.fixture
+def temp_json_file():
+    """
+    Create temporary JSON files for testing.
+    
+    Returns:
+        Function that creates JSON files.
+    """
+    created_files = []
+    
+    def _make_json(
+        data: dict | list,
+        suffix: str = ".json",
+        indent: int = 2
+    ) -> Path:
+        """
+        Create a temporary JSON file.
+        
+        Args:
+            data: JSON data to write
+            suffix: File suffix
+            indent: JSON indentation
+            
+        Returns:
+            Path to created JSON file
+        """
+        with tempfile.NamedTemporaryFile(
+            mode='w',
+            suffix=suffix,
+            delete=False
+        ) as f:
+            json.dump(data, f, indent=indent)
+            path = Path(f.name)
+        
+        created_files.append(path)
+        return path
+    
+    yield _make_json
+    
+    # Cleanup
+    for path in created_files:
+        safe_delete(path, missing_ok=True)
+
+
+__all__ = [
+    "temp_file",
+    "temp_named_file",
+    "temp_file_with_content",
+    "temp_binary_file",
+    "temp_csv_file",
+    "temp_json_file",
+]

provide/foundation/testing/file/directory_fixtures.py

@@ -0,0 +1,107 @@
+"""
+Directory-specific test fixtures.
+
+Fixtures for creating temporary directories, nested structures, 
+and standard test directory layouts.
+"""
+
+import tempfile
+from pathlib import Path
+from collections.abc import Generator
+
+import pytest
+
+
+@pytest.fixture
+def temp_directory() -> Generator[Path, None, None]:
+    """
+    Create a temporary directory that's cleaned up after test.
+    
+    Yields:
+        Path to the temporary directory.
+    """
+    with tempfile.TemporaryDirectory() as temp_dir:
+        yield Path(temp_dir)
+
+
+@pytest.fixture
+def test_files_structure() -> Generator[tuple[Path, Path], None, None]:
+    """
+    Create standard test file structure with files and subdirectories.
+    
+    Creates:
+        - source/
+            - file1.txt (contains "Content 1")
+            - file2.txt (contains "Content 2")
+            - subdir/
+                - file3.txt (contains "Content 3")
+    
+    Yields:
+        Tuple of (temp_path, source_path)
+    """
+    with tempfile.TemporaryDirectory() as temp_dir:
+        path = Path(temp_dir)
+        source = path / "source"
+        source.mkdir()
+        
+        # Create test files
+        (source / "file1.txt").write_text("Content 1")
+        (source / "file2.txt").write_text("Content 2")
+        
+        # Create subdirectory with files
+        subdir = source / "subdir"
+        subdir.mkdir()
+        (subdir / "file3.txt").write_text("Content 3")
+        
+        yield path, source
+
+
+@pytest.fixture
+def nested_directory_structure() -> Generator[Path, None, None]:
+    """
+    Create a deeply nested directory structure for testing.
+    
+    Creates:
+        - level1/
+            - level2/
+                - level3/
+                    - deep_file.txt
+            - file_l2.txt
+        - file_l1.txt
+    
+    Yields:
+        Path to the root of the structure.
+    """
+    with tempfile.TemporaryDirectory() as temp_dir:
+        root = Path(temp_dir)
+        
+        # Create nested structure
+        deep_dir = root / "level1" / "level2" / "level3"
+        deep_dir.mkdir(parents=True)
+        
+        # Add files at different levels
+        (root / "file_l1.txt").write_text("Level 1 file")
+        (root / "level1" / "file_l2.txt").write_text("Level 2 file")
+        (deep_dir / "deep_file.txt").write_text("Deep file")
+        
+        yield root
+
+
+@pytest.fixture
+def empty_directory() -> Generator[Path, None, None]:
+    """
+    Create an empty temporary directory.
+    
+    Yields:
+        Path to an empty directory.
+    """
+    with tempfile.TemporaryDirectory() as temp_dir:
+        yield Path(temp_dir)
+
+
+__all__ = [
+    "temp_directory",
+    "test_files_structure", 
+    "nested_directory_structure",
+    "empty_directory",
+]