httpserver: add URI matching

csernazs · csernazs · commit b63a55f0df7f · 2020-08-05T08:39:32.000+02:00
Extend URI matching functionality which now accepts: * a URIPattern object, whose match() method will be called * a compiled regexp returned by re.compile(). In this case the URI will be matched against the regexp. In both cases the URI will be an absolute path starting with a slash. Fixes #34 and #36.
diff --git a/doc/guide.rst b/doc/guide.rst
@@ -40,8 +40,19 @@ Requests
 ~~~~~~~~
 When registering a :py:class:`pytest_httpserver.server.RequestMatcher`, it can use various parts
 of the HTTP request to be matched: URI, method, data, headers, and query string can be specified.
-All of these are based on simple equality checking, with the exception of method and URI where a special
-value specifying `any` can be given (variables `URI_DEFAULT` and `METHOD_ALL`, respectively).
+
+The following can be matched:
+
+* uri: a string, a regexp or an :py:class:`pytest_httpserver.server.URIPattern` object
+
+* method: GET/POST/..., specified as string
+
+* data: a string or bytes. It is possible to match with arbitrary byte data.
+
+* headers: a str-str dictionary or a :py:class:`pytest_httpserver.server.HeaderValueMatcher` object
+  which matches each header with its own provided callable
+
+* query_string: a string, bytes or a dict specifying the key-value pairs of the query string
 
 :py:class:`pytest_httpserver.server.HTTPServer` also determines how these matchers are looked up and
 what their lifetime is. You can register handlers which handle any amount of requests, but you can also
diff --git a/pytest_httpserver/__init__.py b/pytest_httpserver/__init__.py
@@ -8,4 +8,4 @@
 from .httpserver import HTTPServer
 from .httpserver import HTTPServerError, Error, NoHandlerError
 from .httpserver import WaitingSettings, HeaderValueMatcher, RequestHandler
-from .httpserver import URI_DEFAULT, METHOD_ALL
+from .httpserver import URIPattern, URI_DEFAULT, METHOD_ALL
diff --git a/pytest_httpserver/httpserver.py b/pytest_httpserver/httpserver.py
@@ -3,11 +3,12 @@
 import threading
 import json
 import time
+import re
 from collections import defaultdict
 from enum import Enum
 from contextlib import suppress, contextmanager
 from copy import copy
-from typing import Callable, Mapping, Optional, Union
+from typing import Callable, Mapping, Optional, Union, Pattern
 from ssl import SSLContext
 import abc
 
