pytest_httpserver 1.0.10__py3-none-any.whl → 1.0.11__py3-none-any.whl

pytest_httpserver/__init__.py

@@ -2,6 +2,7 @@
 This is package provides the main API for the pytest_httpserver package.
 
 """
+
 __all__ = [
     "HTTPServer",
     "HTTPServerError",
@@ -10,6 +11,7 @@ __all__ = [
     "WaitingSettings",
     "HeaderValueMatcher",
     "RequestHandler",
+    "RequestMatcher",
     "URIPattern",
     "URI_DEFAULT",
     "METHOD_ALL",
@@ -27,5 +29,6 @@ from .httpserver import HTTPServer
 from .httpserver import HTTPServerError
 from .httpserver import NoHandlerError
 from .httpserver import RequestHandler
+from .httpserver import RequestMatcher
 from .httpserver import URIPattern
 from .httpserver import WaitingSettings

pytest_httpserver/blocking_httpserver.py

@@ -18,8 +18,8 @@ from pytest_httpserver.httpserver import URIPattern
 if TYPE_CHECKING:
     from ssl import SSLContext
 
-    from werkzeug.wrappers import Request
-    from werkzeug.wrappers import Response
+    from werkzeug import Request
+    from werkzeug import Response
 
 
 class BlockingRequestHandler(RequestHandlerBase):

pytest_httpserver/hooks.py

@@ -0,0 +1,103 @@
+"""
+Hooks for pytest-httpserver
+"""
+
+import os
+import time
+from typing import Callable
+
+from werkzeug import Request
+from werkzeug import Response
+
+
+class Chain:
+    """
+    Combine multiple hooks into one callable object
+
+    Hooks specified will be called one by one.
+
+    Each hook will receive the response object made by the previous hook,
+    similar to reduce.
+    """
+
+    def __init__(self, *args: Callable[[Request, Response], Response]):
+        """
+        :param *args: callable objects specified in the same order they should
+            be called.
+        """
+        self._hooks = args
+
+    def __call__(self, request: Request, response: Response) -> Response:
+        """
+        Calls the callable object one by one. The second and further callable
+        objects receive the response returned by the previous one, while the
+        first one receives the original response object.
+        """
+        for hook in self._hooks:
+            response = hook(request, response)
+        return response
+
+
+class Delay:
+    """
+    Delays returning the response
+    """
+
+    def __init__(self, seconds: float):
+        """
+        :param seconds: seconds to sleep before returning the response
+        """
+        self._seconds = seconds
+
+    def _sleep(self):
+        """
+        Sleeps for the seconds specified in the constructor
+        """
+        time.sleep(self._seconds)
+
+    def __call__(self, _request: Request, response: Response) -> Response:
+        """
+        Delays returning the response object for the time specified in the
+        constructor. Returns the original response unmodified.
+        """
+        self._sleep()
+        return response
+
+
+class Garbage:
+    def __init__(self, prefix_size: int = 0, suffix_size: int = 0):
+        """
+        Adds random bytes to the beginning or to the end of the response data.
+
+        :param prefix_size: amount of random bytes to be added to the beginning
+            of the response data
+
+        :param suffix_size: amount of random bytes to be added to the end
+            of the response data
+
+        """
+        assert prefix_size >= 0, "prefix_size should be positive integer"
+        assert suffix_size >= 0, "suffix_size should be positive integer"
+        self._prefix_size = prefix_size
+        self._suffix_size = suffix_size
+
+    def _get_garbage_bytes(self, size: int) -> bytes:
+        """
+        Returns the specified amount of random bytes.
+
+        :param size: amount of bytes to return
+        """
+        return os.urandom(size)
+
+    def __call__(self, _request: Request, response: Response) -> Response:
+        """
+        Adds random bytes to the beginning or to the end of the response data.
+
+        New random bytes will be generated for every call.
+
+        Returns the modified response object.
+        """
+        prefix = self._get_garbage_bytes(self._prefix_size)
+        suffix = self._get_garbage_bytes(self._suffix_size)
+        response.set_data(prefix + response.get_data() + suffix)
+        return response

pytest_httpserver/httpserver.py

@@ -26,11 +26,11 @@ from typing import Tuple
 from typing import Union
 
 import werkzeug.http
+from werkzeug import Request
+from werkzeug import Response
 from werkzeug.datastructures import Authorization
 from werkzeug.datastructures import MultiDict
 from werkzeug.serving import make_server
-from werkzeug.wrappers import Request
-from werkzeug.wrappers import Response
 
 if TYPE_CHECKING:
     from ssl import SSLContext
@@ -495,7 +495,7 @@ class RequestHandlerBase(abc.ABC):
         """
         Prepares a response with raw data.
 
