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

provide/foundation/testing/common/fixtures.py

@@ -5,8 +5,7 @@ Reusable mock objects for configuration, logging, and other common
 testing scenarios across the provide-io ecosystem.
 """
 
-from unittest.mock import Mock, MagicMock, PropertyMock
-from typing import Any
+from unittest.mock import Mock, PropertyMock
 
 import pytest
 
@@ -18,12 +17,12 @@ from provide.foundation.logger.config.logging import LoggingConfig
 def mock_http_config():
     """
     Standard HTTP configuration for testing.
-    
+
     Returns:
         HTTPConfig with common test settings.
     """
     from provide.foundation.transport.config import HTTPConfig
-    
+
     return HTTPConfig(
         timeout=30.0,
         max_retries=3,
@@ -37,40 +36,11 @@ 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
 def mock_telemetry_config():
     """
     Standard telemetry configuration for testing.
-    
+
     Returns:
         TelemetryConfig with debug logging enabled.
     """
@@ -86,7 +56,7 @@ def mock_telemetry_config():
 def mock_config_source():
     """
     Mock configuration source for testing config loading.
-    
+
     Returns:
         Mock that simulates a configuration source.
     """
@@ -97,7 +67,7 @@ def mock_config_source():
     source.watch = Mock()
     source.priority = 100
     source.name = "mock_source"
-    
+
     return source
 
 
@@ -105,7 +75,7 @@ def mock_config_source():
 def mock_event_emitter():
     """
     Mock event emitter for testing event-driven components.
-    
+
     Returns:
         Mock with emit, on, off methods.
     """
@@ -116,7 +86,7 @@ def mock_event_emitter():
     emitter.once = Mock()
     emitter.listeners = Mock(return_value=[])
     emitter.remove_all_listeners = Mock()
-    
+
     return emitter
 
 
@@ -124,7 +94,7 @@ def mock_event_emitter():
 def mock_transport():
     """
     Mock transport for testing network operations.
-    
+
     Returns:
         Mock transport with request/response methods.
     """
@@ -135,7 +105,7 @@ def mock_transport():
     transport.put = Mock(return_value={"status": 200, "data": {}})
     transport.delete = Mock(return_value={"status": 204})
     transport.close = Mock()
-    
+
     return transport
 
 
@@ -143,7 +113,7 @@ def mock_transport():
 def mock_metrics_collector():
     """
     Mock metrics collector for testing instrumentation.
-    
+
     Returns:
         Mock with common metrics methods.
     """
@@ -154,13 +124,13 @@ def mock_metrics_collector():
     collector.histogram = Mock()
     collector.timer = Mock()
     collector.flush = Mock()
-    
+
     # Add context manager support for timing
     timer_cm = Mock()
     timer_cm.__enter__ = Mock(return_value=timer_cm)
     timer_cm.__exit__ = Mock(return_value=None)
     collector.timer.return_value = timer_cm
-    
+
     return collector
 
 
@@ -168,12 +138,12 @@ def mock_metrics_collector():
 def mock_cache():
     """
     Mock cache for testing caching behavior.
-    
+
     Returns:
         Mock with get, set, delete, clear methods.
     """
     cache_data = {}
-    
+
     cache = Mock()
     cache.get = Mock(side_effect=lambda k, default=None: cache_data.get(k, default))
     cache.set = Mock(side_effect=lambda k, v, ttl=None: cache_data.update({k: v}))
@@ -181,10 +151,10 @@ def mock_cache():
     cache.clear = Mock(side_effect=cache_data.clear)
     cache.exists = Mock(side_effect=lambda k: k in cache_data)
     cache.keys = Mock(return_value=list(cache_data.keys()))
-    
+
     # Store reference to data for test assertions
     cache._data = cache_data
-    
+
     return cache
 
 
@@ -192,7 +162,7 @@ def mock_cache():
 def mock_database():
     """
     Mock database connection for testing.
-    
+
     Returns:
         Mock with execute, fetch, commit, rollback methods.
     """
@@ -205,11 +175,11 @@ def mock_database():
     db.rollback = Mock()
     db.close = Mock()
     db.is_connected = PropertyMock(return_value=True)
-    
+
     # Add context manager support
     db.__enter__ = Mock(return_value=db)
     db.__exit__ = Mock(return_value=None)
-    
+
     return db
 
 
@@ -217,7 +187,7 @@ def mock_database():
 def mock_file_system():
     """
     Mock file system operations.
-    
+
     Returns:
         Mock with read, write, exists, delete methods.
     """
@@ -230,7 +200,7 @@ def mock_file_system():
     fs.rmdir = Mock()
     fs.list = Mock(return_value=[])
     fs.stat = Mock(return_value=Mock(st_size=1024, st_mtime=0))
-    
+
     return fs
 
 
@@ -238,19 +208,19 @@ def mock_file_system():
 def mock_subprocess():
     """
     Mock subprocess for testing command execution.
-    
+
     Returns:
         Mock with run, Popen methods.
     """
     subprocess = Mock()
-    
+
     # Mock run method
     result = Mock()
     result.returncode = 0
     result.stdout = "output"
     result.stderr = ""
     subprocess.run = Mock(return_value=result)
-    
+
     # Mock Popen
     process = Mock()
     process.communicate = Mock(return_value=("output", ""))
@@ -259,5 +229,5 @@ def mock_subprocess():
     process.poll = Mock(return_value=0)
     process.wait = Mock(return_value=0)
     subprocess.Popen = Mock(return_value=process)
-    
-    return subprocess
+
+    return subprocess

provide/foundation/testing/file/__init__.py

@@ -6,35 +6,35 @@ across any project that depends on provide.foundation.
 """
 
 from provide.foundation.testing.file.fixtures import (
-    temp_directory,
-    test_files_structure,
-    temp_file,
     binary_file,
-    nested_directory_structure,
     empty_directory,
+    nested_directory_structure,
     readonly_file,
-    temp_named_file,
-    temp_file_with_content,
     temp_binary_file,
     temp_csv_file,
+    temp_directory,
+    temp_executable_file,
+    temp_file,
+    temp_file_with_content,
     temp_json_file,
+    temp_named_file,
     temp_symlink,
-    temp_executable_file,
+    test_files_structure,
 )
 
 __all__ = [
-    "temp_directory",
-    "test_files_structure", 
-    "temp_file",
     "binary_file",
-    "nested_directory_structure",
     "empty_directory",
+    "nested_directory_structure",
     "readonly_file",
-    "temp_named_file",
-    "temp_file_with_content",
     "temp_binary_file",
     "temp_csv_file",
+    "temp_directory",
+    "temp_executable_file",
+    "temp_file",
+    "temp_file_with_content",
     "temp_json_file",
+    "temp_named_file",
     "temp_symlink",
-    "temp_executable_file",
-]
+    "test_files_structure",
+]

provide/foundation/testing/file/content_fixtures.py

@@ -0,0 +1,289 @@
+"""
+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
+from pathlib import Path
+import random
+import tempfile
+
+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_binary_file",
+    "temp_csv_file",
+    "temp_file",
+    "temp_file_with_content",
+    "temp_json_file",
+    "temp_named_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.
+"""
+
+from collections.abc import Generator
+from pathlib import Path
+import tempfile
+
+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__ = [
+    "empty_directory",
+    "nested_directory_structure",
+    "temp_directory",
+    "test_files_structure",
+]