@@ -230,13 +231,27 @@ def _create_query_matcher(query_string: Union[None, QueryMatcher, str, bytes, Ma
     raise TypeError("Unable to cast this type to QueryMatcher: {!r}".format(type(query_string)))
 
 
+class URIPattern(abc.ABC):
+    @abc.abstractmethod
+    def match(self, uri: str) -> bool:
+        """
+            Matches the provided URI.
+
+            :param uri: URI of the request. This is an absolute path startting
+                with "/" and does not contain the query part.
+            :return: True if there's a match, False otherwise
+            """
+        pass
+
+
 class RequestMatcher:
     """
     Matcher object for the incoming request.
 
     It defines various parameters to match the incoming request.
 
-    :param uri: URI of the request. This must be an absolute path starting with ``/``.
+    :param uri: URI of the request. This must be an absolute path starting with ``/``, a
+        :py:class:`URIPattern` object, or a regular expression compiled by re.compile.
     :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
@@ -253,7 +268,7 @@ class RequestMatcher:
 
     def __init__(
             self,
-            uri: str,
+            uri: Union[str, URIPattern, Pattern[str]],
             method: str = METHOD_ALL,
             data: Union[str, bytes, None] = None,
             data_encoding: str = "utf-8",
@@ -300,6 +315,27 @@ def match_data(self, request: Request) -> bool:
             return True
         return request.data == self.data
 
+    def match_uri(self, request: Request) -> bool:
+        path = request.path
+
+        if isinstance(self.uri, URIPattern):
+            return self.uri.match(path)
+
+        # this is python version depending
+        # in python 3.7 and above: it is re.Pattern
+        # below python 3.7 it is _sre.SRE_Pattern which cannot be accessed directly
+        elif isinstance(self.uri, re.compile("").__class__):
+            return bool(self.uri.match(path))
+
+        else:
+            # there could be a guard isinstance(self.uri, str) been here
+            # but we want to allow any object which provides the __eq__ parameter
+            # (note: in this case it will be not typeing correct)
+            #
+            # also, python will raise TypeError when self.uri is a conflicting type
+
+            return self.uri == URI_DEFAULT or path == self.uri
+
     def difference(self, request: Request) -> list:
         """
         Calculates the difference between the matcher and the request.
@@ -313,7 +349,8 @@ def difference(self, request: Request) -> list:
         """
 
         retval = []
-        if self.uri != URI_DEFAULT and request.path != self.uri:
+
+        if not self.match_uri(request):
             retval.append(("uri", request.path, self.uri))
 
         if self.method != METHOD_ALL and self.method != request.method:
diff --git a/releasenotes/notes/uri-matching-dba6660cb0689402.yaml b/releasenotes/notes/uri-matching-dba6660cb0689402.yaml
@@ -0,0 +1,7 @@
+---
+features:
+  - |
+    Extend URI matching by allowing to specify URIPattern object or a compiled
+    regular expression, which will be matched against the URI. URIPattern class
+    is defined as abstract in the library so the user need to implement a new
+    class based on it.
diff --git a/tests/test_urimatch.py b/tests/test_urimatch.py
@@ -0,0 +1,54 @@
+
+
+import re
+
+from pytest_httpserver import HTTPServer, URIPattern
+import requests
+
+
+class PrefixMatch(URIPattern):
+    def __init__(self, prefix: str):
+        self.prefix = prefix
+
+    def match(self, uri):
+        return uri.startswith(self.prefix)
+
+
+class PrefixMatchEq:
+    def __init__(self, prefix: str):
+        self.prefix = prefix
+
+    def __eq__(self, uri):
+        return uri.startswith(self.prefix)
+
+
+def test_uripattern_object(httpserver: HTTPServer):
+    httpserver.expect_request(PrefixMatch("/foo")).respond_with_json({"foo": "bar"})
+    assert requests.get(httpserver.url_for("/foo")).json() == {"foo": "bar"}
+    assert requests.get(httpserver.url_for("/foobar")).json() == {"foo": "bar"}
+    assert requests.get(httpserver.url_for("/foobaz")).json() == {"foo": "bar"}
+
+    assert requests.get(httpserver.url_for("/barfoo")).status_code == 500
+
+    assert len(httpserver.assertions) == 1
+
+
+def test_regexp(httpserver: HTTPServer):
+    httpserver.expect_request(re.compile(r"/foo/\d+/bar/")).respond_with_json({"foo": "bar"})
+    assert requests.get(httpserver.url_for("/foo/123/bar/")).json() == {"foo": "bar"}
+    assert requests.get(httpserver.url_for("/foo/9999/bar/")).json() == {"foo": "bar"}
+
+    assert requests.get(httpserver.url_for("/foo/bar/")).status_code == 500
+
+    assert len(httpserver.assertions) == 1
+
+
+def test_object_with_eq(httpserver: HTTPServer):
+    httpserver.expect_request(PrefixMatchEq("/foo")).respond_with_json({"foo": "bar"})
+    assert requests.get(httpserver.url_for("/foo")).json() == {"foo": "bar"}
+    assert requests.get(httpserver.url_for("/foobar")).json() == {"foo": "bar"}
+    assert requests.get(httpserver.url_for("/foobaz")).json() == {"foo": "bar"}
+
+    assert requests.get(httpserver.url_for("/barfoo")).status_code == 500
+
+    assert len(httpserver.assertions) == 1
