apitally 0.16.1__tar.gz → 0.16.3__tar.gz

{apitally-0.16.1 → apitally-0.16.3}/.github/workflows/tests.yaml

@@ -48,11 +48,8 @@ jobs:
       matrix:
         python: ["3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
         deps:
-          - starlette
           - fastapi starlette
-          - fastapi==0.109.0 starlette
-          - fastapi==0.100.1 starlette
-          - fastapi==0.88.0 starlette
+          - fastapi==0.94.1 starlette
           - flask
           - flask==2.3.*
           - flask==2.0.3 Werkzeug==2.*
@@ -61,36 +58,22 @@ jobs:
           - djangorestframework==3.12.* django==3.2.* uritemplate
           - djangorestframework==3.10.* django==2.2.* uritemplate
           - django-ninja django
-          - django-ninja==0.22.* django
           - django-ninja==0.18.0 django
           - litestar
-          - litestar==2.6.1
-          - litestar==2.3.0
           - litestar==2.0.1
           - blacksheep
-          - blacksheep==2.2.0
           - blacksheep==2.1.0
         exclude:
           - python: "3.8"
             deps: blacksheep
-          - python: "3.8"
-            deps: blacksheep==2.2.0
           - python: "3.8"
             deps: blacksheep==2.1.0
-          - python: "3.12"
-            deps: fastapi==0.100.1 starlette
-          - python: "3.12"
-            deps: fastapi==0.87.0 starlette
           - python: "3.12"
             deps: djangorestframework==3.12.* django==3.2.* uritemplate
           - python: "3.12"
             deps: djangorestframework==3.10.* django==2.2.* uritemplate
           - python: "3.12"
             deps: litestar==2.0.1
-          - python: "3.13"
-            deps: fastapi==0.100.1 starlette
-          - python: "3.13"
-            deps: fastapi==0.87.0 starlette
           - python: "3.13"
             deps: djangorestframework==3.12.* django==3.2.* uritemplate
           - python: "3.13"

{apitally-0.16.1 → apitally-0.16.3}/.pre-commit-config.yaml

@@ -8,12 +8,12 @@ repos:
       - id: trailing-whitespace
       - id: mixed-line-ending
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.11.7
+    rev: v0.11.8
     hooks:
       - id: ruff
         args: ["--fix", "--exit-non-zero-on-fix"]
       - id: ruff-format
   - repo: https://github.com/astral-sh/uv-pre-commit
-    rev: 0.6.17
+    rev: 0.7.2
     hooks:
       - id: uv-lock

{apitally-0.16.1 → apitally-0.16.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apitally
-Version: 0.16.1
+Version: 0.16.3
 Summary: Simple API monitoring & analytics for REST APIs built with FastAPI, Flask, Django, Starlette, Litestar and BlackSheep.
 Project-URL: Homepage, https://apitally.io
 Project-URL: Documentation, https://docs.apitally.io
@@ -49,9 +49,9 @@ Requires-Dist: inflection>=0.5.1; extra == 'django-rest-framework'
 Requires-Dist: requests>=2.26.0; extra == 'django-rest-framework'
 Requires-Dist: uritemplate>=3.0.0; extra == 'django-rest-framework'
 Provides-Extra: fastapi
-Requires-Dist: fastapi>=0.88.0; extra == 'fastapi'
+Requires-Dist: fastapi>=0.94.1; extra == 'fastapi'
 Requires-Dist: httpx>=0.22.0; extra == 'fastapi'
-Requires-Dist: starlette<1.0.0,>=0.22.0; extra == 'fastapi'
+Requires-Dist: starlette<1.0.0,>=0.26.1; extra == 'fastapi'
 Provides-Extra: flask
 Requires-Dist: flask>=2.0.0; extra == 'flask'
 Requires-Dist: requests>=2.26.0; extra == 'flask'
@@ -62,7 +62,7 @@ Provides-Extra: sentry
 Requires-Dist: sentry-sdk>=2.2.0; extra == 'sentry'
 Provides-Extra: starlette
 Requires-Dist: httpx>=0.22.0; extra == 'starlette'
-Requires-Dist: starlette<1.0.0,>=0.21.0; extra == 'starlette'
+Requires-Dist: starlette<1.0.0,>=0.26.1; extra == 'starlette'
 Description-Content-Type: text/markdown
 
 <p align="center">

{apitally-0.16.1 → apitally-0.16.3}/apitally/client/client_asyncio.py

@@ -41,7 +41,6 @@ class ApitallyClient(ApitallyClientBase):
         self._stop_sync_loop = False
         self._sync_loop_task: Optional[asyncio.Task] = None
         self._sync_data_queue: asyncio.Queue[Dict[str, Any]] = asyncio.Queue()
-        self._set_startup_data_task: Optional[asyncio.Task] = None
 
     def get_http_client(self) -> httpx.AsyncClient:
         if httpx.__version__ >= "0.26.0":
@@ -67,7 +66,7 @@ class ApitallyClient(ApitallyClientBase):
                 try:
                     async with self.get_http_client() as client:
                         tasks = [self.send_sync_data(client), self.send_log_data(client)]
-                        if not self._startup_data_sent and last_sync_time > 0:  # not on first sync
+                        if not self._startup_data_sent:
                             tasks.append(self.send_startup_data(client))
                         await asyncio.gather(*tasks)
                     last_sync_time = now
@@ -92,11 +91,6 @@ class ApitallyClient(ApitallyClientBase):
     def set_startup_data(self, data: Dict[str, Any]) -> None:
         self._startup_data_sent = False
         self._startup_data = self.add_uuids_to_data(data)
-        self._set_startup_data_task = asyncio.create_task(self._set_startup_data())
-
-    async def _set_startup_data(self) -> None:
-        async with self.get_http_client() as client:
-            await self.send_startup_data(client)
 
     async def send_startup_data(self, client: httpx.AsyncClient) -> None:
         if self._startup_data is not None:

{apitally-0.16.1 → apitally-0.16.3}/apitally/client/client_threading.py

@@ -80,7 +80,7 @@ class ApitallyClient(ApitallyClientBase):
                 if (now - last_sync_time) >= self.sync_interval:
                     try:
                         with requests.Session() as session:
-                            if not self._startup_data_sent and last_sync_time > 0:  # not on first sync
+                            if not self._startup_data_sent:
                                 self.send_startup_data(session)
                             self.send_sync_data(session)
                             self.send_log_data(session)
@@ -105,8 +105,6 @@ class ApitallyClient(ApitallyClientBase):
     def set_startup_data(self, data: Dict[str, Any]) -> None:
         self._startup_data_sent = False
         self._startup_data = self.add_uuids_to_data(data)
-        with requests.Session() as session:
-            self.send_startup_data(session)
 
     def send_startup_data(self, session: requests.Session) -> None:
         if self._startup_data is not None:

{apitally-0.16.1 → apitally-0.16.3}/apitally/starlette.py

@@ -1,17 +1,18 @@
 from __future__ import annotations
 
-import asyncio
 import time
-from typing import Any, Callable, Dict, List, Optional, Union
+from contextlib import asynccontextmanager
+from typing import Any, Awaitable, Callable, Dict, List, Optional, Union
 from warnings import warn
 
 from httpx import HTTPStatusError, Proxy
+from starlette.applications import Starlette
 from starlette.datastructures import Headers
 from starlette.requests import Request
 from starlette.routing import BaseRoute, Match, Router
 from starlette.schemas import EndpointInfo, SchemaGenerator
 from starlette.testclient import TestClient
-from starlette.types import ASGIApp, Message, Receive, Scope, Send
+from starlette.types import ASGIApp, Lifespan, Message, Receive, Scope, Send
 
 from apitally.client.client_asyncio import ApitallyClient
 from apitally.client.consumers import Consumer as ApitallyConsumer
@@ -40,6 +41,8 @@ class ApitallyMiddleware:
         proxy: Optional[Union[str, Proxy]] = None,
     ) -> None:
         self.app = app
+        self.app_version = app_version
+        self.openapi_url = openapi_url
         self.identify_consumer_callback = identify_consumer_callback
         self.client = ApitallyClient(
             client_id=client_id,
@@ -47,10 +50,6 @@ class ApitallyMiddleware:
             request_logging_config=request_logging_config,
             proxy=proxy,
         )
-        self.client.start_sync_loop()
-        self._delayed_set_startup_data_task: Optional[asyncio.Task] = None
-        self.delayed_set_startup_data(app_version, openapi_url)
-        _register_shutdown_handler(app, self.client.handle_shutdown)
 
         self.capture_request_body = (
             self.client.request_logger.config.enabled and self.client.request_logger.config.log_request_body
@@ -59,17 +58,16 @@ class ApitallyMiddleware:
             self.client.request_logger.config.enabled and self.client.request_logger.config.log_response_body
         )
 
-    def delayed_set_startup_data(self, app_version: Optional[str] = None, openapi_url: Optional[str] = None) -> None:
-        self._delayed_set_startup_data_task = asyncio.create_task(
-            self._delayed_set_startup_data(app_version, openapi_url)
+        _inject_lifespan_handlers(
+            app,
+            on_startup=self.on_startup,
+            on_shutdown=self.client.handle_shutdown,
         )
 
-    async def _delayed_set_startup_data(
-        self, app_version: Optional[str] = None, openapi_url: Optional[str] = None
-    ) -> None:
-        await asyncio.sleep(1.0)  # Short delay to allow app routes to be registered first
-        data = _get_startup_data(self.app, app_version, openapi_url)
+    async def on_startup(self) -> None:
+        data = _get_startup_data(self.app, app_version=self.app_version, openapi_url=self.openapi_url)
         self.client.set_startup_data(data)
+        self.client.start_sync_loop()
 
     async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
         if self.client.enabled and scope["type"] == "http" and scope["method"] != "OPTIONS":
@@ -296,8 +294,30 @@ def _get_routes(app: Union[ASGIApp, Router]) -> List[BaseRoute]:
     return []  # pragma: no cover
 
 
-def _register_shutdown_handler(app: Union[ASGIApp, Router], shutdown_handler: Callable[[], Any]) -> None:
-    if isinstance(app, Router):
-        app.add_event_handler("shutdown", shutdown_handler)
-    elif hasattr(app, "app"):
-        _register_shutdown_handler(app.app, shutdown_handler)
+def _inject_lifespan_handlers(
+    app: Union[ASGIApp, Router],
+    on_startup: Callable[[], Awaitable[Any]],
+    on_shutdown: Callable[[], Awaitable[Any]],
+) -> None:
+    """
+    Ensures the given startup and shutdown functions are called as part of the app's lifespan context manager.
+    """
+    router = app
+    while not isinstance(router, Router) and hasattr(router, "app"):
+        router = router.app
+    if not isinstance(router, Router):
+        raise TypeError("app must be a Starlette or Router instance")
+
+    lifespan: Optional[Lifespan] = getattr(router, "lifespan_context", None)
+
+    @asynccontextmanager
+    async def wrapped_lifespan(app: Starlette):
+        await on_startup()
+        if lifespan is not None:
+            async with lifespan(app):
+                yield
+        else:
+            yield
+        await on_shutdown()
+
+    router.lifespan_context = wrapped_lifespan

{apitally-0.16.1 → apitally-0.16.3}/pyproject.toml

@@ -49,11 +49,11 @@ django_rest_framework = [
     "inflection>=0.5.1",                     # required for schema generation
     "requests>=2.26.0",
 ]
-fastapi = ["fastapi>=0.88.0", "starlette>=0.22.0,<1.0.0", "httpx>=0.22.0"]
+fastapi = ["fastapi>=0.94.1", "starlette>=0.26.1,<1.0.0", "httpx>=0.22.0"]
 flask = ["flask>=2.0.0", "requests>=2.26.0"]
 litestar = ["litestar>=2.0.0", "httpx>=0.22.0"]
 sentry = ["sentry-sdk>=2.2.0"]
-starlette = ["starlette>=0.21.0,<1.0.0", "httpx>=0.22.0"]
+starlette = ["starlette>=0.26.1,<1.0.0", "httpx>=0.22.0"]
 
 [project.urls]
 Homepage = "https://apitally.io"

{apitally-0.16.1 → apitally-0.16.3}/tests/test_client_asyncio.py

@@ -156,13 +156,14 @@ async def test_send_log_data(client: ApitallyClient, httpx_mock: HTTPXMock):
     assert len(client.request_logger.file_deque) == 0
 
 
-async def test_set_startup_data(client: ApitallyClient, httpx_mock: HTTPXMock):
+async def test_send_startup_data(client: ApitallyClient, httpx_mock: HTTPXMock):
     from apitally.client.client_base import HUB_BASE_URL, HUB_VERSION
 
     httpx_mock.add_response()
     data = {"paths": [], "client_version": "1.0.0", "starlette_version": "0.28.0", "python_version": "3.11.4"}
     client.set_startup_data(data)
-    await asyncio.sleep(0.01)
+    async with client.get_http_client() as http_client:
+        await client.send_startup_data(client=http_client)
 
     request = httpx_mock.get_request(url=f"{HUB_BASE_URL}/{HUB_VERSION}/{CLIENT_ID}/{ENV}/startup")
     assert request is not None

{apitally-0.16.1 → apitally-0.16.3}/tests/test_client_threading.py

@@ -141,12 +141,14 @@ def test_send_log_data(client: ApitallyClient, requests_mock: Mocker):
     assert len(client.request_logger.file_deque) == 0
 
 
-def test_set_startup_data(client: ApitallyClient, requests_mock: Mocker):
+def test_send_startup_data(client: ApitallyClient, requests_mock: Mocker):
     from apitally.client.client_base import HUB_BASE_URL, HUB_VERSION
 
     mock = requests_mock.register_uri("POST", f"{HUB_BASE_URL}/{HUB_VERSION}/{CLIENT_ID}/{ENV}/startup")
     data = {"paths": [], "client_version": "1.0.0", "starlette_version": "0.28.0", "python_version": "3.11.4"}
     client.set_startup_data(data)
+    with requests.Session() as session:
+        client.send_startup_data(session)
 
     assert len(mock.request_history) == 1
     request_data = mock.request_history[0].json()

{apitally-0.16.1 → apitally-0.16.3}/tests/test_fastapi.py

@@ -30,8 +30,6 @@ def app(module_mocker: MockerFixture) -> FastAPI:
 
     module_mocker.patch("apitally.client.client_asyncio.ApitallyClient._instance", None)
     module_mocker.patch("apitally.client.client_asyncio.ApitallyClient.start_sync_loop")
-    module_mocker.patch("apitally.client.client_asyncio.ApitallyClient.set_startup_data")
-    module_mocker.patch("apitally.starlette.ApitallyMiddleware.delayed_set_startup_data")
 
     def identify_consumer(request: Request) -> Optional[str]:
         if consumer := request.query_params.get("consumer"):

{apitally-0.16.1 → apitally-0.16.3}/tests/test_litestar.py

@@ -37,7 +37,6 @@ async def app(module_mocker: MockerFixture) -> Litestar:
 
     module_mocker.patch("apitally.client.client_asyncio.ApitallyClient._instance", None)
     module_mocker.patch("apitally.client.client_asyncio.ApitallyClient.start_sync_loop")
-    module_mocker.patch("apitally.client.client_asyncio.ApitallyClient.set_startup_data")
     module_mocker.patch("apitally.client.client_asyncio.ApitallyClient.handle_shutdown", mocked_handle_shutdown)
 
     @get("/foo")

{apitally-0.16.1 → apitally-0.16.3}/tests/test_starlette.py

@@ -28,8 +28,7 @@ if TYPE_CHECKING:
 async def app(request: FixtureRequest, module_mocker: MockerFixture) -> Starlette:
     module_mocker.patch("apitally.client.client_asyncio.ApitallyClient._instance", None)
     module_mocker.patch("apitally.client.client_asyncio.ApitallyClient.start_sync_loop")
-    module_mocker.patch("apitally.client.client_asyncio.ApitallyClient.set_startup_data")
-    module_mocker.patch("apitally.starlette.ApitallyMiddleware.delayed_set_startup_data")
+    module_mocker.patch("apitally.client.client_asyncio.ApitallyClient.handle_shutdown")
     if request.param == "starlette":
         return get_starlette_app()
     elif request.param == "fastapi":
@@ -184,35 +183,35 @@ def test_middleware_requests_ok(app: Starlette, mocker: MockerFixture):
     from starlette.testclient import TestClient
 
     mock = mocker.patch("apitally.client.requests.RequestCounter.add_request")
-    client = TestClient(app)
-
-    response = client.get("/api/foo")
-    assert response.status_code == 200
-    mock.assert_called_once()
-    assert mock.call_args is not None
-    assert mock.call_args.kwargs["consumer"] == "test"
-    assert mock.call_args.kwargs["method"] == "GET"
-    assert mock.call_args.kwargs["path"] == "/api/foo"
-    assert mock.call_args.kwargs["status_code"] == 200
-    assert mock.call_args.kwargs["response_time"] > 0
-
-    response = client.get("/api/foo/123")
-    assert response.status_code == 200
-    assert mock.call_count == 2
-    assert mock.call_args is not None
-    assert mock.call_args.kwargs["path"] == "/api/foo/{bar}"
-
-    response = client.post("/api/bar")
-    assert response.status_code == 200
-    assert mock.call_count == 3
-    assert mock.call_args is not None
-    assert mock.call_args.kwargs["method"] == "POST"
-
-    response = client.get("/stream")
-    assert response.status_code == 200
-    assert mock.call_count == 4
-    assert mock.call_args is not None
-    assert mock.call_args.kwargs["response_size"] == 6
+
+    with TestClient(app) as client:
+        response = client.get("/api/foo")
+        assert response.status_code == 200
+        mock.assert_called_once()
+        assert mock.call_args is not None
+        assert mock.call_args.kwargs["consumer"] == "test"
+        assert mock.call_args.kwargs["method"] == "GET"
+        assert mock.call_args.kwargs["path"] == "/api/foo"
+        assert mock.call_args.kwargs["status_code"] == 200
+        assert mock.call_args.kwargs["response_time"] > 0
+
+        response = client.get("/api/foo/123")
+        assert response.status_code == 200
+        assert mock.call_count == 2
+        assert mock.call_args is not None
+        assert mock.call_args.kwargs["path"] == "/api/foo/{bar}"
+
+        response = client.post("/api/bar")
+        assert response.status_code == 200
+        assert mock.call_count == 3
+        assert mock.call_args is not None
+        assert mock.call_args.kwargs["method"] == "POST"
+
+        response = client.get("/stream")
+        assert response.status_code == 200
+        assert mock.call_count == 4
+        assert mock.call_args is not None
+        assert mock.call_args.kwargs["response_size"] == 6
 
 
 def test_middleware_requests_error(app: Starlette, mocker: MockerFixture):
@@ -220,60 +219,60 @@ def test_middleware_requests_error(app: Starlette, mocker: MockerFixture):
 
     mock1 = mocker.patch("apitally.client.requests.RequestCounter.add_request")
     mock2 = mocker.patch("apitally.client.server_errors.ServerErrorCounter.add_server_error")
-    client = TestClient(app, raise_server_exceptions=False)
-
-    response = client.post("/api/baz")
-    assert response.status_code == 500
-    mock1.assert_called_once()
-    assert mock1.call_args is not None
-    assert mock1.call_args.kwargs["method"] == "POST"
-    assert mock1.call_args.kwargs["path"] == "/api/baz"
-    assert mock1.call_args.kwargs["status_code"] == 500
-    assert mock1.call_args.kwargs["response_time"] > 0
-
-    mock2.assert_called_once()
-    assert mock2.call_args is not None
-    exception = mock2.call_args.kwargs["exception"]
-    assert isinstance(exception, ValueError)
-
-    # Throws a ValueError in a background task, but returns 200
-    response = client.post("/test/task")
-    assert response.status_code == 200
-    assert mock1.call_count == 2
-    assert mock1.call_args is not None
-    assert mock1.call_args.kwargs["status_code"] == 200
-    mock2.assert_called_once()  # Not called again
+
+    with TestClient(app, raise_server_exceptions=False) as client:
+        response = client.post("/api/baz")
+        assert response.status_code == 500
+        mock1.assert_called_once()
+        assert mock1.call_args is not None
+        assert mock1.call_args.kwargs["method"] == "POST"
+        assert mock1.call_args.kwargs["path"] == "/api/baz"
+        assert mock1.call_args.kwargs["status_code"] == 500
+        assert mock1.call_args.kwargs["response_time"] > 0
+
+        mock2.assert_called_once()
+        assert mock2.call_args is not None
+        exception = mock2.call_args.kwargs["exception"]
+        assert isinstance(exception, ValueError)
+
+        # Throws a ValueError in a background task, but returns 200
+        response = client.post("/test/task")
+        assert response.status_code == 200
+        assert mock1.call_count == 2
+        assert mock1.call_args is not None
+        assert mock1.call_args.kwargs["status_code"] == 200
+        mock2.assert_called_once()  # Not called again
 
 
 def test_middleware_requests_unhandled(app: Starlette, mocker: MockerFixture):
     from starlette.testclient import TestClient
 
     mock = mocker.patch("apitally.client.requests.RequestCounter.add_request")
-    client = TestClient(app)
 
-    response = client.post("/xxx")
-    assert response.status_code == 404
-    mock.assert_not_called()
+    with TestClient(app) as client:
+        response = client.post("/xxx")
+        assert response.status_code == 404
+        mock.assert_not_called()
 
 
 def test_middleware_validation_error(app: Starlette, mocker: MockerFixture):
     from starlette.testclient import TestClient
 
     mock = mocker.patch("apitally.client.validation_errors.ValidationErrorCounter.add_validation_errors")
-    client = TestClient(app)
 
-    # Validation error as foo must be an integer
-    response = client.get("/api/val?foo=bar")
-    assert response.status_code == 422
+    with TestClient(app) as client:
+        # Validation error as foo must be an integer
+        response = client.get("/api/val?foo=bar")
+        assert response.status_code == 422
 
-    # FastAPI only
-    if response.headers["Content-Type"] == "application/json":
-        mock.assert_called_once()
-        assert mock.call_args is not None
-        assert mock.call_args.kwargs["method"] == "GET"
-        assert mock.call_args.kwargs["path"] == "/api/val"
-        assert len(mock.call_args.kwargs["detail"]) == 1
-        assert mock.call_args.kwargs["detail"][0]["loc"] == ["query", "foo"]
+        # FastAPI only
+        if response.headers["Content-Type"] == "application/json":
+            mock.assert_called_once()
+            assert mock.call_args is not None
+            assert mock.call_args.kwargs["method"] == "GET"
+            assert mock.call_args.kwargs["path"] == "/api/val"
+            assert len(mock.call_args.kwargs["detail"]) == 1
+            assert mock.call_args.kwargs["detail"][0]["loc"] == ["query", "foo"]
 
 
 def test_middleware_request_logging(app: Starlette, mocker: MockerFixture):
@@ -282,40 +281,40 @@ def test_middleware_request_logging(app: Starlette, mocker: MockerFixture):
     from apitally.client.request_logging import BODY_TOO_LARGE
 
     mock = mocker.patch("apitally.client.request_logging.RequestLogger.log_request")
-    client = TestClient(app)
-
-    response = client.get("/api/foo/123?foo=bar", headers={"Test-Header": "test"})
-    assert response.status_code == 200
-    mock.assert_called_once()
-    assert mock.call_args is not None
-    assert mock.call_args.kwargs["request"]["method"] == "GET"
-    assert mock.call_args.kwargs["request"]["path"] == "/api/foo/{bar}"
-    assert mock.call_args.kwargs["request"]["url"] == "http://testserver/api/foo/123?foo=bar"
-    assert ("test-header", "test") in mock.call_args.kwargs["request"]["headers"]
-    assert mock.call_args.kwargs["request"]["consumer"] == "test"
-    assert mock.call_args.kwargs["response"]["status_code"] == 200
-    assert mock.call_args.kwargs["response"]["response_time"] > 0
-    assert ("content-type", "text/plain; charset=utf-8") in mock.call_args.kwargs["response"]["headers"]
-    assert mock.call_args.kwargs["response"]["size"] > 0
-    assert mock.call_args.kwargs["response"]["body"] == b"foo: 123"
-
-    response = client.post("/api/bar", content=b"foo")
-    assert response.status_code == 200
-    assert mock.call_count == 2
-    assert mock.call_args is not None
-    assert mock.call_args.kwargs["request"]["method"] == "POST"
-    assert mock.call_args.kwargs["request"]["path"] == "/api/bar"
-    assert mock.call_args.kwargs["request"]["url"] == "http://testserver/api/bar"
-    assert mock.call_args.kwargs["request"]["body"] == b"foo"
-    assert mock.call_args.kwargs["response"]["body"] == b"bar: foo"
-
-    mocker.patch("apitally.starlette.MAX_BODY_SIZE", 2)
-    response = client.post("/api/bar", content=b"foo")
-    assert response.status_code == 200
-    assert mock.call_count == 3
-    assert mock.call_args is not None
-    assert mock.call_args.kwargs["request"]["body"] == BODY_TOO_LARGE
-    assert mock.call_args.kwargs["response"]["body"] == BODY_TOO_LARGE
+
+    with TestClient(app) as client:
+        response = client.get("/api/foo/123?foo=bar", headers={"Test-Header": "test"})
+        assert response.status_code == 200
+        mock.assert_called_once()
+        assert mock.call_args is not None
+        assert mock.call_args.kwargs["request"]["method"] == "GET"
+        assert mock.call_args.kwargs["request"]["path"] == "/api/foo/{bar}"
+        assert mock.call_args.kwargs["request"]["url"] == "http://testserver/api/foo/123?foo=bar"
+        assert ("test-header", "test") in mock.call_args.kwargs["request"]["headers"]
+        assert mock.call_args.kwargs["request"]["consumer"] == "test"
+        assert mock.call_args.kwargs["response"]["status_code"] == 200
+        assert mock.call_args.kwargs["response"]["response_time"] > 0
+        assert ("content-type", "text/plain; charset=utf-8") in mock.call_args.kwargs["response"]["headers"]
+        assert mock.call_args.kwargs["response"]["size"] > 0
+        assert mock.call_args.kwargs["response"]["body"] == b"foo: 123"
+
+        response = client.post("/api/bar", content=b"foo")
+        assert response.status_code == 200
+        assert mock.call_count == 2
+        assert mock.call_args is not None
+        assert mock.call_args.kwargs["request"]["method"] == "POST"
+        assert mock.call_args.kwargs["request"]["path"] == "/api/bar"
+        assert mock.call_args.kwargs["request"]["url"] == "http://testserver/api/bar"
+        assert mock.call_args.kwargs["request"]["body"] == b"foo"
+        assert mock.call_args.kwargs["response"]["body"] == b"bar: foo"
+
+        mocker.patch("apitally.starlette.MAX_BODY_SIZE", 2)
+        response = client.post("/api/bar", content=b"foo")
+        assert response.status_code == 200
+        assert mock.call_count == 3
+        assert mock.call_args is not None
+        assert mock.call_args.kwargs["request"]["body"] == BODY_TOO_LARGE
+        assert mock.call_args.kwargs["response"]["body"] == BODY_TOO_LARGE
 
 
 def test_get_startup_data(app: Starlette, mocker: MockerFixture):