Unify expect_request functions

rominf · csernazs · commit d3a02cc100ce · 2019-03-09T10:19:38.000+01:00
This change is not backward compatible! 1. Define enum `HandlerType`. 2. Make `expect_request` universal so that it could register permanent, oneshot, and ordered handlers by adding enum `HandlerType` argument with default value `HandlerType.PERMANENT`. 3. Remove ordered argument from expect_oneshot_request. 4. Add convenience method expect_ordered_request. Fixes #9.
diff --git a/pytest_httpserver/httpserver.py b/pytest_httpserver/httpserver.py
@@ -2,6 +2,7 @@
 import threading
 import json
 from collections import defaultdict
+from enum import Enum
 from typing import Callable, Mapping, Optional, Union
 from ssl import SSLContext
 
@@ -296,6 +297,12 @@ def match(self, request: Request) -> RequestHandler:
         return None
 
 
+class HandlerType(Enum):
+    PERMANENT = 'permanent'
+    ONESHOT = 'oneshot'
+    ORDERED = 'ordered'
+
+
 class HTTPServer:   # pylint: disable=too-many-instance-attributes
     """
     Server instance which manages handlers to serve pre-defined requests.
@@ -398,29 +405,30 @@ def create_matcher(self, *args, **kwargs) -> RequestMatcher:
 
         return RequestMatcher(*args, **kwargs)
 
-    def expect_oneshot_request(
+    def expect_request(
             self,
             uri: str,
             method: str = METHOD_ALL,
             data: Union[str, bytes, None] = None,
             data_encoding: str = "utf-8",
             headers: Optional[Mapping[str, str]] = None,
             query_string: Optional[str] = None,
-            *,
-            ordered=False,
-            header_value_matcher: Optional[HeaderValueMatcher] = None) -> RequestHandler:
+            header_value_matcher: Optional[HeaderValueMatcher] = None,
+            handler_type: HandlerType = HandlerType.PERMANENT) -> RequestHandler:
         """
-        Create and register a oneshot request handler.
+        Create and register a request handler.
 
-        This handler can be only used once. Once the server serves a response for this handler,
-        the handler will be dropped.
+        If `handler_type` is `HandlerType.PERMANENT` a permanent request handler is created. This handler can be used as
+        many times as the request matches it, but ordered handlers have higher priority so if there's one or more
+        ordered handler registered, those must be used first.
 
-        Ordered handler (when `ordered` parameter is `True`) also determines the
-        order of the requests to be served. For example if there are two ordered handlers
-        registered, the first request must hit the first handler, and the second request must hit the
-        second one, and not vica versa.
+        If `handler_type` is `HandlerType.ONESHOT` a oneshot request handler is created. This handler can be only used
+        once. Once the server serves a response for this handler, the handler will be dropped.
 
