chore(coverage): close branch-coverage gaps under tightened --cov=. gate

Add targeted tests for uncovered branches in client.py (cookies/limits/auth
kwargs, InvalidURL exception mapping, RuntimeError re-raise, and all
_request_with_body optional-kwarg branches) and in middleware/__init__.py
(__repr__ methods on before_request/after_response/on_error wrappers).
Apply # pragma: no cover to test-helper methods that are structural
placeholders never invoked (protocol-check __call__, default-arg guards,
and the unreachable swallow_all body in the CancelledError test).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: lesnik512

tests/test_client_construction.py

@@ -55,18 +55,32 @@ def test_default_decoder_is_pydantic_decoder() -> None:
 
 def test_explicit_decoder_is_honored() -> None:
     class _Stub:
-        def decode(self, content: bytes, model: type) -> object:  # noqa: ARG002
+        def decode(self, content: bytes, model: type) -> object:  # noqa: ARG002  # pragma: no cover
             return None
 
     client = AsyncClient(decoder=_Stub())
     assert isinstance(client._decoder, _Stub)  # noqa: SLF001
 
 
+@pytest.mark.parametrize(
+    "kwargs",
+    [
+        {"cookies": {"session": "abc"}},
+        {"limits": httpx2.Limits(max_connections=5)},
+        {"auth": httpx2.BasicAuth("user", "pass")},
+    ],
+)
+def test_construction_with_optional_forwarded_kwargs(kwargs: dict) -> None:
+    """Exercises cookies/limits/auth branches in __init__ when no httpx2_client is supplied."""
+    client = AsyncClient(**kwargs)
+    assert isinstance(client, AsyncClient)
+
+
 def test_explicit_middleware_is_honored() -> None:
     captured: list[str] = []
 
     class _Tag:
-        async def __call__(self, request, next) -> httpx2.Response:  # noqa: A002, ANN001
+        async def __call__(self, request, next) -> httpx2.Response:  # noqa: A002, ANN001  # pragma: no cover
             captured.append("tag")
             return await next(request)
 

tests/test_client_methods.py

@@ -100,3 +100,63 @@ def handler(request: httpx2.Request) -> httpx2.Response:
     client = AsyncClient(httpx2_client=underlying)
     await client.get("/relative")
     assert str(captured[0].url) == "https://example.test/relative"
+
+
+async def test_get_with_cookies_forwarded() -> None:
+    """Exercises the cookies branch in _request_with_body."""
+    captured: list[httpx2.Request] = []
+
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        captured.append(request)
+        return httpx2.Response(HTTPStatus.OK, request=request)
+
+    client = _client_with_handler(handler)
+    await client.get("https://example.test/x", cookies={"token": "abc"})
+    assert "token=abc" in captured[0].headers.get("cookie", "")
+
+
+async def test_get_with_explicit_timeout() -> None:
+    """Exercises the timeout branch in _request_with_body."""
+    client = _client_with_handler(_echo_handler)
+    response = await client.get("https://example.test/x", timeout=5.0)
+    assert response.status_code == HTTPStatus.OK
+
+
+async def test_get_with_extensions() -> None:
+    """Exercises the extensions branch in _request_with_body."""
+    client = _client_with_handler(_echo_handler)
+    response = await client.get("https://example.test/x", extensions={"trace": True})
+    assert response.status_code == HTTPStatus.OK
+
+
+async def test_post_with_content_body() -> None:
+    """Exercises the content branch in _request_with_body."""
+    client = _client_with_handler(_echo_handler)
+    response = await client.post("https://example.test/x", content=b"raw-bytes")
+    assert response.json()["content"] == "raw-bytes"
+
+
+async def test_post_with_data_body() -> None:
+    """Exercises the data branch in _request_with_body."""
+    client = _client_with_handler(_echo_handler)
+    response = await client.post("https://example.test/x", data={"field": "value"})
+    assert response.status_code == HTTPStatus.OK
+
+
+async def test_post_with_files_body() -> None:
+    """Exercises the files branch in _request_with_body."""
+    client = _client_with_handler(_echo_handler)
+    response = await client.post("https://example.test/x", files={"upload": b"file-content"})
+    assert response.status_code == HTTPStatus.OK
+
+
+async def test_runtime_error_without_closed_reraises() -> None:
+    """Exercises the RuntimeError re-raise branch in _terminal (error not containing 'closed')."""
+
+    def boom(request: httpx2.Request) -> httpx2.Response:  # noqa: ARG001
+        msg = "unexpected internal failure"
+        raise RuntimeError(msg)
+
+    client = _client_with_handler(boom)
+    with pytest.raises(RuntimeError, match="unexpected internal failure"):
+        await client.get("https://example.test/x")

