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

provide/foundation/testing/archive/fixtures.py

@@ -0,0 +1,217 @@
+"""
+Archive Testing Fixtures.
+
+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
+
+import pytest
+
+from provide.foundation.testing.file.fixtures import temp_directory
+
+
+@pytest.fixture
+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.
+    """
+    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",
+            "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)
+        
+        yield source, content_map
+
+
+@pytest.fixture
+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
+
+
+@pytest.fixture
+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')
+        archives["gzip"] = gzip_file
+        
+        # BZIP2 file (magic: BZh)
+        bzip2_file = temp_dir / "sample.bz2"
+        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')
+        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_file.write_bytes(tar_header[:512])
+        archives["tar"] = tar_file
+        
+        yield archives
+
+
+@pytest.fixture
+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
+
+
+@pytest.fixture
+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')
+        corrupted["gzip"] = bad_gzip
+        
+        # Corrupted ZIP (incomplete header)
+        bad_zip = temp_dir / "corrupted.zip"
+        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')
+        corrupted["bzip2"] = bad_bzip2
+        
+        # Empty file claiming to be archive
+        empty_archive = temp_dir / "empty.tar.gz"
+        empty_archive.write_bytes(b'')
+        corrupted["empty"] = empty_archive
+        
+        yield corrupted
+
+
+@pytest.fixture
+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

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

@@ -0,0 +1,32 @@
+"""
+Common testing fixtures for the provide-io ecosystem.
+
+Standard mock objects and fixtures that are used across multiple modules
+in any project that depends on provide.foundation.
+"""
+
+from provide.foundation.testing.common.fixtures import (
+    mock_http_config,
+    mock_telemetry_config,
+    mock_config_source,
+    mock_event_emitter,
+    mock_transport,
+    mock_metrics_collector,
+    mock_cache,
+    mock_database,
+    mock_file_system,
+    mock_subprocess,
+)
+
+__all__ = [
+    "mock_http_config",
+    "mock_telemetry_config",
+    "mock_config_source",
+    "mock_event_emitter",
+    "mock_transport",
+    "mock_metrics_collector",
+    "mock_cache",
+    "mock_database",
+    "mock_file_system",
+    "mock_subprocess",
+]

provide/foundation/testing/common/fixtures.py

@@ -0,0 +1,236 @@
+"""
+Common Mock Objects and Fixtures.
+
+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
+
+import pytest
+
+from provide.foundation import TelemetryConfig
+from provide.foundation.logger.config.logging import LoggingConfig
+
+
+@pytest.fixture
+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,
+        retry_backoff_factor=0.5,
+        verify_ssl=True,
+        pool_connections=10,
+        pool_maxsize=100,
+        follow_redirects=True,
+        http2=True,
+        max_redirects=5,
+    )
+
+
+
+
+@pytest.fixture
+def mock_telemetry_config():
+    """
+    Standard telemetry configuration for testing.
+    
+    Returns:
+        TelemetryConfig with debug logging enabled.
+    """
+    return TelemetryConfig(
+        logging=LoggingConfig(default_level="DEBUG"),
+        globally_disabled=False,
+        service_name="test_service",
+        service_version="1.0.0",
+    )
+
+
+@pytest.fixture
+def mock_config_source():
+    """
+    Mock configuration source for testing config loading.
+    
+    Returns:
+        Mock that simulates a configuration source.
+    """
+    source = Mock()
+    source.load = Mock(return_value={"key": "value", "nested": {"key": "value"}})
+    source.exists = Mock(return_value=True)
+    source.reload = Mock()
+    source.watch = Mock()
+    source.priority = 100
+    source.name = "mock_source"
+    
+    return source
+
+
+@pytest.fixture
+def mock_event_emitter():
+    """
+    Mock event emitter for testing event-driven components.
+    
+    Returns:
+        Mock with emit, on, off methods.
+    """
+    emitter = Mock()
+    emitter.emit = Mock()
+    emitter.on = Mock()
+    emitter.off = Mock()
+    emitter.once = Mock()
+    emitter.listeners = Mock(return_value=[])
+    emitter.remove_all_listeners = Mock()
+    
+    return emitter
+
+
+@pytest.fixture
+def mock_transport():
+    """
+    Mock transport for testing network operations.
+    
+    Returns:
+        Mock transport with request/response methods.
+    """
+    transport = Mock()
+    transport.request = Mock(return_value={"status": 200, "data": {}})
+    transport.get = Mock(return_value={"status": 200, "data": {}})
+    transport.post = Mock(return_value={"status": 200, "data": {}})
+    transport.put = Mock(return_value={"status": 200, "data": {}})
+    transport.delete = Mock(return_value={"status": 204})
+    transport.close = Mock()
+    
+    return transport
+
+
+@pytest.fixture
+def mock_metrics_collector():
+    """
+    Mock metrics collector for testing instrumentation.
+    
+    Returns:
+        Mock with common metrics methods.
+    """
+    collector = Mock()
+    collector.increment = Mock()
+    collector.decrement = Mock()
+    collector.gauge = Mock()
+    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
+
+
+@pytest.fixture
+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}))
+    cache.delete = Mock(side_effect=lambda k: cache_data.pop(k, None))
+    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
+
+
+@pytest.fixture
+def mock_database():
+    """
+    Mock database connection for testing.
+    
+    Returns:
+        Mock with execute, fetch, commit, rollback methods.
+    """
+    db = Mock()
+    db.execute = Mock(return_value=Mock(rowcount=1))
+    db.fetch = Mock(return_value=[])
+    db.fetchone = Mock(return_value=None)
+    db.fetchall = Mock(return_value=[])
+    db.commit = Mock()
+    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
+
+
+@pytest.fixture
+def mock_file_system():
+    """
+    Mock file system operations.
+    
+    Returns:
+        Mock with read, write, exists, delete methods.
+    """
+    fs = Mock()
+    fs.read = Mock(return_value=b"content")
+    fs.write = Mock()
+    fs.exists = Mock(return_value=True)
+    fs.delete = Mock()
+    fs.mkdir = Mock()
+    fs.rmdir = Mock()
+    fs.list = Mock(return_value=[])
+    fs.stat = Mock(return_value=Mock(st_size=1024, st_mtime=0))
+    
+    return fs
+
+
+@pytest.fixture
+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", ""))
+    process.returncode = 0
+    process.pid = 12345
+    process.poll = Mock(return_value=0)
+    process.wait = Mock(return_value=0)
+    subprocess.Popen = Mock(return_value=process)
+    
+    return subprocess

provide/foundation/testing/file/__init__.py

@@ -0,0 +1,40 @@
+"""
+File testing fixtures for the provide-io ecosystem.
+
+Standard fixtures for file and directory operations that can be used
+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,
+    readonly_file,
+    temp_named_file,
+    temp_file_with_content,
+    temp_binary_file,
+    temp_csv_file,
+    temp_json_file,
+    temp_symlink,
+    temp_executable_file,
+)
+
+__all__ = [
+    "temp_directory",
+    "test_files_structure", 
+    "temp_file",
+    "binary_file",
+    "nested_directory_structure",
+    "empty_directory",
+    "readonly_file",
+    "temp_named_file",
+    "temp_file_with_content",
+    "temp_binary_file",
+    "temp_csv_file",
+    "temp_json_file",
+    "temp_symlink",
+    "temp_executable_file",
+]