pytest-amgi 0.41.0__py3-none-any.whl

pytest_amgi/__init__.py

@@ -0,0 +1,13 @@
+from pytest_amgi._internal import amgi_producer
+from pytest_amgi._internal import AMGIMessageResult
+from pytest_amgi._internal import AMGIProducer
+from pytest_amgi._internal import AMGIProducerFactory
+from pytest_amgi._internal import Message
+
+__all__ = [
+    "AMGIProducer",
+    "AMGIProducerFactory",
+    "AMGIMessageResult",
+    "Message",
+    "amgi_producer",
+]

pytest_amgi/_internal.py

@@ -0,0 +1,232 @@
+from __future__ import annotations
+
+import json as json_module
+import re
+from collections.abc import AsyncGenerator
+from collections.abc import Awaitable
+from collections.abc import Mapping
+from collections.abc import Sequence
+from contextlib import AsyncExitStack
+from dataclasses import dataclass
+from typing import Any
+from typing import Callable
+from typing import TypeAlias
+
+import pytest
+from amgi_common import Lifespan
+from amgi_types import AMGIApplication
+from amgi_types import AMGIReceiveEvent
+from amgi_types import AMGISendEvent
+from amgi_types import AMGIVersions
+from amgi_types import MessageScope
+from amgi_types import MessageSendEvent
+
+AMGI_CLIENT_SCOPE: AMGIVersions = {"version": "2.0", "spec_version": "2.0"}
+
+
+JsonType: TypeAlias = (
+    None | bool | int | float | str | Sequence["JsonType"] | Mapping[str, "JsonType"]
+)
+
+HeaderType: TypeAlias = (
+    Sequence[tuple[str | bytes, str | bytes]] | Mapping[str, str | bytes]
+)
+
+
+def encode_bytes(data: str | bytes) -> bytes:
+    if isinstance(data, str):
+        return data.encode()
+    return data
+
+
+def encode_headers(headers: HeaderType) -> Sequence[tuple[bytes, bytes]]:
+    header_items = headers.items() if isinstance(headers, Mapping) else headers
+    return [(encode_bytes(key), encode_bytes(value)) for key, value in header_items]
+
+
+class JsonMatcher:
+    def __init__(self, expected: JsonType) -> None:
+        self.expected = expected
+
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, bytes) and json_module.loads(other) == self.expected
+
+
+class HeadersMatcher:
+    def __init__(self, expected: HeaderType) -> None:
+        self.expected = expected
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Sequence):
+            return False
+
+        actual = list(other)
+
+        if isinstance(self.expected, Mapping):
+            expected = [
+                (encode_bytes(key), encode_bytes(value))
+                for key, value in self.expected.items()
+            ]
+            return sorted(actual) == sorted(expected)
+
+        expected = [
+            (encode_bytes(key), encode_bytes(value)) for key, value in self.expected
+        ]
+        return actual == expected
+
+
+class Message:
+    def __init__(
+        self,
+        address: str,
+        headers: HeaderType = (),
+        payload: str | bytes | None = None,
+        json: JsonType = None,
+        bindings: dict[str, dict[str, Any]] | None = None,
+    ) -> None:
+        self._address = address
+        self._header_matcher = HeadersMatcher(headers)
+        self._bindings = {} if bindings is None else bindings
+
+        payload_matcher: bytes | JsonMatcher | None = None
+        if payload is not None:
+            payload_matcher = encode_bytes(payload)
+        elif json is not None:
+            payload_matcher = JsonMatcher(json)
+
+        self._payload_matcher = payload_matcher
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Mapping):
+            return False
+
+        message_send = {
+            **other,
+            "payload": other.get("payload"),
+            "bindings": other.get("bindings", {}),
+        }
+
+        expected_message_send = {
+            "type": "message.send",
+            "address": self._address,
+            "headers": self._header_matcher,
+            "payload": self._payload_matcher,
+            "bindings": self._bindings,
+        }
+
+        return message_send == expected_message_send
+
+
+@dataclass(frozen=True)
+class AMGIMessageResult:
+    _events: Sequence[AMGISendEvent]
+
+    @property
+    def acked(self) -> bool:
+        return any(event["type"] == "message.ack" for event in self._events)
+
+    @property
+    def nack_message(self) -> str | None:
+        for event in self._events:
+            if event["type"] == "message.nack":
+                return event["message"]
+        return None
+
+    @property
+    def message_sends(self) -> Sequence[MessageSendEvent]:
+        return [event for event in self._events if event["type"] == "message.send"]
+
+    def assert_acked(self) -> None:
+        assert self.acked
+
+    def assert_nacked(self, *, match: str | None = None) -> None:
+        assert self.nack_message is not None
+        if match is not None:
+
+            assert re.search(match, self.nack_message) is not None
+
+    def assert_has_message_sends(self, message_sends: Sequence[Message]) -> None:
+        actual_message_sends = self.message_sends
+
+        assert len(actual_message_sends) == len(message_sends)
+        assert all(
+            expected == actual
+            for actual, expected in zip(actual_message_sends, message_sends)
+        )
+
+    def assert_has_message_send(
+        self,
+        address: str,
+        headers: HeaderType = (),
+        payload: str | bytes | None = None,
+        json: JsonType = None,
+        bindings: dict[str, dict[str, Any]] | None = None,
+    ) -> None:
+        expected_message = Message(address, headers, payload, json, bindings)
+
+        assert any(message == expected_message for message in self.message_sends)
+
+
+class AMGIProducer:
+    def __init__(
+        self,
+        app: AMGIApplication,
+        *,
+        state: dict[str, Any],
+    ) -> None:
+        self._app = app
+        self._state = state
+
+    async def send(
+        self,
+        address: str,
+        *,
+        payload: str | bytes | None = None,
+        json: JsonType = None,
+        headers: HeaderType | None = None,
+        bindings: dict[str, dict[str, Any]] | None = None,
+        extensions: dict[str, dict[str, Any]] | None = None,
+    ) -> AMGIMessageResult:
+        scope: MessageScope = {
+            "type": "message",
+            "amgi": AMGI_CLIENT_SCOPE,
+            "address": address,
+            "headers": [] if headers is None else encode_headers(headers),
+            "state": self._state.copy(),
+        }
+        if json is not None:
+            payload = json_module.dumps(json)
+        if payload is not None:
+            scope["payload"] = encode_bytes(payload)
+        if bindings is not None:
+            scope["bindings"] = bindings
+        if extensions is not None:
+            scope["extensions"] = extensions
+
+        events: list[AMGISendEvent] = []
+
+        async def receive() -> AMGIReceiveEvent:
+            raise RuntimeError("Receive should not be called for message scopes")
+
+        async def send(event: AMGISendEvent) -> None:
+            events.append(event)
+
+        await self._app(scope, receive, send)
+        return AMGIMessageResult(events)
+
+
+AMGIProducerFactory = Callable[
+    [AMGIApplication],
+    Awaitable[AMGIProducer],
+]
+
+
+@pytest.fixture
+async def amgi_producer() -> AsyncGenerator[AMGIProducerFactory, None]:
+    async with AsyncExitStack() as exit_stack:
+
+        async def factory(app: AMGIApplication) -> AMGIProducer:
+            state = await exit_stack.enter_async_context(Lifespan(app))
+            return AMGIProducer(app, state=state)
+
+        yield factory

pytest_amgi-0.41.0.dist-info/METADATA

@@ -0,0 +1,95 @@
+Metadata-Version: 2.3
+Name: pytest-amgi
+Version: 0.41.0
+Summary: Pytest helpers for AMGI applications
+Author: jack.burridge
+Author-email: jack.burridge <jack.burridge@mail.com>
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: amgi-common==0.41.0
+Requires-Dist: amgi-types==0.41.0
+Requires-Dist: pytest>=9.0.3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# pytest-amgi
+
+Pytest helpers for driving AMGI applications in-process.
+
+## Installation
+
+```
+pip install pytest-amgi==0.41.0
+```
+
+## Example
+
+This example uses [AsyncFast](https://pypi.org/project/asyncfast/):
+
+```python
+from asyncfast import AsyncFast
+from pytest_amgi import AMGIProducerFactory
+
+
+async def test_message(amgi_producer: AMGIProducerFactory) -> None:
+    app = AsyncFast()
+
+    @app.channel("topic")
+    async def handler(payload: int) -> None:
+        assert payload == 1
+
+    producer = await amgi_producer(app)
+    response = await producer.send("topic", json=1)
+
+    response.assert_acked()
+```
+
+The `amgi_producer` fixture starts lifespan before returning the producer and
+shuts it down when the test finishes.
+
+## Message Sends
+
+Use `assert_has_message_send` to assert that the application sent a follow-up
+message:
+
+```python
+from dataclasses import dataclass
+
+from asyncfast import AsyncFast
+from asyncfast import Message
+from asyncfast import MessageSender
+from pytest_amgi import AMGIProducerFactory
+
+
+@dataclass
+class ProcessOrder(Message, address="order.process"):
+    payload: dict[str, int]
+
+
+async def test_message_send(amgi_producer: AMGIProducerFactory) -> None:
+    app = AsyncFast()
+
+    @app.channel("order.created")
+    async def handle_order_created(
+        message_sender: MessageSender[ProcessOrder],
+    ) -> None:
+        await message_sender.send(ProcessOrder(payload={"id": 1}))
+
+    producer = await amgi_producer(app)
+    response = await producer.send("order.created")
+
+    response.assert_acked()
+    response.assert_has_message_send("order.process", json={"id": 1})
+```
+
+## Contact
+
+For questions or suggestions, please contact [jack.burridge@mail.com](mailto:jack.burridge@mail.com).
+
+## License
+
+Copyright 2026 AMGI

pytest_amgi-0.41.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+pytest_amgi/__init__.py,sha256=ZxY3bhhG1WZ2EpdXONAujEKeUNCJOvV2T2BOznAJRsc,366
+pytest_amgi/_internal.py,sha256=y6CxXoi3pLbZR-iPZ_GTM1Is8ML9SiX4o0ZKYM6KVv8,6934
+pytest_amgi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pytest_amgi-0.41.0.dist-info/WHEEL,sha256=8ZlpUMJ7mlDirmlHRhDirEx_nPnARrwDjeE92mlk68E,81
+pytest_amgi-0.41.0.dist-info/entry_points.txt,sha256=mn2Y0aOYE0_2SH8DDjkPGIvKKJPiEkoIuvE8UI5MY74,31
+pytest_amgi-0.41.0.dist-info/METADATA,sha256=AAUGeXQ7VdTBbRabx8yYKwnFcmdB5L_F8obMIGcRqrU,2420
+pytest_amgi-0.41.0.dist-info/RECORD,,

pytest_amgi-0.41.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.11.21
+Root-Is-Purelib: true
+Tag: py3-none-any

pytest_amgi-0.41.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[pytest11]
+amgi = pytest_amgi
+