mockserver-client 7.5.0__tar.gz → 8.0.0__tar.gz

{mockserver_client-7.5.0 → mockserver_client-8.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mockserver-client
-Version: 7.5.0
+Version: 8.0.0
 Summary: Official Python client for MockServer — create expectations, verify requests, and register dynamic callbacks via WebSocket
 Author-email: James Bloom <jamesdbloom@gmail.com>
 License-Expression: Apache-2.0
@@ -486,7 +486,7 @@ launcher_path = ensure_binary()  # returns Path to the launcher executable
 ```python
 from mockserver.launcher import start
 
-server = start(port=1080, version="7.5.0")
+server = start(port=1080, version="8.0.0")
 # ...
 server.stop()
 ```

{mockserver_client-7.5.0 → mockserver_client-8.0.0}/README.md

@@ -456,7 +456,7 @@ launcher_path = ensure_binary()  # returns Path to the launcher executable
 ```python
 from mockserver.launcher import start
 
-server = start(port=1080, version="7.5.0")
+server = start(port=1080, version="8.0.0")
 # ...
 server.stop()
 ```

{mockserver_client-7.5.0 → mockserver_client-8.0.0}/mockserver/async_client.py

@@ -757,18 +757,21 @@ class AsyncMockServerClient:
         Returns the verdict dict with a ``result`` of ``PASS`` or ``INCONCLUSIVE``
         (HTTP 200). A ``FAIL`` verdict (HTTP 406) raises
         :class:`MockServerVerificationError` so a CI or chaos gate can assert on it
-        directly. SLO tracking is off by default — the server returns 400 (raised as
-        :class:`MockServerError`) until started with ``sloTrackingEnabled=true``.
+        directly. SLO tracking is off by default — the server returns 403 (raised as
+        :class:`MockServerError`) until started with ``sloTrackingEnabled=true``;
+        malformed criteria are a separate 400.
         """
         body = json.dumps(criteria)
         status, response_body = await self._request("PUT", "/mockserver/verifySLO", body)
         if status == 406:
             raise MockServerVerificationError(response_body or "SLO verdict: FAIL")
-        if status == 400:
+        if status == 403:
             raise MockServerError(
-                "Invalid SLO criteria (or SLO tracking disabled — set "
-                f"sloTrackingEnabled=true): {response_body}"
+                "SLO tracking is disabled — start MockServer with "
+                f"sloTrackingEnabled=true: {response_body}"
             )
+        if status == 400:
+            raise MockServerError(f"Invalid SLO criteria: {response_body}")
         if status >= 400:
             raise MockServerError(
                 f"Failed to verify SLO (status={status}): {response_body}"
@@ -1215,6 +1218,105 @@ class AsyncMockServerClient:
                 return [Expectation.from_dict(e) for e in parsed]
         return []
 
+    async def _retrieve_by_id(
+        self, expectation_id: str, query_params: dict[str, str]
+    ) -> tuple[int, str]:
+        """Send a retrieve request filtered by expectation id.
+
+        An expectation id may be sent in place of a request matcher. For
+        ``ACTIVE_EXPECTATIONS`` the server returns only the expectation with that
+        id; for every other type it returns the entries matching that
+        expectation's request, exactly as verify by expectation id matches them.
+        An unknown id is rejected with a 400.
+        """
+        return await self._request(
+            "PUT",
+            "/mockserver/retrieve",
+            json.dumps({"id": expectation_id}),
+            query_params,
+        )
+
+    async def retrieve_recorded_requests_by_id(
+        self, expectation_id: str
+    ) -> list[HttpRequest]:
+        status, response_body = await self._retrieve_by_id(
+            expectation_id, {"type": "REQUESTS", "format": "JSON"}
+        )
+        if status >= 400:
+            raise MockServerError(
+                f"Failed to retrieve recorded requests by id (status={status}): {response_body}"
+            )
+        if response_body:
+            parsed = json.loads(response_body)
+            if isinstance(parsed, list):
+                return [HttpRequest.from_dict(r) for r in parsed]
+        return []
+
+    async def retrieve_active_expectations_by_id(
+        self, expectation_id: str
+    ) -> list[Expectation]:
+        status, response_body = await self._retrieve_by_id(
+            expectation_id, {"type": "ACTIVE_EXPECTATIONS", "format": "JSON"}
+        )
+        if status >= 400:
+            raise MockServerError(
+                f"Failed to retrieve active expectations by id (status={status}): {response_body}"
+            )
+        if response_body:
+            parsed = json.loads(response_body)
+            if isinstance(parsed, list):
+                return [Expectation.from_dict(e) for e in parsed]
+        return []
+
+    async def retrieve_recorded_expectations_by_id(
+        self, expectation_id: str
+    ) -> list[Expectation]:
+        status, response_body = await self._retrieve_by_id(
+            expectation_id, {"type": "RECORDED_EXPECTATIONS", "format": "JSON"}
+        )
+        if status >= 400:
+            raise MockServerError(
+                f"Failed to retrieve recorded expectations by id (status={status}): {response_body}"
+            )
+        if response_body:
+            parsed = json.loads(response_body)
+            if isinstance(parsed, list):
+                return [Expectation.from_dict(e) for e in parsed]
+        return []
+
+    async def retrieve_recorded_requests_and_responses_by_id(
+        self, expectation_id: str
+    ) -> list[HttpRequestAndHttpResponse]:
+        status, response_body = await self._retrieve_by_id(
+            expectation_id, {"type": "REQUEST_RESPONSES", "format": "JSON"}
+        )
+        if status >= 400:
+            raise MockServerError(
+                f"Failed to retrieve request/responses by id (status={status}): {response_body}"
+            )
+        if response_body:
+            parsed = json.loads(response_body)
+            if isinstance(parsed, list):
+                return [HttpRequestAndHttpResponse.from_dict(rr) for rr in parsed]
+        return []
+
+    async def retrieve_log_messages_by_id(self, expectation_id: str) -> list[str]:
+        status, response_body = await self._retrieve_by_id(
+            expectation_id, {"type": "LOGS"}
+        )
+        if status >= 400:
+            raise MockServerError(
+                f"Failed to retrieve log messages by id (status={status}): {response_body}"
+            )
+        if response_body:
+            try:
+                parsed = json.loads(response_body)
+                if isinstance(parsed, list):
+                    return parsed
+            except json.JSONDecodeError:
+                return response_body.split("------------------------------------\n")
+        return []
+
     async def retrieve_expectations_as_code(
         self, fmt: str = "java", request: HttpRequest | None = None
     ) -> str:

{mockserver_client-7.5.0 → mockserver_client-8.0.0}/mockserver/client.py

@@ -378,7 +378,8 @@ class MockServerClient:
 
         Returns the verdict dict (``result`` PASS or INCONCLUSIVE). A FAIL verdict
         (HTTP 406) raises :class:`MockServerVerificationError`. SLO tracking is off
-        by default (HTTP 400 until ``sloTrackingEnabled=true``).
+        by default (HTTP 403 until ``sloTrackingEnabled=true``); malformed criteria
+        are a separate HTTP 400.
         """
         return self._run(self._async_client.verify_slo(criteria))
 
@@ -552,6 +553,41 @@ class MockServerClient:
     ) -> list[Expectation]:
         return self._run(self._async_client.retrieve_recorded_expectations(request))
 
