pytest-amgi 0.41.0__tar.gz

pytest_amgi-0.41.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,77 @@
+# 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/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+build-backend = "uv_build"
+requires = [
+  "uv-build>=0.10.7,<0.11.0",
+]
+
+[project]
+name = "pytest-amgi"
+version = "0.41.0"
+description = "Pytest helpers for AMGI applications"
+readme = "README.md"
+authors = [
+  { name = "jack.burridge", email = "jack.burridge@mail.com" },
+]
+requires-python = ">=3.10"
+classifiers = [
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+]
+dependencies = [
+  "amgi-common==0.41.0",
+  "amgi-types==0.41.0",
+  "pytest>=9.0.3",
+]
+entry-points.pytest11.amgi = "pytest_amgi"
+
+[dependency-groups]
+dev = [
+  "pytest-asyncio>=1.4.0",
+  "pytest-cov>=7.0.0",
+  "pytest-timeout>=2.4.0",
+]
+
+[tool.uv]
+sources.amgi-common.workspace = true
+sources.amgi-types.workspace = true

pytest_amgi-0.41.0/src/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-0.41.0/src/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