smello 0.1.1__tar.gz

smello-0.1.1/.bumpversion.toml

@@ -0,0 +1,16 @@
+[tool.bumpversion]
+current_version = "0.1.1"
+commit = true
+tag = true
+tag_name = "smello/v{new_version}"
+tag_message = "Release smello v{new_version}"
+message = "Bump smello version: {current_version} → {new_version}"
+
+[[tool.bumpversion.files]]
+filename = "clients/python/pyproject.toml"
+key_path = "project.version"
+
+[[tool.bumpversion.files]]
+filename = "clients/python/src/smello/__init__.py"
+search = '__version__ = "{current_version}"'
+replace = '__version__ = "{new_version}"'

smello-0.1.1/.gitignore

@@ -0,0 +1,23 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+dist/
+build/
+*.egg
+.eggs/
+*.so
+.venv/
+venv/
+env/
+.env
+*.db
+*.sqlite3
+.mypy_cache/
+.pytest_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+*.log
+.DS_Store
+Thumbs.db

smello-0.1.1/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: smello
+Version: 0.1.1
+Summary: Capture outgoing HTTP requests and inspect them in a local web dashboard
+Project-URL: Homepage, https://github.com/smelloscope/smello
+Project-URL: Repository, https://github.com/smelloscope/smello
+Project-URL: Issues, https://github.com/smelloscope/smello/issues
+Author-email: Roman Imankulov <roman.imankulov@gmail.com>
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: System :: Networking :: Monitoring
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# Smello
+
+Capture outgoing HTTP requests from your Python code and browse them in a local web dashboard.
+
+Like [Mailpit](https://mailpit.axllent.org/), but for HTTP requests.
+
+## Setup
+
+Install the client SDK and the server:
+
+```bash
+pip install smello smello-server
+```
+
+Start the server:
+
+```bash
+smello-server run
+```
+
+Add two lines to your code:
+
+```python
+import smello
+smello.init()
+
+import requests
+resp = requests.get("https://api.stripe.com/v1/charges")
+
+# Browse captured requests at http://localhost:5110
+```
+
+Smello monkey-patches `requests` and `httpx` to capture all outgoing HTTP traffic. Browse results at `http://localhost:5110`.
+
+## What Smello Captures
+
+- Method, URL, headers, and body
+- Response status code, headers, and body
+- Duration in milliseconds
+- HTTP library used (requests or httpx)
+
+Smello redacts sensitive headers (`Authorization`, `X-Api-Key`) by default.
+
+## Configuration
+
+```python
+smello.init(
+    server_url="http://localhost:5110",  # where to send captured data
+    capture_hosts=["api.stripe.com"],    # only capture these hosts
+    capture_all=True,                     # capture everything (default)
+    ignore_hosts=["localhost"],          # skip these hosts
+    redact_headers=["Authorization"],    # replace values with [REDACTED]
+    enabled=True,                         # kill switch
+)
+```
+
+## Supported Libraries
+
+- **requests** — patches `Session.send()`
+- **httpx** — patches `Client.send()` and `AsyncClient.send()`
+
+## Requires
+
+- Python >= 3.10
+- [smello-server](https://pypi.org/project/smello-server/) running locally
+
+## Links
+
+- [Documentation & Source](https://github.com/smelloscope/smello)
+- [smello-server on PyPI](https://pypi.org/project/smello-server/)

smello-0.1.1/README.md

@@ -0,0 +1,70 @@
+# Smello
+
+Capture outgoing HTTP requests from your Python code and browse them in a local web dashboard.
+
+Like [Mailpit](https://mailpit.axllent.org/), but for HTTP requests.
+
+## Setup
+
+Install the client SDK and the server:
+
+```bash
+pip install smello smello-server
+```
+
+Start the server:
+
+```bash
+smello-server run
+```
+
+Add two lines to your code:
+
+```python
+import smello
+smello.init()
+
+import requests
+resp = requests.get("https://api.stripe.com/v1/charges")
+
+# Browse captured requests at http://localhost:5110
+```
+
+Smello monkey-patches `requests` and `httpx` to capture all outgoing HTTP traffic. Browse results at `http://localhost:5110`.
+
+## What Smello Captures
+
+- Method, URL, headers, and body
+- Response status code, headers, and body
+- Duration in milliseconds
+- HTTP library used (requests or httpx)
+
+Smello redacts sensitive headers (`Authorization`, `X-Api-Key`) by default.
+
+## Configuration
+
+```python
+smello.init(
+    server_url="http://localhost:5110",  # where to send captured data
+    capture_hosts=["api.stripe.com"],    # only capture these hosts
+    capture_all=True,                     # capture everything (default)
+    ignore_hosts=["localhost"],          # skip these hosts
+    redact_headers=["Authorization"],    # replace values with [REDACTED]
+    enabled=True,                         # kill switch
+)
+```
+
+## Supported Libraries
+
+- **requests** — patches `Session.send()`
+- **httpx** — patches `Client.send()` and `AsyncClient.send()`
+
+## Requires
+
+- Python >= 3.10
+- [smello-server](https://pypi.org/project/smello-server/) running locally
+
+## Links
+
+- [Documentation & Source](https://github.com/smelloscope/smello)
+- [smello-server on PyPI](https://pypi.org/project/smello-server/)

smello-0.1.1/pyproject.toml

@@ -0,0 +1,34 @@
+[project]
+name = "smello"
+version = "0.1.1"
+description = "Capture outgoing HTTP requests and inspect them in a local web dashboard"
+license = "MIT"
+requires-python = ">=3.10"
+readme = "README.md"
+authors = [{ name = "Roman Imankulov", email = "roman.imankulov@gmail.com" }]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Software Development :: Testing",
+    "Topic :: System :: Networking :: Monitoring",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/smelloscope/smello"
+Repository = "https://github.com/smelloscope/smello"
+Issues = "https://github.com/smelloscope/smello/issues"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/smello"]

smello-0.1.1/src/smello/__init__.py

@@ -0,0 +1,49 @@
+"""Smello - Capture outgoing HTTP requests automatically."""
+
+from smello.config import SmelloConfig
+
+__version__ = "0.1.1"
+
+_config: SmelloConfig | None = None
+
+
+def init(
+    server_url: str = "http://localhost:5110",
+    capture_hosts: list[str] | None = None,
+    capture_all: bool = True,
+    ignore_hosts: list[str] | None = None,
+    redact_headers: list[str] | None = None,
+    enabled: bool = True,
+) -> None:
+    """Initialize Smello. Patches requests and httpx to capture outgoing HTTP traffic."""
+    global _config
+
+    if not enabled:
+        return
+
+    _config = SmelloConfig(
+        server_url=server_url.rstrip("/"),
+        capture_hosts=capture_hosts or [],
+        capture_all=capture_all,
+        ignore_hosts=ignore_hosts or [],
+        redact_headers=[
+            h.lower() for h in (redact_headers or ["authorization", "x-api-key"])
+        ],
+    )
+
+    # Always ignore the smello server itself
+    from urllib.parse import urlparse
+
+    server_host = urlparse(_config.server_url).hostname
+    if server_host and server_host not in _config.ignore_hosts:
+        _config.ignore_hosts.append(server_host)
+
+    # Start transport worker
+    from smello.transport import start_worker
+
+    start_worker(_config.server_url)
+
+    # Apply patches
+    from smello.patches import apply_all
+
+    apply_all(_config)

smello-0.1.1/src/smello/capture.py

@@ -0,0 +1,73 @@
+"""Serialize captured HTTP request/response pairs for sending to the server."""
+
+import time
+import uuid
+
+from smello.config import SmelloConfig
+
+
+def serialize_request_response(
+    config: SmelloConfig,
+    method: str,
+    url: str,
+    request_headers: dict,
+    request_body: str | bytes | None,
+    status_code: int,
+    response_headers: dict,
+    response_body: str | bytes | None,
+    duration_s: float,
+    library: str,
+) -> dict:
+    """Build the capture payload dict."""
+    req_headers = _redact_headers(dict(request_headers), config.redact_headers)
+    resp_headers = dict(response_headers)
+
+    req_body_str = _body_to_str(request_body)
+    resp_body_str = _body_to_str(response_body)
+
+    return {
+        "id": str(uuid.uuid4()),
+        "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+        "duration_ms": int(duration_s * 1000),
+        "request": {
+            "method": method,
+            "url": url,
+            "headers": req_headers,
+            "body": req_body_str,
+            "body_size": len(request_body) if request_body else 0,
+        },
+        "response": {
+            "status_code": status_code,
+            "headers": resp_headers,
+            "body": resp_body_str,
+            "body_size": len(response_body) if response_body else 0,
+        },
+        "meta": {
+            "library": library,
+            "python_version": _python_version(),
+            "smello_version": "0.1.0",
+        },
+    }
+
+
+def _redact_headers(headers: dict, redact_keys: list[str]) -> dict:
+    return {
+        k: ("[REDACTED]" if k.lower() in redact_keys else v) for k, v in headers.items()
+    }
+
+
+def _body_to_str(body: str | bytes | None) -> str | None:
+    if body is None:
+        return None
+    if isinstance(body, bytes):
+        try:
+            return body.decode("utf-8")
+        except UnicodeDecodeError:
+            return f"<binary: {len(body)} bytes>"
+    return body
+
+
+def _python_version() -> str:
+    import sys
+
+    return f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"

smello-0.1.1/src/smello/config.py

@@ -0,0 +1,22 @@
+"""Configuration for Smello client."""
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class SmelloConfig:
+    server_url: str = "http://localhost:5110"
+    capture_hosts: list[str] = field(default_factory=list)
+    capture_all: bool = True
+    ignore_hosts: list[str] = field(default_factory=list)
+    redact_headers: list[str] = field(
+        default_factory=lambda: ["authorization", "x-api-key"]
+    )
+
+    def should_capture(self, host: str) -> bool:
+        """Decide whether to capture a request to the given host."""
+        if host in self.ignore_hosts:
+            return False
+        if self.capture_all:
+            return True
+        return host in self.capture_hosts

smello-0.1.1/src/smello/patches/__init__.py

@@ -0,0 +1,12 @@
+"""Monkey-patches for HTTP client libraries."""
+
+from smello.config import SmelloConfig
+
+
+def apply_all(config: SmelloConfig) -> None:
+    """Apply all available patches."""
+    from smello.patches.patch_httpx import patch_httpx
+    from smello.patches.patch_requests import patch_requests
+
+    patch_requests(config)
+    patch_httpx(config)

smello-0.1.1/src/smello/patches/patch_httpx.py

@@ -0,0 +1,93 @@
+"""Monkey-patch for the `httpx` library (sync and async)."""
+
+import time
+from urllib.parse import urlparse
+
+from smello.config import SmelloConfig
+
+
+def patch_httpx(config: SmelloConfig) -> None:
+    """Patch httpx.Client.send and httpx.AsyncClient.send."""
+    try:
+        import httpx
+    except ImportError:
+        return  # httpx not installed, skip
+
+    _patch_sync(httpx, config)
+    _patch_async(httpx, config)
+
+
+def _patch_sync(httpx, config: SmelloConfig) -> None:
+    original_send = httpx.Client.send
+
+    def patched_send(self, request, **kwargs):
+        host = urlparse(str(request.url)).hostname or ""
+
+        if not config.should_capture(host):
+            return original_send(self, request, **kwargs)
+
+        start = time.monotonic()
+        response = original_send(self, request, **kwargs)
+        duration = time.monotonic() - start
+
+        try:
+            from smello.capture import serialize_request_response
+            from smello.transport import send
+
+            payload = serialize_request_response(
+                config=config,
+                method=request.method,
+                url=str(request.url),
+                request_headers=dict(request.headers),
+                request_body=request.content,
+                status_code=response.status_code,
+                response_headers=dict(response.headers),
+                response_body=response.text,
+                duration_s=duration,
+                library="httpx",
+            )
+            send(payload)
+        except Exception:
+            pass
+
+        return response
+
+    httpx.Client.send = patched_send
+
+
+def _patch_async(httpx, config: SmelloConfig) -> None:
+    original_send = httpx.AsyncClient.send
+
+    async def patched_send(self, request, **kwargs):
+        host = urlparse(str(request.url)).hostname or ""
+
+        if not config.should_capture(host):
+            return await original_send(self, request, **kwargs)
+
+        start = time.monotonic()
+        response = await original_send(self, request, **kwargs)
+        duration = time.monotonic() - start
+
+        try:
+            from smello.capture import serialize_request_response
+            from smello.transport import send
+
+            payload = serialize_request_response(
+                config=config,
+                method=request.method,
+                url=str(request.url),
+                request_headers=dict(request.headers),
+                request_body=request.content,
+                status_code=response.status_code,
+                response_headers=dict(response.headers),
+                response_body=response.text,
+                duration_s=duration,
+                library="httpx",
+            )
+            send(payload)
+        except Exception:
+            pass
+
+        return response
+
+    httpx.AsyncClient.send = patched_send

smello-0.1.1/src/smello/patches/patch_requests.py

@@ -0,0 +1,50 @@
+"""Monkey-patch for the `requests` library."""
+
+import time
+from urllib.parse import urlparse
+
+from smello.config import SmelloConfig
+
+
+def patch_requests(config: SmelloConfig) -> None:
+    """Patch requests.Session.send to capture outgoing HTTP traffic."""
+    try:
+        import requests
+    except ImportError:
+        return  # requests not installed, skip
+
+    original_send = requests.Session.send
+
+    def patched_send(self, prepared_request, **kwargs):
+        host = urlparse(prepared_request.url).hostname or ""
+
+        if not config.should_capture(host):
+            return original_send(self, prepared_request, **kwargs)
+
+        start = time.monotonic()
+        response = original_send(self, prepared_request, **kwargs)
+        duration = time.monotonic() - start
+
+        try:
+            from smello.capture import serialize_request_response
+            from smello.transport import send
+
+            payload = serialize_request_response(
+                config=config,
+                method=prepared_request.method or "GET",
+                url=prepared_request.url,
+                request_headers=dict(prepared_request.headers),
+                request_body=prepared_request.body,
+                status_code=response.status_code,
+                response_headers=dict(response.headers),
+                response_body=response.text,
+                duration_s=duration,
+                library="requests",
+            )
+            send(payload)
+        except Exception:
+            pass  # never break user's code
+
+        return response
+
+    requests.Session.send = patched_send  # type: ignore[assignment]

smello-0.1.1/src/smello/transport.py

@@ -0,0 +1,49 @@
+"""Background transport: sends captured data to the Smello server without blocking."""
+
+import json
+import queue
+import threading
+import urllib.request
+
+_queue: queue.Queue = queue.Queue(maxsize=1000)
+_server_url: str = ""
+
+
+def start_worker(server_url: str) -> None:
+    """Start the background worker thread."""
+    global _server_url
+    _server_url = server_url
+
+    thread = threading.Thread(target=_worker, daemon=True, name="smello-transport")
+    thread.start()
+
+
+def send(payload: dict) -> None:
+    """Queue a capture payload for sending. Non-blocking, drops if queue is full."""
+    try:
+        _queue.put_nowait(payload)
+    except queue.Full:
+        pass  # drop silently if queue is full
+
+
+def _worker() -> None:
+    """Background worker that sends queued payloads to the server."""
+    while True:
+        payload = _queue.get()
+        try:
+            _send_to_server(payload)
+        except Exception:
+            pass  # silently drop if server is down
+        _queue.task_done()
+
+
+def _send_to_server(payload: dict) -> None:
+    """Send a payload to the Smello server using urllib (to avoid recursion)."""
+    data = json.dumps(payload).encode("utf-8")
+    req = urllib.request.Request(
+        f"{_server_url}/api/capture",
+        data=data,
+        headers={"Content-Type": "application/json"},
+        method="POST",
+    )
+    urllib.request.urlopen(req, timeout=5)

smello-0.1.1/tests/test_capture.py

@@ -0,0 +1,155 @@
+"""Tests for smello.capture serialization."""
+
+import pytest
+from smello.capture import serialize_request_response
+from smello.config import SmelloConfig
+
+
+@pytest.fixture()
+def config():
+    return SmelloConfig(redact_headers=["authorization", "x-api-key"])
+
+
+@pytest.fixture()
+def basic_payload(config):
+    return serialize_request_response(
+        config=config,
+        method="GET",
+        url="https://api.example.com/test",
+        request_headers={"Content-Type": "application/json"},
+        request_body=None,
+        status_code=200,
+        response_headers={"Content-Type": "application/json"},
+        response_body='{"ok": true}',
+        duration_s=0.15,
+        library="requests",
+    )
+
+
+def test_basic_fields(basic_payload):
+    assert basic_payload["duration_ms"] == 150
+    assert basic_payload["request"]["method"] == "GET"
+    assert basic_payload["request"]["url"] == "https://api.example.com/test"
+    assert basic_payload["response"]["status_code"] == 200
+    assert basic_payload["response"]["body"] == '{"ok": true}'
+    assert basic_payload["meta"]["library"] == "requests"
+    assert "id" in basic_payload
+    assert "timestamp" in basic_payload
+
+
+def test_null_body(basic_payload):
+    assert basic_payload["request"]["body"] is None
+    assert basic_payload["request"]["body_size"] == 0
+
+
+def test_header_redaction(config):
+    payload = serialize_request_response(
+        config=config,
+        method="POST",
+        url="https://example.com",
+        request_headers={
+            "Content-Type": "application/json",
+            "Authorization": "Bearer sk-secret",
+            "X-Api-Key": "key_12345",
+            "X-Custom": "keep-this",
+        },
+        request_body=None,
+        status_code=200,
+        response_headers={},
+        response_body=None,
+        duration_s=0.1,
+        library="httpx",
+    )
+    headers = payload["request"]["headers"]
+    assert headers["Content-Type"] == "application/json"
+    assert headers["Authorization"] == "[REDACTED]"
+    assert headers["X-Api-Key"] == "[REDACTED]"
+    assert headers["X-Custom"] == "keep-this"
+
+
+def test_custom_redact_headers():
+    config = SmelloConfig(redact_headers=["x-secret"])
+    payload = serialize_request_response(
+        config=config,
+        method="GET",
+        url="https://example.com",
+        request_headers={"Authorization": "Bearer token", "X-Secret": "hidden"},
+        request_body=None,
+        status_code=200,
+        response_headers={},
+        response_body=None,
+        duration_s=0.05,
+        library="requests",
+    )
+    headers = payload["request"]["headers"]
+    assert headers["Authorization"] == "Bearer token"
+    assert headers["X-Secret"] == "[REDACTED]"
+
+
+def test_bytes_body_utf8(config):
+    payload = serialize_request_response(
+        config=config,
+        method="POST",
+        url="https://example.com",
+        request_headers={},
+        request_body=b'{"key": "value"}',
+        status_code=200,
+        response_headers={},
+        response_body=b'{"result": "ok"}',
+        duration_s=0.1,
+        library="requests",
+    )
+    assert payload["request"]["body"] == '{"key": "value"}'
+    assert payload["request"]["body_size"] == 16
+    assert payload["response"]["body"] == '{"result": "ok"}'
+
+
+def test_binary_body_non_utf8(config):
+    binary_data = bytes(range(256))
+    payload = serialize_request_response(
+        config=config,
+        method="POST",
+        url="https://example.com",
+        request_headers={},
+        request_body=binary_data,
+        status_code=200,
+        response_headers={},
+        response_body=None,
+        duration_s=0.1,
+        library="requests",
+    )
+    assert payload["request"]["body"] == "<binary: 256 bytes>"
+    assert payload["request"]["body_size"] == 256
+
+
+def test_string_body(config):
+    payload = serialize_request_response(
+        config=config,
+        method="POST",
+        url="https://example.com",
+        request_headers={},
+        request_body="plain text",
+        status_code=200,
+        response_headers={},
+        response_body="response text",
+        duration_s=0.1,
+        library="httpx",
+    )
+    assert payload["request"]["body"] == "plain text"
+    assert payload["response"]["body"] == "response text"
+
+
+def test_duration_rounding(config):
+    payload = serialize_request_response(
+        config=config,
+        method="GET",
+        url="https://example.com",
+        request_headers={},
+        request_body=None,
+        status_code=200,
+        response_headers={},
+        response_body=None,
+        duration_s=1.5678,
+        library="requests",
+    )
+    assert payload["duration_ms"] == 1567

smello-0.1.1/tests/test_config.py

@@ -0,0 +1,46 @@
+"""Tests for smello.config.SmelloConfig."""
+
+import pytest
+from smello.config import SmelloConfig
+
+
+@pytest.fixture()
+def default_config():
+    return SmelloConfig()
+
+
+@pytest.fixture()
+def selective_config():
+    return SmelloConfig(capture_all=False, capture_hosts=["api.stripe.com"])
+
+
+def test_capture_all_by_default(default_config):
+    assert default_config.should_capture("api.stripe.com") is True
+    assert default_config.should_capture("example.com") is True
+
+
+def test_ignore_hosts():
+    config = SmelloConfig(ignore_hosts=["localhost", "127.0.0.1"])
+    assert config.should_capture("localhost") is False
+    assert config.should_capture("127.0.0.1") is False
+    assert config.should_capture("api.stripe.com") is True
+
+
+def test_capture_specific_hosts_only(selective_config):
+    assert selective_config.should_capture("api.stripe.com") is True
+    assert selective_config.should_capture("api.openai.com") is False
+
+
+def test_ignore_takes_precedence_over_capture_hosts():
+    config = SmelloConfig(
+        capture_all=False,
+        capture_hosts=["api.stripe.com"],
+        ignore_hosts=["api.stripe.com"],
+    )
+    assert config.should_capture("api.stripe.com") is False
+
+
+def test_ignore_takes_precedence_over_capture_all():
+    config = SmelloConfig(capture_all=True, ignore_hosts=["secret.internal"])
+    assert config.should_capture("secret.internal") is False
+    assert config.should_capture("anything.else") is True

smello-0.1.1/tests/test_transport.py

@@ -0,0 +1,55 @@
+"""Tests for smello.transport."""
+
+import json
+import threading
+import time
+from http.server import BaseHTTPRequestHandler, HTTPServer
+
+import pytest
+from smello.transport import send, start_worker
+
+
+class _CaptureHandler(BaseHTTPRequestHandler):
+    captured: list = []
+
+    def do_POST(self):
+        length = int(self.headers.get("Content-Length", 0))
+        body = json.loads(self.rfile.read(length))
+        _CaptureHandler.captured.append(body)
+        self.send_response(201)
+        self.end_headers()
+        self.wfile.write(b'{"status":"ok"}')
+
+    def log_message(self, format, *args):
+        pass
+
+
+@pytest.fixture()
+def capture_server():
+    """Start a minimal HTTP server that records POSTed payloads."""
+    _CaptureHandler.captured = []
+    server = HTTPServer(("127.0.0.1", 0), _CaptureHandler)
+    port = server.server_address[1]
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    yield f"http://127.0.0.1:{port}", _CaptureHandler.captured
+    server.shutdown()
+
+
+def test_send_delivers_payload(capture_server):
+    url, captured = capture_server
+    start_worker(url)
+
+    payload = {
+        "id": "test-transport-1",
+        "request": {"method": "GET", "url": "https://example.com"},
+        "response": {"status_code": 200},
+    }
+    send(payload)
+
+    deadline = time.monotonic() + 5
+    while not captured and time.monotonic() < deadline:
+        time.sleep(0.05)
+
+    assert len(captured) == 1
+    assert captured[0]["id"] == "test-transport-1"