httpx2-pytest 1.0.0__py3-none-any.whl

httpx2_pytest-1.0.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+httpx2_pytest-1.0.0.dist-info/licenses/LICENSE.txt,sha256=ib2JF6cwoV7nyeX4c0sDLdhrZ7Ob_htsSjU2yntwlBs,1076
+pytest_httpx2/__init__.py,sha256=YCQj6qz-vh1lMs05vBYRqyNCQp6rJEx9WGqIcwwh77s,2932
+pytest_httpx2/_httpx_internals.py,sha256=Ilzvtg-JfXlJgmEzUtoBAXZCTfieI3FrnLjUbOfejxs,1885
+pytest_httpx2/_httpx_mock.py,sha256=UtKcuv5WJhNBd9rjj5cPGQEt9OvATVyGLkIH9ibAoP0,20283
+pytest_httpx2/_options.py,sha256=aNoquhLGycu3tSN0zt51JuzMaHbitRh2TNgf0HL-Xvw,681
+pytest_httpx2/_pretty_print.py,sha256=racZ7du0l7uNhTfik2Kb0QLLZY1guXrkcsQ7yiu6gjc,2804
+pytest_httpx2/_request_matcher.py,sha256=b5zsDqg8wVYrqsKmESs3v_gIcd3UQU2MoN4YGaMnbec,10828
+pytest_httpx2/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pytest_httpx2/version.py,sha256=OACSSeX9t5kwvTTY-7QCyGcmxapSWwM6xDUHbFQTiRk,399
+httpx2_pytest-1.0.0.dist-info/METADATA,sha256=79Im7ZLJ5URiiQoatj2EwgGfozmAni9gJLe75M4TQZc,37713
+httpx2_pytest-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+httpx2_pytest-1.0.0.dist-info/entry_points.txt,sha256=SlRnMRGPZ-RP71afgn-lVHWXs5z1HafRWmMdLlrYZqs,41
+httpx2_pytest-1.0.0.dist-info/top_level.txt,sha256=o2aJBtQGp3dIFjbw5SIWSV6CuRwxaL-VCrnxrZbTcQw,14
+httpx2_pytest-1.0.0.dist-info/RECORD,,

httpx2_pytest-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

httpx2_pytest-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pytest11]
+pytest_httpx2 = pytest_httpx2

httpx2_pytest-1.0.0.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020-2026 Colin Bounouar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

httpx2_pytest-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pytest_httpx2

pytest_httpx2/__init__.py

@@ -0,0 +1,96 @@
+from collections.abc import Generator
+from operator import methodcaller
+
+import httpx2
+import pytest
+from pytest import Config, FixtureRequest, MonkeyPatch
+
+from pytest_httpx2._httpx_internals import IteratorStream
+from pytest_httpx2._httpx_mock import HTTPXMock
+from pytest_httpx2._options import _HTTPXMockOptions
+from pytest_httpx2.version import __version__
+
+__all__ = (
+    "HTTPXMock",
+    "IteratorStream",
+    "__version__",
+)
+
+
+def _httpx_mock_options(request: FixtureRequest) -> _HTTPXMockOptions:
+    httpx_mock_markers: dict = {}
+    for marker_name in ("httpx_mock", "httpx2_mock"):
+        for marker in request.node.iter_markers(marker_name):
+            httpx_mock_markers = marker.kwargs | httpx_mock_markers
+    __tracebackhide__ = methodcaller("errisinstance", TypeError)
+    return _HTTPXMockOptions(**httpx_mock_markers)
+
+
+@pytest.fixture
+def httpx_mock(
+    monkeypatch: MonkeyPatch,
+    request: FixtureRequest,
+) -> Generator[HTTPXMock, None, None]:
+    options = _httpx_mock_options(request)
+    mock = HTTPXMock(options)
+
+    # Mock synchronous requests
+    real_handle_request = httpx2.HTTPTransport.handle_request
+
+    def mocked_handle_request(
+        transport: httpx2.HTTPTransport, request: httpx2.Request
+    ) -> httpx2.Response:
+        if options.should_mock(request):
+            return mock._handle_request(transport, request)
+        return real_handle_request(transport, request)
+
+    monkeypatch.setattr(
+        httpx2.HTTPTransport,
+        "handle_request",
+        mocked_handle_request,
+    )
+
+    # Mock asynchronous requests
+    real_handle_async_request = httpx2.AsyncHTTPTransport.handle_async_request
+
+    async def mocked_handle_async_request(
+        transport: httpx2.AsyncHTTPTransport, request: httpx2.Request
+    ) -> httpx2.Response:
+        if options.should_mock(request):
+            return await mock._handle_async_request(transport, request)
+        return await real_handle_async_request(transport, request)
+
+    monkeypatch.setattr(
+        httpx2.AsyncHTTPTransport,
+        "handle_async_request",
+        mocked_handle_async_request,
+    )
+
+    yield mock
+    try:
+        mock._assert_options()
+    finally:
+        mock.reset()
+
+
+@pytest.fixture
+def httpx2_mock(httpx_mock: HTTPXMock) -> HTTPXMock:
+    """Alias of :func:`httpx_mock` for HTTPX2-oriented test suites."""
+    return httpx_mock
+
+
+def pytest_configure(config: Config) -> None:
+    marker_signature = (
+        "*, assert_all_responses_were_requested=True, "
+        "assert_all_requests_were_expected=True, "
+        "can_send_already_matched_responses=False, "
+        "should_mock=lambda request: True"
+    )
+    config.addinivalue_line(
+        "markers",
+        f"httpx_mock({marker_signature}): Configure httpx_mock / httpx2_mock fixtures.",
+    )
+    config.addinivalue_line(
+        "markers",
+        f"httpx2_mock({marker_signature}): Configure httpx_mock / httpx2_mock fixtures.",
+    )

