mesh-sandbox 0.1.34__py3-none-any.whl → 1.0.1__py3-none-any.whl

mesh_sandbox/store/memory_store.py

@@ -1,175 +1,49 @@
-import asyncio
-import importlib
-import inspect
 import logging
-import pkgutil
-from abc import ABC, abstractmethod
 from collections import defaultdict
-from types import ModuleType
-from typing import Literal, Optional, cast
+from typing import Optional
 
-from fastapi import BackgroundTasks
-
-from .. import plugins as plugins_ns
 from ..common import EnvConfig
-from ..models.message import Message, MessageEvent, MessageStatus
+from ..models.message import Message
 from .canned_store import CannedStore
 
 
-class _SandboxPlugin(ABC):
-
-    triggers: list[Literal["message_accepted", "message_acknowledged"]] = []
-
-    @abstractmethod
-    async def on_event(self, event: str, message: Message):
-        pass
-
-
 class MemoryStore(CannedStore):
     """
     in memory store, good for 'in-process' testing or small messages
     """
 
-    supports_reset = True
+    readonly = False
     load_messages = False
 
-    def __init__(self, config: EnvConfig, logger: logging.Logger, plugins_module: ModuleType = plugins_ns):
+    def __init__(self, config: EnvConfig, logger: logging.Logger):
         super().__init__(config, logger, filter_expired=True)
 
-        self._plugin_registry = self._find_plugins(plugins_module)
-        self._plugin_instances: dict[str, list[_SandboxPlugin]] = {}
-
-    def _find_plugins(self, package: ModuleType) -> dict[str, list[type[_SandboxPlugin]]]:
-        plugin_classes = defaultdict(list)
-        for _, name, _ in pkgutil.iter_modules(package.__path__, package.__name__ + "."):
-            module = importlib.import_module(name)
-            for _, class_type in inspect.getmembers(module):
-
-                if not inspect.isclass(class_type) or not class_type.__name__.endswith("Plugin"):
-                    continue
-
-                self.logger.info(f"potential plugin: {class_type.__name__} found")
-                if not hasattr(class_type, "triggers"):
-                    self.logger.warning(f"plugin: {class_type.__name__} has no class attr triggers .. not loading")
-                    continue
-
-                if not hasattr(class_type, "on_event"):
-                    self.logger.warning(f"plugin: {class_type.__name__} has no class attr on_event .. not loading")
-                    continue
-
-                if not inspect.iscoroutinefunction(class_type.on_event):
-                    self.logger.warning(f"plugin: {class_type.__name__} on_event os not a coroutine.. not loading")
-                    continue
-
-                on_event_args = cast(list[str], inspect.getfullargspec(class_type.on_event)[0])
-
-                if not on_event_args:
-                    self.logger.warning(
-                        f"plugin: {class_type.__name__} on_event expected args event, message .. not loading"
-                    )
-                    continue
-
-                if not isinstance(inspect.getattr_static(class_type, "on_event"), staticmethod):
-                    on_event_args.pop(0)
-
-                if not len(on_event_args) == 2:
-                    self.logger.warning(
-                        f"plugin: {class_type.__name__} on_event expected args event, message .. not loading"
-                    )
-                    continue
-
-                for trigger in class_type.triggers:
-                    plugin_classes[trigger].append(class_type)
-
-        return cast(dict[str, list[type[_SandboxPlugin]]], plugin_classes)
-
-    @staticmethod
-    async def _construct(plugin_type: type[_SandboxPlugin]) -> _SandboxPlugin:
-        created = plugin_type()
-        return created
-
-    async def on_event(self, event: str, message: Message):
-
-        instances = self._plugin_instances.get(event, [])
-        if not instances:
-            registered = self._plugin_registry.get(event, [])
-            if not registered:
-                return
-
-            instances = await asyncio.gather(*[self._construct(plugin_type) for plugin_type in registered])
-            self._plugin_instances[event] = instances
-
-        await asyncio.gather(*[plugin.on_event(event, message) for plugin in instances])
-
     async def reset(self):
-        async with self.lock:
-            super().initialise()
+        super().initialise()
 
     async def reset_mailbox(self, mailbox_id: str):
+        self.inboxes[mailbox_id] = []
+        self.outboxes[mailbox_id] = []
+        self.local_ids[mailbox_id] = defaultdict(list)
+        self.mailboxes[mailbox_id].inbox_count = 0
 
