fixturify 0.1.9__py3-none-any.whl

fixturify/http_d/_stubs/_httpcore.py

@@ -0,0 +1,269 @@
+"""Stubs for httpcore HTTP client.
+
+httpcore is the low-level transport layer used by httpx.
+By patching at this level, we intercept ALL httpx traffic,
+including async requests in FastAPI TestClient.
+"""
+
+import functools
+from typing import TYPE_CHECKING, Any
+
+from .._models import HttpRequest, HttpResponse
+from .._recorder import create_request_from_httpcore, create_response_from_httpcore
+
+if TYPE_CHECKING:
+    from .._mock_context import HttpMockContext
+
+
+def _make_request(httpcore_request: Any) -> HttpRequest:
+    """Create HttpRequest from httpcore Request object."""
+    # httpcore Request has: method, url, headers, stream
+    method = httpcore_request.method
+    if isinstance(method, bytes):
+        method = method.decode("ascii")
+    
+    url = bytes(httpcore_request.url).decode("ascii")
+    
+    # Read body from stream
+    body_parts = []
+    for chunk in httpcore_request.stream:
+        body_parts.append(chunk)
+    body = b"".join(body_parts)
+    
+    # Restore stream for potential real request
+    from httpcore._models import ByteStream
+    httpcore_request.stream = ByteStream(body)
+    
+    return create_request_from_httpcore(
+        method=method,
+        url=url,
+        content=body,
+        headers=httpcore_request.headers,
+    )
+
+
+async def _make_request_async(httpcore_request: Any) -> HttpRequest:
+    """Create HttpRequest from httpcore Request object (async version)."""
+    method = httpcore_request.method
+    if isinstance(method, bytes):
+        method = method.decode("ascii")
+    
+    url = bytes(httpcore_request.url).decode("ascii")
+    
+    # Read body from async stream
+    body_parts = []
+    async for chunk in httpcore_request.stream:
+        body_parts.append(chunk)
+    body = b"".join(body_parts)
+    
+    # Restore stream for potential real request
+    from httpcore._models import ByteStream
+    httpcore_request.stream = ByteStream(body)
+    
+    return create_request_from_httpcore(
+        method=method,
+        url=url,
+        content=body,
+        headers=httpcore_request.headers,
+    )
+
+
+def _build_response(response_model: HttpResponse) -> Any:
+    """Build httpcore Response from HttpResponse model."""
+    from httpcore import Response
+    import gzip
+    
+    # Get content encoding before filtering headers
+    content_encoding = response_model.headers.get(
+        "content-encoding", 
+        response_model.headers.get("Content-Encoding", "")
+    ).lower()
+    
+    # Build headers as list of tuples
+    headers = [
+        (k.encode("ascii"), v.encode("ascii"))
+        for k, v in response_model.headers.items()
+        # Skip headers that cause issues
+        if k.lower() not in ("transfer-encoding", "content-encoding")
+    ]
+    
+    body = response_model.get_body_bytes()
+    
+    # Decompress gzip body if needed (since we removed content-encoding header)
+    if content_encoding == "gzip" and body:
+        try:
+            body = gzip.decompress(body)
+        except (gzip.BadGzipFile, OSError):
+            pass  # Not actually gzip, use as-is
+    
+    return Response(
+        status=response_model.status,
+        headers=headers,
+        content=body,
+    )
+
+
+def _serialize_response(httpcore_response: Any) -> HttpResponse:
+    """Create HttpResponse from httpcore Response object.
+    
+    Handles gzip decompression before serialization to ensure
+    body is stored as readable text, not binary.
+    """
+    import gzip
+    from .._models import HttpResponse
+    
+    # Get body - should be available after read()/aread()
+    body_bytes = httpcore_response.content
+    
+    # Convert headers
+    headers_dict = {}
+    content_encoding = ""
+    for k, v in httpcore_response.headers:
+        key = k.decode() if isinstance(k, bytes) else k
+        val = v.decode() if isinstance(v, bytes) else v
+        headers_dict[key] = val
+        if key.lower() == "content-encoding":
+            content_encoding = val.lower()
+    
+    # If gzip, decompress body before serialization
+    if content_encoding == "gzip" and body_bytes:
+        try:
+            body_bytes = gzip.decompress(body_bytes)
+            # Remove content-encoding header since we decompressed
+            headers_dict = {
+                k: v for k, v in headers_dict.items()
+                if k.lower() != "content-encoding"
+            }
+        except (gzip.BadGzipFile, OSError):
+            pass  # Not actually gzip, use as-is
+    
+    # Determine content type
+    content_type = headers_dict.get("content-type", headers_dict.get("Content-Type", ""))
+    
+    # Try to decode as text/JSON
+    body_str = None
+    if body_bytes:
+        try:
+            body_str = body_bytes.decode("utf-8")
+        except UnicodeDecodeError:
+            # Binary content - store for file saving
+            resp = HttpResponse(
+                status=httpcore_response.status,
+                headers=headers_dict,
+                body=None,
+            )
+            resp._body_bytes = body_bytes
+            return resp
+    
+    return HttpResponse(
+        status=httpcore_response.status,
+        headers=headers_dict,
+        body=body_str,
+    )
+
+
+def _read_response_body(response: Any) -> bytes:
+    """Read response body using httpcore's built-in method.
+    
+    This properly sets response._content so response.content works.
+    """
+    return response.read()
+
+
+async def _read_response_body_async(response: Any) -> bytes:
+    """Read response body using httpcore's built-in method (async version).
+    
+    This properly sets response._content so response.content works.
+    """
+    return await response.aread()
+
+
+def make_sync_handler(mock_context: "HttpMockContext"):
+    """
+    Create patched handle_request for httpcore.ConnectionPool.
+    
+    This intercepts all synchronous httpx requests.
+    """
+    import httpcore
+    original = httpcore.ConnectionPool.handle_request
+    
+    @functools.wraps(original)
+    def handle_request(self, request):
+        # Build our request model
+        http_request = _make_request(request)
+        
+        # Check for excluded hosts
+        if mock_context.is_host_excluded(http_request.url):
+            from .._patcher import force_reset
+            with force_reset():
+                return original(self, request)
+        
+        # Playback mode - require a recorded response
+        if mock_context.mode == "playback":
+            return _build_response(mock_context.play_response(http_request))
+        
+        # Record mode - use recording if available
+        if mock_context.can_play_response_for(http_request):
+            return _build_response(mock_context.play_response(http_request))
+        
+        # Record mode - make real request and read body
+        from .._patcher import force_reset
+        with force_reset():
+            response = original(self, request)
+            # Read response body inside force_reset (uses same connection)
+            _read_response_body(response)
+        
+        # Record the interaction
+        resp_model = _serialize_response(response)
+        mock_context.record(http_request, resp_model)
+        
+        # Return new response with body as content (original has consumed stream)
+        return _build_response(resp_model)
+    
+    return handle_request
+
+
+def make_async_handler(mock_context: "HttpMockContext"):
+    """
+    Create patched handle_async_request for httpcore.AsyncConnectionPool.
+    
+    This intercepts all asynchronous httpx requests, including those
+    made from FastAPI endpoints via TestClient.
+    """
+    import httpcore
+    original = httpcore.AsyncConnectionPool.handle_async_request
+    
+    @functools.wraps(original)
+    async def handle_async_request(self, request):
+        # Build our request model
+        http_request = await _make_request_async(request)
+        
+        # Check for excluded hosts
+        if mock_context.is_host_excluded(http_request.url):
+            from .._patcher import force_reset
+            with force_reset():
+                return await original(self, request)
+        
+        # Playback mode - require a recorded response
+        if mock_context.mode == "playback":
+            return _build_response(mock_context.play_response(http_request))
+        
+        # Record mode - use recording if available
+        if mock_context.can_play_response_for(http_request):
+            return _build_response(mock_context.play_response(http_request))
+        
+        # Record mode - make real request and read body
+        from .._patcher import force_reset
+        with force_reset():
+            response = await original(self, request)
+            # Read response body inside force_reset (uses same connection)
+            await _read_response_body_async(response)
+        
+        # Record the interaction
+        resp_model = _serialize_response(response)
+        mock_context.record(http_request, resp_model)
+        
+        # Return new response with body as content (original has consumed stream)
+        return _build_response(resp_model)
+    
+    return handle_async_request

