CCM-13278: Implement mesh-acknowledge lambda

Author: gareth-allan

lambdas/mesh-acknowledge/mesh_acknowledge/__tests__/fixtures.py

@@ -0,0 +1,40 @@
+"""Fixtures for tests"""
+from typing import Dict
+
+
+def create_downloaded_event_dict(event_id: str) -> Dict[str, str | int | Dict[str, str]]:
+    """Create a dictionary representing a MESHInboxMessageDownloaded event"""
+    return {
+        "id": event_id,
+        "specversion": "1.0",
+        "source": (
+            "/nhs/england/notify/production/primary/"
+            'data-plane/digitalletters/mesh'
+        ),
+        "subject": (
+            'customer/920fca11-596a-4eca-9c47-99f624614658/'
+            'recipient/769acdd4-6a47-496f-999f-76a6fd2c3959'
+        ),
+        "type": (
+            'uk.nhs.notify.digital.letters.mesh.inbox.message.downloaded.v1'
+        ),
+        "time": '2026-01-08T10:00:00Z',
+        "recordedtime": '2026-01-08T10:00:00Z',
+        "severitynumber": 2,
+        "severitytext": 'INFO',
+        "traceparent": '00-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-01',
+        "datacontenttype": 'application/json',
+        "dataschema": (
+            'https://notify.nhs.uk/cloudevents/schemas/digital-letters/2025-10-draft/data/'
+            'digital-letters-mesh-inbox-message-downloaded-data.schema.json'
+        ),
+        "datacategory": "non-sensitive",
+        "dataclassification": "public",
+        "dataregulation": "GDPR",
+        "data": {
+            "meshMessageId": "MSG123456",
+            "messageUri": f"https://example.com/ttl/resource/{event_id}",
+            "messageReference": "REF123",
+            "senderId": "SENDER001",
+        }
+    }

lambdas/mesh-acknowledge/mesh_acknowledge/__tests__/test_acknowledger.py

@@ -0,0 +1,109 @@
+"""
+Tests for MeshAcknowledger class
+"""
+import json
+from unittest.mock import Mock
+import pytest
+from mesh_acknowledge.acknowledger import (
+    MeshAcknowledger,
+    NOTIFY_ACK_WORKFLOW_ID,
+    ACK_SUBJECT
+)
+
+SENT_MESH_MESSAGE_ID = "MSG123456"
+
+
+@pytest.fixture(name='mock_mesh_client')
+def create_mock_mesh_client():
+    """Create a mock MeshClient for testing"""
+    client = Mock()
+    client.handshake = Mock()
+    client.send_message = Mock(return_value=SENT_MESH_MESSAGE_ID)
+    return client
+
+
+@pytest.fixture(name='mock_logger')
+def create_mock_logger():
+    """Create a mock logger for testing"""
+    logger = Mock()
+    logger.debug = Mock()
+    return logger
+
+
+@pytest.fixture(name='acknowledger')
+def create_acknowledger(mock_mesh_client, mock_logger):
+    """Create a MeshAcknowledger instance with mocked dependencies"""
+    return MeshAcknowledger(mock_mesh_client, mock_logger)
+
+
+class TestMeshAcknowledger:
+    """Test suite for MeshAcknowledger class"""
+
+    def test_init_performs_handshake(self, mock_mesh_client, mock_logger):
+        """Test that __init__ performs a MESH handshake"""
+        MeshAcknowledger(mock_mesh_client, mock_logger)
+
+        mock_mesh_client.handshake.assert_called_once()
+
+    def test_acknowledge_message_sends_correct_message(
+        self, acknowledger, mock_mesh_client
+    ):
+        """Test that acknowledge_message sends the correct message via MESH"""
+        mailbox_id = "MAILBOX001"
+        message_id = "MSG123456"
+        message_reference = "REF789"
+        sender_id = "SENDER001"
+
+        expected_body = json.dumps({
+            "meshMessageId": message_id,
+            "requestId": f"{sender_id}_{message_reference}"
+        }).encode()
+
+        acknowledger.acknowledge_message(
+            mailbox_id, message_id, message_reference, sender_id
+        )
+
+        mock_mesh_client.send_message.assert_called_once_with(
+            mailbox_id,
+            expected_body,
+            workflow_id=NOTIFY_ACK_WORKFLOW_ID,
+            local_id=message_reference,
+            subject=ACK_SUBJECT
+        )
+
+    def test_acknowledge_message_returns_ack_id(
+        self, acknowledger, mock_mesh_client
+    ):
+        """Test that acknowledge_message returns the acknowledgment ID"""
+        mailbox_id = "MAILBOX001"
+        message_id = "MSG123456"
+        message_reference = "REF789"
+        sender_id = "SENDER001"
+
+        expected_ack_id = "ACK_CUSTOM_ID"
+
+        mock_mesh_client.send_message.return_value = expected_ack_id
+
+        ack_message_id = acknowledger.acknowledge_message(
+            mailbox_id, message_id, message_reference, sender_id
+        )
+
+        assert ack_message_id == expected_ack_id
+
+    def test_acknowledge_message_raises_error_if_mesh_send_fails(
+        self, acknowledger, mock_mesh_client
+    ):
+        """Test that the MeshAcknowledger raises an error if MESH send_message fails"""
+        mailbox_id = "MAILBOX001"
+        message_id = "MSG123"
+        message_reference = "REF123"
+        sender_id = "SENDER001"
+        expected_exception_message = "MESH send failed"
+
+        mock_mesh_client.send_message.side_effect = Exception(
+            expected_exception_message)
+
+        with pytest.raises(Exception, match=expected_exception_message):
+            acknowledger.acknowledge_message(
+                mailbox_id, message_id, message_reference, sender_id
+            )