-        For detailed description please see the :py:class:`werkzeug.wrappers.Response` object as the
+        For detailed description please see the :py:class:`werkzeug.Response` object as the
         parameters are analogue.
 
         :param response_data: a string or bytes object representing the body of the response
@@ -529,6 +529,11 @@ class RequestHandler(RequestHandlerBase):
     def __init__(self, matcher: RequestMatcher):
         self.matcher = matcher
         self.request_handler: Callable[[Request], Response] | None = None
+        self._hooks: list[Callable[[Request, Response], Response]] = []
+
+    def with_post_hook(self, hook: Callable[[Request, Response], Response]):
+        self._hooks.append(hook)
+        return self
 
     def respond(self, request: Request) -> Response:
         """
@@ -546,7 +551,11 @@ class RequestHandler(RequestHandlerBase):
                 "Matching request handler found but no response defined: {} {}".format(request.method, request.path)
             )
         else:
-            return self.request_handler(request)
+            response = self.request_handler(request)
+
+            for hook in self._hooks:
+                response = hook(request, response)
+            return response
 
     def respond_with_handler(self, func: Callable[[Request], Response]):
         """
@@ -598,11 +607,12 @@ class HTTPServerBase(abc.ABC):  # pylint: disable=too-many-instance-attributes
     :param host: the host or IP where the server will listen
     :param port: the TCP port where the server will listen
     :param ssl_context: the ssl context object to use for https connections
+    :param threaded: whether to handle concurrent requests in separate threads
 
     .. py:attribute:: log
 
         Attribute containing the list of two-element tuples. Each tuple contains
-        :py:class:`werkzeug.wrappers.Request` and :py:class:`werkzeug.wrappers.Response` object which represents the
+        :py:class:`werkzeug.Request` and :py:class:`werkzeug.Response` object which represents the
         incoming request and the outgoing response which happened during the lifetime
         of the server.
 
@@ -619,6 +629,8 @@ class HTTPServerBase(abc.ABC):  # pylint: disable=too-many-instance-attributes
         host: str,
         port: int,
         ssl_context: SSLContext | None = None,