fixturify/http_d/_stubs/_tornado.py

@@ -0,0 +1,95 @@
+"""Stubs for tornado HTTP client.
+
+Tornado has its own async HTTP client that doesn't use http.client,
+so it needs its own patching strategy.
+"""
+
+import functools
+from typing import TYPE_CHECKING, Any
+
+from .._models import HttpResponse
+from .._recorder import create_request_from_tornado, create_response_from_tornado
+
+if TYPE_CHECKING:
+    from .._mock_context import HttpMockContext
+
+
+class MockTornadoResponse:
+    """Mock tornado HTTPResponse for playback."""
+    
+    def __init__(self, request: Any, response_model: HttpResponse):
+        from tornado.httputil import HTTPHeaders
+        
+        self.request = request
+        self._response_model = response_model
+        
+        self.code = response_model.status
+        self.reason = self._get_reason(response_model.status)
+        self.body = response_model.get_body_bytes()
+        self.headers = HTTPHeaders(response_model.headers)
+        self.buffer = None
+        self.effective_url = request.url
+        self.error = None
+        self.request_time = 0.0
+        self.start_time = 0.0
+        self.time_info = {}
+    
+    @staticmethod
+    def _get_reason(status: int) -> str:
+        from http import HTTPStatus
+        try:
+            return HTTPStatus(status).phrase
+        except ValueError:
+            return "Unknown"
+    
+    def rethrow(self):
+        """Raise error if request failed."""
+        if self.error:
+            raise self.error
+
+
+def make_tornado_fetch_handler(mock_context: "HttpMockContext", original_fetch_impl):
+    """
+    Create patched fetch_impl for tornado HTTP clients.
+    
+    Works for both SimpleAsyncHTTPClient and CurlAsyncHTTPClient.
+    Note: fetch_impl is NOT a coroutine - it uses callbacks.
+    """
+    
+    @functools.wraps(original_fetch_impl)
+    def fetch_impl(self, request, callback):
+        """Patched fetch implementation."""
+        # Create request model
+        http_request = create_request_from_tornado(request)
+        
+        # Check for excluded hosts
+        if mock_context.is_host_excluded(http_request.url):
+            from .._patcher import force_reset
+            with force_reset():
+                return original_fetch_impl(self, request, callback)
+        
+        # In playback mode, return recorded response
+        if mock_context.mode == "playback":
+            response_model = mock_context.play_response(http_request)
+            mock_response = MockTornadoResponse(request, response_model)
+            
+            # Call callback with mock response via IOLoop
+            from tornado.ioloop import IOLoop
+            IOLoop.current().add_callback(callback, mock_response)
+            return
+        
+        # Record mode - wrap the callback to record the response
+        def recording_callback(response):
+            # Create response model and record
+            resp_model = create_response_from_tornado(response)
+            mock_context.record(http_request, resp_model)
+            
+            # Call original callback
+            if callback:
+                callback(response)
+        
+        from .._patcher import force_reset
+        with force_reset():
+            return original_fetch_impl(self, request, recording_callback)
+    
+    return fetch_impl