lambdas/mesh-acknowledge/mesh_acknowledge/__tests__/test_dlq.py

@@ -0,0 +1,89 @@
+"""
+Tests for Dlq class in mesh_acknowledge.dlq
+"""
+import json
+from unittest.mock import Mock
+
+import pytest
+from botocore.exceptions import ClientError
+
+from mesh_acknowledge.dlq import Dlq
+
+
+@pytest.fixture(name='mock_sqs_client')
+def create_mock_sqs_client():
+    """Create a mock SQS client for testing"""
+    client = Mock()
+    client.send_message = Mock(return_value={'MessageId': 'msg-12345'})
+    return client
+
+
+@pytest.fixture(name='mock_logger')
+def create_mock_logger():
+    """Create a mock logger for testing"""
+    logger = Mock()
+    logger.info = Mock()
+    logger.error = Mock()
+    return logger
+
+@pytest.fixture(name='dlq_url')
+def create_dlq_url():
+    """Create a DLQ URL for testing"""
+    return "https://sqs.us-east-1.amazonaws.com/123456789012/test-dlq"
+
+@pytest.fixture(name='dlq')
+def create_dlq(mock_sqs_client, mock_logger, dlq_url):
+    """Create a Dlq instance for testing"""
+    return Dlq(
+        sqs_client=mock_sqs_client,
+        dlq_url=dlq_url,
+        logger=mock_logger
+    )
+
+
+class TestSendToQueue:
+    """Tests for send_to_queue method"""
+
+    def test_sends_record_to_dlq_successfully(
+        self,
+        dlq,
+        mock_sqs_client,
+        dlq_url
+    ):
+        """Test that a record is sent to DLQ successfully"""
+        record = {
+            "id": "test-event-123",
+            "type": "test.event.v1",
+            "data": {"key": "value"}
+        }
+        reason = "Validation failed"
+
+        dlq.send_to_queue(record, reason)
+
+        mock_sqs_client.send_message.assert_called_once_with(
+            QueueUrl=dlq_url,
+            MessageBody=json.dumps(record),
+            MessageAttributes={
+                'DlqReason': {
+                    'DataType': 'String',
+                    'StringValue': reason
+                }
+            }
+        )
+
+    def test_handles_sqs_client_error(
+        self,
+        dlq,
+        mock_sqs_client,
+    ):
+        """Test that ClientError from SQS is handled and re-raised"""
+        record = {"id": "test-event-123"}
+        reason = "Processing error"
+        error = ClientError(
+            {'Error': {'Code': 'InvalidParameterValue', 'Message': 'Invalid queue URL'}},
+            'SendMessage'
+        )
+        mock_sqs_client.send_message.side_effect = error
+
+        with pytest.raises(ClientError):
+            dlq.send_to_queue(record, reason)