-        async with self.lock:
-            self.inboxes[mailbox_id] = []
-            self.outboxes[mailbox_id] = []
-            self.local_ids[mailbox_id] = defaultdict(list)
-            self.mailboxes[mailbox_id].inbox_count = 0
-
-    async def save_message(self, message: Message):
-        self.messages[message.message_id] = message
-
-    async def send_message(self, message: Message, body: bytes, background_tasks: BackgroundTasks) -> Message:
-
-        async with self.lock:
-            parts = cast(list[Optional[bytes]], [None for _ in range(message.total_chunks)])
-
-            self.chunks[message.message_id] = parts
+    async def add_to_outbox(self, message: Message):
+        if not message.sender.mailbox_id:
+            return
 
-            if message.total_chunks > 0:
-                await self.receive_chunk(message, 1, body, background_tasks)
+        self.outboxes[message.sender.mailbox_id].insert(0, message)
+        if not message.metadata.local_id:
+            return
 
-            if message.sender.mailbox_id:
-                self.outboxes[message.sender.mailbox_id].insert(0, message)
-                if message.metadata.local_id:
-                    self.local_ids[message.sender.mailbox_id][message.metadata.local_id].insert(0, message)
+        self.local_ids[message.sender.mailbox_id][message.metadata.local_id].insert(0, message)
 
-            if message.status != MessageStatus.ACCEPTED:
-                await self.save_message(message)
-            else:
-                await self._accept_message_no_lock(message, background_tasks)
+    async def add_to_inbox(self, message: Message):
+        self.inboxes[message.recipient.mailbox_id].append(message)
 
-        background_tasks.add_task(self.on_event, "post_send_message", message)
-        return message
+    async def save_message(self, message: Message):
+        self.messages[message.message_id] = message
 
     async def save_chunk(self, message: Message, chunk_number: int, chunk: Optional[bytes]):
+        if message.message_id not in self.chunks:
+            self.chunks[message.message_id] = [None for _ in range(message.total_chunks)]
         self.chunks[message.message_id][chunk_number - 1] = chunk
-
-    async def receive_chunk(
-        self, message: Message, chunk_number: int, chunk: Optional[bytes], background_tasks: BackgroundTasks
-    ):
-        await self.save_chunk(message, chunk_number, chunk)
-        background_tasks.add_task(self.on_event, "chunk_received", message)
-
-    async def _get_file_size(self, message: Message) -> int:
-        return sum(len(chunk or b"") for chunk in self.chunks.get(message.message_id, []))
-
-    async def _accept_message_no_lock(self, message: Message, background_tasks: BackgroundTasks) -> Message:
-
-        if message.status != MessageStatus.ACCEPTED:
-            message.events.insert(0, MessageEvent(status=MessageStatus.ACCEPTED))
-        message.file_size = await self._get_file_size(message)
-        self.inboxes[message.recipient.mailbox_id].append(message)
-        await self.save_message(message)
-
-        background_tasks.add_task(self.on_event, "message_accepted", message)
-        return message
-
-    async def accept_message(self, message: Message, background_tasks: BackgroundTasks) -> Message:
-        async with self.lock:
-            return await self._accept_message_no_lock(message, background_tasks)
-
-    async def acknowledge_message(self, message: Message, background_tasks: BackgroundTasks) -> Message:
-        async with self.lock:
-            message.events.insert(0, MessageEvent(status=MessageStatus.ACKNOWLEDGED))
-            await self.save_message(message)
-
-        background_tasks.add_task(self.on_event, "message_acknowledged", message)
-        return message

mesh_sandbox/test_plugin/example_plugin.py

@@ -1,5 +1,6 @@
 import logging
 import os.path
+from typing import Any, Optional
 
 
 class OnMessageAcceptedPlugin:
@@ -8,9 +9,18 @@ class OnMessageAcceptedPlugin:
         with open(os.path.join(os.path.dirname(__file__), "example_plugin.txt"), encoding="utf-8", mode="r") as f:
             self.config_message = f.read().strip()
 
-    triggers = ["message_accepted"]
+    triggers = ["before_accept_message"]
 
-    async def on_event(self, event: str, message):  # pylint: disable=unused-argument
+    async def on_event(self, event: str, kwargs: dict[str, Any], err: Optional[Exception] = None):
+
+        if err:
+            print(f"plugin received error {event}\n{kwargs}\n{err}")
+            return
+
+        print(f"plugin received event {event}")
+
+        message = kwargs.get("message")
+        assert message
         self.logger.info(f"message: {message.message_id} accepted - {self.config_message}")
 
         if not message.metadata.subject:

mesh_sandbox/tests/admin.py

@@ -17,7 +17,7 @@ from mesh_sandbox.tests.mesh_api_helpers import (
 
 from ..common.constants import Headers
 from ..models.message import MessageStatus, MessageType
-from ..views.admin import PutReportRequest
+from ..views.admin import AddMessageEventRequest, CreateReportRequest
 from .helpers import generate_auth_token, temp_env_vars
 
 
@@ -241,7 +241,7 @@ def test_put_report_in_inbox(app: TestClient, tmp_path: str):
 
     with temp_env_vars(STORE_MODE="file", MAILBOXES_DATA_DIR=tmp_path):
 
-        request = PutReportRequest(
+        request = CreateReportRequest(
             mailbox_id=recipient,
             status=MessageStatus.ERROR,
             workflow_id=uuid4().hex,
@@ -298,3 +298,64 @@ def test_put_report_in_inbox(app: TestClient, tmp_path: str):
         )
         messages = res.json().get("messages", [])
         assert not messages
+
+
+def test_add_message_event(app: TestClient, tmp_path: str):
+
+    recipient = _CANNED_MAILBOX1
+
+    with temp_env_vars(STORE_MODE="file", MAILBOXES_DATA_DIR=tmp_path):
+
+        create_report_request = CreateReportRequest(
+            mailbox_id=recipient,
+            status=MessageStatus.ERROR,
+            workflow_id=uuid4().hex,
+            code="21",
+            description="my error",
+            subject=f"my subject {uuid4().hex}",
+            local_id=f"my local id {uuid4().hex}",
+            file_name=f"my filename {uuid4().hex}",
+            linked_message_id=uuid4().hex,
+        )
+
+        res = app.post("/messageexchange/report", json=create_report_request.dict())
+        assert res.status_code == status.HTTP_200_OK
+
+        result = res.json()
+        assert result
+        message_id = result["message_id"]
+        assert message_id
+
+        res = app.get(
+            f"/messageexchange/{recipient}/inbox",
+            headers={Headers.Authorization: generate_auth_token(recipient)},
+        )
+        messages = res.json().get("messages", [])
+        assert messages
+        assert messages[0] == message_id
+
+        res = app.put(
+            f"/messageexchange/{recipient}/inbox/{message_id}/status/acknowledged",
+            headers={Headers.Authorization: generate_auth_token(recipient)},
+        )
+        assert res.status_code == status.HTTP_200_OK
+
+        res = app.get(
+            f"/messageexchange/{recipient}/inbox",
+            headers={Headers.Authorization: generate_auth_token(recipient)},
+        )
+        messages = res.json().get("messages", [])
+        assert not messages
+
+        # move the message to accepted again
+        add_event_request = AddMessageEventRequest(status=MessageStatus.ACCEPTED)
+
+        res = app.post(f"/messageexchange/message/{message_id}/event", json=add_event_request.dict())
+        assert res.status_code == status.HTTP_200_OK
+
+        res = app.get(
+            f"/messageexchange/{recipient}/inbox",
+            headers={Headers.Authorization: generate_auth_token(recipient)},
+        )
+        messages = res.json().get("messages", [])
+        assert messages == [message_id]

mesh_sandbox/tests/messaging_tests.py

@@ -0,0 +1,165 @@
+from typing import Any, Optional
+from uuid import uuid4
+
+import pytest
+from fastapi import BackgroundTasks
+
+from .. import tests as tests_module
+from ..common.messaging import Messaging
+from ..dependencies import get_messaging, get_store
+from ..models.message import (
+    Message,
+    MessageEvent,
+    MessageMetadata,
+    MessageParty,
+    MessageStatus,
+)
+from .helpers import temp_env_vars
+
+
+@pytest.fixture(name="message", scope="function")
+def _create_message() -> Message:
+    message = Message(
+        message_id=uuid4().hex.upper(),
+        workflow_id=uuid4().hex.upper(),
+        sender=MessageParty(mailbox_id=uuid4().hex.upper()),
+        recipient=MessageParty(mailbox_id=uuid4().hex.upper()),
+        metadata=MessageMetadata(),
+        events=[MessageEvent(status=MessageStatus.ACCEPTED)],
+    )
+    return message
+
+
+@pytest.fixture(name="background_tasks", scope="function")
+def _background_tasks() -> BackgroundTasks:
+    return BackgroundTasks()
+
+
+async def test_canned_store_raises_for_save_message(message: Message):
+
+    with pytest.raises(NotImplementedError):
+        with temp_env_vars(STORE_MODE="canned"):
+            store = get_store()
+            await store.save_message(message)
+
+
+async def test_canned_messaging_does_not_raise_no_bgt(message: Message):
+
+    calls = []
+
+    class TestPlugin:
+
+        triggers = ["before_save_message", "after_save_message", "save_message_error"]
+
+        async def on_event(self, event: str, args: dict[str, Any], exception: Optional[Exception] = None):
+            calls.append((event, args, exception))
+
+    with temp_env_vars(STORE_MODE="canned"):
+        messaging = get_messaging()
+        messaging.register_plugin(TestPlugin)
+        await messaging.save_message(message=message)
+
+    assert len(calls) == 1
+    assert calls[0][0] == "before_save_message"
+
+
+async def test_canned_messaging_does_not_raise_with_bgt(message: Message, background_tasks: BackgroundTasks):
+
+    calls = []
+
+    class Test2Plugin:
+
+        triggers = ["before_save_message", "after_save_message", "save_message_error"]
+
+        async def on_event(self, event: str, args: dict[str, Any], exception: Optional[Exception] = None):
+            calls.append((event, args, exception))
+
+    with temp_env_vars(STORE_MODE="canned"):
+        messaging = get_messaging()
+        messaging.register_plugin(Test2Plugin)
+        await messaging.save_message(message=message, background_tasks=background_tasks)
+
+    await background_tasks()
+
+    assert len(calls) == 2
+    assert calls[0][0] == "before_save_message"
+    assert calls[1][0] == "after_save_message"
+
+
+async def test_messaging_does_not_raise_with_bgt(message: Message, background_tasks: BackgroundTasks):
+
+    calls = []
+
+    class Test2Plugin:
+
+        triggers = ["before_save_message", "after_save_message", "save_message_error"]
+
+        async def on_event(self, event: str, args: dict[str, Any], exception: Optional[Exception] = None):
+            calls.append((event, args, exception))
+
+    with temp_env_vars(STORE_MODE="memory"):
+        messaging = get_messaging()
+        messaging.register_plugin(Test2Plugin)
+        await messaging.save_message(message=message, background_tasks=background_tasks)
+
+    await background_tasks()
+
+    assert len(calls) == 2
+    assert calls[0][0] == "before_save_message"
+    assert calls[1][0] == "after_save_message"
+
+
+async def test_error_events_raised_with_bgt(message: Message, background_tasks: BackgroundTasks):
+
+    calls = []
+
+    class Test2Plugin:
+
+        triggers = ["before_save_message", "after_save_message", "save_message_error"]
+
+        async def on_event(self, event: str, args: dict[str, Any], exception: Optional[Exception] = None):
+            calls.append((event, args, exception))
+
+    with temp_env_vars(STORE_MODE="memory"):
+        messaging = get_messaging()
+        messaging.register_plugin(Test2Plugin)
+        await messaging.save_message(message=message, background_tasks=background_tasks)
+
+    await background_tasks()
+
+    assert len(calls) == 2
+    assert calls[0][0] == "before_save_message"
+    assert calls[1][0] == "after_save_message"
+
+
+class TestDiscoveredPlugin:
+
+    triggers = ["before_accept_message"]
+
+    async def on_event(self, event: str, args: dict[str, Any], err: Optional[Exception] = None):
+        pass
+
+
+async def test_plugin_discovery(monkeypatch):
+
+    messaging = Messaging(store=get_store(), plugins_module=tests_module)
+
+    calls = []
+
+    async def on_event(_, event: str, args: dict[str, Any], err: Optional[Exception] = None):
+        calls.append((event, args, err))
+
+    monkeypatch.setattr(TestDiscoveredPlugin, "on_event", on_event)
+
+    assert messaging._plugin_registry  # pylint: disable=protected-access
+
+    message = Message(message_id=uuid4().hex)
+    args = {"message": message}
+
+    await messaging.on_event("before_accept_message", args)
+
+    assert len(calls) == 1
+
+    assert calls[0][0] == "before_accept_message"
+    assert calls[0][1] == args
+    assert calls[0][2] is None

mesh_sandbox/views/admin.py

@@ -5,7 +5,7 @@ from pydantic import BaseModel, Field  # pylint: disable=no-name-in-module
 from mesh_sandbox.models.message import MessageStatus
 
 
-class PutReportRequest(BaseModel):
+class CreateReportRequest(BaseModel):
     mailbox_id: str = Field(description="mailbox id to put the report in")
     code: str = Field(description="error code")
     description: str = Field(description="error description")
@@ -15,3 +15,11 @@ class PutReportRequest(BaseModel):
     status: str = Field(description="report status (error/undeliverable)", default=MessageStatus.UNDELIVERABLE)
     file_name: Optional[str] = Field(description="file name", default=None)
     linked_message_id: Optional[str] = Field(description="linked message id", default=None)
+
+
+class AddMessageEventRequest(BaseModel):
+    status: str = Field(description="new message status")
+    code: str = Field(description="error code", default=None)
+    event: str = Field(description="error event (SEND/TRANSFER) etc)", default=None)
+    description: str = Field(description="error description", default=None)
+    linked_message_id: Optional[str] = Field(description="linked message id", default=None)

{mesh_sandbox-0.1.34.dist-info → mesh_sandbox-1.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mesh-sandbox
-Version: 0.1.34
+Version: 1.0.1
 Summary: NHSDigital mesh sandbox, a locally testable version of the MESH api
 License: MIT
 Author: spinecore

{mesh_sandbox-0.1.34.dist-info → mesh_sandbox-1.0.1.dist-info}/RECORD

@@ -1,27 +1,28 @@
-mesh_sandbox/__init__.py,sha256=79r5jd-MqbhXLbIBDVBqUJvhvcucjkaId96r46KF18I,23
+mesh_sandbox/__init__.py,sha256=d4QHYmS_30j0hPN8NmNPnQ_Z0TphDRbu4MtQj9cT9e8,22
 mesh_sandbox/api.py,sha256=F2KUKENAsSe6NAGG0wzHA2jebGF6mWFgta1q55oqacU,3925
 mesh_sandbox/common/__init__.py,sha256=MwKS4FixADUGgN49MQJI7vW0Wx6mnf9SBOPbgE4RddM,3403
 mesh_sandbox/common/constants.py,sha256=_hnaHDkAQGHWLF7n_WfC5ZHIY5D-fUbOdpSqLusUMNY,6504
 mesh_sandbox/common/exceptions.py,sha256=YQII8w6DQQoKuW0cukEr6PIE9j0rwrqDpCn5lapgmkQ,1481
 mesh_sandbox/common/fernet.py,sha256=f8yygkVnK1cmQLBgcPifoB4PwGpgiOrG8Yk-6OMDy8o,551
 mesh_sandbox/common/handler_helpers.py,sha256=Eg00Tide2mL87EoMFw83fDuxiTL5DgIwxHs2RaJasgE,392
+mesh_sandbox/common/messaging.py,sha256=xZbNpWQLhfjI4wiBG3PpIkEy2WbvwxqaWSR90sSb4hk,14664
 mesh_sandbox/common/mex_headers.py,sha256=Eu-ixdVml2obROXggYyUyiS4QZHUA1JUgF7gO4YYkyg,6088
-mesh_sandbox/conftest.py,sha256=Bd-soyJTgtNAhC_LOH0vFNuE5bK9mPW1uYPglxL2Ox4,2186
-mesh_sandbox/dependencies.py,sha256=ityaCPppg6tLa-bm-uARIDt334ULDjooDDWZvHFp93E,3945
+mesh_sandbox/conftest.py,sha256=IXrb8Y8Hi4-0ZxDNfTDFI0L1uG1Iz9FBQdNBZtPMsEw,2233
+mesh_sandbox/dependencies.py,sha256=Crl7yEUED-XYl_odMenpvMJoYeIVDROWfvcrfvV85fc,4089
 mesh_sandbox/handlers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mesh_sandbox/handlers/admin.py,sha256=G1MagezVqk9jJP8h1l5AlybVdUSxGCDUQZklq3eJe3M,3143
+mesh_sandbox/handlers/admin.py,sha256=JwPqeN3LHpau0pk7QOEFVrKZ9DV_896j0L_eSZxHIX4,3783
 mesh_sandbox/handlers/handshake.py,sha256=p3_NveSscNBgCdIIJhBza34b0WreqgBxZwI2sw7ZMTk,605
-mesh_sandbox/handlers/inbox.py,sha256=USg8CFMjJ3JmPLPUclW9H-EqLGHLngxol-HQDgWlzJU,15501
-mesh_sandbox/handlers/lookup.py,sha256=hqZBjp-Bwg4Jrx71BfKE3ET2AO6x8XXsbl81tLYoshM,1471
-mesh_sandbox/handlers/outbox.py,sha256=jshdiG0sfbjapvHZsKvGI1-9b9ssKgPRh_e0vgx3_6w,9869
-mesh_sandbox/handlers/tracking.py,sha256=yZdb30g8vHRXv5o6AjgNcX6lY_sxlFxzc0_TxYmP_jU,2407
+mesh_sandbox/handlers/inbox.py,sha256=J20JUX1dHlS2We2UIDQa1MMoVN_QsRoP0tC-3zKAlD8,15450
+mesh_sandbox/handlers/lookup.py,sha256=p_xmnCJi6BoNqRaQjRAGeQthL5EohQfZ_LA1h0QU36Q,1392
+mesh_sandbox/handlers/outbox.py,sha256=XrLOGhw0QqMTfMFevrh-_Z-EyFSEAQLO1BcmbL1bR0Y,10045
+mesh_sandbox/handlers/tracking.py,sha256=nmn5JexFhAvzFmj9C5l0w4sq8sNz3x-mMd3CsGVrEM4,2356
 mesh_sandbox/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mesh_sandbox/models/mailbox.py,sha256=W1b1R1XjhyiCp30LvTLtQVlxagfxXH8eb0XnNj3D4Dw,993
 mesh_sandbox/models/message.py,sha256=ze-IPbCg6XlKZtOL1RWQvMnu04AzrGppwdk2mTyVAfU,4926
 mesh_sandbox/models/workflow.py,sha256=T8A1Q729TOUaz1MOa1Ly8oZs_G4769xMZpTYGF0TlO8,518
 mesh_sandbox/plugins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mesh_sandbox/routers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mesh_sandbox/routers/admin.py,sha256=dNnW77DUc5IWNehkpuKgbOywEmG8Jg_uVpK-pMTI-ZE,2990
+mesh_sandbox/routers/admin.py,sha256=pJ9rPF-JDWs1dbVbQVqW8uKQrX3yh4oUxswBOnO5zR8,3852
 mesh_sandbox/routers/handshake.py,sha256=5TVyQ5OrHIe6W3UVpbap-hc5ia669Of6w6F1vgcYjm4,2693
 mesh_sandbox/routers/inbox.py,sha256=EkOmL9pxE6pYPBTzGU1CZJLu80ZR2EnKg9fe7DDMLLQ,8898
 mesh_sandbox/routers/inbox_count.py,sha256=hY88h7dBa6asnvYEP9mmx6CEBw5ZyRO7gz6lHg4Yj3c,1521
@@ -31,8 +32,8 @@ mesh_sandbox/routers/request_logging.py,sha256=gZaOJ_Mp3QPsmrpxXQ0pOzVGNPKd_RAEj
 mesh_sandbox/routers/tracking.py,sha256=UVIRkMBGD5pI7vgp8l6cnP5VX8OFRDPNb2JHs9q5w58,2210
 mesh_sandbox/routers/update.py,sha256=a9ttmk3levdDcu-ZF7a5EniR35zRMhty8pG2EyzB1po,409
 mesh_sandbox/store/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mesh_sandbox/store/base.py,sha256=UDNqXBWTsJTyEL4XcuEIhW6xD7R7exp0pwVuVegRmLM,6283
-mesh_sandbox/store/canned_store.py,sha256=cdO0uXi0TMRTxHF6X7pn1hdQSbFqBHdNMqnoLkEZ3u4,9929
+mesh_sandbox/store/base.py,sha256=FV93oTeg40ikOaIqcRmDGnigbOEpYexYNqcLyvCaLnA,1983
+mesh_sandbox/store/canned_store.py,sha256=DG5v7Aqy29mCCF9nupqoLIW4m2puLl6iGs2JiNtYnyw,9862
 mesh_sandbox/store/data/mailboxes/X26ABC1/in/SIMPLE_MESSAGE/1,sha256=aqaFLD9HL0hqn0sLIsv-qQqMVyaBmnHx17fu-lgVR9A,662
 mesh_sandbox/store/data/mailboxes/X26ABC1/in/SIMPLE_MESSAGE.json,sha256=lb_vaAXr9hJefOdQ1WXvrBXlIRtzPKzUXt3NT_-b_qA,714
 mesh_sandbox/store/data/mailboxes/X26ABC1/in/UNDELIVERED_MESSAGE/1,sha256=aqaFLD9HL0hqn0sLIsv-qQqMVyaBmnHx17fu-lgVR9A,662
@@ -42,14 +43,14 @@ mesh_sandbox/store/data/mailboxes/X26ABC2/in/CHUNKED_MESSAGE_GZ/2,sha256=uelYjD2
 mesh_sandbox/store/data/mailboxes/X26ABC2/in/CHUNKED_MESSAGE_GZ.json,sha256=N9T-V-nTrwnJeSefL5aIjXLLlBkjdO86iUmKyxjee0k,817
 mesh_sandbox/store/data/mailboxes.jsonl,sha256=ADXpImNo9UH6rY6T9bqgI-BvnbziFaGwcf_XeJW1bW4,432
 mesh_sandbox/store/data/workflows.jsonl,sha256=RFvycuqVmEkImeXlFD2wjuJFjt6dw581D_raPWstxpU,292
-mesh_sandbox/store/file_store.py,sha256=CHKJ5h_JRgMPEUS3-GvxoD0ZzjR6hlh2jNkqK0BB6oY,2383
-mesh_sandbox/store/memory_store.py,sha256=tGwhygUawf-VG05xxkgkE5nA6AYW1SXJ4XtCPRw9GdI,7036
+mesh_sandbox/store/file_store.py,sha256=a4GAhDLjEj2S-zvQxpbMkyDKhC69POCFZln0abH6sUw,2400
+mesh_sandbox/store/memory_store.py,sha256=VJTsPAnwvPAVFTEo-mO2A__lcc7jMnyqiq0JerYmrKY,1643
 mesh_sandbox/store/serialisation.py,sha256=pMYZ704GP74aCDRX9Nu1r4B1XA4BPJXYY-RKLFJJfUg,3615
 mesh_sandbox/test_plugin/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mesh_sandbox/test_plugin/example_plugin.py,sha256=K0yFDl64bH4QRtx1XFw2HzaSutNCYi3LGszwkcdTcnI,698
+mesh_sandbox/test_plugin/example_plugin.py,sha256=MnNpyyWKziqvOr89LeIxOwqskwHcrSsh_te67SeNJr4,967
 mesh_sandbox/test_plugin/example_plugin.txt,sha256=aUePU6UUVhpxeP37Pdz5Zxyn_nxI6HCY3qtQBo1iUEI,24
 mesh_sandbox/tests/__init__.py,sha256=wPjH0Ka1334a0OR9VMUfeYxsr03JqWjHTBnAH_1SB7I,106
-mesh_sandbox/tests/admin.py,sha256=3DPIZXNmItwnoAEmf4Bn601l2QmDy7iPuFFfnV3jH7c,12362
+mesh_sandbox/tests/admin.py,sha256=Y_nzBhqSGPCTjG3EczSHClA-mVALGNBd-iOShoYh8WU,14549
 mesh_sandbox/tests/docker_tests.py,sha256=SJuuquoQA7_fP49--89mrIZmY_4KRO7fiFkOcZeR4AU,1584
 mesh_sandbox/tests/exceptions.py,sha256=j_jKskVzLAYpyu4qNAEY5ahkbk8Uh2Nc_CGpnpdXjnI,740
 mesh_sandbox/tests/handshake.py,sha256=X-fCbwaEAc8cAvvnniCvt4W4DAV9ItPq7tpIpZkfj6M,6259
@@ -59,17 +60,17 @@ mesh_sandbox/tests/java_client_tests.py,sha256=NYvNH1LxJc0SmHQ3q6mSvEd6Wuv2r_xMq
 mesh_sandbox/tests/lookup.py,sha256=wY8x0F415y2um48Lw5kyD4ugMo1vBGKB7cqPdHEaVO4,2768
 mesh_sandbox/tests/mesh_api_helpers.py,sha256=ZedDWMHO88j4Zxw3hsK5vmvivy3UhdzbzHle0g9GJXA,3901
 mesh_sandbox/tests/mesh_client_tests.py,sha256=WL7ht-tT4QLMw73pIbcFMZg7Ehpn5Mi4jcZg5qgEgyw,3947
+mesh_sandbox/tests/messaging_tests.py,sha256=Bup6aJsiJ0xdtg0Ab37ME0VHI6HFJA-0ATmfS88giBI,5006
 mesh_sandbox/tests/outbox.py,sha256=AbQR8vgRy8KAG0RMCU0jYFUXSCPQMrLRJMJTU3PGQhI,20061
-mesh_sandbox/tests/plugin_manager_tests.py,sha256=wTmyDtg1Up2jzqZgiRIVjkD35USZw-tTEoS4LtdFwCo,1070
 mesh_sandbox/tests/serialisation.py,sha256=kRSMZLDHlX6oRK6c2OCZL0XQoUCKQxqcYXrJWbc9VkA,663
 mesh_sandbox/views/__init__.py,sha256=nZkb6_1S8jz8Xl_AayfwjgEZG0JD2dfulfGxjJ5W9Ec,1237
-mesh_sandbox/views/admin.py,sha256=l4WfErLNgc14qObt0iwK_Q3sl_IbMImybcyLgv3pW0Y,896
+mesh_sandbox/views/admin.py,sha256=2YGslfDyC0QKoq3WTGXBicqrOMR9UmQYocP3R0qTbAY,1315
 mesh_sandbox/views/error.py,sha256=9lnUr3P93Vm-nOrBTEuAD6nrSBUvpI6-XqXzILWjgGk,3885
 mesh_sandbox/views/inbox.py,sha256=gnaD9Csx5BqilVRefQQ_tXmeq80lwcLJfepW005GrkU,5662
 mesh_sandbox/views/lookup.py,sha256=HHUqZ-Iy22ysC3qaO8Bl5GBQqf_7IiBbe5acyxqS78M,2775
 mesh_sandbox/views/outbox.py,sha256=jxYiHylEdpljZ6Wl45Ke3aaH5rEKb-kzUuCNEKDS3So,4932
 mesh_sandbox/views/tracking.py,sha256=1H7Ghcvqkmx__KS1Y-lm105EVx_Z1eJo3oMDh8pzRMQ,8918
-mesh_sandbox-0.1.34.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
-mesh_sandbox-0.1.34.dist-info/LICENSE,sha256=usgzIvDUpVX5pYZepJTRXQJqIaz0mdd32GuS5a3PFlY,1051
-mesh_sandbox-0.1.34.dist-info/METADATA,sha256=JtP-cKUHvIMaz8fEdnSfaDzR5-PqhyvBwflPEsCVd1g,2433
-mesh_sandbox-0.1.34.dist-info/RECORD,,
+mesh_sandbox-1.0.1.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
+mesh_sandbox-1.0.1.dist-info/LICENSE,sha256=usgzIvDUpVX5pYZepJTRXQJqIaz0mdd32GuS5a3PFlY,1051
+mesh_sandbox-1.0.1.dist-info/METADATA,sha256=UUnhdGz3llub6OOLmTV7d2zGBkawfaUyyUzhSR1zMuE,2432
+mesh_sandbox-1.0.1.dist-info/RECORD,,

mesh_sandbox/tests/plugin_manager_tests.py

@@ -1,41 +0,0 @@
-import logging
-from uuid import uuid4
-
-from .. import tests as tests_module
-from ..common import EnvConfig
-from ..models.message import Message
-from ..store.memory_store import MemoryStore
-
-
-class TestPlugin:
-
-    triggers = ["message_accepted"]
-
-    def real_handler(self, event: str, message: Message):
-        pass
-
-    async def on_event(self, event: str, message: Message):
-        self.real_handler(event, message)
-
-
-async def test_plugin_provider():
-
-    manager = MemoryStore(config=EnvConfig(), logger=logging.getLogger("mesh-sandbox"), plugins_module=tests_module)
-
-    calls = []
-
-    def test_handler(_: TestPlugin, event: str, message: Message):
-        calls.append((event, message))
-
-    TestPlugin.real_handler = test_handler  # type: ignore[method-assign, assignment]
-
-    assert manager._plugin_registry  # pylint: disable=protected-access
-
-    message = Message(message_id=uuid4().hex)
-
-    await manager.on_event("message_accepted", message)
-
-    assert len(calls) == 1
-
-    assert calls[0][0] == "message_accepted"
-    assert calls[0][1] == message