fixturify/http_d/_utils.py

@@ -0,0 +1,194 @@
+"""Utility functions for HTTP recording and playback."""
+
+import json
+import mimetypes
+from typing import Any, Optional, Tuple, Union
+
+
+# Content types that should be stored as separate binary files
+BINARY_CONTENT_TYPES = (
+    "image/",
+    "audio/",
+    "video/",
+    "application/octet-stream",
+    "application/pdf",
+    "application/zip",
+    "application/gzip",
+    "application/x-tar",
+    "application/x-rar",
+    "application/x-7z-compressed",
+    "application/vnd.ms-excel",
+    "application/vnd.openxmlformats",
+    "application/msword",
+    "font/",
+)
+
+
+def normalize_content_type(content_type: Union[str, bytes, None]) -> str:
+    """Normalize content type to string."""
+    if content_type is None:
+        return ""
+    if isinstance(content_type, bytes):
+        return content_type.decode("utf-8", errors="ignore")
+    return content_type
+
+
+def is_text_content_type(content_type: Union[str, bytes]) -> bool:
+    """Check if content type indicates text content."""
+    text_types = (
+        "text/",
+        "application/json",
+        "application/xml",
+        "application/javascript",
+        "application/x-www-form-urlencoded",
+    )
+    content_str = normalize_content_type(content_type)
+    return any(t in content_str.lower() for t in text_types)
+
+
+def is_json_content_type(content_type: Union[str, bytes]) -> bool:
+    """Check if content type indicates JSON content."""
+    content_str = normalize_content_type(content_type)
+    return "application/json" in content_str.lower()
+
+
+def is_binary_content_type(content_type: Union[str, bytes]) -> bool:
+    """Check if content type indicates binary content that should be stored as file."""
+    content_str = normalize_content_type(content_type)
+    content_lower = content_str.lower()
+    return any(t in content_lower for t in BINARY_CONTENT_TYPES)
+
+
+def try_parse_json(content: str) -> Any:
+    """Try to parse string as JSON, return parsed or original string."""
+    try:
+        return json.loads(content)
+    except (json.JSONDecodeError, TypeError):
+        return content
+
+
+def get_file_extension(content_type: Union[str, bytes]) -> str:
+    """Get appropriate file extension for a content type."""
+    extension_map = {
+        "application/json": ".json",
+        "application/pdf": ".pdf",
+        "application/zip": ".zip",
+        "application/gzip": ".gz",
+        "application/xml": ".xml",
+        "text/html": ".html",
+        "text/plain": ".txt",
+        "text/css": ".css",
+        "text/javascript": ".js",
+        "image/jpeg": ".jpg",
+        "image/png": ".png",
+        "image/gif": ".gif",
+        "image/webp": ".webp",
+        "image/svg+xml": ".svg",
+        "audio/mpeg": ".mp3",
+        "audio/wav": ".wav",
+        "video/mp4": ".mp4",
+        "video/webm": ".webm",
+    }
+
+    content_str = normalize_content_type(content_type)
+    content_lower = content_str.lower().split(";")[0].strip()
+    
+    if content_lower in extension_map:
+        return extension_map[content_lower]
+
+    ext = mimetypes.guess_extension(content_lower)
+    if ext:
+        return ext
+
+    return ".bin"
+
+
+def serialize_body(
+    body: Optional[Union[bytes, str]],
+    content_type: Union[str, bytes] = "",
+) -> Tuple[Any, Optional[str], bool]:
+    """
+    Serialize body for storage.
+
+    For JSON content: returns parsed JSON object (not stringified)
+    For text content: returns string
+    For binary content: returns raw bytes and flag to save as file
+
+    Args:
+        body: Request or response body (bytes, string, or BytesIO)
+        content_type: Content-Type header value (str or bytes)
+
+    Returns:
+        Tuple of (body_value, encoding, is_binary_file)
+        - For text/JSON: (value, None, False)
+        - For binary: (bytes, None, True)
+    """
+    if body is None:
+        return None, None, False
+
+    # Handle BytesIO and other file-like objects
+    if hasattr(body, "read"):
+        file_obj = body
+        body = file_obj.read()
+        if hasattr(file_obj, "seek"):
+            file_obj.seek(0)
+
+    # Normalize content_type to string
+    content_type = normalize_content_type(content_type)
+
+    # Check if this should be stored as a binary file
+    if is_binary_content_type(content_type):
+        if isinstance(body, bytes):
+            return body, None, True
+        elif isinstance(body, str):
+            return body.encode("utf-8"), None, True
+        else:
+            return str(body).encode("utf-8"), None, True
+
+    # Convert bytes to string if needed
+    if isinstance(body, bytes):
+        if is_text_content_type(content_type) or not content_type:
+            try:
+                body_str = body.decode("utf-8")
+            except UnicodeDecodeError:
+                return body, None, True
+        else:
+            try:
+                body_str = body.decode("utf-8")
+            except UnicodeDecodeError:
+                return body, None, True
+    else:
+        body_str = body
+
+    # Empty body
+    if not body_str:
+        return None, None, False
+
+    # For JSON content, parse and store as native JSON
+    if is_json_content_type(content_type):
+        return try_parse_json(body_str), None, False
+
+    # Return as string for non-JSON text content
+    return body_str, None, False
+
+
+def normalize_headers(headers: Any) -> dict:
+    """
+    Normalize headers to a dict with string keys and values.
+    
+    Handles:
+    - Dict with bytes keys/values
+    - List of tuples
+    - Dict-like objects with items() method
+    """
+    result = {}
+    if headers is None:
+        return result
+    
+    items = headers.items() if hasattr(headers, "items") else headers
+    for k, v in items:
+        key = k.decode("utf-8") if isinstance(k, bytes) else str(k)
+        val = v.decode("utf-8") if isinstance(v, bytes) else str(v)
+        result[key] = val
+    
+    return result

