pytest_httpserver 1.1.4__tar.gz → 1.1.5__tar.gz

{pytest_httpserver-1.1.4 → pytest_httpserver-1.1.5}/CHANGES.rst

@@ -2,6 +2,24 @@
 Release Notes
 =============
 
+.. _Release Notes_1.1.5:
+
+1.1.5
+=====
+
+.. _Release Notes_1.1.5_New Features:
+
+New Features
+------------
+
+- Add ``bake()`` method to ``HTTPServer`` for creating pre-configured
+  request expectation proxies (``BakedHTTPServer``). This allows sharing
+  common keyword arguments (e.g. ``method``, ``headers``) across multiple
+  ``expect_request()`` calls with last-wins merging semantics.
+  `#470 <https://github.com/csernazs/pytest-httpserver/pull/470>`_
+  Contributed by `@HayaoSuzuki <https://github.com/HayaoSuzuki>`_
+
+
 .. _Release Notes_1.1.4:
 
 1.1.4

{pytest_httpserver-1.1.4 → pytest_httpserver-1.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest_httpserver
-Version: 1.1.4
+Version: 1.1.5
 Summary: pytest-httpserver is a httpserver for pytest
 License-Expression: MIT
 License-File: LICENSE

{pytest_httpserver-1.1.4 → pytest_httpserver-1.1.5}/doc/api.rst

@@ -24,6 +24,12 @@ RequestHandler
         :inherited-members:
 
 
+RequestMatcherKwargs
+~~~~~~~~~~~~~~~~~~~~
+
+    .. autoclass:: RequestMatcherKwargs
+        :members:
+
 RequestMatcher
 ~~~~~~~~~~~~~~
 
@@ -31,6 +37,12 @@ RequestMatcher
         :members:
 
 
+BakedHTTPServer
+~~~~~~~~~~~~~~~~
+
+    .. autoclass:: BakedHTTPServer
+        :members:
+
 BlockingHTTPServer
 ~~~~~~~~~~~~~~~~~~
 

{pytest_httpserver-1.1.4 → pytest_httpserver-1.1.5}/doc/conf.py

@@ -68,7 +68,7 @@ author = "Zsolt Cserna"
 # built documents.
 #
 # The short X.Y version.
-version = "1.1.4"
+version = "1.1.5"
 # The full version, including alpha/beta/rc tags.
 release = version
 

{pytest_httpserver-1.1.4 → pytest_httpserver-1.1.5}/doc/howto.rst

@@ -704,3 +704,29 @@ Example:
 will register the hooks, and hooks will be called sequentially, one by one. Each
 hook will receive the response what the previous hook returned, and the last
 hook called will return the final response which will be sent back to the client.
+
+
+Reducing repetition with bake
+-----------------------------
+
+When multiple expectations share common parameters (such as headers or method),
+the ``bake()`` method creates a proxy with pre-configured defaults. Keyword
+arguments passed to ``bake()`` become defaults that are merged with arguments
+provided at call time using last-wins semantics: if the same keyword appears in
+both, the call-time value is used.
+
+.. literalinclude :: ../tests/examples/test_howto_bake.py
+   :language: python
+
+The ``bake()`` method can be chained to layer additional defaults:
+
+.. code-block:: python
+
+    json_post = httpserver.bake(method="POST").bake(
+        headers={"Content-Type": "application/json"}
+    )
+
+All ``expect_request``, ``expect_oneshot_request``, and
+``expect_ordered_request`` methods are available on the baked object. Other
+attributes such as ``url_for()`` and ``check_assertions()`` are delegated to
+the underlying server transparently.

{pytest_httpserver-1.1.4 → pytest_httpserver-1.1.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pytest_httpserver"
-version = "1.1.4"
+version = "1.1.5"
 description = "pytest-httpserver is a httpserver for pytest"
 readme = "README.md"
 license = "MIT"

{pytest_httpserver-1.1.4 → pytest_httpserver-1.1.5}/pytest_httpserver/__init__.py

@@ -6,6 +6,7 @@ This is package provides the main API for the pytest_httpserver package.
 __all__ = [
     "METHOD_ALL",
     "URI_DEFAULT",
+    "BakedHTTPServer",
     "BlockingHTTPServer",
     "BlockingRequestHandler",
     "Error",
@@ -15,10 +16,12 @@ __all__ = [
     "NoHandlerError",
     "RequestHandler",
     "RequestMatcher",
+    "RequestMatcherKwargs",
     "URIPattern",
     "WaitingSettings",
 ]
 
+from .bake import BakedHTTPServer
 from .blocking_httpserver import BlockingHTTPServer
 from .blocking_httpserver import BlockingRequestHandler
 from .httpserver import METHOD_ALL
@@ -30,5 +33,6 @@ from .httpserver import HTTPServerError
 from .httpserver import NoHandlerError
 from .httpserver import RequestHandler
 from .httpserver import RequestMatcher
+from .httpserver import RequestMatcherKwargs
 from .httpserver import URIPattern
 from .httpserver import WaitingSettings

pytest_httpserver-1.1.5/pytest_httpserver/bake.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from typing import Any
+
+if TYPE_CHECKING:
+    import sys
+    from re import Pattern
+    from types import TracebackType
+
+    if sys.version_info >= (3, 11):
+        from typing import Self
+    else:
+        from typing_extensions import Self
+
+    if sys.version_info >= (3, 12):
+        from typing import Unpack
+    else:
+        from typing_extensions import Unpack
+
+    from .httpserver import HTTPServer
+    from .httpserver import RequestHandler
+    from .httpserver import RequestMatcherKwargs
+    from .httpserver import URIPattern
+
+
+class BakedHTTPServer:
+    """
+    A proxy for :py:class:`HTTPServer` with pre-configured defaults for
+    ``expect_request()`` and related methods.
+
+    Created via :py:meth:`HTTPServer.bake`. Keyword arguments stored at bake
+    time are merged with arguments provided at call time using last-wins
+    semantics: if the same keyword appears in both, the call-time value is
+    used.
+
+    Any attribute not explicitly defined here is delegated to the wrapped
+    :py:class:`HTTPServer`, so ``url_for()``, ``check_assertions()``, etc.
+    work transparently.
+    """
+
+    def __init__(self, server: HTTPServer, **kwargs: Unpack[RequestMatcherKwargs]) -> None:
+        self._server = server
+        self._defaults = kwargs
+        self._context_depth: int = 0
+        self._started_server: bool = False
+
+    def __enter__(self) -> Self:
+        if self._context_depth == 0:
+            self._started_server = not self._server.is_running()
+            self._server.__enter__()
+        self._context_depth += 1
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        self._context_depth -= 1
+        if self._started_server and self._context_depth == 0:
+            self._server.__exit__(exc_type, exc_value, traceback)
+            self._started_server = False
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._server, name)
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} defaults={self._defaults!r} server={self._server!r}>"
+
+    def _merge_kwargs(self, kwargs: RequestMatcherKwargs) -> RequestMatcherKwargs:
+        return self._defaults | kwargs
+
+    def bake(self, **kwargs: Unpack[RequestMatcherKwargs]) -> Self:
+        """
+        Create a new :py:class:`BakedHTTPServer` by further layering defaults.
+
+        The new proxy merges the current defaults with the new ``kwargs``.
+        """
+        return self.__class__(self._server, **self._merge_kwargs(kwargs))
+
+    def expect_request(
+        self,
+        uri: str | URIPattern | Pattern[str],
+        **kwargs: Unpack[RequestMatcherKwargs],
+    ) -> RequestHandler:
+        """Create and register a request handler, using baked defaults."""
+        return self._server.expect_request(uri, **self._merge_kwargs(kwargs))
+
+    def expect_oneshot_request(
+        self,
+        uri: str | URIPattern | Pattern[str],
+        **kwargs: Unpack[RequestMatcherKwargs],
+    ) -> RequestHandler:
+        """Create and register a oneshot request handler, using baked defaults."""
+        return self._server.expect_oneshot_request(uri, **self._merge_kwargs(kwargs))
+
+    def expect_ordered_request(
+        self,
+        uri: str | URIPattern | Pattern[str],
+        **kwargs: Unpack[RequestMatcherKwargs],
+    ) -> RequestHandler:
+        """Create and register an ordered request handler, using baked defaults."""
+        return self._server.expect_ordered_request(uri, **self._merge_kwargs(kwargs))

{pytest_httpserver-1.1.4 → pytest_httpserver-1.1.5}/pytest_httpserver/httpserver.py

@@ -24,6 +24,7 @@ from re import Pattern
 from typing import TYPE_CHECKING
 from typing import Any
 from typing import ClassVar
+from typing import TypedDict
 
 import werkzeug.http
 from werkzeug import Request
@@ -32,6 +33,8 @@ from werkzeug.datastructures import Authorization
 from werkzeug.datastructures import MultiDict
 from werkzeug.serving import make_server
 
+from .bake import BakedHTTPServer
+
 if TYPE_CHECKING:
     import sys
     from ssl import SSLContext
@@ -44,6 +47,11 @@ if TYPE_CHECKING:
     else:
         from typing_extensions import Self
 
+    if sys.version_info >= (3, 12):
+        from typing import Unpack
+    else:
+        from typing_extensions import Unpack
+
 URI_DEFAULT = ""
 METHOD_ALL = "__ALL"
 
@@ -285,6 +293,18 @@ class URIPattern(abc.ABC):
         """
 
 
+class RequestMatcherKwargs(TypedDict, total=False):
+    """Keyword arguments common to ``expect_request()`` and related methods."""
+
+    method: str
+    data: str | bytes | None
+    data_encoding: str
+    headers: Mapping[str, str] | None
+    query_string: None | QueryMatcher | str | bytes | Mapping[str, str]
+    header_value_matcher: HVMATCHER_T | None
+    json: Any
+
+
 class RequestMatcher:
     """
     Matcher object for the incoming request.
@@ -1495,3 +1515,25 @@ class HTTPServer(HTTPServerBase):  # pylint: disable=too-many-instance-attribute
             assert_msg = "\n".join(assert_msg_lines) + "\n"
 
             assert matching_count == count, assert_msg
+
+    def bake(self, **kwargs: Unpack[RequestMatcherKwargs]) -> BakedHTTPServer:
+        """
+        Create a proxy with pre-configured defaults for ``expect_request()``.
+
+        Keyword arguments passed here become defaults for ``expect_request()``
+        and related methods. When the same keyword is provided both at bake
+        time and at call time, the call-time value wins (last-wins merging).
+
+        Accepts the same keyword arguments as ``expect_request()`` (see
+        :py:class:`RequestMatcherKwargs`).
+
+        :return: a :py:class:`BakedHTTPServer` proxy object.
+
+        Example:
+
+        .. code-block:: python
+
+            json_server = httpserver.bake(headers={"content-type": "application/json"})
+            json_server.expect_request("/foo").respond_with_json({"result": "ok"})
+        """
+        return BakedHTTPServer(self, **kwargs)

pytest_httpserver-1.1.5/tests/examples/test_howto_bake.py

@@ -0,0 +1,25 @@
+import requests
+
+from pytest_httpserver import HTTPServer
+
+
+def test_bake_json_api(httpserver: HTTPServer) -> None:
+    # bake common defaults so you don't repeat them for every expect_request
+    json_api = httpserver.bake(method="POST", headers={"Content-Type": "application/json"})
+
+    json_api.expect_request("/users").respond_with_json({"id": 1, "name": "Alice"}, status=201)
+    json_api.expect_request("/items").respond_with_json({"id": 42, "name": "Widget"}, status=201)
+
+    resp = requests.post(
+        httpserver.url_for("/users"),
+        json={"name": "Alice"},
+    )
+    assert resp.status_code == 201
+    assert resp.json() == {"id": 1, "name": "Alice"}
+
+    resp = requests.post(
+        httpserver.url_for("/items"),
+        json={"name": "Widget"},
+    )
+    assert resp.status_code == 201
+    assert resp.json() == {"id": 42, "name": "Widget"}

pytest_httpserver-1.1.5/tests/test_bake.py

@@ -0,0 +1,162 @@
+from collections.abc import Callable
+
+import pytest
+import requests
+
+from pytest_httpserver import BakedHTTPServer
+from pytest_httpserver import HTTPServer
+from pytest_httpserver import RequestMatcherKwargs
+
+
+def test_bake_with_headers(httpserver: HTTPServer) -> None:
+    server = httpserver.bake(headers={"Content-Type": "application/json"})
+    server.expect_request("/foo").respond_with_json({"result": "ok"})
+
+    response = requests.get(
+        httpserver.url_for("/foo"),
+        headers={"Content-Type": "application/json"},
+    )
+    assert response.status_code == 200
+    assert response.json() == {"result": "ok"}
+
+
+@pytest.mark.parametrize(
+    ("bake_chain", "expect_kwargs", "request_method"),
+    [
+        pytest.param(
+            lambda s: s.bake(method="POST"),
+            {},
+            "POST",
+            id="bake-default",
+        ),
+        pytest.param(
+            lambda s: s.bake(method="GET"),
+            {"method": "POST"},
+            "POST",
+            id="call-time-override",
+        ),
+        pytest.param(
+            lambda s: s.bake(method="GET").bake(method="POST"),
+            {},
+            "POST",
+            id="chained-override",
+        ),
+    ],
+)
+def test_bake_method_resolution(
+    httpserver: HTTPServer,
+    bake_chain: Callable[[HTTPServer], BakedHTTPServer],
+    expect_kwargs: RequestMatcherKwargs,
+    request_method: str,
+) -> None:
+    server = bake_chain(httpserver)
+    server.expect_request("/endpoint", **expect_kwargs).respond_with_data("ok")
+
+    response = requests.request(request_method, httpserver.url_for("/endpoint"))
+    assert response.status_code == 200
+    assert response.text == "ok"
+
+
+def test_bake_chained(httpserver: HTTPServer) -> None:
+    server = httpserver.bake(method="POST").bake(headers={"X-Custom": "value"})
+    server.expect_request("/chain").respond_with_data("chained")
+
+    response = requests.post(
+        httpserver.url_for("/chain"),
+        headers={"X-Custom": "value"},
+    )
+    assert response.status_code == 200
+    assert response.text == "chained"
+
+
+def test_bake_oneshot(httpserver: HTTPServer) -> None:
+    server = httpserver.bake(method="PUT")
+    server.expect_oneshot_request("/once").respond_with_data("once")
+
+    response = requests.put(httpserver.url_for("/once"))
+    assert response.status_code == 200
+    assert response.text == "once"
+
+    response = requests.put(httpserver.url_for("/once"))
+    assert response.status_code == 500
+
+
+def test_bake_ordered(httpserver: HTTPServer) -> None:
+    server = httpserver.bake(method="GET")
+    server.expect_ordered_request("/first").respond_with_data("1")
+    server.expect_ordered_request("/second").respond_with_data("2")
+
+    response = requests.get(httpserver.url_for("/first"))
+    assert response.status_code == 200
+    assert response.text == "1"
+
+    response = requests.get(httpserver.url_for("/second"))
+    assert response.status_code == 200
+    assert response.text == "2"
+
+
+def test_bake_delegates_url_for(httpserver: HTTPServer) -> None:
+    server = httpserver.bake(method="GET")
+    assert server.url_for("/path") == httpserver.url_for("/path")
+
+
+def test_bake_context_manager() -> None:
+    server = HTTPServer()
+    baked = server.bake(method="GET")
+    with baked:
+        assert server.is_running()
+        baked.expect_request("/ctx").respond_with_data("ok")
+        response = requests.get(baked.url_for("/ctx"))
+        assert response.status_code == 200
+        assert response.text == "ok"
+    assert not server.is_running()
+
+
+def test_bake_nested_context_manager() -> None:
+    server = HTTPServer()
+    with server:
+        with server.bake(method="GET"):
+            assert server.is_running()
+        assert server.is_running()  # inner exit must not stop the server
+    assert not server.is_running()
+
+
+def test_bake_reentrant_context_manager() -> None:
+    server = HTTPServer()
+    baked = server.bake(method="GET")
+    with baked:
+        assert server.is_running()
+        with baked:
+            assert server.is_running()
+        assert server.is_running()  # inner exit must not stop the server
+    assert not server.is_running()  # outer exit must stop the server
+
+
+def test_bake_from_server_returns_new_object(httpserver: HTTPServer) -> None:
+    assert httpserver.bake(method="GET") is not httpserver.bake(method="GET")
+
+
+def test_bake_from_baked_returns_new_object(httpserver: HTTPServer) -> None:
+    baked = httpserver.bake(method="GET")
+    assert baked.bake(headers={"X": "1"}) is not baked
+
+
+def test_bake_repr() -> None:
+    server = HTTPServer(host="localhost", port=12345)
+    baked = server.bake(method="GET")
+    assert repr(baked) == "<BakedHTTPServer defaults={'method': 'GET'} server=<HTTPServer host=localhost port=12345>>"
+
+
+@pytest.mark.parametrize(
+    "bake_chain",
+    [
+        pytest.param(lambda s: s.bake(method="GET"), id="single"),
+        pytest.param(lambda s: s.bake(method="GET").bake(headers={"X-Foo": "bar"}), id="chained"),
+    ],
+)
+def test_bake_returns_baked_type(
+    httpserver: HTTPServer,
+    bake_chain: Callable[[HTTPServer], BakedHTTPServer],
+) -> None:
+    server = bake_chain(httpserver)
+    assert isinstance(server, BakedHTTPServer)

{pytest_httpserver-1.1.4 → pytest_httpserver-1.1.5}/tests/test_release.py

@@ -163,6 +163,7 @@ def test_wheel_no_extra_contents(build: Build, version: str):
     package_contents = {path.name for path in wheel_dir.joinpath(NAME_UNDERSCORE).iterdir()}
     assert package_contents == {
         "__init__.py",
+        "bake.py",
         "blocking_httpserver.py",
         "hooks.py",
         "httpserver.py",
@@ -205,6 +206,7 @@ def test_sdist_contents(build: Build, version: str):
         },
         "pytest_httpserver": {
             "__init__.py",
+            "bake.py",
             "blocking_httpserver.py",
             "hooks.py",
             "httpserver.py",
@@ -215,6 +217,7 @@ def test_sdist_contents(build: Build, version: str):
             "assets",
             "conftest.py",
             "examples",
+            "test_bake.py",
             "test_blocking_httpserver.py",
             "test_handler_errors.py",
             "test_headers.py",

pytest_httpserver-1.1.4/doc/_build/html/.buildinfo

@@ -1,4 +0,0 @@
-# Sphinx build info version 1
-# This file records the configuration used when building these files. When it is not found, a full rebuild will be done.
-config: 94839d66317b50436b62af161e657c65
-tags: 645f666f9bcd5a90fca523b33c5a78b7

pytest_httpserver-1.1.4/doc/_build/html/_sources/api.rst.txt

@@ -1,118 +0,0 @@
-
-.. _api-documentation:
-
-API documentation
-=================
-
-pytest_httpserver
------------------
-
-.. automodule:: pytest_httpserver
-
-HTTPServer
-~~~~~~~~~~
-
-    .. autoclass:: HTTPServer
-        :members:
-        :inherited-members:
-
-RequestHandler
-~~~~~~~~~~~~~~
-
-    .. autoclass:: RequestHandler
-        :members:
-        :inherited-members:
-
-
-RequestMatcher
-~~~~~~~~~~~~~~
-
-    .. autoclass:: RequestMatcher
-        :members:
-
-
-BlockingHTTPServer
-~~~~~~~~~~~~~~~~~~
-
-    .. autoclass:: BlockingHTTPServer
-        :members:
-        :inherited-members:
-
-BlockingRequestHandler
-~~~~~~~~~~~~~~~~~~~~~~
-
-    .. autoclass:: BlockingRequestHandler
-        :members:
-        :inherited-members:
-
-WaitingSettings
-~~~~~~~~~~~~~~~
-
-    .. autoclass:: WaitingSettings
-        :members:
-
-HeaderValueMatcher
-~~~~~~~~~~~~~~~~~~
-
-    .. autoclass:: HeaderValueMatcher
-        :members:
-
-URIPattern
-~~~~~~~~~~
-
-    .. autoclass:: URIPattern
-        :members:
-
-HTTPServerError
-~~~~~~~~~~~~~~~
-
-    .. autoclass:: HTTPServerError
-        :members:
-
-NoHandlerError
-~~~~~~~~~~~~~~
-
-    .. autoclass:: NoHandlerError
-        :members:
-
-
-pytest_httpserver.httpserver
-----------------------------
-This module contains some internal classes which are normally not instantiated
-by the user.
-
-.. automodule:: pytest_httpserver.httpserver
-
-    .. autoclass:: RequestMatcher
-        :members:
-
-    .. autoclass:: pytest_httpserver.httpserver.HTTPServerBase
-        :members:
-
-    .. autoclass:: pytest_httpserver.httpserver.Error
-        :members:
-
-    .. autoclass:: pytest_httpserver.httpserver.NoHandlerError
-        :members:
-
-    .. autoclass:: pytest_httpserver.httpserver.HTTPServerError
-        :members:
-
-    .. autoclass:: pytest_httpserver.httpserver.RequestHandlerList
-        :members:
-
-
-pytest_httpserver.hooks
------------------------
-
-.. automodule:: pytest_httpserver.hooks
-
-
-    .. autoclass:: pytest_httpserver.hooks.Chain
-        :members:
-
-    .. autoclass:: pytest_httpserver.hooks.Delay
-        :members:
-
-    .. autoclass:: pytest_httpserver.hooks.Garbage
-        :members: