mockserver-client 6.0.0__tar.gz → 7.0.0__tar.gz

{mockserver_client-6.0.0 → mockserver_client-7.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mockserver-client
-Version: 6.0.0
+Version: 7.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

{mockserver_client-6.0.0 → mockserver_client-7.0.0}/mockserver/__init__.py

@@ -1,11 +1,20 @@
 from mockserver.models import (
     AfterAction,
+    BinaryResponse,
     Body,
     ConnectionOptions,
     Delay,
     DelayDistribution,
+    DnsRecord,
+    DnsResponse,
     Expectation,
     ExpectationId,
+    ExpectationStep,
+    GrpcBidiResponse,
+    GrpcBidiRule,
+    GrpcStreamMessage,
+    GrpcStreamResponse,
+    HttpChaosProfile,
     HttpClassCallback,
     HttpError,
     HttpForward,
@@ -45,12 +54,21 @@ from mockserver.async_client import AsyncMockServerClient
 __all__ = [
     "AfterAction",
     "AsyncMockServerClient",
+    "BinaryResponse",
     "Body",
     "ConnectionOptions",
     "Delay",
     "DelayDistribution",
+    "DnsRecord",
+    "DnsResponse",
     "Expectation",
     "ExpectationId",
+    "ExpectationStep",
+    "GrpcBidiResponse",
+    "GrpcBidiRule",
+    "GrpcStreamMessage",
+    "GrpcStreamResponse",
+    "HttpChaosProfile",
     "HttpClassCallback",
     "HttpError",
     "HttpForward",

{mockserver_client-6.0.0 → mockserver_client-7.0.0}/mockserver/async_client.py

@@ -18,6 +18,7 @@ from mockserver.exceptions import (
 from mockserver.fluent import ForwardChainExpectation
 from mockserver.models import (
     Expectation,
+    HttpChaosProfile,
     HttpObjectCallback,
     HttpRequest,
     HttpRequestAndHttpResponse,
@@ -166,6 +167,121 @@ class AsyncMockServerClient:
                 f"Failed to reset (status={status}): {response_body}"
             )
 
+    async def freeze_clock(self, instant: str | None = None) -> dict:
+        """Freeze the server clock at the given ISO-8601 instant.
+
+        If *instant* is ``None``, the clock freezes at the current real time.
+
+        Returns the JSON response as a dict with keys ``status``,
+        ``currentInstant``, and ``currentEpochMillis``.
+        """
+        payload: dict = {"action": "freeze"}
+        if instant is not None:
+            payload["instant"] = instant
+        body = json.dumps(payload)
+        status, response_body = await self._request("PUT", "/mockserver/clock", body)
+        if status >= 400:
+            raise MockServerError(
+                f"Failed to freeze clock (status={status}): {response_body}"
+            )
+        return json.loads(response_body) if response_body else {}
+
+    async def advance_clock(self, duration_millis: int) -> dict:
+        """Advance the frozen clock by *duration_millis* milliseconds.
+
+        Returns the JSON response as a dict with keys ``status``,
+        ``currentInstant``, and ``currentEpochMillis``.
+        """
+        body = json.dumps({"action": "advance", "durationMillis": duration_millis})
+        status, response_body = await self._request("PUT", "/mockserver/clock", body)
+        if status >= 400:
+            raise MockServerError(
+                f"Failed to advance clock (status={status}): {response_body}"
+            )
+        return json.loads(response_body) if response_body else {}
+
+    async def reset_clock(self) -> dict:
+        """Reset the server clock to real wall-clock time.
+
+        Returns the JSON response as a dict with keys ``status``,
+        ``currentInstant``, and ``currentEpochMillis``.
+        """
+        body = json.dumps({"action": "reset"})
+        status, response_body = await self._request("PUT", "/mockserver/clock", body)
+        if status >= 400:
+            raise MockServerError(
+                f"Failed to reset clock (status={status}): {response_body}"
+            )
+        return json.loads(response_body) if response_body else {}
+
+    async def clock_status(self) -> dict:
+        """Query the current clock status.
+
+        Returns a dict with keys ``currentInstant``, ``currentEpochMillis``,
+        and ``frozen``.
+        """
+        status, response_body = await self._request("GET", "/mockserver/clock")
+        if status >= 400:
+            raise MockServerError(
+                f"Failed to get clock status (status={status}): {response_body}"
+            )
+        return json.loads(response_body) if response_body else {}
+
+    async def set_service_chaos(
+        self, host: str, chaos: HttpChaosProfile, ttl_millis: int | None = None
+    ) -> dict:
+        """Register a service-scoped HTTP chaos profile for an upstream *host*.
+
+        The profile is applied to every matched forward expectation to that host
+        that does not define its own chaos (an expectation's own chaos always
+        wins). The host is matched case-insensitively, ignoring any ``:port``.
+
+        If *ttl_millis* is set, the chaos auto-reverts after that many milliseconds
+        (a dead-man's switch so it self-heals even if no clear is sent).
+        """
+        payload: dict = {"host": host, "chaos": chaos.to_dict()}
+        if ttl_millis is not None:
+            payload["ttlMillis"] = ttl_millis
+        body = json.dumps(payload)
+        status, response_body = await self._request("PUT", "/mockserver/serviceChaos", body)
+        if status >= 400:
+            raise MockServerError(
+                f"Failed to set service chaos (status={status}): {response_body}"
+            )
+        return json.loads(response_body) if response_body else {}
+
+    async def remove_service_chaos(self, host: str) -> dict:
+        """Remove the service-scoped chaos profile registered for *host*."""
+        body = json.dumps({"host": host, "remove": True})
+        status, response_body = await self._request("PUT", "/mockserver/serviceChaos", body)
+        if status >= 400:
+            raise MockServerError(
+                f"Failed to remove service chaos (status={status}): {response_body}"
+            )
+        return json.loads(response_body) if response_body else {}
+
+    async def clear_service_chaos(self) -> dict:
+        """Clear all service-scoped chaos profiles."""
+        body = json.dumps({"clear": True})
+        status, response_body = await self._request("PUT", "/mockserver/serviceChaos", body)
+        if status >= 400:
+            raise MockServerError(
+                f"Failed to clear service chaos (status={status}): {response_body}"
+            )
+        return json.loads(response_body) if response_body else {}
+
+    async def service_chaos_status(self) -> dict:
+        """Query the current service-scoped chaos registrations.
+
+        Returns a dict of the form ``{"services": {host: profile, ...}}``.
+        """
+        status, response_body = await self._request("GET", "/mockserver/serviceChaos")
+        if status >= 400:
+            raise MockServerError(
+                f"Failed to get service chaos (status={status}): {response_body}"
+            )
+        return json.loads(response_body) if response_body else {}
+
     async def verify(
         self,
         request: HttpRequest,

{mockserver_client-6.0.0 → mockserver_client-7.0.0}/mockserver/client.py

@@ -8,6 +8,7 @@ from mockserver.async_client import AsyncMockServerClient
 from mockserver.models import (
     Delay,
     Expectation,
+    HttpChaosProfile,
     HttpError,
     HttpForward,
     HttpOverrideForwardedRequest,
@@ -61,6 +62,21 @@ class SyncForwardChainExpectation:
     def respond_with_websocket(self, websocket_response) -> list[Expectation]:
         return self._run(self._async_chain.respond_with_websocket(websocket_response))
 
+    def respond_with_grpc_stream(self, grpc_stream_response) -> list[Expectation]:
+        return self._run(self._async_chain.respond_with_grpc_stream(grpc_stream_response))
+
+    def respond_with_binary(self, binary_response) -> list[Expectation]:
+        return self._run(self._async_chain.respond_with_binary(binary_response))
+
+    def respond_with_dns(self, dns_response) -> list[Expectation]:
+        return self._run(self._async_chain.respond_with_dns(dns_response))
+
+    def forward_with_template(self, template) -> list[Expectation]:
+        return self._run(self._async_chain.forward_with_template(template))
+
+    def forward_with_class_callback(self, class_callback) -> list[Expectation]:
+        return self._run(self._async_chain.forward_with_class_callback(class_callback))
+
     def error(self, error: HttpError) -> list[Expectation]:
         return self._run(self._async_chain.error(error))
 
@@ -111,6 +127,46 @@ class MockServerClient:
     def reset(self) -> None:
         return self._run(self._async_client.reset())
 
+    def freeze_clock(self, instant: str | None = None) -> dict:
+        """Freeze the server clock at the given ISO-8601 instant.
+
+        If *instant* is ``None``, the clock freezes at the current real time.
+        """
+        return self._run(self._async_client.freeze_clock(instant))
+
+    def advance_clock(self, duration_millis: int) -> dict:
+        """Advance the frozen clock by *duration_millis* milliseconds."""
+        return self._run(self._async_client.advance_clock(duration_millis))
+
+    def reset_clock(self) -> dict:
+        """Reset the server clock to real wall-clock time."""
+        return self._run(self._async_client.reset_clock())
+
+    def clock_status(self) -> dict:
+        """Query the current clock status."""
+        return self._run(self._async_client.clock_status())
+
+    def set_service_chaos(
+        self, host: str, chaos: HttpChaosProfile, ttl_millis: int | None = None
+    ) -> dict:
+        """Register a service-scoped HTTP chaos profile for an upstream host.
+
+        If *ttl_millis* is set, the chaos auto-reverts after that many milliseconds.
+        """
+        return self._run(self._async_client.set_service_chaos(host, chaos, ttl_millis))
+
+    def remove_service_chaos(self, host: str) -> dict:
+        """Remove the service-scoped chaos profile registered for *host*."""
+        return self._run(self._async_client.remove_service_chaos(host))
+
+    def clear_service_chaos(self) -> dict:
+        """Clear all service-scoped chaos profiles."""
+        return self._run(self._async_client.clear_service_chaos())
+
+    def service_chaos_status(self) -> dict:
+        """Query the current service-scoped chaos registrations."""
+        return self._run(self._async_client.service_chaos_status())
+
     def verify(
         self,
         request: HttpRequest,

{mockserver_client-6.0.0 → mockserver_client-7.0.0}/mockserver/fluent.py

@@ -4,8 +4,15 @@ import asyncio
 from typing import TYPE_CHECKING, Callable
 
 from mockserver.models import (
+    BinaryResponse,
     Delay,
+    DnsResponse,
     Expectation,
+    ExpectationStep,
+    GrpcBidiResponse,
+    GrpcStreamResponse,
+    HttpChaosProfile,
+    HttpClassCallback,
     HttpError,
     HttpForward,
     HttpObjectCallback,
@@ -37,6 +44,10 @@ class ForwardChainExpectation:
         self._expectation.priority = priority
         return self
 
+    def with_chaos(self, chaos: HttpChaosProfile) -> ForwardChainExpectation:
+        self._expectation.chaos = chaos
+        return self
+
     async def respond(self, response_or_callback) -> list[Expectation]:
         if callable(response_or_callback):
             client_id = await self._client._register_websocket_callback(
@@ -110,7 +121,68 @@ class ForwardChainExpectation:
         self._expectation.http_websocket_response = websocket_response
         return await self._client.upsert(self._expectation)
 
+    async def respond_with_grpc_stream(self, grpc_stream_response: GrpcStreamResponse) -> list[Expectation]:
+        if not isinstance(grpc_stream_response, GrpcStreamResponse):
+            raise TypeError(
+                f"Expected GrpcStreamResponse, got {type(grpc_stream_response).__name__}"
+            )
+        self._expectation.grpc_stream_response = grpc_stream_response
+        return await self._client.upsert(self._expectation)
+
+    async def respond_with_grpc_bidi(self, grpc_bidi_response: GrpcBidiResponse) -> list[Expectation]:
+        if not isinstance(grpc_bidi_response, GrpcBidiResponse):
+            raise TypeError(
+                f"Expected GrpcBidiResponse, got {type(grpc_bidi_response).__name__}"
+            )
+        self._expectation.grpc_bidi_response = grpc_bidi_response
+        return await self._client.upsert(self._expectation)
+
+    async def respond_with_binary(self, binary_response: BinaryResponse) -> list[Expectation]:
+        if not isinstance(binary_response, BinaryResponse):
+            raise TypeError(
+                f"Expected BinaryResponse, got {type(binary_response).__name__}"
+            )
+        self._expectation.binary_response = binary_response
+        return await self._client.upsert(self._expectation)
+
+    async def respond_with_dns(self, dns_response: DnsResponse) -> list[Expectation]:
+        if not isinstance(dns_response, DnsResponse):
+            raise TypeError(
+                f"Expected DnsResponse, got {type(dns_response).__name__}"
+            )
+        self._expectation.dns_response = dns_response
+        return await self._client.upsert(self._expectation)
+
+    async def forward_with_template(self, template: HttpTemplate) -> list[Expectation]:
+        if not isinstance(template, HttpTemplate):
+            raise TypeError(
+                f"Expected HttpTemplate, got {type(template).__name__}"
+            )
+        self._expectation.http_forward_template = template
+        return await self._client.upsert(self._expectation)
+
+    async def forward_with_class_callback(self, class_callback: HttpClassCallback) -> list[Expectation]:
+        if not isinstance(class_callback, HttpClassCallback):
+            raise TypeError(
+                f"Expected HttpClassCallback, got {type(class_callback).__name__}"
+            )
+        self._expectation.http_forward_class_callback = class_callback
+        return await self._client.upsert(self._expectation)
+
     async def error(self, error: HttpError) -> list[Expectation]:
         self._expectation.http_error = error
         return await self._client.upsert(self._expectation)
 
+    async def with_steps(self, steps: list[ExpectationStep]) -> list[Expectation]:
+        """Set an ordered multi-action pipeline of steps.
+
+        Exactly one step must have ``responder=True``; that step produces the
+        HTTP response. All other steps are side-effects executed in order.
+        """
+        if not isinstance(steps, list) or not all(isinstance(s, ExpectationStep) for s in steps):
+            raise TypeError(
+                "Expected a list of ExpectationStep objects"
+            )
+        self._expectation.steps = steps
+        return await self._client.upsert(self._expectation)
+