pytest_httpserver 1.1.3__tar.gz → 1.1.5__tar.gz

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

@@ -2,6 +2,48 @@
 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
+=====
+
+.. _Release Notes_1.1.4_New Features:
+
+New Features
+------------
+
+- More robust server startup by checking server readiness (disabled by
+  default).
+  `#462 <https://github.com/csernazs/pytest-httpserver/pull/462>`_
+
+
+.. _Release Notes_1.1.4_Deprecation Notes:
+
+Deprecation Notes
+-----------------
+
+- Python 3.9 has been deprecated as it reached EOL 2025-10-31. While the code
+  may work on this version, there will be no CI tests running on it.
+
+
 .. _Release Notes_1.1.3:
 
 1.1.3

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

@@ -1,27 +1,27 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: pytest_httpserver
-Version: 1.1.3
+Version: 1.1.5
 Summary: pytest-httpserver is a httpserver for pytest
-Home-page: https://github.com/csernazs/pytest-httpserver
-License: MIT
+License-Expression: MIT
+License-File: LICENSE
 Author: Zsolt Cserna
 Author-email: cserna.zsolt@gmail.com
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Classifier: Development Status :: 3 - Alpha
-Classifier: Framework :: Pytest
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 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 :: Libraries :: Python Modules
+Classifier: Framework :: Pytest
 Requires-Dist: Werkzeug (>=2.0.0)
 Project-URL: Bug Tracker, https://github.com/csernazs/pytest-httpserver/issues
 Project-URL: Documentation, https://pytest-httpserver.readthedocs.io/en/latest/
+Project-URL: Homepage, https://github.com/csernazs/pytest-httpserver
 Project-URL: Repository, https://github.com/csernazs/pytest-httpserver
 Description-Content-Type: text/markdown
 

{pytest_httpserver-1.1.3 → 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.3 → 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.3"
+version = "1.1.5"
 # The full version, including alpha/beta/rc tags.
 release = version
 

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

@@ -299,6 +299,41 @@ the ``httpserver`` fixture).
         return ("127.0.0.1", 8000)
 
 
+Waiting for server to be ready
+------------------------------
+
+By default, the ``httpserver`` fixture ensures that the server is bound to the
+configured address and listening for incoming connections. While this is
+sufficient for most use cases, you can optionally wait for the server to be
+fully ready to serve HTTP requests before proceeding with your tests. This is
+particularly useful when your client has strict timeout requirements or when the
+HTTP server has a slow startup time.
+
+To enable this check, *pytest-httpserver* issues an HTTP probe request to the
+server before your test starts to ensure the server is ready to serve requests.
+You can configure the timeout for this probe request as needed.
+
+
+.. warning::
+
+    This check is not supported in SSL mode, as the probe request is not
+    configured to accept the self-signed certificate used by the server. To
+    enable this feature with SSL, override the ``wait_for_server_ready()``
+    method with your implementation.
+
+
+To enable this feature, set the ``startup_timeout`` keyword argument when
+initializing ``HTTPServer``. This parameter specifies the maximum time to wait
+for the server to become ready to serve HTTP requests.
+
+
+.. literalinclude :: ../tests/examples/test_howto_readiness.py
+   :language: python
+
+
+In the case the server times out, the test will fail.
+
+
 Multi-threading support
 -----------------------
 
@@ -669,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.3 → pytest_httpserver-1.1.5}/doc/tutorial.rst

@@ -419,7 +419,7 @@ unhandled and in the end the test will be failed.
 
 In some cases, however, you want to make sure that everything is ok so far,
 and raise AssertionError when something is not good. Call the
-``check_assertions()`` method of the httpserver object, and this will look at
+``check()`` method of the httpserver object, and this will look at
 the server's internal state (which is running in the other thread) and if
 there's something not right (such as the order of the requests not matching,
 or there was a non-matching request), it will raise an AssertionError and
@@ -434,8 +434,71 @@ your test will properly fail:
         requests.get(httpserver.url_for("/foobaz"))
         requests.get(httpserver.url_for("/foobar"))  # gets 500
 
-        httpserver.check_assertions()  # this will raise AssertionError and make the test failing
+        httpserver.check()  # this will raise AssertionError and make the test failing
 
