Calls info in BaseResponse

CHANGES

@@ -1,6 +1,7 @@
 0.24.0
 ------
 
+* Added `BaseResponse.calls` to access calls data of a separate mocked request. See #664
 * Added support for re.Pattern based header matching.
 * Added support for gzipped response bodies to `json_params_matcher`.
 * Moved types-pyyaml dependency to `tests_requires`

README.rst

@@ -1079,6 +1079,75 @@ Assert that the request was called exactly n times.
         responses.assert_call_count("http://www.example.com?hello=world", 1) is True
 
 
+Assert Request Calls data
+------------------
+
+``Request`` object has ``calls`` list which elements correspond to ``Call`` objects
+in the global list of ``Registry``. This can be useful when the order of requests is not
+guaranteed, but you need to check their correctness, for example in multithreaded
+applications.
+
+.. code-block:: python
+
+    import concurrent.futures
+    import responses
+    import requests
+
+
+    @responses.activate
+    def test_assert_calls_on_resp():
+        uid_with_permissions = [
+            ("0123", {"client": True, "admin": False, "disabled": False}),
+            ("1234", {"client": False, "admin": True, "disabled": False}),
+            ("2345", {"client": False, "admin": False, "disabled": True}),
+        ]
+        rsp0123 = responses.patch(
+            "http://www.foo.bar/0123/",
+            json={"OK": True, "uid": "0123"},
+            status=200,
+        )
+        rsp1234 = responses.patch(
+            "http://www.foo.bar/1234/",
+            json={"OK": False, "uid": "1234"},
+            status=400,
+        )
+        rsp2345 = responses.patch(
+            "http://www.foo.bar/2345/",
+            json={"OK": True, "uid": "2345"},
+            status=200,
+        )
+
+        def update_permissions(uid, permissions):
+            url = f"http://www.foo.bar/{uid}/"
+            response = requests.patch(url, json=permissions)
+            return response
+
+        with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
+            future_to_uid = {
+                executor.submit(update_permissions, uid, permissions): uid
+                for (uid, permissions) in uid_with_permissions
+            }
+            for future in concurrent.futures.as_completed(future_to_uid):
+                uid = future_to_uid[future]
+                response = future.result()
+                print("%s updated with %d status code" % (uid, response.status_code))
+
+        assert len(responses.calls) == 3  # total calls count
+
+        assert rsp0123.call_count == 1
+        assert rsp0123.calls[0] in responses.calls
+        assert json.loads(rsp0123.calls[0].request.body) == {"client": True, "admin": False, "disabled": False}
+
+        assert rsp1234.call_count == 1
+        assert rsp1234.calls[0] in responses.calls
+        assert json.loads(rsp1234.calls[0].request.body) == {"client": False, "admin": True, "disabled": False}
+        assert rsp1234.calls[0].response.json() == {"OK": False, "uid": "1234"}
+
+        assert rsp2345.call_count == 1
+        assert rsp2345.calls[0] in responses.calls
+        assert json.loads(rsp2345.calls[0].request.body) == {"client": False, "admin": False, "disabled": True}
+
+
 Multiple Responses
 ------------------
 

responses/__init__.py

@@ -253,6 +253,9 @@ def __getitem__(self, idx: Union[int, slice]) -> Union[Call, List[Call]]:
     def add(self, request: "PreparedRequest", response: _Body) -> None:
         self._calls.append(Call(request, response))
 
+    def add_call(self, call: Call) -> None:
+        self._calls.append(call)
+
     def reset(self) -> None:
         self._calls = []
 
@@ -392,7 +395,7 @@ def __init__(
             )
 
         self.match: "_MatcherIterable" = match
-        self.call_count: int = 0
+        self._calls: CallList = CallList()
         self.passthrough = passthrough
 
     def __eq__(self, other: Any) -> bool:
@@ -501,6 +504,14 @@ def matches(self, request: "PreparedRequest") -> Tuple[bool, str]:
 
         return True, ""
 
