httpserver: add methods to query log

csernazs · csernazs · commit b078e90fa03b · 2024-04-03T15:17:26.000+02:00
New methods added to query log for the given matcher. Fixes csernazs#293
diff --git a/pytest_httpserver/__init__.py b/pytest_httpserver/__init__.py
@@ -11,6 +11,7 @@
     "WaitingSettings",
     "HeaderValueMatcher",
     "RequestHandler",
+    "RequestMatcher",
     "URIPattern",
     "URI_DEFAULT",
     "METHOD_ALL",
@@ -28,5 +29,6 @@
 from .httpserver import HTTPServerError
 from .httpserver import NoHandlerError
 from .httpserver import RequestHandler
+from .httpserver import RequestMatcher
 from .httpserver import URIPattern
 from .httpserver import WaitingSettings
diff --git a/pytest_httpserver/httpserver.py b/pytest_httpserver/httpserver.py
@@ -1333,3 +1333,73 @@ def test_wait(httpserver):
                 )
         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
diff --git a/releasenotes/notes/log-querying-683219f3587d2139.yaml b/releasenotes/notes/log-querying-683219f3587d2139.yaml
@@ -0,0 +1,4 @@
+---
+features:
+  - |
+    New methods added to query for matching requests in the log.
diff --git a/tests/test_log_querying.py b/tests/test_log_querying.py
@@ -0,0 +1,73 @@
+import pytest
+import requests
+
+from pytest_httpserver import HTTPServer
+from pytest_httpserver import RequestMatcher
+
+
+def test_verify(httpserver: HTTPServer):
+    httpserver.expect_request("/foo").respond_with_data("OK")
+    httpserver.expect_request("/bar").respond_with_data("OKOK")
+
+    assert list(httpserver.iter_matching_requests(httpserver.create_matcher("/foo"))) == []
+    assert requests.get(httpserver.url_for("/foo")).text == "OK"
+    assert requests.get(httpserver.url_for("/bar")).text == "OKOK"
+
+    matching_log = list(httpserver.iter_matching_requests(httpserver.create_matcher("/foo")))
+    assert len(matching_log) == 1
+
+    request, response = matching_log[0]
+
+    assert request.url == httpserver.url_for("/foo")
+    assert response.get_data() == b"OK"
+
+    assert httpserver.get_matching_requests_count(httpserver.create_matcher("/foo")) == 1
+    httpserver.assert_request_made(httpserver.create_matcher("/foo"))
+    httpserver.assert_request_made(httpserver.create_matcher("/no_match"), count=0)
+
+    with pytest.raises(AssertionError):
+        assert httpserver.assert_request_made(httpserver.create_matcher("/no_match"))
+
+    with pytest.raises(AssertionError):
+        assert httpserver.assert_request_made(httpserver.create_matcher("/foo"), count=2)
+
+
+def test_verify_assert_msg(httpserver: HTTPServer):
+    httpserver.no_handler_status_code = 404
+    httpserver.expect_request("/foo", json={"foo": "bar"}, method="POST").respond_with_data("OK")
+    assert requests.get(httpserver.url_for("/foo"), headers={"User-Agent": "requests"}).status_code == 404
+
+    with pytest.raises(AssertionError) as err:
+        httpserver.assert_request_made(RequestMatcher("/foo", json={"foo": "bar"}, method="POST"))
+
+    expected_message = f"""Matching request found 0 times but expected 1 times.
+Expected request: <RequestMatcher uri='/foo' method='POST' query_string=None headers={{}} data=None json={{'foo': 'bar'}}>
+Found 1 similar request(s):
+--- Similar Request Start
+Path: /foo
+Method: GET
+Body: b''
+Headers: Host: localhost:{httpserver.port}\r
+User-Agent: requests\r
+Accept-Encoding: gzip, deflate\r
+Accept: */*\r
+Connection: keep-alive\r
+\r
+
+Query String: ''
+--- Similar Request End
+"""  # noqa: E501
+    assert str(err.value) == expected_message
+
+
+def test_verify_assert_msg_no_similar_requests(httpserver: HTTPServer):
+    httpserver.expect_request("/foo", json={"foo": "bar"}, method="POST").respond_with_data("OK")
+
+    with pytest.raises(AssertionError) as err:
+        httpserver.assert_request_made(RequestMatcher("/foo", json={"foo": "bar"}, method="POST"))
+
+    expected_message = """Matching request found 0 times but expected 1 times.
+Expected request: <RequestMatcher uri='/foo' method='POST' query_string=None headers={} data=None json={'foo': 'bar'}>
+No similar requests found.
+"""
+    assert str(err.value) == expected_message
diff --git a/tests/test_release.py b/tests/test_release.py
@@ -202,6 +202,7 @@ def test_sdist_contents(build: Build, version: str):
             "test_headers.py",
             "test_ip_protocols.py",
             "test_json_matcher.py",
+            "test_log_querying.py",
             "test_mixed.py",
             "test_oneshot.py",
             "test_ordered.py",

-Original file line number
+Diff line change
@@ @@ -0,0 +1,4 @@ @@
 +---
 +features:
 +  - |
 +    New methods added to query for matching requests in the log.