+        *,
+        threaded: bool = False,
     ):
         """
         Initializes the instance.
@@ -632,6 +644,7 @@ class HTTPServerBase(abc.ABC):  # pylint: disable=too-many-instance-attributes
         self.handler_errors: list[Exception] = []
         self.log: list[tuple[Request, Response]] = []
         self.ssl_context = ssl_context
+        self.threaded = threaded
         self.no_handler_status_code = 500
 
     def __repr__(self):
@@ -730,11 +743,11 @@ class HTTPServerBase(abc.ABC):  # pylint: disable=too-many-instance-attributes
         This method returns immediately (e.g. does not block), and it's the caller's
         responsibility to stop the server (by calling :py:meth:`stop`) when it is no longer needed).
 
-        If the sever is not stopped by the caller and execution reaches the end, the
+        If the server is not stopped by the caller and execution reaches the end, the
         program needs to be terminated by Ctrl+C or by signal as it will not terminate until
         the thread is stopped.
 
-        If the sever is already running :py:class:`HTTPServerError` will be raised. If you are
+        If the server is already running :py:class:`HTTPServerError` will be raised. If you are
         unsure, call :py:meth:`is_running` first.
 
         There's a context interface of this class which stops the server when the context block ends.
@@ -742,7 +755,9 @@ class HTTPServerBase(abc.ABC):  # pylint: disable=too-many-instance-attributes
         if self.is_running():
             raise HTTPServerError("Server is already running")
 
-        self.server = make_server(self.host, self.port, self.application, ssl_context=self.ssl_context)
+        self.server = make_server(
+            self.host, self.port, self.application, ssl_context=self.ssl_context, threaded=self.threaded
+        )
         self.port = self.server.port  # Update port (needed if `port` was set to 0)
         self.server_thread = threading.Thread(target=self.thread_target)
         self.server_thread.start()
@@ -900,6 +915,8 @@ class HTTPServer(HTTPServerBase):  # pylint: disable=too-many-instance-attribute
     :param default_waiting_settings: the waiting settings object to use as default settings for :py:meth:`wait` context
         manager
 
+    :param threaded: whether to handle concurrent requests in separate threads
+
     .. py:attribute:: no_handler_status_code
 
         Attribute containing the http status code (int) which will be the response
@@ -916,11 +933,13 @@ class HTTPServer(HTTPServerBase):  # pylint: disable=too-many-instance-attribute
         port=DEFAULT_LISTEN_PORT,
         ssl_context: SSLContext | None = None,
         default_waiting_settings: WaitingSettings | None = None,
+        *,
+        threaded: bool = False,
     ):
         """
         Initializes the instance.
         """
-        super().__init__(host, port, ssl_context)
+        super().__init__(host, port, ssl_context, threaded=threaded)
 
         self.ordered_handlers: list[RequestHandler] = []
         self.oneshot_handlers = RequestHandlerList()
@@ -1333,3 +1352,73 @@ class HTTPServer(HTTPServerBase):  # pylint: disable=too-many-instance-attribute
                 )
         if self._waiting_settings.raise_assertions and not waiting.result:
             self.check_assertions()
+
+    def iter_matching_requests(self, matcher: RequestMatcher) -> Iterable[tuple[Request, Response]]:
+        """
+        Queries log for matching requests.
+
+
+        :param matcher: the matcher object to match requests
+        :return: an iterator with request-response pair from the log
+        """
+
+        for request, response in self.log:
+            if matcher.match(request):
+                yield (request, response)
+
+    def get_matching_requests_count(self, matcher: RequestMatcher) -> int:
+        """
+        Queries the log for matching requests, returning the number of log
+        entries matching for the specified matcher.
+
+        :param matcher: the matcher object to match requests
+        :return: the number of log entries matching
+        """
+        return len(list(self.iter_matching_requests(matcher)))
+
+    def assert_request_made(self, matcher: RequestMatcher, *, count: int = 1):
+        """
+        Check the amount of log entries matching for the matcher specified. By
+        default it verifies that exactly one request matching for the matcher
+        specified. The expected count can be customized with the count kwarg
+        (including zero, which asserts that no requests made for the given
+        matcher).
+
+        :param matcher: the matcher object to match requests
+        :param count: the expected number of matches in the log
+        :return: ``None`` if the assert succeeded, raises
+            :py:class:`AssertionError` if not.
+        """
+
+        matching_count = self.get_matching_requests_count(matcher)
+        if matching_count != count:
+            similar_requests: list[Request] = []
+            for request, _ in self.log:
+                if request.path == matcher.uri:
+                    similar_requests.append(request)
+
+            assert_msg_lines = [
+                f"Matching request found {matching_count} times but expected {count} times.",
+                f"Expected request: {matcher}",
+            ]
+
+            if similar_requests:
+                assert_msg_lines.append(f"Found {len(similar_requests)} similar request(s):")
+                for request in similar_requests:
+                    assert_msg_lines.extend(
+                        (
+                            "--- Similar Request Start",
+                            f"Path: {request.path}",
+                            f"Method: {request.method}",
+                            f"Body: {request.get_data()!r}",
+                            f"Headers: {request.headers}",
+                            f"Query String: {request.query_string.decode('utf-8')!r}",
+                            "--- Similar Request End",
+                        )
+                    )
+            else:
+                assert_msg_lines.append("No similar requests found.")
+
+            assert_msg = "\n".join(assert_msg_lines) + "\n"
+
+            assert matching_count == count, assert_msg

{pytest_httpserver-1.0.10.dist-info → pytest_httpserver-1.0.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pytest_httpserver
-Version: 1.0.10
+Version: 1.0.11
 Summary: pytest-httpserver is a httpserver for pytest
 Home-page: https://github.com/csernazs/pytest-httpserver
 License: MIT

pytest_httpserver-1.0.11.dist-info/RECORD

@@ -0,0 +1,11 @@
+pytest_httpserver/__init__.py,sha256=mxclzFNYdCWBmbsmOP5ctA_7334LMPg2B-dzO6Q4cKs,897
+pytest_httpserver/blocking_httpserver.py,sha256=X83nmJUnDt1ntWopD6Ob0V8iUjzEVES64IpxPtwjLis,7227
+pytest_httpserver/hooks.py,sha256=dPQih1u-RJdsRrU5JBlaYaaLFBGIWH8F9nN0qqYa5OU,3022
+pytest_httpserver/httpserver.py,sha256=zrGItVnHTdiCMzlQEq4bMwEROl0vSRjhy9fXr3YuDiw,53603
+pytest_httpserver/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pytest_httpserver/pytest_plugin.py,sha256=5xFe-nF3QfnuAOk3WP76zljxJlAF1jmd3gJQFYY6OFI,2320
+pytest_httpserver-1.0.11.dist-info/LICENSE,sha256=KUr7ZKG_73p9_Z8ODdU7FI-Tw6CHVhcxNjXJhUzUpak,1069
+pytest_httpserver-1.0.11.dist-info/METADATA,sha256=Ixu3pzo29b9ylP7fNFthWmPqiV9-HHrAnYJIsQ0f-J0,6164
+pytest_httpserver-1.0.11.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+pytest_httpserver-1.0.11.dist-info/entry_points.txt,sha256=bsXb6tjhUsMGU1mzPAjf92HukEHrLB0TebYnXbhY9rw,62
+pytest_httpserver-1.0.11.dist-info/RECORD,,

{pytest_httpserver-1.0.10.dist-info → pytest_httpserver-1.0.11.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.8.1
+Generator: poetry-core 1.9.0
 Root-Is-Purelib: true
 Tag: py3-none-any

pytest_httpserver-1.0.10.dist-info/RECORD

@@ -1,10 +0,0 @@
-pytest_httpserver/__init__.py,sha256=a0TGt29_kd-4xhMOqJmh370EjpujzDY0c7ZLK2DplW4,835
-pytest_httpserver/blocking_httpserver.py,sha256=HWxcXLjCcke4PlK-i2aZy-7T6dtR8E7DPS0hBxAaY_8,7245
-pytest_httpserver/httpserver.py,sha256=4YrUFp0RMVLDP5SCYJSClm2XP54-6p_bfsYJ9uoeoh0,50073
-pytest_httpserver/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pytest_httpserver/pytest_plugin.py,sha256=5xFe-nF3QfnuAOk3WP76zljxJlAF1jmd3gJQFYY6OFI,2320
-pytest_httpserver-1.0.10.dist-info/LICENSE,sha256=KUr7ZKG_73p9_Z8ODdU7FI-Tw6CHVhcxNjXJhUzUpak,1069
-pytest_httpserver-1.0.10.dist-info/METADATA,sha256=Btn3EcgiCGKCYCDo-6NfTT3-6UHqgODJlla3FuzcJm4,6164
-pytest_httpserver-1.0.10.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-pytest_httpserver-1.0.10.dist-info/entry_points.txt,sha256=bsXb6tjhUsMGU1mzPAjf92HukEHrLB0TebYnXbhY9rw,62
-pytest_httpserver-1.0.10.dist-info/RECORD,,