+    @property
+    def call_count(self) -> int:
+        return len(self._calls)
+
+    @property
+    def calls(self) -> CallList:
+        return self._calls
+
 
 def _form_response(
     body: Union[BufferedReader, BytesIO],
@@ -1062,14 +1073,16 @@ def _on_request(
                     request, match.get_response(request)
                 )
             except BaseException as response:
-                match.call_count += 1
-                self._calls.add(request, response)
+                call = Call(request, response)
+                self._calls.add_call(call)
+                match.calls.add_call(call)
                 raise
 
         if resp_callback:
             response = resp_callback(response)  # type: ignore[misc]
-        match.call_count += 1
-        self._calls.add(request, response)  # type: ignore[misc]
+        call = Call(request, response)
+        self._calls.add_call(call)
+        match.calls.add_call(call)
 
         retries = retries or adapter.max_retries
         # first validate that current request is eligible to be retried.

responses/tests/test_responses.py

@@ -1,4 +1,5 @@
 import inspect
+import json
 import os
 import re
 import warnings
@@ -1986,6 +1987,88 @@ def run():
     assert_reset()
 
 
+def test_response_and_requests_mock_calls_are_equal():
+    @responses.activate
+    def run():
+        rsp = responses.add(responses.GET, "http://www.example.com")
+        rsp2 = responses.add(responses.GET, "http://www.example.com/1")
+
+        requests.get("http://www.example.com")
+        requests.get("http://www.example.com/1")
+
+        assert len(responses.calls) == 2
+        assert rsp.call_count == 1
+        assert rsp.calls[0] is responses.calls[0]
+        assert rsp2.call_count == 1
+        assert rsp2.calls[0] is responses.calls[1]
+
+    run()
+    assert_reset()
+
+
+def test_response_call_request():
+    @responses.activate
+    def run():
+        rsp = responses.add(responses.GET, "http://www.example.com")
+        rsp2 = responses.add(
+            responses.PUT, "http://www.foo.bar/42/", json={"id": 42, "name": "Bazz"}
+        )
+
+        requests.get("http://www.example.com")
+        requests.get("http://www.example.com?hello=world")
+        requests.put(
+            "http://www.foo.bar/42/",
+            json={"name": "Bazz"},
+        )
+
+        assert rsp.call_count == 2
+        request = rsp.calls[0].request
+        assert request.url == "http://www.example.com/"
+        assert request.method == "GET"
+        request = rsp.calls[1].request
+        assert request.url == "http://www.example.com/?hello=world"
+        assert request.method == "GET"
+        assert rsp2.call_count == 1
+        request = rsp2.calls[0].request
+        assert request.url == "http://www.foo.bar/42/"
+        assert request.method == "PUT"
+        request_payload = json.loads(request.body)
+        assert request_payload == {"name": "Bazz"}
+
+    run()
+    assert_reset()
+
+
+def test_response_call_response():
+    @responses.activate
+    def run():
+        rsp = responses.add(responses.GET, "http://www.example.com", body=b"test")
+        rsp2 = responses.add(
+            responses.POST,
+            "http://www.foo.bar/42/",
+            json={"id": 42, "name": "Bazz"},
+            status=201,
+        )
+
+        requests.get("http://www.example.com")
+        requests.post(
+            "http://www.foo.bar/42/",
+            json={"name": "Bazz"},
+        )
+
+        assert rsp.call_count == 1
+        response = rsp.calls[0].response
+        assert response.content == b"test"
+        assert response.status_code == 200
+        assert rsp2.call_count == 1
+        response = rsp2.calls[0].response
+        assert response.json() == {"id": 42, "name": "Bazz"}
+        assert response.status_code == 201
+
+    run()
+    assert_reset()
+
+
 def test_fail_request_error():
     """
     Validate that exception is raised if request URL/Method/kwargs don't match