pytest_httpx2/_httpx_internals.py

@@ -0,0 +1,60 @@
+import base64
+from collections.abc import AsyncIterator, Iterable, Iterator, Sequence
+
+import httpcore2 as httpcore
+import httpx2
+
+# TODO Get rid of this internal import
+from httpx2._content import AsyncIteratorByteStream, IteratorByteStream
+
+# Those types are internally defined within httpx2._types
+HeaderTypes = (
+    httpx2.Headers
+    | dict[str, str]
+    | dict[bytes, bytes]
+    | Sequence[tuple[str, str]]
+    | Sequence[tuple[bytes, bytes]]
+)
+PrimitiveData = str | int | float | bool | None
+
+
+class IteratorStream(AsyncIteratorByteStream, IteratorByteStream):
+    def __init__(self, stream: Iterable[bytes]):
+        class Stream:
+            def __iter__(self) -> Iterator[bytes]:
+                yield from stream
+
+            async def __aiter__(self) -> AsyncIterator[bytes]:
+                for chunk in stream:
+                    yield chunk
+
+        AsyncIteratorByteStream.__init__(self, stream=Stream())
+        IteratorByteStream.__init__(self, stream=Stream())
+
+
+def _to_httpx_url(url: httpcore.URL, headers: list[tuple[bytes, bytes]]) -> httpx2.URL:
+    for name, value in headers:
+        if b"Proxy-Authorization" == name:
+            return httpx2.URL(
+                scheme=url.scheme.decode(),
+                host=url.host.decode(),
+                port=url.port,
+                raw_path=url.target,
+                userinfo=base64.b64decode(value[6:]),
+            )
+
+    return httpx2.URL(
+        scheme=url.scheme.decode(),
+        host=url.host.decode(),
+        port=url.port,
+        raw_path=url.target,
+    )
+
+
+def _proxy_url(
+    real_transport: httpx2.BaseTransport | httpx2.AsyncBaseTransport,
+) -> httpx2.URL | None:
+    real_pool = getattr(real_transport, "_pool", None)
+    if isinstance(real_pool, (httpcore.HTTPProxy, httpcore.AsyncHTTPProxy)):
+        return _to_httpx_url(real_pool._proxy_url, real_pool._proxy_headers)
+    return None

pytest_httpx2/_httpx_mock.py