+This will also produce a (hopefully) helpful description about what went wrong::
+
+    >           raise AssertionError(assertion)
+    E           AssertionError: No handler found for request <Request 'http://localhost:41085/foobaz' [GET]> with data b''.Ordered matchers:
+    E               <RequestMatcher uri='/foobar' method='__ALL' query_string=None headers={} data=None json=<UNDEFINED>>
+    E               <RequestMatcher uri='/foobaz' method='__ALL' query_string=None headers={} data=None json=<UNDEFINED>>
+    E
+    E           Oneshot matchers:
+    E               none
+    E
+    E           Persistent matchers:
+    E               none
+
+
+Calling ``check()`` for all tests
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Sometimes you want to see the informative message made by ``check()`` if
+your test failed.
+
+In such case you can implement a new fixture or override the behavior:
+
+
+.. code:: python
+
+  from collections.abc import Iterable
+  from pytest_httpserver import HTTPServer
+  import requests
+
+  import pytest
+
+
+  @pytest.fixture
+  def httpserver(httpserver: HTTPServer) -> Iterable[HTTPServer]:
+      yield httpserver
+      httpserver.check()  # this will raise AssertionError and make the test failing
+
+
+  def test_client(httpserver: HTTPServer):
+      httpserver.expect_request("/foo").respond_with_data("foo")
+      httpserver.expect_request("/bar").respond_with_data("bar")
+
+      resp = requests.get(httpserver.url_for("/foobar"))  # gets 500
+      resp.raise_for_status()  # raises error
+
+
+When the tests are run with ``-vv`` then it will show both errors::
+
+  FAILED example2.py::test_client - requests.exceptions.HTTPError: 500 Server Error: INTERNAL SERVER ERROR for url: http://localhost:37425/foobar
+  ERROR example2.py::test_client - AssertionError: No handler found for request <Request 'http://localhost:37425/foobar' [GET]> with data b''.
+  Ordered matchers:
+      none
+
+  Oneshot matchers:
+      none
+
+  Persistent matchers:
+      <RequestMatcher uri='/foo' method='__ALL' query_string=None headers={} data=None json=<UNDEFINED>>
+      <RequestMatcher uri='/bar' method='__ALL' query_string=None headers={} data=None json=<UNDEFINED>>
+
+
+Logs
+~~~~
 
 The server writes a log about the requests and responses which were
 processed. This can be accessed in the `log` attribute of the http server.
@@ -457,7 +520,7 @@ Debugging
 ~~~~~~~~~
 
 If you having multiple requests for the server, adding the call to
-``check_assertions()`` may to debug as it will make the test failed as
+``check()`` may help to debug as it will make the test failed as
 soon as possible.
 
 .. code:: python
@@ -471,20 +534,20 @@ soon as possible.
         requests.get(httpserver.url_for("/bar"))
         requests.get(httpserver.url_for("/foobar"))
 