-        If one or more ordered handler defined, those must be exhausted first.
+        If `handler_type` is `HandlerType.ORDERED` an ordered request handler is created. Comparing to oneshot handler,
+        ordered handler also determines the order of the requests to be served. For example if there are two ordered
+        handlers registered, the first request must hit the first handler, and the second request must hit the second
+        one, and not vice versa. If one or more ordered handler defined, those must be exhausted first.
 
         :param uri: URI of the request. This must be an absolute path starting with ``/``.
         :param method: HTTP method of the request. If not specified (or `METHOD_ALL`
@@ -430,8 +438,8 @@ def expect_oneshot_request(
         :param data_encoding: the encoding used for data parameter if data is a string.
         :param headers: dictionary of the headers of the request to be matched
         :param query_string: the http query string starting with ``?``, such as ``?username=user``
-        :param ordered: specifies whether to create an ordered handler or not. See above for details.
         :param header_value_matcher: :py:class:`HeaderValueMatcher` that matches values of headers.
+        :param handler_type: type of handler
 
         :return: Created and register :py:class:`RequestHandler`.
         """
@@ -446,14 +454,15 @@ def expect_oneshot_request(
             header_value_matcher=header_value_matcher,
         )
         request_handler = RequestHandler(matcher)
-        if ordered:
-            self.ordered_handlers.append(request_handler)
-        else:
+        if handler_type == HandlerType.PERMANENT:
+            self.handlers.append(request_handler)
+        elif handler_type == HandlerType.ONESHOT:
             self.oneshot_handlers.append(request_handler)
-
+        elif handler_type == HandlerType.ORDERED:
+            self.ordered_handlers.append(request_handler)
         return request_handler
 
-    def expect_request(
+    def expect_oneshot_request(
             self,
             uri: str,
             method: str = METHOD_ALL,
@@ -463,10 +472,9 @@ def expect_request(
             query_string: Optional[str] = None,
             header_value_matcher: Optional[HeaderValueMatcher] = None) -> RequestHandler:
         """
-        Create and register a permanent request handler.
+        Create and register a oneshot request handler.
 
-        This handler can be used as many times as the request matches it, but ordered handlers
-        have higher priority so if there's one or more ordered handler registered, those must be used first.
+        This is a method for convenience. See :py:meth:`expect_request` for documentation.
 
         :param uri: URI of the request. This must be an absolute path starting with ``/``.
         :param method: HTTP method of the request. If not specified (or `METHOD_ALL`
@@ -475,24 +483,60 @@ def expect_request(
             by default, see `data_encoding`) or a bytes object.
         :param data_encoding: the encoding used for data parameter if data is a string.
         :param headers: dictionary of the headers of the request to be matched
-        :param ordered: specifies whether to create an ordered handler or not. See above for details.
+        :param query_string: the http query string starting with ``?``, such as ``?username=user``
         :param header_value_matcher: :py:class:`HeaderValueMatcher` that matches values of headers.
 
         :return: Created and register :py:class:`RequestHandler`.
         """
 
-        matcher = self.create_matcher(
-            uri,
+        return self.expect_request(
+            uri=uri,
             method=method,
             data=data,
             data_encoding=data_encoding,
             headers=headers,
             query_string=query_string,
             header_value_matcher=header_value_matcher,
+            handler_type=HandlerType.ONESHOT,
+        )
+
+    def expect_ordered_request(
+            self,
+            uri: str,
+            method: str = METHOD_ALL,
+            data: Union[str, bytes, None] = None,
+            data_encoding: str = "utf-8",
+            headers: Optional[Mapping[str, str]] = None,
+            query_string: Optional[str] = None,
+            header_value_matcher: Optional[HeaderValueMatcher] = None) -> RequestHandler:
+        """
+        Create and register a ordered request handler.
+
+        This is a method for convenience. See :py:meth:`expect_request` for documentation.
+
+        :param uri: URI of the request. This must be an absolute path starting with ``/``.
+        :param method: HTTP method of the request. If not specified (or `METHOD_ALL`
+            specified), all HTTP requests will match.
+        :param data: payload of the HTTP request. This could be a string (utf-8 encoded
+            by default, see `data_encoding`) or a bytes object.
+        :param data_encoding: the encoding used for data parameter if data is a string.
+        :param headers: dictionary of the headers of the request to be matched
+        :param query_string: the http query string starting with ``?``, such as ``?username=user``
+        :param header_value_matcher: :py:class:`HeaderValueMatcher` that matches values of headers.
+
+        :return: Created and register :py:class:`RequestHandler`.
+        """
+
+        return self.expect_request(
+            uri=uri,
+            method=method,
+            data=data,
+            data_encoding=data_encoding,
+            headers=headers,
+            query_string=query_string,
+            header_value_matcher=header_value_matcher,
+            handler_type=HandlerType.ORDERED,
         )
-        request_handler = RequestHandler(matcher)
-        self.handlers.append(request_handler)
-        return request_handler
 
     def thread_target(self):
         """
diff --git a/tests/test_mixed.py b/tests/test_mixed.py
@@ -10,8 +10,8 @@ def _setup_oneshot(server: HTTPServer):
 
 
 def _setup_ordered(server: HTTPServer):
-    server.expect_oneshot_request("/ordered1", ordered=True).respond_with_data("OK ordered1")
-    server.expect_oneshot_request("/ordered2", ordered=True).respond_with_data("OK ordered2")
+    server.expect_ordered_request("/ordered1").respond_with_data("OK ordered1")
+    server.expect_ordered_request("/ordered2").respond_with_data("OK ordered2")
 
 
 def _setup_all(server: HTTPServer):
diff --git a/tests/test_oneshot.py b/tests/test_oneshot.py
@@ -27,48 +27,6 @@ def test_oneshot(httpserver: HTTPServer):
     assert requests.get(httpserver.url_for("/foobaz")).status_code == 500
 
 
-def test_ordered_ok(httpserver: HTTPServer):
-    httpserver.expect_oneshot_request("/foobar", ordered=True).respond_with_data("OK foobar")
-    httpserver.expect_oneshot_request("/foobaz", ordered=True).respond_with_data("OK foobaz")
-
-    assert len(httpserver.ordered_handlers) == 2
-
-    # first requests should pass
-    response = requests.get(httpserver.url_for("/foobar"))
-    httpserver.check_assertions()
-    assert response.status_code == 200
-    assert response.text == "OK foobar"
-
-    response = requests.get(httpserver.url_for("/foobaz"))
-    httpserver.check_assertions()
-    assert response.status_code == 200
-    assert response.text == "OK foobaz"
-
-    assert len(httpserver.ordered_handlers) == 0
-
-    # second requests should fail due to 'oneshot' type
-    assert requests.get(httpserver.url_for("/foobar")).status_code == 500
-    assert requests.get(httpserver.url_for("/foobaz")).status_code == 500
-
-
-def test_ordered_invalid_order(httpserver: HTTPServer):
-    httpserver.expect_oneshot_request("/foobar", ordered=True).respond_with_data("OK foobar")
-    httpserver.expect_oneshot_request("/foobaz", ordered=True).respond_with_data("OK foobaz")
-
-    assert len(httpserver.ordered_handlers) == 2
-
-    # these would not pass as the order is different
-    # this mark the whole thing 'permanently failed' so no further requests must pass
-    response = requests.get(httpserver.url_for("/foobaz"))
-    assert response.status_code == 500
-
-    response = requests.get(httpserver.url_for("/foobar"))
-    assert response.status_code == 500
-
-    # as no ordered handlers are triggered yet, these must be intact..
-    assert len(httpserver.ordered_handlers) == 2
-
-
 def test_oneshot_any_method(httpserver: HTTPServer):
     for _ in range(5):
         httpserver.expect_oneshot_request("/foobar").respond_with_data("OK")
diff --git a/tests/test_ordered.py b/tests/test_ordered.py
@@ -0,0 +1,45 @@
+
+import requests
+from pytest_httpserver import HTTPServer
+
+
+def test_ordered_ok(httpserver: HTTPServer):
+    httpserver.expect_ordered_request("/foobar").respond_with_data("OK foobar")
+    httpserver.expect_ordered_request("/foobaz").respond_with_data("OK foobaz")
+
+    assert len(httpserver.ordered_handlers) == 2
+
+    # first requests should pass
+    response = requests.get(httpserver.url_for("/foobar"))
+    httpserver.check_assertions()
+    assert response.status_code == 200
+    assert response.text == "OK foobar"
+
+    response = requests.get(httpserver.url_for("/foobaz"))
+    httpserver.check_assertions()
+    assert response.status_code == 200
+    assert response.text == "OK foobaz"
+
+    assert len(httpserver.ordered_handlers) == 0
+
+    # second requests should fail due to 'oneshot' type
+    assert requests.get(httpserver.url_for("/foobar")).status_code == 500
+    assert requests.get(httpserver.url_for("/foobaz")).status_code == 500
+
+
+def test_ordered_invalid_order(httpserver: HTTPServer):
+    httpserver.expect_ordered_request("/foobar").respond_with_data("OK foobar")
+    httpserver.expect_ordered_request("/foobaz").respond_with_data("OK foobaz")
+
+    assert len(httpserver.ordered_handlers) == 2
+
+    # these would not pass as the order is different
+    # this mark the whole thing 'permanently failed' so no further requests must pass
+    response = requests.get(httpserver.url_for("/foobaz"))
+    assert response.status_code == 500
+
+    response = requests.get(httpserver.url_for("/foobar"))
+    assert response.status_code == 500
+
+    # as no ordered handlers are triggered yet, these must be intact..
+    assert len(httpserver.ordered_handlers) == 2