@@ -0,0 +1,372 @@
+import copy
+import inspect
+from collections.abc import Awaitable, Callable
+from typing import Any
+
+import httpx2
+
+from pytest_httpx2 import _httpx_internals
+from pytest_httpx2._options import _HTTPXMockOptions
+from pytest_httpx2._pretty_print import RequestDescription
+from pytest_httpx2._request_matcher import _RequestMatcher
+
+
+class HTTPXMock:
+    """
+    This class is only exposed for `httpx_mock` fixture type hinting purpose.
+    """
+
+    def __init__(self, options: _HTTPXMockOptions) -> None:
+        """Private and subject to breaking changes without notice."""
+        self._options = options
+        self._requests: list[
+            tuple[httpx2.HTTPTransport | httpx2.AsyncHTTPTransport, httpx2.Request]
+        ] = []
+        self._callbacks: list[
+            tuple[
+                _RequestMatcher,
+                Callable[
+                    [httpx2.Request],
+                    httpx2.Response | None | Awaitable[httpx2.Response | None],
+                ],
+            ]
+        ] = []
+        self._requests_not_matched: list[httpx2.Request] = []
+
+    def add_response(
+        self,
+        status_code: int = 200,
+        http_version: str = "HTTP/1.1",
+        headers: _httpx_internals.HeaderTypes | None = None,
+        content: bytes | None = None,
+        text: str | None = None,
+        html: str | None = None,
+        stream: Any = None,
+        json: Any = None,
+        **matchers: Any,
+    ) -> None:
+        """
+        Mock the response that will be sent if a request match.
+
+        :param status_code: HTTP status code of the response to send. Default to 200 (OK).
+        :param http_version: HTTP protocol version of the response to send. Default to HTTP/1.1
+        :param headers: HTTP headers of the response to send. Default to no headers.
+        :param content: HTTP body of the response (as bytes).
+        :param text: HTTP body of the response (as string).
+        :param html: HTTP body of the response (as HTML string content).
+        :param stream: HTTP body of the response (as httpx2.SyncByteStream or httpx2.AsyncByteStream) as stream content.
+        :param json: HTTP body of the response (if JSON should be used as content type) if data is not provided.
+        :param url: Full URL identifying the request(s) to match. Use in addition to match_params if you do not want to provide query parameters as part of the URL.
+        Can be a str, a re.Pattern instance or a httpx2.URL instance.
+        :param method: HTTP method identifying the request(s) to match.
+        :param proxy_url: Full proxy URL identifying the request(s) to match.
+        Can be a str, a re.Pattern instance or a httpx2.URL instance.
+        :param match_headers: HTTP headers identifying the request(s) to match. Must be a dictionary.
+        :param match_content: Full HTTP body identifying the request(s) to match. Must be bytes.
+        :param match_json: JSON decoded HTTP body identifying the request(s) to match. Must be JSON encodable.
+        :param match_data: Multipart data (excluding files) identifying the request(s) to match. Must be a dictionary.
+        :param match_files: Multipart files identifying the request(s) to match. Refer to httpx2 documentation for more information on supported values: https://httpx2.pydantic.dev/advanced/clients/#multipart-file-encoding
+        :param match_extensions: Extensions identifying the request(s) to match. Must be a dictionary.
+        :param match_params: Query string parameters identifying the request(s) to match (if not provided as part of URL already). Must be a dictionary with str keys (parameter name) and str, bool, int or float values (or a list of values if parameter is provided more than once).
+        :param is_optional: True will mark this response as optional, False will expect a request matching it. Must be a boolean. Default to the opposite of assert_all_responses_were_requested option value (itself defaulting to True, meaning this parameter default to False).
+        :param is_reusable: True will allow re-using this response even if it already matched, False prevent re-using it. Must be a boolean. Default to the can_send_already_matched_responses option value (itself defaulting to False).
+        """
+
+        json = copy.deepcopy(json) if json is not None else None
+
+        def response_callback(request: httpx2.Request) -> httpx2.Response:
+            return httpx2.Response(
+                status_code=status_code,
+                extensions={"http_version": http_version.encode("ascii")},
+                headers=headers,
+                json=json,
+                content=content,
+                text=text,
+                html=html,
+                stream=stream,
+            )
+
+        self.add_callback(response_callback, **matchers)
+
+    def add_callback(
+        self,
+        callback: Callable[
+            [httpx2.Request],
+            httpx2.Response | None | Awaitable[httpx2.Response | None],
+        ],
+        **matchers: Any,
+    ) -> None:
+        """
+        Mock the action that will take place if a request match.
+
+        :param callback: The callable that will be called upon reception of the matched request.
+        It must expect one parameter, the received httpx2.Request and should return a httpx2.Response.
+        :param url: Full URL identifying the request(s) to match. Use in addition to match_params if you do not want to provide query parameters as part of the URL.
+        Can be a str, a re.Pattern instance or a httpx2.URL instance.
+        :param method: HTTP method identifying the request(s) to match.
+        :param proxy_url: Full proxy URL identifying the request(s) to match.
+        Can be a str, a re.Pattern instance or a httpx2.URL instance.
+        :param match_headers: HTTP headers identifying the request(s) to match. Must be a dictionary.
+        :param match_content: Full HTTP body identifying the request(s) to match. Must be bytes.
+        :param match_json: JSON decoded HTTP body identifying the request(s) to match. Must be JSON encodable.
+        :param match_data: Multipart data (excluding files) identifying the request(s) to match. Must be a dictionary.
+        :param match_files: Multipart files identifying the request(s) to match. Refer to httpx2 documentation for more information on supported values: https://httpx2.pydantic.dev/advanced/clients/#multipart-file-encoding
+        :param match_extensions: Extensions identifying the request(s) to match. Must be a dictionary.
+        :param match_params: Query string parameters identifying the request(s) to match (if not provided as part of URL already). Must be a dictionary with str keys (parameter name) and str, bool, int or float values (or a list of values if parameter is provided more than once).
+        :param is_optional: True will mark this callback as optional, False will expect a request matching it. Must be a boolean. Default to the opposite of assert_all_responses_were_requested option value (itself defaulting to True, meaning this parameter default to False).
+        :param is_reusable: True will allow re-using this callback even if it already matched, False prevent re-using it. Must be a boolean. Default to the can_send_already_matched_responses option value (itself defaulting to False).
+        """
+        self._callbacks.append((_RequestMatcher(self._options, **matchers), callback))
+
+    def add_exception(self, exception: BaseException, **matchers: Any) -> None:
+        """
+        Raise an exception if a request match.
+
+        :param exception: The exception that will be raised upon reception of the matched request.
+        :param url: Full URL identifying the request(s) to match. Use in addition to match_params if you do not want to provide query parameters as part of the URL.
+        Can be a str, a re.Pattern instance or a httpx2.URL instance.
+        :param method: HTTP method identifying the request(s) to match.
+        :param proxy_url: Full proxy URL identifying the request(s) to match.
+        Can be a str, a re.Pattern instance or a httpx2.URL instance.
+        :param match_headers: HTTP headers identifying the request(s) to match. Must be a dictionary.
+        :param match_content: Full HTTP body identifying the request(s) to match. Must be bytes.
+        :param match_json: JSON decoded HTTP body identifying the request(s) to match. Must be JSON encodable.
+        :param match_data: Multipart data (excluding files) identifying the request(s) to match. Must be a dictionary.
+        :param match_files: Multipart files identifying the request(s) to match. Refer to httpx2 documentation for more information on supported values: https://httpx2.pydantic.dev/advanced/clients/#multipart-file-encoding
+        :param match_extensions: Extensions identifying the request(s) to match. Must be a dictionary.
+        :param match_params: Query string parameters identifying the request(s) to match (if not provided as part of URL already). Must be a dictionary with str keys (parameter name) and str, bool, int or float values (or a list of values if parameter is provided more than once).
+        :param is_optional: True will mark this exception response as optional, False will expect a request matching it. Must be a boolean. Default to the opposite of assert_all_responses_were_requested option value (itself defaulting to True, meaning this parameter default to False).
+        :param is_reusable: True will allow re-using this exception response even if it already matched, False prevent re-using it. Must be a boolean. Default to the can_send_already_matched_responses option value (itself defaulting to False).
+        """
+
+        def exception_callback(request: httpx2.Request) -> None:
+            if isinstance(exception, httpx2.RequestError):
+                exception.request = request
+            raise exception
+
+        self.add_callback(exception_callback, **matchers)
+
+    def _handle_request(
+        self,
+        real_transport: httpx2.HTTPTransport,
+        request: httpx2.Request,
+    ) -> httpx2.Response:
+        # Store the content in request for future matching
+        request.read()
+        self._requests.append((real_transport, request))
+
+        callback = self._get_callback(real_transport, request)
+        if callback:
+            response = callback(request)
+
+            if isinstance(response, httpx2.Response):
+                return _unread(response)
+
+            raise self._request_not_matched(
+                request,
+                self._explain_that_callback_must_return_a_response(
+                    real_transport, request
+                ),
+            )
+
+        raise self._request_not_matched(
+            request, self._explain_that_no_response_was_found(real_transport, request)
+        )
+
+    async def _handle_async_request(
+        self,
+        real_transport: httpx2.AsyncHTTPTransport,
+        request: httpx2.Request,
+    ) -> httpx2.Response:
+        # Store the content in request for future matching
+        await request.aread()
+        self._requests.append((real_transport, request))
+
+        callback = self._get_callback(real_transport, request)
+        if callback:
+            response = callback(request)
+
+            if inspect.isawaitable(response):
+                response = await response
+
+            if isinstance(response, httpx2.Response):
+                return _unread(response)
+
+            raise self._request_not_matched(
+                request,
+                self._explain_that_callback_must_return_a_response(
+                    real_transport, request
+                ),
+            )
+
+        raise self._request_not_matched(
+            request, self._explain_that_no_response_was_found(real_transport, request)
+        )
+
+    def _request_not_matched(
+        self, request: httpx2.Request, message: str
+    ) -> httpx2.TimeoutException:
+        self._requests_not_matched.append(request)
+        return httpx2.TimeoutException(message, request=request)
+
+    def _explain_that_callback_must_return_a_response(
+        self,
+        real_transport: httpx2.BaseTransport | httpx2.AsyncBaseTransport,
+        request: httpx2.Request,
+    ) -> str:
+        return f"Callback registered for {RequestDescription(real_transport, request, [])} MUST return httpx2.Response"
+
+    def _explain_that_no_response_was_found(
+        self,
+        real_transport: httpx2.BaseTransport | httpx2.AsyncBaseTransport,
+        request: httpx2.Request,
+    ) -> str:
+        matchers = [matcher for matcher, _ in self._callbacks]
+
+        message = f"No response can be found for {RequestDescription(real_transport, request, matchers)}"
+
+        already_matched = []
+        unmatched = []
+        for matcher in matchers:
+            if matcher.nb_calls:
+                already_matched.append(matcher)
+            else:
+                unmatched.append(matcher)
+
+        matchers_description = "\n".join(
+            [f"- {matcher}" for matcher in unmatched + already_matched]
+        )
+        if matchers_description:
+            message += f" amongst:\n{matchers_description}"
+            # If we could not find a response, but we have already matched responses
+            # it might be that user is expecting one of those responses to be reused
+            if any(not matcher.is_reusable for matcher in already_matched):
+                message += "\n\nIf you wanted to reuse an already matched response instead of registering it again, refer to https://github.com/angryfoxx/pytest_httpx2/blob/master/README.md#allow-to-register-a-response-for-more-than-one-request"
+
+        return message
+
+    def _get_callback(
+        self,
+        real_transport: httpx2.HTTPTransport | httpx2.AsyncHTTPTransport,
+        request: httpx2.Request,
+    ) -> (
+        Callable[
+            [httpx2.Request], httpx2.Response | None | Awaitable[httpx2.Response | None]
+        ]
+        | None
+    ):
+        callbacks = [
+            (matcher, callback)
+            for matcher, callback in self._callbacks
+            if matcher.match(real_transport, request)
+        ]
+
+        # No callback match this request
+        if not callbacks:
+            return None
+
+        # Callbacks match this request
+        for matcher, callback in callbacks:
+            # Return the first not yet called
+            if not matcher.nb_calls:
+                matcher.nb_calls += 1
+                return callback
+
+        # Or the last registered (if it can be reused)
+        if matcher.is_reusable:
+            matcher.nb_calls += 1
+            return callback
+
+        # All callbacks have already been matched and last registered cannot be reused
+        return None
+
+    def get_requests(self, **matchers: Any) -> list[httpx2.Request]:
+        """
+        Return all requests sent that match (empty list if no requests were matched).
+
+        :param url: Full URL identifying the requests to retrieve. Use in addition to match_params if you do not want to provide query parameters as part of the URL.
+        Can be a str, a re.Pattern instance or a httpx2.URL instance.
+        :param method: HTTP method identifying the requests to retrieve. Must be an upper-cased string value.
+        :param proxy_url: Full proxy URL identifying the requests to retrieve.
+        Can be a str, a re.Pattern instance or a httpx2.URL instance.
+        :param match_headers: HTTP headers identifying the requests to retrieve. Must be a dictionary.
+        :param match_content: Full HTTP body identifying the requests to retrieve. Must be bytes.
+        :param match_json: JSON decoded HTTP body identifying the requests to retrieve. Must be JSON encodable.
+        :param match_data: Multipart data (excluding files) identifying the requests to retrieve. Must be a dictionary.
+        :param match_files: Multipart files identifying the requests to retrieve. Refer to httpx2 documentation for more information on supported values: https://httpx2.pydantic.dev/advanced/clients/#multipart-file-encoding
+        :param match_extensions: Extensions identifying the requests to retrieve. Must be a dictionary.
+        :param match_params: Query string parameters identifying the requests to retrieve (if not provided as part of URL already). Must be a dictionary with str keys (parameter name) and str, bool, int or float values (or a list of values if parameter is provided more than once).
+        """
+        matcher = _RequestMatcher(self._options, **matchers)
+        return [
+            request
+            for real_transport, request in self._requests
+            if matcher.match(real_transport, request)
+        ]
+
+    def get_request(self, **matchers: Any) -> httpx2.Request | None:
+        """
+        Return the single request that match (or None).
+
+        :param url: Full URL identifying the request to retrieve. Use in addition to match_params if you do not want to provide query parameters as part of the URL.
+        Can be a str, a re.Pattern instance or a httpx2.URL instance.
+        :param method: HTTP method identifying the request to retrieve. Must be an upper-cased string value.
+        :param proxy_url: Full proxy URL identifying the request to retrieve.
+        Can be a str, a re.Pattern instance or a httpx2.URL instance.
+        :param match_headers: HTTP headers identifying the request to retrieve. Must be a dictionary.
+        :param match_content: Full HTTP body identifying the request to retrieve. Must be bytes.
+        :param match_json: JSON decoded HTTP body identifying the request to retrieve. Must be JSON encodable.
+        :param match_data: Multipart data (excluding files) identifying the request to retrieve. Must be a dictionary.
+        :param match_files: Multipart files identifying the request to retrieve. Refer to httpx2 documentation for more information on supported values: https://httpx2.pydantic.dev/advanced/clients/#multipart-file-encoding
+        :param match_extensions: Extensions identifying the request to retrieve. Must be a dictionary.
+        :param match_params: Query string parameters identifying the request to retrieve (if not provided as part of URL already). Must be a dictionary with str keys (parameter name) and str, bool, int or float values (or a list of values if parameter is provided more than once).
+        :raises AssertionError: in case more than one request match.
+        """
+        requests = self.get_requests(**matchers)
+        assert len(requests) <= 1, (
+            f"More than one request ({len(requests)}) matched, use get_requests instead or refine your filters."
+        )
+        return requests[0] if requests else None
+
+    def reset(self) -> None:
+        self._requests.clear()
+        self._callbacks.clear()
+        self._requests_not_matched.clear()
+
+    def _assert_options(self) -> None:
+        callbacks_not_executed = [
+            matcher for matcher, _ in self._callbacks if matcher.should_have_matched()
+        ]
+        matchers_description = "\n".join(
+            [f"- {matcher}" for matcher in callbacks_not_executed]
+        )
+
+        assert not callbacks_not_executed, (
+            "The following responses are mocked but not requested:\n"
+            f"{matchers_description}\n"
+            "\n"
+            "If this is on purpose, refer to https://github.com/angryfoxx/pytest_httpx2/blob/master/README.md#allow-to-register-more-responses-than-what-will-be-requested"
+        )
+
+        if self._options.assert_all_requests_were_expected:
+            requests_description = "\n".join(
+                [
+                    f"- {request.method} request on {request.url}"
+                    for request in self._requests_not_matched
+                ]
+            )
+            assert not self._requests_not_matched, (
+                f"The following requests were not expected:\n"
+                f"{requests_description}\n"
+                "\n"
+                "If this is on purpose, refer to https://github.com/angryfoxx/pytest_httpx2/blob/master/README.md#allow-to-not-register-responses-for-every-request"
+            )
+
+
+def _unread(response: httpx2.Response) -> httpx2.Response:
+    # Allow to read the response on client side
+    response.is_stream_consumed = False
+    response.is_closed = False
+    if hasattr(response, "_content"):
+        del response._content
+    return response