tests/test_error_mapping_terminal.py

@@ -91,6 +91,16 @@ def handler(request: httpx2.Request) -> httpx2.Response:  # noqa: ARG001
         await client.send(httpx2.Request("GET", "https://example.test/x"))
 
 
+async def test_httpx2_invalid_url_maps_to_transport_error() -> None:
+    def handler(request: httpx2.Request) -> httpx2.Response:  # noqa: ARG001
+        msg = "synthetic invalid URL from transport"
+        raise httpx2.InvalidURL(msg)
+
+    client = _client_with_handler(handler)
+    with pytest.raises(TransportError, match="synthetic invalid URL"):
+        await client.send(httpx2.Request("GET", "https://example.test/x"))
+
+
 async def test_send_on_closed_client_raises_transport_error() -> None:
     transport = httpx2.MockTransport(lambda req: httpx2.Response(HTTPStatus.OK, request=req))
     underlying = httpx2.AsyncClient(transport=transport)

tests/test_middleware.py

@@ -21,14 +21,14 @@ def _make_request(url: str = "https://example.test/x") -> httpx2.Request:
 
 
 def _make_response(status: int = HTTPStatus.OK, *, request: httpx2.Request | None = None) -> httpx2.Response:
-    if request is None:
+    if request is None:  # pragma: no cover
         request = _make_request()
     return httpx2.Response(status, request=request)
 
 
 async def test_middleware_protocol_is_runtime_checkable() -> None:
     class _OkMiddleware:
-        async def __call__(self, request: httpx2.Request, next: Next) -> httpx2.Response:  # noqa: A002
+        async def __call__(self, request: httpx2.Request, next: Next) -> httpx2.Response:  # noqa: A002  # pragma: no cover
             return await next(request)
 
     assert isinstance(_OkMiddleware(), Middleware)
@@ -104,7 +104,7 @@ async def test_on_error_decorator_can_translate_exception() -> None:
     async def swallow(request: httpx2.Request, exc: Exception) -> httpx2.Response | None:
         if isinstance(exc, RuntimeError) and str(exc) == "boom":
             return _make_response(HTTPStatus.SERVICE_UNAVAILABLE, request=request)
-        return None
+        return None  # pragma: no cover
 
     async def terminal(request: httpx2.Request) -> httpx2.Response:  # noqa: ARG001
         msg = "boom"
@@ -132,12 +132,39 @@ async def terminal(request: httpx2.Request) -> httpx2.Response:  # noqa: ARG001
         await dispatch(_make_request())
 
 
+def test_before_request_repr() -> None:
+    @before_request
+    async def my_transform(request: httpx2.Request) -> httpx2.Request:
+        return request  # pragma: no cover
+
+    assert "before_request" in repr(my_transform)
+    assert "my_transform" in repr(my_transform)
+
+
+def test_after_response_repr() -> None:
+    @after_response
+    async def my_transform(request: httpx2.Request, response: httpx2.Response) -> httpx2.Response:  # noqa: ARG001
+        return response  # pragma: no cover
+
+    assert "after_response" in repr(my_transform)
+    assert "my_transform" in repr(my_transform)
+
+
+def test_on_error_repr() -> None:
+    @on_error
+    async def my_handler(request: httpx2.Request, exc: Exception) -> httpx2.Response | None:  # noqa: ARG001
+        return None  # pragma: no cover
+
+    assert "on_error" in repr(my_handler)
+    assert "my_handler" in repr(my_handler)
+
+
 async def test_on_error_lets_cancelled_propagate() -> None:
     @on_error
     async def swallow_all(
         request: httpx2.Request,  # noqa: ARG001
         exc: Exception,  # noqa: ARG001
-    ) -> httpx2.Response | None:
+    ) -> httpx2.Response | None:  # pragma: no cover
         msg = "should not catch CancelledError"
         raise AssertionError(msg)