mesh-sandbox 0.1.14__py3-none-any.whl → 0.1.16__py3-none-any.whl

mesh_sandbox/__init__.py

@@ -1 +1 @@
-__version__ = "0.1.14"
+__version__ = "0.1.16"

mesh_sandbox/api.py

@@ -7,12 +7,12 @@ from .common import logger
 from .common.exceptions import MessagingException
 from .dependencies import get_env_config
 from .routers import (
+    admin,
     handshake,
     inbox,
     inbox_count,
     lookup,
     outbox,
-    simple,
     tracking,
     update,
 )
@@ -72,7 +72,7 @@ async def validation_exception_handler(request: Request, exc: RequestValidationE
     return get_validation_error_response(request, exc)
 
 
-app.include_router(simple.router)
+app.include_router(admin.router)
 
 
 app.include_router(

mesh_sandbox/handlers/inbox.py

@@ -241,9 +241,10 @@ class InboxHandler:
         max_results: int = DEFAULT_MAX_RESULTS,
         last_key: Optional[dict] = None,
         message_filter: Optional[Callable[[Message], bool]] = None,
+        rich: bool = False,
     ) -> tuple[list[Message], Optional[dict]]:
 
-        messages = await self.store.get_inbox(mailbox.mailbox_id)
+        messages = await self.store.get_inbox(mailbox.mailbox_id, rich=rich)
 
         if message_filter:
             messages = list(filter(message_filter, messages))
@@ -383,7 +384,7 @@ class InboxHandler:
         def message_filter(message: Message) -> bool:
             return message.created_timestamp > from_date
 
-        messages, last_key = await self._get_inbox_messages(mailbox, max_results, last_key, message_filter)
+        messages, last_key = await self._get_inbox_messages(mailbox, max_results, last_key, message_filter, rich=True)
 
         url_template = "{0}/inbox/rich"
         links: dict[str, str] = {

mesh_sandbox/handlers/reset.py

@@ -1,4 +1,6 @@
-from fastapi import Depends
+from typing import Optional
+
+from fastapi import Depends, HTTPException, status
 
 from ..common import EnvConfig
 from ..dependencies import get_env_config, get_store
@@ -10,5 +12,14 @@ class ResetHandler:
         self.config = config
         self.store = store
 
-    async def reset(self, clear_disk: bool):
-        await self.store.reinitialise(clear_disk)
+    async def reset(self, clear_disk: bool, mailbox_id: Optional[str] = None):
+
+        if not mailbox_id:
+            await self.store.reset(clear_disk)
+            return
+
+        mailbox = await self.store.get_mailbox(mailbox_id, accessed=True)
+        if not mailbox:
+            raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="mailbox does not exist")
+
+        await self.store.reset_mailbox(clear_disk, mailbox.mailbox_id)

mesh_sandbox/handlers/tracking.py

@@ -28,6 +28,10 @@ class TrackingHandler:
             # intentionally not a 403 (matching spine)
             raise HTTPException(status_code=http_status.HTTP_404_NOT_FOUND)
 
+        sender_outbox = await self.store.get_outbox(sender_mailbox.mailbox_id)
+        if message.message_id not in [message.message_id for message in sender_outbox]:
+            raise HTTPException(status_code=http_status.HTTP_404_NOT_FOUND)
+
         model = create_tracking_response(message, accepts_api_version)
         return JSONResponse(content=exclude_none_json_encoder(model), media_type=MESH_MEDIA_TYPES[accepts_api_version])
 
@@ -42,5 +46,10 @@ class TrackingHandler:
             raise HTTPException(status_code=http_status.HTTP_300_MULTIPLE_CHOICES)
 
         message = messages[0]
+
+        sender_outbox = await self.store.get_outbox(sender_mailbox.mailbox_id)
+        if message.message_id not in [message.message_id for message in sender_outbox]:
+            raise HTTPException(status_code=http_status.HTTP_404_NOT_FOUND)
+
         model = create_tracking_response(message, 1)
         return JSONResponse(content=exclude_none_json_encoder(model))

mesh_sandbox/routers/{simple.py → admin.py}

@@ -1,6 +1,6 @@
 from fastapi import APIRouter, Depends, Query, status
 
-from ..dependencies import EnvConfig, get_env_config
+from ..dependencies import EnvConfig, get_env_config, normalise_mailbox_id_path
 from ..handlers.reset import ResetHandler
 from .request_logging import RequestLoggingRoute
 
@@ -40,4 +40,24 @@ async def reset(
     handler: ResetHandler = Depends(ResetHandler),
 ):
     await handler.reset(clear_disk.lower() == "true")
-    return {"message": "reset ok"}
+    return {"message": "all mailboxes reset"}
+
+
+@router.get(
+    "/messageexchange/reset/{mailbox_id}",
+    status_code=status.HTTP_200_OK,
+    include_in_schema=False,
+    response_model_exclude_none=True,
+)
+async def reset_mailbox(
+    clear_disk: str = Query(
+        default="true",
+        title="Clear disk",
+        description="whether to clear the filesystem store if STORE_MODE=file, otherwise ignored",
+        example="true",
+    ),
+    mailbox_id: str = Depends(normalise_mailbox_id_path),
+    handler: ResetHandler = Depends(ResetHandler),
+):
+    await handler.reset(clear_disk.lower() == "true", mailbox_id)
+    return {"message": "mailbox {mailbox_id} reset"}

mesh_sandbox/store/base.py

@@ -72,7 +72,13 @@ class Store(ABC):
     def __init__(self, config: EnvConfig):
         self.config = config
 
-    async def reinitialise(self, clear_disk: bool):
+    async def reset(self, clear_disk: bool):
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=f"reset not supported for {self.config.store_mode} store mode",
+        )
+
+    async def reset_mailbox(self, clear_disk: bool, mailbox_id: str):
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
             detail=f"reset not supported for {self.config.store_mode} store mode",
@@ -156,7 +162,7 @@ class Store(ABC):
         pass
 
     @abstractmethod
-    async def get_inbox(self, mailbox_id: str) -> list[Message]:
+    async def get_inbox(self, mailbox_id: str, rich: bool) -> list[Message]:
         pass
 
     @abstractmethod

mesh_sandbox/store/canned_store.py

@@ -167,7 +167,10 @@ class CannedStore(Store):
     async def get_message(self, message_id: str) -> Optional[Message]:
         return self.messages.get(message_id)
 
-    async def get_inbox(self, mailbox_id: str) -> list[Message]:
+    async def get_inbox(self, mailbox_id: str, rich: bool) -> list[Message]:
+        if rich:  # note: rich inbox is deprecated
+            return [m for m in self.messages.values() if m.recipient.mailbox_id == mailbox_id]
+
         return self.inboxes[mailbox_id]
 
     async def get_outbox(self, mailbox_id: str) -> list[Message]:

mesh_sandbox/store/file_store.py

@@ -15,8 +15,8 @@ class FileStore(MemoryStore):
         super().__init__(config)
         self._base_dir = config.file_store_dir
 
-    async def reinitialise(self, clear_disk: bool):
-        await super().reinitialise(clear_disk)
+    async def reset(self, clear_disk: bool):
+        await super().reset(clear_disk)
         # recursive delete, but preserve top-level folder
         if clear_disk:
             for file in os.listdir(self._base_dir):
@@ -26,6 +26,13 @@ class FileStore(MemoryStore):
                 else:
                     shutil.rmtree(path)
 
+    async def reset_mailbox(self, clear_disk: bool, mailbox_id):
+        await super().reset_mailbox(clear_disk, mailbox_id)
+        if clear_disk:
+            path = os.path.join(self._base_dir, mailbox_id)
+            if os.path.exists(path):
+                shutil.rmtree(path)
+
     async def _get_file_size(self, message: Message) -> int:
         size = 0
         message_dir = os.path.join(self._base_dir, f"{message.recipient.mailbox_id}/in/{message.message_id}")

mesh_sandbox/store/memory_store.py

@@ -1,3 +1,4 @@
+from collections import defaultdict
 from typing import cast
 
 from ..common import EnvConfig
@@ -13,9 +14,15 @@ class MemoryStore(CannedStore):
     def __init__(self, config: EnvConfig):
         super().__init__(config, load_messages=False)
 
-    async def reinitialise(self, clear_disk: bool):
+    async def reset(self, clear_disk: bool):
         super().initialise()
 
+    async def reset_mailbox(self, clear_disk: bool, mailbox_id: str):
+
+        self.inboxes[mailbox_id] = []
+        self.outboxes[mailbox_id] = []
+        self.local_ids[mailbox_id] = defaultdict(list)
+
     async def send_message(self, message: Message, body: bytes):
 
         async with self.lock:

mesh_sandbox/tests/admin.py