fixturify/json_assert/__init__.py

@@ -0,0 +1,13 @@
+"""JsonAssert module for JSON comparison assertions in testing."""
+
+# Check for deepdiff dependency at import time
+try:
+    import deepdiff  # noqa: F401
+except ImportError:
+    raise ImportError(
+        "JsonAssert requires 'deepdiff'. Install it with: pip install pytools[json-assert]"
+    )
+
+from fixturify.json_assert._assert import JsonAssert
+
+__all__ = ["JsonAssert"]

fixturify/json_assert/_actual_saver.py

@@ -0,0 +1,67 @@
+"""Actual saver for saving actual JSON data on assertion failure."""
+
+import json
+from pathlib import Path
+from typing import Tuple, Union
+
+from fixturify._utils._constants import ENCODING
+
+
+class _ActualSaver:
+    """Saves actual JSON data to ACTUAL folder on assertion failure."""
+
+    ACTUAL_FOLDER_NAME = "ACTUAL"
+
+    @staticmethod
+    def save(
+        actual_data: Union[dict, list], expected_file_path: Path
+    ) -> Tuple[Path, bool]:
+        """
+        Save actual JSON data to ACTUAL folder, mirroring the expected file path.
+
+        Given expected file: /path/to/fixtures/expected_user.json
+        Creates actual file:  /path/to/fixtures/ACTUAL/expected_user.json
+
+        Args:
+            actual_data: The normalized actual data (dict or list)
+            expected_file_path: Absolute path to the expected JSON file
+
+        Returns:
+            Tuple of (path to saved file, success flag).
+            The path is returned even if save fails so it can be included
+            in error messages.
+
+        Note:
+            - Creates ACTUAL folder if it doesn't exist
+            - Overwrites existing actual file if present
+            - Saves JSON with indent=2 for readability
+        """
+        actual_path = _ActualSaver._get_actual_path(expected_file_path)
+
+        try:
+            # Create ACTUAL directory if it doesn't exist
+            actual_path.parent.mkdir(parents=True, exist_ok=True)
+
+            # Write actual data as JSON
+            with open(actual_path, "w", encoding=ENCODING) as f:
+                json.dump(actual_data, f, indent=2, ensure_ascii=False)
+
+            return actual_path, True
+
+        except Exception:
+            # If save fails (permissions, disk full, etc.), return failure flag
+            # so the error message can indicate the actual data could not be saved
+            return actual_path, False
+
+    @staticmethod
+    def _get_actual_path(expected_file_path: Path) -> Path:
+        """
+        Calculate the ACTUAL folder path based on expected file path.
+
+        Example:
+            Input:  /project/tests/fixtures/expected_user.json
+            Output: /project/tests/fixtures/ACTUAL/expected_user.json
+        """
+        expected_dir = expected_file_path.parent
+        actual_dir = expected_dir / _ActualSaver.ACTUAL_FOLDER_NAME
+        return actual_dir / expected_file_path.name