+    def retrieve_recorded_requests_by_id(
+        self, expectation_id: str
+    ) -> list[HttpRequest]:
+        return self._run(
+            self._async_client.retrieve_recorded_requests_by_id(expectation_id)
+        )
+
+    def retrieve_active_expectations_by_id(
+        self, expectation_id: str
+    ) -> list[Expectation]:
+        return self._run(
+            self._async_client.retrieve_active_expectations_by_id(expectation_id)
+        )
+
+    def retrieve_recorded_expectations_by_id(
+        self, expectation_id: str
+    ) -> list[Expectation]:
+        return self._run(
+            self._async_client.retrieve_recorded_expectations_by_id(expectation_id)
+        )
+
+    def retrieve_recorded_requests_and_responses_by_id(
+        self, expectation_id: str
+    ) -> list[HttpRequestAndHttpResponse]:
+        return self._run(
+            self._async_client.retrieve_recorded_requests_and_responses_by_id(
+                expectation_id
+            )
+        )
+
+    def retrieve_log_messages_by_id(self, expectation_id: str) -> list[str]:
+        return self._run(
+            self._async_client.retrieve_log_messages_by_id(expectation_id)
+        )
+
     def retrieve_expectations_as_code(
         self, fmt: str = "java", request: HttpRequest | None = None
     ) -> str:

{mockserver_client-7.5.0 → mockserver_client-8.0.0}/mockserver/launcher.py

@@ -45,7 +45,7 @@ logger = logging.getLogger(__name__)
 
 # The version shipped with this client.  ``ensure_binary()`` defaults to this
 # when no explicit version is passed.
-_CLIENT_VERSION = "7.5.0"
+_CLIENT_VERSION = "8.0.0"
 
 _REPO = "mock-server/mockserver-monorepo"
 

{mockserver_client-7.5.0 → mockserver_client-8.0.0}/mockserver_client.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mockserver-client
-Version: 7.5.0
+Version: 8.0.0
 Summary: Official Python client for MockServer — create expectations, verify requests, and register dynamic callbacks via WebSocket
 Author-email: James Bloom <jamesdbloom@gmail.com>
 License-Expression: Apache-2.0
@@ -486,7 +486,7 @@ launcher_path = ensure_binary()  # returns Path to the launcher executable
 ```python
 from mockserver.launcher import start
 
-server = start(port=1080, version="7.5.0")
+server = start(port=1080, version="8.0.0")
 # ...
 server.stop()
 ```

{mockserver_client-7.5.0 → mockserver_client-8.0.0}/mockserver_client.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ mockserver/launcher.py
 mockserver/llm.py
 mockserver/mcp.py
 mockserver/models.py
+mockserver/py.typed
 mockserver/pytest_plugin.py
 mockserver/websocket_client.py
 mockserver_client.egg-info/PKG-INFO