@@ -0,0 +1,201 @@
+import os
+from uuid import uuid4
+
+import pytest
+from fastapi import status
+from fastapi.testclient import TestClient
+
+from mesh_sandbox.tests import _CANNED_MAILBOX1, _CANNED_MAILBOX2
+from mesh_sandbox.tests.mesh_api_helpers import (
+    mesh_api_get_inbox_size,
+    mesh_api_send_message_and_return_message_id,
+    mesh_api_track_message_by_message_id,
+    mesh_api_track_message_by_message_id_status,
+)
+
+from .helpers import temp_env_vars
+
+
+def test_reset_canned_store_should_return_bad_request(app: TestClient):
+
+    with temp_env_vars(STORE_MODE="canned"):
+
+        res = app.get("/messageexchange/reset")
+        assert res.status_code == status.HTTP_400_BAD_REQUEST
+
+
+def test_reset_canned_store_with_valid_mailbox_id_should_return_bad_request(app: TestClient):
+
+    with temp_env_vars(STORE_MODE="canned"):
+
+        res = app.get(f"/messageexchange/reset/{_CANNED_MAILBOX1}")
+        assert res.status_code == status.HTTP_400_BAD_REQUEST
+
+
+def test_reset_memory_store_with_invalid_mailbox_id_should_return_bad_request(app: TestClient):
+
+    with temp_env_vars(STORE_MODE="memory"):
+
+        res = app.get(f"/messageexchange/reset/{uuid4().hex}")
+        assert res.status_code == status.HTTP_400_BAD_REQUEST
+
+
+def test_reset_file_store_with_invalid_mailbox_id_should_return_bad_request(app: TestClient):
+
+    with temp_env_vars(STORE_MODE="file"):
+
+        res = app.get(f"/messageexchange/reset/{uuid4().hex}")
+        assert res.status_code == status.HTTP_400_BAD_REQUEST
+
+
+def test_reset_memory_store_should_clear_all_mailboxes(app: TestClient):
+
+    with temp_env_vars(STORE_MODE="memory"):
+
+        msg_1to2_id = mesh_api_send_message_and_return_message_id(app, _CANNED_MAILBOX1, _CANNED_MAILBOX2)
+        assert mesh_api_get_inbox_size(app, _CANNED_MAILBOX2) == 1
+
+        msg_2to1_id = mesh_api_send_message_and_return_message_id(app, _CANNED_MAILBOX2, _CANNED_MAILBOX1)
+        assert mesh_api_get_inbox_size(app, _CANNED_MAILBOX1) == 1
+
+        res = app.get("/messageexchange/reset")
+        assert res.status_code == status.HTTP_200_OK
+
+        assert mesh_api_get_inbox_size(app, _CANNED_MAILBOX1) == 0
+        assert (
+            mesh_api_track_message_by_message_id_status(app, _CANNED_MAILBOX1, msg_2to1_id) == status.HTTP_404_NOT_FOUND
+        )
+
+        assert mesh_api_get_inbox_size(app, _CANNED_MAILBOX2) == 0
+        assert (
+            mesh_api_track_message_by_message_id_status(app, _CANNED_MAILBOX2, msg_1to2_id) == status.HTTP_404_NOT_FOUND
+        )
+
+
+def test_reset_memory_store_should_clear_specified_mailbox_only(app: TestClient):
+
+    with temp_env_vars(STORE_MODE="memory"):
+
+        msg_1to2_id = mesh_api_send_message_and_return_message_id(app, _CANNED_MAILBOX1, _CANNED_MAILBOX2)
+        assert mesh_api_get_inbox_size(app, _CANNED_MAILBOX2) == 1
+
+        res = mesh_api_track_message_by_message_id(app, _CANNED_MAILBOX1, msg_1to2_id)
+        assert res.json()["messageId"] == msg_1to2_id
+
+        msg_2to1_id = mesh_api_send_message_and_return_message_id(app, _CANNED_MAILBOX2, _CANNED_MAILBOX1)
+        assert mesh_api_get_inbox_size(app, _CANNED_MAILBOX1) == 1
+
+        res = mesh_api_track_message_by_message_id(app, _CANNED_MAILBOX2, msg_2to1_id)
+        assert res.json()["messageId"] == msg_2to1_id
+
+        res = app.get(f"/messageexchange/reset/{_CANNED_MAILBOX2}")
+        assert res.status_code == status.HTTP_200_OK
+
+        assert mesh_api_get_inbox_size(app, _CANNED_MAILBOX2) == 0
+        assert (
+            mesh_api_track_message_by_message_id_status(app, _CANNED_MAILBOX2, msg_2to1_id) == status.HTTP_404_NOT_FOUND
+        )
+
+        assert mesh_api_get_inbox_size(app, _CANNED_MAILBOX1) == 1
+        assert mesh_api_track_message_by_message_id_status(app, _CANNED_MAILBOX1, msg_1to2_id) == status.HTTP_200_OK
+
+
+@pytest.mark.parametrize("clear_disk", ["tRue", "faLse", None])
+def test_reset_file_store_should_clear_all_mailboxes_and_maybe_files(app: TestClient, clear_disk: str, tmp_path: str):
+
+    with temp_env_vars(STORE_MODE="file", FILE_STORE_DIR=tmp_path):
+
+        msg_1to2_id = mesh_api_send_message_and_return_message_id(app, _CANNED_MAILBOX1, _CANNED_MAILBOX2)
+        assert mesh_api_get_inbox_size(app, _CANNED_MAILBOX2) == 1
+
+        msg_2to1_id = mesh_api_send_message_and_return_message_id(app, _CANNED_MAILBOX2, _CANNED_MAILBOX1)
+        assert mesh_api_get_inbox_size(app, _CANNED_MAILBOX1) == 1
+
+        inbox_folder1 = os.path.join(tmp_path, _CANNED_MAILBOX1, "in")
+        assert os.path.exists(inbox_folder1)
+        messages = os.listdir(inbox_folder1)
+        assert len(messages) == 1
+        assert messages[0] == msg_2to1_id
+
+        inbox_folder2 = os.path.join(tmp_path, _CANNED_MAILBOX2, "in")
+        assert os.path.exists(inbox_folder2)
+        messages = os.listdir(inbox_folder2)
+        assert len(messages) == 1
+        assert messages[0] == msg_1to2_id
+
+        clear_disk_param = "" if clear_disk is None else f"?clear_disk={clear_disk}"
+        res = app.get(f"/messageexchange/reset{clear_disk_param}")
+        assert res.status_code == status.HTTP_200_OK
+
+        assert mesh_api_get_inbox_size(app, _CANNED_MAILBOX1) == 0
+        assert (
+            mesh_api_track_message_by_message_id_status(app, _CANNED_MAILBOX1, msg_1to2_id) == status.HTTP_404_NOT_FOUND
+        )
+
+        assert mesh_api_get_inbox_size(app, _CANNED_MAILBOX2) == 0
+        assert (
+            mesh_api_track_message_by_message_id_status(app, _CANNED_MAILBOX2, msg_2to1_id) == status.HTTP_404_NOT_FOUND
+        )
+
+        # clear_disk should default to true if file mode is used
+        if not clear_disk or clear_disk == "tRue":
+            assert not os.path.exists(inbox_folder1)
+            assert not os.path.exists(inbox_folder2)
+
+
+@pytest.mark.parametrize("clear_disk", ["tRue", "faLse", None])
+def test_reset_file_store_should_clear_specified_mailbox_only_and_maybe_files(
+    app: TestClient, clear_disk: str, tmp_path: str
+):
+
+    with temp_env_vars(STORE_MODE="file", FILE_STORE_DIR=tmp_path):
+
+        msg_1to2_id = mesh_api_send_message_and_return_message_id(app, _CANNED_MAILBOX1, _CANNED_MAILBOX2)
+        assert mesh_api_get_inbox_size(app, _CANNED_MAILBOX2) == 1
+
+        msg_2to1_id = mesh_api_send_message_and_return_message_id(app, _CANNED_MAILBOX2, _CANNED_MAILBOX1)
+        assert mesh_api_get_inbox_size(app, _CANNED_MAILBOX1) == 1
+
+        inbox_folder1 = os.path.join(tmp_path, _CANNED_MAILBOX1, "in")
+        assert os.path.exists(inbox_folder1)
+        messages = os.listdir(inbox_folder1)
+        assert len(messages) == 1
+        assert messages[0] == msg_2to1_id
+
+        inbox_folder2 = os.path.join(tmp_path, _CANNED_MAILBOX2, "in")
+        assert os.path.exists(inbox_folder2)
+        messages = os.listdir(inbox_folder2)
+        assert len(messages) == 1
+        assert messages[0] == msg_1to2_id
+
+        clear_disk_param = "" if clear_disk is None else f"?clear_disk={clear_disk}"
+        res = app.get(f"/messageexchange/reset/{_CANNED_MAILBOX2}{clear_disk_param}")
+        assert res.status_code == status.HTTP_200_OK
+
+        assert mesh_api_get_inbox_size(app, _CANNED_MAILBOX1) == 1
+        assert mesh_api_track_message_by_message_id_status(app, _CANNED_MAILBOX1, msg_1to2_id) == status.HTTP_200_OK
+
+        assert mesh_api_get_inbox_size(app, _CANNED_MAILBOX2) == 0
+        assert (
+            mesh_api_track_message_by_message_id_status(app, _CANNED_MAILBOX2, msg_2to1_id) == status.HTTP_404_NOT_FOUND
+        )
+
+        # clear_disk should default to true if file mode is used
+        if not clear_disk or clear_disk == "tRue":
+            assert os.path.exists(inbox_folder1)
+            assert not os.path.exists(inbox_folder2)
+
+
+@pytest.mark.parametrize("clear_disk", ["tRue", "faLse", None])
+def test_reset_file_store_should_not_error_if_folder_does_not_exist_yet(
+    app: TestClient, clear_disk: str, tmp_path: str
+):
+
+    with temp_env_vars(STORE_MODE="file", FILE_STORE_DIR=tmp_path):
+
+        inbox_folder = os.path.join(tmp_path, _CANNED_MAILBOX1, "in")
+        assert not os.path.exists(inbox_folder)
+
+        clear_disk_param = "" if clear_disk is None else f"?clear_disk={clear_disk}"
+        res = app.get(f"/messageexchange/reset/{_CANNED_MAILBOX2}{clear_disk_param}")
+        assert res.status_code == status.HTTP_200_OK

mesh_sandbox/tests/helpers.py

@@ -8,11 +8,9 @@ from typing import Optional
 from uuid import uuid4
 
 import httpx
-from fastapi.testclient import TestClient
 from OpenSSL import crypto
 
 from ..common import MESH_AUTH_SCHEME, generate_cipher_text