-        httpserver.check_assertions()
+        httpserver.check()
 
 In the above code, the first request (to **/foo**) is not successful (it gets
 http status 500), but as the response status is not checked (or any of the
-response), and there's no call to ``check_assertions()``, the test continues the
+response), and there's no call to ``check()``, the test continues the
 running. It gets through the **/bar** request, which is also not successful
 (and gets http status 500 also like the first one), then goes the last request
 which is successful (as there's a handler defined for it)
 
-In the end, when checking the check_assertions() raise the error for the first
+In the end, when checking the check() raise the error for the first
 request, but it is a bit late: figuring out the request which caused the problem
 could be troublesome. Also, it will report the problem for the first request only.
 
-Adding more call of ``check_assertions()`` will help.
+Adding more call of ``check()`` will help.
 
 
 .. code:: python
@@ -495,13 +558,13 @@ Adding more call of ``check_assertions()`` will help.
     def test_json_client(httpserver: HTTPServer):
         httpserver.expect_request("/foobar").respond_with_json({"foo": "bar"})
         requests.get(httpserver.url_for("/foo"))
-        httpserver.check_assertions()
+        httpserver.check()
 
         requests.get(httpserver.url_for("/bar"))
-        httpserver.check_assertions()
+        httpserver.check()
 
         requests.get(httpserver.url_for("/foobar"))
-        httpserver.check_assertions()
+        httpserver.check()
 
 
 In the above code, the test will fail after the first request.

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

@@ -1,20 +1,40 @@
-[tool.poetry]
+[project]
 name = "pytest_httpserver"
-version = "1.1.3"
+version = "1.1.5"
 description = "pytest-httpserver is a httpserver for pytest"
-authors = ["Zsolt Cserna <cserna.zsolt@gmail.com>"]
-license = "MIT"
 readme = "README.md"
-documentation = "https://pytest-httpserver.readthedocs.io/en/latest/"
+license = "MIT"
+authors = [
+    { name = "Zsolt Cserna", email = "cserna.zsolt@gmail.com" }
+]
 classifiers = [
     "Development Status :: 3 - Alpha",
     "Intended Audience :: Developers",
     "Operating System :: OS Independent",
+    "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 :: Libraries :: Python Modules",
     "Framework :: Pytest",
 ]
-repository = "https://github.com/csernazs/pytest-httpserver"
+requires-python = ">=3.10"
+dependencies = [
+    "Werkzeug >= 2.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/csernazs/pytest-httpserver"
+Documentation = "https://pytest-httpserver.readthedocs.io/en/latest/"
+Repository = "https://github.com/csernazs/pytest-httpserver"
+"Bug Tracker" = "https://github.com/csernazs/pytest-httpserver/issues"
+
+[project.entry-points.pytest11]
+pytest_httpserver = "pytest_httpserver.pytest_plugin"
 
+[tool.poetry]
 include = [
     { path = "tests", format = "sdist" },
     { path = "CHANGES.rst", format = "sdist" },
@@ -23,29 +43,19 @@ include = [
     { path = "doc", format = "sdist" },
 ]
 
-[tool.poetry.dependencies]
-python = ">=3.9"
-Werkzeug = ">= 2.0.0"
-
-
-[tool.poetry.plugins.pytest11]
-pytest_httpserver = "pytest_httpserver.pytest_plugin"
-
-[tool.poetry.urls]
-"Bug Tracker" = "https://github.com/csernazs/pytest-httpserver/issues"
-
 [tool.poetry.group.develop]
 optional = true
 
 [tool.poetry.group.develop.dependencies]
 pre-commit = ">=2.20,<5.0"
 requests = "*"
-Sphinx = ">=5.1.1,<8.0.0"
+typing_extensions = { version = ">=4.0", markers = "python_version < '3.11'" }
+Sphinx = ">=5.1.1,<9.0.0"
 sphinx-rtd-theme = ">=1,<4"
 reno = "*"
 types-requests = "*"
-pytest = ">=7.1.3,<9.0.0"
-pytest-cov = ">=3,<7"
+pytest = ">=7.1.3,<10.0.0"
+pytest-cov = ">=3,<8"
 coverage = ">=6.4.4,<8.0.0"
 tomli = { version = "*", markers = "python_version < '3.11'"}
 black = "*"
@@ -57,7 +67,7 @@ mypy = "*"
 optional = true
 
 [tool.poetry.group.doc.dependencies]
-Sphinx = ">=5.1.1,<8.0.0"
+Sphinx = ">=5.1.1,<9.0.0"
 sphinx-rtd-theme = ">=1,<4"
 
 
@@ -116,7 +126,6 @@ lint.ignore = [
   "PLR0913",
   "PLR2004",
   "PLW2901",
-  "PT004",
   "PT012",
   "PT013",
   "PTH118",
@@ -137,5 +146,5 @@ lint.ignore = [
   "UP032",
 ]
 line-length = 120
-target-version = "py39"
+target-version = "py310"
 exclude = ["doc", "example*.py", "tests/examples/*.py"]

{pytest_httpserver-1.1.3 → 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.3 → pytest_httpserver-1.1.5}/pytest_httpserver/blocking_httpserver.py

@@ -29,10 +29,10 @@ class BlockingRequestHandler(RequestHandlerBase):
     This class should only be instantiated inside the implementation of the :py:class:`BlockingHTTPServer`.
     """
 
-    def __init__(self):
-        self.response_queue = Queue()
+    def __init__(self) -> None:
+        self.response_queue: Queue[Response] = Queue()
 
-    def respond_with_response(self, response: Response):
+    def respond_with_response(self, response: Response) -> None:
         self.response_queue.put_nowait(response)
 
 
@@ -59,11 +59,11 @@ class BlockingHTTPServer(HTTPServerBase):
 
     def __init__(
         self,
-        host=DEFAULT_LISTEN_HOST,
-        port=DEFAULT_LISTEN_PORT,
+        host: str = DEFAULT_LISTEN_HOST,
+        port: int = DEFAULT_LISTEN_PORT,
         ssl_context: SSLContext | None = None,
         timeout: int = 30,
-    ):
+    ) -> None:
         super().__init__(host, port, ssl_context)
         self.timeout = timeout
         self.request_queue: Queue[Request] = Queue()
@@ -76,7 +76,7 @@ class BlockingHTTPServer(HTTPServerBase):
         data: str | bytes | None = None,
         data_encoding: str = "utf-8",
         headers: Mapping[str, str] | None = None,
-        query_string: None | QueryMatcher | str | bytes | Mapping = None,
+        query_string: None | QueryMatcher | str | bytes | Mapping[str, str] = None,
         header_value_matcher: HeaderValueMatcher | None = None,
         json: Any = UNDEFINED,
         timeout: int = 30,

{pytest_httpserver-1.1.3 → pytest_httpserver-1.1.5}/pytest_httpserver/hooks.py

@@ -4,7 +4,7 @@ Hooks for pytest-httpserver
 
 import os
 import time
-from typing import Callable
+from collections.abc import Callable
 
 from werkzeug import Request
 from werkzeug import Response
@@ -20,7 +20,7 @@ class Chain:
     similar to reduce.
     """
 
-    def __init__(self, *args: Callable[[Request, Response], Response]):
+    def __init__(self, *args: Callable[[Request, Response], Response]) -> None:
         """
         :param *args: callable objects specified in the same order they should
             be called.
@@ -43,13 +43,13 @@ class Delay:
     Delays returning the response
     """
 
-    def __init__(self, seconds: float):
+    def __init__(self, seconds: float) -> None:
         """
         :param seconds: seconds to sleep before returning the response
         """
         self._seconds = seconds
 
-    def _sleep(self):
+    def _sleep(self) -> None:
         """
         Sleeps for the seconds specified in the constructor
         """
@@ -65,7 +65,7 @@ class Delay:
 
 
 class Garbage:
-    def __init__(self, prefix_size: int = 0, suffix_size: int = 0):
+    def __init__(self, prefix_size: int = 0, suffix_size: int = 0) -> None:
         """
         Adds random bytes to the beginning or to the end of the response data.