{mockserver_client-7.5.0 → mockserver_client-8.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mockserver-client"
-version = "7.5.0"
+version = "8.0.0"
 description = "Official Python client for MockServer — create expectations, verify requests, and register dynamic callbacks via WebSocket"
 authors = [
   {name = "James Bloom", email = "jamesdbloom@gmail.com"},
@@ -47,6 +47,12 @@ Changelog = "https://www.mock-server.com/mock_server/changelog.html"
 requires = ["setuptools"]
 build-backend = "setuptools.build_meta"
 
+# PEP 561: ship the inline annotations. Without this marker mypy ignores the types entirely
+# ("module is installed, but missing library stubs or py.typed marker"), and without the
+# package-data entry setuptools would not put the marker in the wheel or sdist at all.
+[tool.setuptools.package-data]
+"mockserver" = ["py.typed"]
+
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 asyncio_mode = "auto"

{mockserver_client-7.5.0 → mockserver_client-8.0.0}/tests/test_client.py

@@ -245,6 +245,54 @@ class TestSyncRetrieve:
             result = client.retrieve_recorded_expectations()
             assert len(result) == 1
 
+    def test_retrieve_recorded_requests_by_id(self, sync_mock_server):
+        SyncMockHandler.response_body = json.dumps([
+            {"method": "GET", "path": "/recorded"},
+        ])
+        with MockServerClient("127.0.0.1", sync_mock_server) as client:
+            result = client.retrieve_recorded_requests_by_id("exp-abc")
+            assert len(result) == 1
+            assert result[0].path == "/recorded"
+            assert json.loads(SyncMockHandler.last_request_body)["id"] == "exp-abc"
+            assert "type=REQUESTS" in SyncMockHandler.last_path
+
+    def test_retrieve_active_expectations_by_id(self, sync_mock_server):
+        SyncMockHandler.response_body = json.dumps([
+            {"id": "exp-abc", "httpRequest": {"path": "/active"}},
+        ])
+        with MockServerClient("127.0.0.1", sync_mock_server) as client:
+            result = client.retrieve_active_expectations_by_id("exp-abc")
+            assert len(result) == 1
+            assert result[0].id == "exp-abc"
+            assert json.loads(SyncMockHandler.last_request_body)["id"] == "exp-abc"
+            assert "type=ACTIVE_EXPECTATIONS" in SyncMockHandler.last_path
+
+    def test_retrieve_recorded_expectations_by_id(self, sync_mock_server):
+        SyncMockHandler.response_body = json.dumps([{"id": "re1"}])
+        with MockServerClient("127.0.0.1", sync_mock_server) as client:
+            result = client.retrieve_recorded_expectations_by_id("exp-abc")
+            assert len(result) == 1
+            assert json.loads(SyncMockHandler.last_request_body)["id"] == "exp-abc"
+            assert "type=RECORDED_EXPECTATIONS" in SyncMockHandler.last_path
+
+    def test_retrieve_recorded_requests_and_responses_by_id(self, sync_mock_server):
+        SyncMockHandler.response_body = json.dumps([
+            {"httpRequest": {"path": "/recorded"}, "httpResponse": {"statusCode": 200}},
+        ])
+        with MockServerClient("127.0.0.1", sync_mock_server) as client:
+            result = client.retrieve_recorded_requests_and_responses_by_id("exp-abc")
+            assert len(result) == 1
+            assert json.loads(SyncMockHandler.last_request_body)["id"] == "exp-abc"
+            assert "type=REQUEST_RESPONSES" in SyncMockHandler.last_path
+
+    def test_retrieve_log_messages_by_id(self, sync_mock_server):
+        SyncMockHandler.response_body = json.dumps(["log one"])
+        with MockServerClient("127.0.0.1", sync_mock_server) as client:
+            result = client.retrieve_log_messages_by_id("exp-abc")
+            assert result == ["log one"]
+            assert json.loads(SyncMockHandler.last_request_body)["id"] == "exp-abc"
+            assert "type=LOGS" in SyncMockHandler.last_path
+
     def test_retrieve_expectations_as_code(self, sync_mock_server):
         SyncMockHandler.response_body = 'when(request().withPath("/code"));'
         with MockServerClient("127.0.0.1", sync_mock_server) as client:
@@ -555,10 +603,18 @@ class TestSyncVerifySlo:
                 client.verify_slo({"name": "x"})
 
     def test_verify_slo_disabled_raises_error(self, sync_mock_server):
+        # 403 is "SLO tracking is off"; it used to share 400 with malformed criteria
+        SyncMockHandler.response_status = 403
+        SyncMockHandler.response_body = "SLO tracking not enabled"
+        with MockServerClient("127.0.0.1", sync_mock_server) as client:
+            with pytest.raises(MockServerError, match="sloTrackingEnabled=true"):
+                client.verify_slo({"name": "x"})
+
+    def test_verify_slo_malformed_criteria_raises_invalid_error(self, sync_mock_server):
         SyncMockHandler.response_status = 400
-        SyncMockHandler.response_body = "SLO tracking disabled"
+        SyncMockHandler.response_body = "objectives must be an array"
         with MockServerClient("127.0.0.1", sync_mock_server) as client:
-            with pytest.raises(MockServerError, match="SLO tracking disabled"):
+            with pytest.raises(MockServerError, match="Invalid SLO criteria"):
                 client.verify_slo({"name": "x"})