http-snapshot 0.1.0__tar.gz

http_snapshot-0.1.0/PKG-INFO

@@ -0,0 +1,241 @@
+Metadata-Version: 2.4
+Name: http-snapshot
+Version: 0.1.0
+Summary: http-snapshot is a pytest plugin that snapshots requests made with popular Python HTTP clients.
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Provides-Extra: httpx
+Requires-Dist: httpx>=0.28.1; extra == "httpx"
+Provides-Extra: requests
+Requires-Dist: requests>=2.32.5; extra == "requests"
+
+# http-snapshot
+
+`http-snapshot` is a pytest plugin that captures and snapshots HTTP requests/responses made with popular Python HTTP clients like `httpx` and `requests`. It uses [inline-snapshot](https://github.com/15r10nk/inline-snapshot) to store HTTP interactions as JSON files, enabling fast and reliable HTTP testing without making actual network calls.
+
+## Features
+
+- 🚀 **Support for multiple HTTP clients**: `httpx` (async) and `requests` (sync)
+- 📸 **Automatic HTTP interaction capture**: Records both requests and responses
+- 🔒 **Security-aware**: Automatically excludes sensitive headers like authorization and cookies
+- ⚙️ **Configurable**: Control what gets captured and what gets excluded
+- 🧪 **pytest integration**: Works seamlessly with your existing pytest test suite
+- 📁 **External snapshots**: Stores snapshots in organized JSON files
+
+## Installation
+
+```bash
+pip install http-snapshot
+```
+
+For specific HTTP client support:
+
+```bash
+# For httpx support
+pip install http-snapshot[httpx]
+
+# For requests support
+pip install http-snapshot[requests]
+
+# For both
+pip install http-snapshot[httpx,requests]
+```
+
+## Quick Start
+
+### Using with httpx (async)
+
+```python
+import httpx
+import pytest
+import inline_snapshot
+
+@pytest.mark.anyio
+@pytest.mark.parametrize(
+    "http_snapshot",
+    [inline_snapshot.external("uuid:my-test-snapshot.json")],
+)
+async def test_api_call(snapshot_httpx_client: httpx.AsyncClient) -> None:
+    # This will be captured on first run, replayed on subsequent runs
+    response = await snapshot_httpx_client.get("https://api.example.com/users")
+    assert response.status_code == 200
+    assert "users" in response.json()
+```
+
+### Using with requests (sync)
+
+```python
+import requests
+import pytest
+import inline_snapshot
+
+@pytest.mark.parametrize(
+    "http_snapshot",
+    [inline_snapshot.external("uuid:my-test-snapshot.json")],
+)
+def test_api_call(snapshot_requests_session: requests.Session) -> None:
+    # This will be captured on first run, replayed on subsequent runs
+    response = snapshot_requests_session.get("https://api.example.com/users")
+    assert response.status_code == 200
+    assert "users" in response.json()
+```
+
+## How It Works
+
+### Live Mode vs Replay Mode
+
+The plugin operates in two modes:
+
+1. **Live Mode**: When `HTTP_SNAPSHOT_LIVE=1` is set, actual HTTP requests are made and responses are captured
+2. **Replay Mode**: When not in live mode, previously captured responses are replayed
+
+### Running in Live Mode
+
+```bash
+# Capture new snapshots
+HTTP_SNAPSHOT_LIVE=1 pytest tests/
+
+# Replay existing snapshots (default)
+pytest tests/
+```
+
+## Configuration Options
+
+You can customize what gets captured using `SnapshotSerializerOptions`:
+
+```python
+import pytest
+import inline_snapshot
+from http_snapshot._serializer import SnapshotSerializerOptions
+
+@pytest.mark.parametrize(
+    "http_snapshot, http_snapshot_serializer_options",
+    [
+        (
+            inline_snapshot.external("uuid:my-test-snapshot.json"),
+            SnapshotSerializerOptions(
+                exclude_request_headers=["X-API-Key"],
+                include_request=True,  # Include request details in snapshot
+            ),
+        ),
+    ],
+)
+def test_with_custom_options(
+    snapshot_requests_session: requests.Session,
+    http_snapshot_serializer_options: SnapshotSerializerOptions,
+) -> None:
+    response = snapshot_requests_session.get(
+        "https://api.example.com/protected",
+        headers={"X-API-Key": "secret-key"}
+    )
+    assert response.status_code == 200
+```
+
+### Available Options
+
+- `include_request`: Whether to include request details in snapshots (default: `True`)
+- `exclude_request_headers`: List of request headers to exclude from snapshots
+- `exclude_response_headers`: List of response headers to exclude from snapshots
+
+By default, the following sensitive headers are always excluded:
+
+- **Request**: `authorization`, `cookie`
+- **Response**: `set-cookie`, `www-authenticate`, `proxy-authenticate`, `authentication-info`, `proxy-authentication-info`, `transfer-encoding`, `content-encoding`
+
+## Snapshot Format
+
+Snapshots are stored as JSON files with the following structure:
+
+```json
+[
+  {
+    "request": {
+      "method": "GET",
+      "url": "https://api.example.com/users",
+      "headers": {
+        "host": "api.example.com",
+        "accept": "*/*",
+        "accept-encoding": "gzip, deflate",
+        "connection": "keep-alive",
+        "user-agent": "python-httpx/0.28.1"
+      },
+      "body": ""
+    },
+    "response": {
+      "status_code": 200,
+      "headers": {
+        "date": "Thu, 21 Aug 2025 15:49:45 GMT",
+        "content-type": "application/json; charset=utf-8",
+        "connection": "keep-alive",
+        "server": "nginx/1.18.0"
+      },
+      "body": "{\n  \"users\": [\n    {\n      \"id\": 1,\n      \"name\": \"John Doe\",\n      \"email\": \"john@example.com\"\n    }\n  ]\n}"
+    }
+  }
+]
+```
+
+### Content Encoding
+
+The plugin intelligently handles different content types:
+
+- **JSON**: Formatted with proper indentation for readability
+- **Text**: Stored as UTF-8 strings
+- **Binary**: Base64 encoded
+
+## Advanced Examples
+
+### Testing API with Multiple Requests
+
+```python
+@pytest.mark.anyio
+@pytest.mark.parametrize(
+    "http_snapshot",
+    [inline_snapshot.external("uuid:multi-request-test.json")],
+)
+async def test_multiple_requests(snapshot_httpx_client: httpx.AsyncClient) -> None:
+    # Create a user
+    create_response = await snapshot_httpx_client.post(
+        "https://api.example.com/users",
+        json={"name": "Alice", "email": "alice@example.com"}
+    )
+    assert create_response.status_code == 201
+    user_id = create_response.json()["id"]
+
+    # Fetch the user
+    get_response = await snapshot_httpx_client.get(
+        f"https://api.example.com/users/{user_id}"
+    )
+    assert get_response.status_code == 200
+    assert get_response.json()["name"] == "Alice"
+```
+
+### Testing with Authentication
+
+```python
+@pytest.mark.parametrize(
+    "http_snapshot, http_snapshot_serializer_options",
+    [
+        (
+            inline_snapshot.external("uuid:auth-test.json"),
+            SnapshotSerializerOptions(exclude_request_headers=["Authorization"]),
+        ),
+    ],
+)
+def test_authenticated_request(
+    snapshot_requests_session: requests.Session,
+    http_snapshot_serializer_options,
+) -> None:
+    # The Authorization header will be excluded from the snapshot
+    response = snapshot_requests_session.get(
+        "https://api.example.com/profile",
+        headers={"Authorization": "Bearer secret-token"}
+    )
+    assert response.status_code == 200
+```
+
+## Best Practices
+
+1. **Exclude sensitive data**: Always exclude headers containing secrets, tokens, or personal data
+2. **Review snapshots**: Check generated snapshot files into version control and review changes
+3. **Use live mode sparingly**: Only run in live mode when you need to update snapshots

http_snapshot-0.1.0/README.md

@@ -0,0 +1,230 @@
+# http-snapshot
+
+`http-snapshot` is a pytest plugin that captures and snapshots HTTP requests/responses made with popular Python HTTP clients like `httpx` and `requests`. It uses [inline-snapshot](https://github.com/15r10nk/inline-snapshot) to store HTTP interactions as JSON files, enabling fast and reliable HTTP testing without making actual network calls.
+
+## Features
+
+- 🚀 **Support for multiple HTTP clients**: `httpx` (async) and `requests` (sync)
+- 📸 **Automatic HTTP interaction capture**: Records both requests and responses
+- 🔒 **Security-aware**: Automatically excludes sensitive headers like authorization and cookies
+- ⚙️ **Configurable**: Control what gets captured and what gets excluded
+- 🧪 **pytest integration**: Works seamlessly with your existing pytest test suite
+- 📁 **External snapshots**: Stores snapshots in organized JSON files
+
+## Installation
+
+```bash
+pip install http-snapshot
+```
+
+For specific HTTP client support:
+
+```bash
+# For httpx support
+pip install http-snapshot[httpx]
+
+# For requests support
+pip install http-snapshot[requests]
+
+# For both
+pip install http-snapshot[httpx,requests]
+```
+
+## Quick Start
+
+### Using with httpx (async)
+
+```python
+import httpx
+import pytest
+import inline_snapshot
+
+@pytest.mark.anyio
+@pytest.mark.parametrize(
+    "http_snapshot",
+    [inline_snapshot.external("uuid:my-test-snapshot.json")],
+)
+async def test_api_call(snapshot_httpx_client: httpx.AsyncClient) -> None:
+    # This will be captured on first run, replayed on subsequent runs
+    response = await snapshot_httpx_client.get("https://api.example.com/users")
+    assert response.status_code == 200
+    assert "users" in response.json()
+```
+
+### Using with requests (sync)
+
+```python
+import requests
+import pytest
+import inline_snapshot
+
+@pytest.mark.parametrize(
+    "http_snapshot",
+    [inline_snapshot.external("uuid:my-test-snapshot.json")],
+)
+def test_api_call(snapshot_requests_session: requests.Session) -> None:
+    # This will be captured on first run, replayed on subsequent runs
+    response = snapshot_requests_session.get("https://api.example.com/users")
+    assert response.status_code == 200
+    assert "users" in response.json()
+```
+
+## How It Works
+
+### Live Mode vs Replay Mode
+
+The plugin operates in two modes:
+
+1. **Live Mode**: When `HTTP_SNAPSHOT_LIVE=1` is set, actual HTTP requests are made and responses are captured
+2. **Replay Mode**: When not in live mode, previously captured responses are replayed
+
+### Running in Live Mode
+
+```bash
+# Capture new snapshots
+HTTP_SNAPSHOT_LIVE=1 pytest tests/
+
+# Replay existing snapshots (default)
+pytest tests/
+```
+
+## Configuration Options
+
+You can customize what gets captured using `SnapshotSerializerOptions`:
+
+```python
+import pytest
+import inline_snapshot
+from http_snapshot._serializer import SnapshotSerializerOptions
+
+@pytest.mark.parametrize(
+    "http_snapshot, http_snapshot_serializer_options",
+    [
+        (
+            inline_snapshot.external("uuid:my-test-snapshot.json"),
+            SnapshotSerializerOptions(
+                exclude_request_headers=["X-API-Key"],
+                include_request=True,  # Include request details in snapshot
+            ),
+        ),
+    ],
+)
+def test_with_custom_options(
+    snapshot_requests_session: requests.Session,
+    http_snapshot_serializer_options: SnapshotSerializerOptions,
+) -> None:
+    response = snapshot_requests_session.get(
+        "https://api.example.com/protected",
+        headers={"X-API-Key": "secret-key"}
+    )
+    assert response.status_code == 200
+```
+
+### Available Options
+
+- `include_request`: Whether to include request details in snapshots (default: `True`)
+- `exclude_request_headers`: List of request headers to exclude from snapshots
+- `exclude_response_headers`: List of response headers to exclude from snapshots
+
+By default, the following sensitive headers are always excluded:
+
+- **Request**: `authorization`, `cookie`
+- **Response**: `set-cookie`, `www-authenticate`, `proxy-authenticate`, `authentication-info`, `proxy-authentication-info`, `transfer-encoding`, `content-encoding`
+
+## Snapshot Format
+
+Snapshots are stored as JSON files with the following structure:
+
+```json
+[
+  {
+    "request": {
+      "method": "GET",
+      "url": "https://api.example.com/users",
+      "headers": {
+        "host": "api.example.com",
+        "accept": "*/*",
+        "accept-encoding": "gzip, deflate",
+        "connection": "keep-alive",
+        "user-agent": "python-httpx/0.28.1"
+      },
+      "body": ""
+    },
+    "response": {
+      "status_code": 200,
+      "headers": {
+        "date": "Thu, 21 Aug 2025 15:49:45 GMT",
+        "content-type": "application/json; charset=utf-8",
+        "connection": "keep-alive",
+        "server": "nginx/1.18.0"
+      },
+      "body": "{\n  \"users\": [\n    {\n      \"id\": 1,\n      \"name\": \"John Doe\",\n      \"email\": \"john@example.com\"\n    }\n  ]\n}"
+    }
+  }
+]
+```
+
+### Content Encoding
+
+The plugin intelligently handles different content types:
+
+- **JSON**: Formatted with proper indentation for readability
+- **Text**: Stored as UTF-8 strings
+- **Binary**: Base64 encoded
+
+## Advanced Examples
+
+### Testing API with Multiple Requests
+
+```python
+@pytest.mark.anyio
+@pytest.mark.parametrize(
+    "http_snapshot",
+    [inline_snapshot.external("uuid:multi-request-test.json")],
+)
+async def test_multiple_requests(snapshot_httpx_client: httpx.AsyncClient) -> None:
+    # Create a user
+    create_response = await snapshot_httpx_client.post(
+        "https://api.example.com/users",
+        json={"name": "Alice", "email": "alice@example.com"}
+    )
+    assert create_response.status_code == 201
+    user_id = create_response.json()["id"]
+
+    # Fetch the user
+    get_response = await snapshot_httpx_client.get(
+        f"https://api.example.com/users/{user_id}"
+    )
+    assert get_response.status_code == 200
+    assert get_response.json()["name"] == "Alice"
+```
+
+### Testing with Authentication
+
+```python
+@pytest.mark.parametrize(
+    "http_snapshot, http_snapshot_serializer_options",
+    [
+        (
+            inline_snapshot.external("uuid:auth-test.json"),
+            SnapshotSerializerOptions(exclude_request_headers=["Authorization"]),
+        ),
+    ],
+)
+def test_authenticated_request(
+    snapshot_requests_session: requests.Session,
+    http_snapshot_serializer_options,
+) -> None:
+    # The Authorization header will be excluded from the snapshot
+    response = snapshot_requests_session.get(
+        "https://api.example.com/profile",
+        headers={"Authorization": "Bearer secret-token"}
+    )
+    assert response.status_code == 200
+```
+
+## Best Practices
+
+1. **Exclude sensitive data**: Always exclude headers containing secrets, tokens, or personal data
+2. **Review snapshots**: Check generated snapshot files into version control and review changes
+3. **Use live mode sparingly**: Only run in live mode when you need to update snapshots

http_snapshot-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[project]
+name = "http-snapshot"
+version = "0.1.0"
+description = "http-snapshot is a pytest plugin that snapshots requests made with popular Python HTTP clients."
+readme = "README.md"
+requires-python = ">=3.9"
+
+
+[dependency-groups]
+dev = [
+    "anyio>=4.10.0",
+    "httpx>=0.28.1",
+    "inline-snapshot>=0.27.2",
+    "mypy>=1.17.1",
+    "pytest>=8.4.1",
+    "ruff>=0.12.10",
+]
+
+[tool.mypy]
+strict = true
+
+[project.entry-points.pytest11]
+http_snapshot = "http_snapshot._pytest_plugin"
+
+[project.optional-dependencies]
+httpx = ["httpx>=0.28.1"]
+requests = ["requests>=2.32.5"]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]

http_snapshot-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

http_snapshot-0.1.0/src/http_snapshot/_integrations/_httpx.py

@@ -0,0 +1,76 @@
+from typing import Any, assert_never, overload
+import httpx
+from inline_snapshot import Snapshot
+
+from .._models import Request, Response
+from .._serializer import snapshot_to_internal
+
+
+@overload
+def httpx_to_internal(
+    model: httpx.Request,
+) -> Request: ...
+
+
+@overload
+def httpx_to_internal(
+    model: httpx.Response,
+) -> Response: ...
+
+
+def httpx_to_internal(
+    model: httpx.Request | httpx.Response,
+) -> Request | Response:
+    if isinstance(model, httpx.Request):
+        return Request(
+            method=model.method,
+            url=str(model.url),
+            headers=dict(model.headers),
+            body=model.content,
+        )
+    elif isinstance(model, httpx.Response):
+        model.aiter_bytes
+        return Response(
+            status_code=model.status_code,
+            headers=dict(model.headers),
+            body=model.content,
+        )
+    else:
+        assert_never(model, "Unsupported model type for serialization")
+
+
+def internal_to_httpx(model: Response) -> httpx.Response:
+    return httpx.Response(
+        status_code=model.status_code,
+        headers=model.headers,
+        content=model.body,
+    )
+
+
+class SnapshotTransport(httpx.AsyncBaseTransport):
+    def __init__(
+        self,
+        next_transport: httpx.AsyncBaseTransport,
+        snapshot: Snapshot[list[dict[str, Any]]],
+        is_live: bool,
+    ) -> None:
+        self.is_live = is_live
+        self.next_transport = next_transport
+        self.collected_pairs: list[tuple[Request, Response]] = []
+        self.snapshot = snapshot
+        self._request_number = -1
+
+    async def handle_async_request(self, request: httpx.Request) -> httpx.Response:
+        self._request_number += 1
+
+        if self.is_live:
+            # In live mode, we would normally send the request to the server.
+            response = await self.next_transport.handle_async_request(request)
+            await response.aread()
+            self.collected_pairs.append(
+                (httpx_to_internal(request), httpx_to_internal(response))
+            )
+        else:
+            internal = snapshot_to_internal(self.snapshot)
+            response = internal_to_httpx(internal[self._request_number])
+        return response

http_snapshot-0.1.0/src/http_snapshot/_integrations/_requests.py

@@ -0,0 +1,105 @@
+from typing import Any, Mapping, assert_never, overload
+from inline_snapshot import Snapshot
+from requests.adapters import HTTPAdapter
+from requests.models import PreparedRequest, Response
+from http_snapshot._models import Request, Response as InternalResponse
+from http_snapshot._serializer import snapshot_to_internal
+from urllib3.util.retry import Retry as Retry
+
+
+@overload
+def requests_to_internal(
+    model: PreparedRequest,
+) -> Request: ...
+
+
+@overload
+def requests_to_internal(
+    model: Response,
+) -> InternalResponse: ...
+
+
+def requests_to_internal(
+    model: PreparedRequest | Response,
+) -> Request | InternalResponse:
+    if isinstance(model, PreparedRequest):
+        body: bytes
+        if isinstance(model.body, str):
+            body = model.body.encode("utf-8")
+        elif isinstance(model.body, bytes):
+            body = body
+        else:
+            body = b""
+        return Request(
+            method=model.method,
+            url=str(model.url),
+            headers=dict(model.headers),
+            body=body,
+        )
+    elif isinstance(model, Response):
+        content = model.content
+        if not isinstance(content, bytes):
+            raise RuntimeError(
+                f"Expected response content to be bytes, got {type(content).__name__}"
+            )
+        return InternalResponse(
+            status_code=model.status_code,
+            headers=dict(model.headers),
+            body=content,
+        )
+    else:
+        assert_never(model, "Unsupported model type for serialization")
+
+
+def internal_to_requests(model: InternalResponse, adapter: HTTPAdapter) -> Response:
+    response = Response()
+
+    response.status_code = model.status_code
+    for key, value in model.headers.items():
+        response.headers[key] = value
+    response._content = model.body
+    return response
+
+
+class SnapshotAdapter(HTTPAdapter):
+    """
+    A custom HTTPAdapter that can be used with requests to capture HTTP interactions
+    for snapshot testing.
+    """
+
+    def __init__(
+        self,
+        snapshot: Snapshot[list[dict[str, Any]]],
+        pool_connections: int = 10,
+        pool_maxsize: int = 10,
+        max_retries: Retry | int | None = 0,
+        pool_block: bool = False,
+        is_live: bool = False,
+    ) -> None:
+        super().__init__(pool_connections, pool_maxsize, max_retries, pool_block)
+        self.snapshot = snapshot
+        self.is_live = is_live
+        self.collected_pairs: list[tuple[PreparedRequest, Response]] = []
+        self._request_number = -1
+
+    def send(
+        self,
+        request: PreparedRequest,
+        stream: bool = False,
+        timeout: None | float | tuple[float, float] | tuple[float, None] = None,
+        verify: bool | str = True,
+        cert: None | bytes | str | tuple[bytes | str, bytes | str] = None,
+        proxies: Mapping[str, str] | None = None,
+    ) -> Response:
+        self._request_number += 1
+
+        if self.is_live:
+            response = super().send(request, False, timeout, verify, cert, proxies)
+            self.collected_pairs.append(
+                (requests_to_internal(request), requests_to_internal(response))
+            )
+        else:
+            internal = snapshot_to_internal(self.snapshot)
+            response = internal_to_requests(internal[self._request_number], self)
+
+        return response

http_snapshot-0.1.0/src/http_snapshot/_models.py

@@ -0,0 +1,17 @@
+from dataclasses import dataclass
+from typing import Mapping
+
+
+@dataclass
+class Request:
+    method: str
+    url: str
+    headers: Mapping[str, str]
+    body: bytes
+
+
+@dataclass
+class Response:
+    status_code: int
+    headers: Mapping[str, str]
+    body: bytes

http_snapshot-0.1.0/src/http_snapshot/_pytest_plugin.py

@@ -0,0 +1,84 @@
+import os
+from typing import Any, Iterator
+import httpx
+import pytest
+import inline_snapshot
+
+from ._serializer import SnapshotSerializerOptions, internal_to_snapshot
+
+
+try:
+    import httpx
+except ImportError:
+    httpx: Any = None
+
+try:
+    import requests
+except ImportError:
+    requests: Any = None
+
+
+def is_live() -> bool:
+    return os.getenv("HTTP_SNAPSHOT_LIVE") == "1"
+
+
+@pytest.fixture
+def http_snapshot_serializer_options() -> SnapshotSerializerOptions:
+    return SnapshotSerializerOptions()
+
+
+@pytest.fixture
+def snapshot_httpx_client(
+    http_snapshot: inline_snapshot.Snapshot[Any],
+    http_snapshot_serializer_options: SnapshotSerializerOptions,
+) -> Iterator[httpx.AsyncClient]:
+    if httpx is None:
+        raise ImportError(
+            "httpx is not installed. Please install http-snapshot with httpx feature [pip install http-snapshot[httpx]]"
+        )
+    from ._integrations._httpx import SnapshotTransport
+
+    snapshot_transport = SnapshotTransport(
+        httpx.AsyncHTTPTransport(),
+        http_snapshot,
+        is_live=is_live(),
+    )
+    yield httpx.AsyncClient(
+        transport=snapshot_transport,
+    )
+
+    if snapshot_transport.is_live:
+        assert (
+            internal_to_snapshot(
+                snapshot_transport.collected_pairs, http_snapshot_serializer_options
+            )
+            == snapshot_transport.snapshot
+        )
+
+
+@pytest.fixture
+def snapshot_requests_session(
+    http_snapshot: inline_snapshot.Snapshot[Any],
+    http_snapshot_serializer_options: SnapshotSerializerOptions,
+) -> Iterator[requests.Session]:
+    if requests is None:
+        raise ImportError(
+            "requests is not installed. Please install http-snapshot with requests feature [pip install http-snapshot[requests]]"
+        )
+
+    from ._integrations._requests import SnapshotAdapter
+
+    with requests.Session() as session:
+        adapter = SnapshotAdapter(snapshot=http_snapshot, is_live=is_live())
+        session.mount("http://", adapter)
+        session.mount("https://", adapter)
+
+        yield session
+
+        if adapter.is_live:
+            assert (
+                internal_to_snapshot(
+                    adapter.collected_pairs, http_snapshot_serializer_options
+                )
+                == adapter.snapshot
+            )

http_snapshot-0.1.0/src/http_snapshot/_serializer.py

@@ -0,0 +1,154 @@
+from dataclasses import dataclass, field
+import json
+from typing import Any, Iterable, Mapping, Optional
+import inline_snapshot
+import pytest
+import base64
+
+from ._models import Request, Response
+
+
+@dataclass
+class SnapshotSerializerOptions:
+    include_request: bool = True
+    exclude_request_headers: Iterable[str] = field(default_factory=list)
+    exclude_response_headers: Iterable[str] = field(default_factory=list)
+
+    def __post_init__(self) -> None:
+        self.exclude_request_headers = set(
+            header.lower() for header in self.exclude_request_headers
+        )
+        self.exclude_response_headers = set(
+            header.lower() for header in self.exclude_response_headers
+        )
+
+
+def get_snapshot_value(snapshot: Any) -> Any:
+    # todo fix this
+    return snapshot._load_value()
+    if not hasattr(snapshot, "_old_value"):
+        return snapshot
+
+    old = snapshot._old_value
+    if not hasattr(old, "value"):
+        return old
+
+    loader = getattr(old.value, "_load_value", None)
+    return loader() if loader else old.value
+
+
+def encode_content(content: bytes, content_type: str) -> str:
+    if content_type == "application/json":
+        return json.dumps(json.loads(content), indent=2, ensure_ascii=False)
+    elif content_type.startswith("text/"):
+        return content.decode("utf-8")
+    else:
+        # base64 any other binary content
+        return base64.b64encode(content).decode("utf-8")
+
+
+def decode_content(encoded_content: str, content_type: str) -> bytes:
+    if content_type == "application/json":
+        return json.dumps(
+            json.loads(encoded_content), indent=2, ensure_ascii=False
+        ).encode("utf-8")
+    elif content_type.startswith("text/"):
+        return encoded_content.encode("utf-8")
+    else:
+        # decode base64 for other binary content
+        return base64.b64decode(encoded_content)
+
+
+def exclude_sensitive_request_headers(
+    headers: Mapping[str, str], options: Optional[SnapshotSerializerOptions] = None
+) -> dict[str, str]:
+    options = options or SnapshotSerializerOptions()
+    return {
+        k: v
+        for k, v in headers.items()
+        if k.lower() not in options.exclude_request_headers
+        and k.lower() not in ("authorization", "cookie")
+    }
+
+
+def exclude_sensitive_response_headers(
+    headers: Mapping[str, str],
+    options: Optional[SnapshotSerializerOptions] = None,
+) -> dict[str, str]:
+    options = options or SnapshotSerializerOptions()
+    return {
+        k: v
+        for k, v in headers.items()
+        if k.lower() not in options.exclude_response_headers
+        and k.lower()
+        not in (
+            "set-cookie",
+            "www-authenticate",
+            "proxy-authenticate",
+            "authentication-info",
+            "proxy-authentication-info",
+            "transfer-encoding",
+            "content-encoding",
+        )
+    }
+
+
+def internal_to_snapshot(
+    pairs: list[tuple[Request, Response]],
+    options: Optional[SnapshotSerializerOptions] = None,
+) -> list[dict[str, Any]]:
+    options = options or SnapshotSerializerOptions()
+    to_compare = []
+
+    for request, response in pairs:
+        repr: dict[str, Any] = {}
+
+        if options.include_request:
+            repr["request"] = {
+                "method": request.method,
+                "url": str(request.url),
+                "headers": exclude_sensitive_request_headers(
+                    dict(request.headers), options
+                ),
+                "body": encode_content(
+                    request.body, request.headers.get("Content-Type", "")
+                ),
+            }
+
+        repr["response"] = {
+            "status_code": response.status_code,
+            "headers": exclude_sensitive_response_headers(
+                dict(response.headers), options
+            ),
+            "body": encode_content(
+                response.body, response.headers.get("Content-Type", "")
+            ),
+        }
+
+        to_compare.append(repr)
+    return to_compare
+
+
+def snapshot_to_internal(
+    snapshot: inline_snapshot.Snapshot[list[dict[str, Any]]],
+) -> list[Response]:
+    responses = []
+
+    value: list[dict[str, Any]] = get_snapshot_value(snapshot)
+    for item in value:
+        response = Response(
+            status_code=item["response"]["status_code"],
+            headers=item["response"]["headers"],
+            body=decode_content(
+                item["response"]["body"],
+                item["response"]["headers"].get("Content-Type", ""),
+            ),
+        )
+        responses.append(response)
+
+    return responses
+
+
+@pytest.fixture
+def snapshot() -> Any:
+    return inline_snapshot.external("uuid:93ec4e8a-8760-4cd1-8330-df818d448e0d.json")

http_snapshot-0.1.0/src/http_snapshot.egg-info/PKG-INFO

@@ -0,0 +1,241 @@
+Metadata-Version: 2.4
+Name: http-snapshot
+Version: 0.1.0
+Summary: http-snapshot is a pytest plugin that snapshots requests made with popular Python HTTP clients.
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Provides-Extra: httpx
+Requires-Dist: httpx>=0.28.1; extra == "httpx"
+Provides-Extra: requests
+Requires-Dist: requests>=2.32.5; extra == "requests"
+
+# http-snapshot
+
+`http-snapshot` is a pytest plugin that captures and snapshots HTTP requests/responses made with popular Python HTTP clients like `httpx` and `requests`. It uses [inline-snapshot](https://github.com/15r10nk/inline-snapshot) to store HTTP interactions as JSON files, enabling fast and reliable HTTP testing without making actual network calls.
+
+## Features
+
+- 🚀 **Support for multiple HTTP clients**: `httpx` (async) and `requests` (sync)
+- 📸 **Automatic HTTP interaction capture**: Records both requests and responses
+- 🔒 **Security-aware**: Automatically excludes sensitive headers like authorization and cookies
+- ⚙️ **Configurable**: Control what gets captured and what gets excluded
+- 🧪 **pytest integration**: Works seamlessly with your existing pytest test suite
+- 📁 **External snapshots**: Stores snapshots in organized JSON files
+
+## Installation
+
+```bash
+pip install http-snapshot
+```
+
+For specific HTTP client support:
+
+```bash
+# For httpx support
+pip install http-snapshot[httpx]
+
+# For requests support
+pip install http-snapshot[requests]
+
+# For both
+pip install http-snapshot[httpx,requests]
+```
+
+## Quick Start
+
+### Using with httpx (async)
+
+```python
+import httpx
+import pytest
+import inline_snapshot
+
+@pytest.mark.anyio
+@pytest.mark.parametrize(
+    "http_snapshot",
+    [inline_snapshot.external("uuid:my-test-snapshot.json")],
+)
+async def test_api_call(snapshot_httpx_client: httpx.AsyncClient) -> None:
+    # This will be captured on first run, replayed on subsequent runs
+    response = await snapshot_httpx_client.get("https://api.example.com/users")
+    assert response.status_code == 200
+    assert "users" in response.json()
+```
+
+### Using with requests (sync)
+
+```python
+import requests
+import pytest
+import inline_snapshot
+
+@pytest.mark.parametrize(
+    "http_snapshot",
+    [inline_snapshot.external("uuid:my-test-snapshot.json")],
+)
+def test_api_call(snapshot_requests_session: requests.Session) -> None:
+    # This will be captured on first run, replayed on subsequent runs
+    response = snapshot_requests_session.get("https://api.example.com/users")
+    assert response.status_code == 200
+    assert "users" in response.json()
+```
+
+## How It Works
+
+### Live Mode vs Replay Mode
+
+The plugin operates in two modes:
+
+1. **Live Mode**: When `HTTP_SNAPSHOT_LIVE=1` is set, actual HTTP requests are made and responses are captured
+2. **Replay Mode**: When not in live mode, previously captured responses are replayed
+
+### Running in Live Mode
+
+```bash
+# Capture new snapshots
+HTTP_SNAPSHOT_LIVE=1 pytest tests/
+
+# Replay existing snapshots (default)
+pytest tests/
+```
+
+## Configuration Options
+
+You can customize what gets captured using `SnapshotSerializerOptions`:
+
+```python
+import pytest
+import inline_snapshot
+from http_snapshot._serializer import SnapshotSerializerOptions
+
+@pytest.mark.parametrize(
+    "http_snapshot, http_snapshot_serializer_options",
+    [
+        (
+            inline_snapshot.external("uuid:my-test-snapshot.json"),
+            SnapshotSerializerOptions(
+                exclude_request_headers=["X-API-Key"],
+                include_request=True,  # Include request details in snapshot
+            ),
+        ),
+    ],
+)
+def test_with_custom_options(
+    snapshot_requests_session: requests.Session,
+    http_snapshot_serializer_options: SnapshotSerializerOptions,
+) -> None:
+    response = snapshot_requests_session.get(
+        "https://api.example.com/protected",
+        headers={"X-API-Key": "secret-key"}
+    )
+    assert response.status_code == 200
+```
+
+### Available Options
+
+- `include_request`: Whether to include request details in snapshots (default: `True`)
+- `exclude_request_headers`: List of request headers to exclude from snapshots
+- `exclude_response_headers`: List of response headers to exclude from snapshots
+
+By default, the following sensitive headers are always excluded:
+
+- **Request**: `authorization`, `cookie`
+- **Response**: `set-cookie`, `www-authenticate`, `proxy-authenticate`, `authentication-info`, `proxy-authentication-info`, `transfer-encoding`, `content-encoding`
+
+## Snapshot Format
+
+Snapshots are stored as JSON files with the following structure:
+
+```json
+[
+  {
+    "request": {
+      "method": "GET",
+      "url": "https://api.example.com/users",
+      "headers": {
+        "host": "api.example.com",
+        "accept": "*/*",
+        "accept-encoding": "gzip, deflate",
+        "connection": "keep-alive",
+        "user-agent": "python-httpx/0.28.1"
+      },
+      "body": ""
+    },
+    "response": {
+      "status_code": 200,
+      "headers": {
+        "date": "Thu, 21 Aug 2025 15:49:45 GMT",
+        "content-type": "application/json; charset=utf-8",
+        "connection": "keep-alive",
+        "server": "nginx/1.18.0"
+      },
+      "body": "{\n  \"users\": [\n    {\n      \"id\": 1,\n      \"name\": \"John Doe\",\n      \"email\": \"john@example.com\"\n    }\n  ]\n}"
+    }
+  }
+]
+```
+
+### Content Encoding
+
+The plugin intelligently handles different content types:
+
+- **JSON**: Formatted with proper indentation for readability
+- **Text**: Stored as UTF-8 strings
+- **Binary**: Base64 encoded
+
+## Advanced Examples
+
+### Testing API with Multiple Requests
+
+```python
+@pytest.mark.anyio
+@pytest.mark.parametrize(
+    "http_snapshot",
+    [inline_snapshot.external("uuid:multi-request-test.json")],
+)
+async def test_multiple_requests(snapshot_httpx_client: httpx.AsyncClient) -> None:
+    # Create a user
+    create_response = await snapshot_httpx_client.post(
+        "https://api.example.com/users",
+        json={"name": "Alice", "email": "alice@example.com"}
+    )
+    assert create_response.status_code == 201
+    user_id = create_response.json()["id"]
+
+    # Fetch the user
+    get_response = await snapshot_httpx_client.get(
+        f"https://api.example.com/users/{user_id}"
+    )
+    assert get_response.status_code == 200
+    assert get_response.json()["name"] == "Alice"
+```
+
+### Testing with Authentication
+
+```python
+@pytest.mark.parametrize(
+    "http_snapshot, http_snapshot_serializer_options",
+    [
+        (
+            inline_snapshot.external("uuid:auth-test.json"),
+            SnapshotSerializerOptions(exclude_request_headers=["Authorization"]),
+        ),
+    ],
+)
+def test_authenticated_request(
+    snapshot_requests_session: requests.Session,
+    http_snapshot_serializer_options,
+) -> None:
+    # The Authorization header will be excluded from the snapshot
+    response = snapshot_requests_session.get(
+        "https://api.example.com/profile",
+        headers={"Authorization": "Bearer secret-token"}
+    )
+    assert response.status_code == 200
+```
+
+## Best Practices
+
+1. **Exclude sensitive data**: Always exclude headers containing secrets, tokens, or personal data
+2. **Review snapshots**: Check generated snapshot files into version control and review changes
+3. **Use live mode sparingly**: Only run in live mode when you need to update snapshots

http_snapshot-0.1.0/src/http_snapshot.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+src/http_snapshot/__init__.py
+src/http_snapshot/_models.py
+src/http_snapshot/_pytest_plugin.py
+src/http_snapshot/_serializer.py
+src/http_snapshot.egg-info/PKG-INFO
+src/http_snapshot.egg-info/SOURCES.txt
+src/http_snapshot.egg-info/dependency_links.txt
+src/http_snapshot.egg-info/entry_points.txt
+src/http_snapshot.egg-info/requires.txt
+src/http_snapshot.egg-info/top_level.txt
+src/http_snapshot/_integrations/__init__.py
+src/http_snapshot/_integrations/_httpx.py
+src/http_snapshot/_integrations/_requests.py

http_snapshot-0.1.0/src/http_snapshot.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

http_snapshot-0.1.0/src/http_snapshot.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pytest11]
+http_snapshot = http_snapshot._pytest_plugin

http_snapshot-0.1.0/src/http_snapshot.egg-info/requires.txt

@@ -0,0 +1,6 @@
+
+[httpx]
+httpx>=0.28.1
+
+[requests]
+requests>=2.32.5

http_snapshot-0.1.0/src/http_snapshot.egg-info/top_level.txt

@@ -0,0 +1 @@
+http_snapshot