-from ..common.constants import Headers
 
 
 def generate_auth_token(
@@ -49,37 +47,6 @@ def temp_env_vars(**kwargs):
         os.environ.update(old_environ)
 
 
-def send_message(
-    app: TestClient,
-    sender_mailbox_id: str,
-    recipient_mailbox_id: str,
-    workflow_id: Optional[str] = None,
-    message_data: Optional[bytes] = None,
-    extra_headers: Optional[dict] = None,
-    test_empty_payload: bool = False,
-    file_name: Optional[str] = None,
-):
-
-    if not test_empty_payload:
-        message_data = message_data or f"Hello World!\n{uuid4().hex}".encode("utf-8")
-
-    headers = {
-        Headers.Mex_From: sender_mailbox_id,
-        Headers.Mex_To: recipient_mailbox_id,
-        Headers.Mex_WorkflowID: workflow_id or "TEST_WORKFLOW",
-        Headers.Authorization: generate_auth_token(sender_mailbox_id),
-    }
-    if file_name:
-        headers[Headers.Mex_FileName] = file_name
-
-    if extra_headers:
-        headers.update(extra_headers)
-
-    response = app.post(f"/messageexchange/{sender_mailbox_id}/outbox", headers=headers, data=message_data)
-
-    return response
-
-
 def ensure_client_installed(java_path: str, base_dir: str, version: str):  # pylint: disable=too-many-locals
 
     install_dir = os.path.join(base_dir, version)

mesh_sandbox/tests/inbox.py

@@ -4,10 +4,12 @@ import pytest
 from fastapi import status
 from fastapi.testclient import TestClient
 
+from mesh_sandbox.tests.mesh_api_helpers import mesh_api_send_message
+
 from ..common import APP_V1_JSON, APP_V2_JSON
 from ..common.constants import Headers
 from ..models.message import MessageStatus
-from .helpers import generate_auth_token, send_message, temp_env_vars
+from .helpers import generate_auth_token, temp_env_vars
 
 _CANNED_MAILBOX1 = "X26ABC1"
 _CANNED_MAILBOX2 = "X26ABC2"
@@ -39,12 +41,12 @@ def test_inbox_count(app: TestClient, accept: str):
 
     message_body = f"test{uuid4().hex}".encode()
 
-    resp = send_message(
+    resp = mesh_api_send_message(
         app,
         sender_mailbox_id=sender,
         recipient_mailbox_id=recipient,
-        workflow_id=workflow_id,
         message_data=message_body,
+        workflow_id=workflow_id,
         extra_headers={Headers.Accept: accept, Headers.Mex_LocalID: local_id},
     )
 
@@ -78,7 +80,7 @@ def test_paginated_inbox_outbox(app: TestClient, accept: str):
     message_ids = []
     for _ in range(page_size * 3):
 
-        resp = send_message(
+        resp = mesh_api_send_message(
             app,
             sender_mailbox_id=sender,
             recipient_mailbox_id=recipient,
@@ -259,3 +261,60 @@ def test_receive_canned_undelivered_message(app: TestClient, accept: str):
         result = res.json()
         expected = MessageStatus.UNDELIVERABLE.title() if accept == APP_V1_JSON else MessageStatus.UNDELIVERABLE
         assert result["status"] == expected
+
+
+def test_rich_inbox_includes_acknowledged_messages(app: TestClient):
+
+    sender = _CANNED_MAILBOX1
+    recipient = _CANNED_MAILBOX2
+
+    res = app.get(
+        f"/messageexchange/{recipient}/inbox",
+        headers={Headers.Authorization: generate_auth_token(recipient)},
+    )
+    assert res.json()["messages"] == []
+
+    acknowledged_message_id = ""
+    message_ids = []
+    for index in range(5):
+
+        resp = mesh_api_send_message(
+            app,
+            sender_mailbox_id=sender,
+            recipient_mailbox_id=recipient,
+        )
+
+        assert resp.status_code == status.HTTP_202_ACCEPTED
+        result = resp.json()
+        message_id = result["messageID"]
+        assert message_id
+        message_ids.append(message_id)
+
+        if index == 2:
+            ack_response = app.put(
+                f"/messageexchange/{recipient}/inbox/{message_id}/status/acknowledged",
+                headers={Headers.Authorization: generate_auth_token(recipient)},
+            )
+            assert ack_response.status_code == status.HTTP_200_OK
+            assert message_id in ack_response.text
+            acknowledged_message_id = message_id
+
+    # inbox
+    res = app.get(
+        f"/messageexchange/{recipient}/inbox",
+        headers={Headers.Authorization: generate_auth_token(recipient)},
+    )
+    assert res.status_code == status.HTTP_200_OK
+    messages = res.json().get("messages", [])
+    assert len(messages) == 4
+    assert acknowledged_message_id not in messages
+
+    # rich inbox
+    res = app.get(
+        f"/messageexchange/{recipient}/inbox/rich",
+        headers={Headers.Authorization: generate_auth_token(recipient)},
+    )
+    assert res.status_code == status.HTTP_200_OK
+    messages = res.json().get("messages", [])
+    assert len(messages) == 5
+    assert acknowledged_message_id in [m["message_id"] for m in messages]

mesh_sandbox/tests/mesh_api_helpers.py

@@ -0,0 +1,132 @@
+from typing import Optional
+from uuid import uuid4
+
+from fastapi.testclient import TestClient
+
+from mesh_sandbox.tests.helpers import generate_auth_token
+
+from ..common.constants import Headers
+
+
+def mesh_api_send_message(
+    app: TestClient,
+    sender_mailbox_id: str,
+    recipient_mailbox_id: str,
+    message_data: Optional[bytes] = None,
+    workflow_id: Optional[str] = None,
+    extra_headers: Optional[dict] = None,
+    test_empty_message_data: bool = False,
+    file_name: Optional[str] = None,
+):
+
+    if not test_empty_message_data:
+        message_data = message_data or f"Hello World!\n{uuid4().hex}".encode("utf-8")
+
+    headers = {
+        Headers.Mex_From: sender_mailbox_id,
+        Headers.Mex_To: recipient_mailbox_id,
+        Headers.Mex_WorkflowID: workflow_id or "TEST_WORKFLOW",
+        Headers.Authorization: generate_auth_token(sender_mailbox_id),
+    }
+
+    if file_name:
+        headers[Headers.Mex_FileName] = file_name
+
+    if extra_headers:
+        headers.update(extra_headers)
+
+    return app.post(f"/messageexchange/{sender_mailbox_id}/outbox", headers=headers, data=message_data)
+
+
+def mesh_api_send_message_and_return_message_id(
+    app: TestClient,
+    sender_mailbox_id: str,
+    recipient_mailbox_id: str,
+    message_data: Optional[bytes] = None,
+    workflow_id: Optional[str] = None,
+    extra_headers: Optional[dict] = None,
+    test_empty_message_data: bool = False,
+    file_name: Optional[str] = None,
+):
+
+    res = mesh_api_send_message(
+        app,
+        sender_mailbox_id,
+        recipient_mailbox_id,
+        message_data,
+        workflow_id,
+        extra_headers,
+        test_empty_message_data,
+        file_name,
+    )
+
+    assert res.status_code == 202, res.text
+    return res.json()["messageID"]
+
+
+def mesh_api_get_message(
+    app: TestClient,
+    recipient_mailbox_id: str,
+    message_id: str,
+    extra_headers: Optional[dict] = None,
+):
+
+    headers = {Headers.Authorization: generate_auth_token(recipient_mailbox_id)}
+    if extra_headers:
+        headers.update(extra_headers)
+
+    return app.get(url=f"/messageexchange/{recipient_mailbox_id}/inbox/{message_id}", headers=headers)
+
+
+def mesh_api_get_inbox(
+    app: TestClient,
+    recipient_mailbox_id: str,
+    extra_headers: Optional[dict] = None,
+):
+
+    headers = {Headers.Authorization: generate_auth_token(recipient_mailbox_id)}
+    if extra_headers:
+        headers.update(extra_headers)
+
+    return app.get(url=f"/messageexchange/{recipient_mailbox_id}/inbox", headers=headers)
+
+
+def mesh_api_get_inbox_size(
+    app: TestClient,
+    recipient_mailbox_id: str,
+    extra_headers: Optional[dict] = None,
+):
+    res = mesh_api_get_inbox(app, recipient_mailbox_id, extra_headers=extra_headers)
+    assert res.status_code == 200
+    return len(res.json()["messages"])
+
+
+def mesh_api_track_message_by_local_id(
+    app: TestClient, sender_mailbox_id: str, local_id: str, extra_headers: Optional[dict] = None
+):
+
+    headers = {Headers.Authorization: generate_auth_token(sender_mailbox_id)}
+    if extra_headers:
+        headers.update(extra_headers)
+
+    return app.get(f"/messageexchange/{sender_mailbox_id}/outbox/tracking?localID={local_id}", headers=headers)
+
+
+def mesh_api_track_message_by_message_id(
+    app: TestClient, sender_mailbox_id: str, message_id: str, extra_headers: Optional[dict] = None
+):
+
+    headers = {Headers.Authorization: generate_auth_token(sender_mailbox_id)}
+    if extra_headers:
+        headers.update(extra_headers)
+
+    res = app.get(f"/messageexchange/{sender_mailbox_id}/outbox/tracking?messageID={message_id}", headers=headers)
+    return res
+
+
+def mesh_api_track_message_by_message_id_status(
+    app: TestClient, sender_mailbox_id: str, message_id: str, extra_headers: Optional[dict] = None
+):
+
+    res = mesh_api_track_message_by_message_id(app, sender_mailbox_id, message_id, extra_headers=extra_headers)
+    return res.status_code

mesh_sandbox/tests/mesh_client_tests.py

@@ -14,7 +14,22 @@ from mesh_sandbox.tests.docker_tests import (
 )
 
 
-def _get_inbox_count(base_uri: str, recipient_mailbox_id: str):
+def _mesh_client_send_message(
+    base_uri: str,
+    sender_mailbox_id: str,
+    recipient_mailbox_id: str,
+    workflow_id: str,
+    payload: bytes,
+):
+    with MeshClient(
+        url=base_uri, mailbox=sender_mailbox_id, password=_PASSWORD, shared_key=_SHARED_KEY, max_chunk_size=100
+    ) as sender:
+        message_id = sender.send_message(recipient_mailbox_id, payload, workflow_id=workflow_id)
+        assert message_id
+        return message_id
+
+
+def _mesh_client_get_inbox_count(base_uri: str, recipient_mailbox_id: str):
     with MeshClient(
         url=base_uri, mailbox=recipient_mailbox_id, password=_PASSWORD, shared_key=_SHARED_KEY
     ) as recipient:
@@ -22,19 +37,13 @@ def _get_inbox_count(base_uri: str, recipient_mailbox_id: str):
         return len(message_ids)
 
 
-def _send_message_and_assert_inbox_count_is_one(
-    base_uri: str, recipient_mailbox_id: str, workflow_id: str, payload: bytes
-):
-    sender_mailbox_id = _CANNED_MAILBOX1
-
+def _mesh_client_track_message_by_message_id(base_uri: str, sender_mailbox_id: str, message_id: str):
     with MeshClient(
         url=base_uri, mailbox=sender_mailbox_id, password=_PASSWORD, shared_key=_SHARED_KEY, max_chunk_size=100
     ) as sender:
-
-        message_id = sender.send_message(recipient_mailbox_id, payload, workflow_id=workflow_id)
-        assert message_id
-        assert _get_inbox_count(base_uri, _CANNED_MAILBOX2) == 1
-        return message_id
+        tracking = sender.track_by_message_id(message_id)
+        assert tracking
+        return tracking
 
 
 def test_app_health(base_uri: str):
@@ -62,14 +71,12 @@ def test_handshake_bad_password(base_uri: str):
 
 def test_send_receive_chunked_message(base_uri: str):
 
-    recipient_mailbox_id = _CANNED_MAILBOX2
     workflow_id = uuid4().hex
     sent_payload = b"a" * 1000
-    message_id = _send_message_and_assert_inbox_count_is_one(base_uri, recipient_mailbox_id, workflow_id, sent_payload)
+    message_id = _mesh_client_send_message(base_uri, _CANNED_MAILBOX1, _CANNED_MAILBOX2, workflow_id, sent_payload)
+    assert _mesh_client_get_inbox_count(base_uri, _CANNED_MAILBOX2) == 1
 
-    with MeshClient(
-        url=base_uri, mailbox=recipient_mailbox_id, password=_PASSWORD, shared_key=_SHARED_KEY
-    ) as recipient:
+    with MeshClient(url=base_uri, mailbox=_CANNED_MAILBOX2, password=_PASSWORD, shared_key=_SHARED_KEY) as recipient:
         message_ids = recipient.list_messages()
         assert message_ids == [message_id]
         message = recipient.retrieve_message(message_id)
@@ -80,3 +87,25 @@ def test_send_receive_chunked_message(base_uri: str):
         message.acknowledge()
         message_ids = recipient.list_messages()
         assert message_ids == []
+
+
+def test_track_message_by_message_id(base_uri: str):
+
+    workflow_id = uuid4().hex
+    sent_payload = b"a" * 1000
+    message_id = _mesh_client_send_message(base_uri, _CANNED_MAILBOX1, _CANNED_MAILBOX2, workflow_id, sent_payload)
+    assert _mesh_client_get_inbox_count(base_uri, _CANNED_MAILBOX2) == 1
+
+    tracking = _mesh_client_track_message_by_message_id(base_uri, _CANNED_MAILBOX1, message_id)
+    assert tracking["messageId"] == message_id
+    assert tracking["status"] == "Accepted"
+    assert tracking["sender"] == _CANNED_MAILBOX1
+    assert tracking["recipient"] == _CANNED_MAILBOX2
+
+    with MeshClient(url=base_uri, mailbox=_CANNED_MAILBOX2, password=_PASSWORD, shared_key=_SHARED_KEY) as recipient:
+        message = recipient.retrieve_message(message_id)
+        message.acknowledge()
+
+    tracking = _mesh_client_track_message_by_message_id(base_uri, _CANNED_MAILBOX1, message_id)
+    assert tracking["messageId"] == message_id
+    assert tracking["status"] == "Acknowledged"

mesh_sandbox/tests/outbox.py

@@ -5,10 +5,12 @@ import pytest
 from fastapi import status
 from fastapi.testclient import TestClient
 
+from mesh_sandbox.tests.mesh_api_helpers import mesh_api_send_message
+
 from ..common import APP_V1_JSON, APP_V2_JSON
 from ..common.constants import Headers
 from ..models.message import MessageStatus
-from .helpers import generate_auth_token, send_message, temp_env_vars
+from .helpers import generate_auth_token, temp_env_vars
 
 _CANNED_MAILBOX1 = "X26ABC1"
 _CANNED_MAILBOX2 = "X26ABC2"
@@ -33,12 +35,12 @@ def test_memory_send_message_with_local_id(app: TestClient, accept: str):
 
     message_body = f"test{uuid4().hex}".encode()
 
-    resp = send_message(
+    resp = mesh_api_send_message(
         app,
         sender_mailbox_id=sender,
         recipient_mailbox_id=recipient,
-        workflow_id=workflow_id,
         message_data=message_body,
+        workflow_id=workflow_id,
         extra_headers={Headers.Accept: accept, Headers.Mex_LocalID: local_id},
     )
 
@@ -146,12 +148,12 @@ def test_file_send_message_with_local_id(app: TestClient, accept: str, tmp_path:
 
         message_body = f"test{uuid4().hex}".encode()
 
-        resp = send_message(
+        resp = mesh_api_send_message(
             app,
             sender_mailbox_id=sender,
             recipient_mailbox_id=recipient,
-            workflow_id=workflow_id,
             message_data=message_body,
+            workflow_id=workflow_id,
             extra_headers={Headers.Accept: accept},
         )
 
@@ -208,12 +210,12 @@ def test_memory_send_chunked_message(app: TestClient, accept: str):
 
     workflow_id = "TEST_WORKFLOW"
 
-    resp = send_message(
+    resp = mesh_api_send_message(
         app,
         sender_mailbox_id=sender,
         recipient_mailbox_id=recipient,
-        workflow_id=workflow_id,
         message_data=chunk_1,
+        workflow_id=workflow_id,
         extra_headers={Headers.Accept: accept, Headers.Mex_Chunk_Range: "1:2"},
     )
 
@@ -330,12 +332,12 @@ def test_file_send_chunked_message(app: TestClient, accept: str, tmp_path: str):
 
         workflow_id = "TEST_WORKFLOW"
 
-        resp = send_message(
+        resp = mesh_api_send_message(
             app,
             sender_mailbox_id=sender,
             recipient_mailbox_id=recipient,
-            workflow_id=workflow_id,
             message_data=chunk_1,
+            workflow_id=workflow_id,
             extra_headers={Headers.Accept: accept, Headers.Mex_Chunk_Range: "1:2"},
         )
 
@@ -464,7 +466,7 @@ def test_mex_content_compress_validation(app: TestClient, value: str):
     sender = _CANNED_MAILBOX1
     recipient = _CANNED_MAILBOX2
 
-    response = send_message(app, sender, recipient, extra_headers={Headers.Mex_Content_Compress: value})
+    response = mesh_api_send_message(app, sender, recipient, extra_headers={Headers.Mex_Content_Compress: value})
 
     assert response.status_code == status.HTTP_202_ACCEPTED
 
@@ -502,7 +504,7 @@ def test_mex_content_encrypted_validation(app: TestClient, value: str):
     sender = _CANNED_MAILBOX1
     recipient = _CANNED_MAILBOX2
 
-    response = send_message(app, sender, recipient, extra_headers={Headers.Mex_Content_Encrypted: value})
+    response = mesh_api_send_message(app, sender, recipient, extra_headers={Headers.Mex_Content_Encrypted: value})
 
     assert response.status_code == status.HTTP_202_ACCEPTED
 
@@ -540,7 +542,7 @@ def test_mex_content_compressed_validation(app: TestClient, value: str):
     sender = _CANNED_MAILBOX1
     recipient = _CANNED_MAILBOX2
 
-    response = send_message(app, sender, recipient, extra_headers={Headers.Mex_Content_Compressed: value})
+    response = mesh_api_send_message(app, sender, recipient, extra_headers={Headers.Mex_Content_Compressed: value})
     assert response.status_code == status.HTTP_202_ACCEPTED
 
 
@@ -561,7 +563,9 @@ def test_mex_content_checksum_validation(app: TestClient, mex_content_checksum:
     sender = _CANNED_MAILBOX1
     recipient = _CANNED_MAILBOX2
 
-    response = send_message(app, sender, recipient, extra_headers={Headers.Mex_Content_Checksum: mex_content_checksum})
+    response = mesh_api_send_message(
+        app, sender, recipient, extra_headers={Headers.Mex_Content_Checksum: mex_content_checksum}
+    )
 
     assert response.status_code == expected_response_status
 
@@ -571,7 +575,7 @@ def test_mex_local_id_validation(app: TestClient):
     sender = _CANNED_MAILBOX1
     recipient = _CANNED_MAILBOX2
 
-    response = send_message(
+    response = mesh_api_send_message(
         app, sender, recipient, extra_headers={Headers.Mex_LocalID: "test#TEST", Headers.Mex_WorkflowID: "test TEST"}
     )
 

{mesh_sandbox-0.1.14.dist-info → mesh_sandbox-0.1.16.dist-info}/METADATA

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

{mesh_sandbox-0.1.14.dist-info → mesh_sandbox-0.1.16.dist-info}/RECORD

@@ -1,5 +1,5 @@
-mesh_sandbox/__init__.py,sha256=PIBqEOI-nqKFL9oJAWQQwlHuujG9Cd7EmdxDrThNQto,23
-mesh_sandbox/api.py,sha256=Aj_qE5eIXEmLCqvUJdAiuhONgGH_khnooH3JbAhNJoI,3927
+mesh_sandbox/__init__.py,sha256=yF88-8vL8keLe6gCTumymw0UoMkWkSrJnzLru4zBCLQ,23
+mesh_sandbox/api.py,sha256=F2KUKENAsSe6NAGG0wzHA2jebGF6mWFgta1q55oqacU,3925
 mesh_sandbox/common/__init__.py,sha256=B0eGgN6SGCvNIsalhQOXhFJvxZaE4wJS_ratFOMMwvI,3071
 mesh_sandbox/common/constants.py,sha256=_hnaHDkAQGHWLF7n_WfC5ZHIY5D-fUbOdpSqLusUMNY,6504
 mesh_sandbox/common/exceptions.py,sha256=YQII8w6DQQoKuW0cukEr6PIE9j0rwrqDpCn5lapgmkQ,1481
@@ -10,46 +10,47 @@ mesh_sandbox/conftest.py,sha256=Bd-soyJTgtNAhC_LOH0vFNuE5bK9mPW1uYPglxL2Ox4,2186
 mesh_sandbox/dependencies.py,sha256=f23B71zqz4gAyQHdlw-9bFpWrQk373BG9zZrHY2wnd4,3264
 mesh_sandbox/handlers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mesh_sandbox/handlers/handshake.py,sha256=p3_NveSscNBgCdIIJhBza34b0WreqgBxZwI2sw7ZMTk,605
-mesh_sandbox/handlers/inbox.py,sha256=SwFyMQcrJ29B4nHnF1woPy23egWoffhCPdeajFc55Hs,15177
+mesh_sandbox/handlers/inbox.py,sha256=FH6jEl1vgHD07ttFJqUbarOzumfVJNv-hi0QziIfxl0,15227
 mesh_sandbox/handlers/lookup.py,sha256=hqZBjp-Bwg4Jrx71BfKE3ET2AO6x8XXsbl81tLYoshM,1471
 mesh_sandbox/handlers/outbox.py,sha256=wRBTquvOBLYHhvnvXc07DvSpPEdWy7nCu3zvrXrhjbM,9426
-mesh_sandbox/handlers/reset.py,sha256=-Mk6Xc0etU-XJAjFWRUnSN074_heQaK7vEL2NB4cyWw,422
-mesh_sandbox/handlers/tracking.py,sha256=ZSrFVcs7J-aLz8TLCF7JpVZ6ZBBFjQZOmofg2MUolbQ,1918
+mesh_sandbox/handlers/reset.py,sha256=Mxnsrc273B2B3HvkX3R8Ij7Sl4HW05rj6__XLqG-K48,829
+mesh_sandbox/handlers/tracking.py,sha256=yZdb30g8vHRXv5o6AjgNcX6lY_sxlFxzc0_TxYmP_jU,2407
 mesh_sandbox/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mesh_sandbox/models/mailbox.py,sha256=W1b1R1XjhyiCp30LvTLtQVlxagfxXH8eb0XnNj3D4Dw,993
 mesh_sandbox/models/message.py,sha256=br4U7jxJ8Dxkibal9IA9FAK-Yv1sEtkXVQzPDAFXT08,4875
 mesh_sandbox/models/workflow.py,sha256=T8A1Q729TOUaz1MOa1Ly8oZs_G4769xMZpTYGF0TlO8,518
 mesh_sandbox/routers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mesh_sandbox/routers/admin.py,sha256=mLZ81tBi7tRjGgTDqVzCxyu3QUseoxVY7DJqmzmONEo,2463
 mesh_sandbox/routers/handshake.py,sha256=5TVyQ5OrHIe6W3UVpbap-hc5ia669Of6w6F1vgcYjm4,2693
 mesh_sandbox/routers/inbox.py,sha256=wSgXEziugJM2PLlVbmGRvd3Hw5GK2hecwxhWx2ycal4,8787
 mesh_sandbox/routers/inbox_count.py,sha256=_hnBuJJaO-g9F_ddmA6WLaNcYHEAsvyF9TimRVaRBH0,1490
 mesh_sandbox/routers/lookup.py,sha256=ViYK80gp9m9nkiZuQf-nimuuIo_nmYKdUBHEuNcKCLY,2115
 mesh_sandbox/routers/outbox.py,sha256=kuMrJPW9XiwLisquAs2rNqaUG0c9VauCudWPLu43inc,4736
 mesh_sandbox/routers/request_logging.py,sha256=gZaOJ_Mp3QPsmrpxXQ0pOzVGNPKd_RAEjpT3Iz1ImVM,1439
-mesh_sandbox/routers/simple.py,sha256=r7eWvR-Uv0IhlvhsHxRCug5u_cMpStam3RmpkAmCUlM,1795
 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=yJU3y1oFkM3QnWTDDJiv3atpkIW--Ei5GTBhIv51EWg,5656
-mesh_sandbox/store/canned_store.py,sha256=38Z7TcSj5eKFqBAsiI9XwCcNamHQVUNYkSdqPdVwRMc,7051
+mesh_sandbox/store/base.py,sha256=7oRqluFGBIHQ7liLVj42bYIPtSS3luh8MmHTM5Md5a0,5907
+mesh_sandbox/store/canned_store.py,sha256=Prbo78iKc7XgeCJmxKRFK4ZUSj13Su-3pM5WR8TeU0U,7210
 mesh_sandbox/store/data/chunks.jsonl,sha256=sQ6ZfrCGLMRxeukgbdUYC03ScPg3ofgppG7USNu20ek,2612
 mesh_sandbox/store/data/mailboxes.jsonl,sha256=Gar9pfGb3f3v0Tp8ighV31ZQVy5uKtjofSb8NURgGzs,434
 mesh_sandbox/store/data/messages.jsonl,sha256=MtwyUVows8-nrk4uR88cw7uz_CjjxI7wyD7qc0ppBAg,2333
 mesh_sandbox/store/data/workflows.jsonl,sha256=RFvycuqVmEkImeXlFD2wjuJFjt6dw581D_raPWstxpU,292
-mesh_sandbox/store/file_store.py,sha256=uV6_cCXj1gamBUPrGhMsWPbtXav9TbKJQq3SVsCxXoQ,1955
-mesh_sandbox/store/memory_store.py,sha256=OZdnYXXU2On0oYCuWjaaxGQAhUgzRpiD9hd7vUfBauU,2290
+mesh_sandbox/store/file_store.py,sha256=ljWHpAJ0mab8gNRUXIHto6A5f0wUIaSh1BWk6wPxnJI,2223
+mesh_sandbox/store/memory_store.py,sha256=O0E-szdW7r4XknXOXWPhhqRUS6EYZ8fFObNsb6KKhW4,2523
 mesh_sandbox/store/serialisation.py,sha256=nzBMxGkrHOEQ3Q-zmV0W5bwNhs_Q1JlvLsbqONDAtzo,3585
 mesh_sandbox/tests/__init__.py,sha256=wPjH0Ka1334a0OR9VMUfeYxsr03JqWjHTBnAH_1SB7I,106
+mesh_sandbox/tests/admin.py,sha256=9niKHUrTqRA4XHZ2abXkOx8RvdrPFL8WW7_tH0rND5Q,8261
 mesh_sandbox/tests/docker_tests.py,sha256=nxErB5EDDvewgrgI-YqofsOqo52uYWCPTsk-ggK5axQ,1292
 mesh_sandbox/tests/exceptions.py,sha256=j_jKskVzLAYpyu4qNAEY5ahkbk8Uh2Nc_CGpnpdXjnI,740
 mesh_sandbox/tests/handshake.py,sha256=X-fCbwaEAc8cAvvnniCvt4W4DAV9ItPq7tpIpZkfj6M,6259
-mesh_sandbox/tests/helpers.py,sha256=7wMi4YhStWrJhAlsGUjc5kmOQjMDtOZBhnTNyZIQ-o0,7909
-mesh_sandbox/tests/inbox.py,sha256=UdDlhqpCjRurrgexm5S9dnfyaiKnIFyG27jrXnBeU6M,8480
+mesh_sandbox/tests/helpers.py,sha256=Cr4FtD3jLGf-jsnDBd39YCLW_6__VdWBTZ2gzySaqmc,6901
+mesh_sandbox/tests/inbox.py,sha256=GLqOC6qlivKpp7qEtcGqv_nECkf2MhP4XwRWbIPC_ks,10412
 mesh_sandbox/tests/java_client_tests.py,sha256=oeg1dG83ZBrgy3rb3-lQ26myAxRu-z-u7T-wigIwAhE,6546
 mesh_sandbox/tests/lookup.py,sha256=wY8x0F415y2um48Lw5kyD4ugMo1vBGKB7cqPdHEaVO4,2768
-mesh_sandbox/tests/mesh_client_tests.py,sha256=zYXIxO-BbaVWq4wEQyts_wuOtv1NkzyNo_121KTZ36k,2660
-mesh_sandbox/tests/outbox.py,sha256=aFZLKUHxK1fYlBY65r6k45fItn2uo-izJlC9pqT_X5M,18798
-mesh_sandbox/tests/reset.py,sha256=6BCVKwiY1pjxzDHaxMwOiRdIQPquzMQAecDmtwvTDl4,2154
+mesh_sandbox/tests/mesh_api_helpers.py,sha256=spMQnv0EvOSfBVwnr3yAX2Zq1lOg3cc5X4YkZBKeMpg,3898
+mesh_sandbox/tests/mesh_client_tests.py,sha256=Q_s_U5-NRl4aaX8Tq0diMQdUS-SmPE8nBfc2XjXbV9s,3949
+mesh_sandbox/tests/outbox.py,sha256=x4H7quRre8EZe23_Js4pqF0KCumvtDemS92UuYcan5c,18950
 mesh_sandbox/tests/serialisation.py,sha256=zCoP_fAaTCzZ68HpdKQVZLzUJGpbcHTYjHPM2uTtNWQ,640
 mesh_sandbox/views/__init__.py,sha256=nZkb6_1S8jz8Xl_AayfwjgEZG0JD2dfulfGxjJ5W9Ec,1237
 mesh_sandbox/views/error.py,sha256=9lnUr3P93Vm-nOrBTEuAD6nrSBUvpI6-XqXzILWjgGk,3885
@@ -57,7 +58,7 @@ mesh_sandbox/views/inbox.py,sha256=gnaD9Csx5BqilVRefQQ_tXmeq80lwcLJfepW005GrkU,5
 mesh_sandbox/views/lookup.py,sha256=HHUqZ-Iy22ysC3qaO8Bl5GBQqf_7IiBbe5acyxqS78M,2775
 mesh_sandbox/views/outbox.py,sha256=gd32ClmFn-_sROCBnsPos9SPrkTn9GpY1e4tQ_jWf1g,4883
 mesh_sandbox/views/tracking.py,sha256=UDEHd0DI_iCS5di8r134nh5lY0c9gClb7mdhXA5nMo4,8827
-mesh_sandbox-0.1.14.dist-info/METADATA,sha256=l2_7T_tfz5uMdx-vsC_OAZx3FIRA-qh0-icyWkaDFzM,2232
-mesh_sandbox-0.1.14.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
-mesh_sandbox-0.1.14.dist-info/LICENSE,sha256=usgzIvDUpVX5pYZepJTRXQJqIaz0mdd32GuS5a3PFlY,1051
-mesh_sandbox-0.1.14.dist-info/RECORD,,
+mesh_sandbox-0.1.16.dist-info/LICENSE,sha256=usgzIvDUpVX5pYZepJTRXQJqIaz0mdd32GuS5a3PFlY,1051
+mesh_sandbox-0.1.16.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
+mesh_sandbox-0.1.16.dist-info/METADATA,sha256=XcDTBhb5A4AYg6o4Ikx_M4-_2_BW8uBoZcUVHOjOmOc,2232
+mesh_sandbox-0.1.16.dist-info/RECORD,,

mesh_sandbox/tests/reset.py

@@ -1,59 +0,0 @@
-import os
-from uuid import uuid4
-
-import httpx
-import pytest
-from fastapi import status
-
-from mesh_sandbox.tests import _CANNED_MAILBOX2
-from mesh_sandbox.tests.mesh_client_tests import (
-    _get_inbox_count,
-    _send_message_and_assert_inbox_count_is_one,
-)
-
-from .helpers import temp_env_vars
-
-
-def test_reset_memory_store_should_clear_inbox(base_uri: str):
-
-    _send_message_and_assert_inbox_count_is_one(base_uri, _CANNED_MAILBOX2, uuid4().hex, b"b" * 10)
-
-    with temp_env_vars(STORE_MODE="memory"):
-        with httpx.Client(base_url=base_uri) as client:
-            res = client.get("/messageexchange/reset")
-            assert res.status_code == status.HTTP_200_OK
-
-    assert _get_inbox_count(base_uri, _CANNED_MAILBOX2) == 0
-
-
-@pytest.mark.parametrize("clear_disk", ["tRue", "faLse", None])
-def test_reset_file_store_should_clear_inbox_and_maybe_files(base_uri: str, clear_disk: str, tmp_path: str):
-
-    with temp_env_vars(STORE_MODE="file", FILE_STORE_DIR=tmp_path):
-
-        message_id = _send_message_and_assert_inbox_count_is_one(base_uri, _CANNED_MAILBOX2, uuid4().hex, b"b" * 10)
-
-        inbox_folder = os.path.join(tmp_path, _CANNED_MAILBOX2, "in")
-        assert os.path.exists(inbox_folder)
-        messages = os.listdir(inbox_folder)
-        assert len(messages) == 1
-        assert messages[0] == message_id
-
-        with httpx.Client(base_url=base_uri, timeout=60) as client:
-            clear_disk_param = "" if clear_disk is None else f"?clear_disk={clear_disk}"
-            res = client.get(f"/messageexchange/reset{clear_disk_param}")
-            assert res.status_code == status.HTTP_200_OK
-
-        assert _get_inbox_count(base_uri, _CANNED_MAILBOX2) == 0
-
-        # clear_disk should default to true if file mode is used
-        if not clear_disk or clear_disk == "tRue":
-            assert not os.path.exists(inbox_folder)
-
-
-def test_reset_canned_store_should_return_bad_request(base_uri: str):
-
-    with temp_env_vars(STORE_MODE="canned"):
-        with httpx.Client(base_url=base_uri) as client:
-            res = client.get("/messageexchange/reset")
-            assert res.status_code == status.HTTP_400_BAD_REQUEST