pytest_httpx2/_options.py

@@ -0,0 +1,18 @@
+from collections.abc import Callable
+
+import httpx2
+
+
+class _HTTPXMockOptions:
+    def __init__(
+        self,
+        *,
+        assert_all_responses_were_requested: bool = True,
+        assert_all_requests_were_expected: bool = True,
+        can_send_already_matched_responses: bool = False,
+        should_mock: Callable[[httpx2.Request], bool] = lambda request: True,
+    ) -> None:
+        self.assert_all_responses_were_requested = assert_all_responses_were_requested
+        self.assert_all_requests_were_expected = assert_all_requests_were_expected
+        self.can_send_already_matched_responses = can_send_already_matched_responses
+        self.should_mock = should_mock

pytest_httpx2/_pretty_print.py

@@ -0,0 +1,72 @@
+import httpx2
+
+from pytest_httpx2._httpx_internals import _proxy_url
+from pytest_httpx2._request_matcher import _RequestMatcher
+
+
+class RequestDescription:
+    def __init__(
+        self,
+        real_transport: httpx2.BaseTransport | httpx2.AsyncBaseTransport,
+        request: httpx2.Request,
+        matchers: list[_RequestMatcher],
+    ):
+        self.real_transport = real_transport
+        self.request = request
+
+        headers_encoding = request.headers.encoding
+        self.expected_headers = {
+            # httpx2 uses lower cased header names as internal key
+            header.lower().encode(headers_encoding)
+            for matcher in matchers
+            if matcher.headers
+            for header in matcher.headers
+        }
+        self.expect_body = any([matcher.expect_body() for matcher in matchers])
+        self.expect_proxy = any([matcher.proxy_url is not None for matcher in matchers])
+        self.expected_extensions = {
+            extension
+            for matcher in matchers
+            if matcher.extensions
+            for extension in matcher.extensions
+        }
+
+    def __str__(self) -> str:
+        request_description = f"{self.request.method} request on {self.request.url}"
+        if extra_description := self.extra_request_description():
+            request_description += f" with {extra_description}"
+        return request_description
+
+    def extra_request_description(self) -> str:
+        extra_description = []
+
+        if self.expected_headers:
+            headers_encoding = self.request.headers.encoding
+            present_headers: dict = {}
+            # Can be cleaned based on the outcome of upstream header matching discussions
+            for name, lower_name, value in self.request.headers._list:
+                if lower_name in self.expected_headers:
+                    name = name.decode(headers_encoding)
+                    if name in present_headers:
+                        present_headers[name] += f", {value.decode(headers_encoding)}"
+                    else:
+                        present_headers[name] = value.decode(headers_encoding)
+
+            extra_description.append(f"{present_headers} headers")
+
+        if self.expect_body:
+            extra_description.append(f"{self.request.read()} body")
+
+        if self.expect_proxy:
+            proxy_url = _proxy_url(self.real_transport)
+            extra_description.append(f"{proxy_url if proxy_url else 'no'} proxy URL")
+
+        if self.expected_extensions:
+            present_extensions = {
+                name: value
+                for name, value in self.request.extensions.items()
+                if name in self.expected_extensions
+            }
+            extra_description.append(f"{present_extensions} extensions")
+
+        return " and ".join(extra_description)