Feature/CCM-12616 Mesh poll retrieve component tests

infrastructure/terraform/components/dl/locals.tf

@@ -6,6 +6,7 @@ locals {
   apim_private_key_ssm_parameter_name  = "/${var.component}/${var.environment}/apim/private_key"
   apim_keystore_s3_bucket              = "nhs-${var.aws_account_id}-${var.region}-${var.environment}-${var.component}-static-assets"
   ssm_mesh_prefix                      = "/${var.component}/${var.environment}/mesh"
+  ssm_senders_prefix                   = "/${var.component}/${var.environment}/senders"
   mock_mesh_endpoint                   = "s3://${module.s3bucket_non_pii_data.bucket}/mock-mesh"
   root_domain_name                     = "${var.environment}.${local.acct.route53_zone_names["digital-letters"]}"
   root_domain_id                       = local.acct.route53_zone_ids["digital-letters"]

infrastructure/terraform/components/dl/module_lambda_mesh_download.tf

@@ -37,15 +37,14 @@ module "mesh_download" {
   log_subscription_role_arn = local.acct.log_subscription_role_arn
 
   lambda_env_vars = {
-    CERTIFICATE_EXPIRY_METRIC_NAME      = "mesh-download-client-certificate-near-expiry"
-    CERTIFICATE_EXPIRY_METRIC_NAMESPACE = "dl-mesh-download"
     DOWNLOAD_METRIC_NAME                = "mesh-download-successful-downloads"
     DOWNLOAD_METRIC_NAMESPACE           = "dl-mesh-download"
     ENVIRONMENT                         = var.environment
     EVENT_PUBLISHER_DLQ_URL             = module.sqs_event_publisher_errors.sqs_queue_url
     EVENT_PUBLISHER_EVENT_BUS_ARN       = aws_cloudwatch_event_bus.main.arn
     PII_BUCKET                          = module.s3bucket_pii_data.bucket
-    SSM_PREFIX                          = "${local.ssm_mesh_prefix}"
+    SSM_MESH_PREFIX                     = "${local.ssm_mesh_prefix}"
+    SSM_SENDERS_PREFIX                  = "${local.ssm_senders_prefix}"
     USE_MESH_MOCK                       = var.enable_mock_mesh ? "true" : "false"
   }
 
@@ -172,7 +171,8 @@ data "aws_iam_policy_document" "mesh_download_lambda" {
     ]
 
     resources = [
-      "arn:aws:ssm:${var.region}:${var.aws_account_id}:parameter${local.ssm_mesh_prefix}/*"
+      "arn:aws:ssm:${var.region}:${var.aws_account_id}:parameter${local.ssm_mesh_prefix}/*",
+      "arn:aws:ssm:${var.region}:${var.aws_account_id}:parameter${local.ssm_senders_prefix}/*"
     ]
   }
 }

infrastructure/terraform/components/dl/module_lambda_mesh_poll.tf

@@ -45,7 +45,8 @@ module "mesh_poll" {
     MAXIMUM_RUNTIME_MILLISECONDS        = "240000"  # 4 minutes (Lambda has 5 min timeout)
     POLLING_METRIC_NAME                 = "mesh-poll-successful-polls"
     POLLING_METRIC_NAMESPACE            = "dl-mesh-poll"
-    SSM_PREFIX                          = "${local.ssm_mesh_prefix}"
+    SSM_MESH_PREFIX                     = "${local.ssm_mesh_prefix}"
+    SSM_SENDERS_PREFIX                  = "${local.ssm_senders_prefix}"
     USE_MESH_MOCK                       = var.enable_mock_mesh ? "true" : "false"
   }
 
@@ -144,7 +145,8 @@ data "aws_iam_policy_document" "mesh_poll_lambda" {
     ]
 
     resources = [
-      "arn:aws:ssm:${var.region}:${var.aws_account_id}:parameter${local.ssm_mesh_prefix}/*"
+      "arn:aws:ssm:${var.region}:${var.aws_account_id}:parameter${local.ssm_mesh_prefix}/*",
+      "arn:aws:ssm:${var.region}:${var.aws_account_id}:parameter${local.ssm_senders_prefix}/*"
     ]
   }
 }

lambdas/mesh-download/mesh_download/__tests__/test_processor.py

@@ -8,6 +8,7 @@
 from unittest.mock import Mock, patch
 from datetime import datetime, timezone
 from pydantic import ValidationError
+from mesh_download.errors import MeshMessageNotFound
 
 
 def setup_mocks():
@@ -238,9 +239,11 @@ def test_download_and_store_message_not_found(self):
 
         config.mesh_client.retrieve_message.return_value = None
         sqs_record = create_sqs_record()
-        processor.process_sqs_message(sqs_record)
-        config.mesh_client.retrieve_message.assert_called_once_with('test_message_123')
 
+        with pytest.raises(MeshMessageNotFound, match="MESH message with ID test_message_123 not found"):
+            processor.process_sqs_message(sqs_record)
+
+        config.mesh_client.retrieve_message.assert_called_once_with('test_message_123')
         document_store.store_document.assert_not_called()
         event_publisher.send_events.assert_not_called()
         config.download_metric.record.assert_not_called()

lambdas/mesh-download/mesh_download/config.py

@@ -6,10 +6,9 @@
 
 
 _REQUIRED_ENV_VAR_MAP = {
-    "ssm_prefix": "SSM_PREFIX",
+    "ssm_senders_prefix": "SSM_SENDERS_PREFIX",
+    "ssm_mesh_prefix": "SSM_MESH_PREFIX",
     "environment": "ENVIRONMENT",
-    "certificate_expiry_metric_name": "CERTIFICATE_EXPIRY_METRIC_NAME",
-    "certificate_expiry_metric_namespace": "CERTIFICATE_EXPIRY_METRIC_NAMESPACE",
     "download_metric_name": "DOWNLOAD_METRIC_NAME",
     "download_metric_namespace": "DOWNLOAD_METRIC_NAMESPACE",
     "event_publisher_event_bus_arn": "EVENT_PUBLISHER_EVENT_BUS_ARN",

lambdas/mesh-download/mesh_download/errors.py

@@ -11,3 +11,8 @@ def format_exception(exception):
     """
     return ''.join(traceback.format_exception(
         type(exception), exception, exception.__traceback__))
+
+class MeshMessageNotFound(Exception):
+    """
+    Indicates an invalid MESH message could not be retrieved
+    """

lambdas/mesh-download/mesh_download/processor.py

@@ -4,6 +4,7 @@
 
 from pydantic import ValidationError
 from event_publisher.models import MeshInboxMessageEvent, MeshDownloadMessageEvent
+from mesh_download.errors import MeshMessageNotFound
 
 
 class MeshDownloadProcessor:
@@ -57,7 +58,7 @@ def _handle_download(self, event, logger):
         message = self.__mesh_client.retrieve_message(data.meshMessageId)
         if not message:
             logger.error("Message not found in MESH inbox")
-            return
+            raise MeshMessageNotFound(f"MESH message with ID {data.meshMessageId} not found")
 
         logger.info(
             "Retrieved MESH message",

lambdas/mesh-poll/mesh_poll/__tests__/test_sender_lookup.py

@@ -10,7 +10,8 @@ def setup_mocks():
     ssm = Mock()
 
     config = Mock()
-    config.ssm_prefix = "/dl/test"
+    config.ssm_mesh_prefix = "/dl/test/mesh"
+    config.ssm_senders_prefix = "/dl/test/senders"
 
     logger = Mock()
 

lambdas/mesh-poll/mesh_poll/config.py

@@ -6,7 +6,8 @@
 
 
 _REQUIRED_ENV_VAR_MAP = {
-    "ssm_prefix": "SSM_PREFIX",
+    "ssm_senders_prefix": "SSM_SENDERS_PREFIX",
+    "ssm_mesh_prefix": "SSM_MESH_PREFIX",
     "maximum_runtime_milliseconds": "MAXIMUM_RUNTIME_MILLISECONDS",
     "environment": "ENVIRONMENT",
     "event_bus_arn": "EVENT_PUBLISHER_EVENT_BUS_ARN",

lambdas/mesh-poll/mesh_poll/processor.py

@@ -135,14 +135,15 @@ def _publish_mesh_inbox_message_received_event(self, event_detail):
             'id': str(uuid4()),
             'specversion': '1.0',
             'source': self.__cloud_event_source,
-            'subject': 'customer/00000000-0000-0000-0000-000000000000/recipient/00000000-0000-0000-0000-000000000000',
+            'subject': f'customer/{event_detail["data"]["senderId"]}/recipient/{event_detail["data"]["messageReference"]}',
             'type': 'uk.nhs.notify.digital.letters.mesh.inbox.message.received.v1',
             'time': now,
             'recordedtime': now,
             'severitynumber': 2,
             'severitytext': 'INFO',
             'traceparent': '00-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-01',
             'dataschema': 'https://notify.nhs.uk/cloudevents/schemas/digital-letters/2025-10-draft/data/digital-letters-mesh-inbox-message-received-data.schema.json',
+            'datacontenttype': 'application/json',
             'data': event_detail.get('data', {}),
         }
 

lambdas/mesh-poll/mesh_poll/sender_lookup.py

@@ -58,7 +58,7 @@ def __get_page(self, next_token=""):
         """
         Loads a page of sender data and extracts mailbox IDs and sender IDs
         """
-        senders_path = f"{self.__config.ssm_prefix.rstrip('/')}/senders/"
+        senders_path = f"{self.__config.ssm_senders_prefix.rstrip('/')}/"
 
         if len(next_token) == 0:
             response = self.__ssm.get_parameters_by_path(

tests/playwright/constants/backend-constants.ts

@@ -17,6 +17,7 @@ export const CORE_NOTIFIER_LAMBDA_NAME = `${CSI}-core-notifier`;
 export const TTL_QUEUE_NAME = `${CSI}-ttl-queue`;
 export const TTL_DLQ_NAME = `${CSI}-ttl-dlq`;
 export const PDM_UPLOADER_DLQ_NAME = `${CSI}-pdm-uploader-dlq`;
+export const MESH_DOWNLOAD_DLQ_NAME = `${CSI}-mesh-download-dlq`;
 export const PDM_POLL_DLQ_NAME = `${CSI}-pdm-poll-dlq`;
 export const CORE_NOTIFIER_DLQ_NAME = `${CSI}-core-notifier-dlq`;
 
@@ -33,6 +34,8 @@ export const TTL_TABLE_NAME = `${CSI}-ttl`;
 
 // S3
 export const LETTERS_S3_BUCKET_NAME = `nhs-${process.env.AWS_ACCOUNT_ID}-${REGION}-${ENV}-dl-letters`;
+export const NON_PII_S3_BUCKET_NAME = `nhs-${process.env.AWS_ACCOUNT_ID}-${REGION}-${ENV}-dl-non-pii-data`;
+export const PII_S3_BUCKET_NAME = `nhs-${process.env.AWS_ACCOUNT_ID}-${REGION}-${ENV}-dl-pii-data`;
 
 // Cloudwatch
 export const PDM_UPLOADER_LAMBDA_LOG_GROUP_NAME = `/aws/lambda/${CSI}-pdm-uploader`;

tests/playwright/constants/tests-constants.ts

@@ -1,6 +1,6 @@
 // senderIds
 export const SENDER_ID_VALID_FOR_NOTIFY_SANDBOX =
-  'componentTestSender_RoutingConfig';
+  '2b8ebb33-8b33-49bd-949e-c12e22d25320';
 export const SENDER_ID_THAT_TRIGGERS_ERROR_IN_NOTIFY_SANDBOX =
-  'componentTestSender_RoutingConfigInvalid';
-export const SENDER_ID_SKIPS_NOTIFY = 'test-sender-1';
+  'f017669b-6da4-4576-9d59-3d2b7f005ae2';
+export const SENDER_ID_SKIPS_NOTIFY = '67403568-166e-41d0-900a-1f31fe93a091';

tests/playwright/digital-letters-component-tests/mesh-poll-download.component.spec.ts

@@ -0,0 +1,182 @@
+import { expect, test } from '@playwright/test';
+import {
+  ENV,
+  MESH_DOWNLOAD_DLQ_NAME,
+  MESH_POLL_LAMBDA_NAME,
+  NON_PII_S3_BUCKET_NAME,
+  PII_S3_BUCKET_NAME,
+} from 'constants/backend-constants';
+import { getLogsFromCloudwatch } from 'helpers/cloudwatch-helpers';
+import eventPublisher from 'helpers/event-bus-helpers';
+import expectToPassEventually from 'helpers/expectations';
+import { invokeLambda } from 'helpers/lambda-helpers';
+import { downloadFromS3, uploadToS3 } from 'helpers/s3-helpers';
+import { expectMessageContainingString } from 'helpers/sqs-helpers';
+import { v4 as uuidv4 } from 'uuid';
+import messageMessageReceived from 'digital-letters-events/MESHInboxMessageReceived.js';
+import { SENDER_ID_SKIPS_NOTIFY } from 'constants/tests-constants';
+
+test.describe('Digital Letters - MESH Poll and Download', () => {
+  const senderId = SENDER_ID_SKIPS_NOTIFY;
+  const sendersMeshMailboxId = 'test-mesh-sender-1';
+  const meshMailboxId = 'mock-mailbox';
+
+  async function uploadMeshMessage(
+    meshMessageId: string,
+    messageReference: string,
+    messageContent: string,
+    metadata: Record<string, string> = {},
+  ): Promise<void> {
+    const key = `mock-mesh/${meshMailboxId}/in/${meshMessageId}`;
+    const meshMetadata = {
+      sender: sendersMeshMailboxId,
+      subject: '201',
+      workflow_id: 'NHS_NOTIFY_SEND_REQUEST',
+      local_id: messageReference,
+      ...metadata,
+    };
+
+    await uploadToS3(messageContent, NON_PII_S3_BUCKET_NAME, key, meshMetadata);
+  }
+
+  async function expectMeshInboxMessageReceivedEvent(
+    meshMessageId: string,
+  ): Promise<void> {
+    await expectToPassEventually(async () => {
+      const eventLogEntry = await getLogsFromCloudwatch(
+        `/aws/vendedlogs/events/event-bus/nhs-${ENV}-dl`,
+        [
+          '$.message_type = "EVENT_RECEIPT"',
+          '$.details.detail_type = "uk.nhs.notify.digital.letters.mesh.inbox.message.received.v1"',
+          `$.details.event_detail = "*\\"meshMessageId\\":\\"${meshMessageId}\\"*"`,
+          `$.details.event_detail = "*\\"senderId\\":\\"${senderId}\\"*"`,
+        ],
+      );
+
+      expect(eventLogEntry.length).toBeGreaterThanOrEqual(1);
+    }, 120_000);
+  }
+
+  async function expectMeshInboxMessageDownloadedEvent(
+    messageReference: string,
+  ): Promise<void> {
+    await expectToPassEventually(async () => {
+      const eventLogEntry = await getLogsFromCloudwatch(
+        `/aws/vendedlogs/events/event-bus/nhs-${ENV}-dl`,
+        [
+          '$.message_type = "EVENT_RECEIPT"',
+          '$.details.detail_type = "uk.nhs.notify.digital.letters.mesh.inbox.message.downloaded.v1"',
+          `$.details.event_detail = "*\\"messageReference\\":\\"${messageReference}\\"*"`,
+          `$.details.event_detail = "*\\"senderId\\":\\"${senderId}\\"*"`,
+        ],
+      );
+
+      expect(eventLogEntry.length).toBeGreaterThanOrEqual(1);
+    }, 180_000);
+  }
+
+  test('should poll message from MESH inbox, publish received event, download message, and publish downloaded event', async () => {
+    const meshMessageId = `${Date.now()}_TEST_${uuidv4().slice(0, 8)}`;
+    const messageReference = uuidv4();
+    const messageContent = JSON.stringify({
+      senderId,
+      messageReference,
+      testData: 'This is a test letter content',
+      timestamp: new Date().toISOString(),
+    });
+
+    await uploadMeshMessage(meshMessageId, messageReference, messageContent);
+
+    await invokeLambda(MESH_POLL_LAMBDA_NAME);
+
+    await expectMeshInboxMessageReceivedEvent(meshMessageId);
+    await expectMeshInboxMessageDownloadedEvent(messageReference);
+
+    await expectToPassEventually(async () => {
+      const storedMessage = await downloadFromS3(
+        PII_S3_BUCKET_NAME,
+        `document-reference/${senderId}_${messageReference}`,
+      );
+
+      expect(storedMessage.body).toContain(messageContent);
+    }, 60_000);
+
+    await expectToPassEventually(async () => {
+      await expect(async () => {
+        await downloadFromS3(
+          NON_PII_S3_BUCKET_NAME,
+          `mock-mesh/${meshMailboxId}/in/${meshMessageId}`,
+        );
+      }).rejects.toThrow('No objects found');
+    }, 60_000);
+  });
+
+  test('should send message to mesh-download DLQ when download fails', async () => {
+    test.setTimeout(400_000);
+
+    const invalidMeshMessageId = `${Date.now()}_DLQ_${uuidv4().slice(0, 8)}`;
+    const messageReference = uuidv4();
+
+    await eventPublisher.sendEvents(
+      [
+        {
+          id: uuidv4(),
+          specversion: '1.0',
+          source:
+            '/nhs/england/notify/development/primary/data-plane/digitalletters/mesh',
+          subject:
+            'customer/00000000-0000-0000-0000-000000000000/recipient/00000000-0000-0000-0000-000000000000',
+          type: 'uk.nhs.notify.digital.letters.mesh.inbox.message.received.v1',
+          time: '2026-01-20T15:48:21.636284+00:00',
+          recordedtime: '2026-01-20T15:48:21.636284+00:00',
+          severitynumber: 2,
+          severitytext: 'INFO',
+          traceparent:
+            '00-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-01',
+          dataschema:
+            'https://notify.nhs.uk/cloudevents/schemas/digital-letters/2025-10-draft/data/digital-letters-mesh-inbox-message-received-data.schema.json',
+          data: {
+            meshMessageId: invalidMeshMessageId,
+            senderId,
+            messageReference,
+          },
+        },
+      ],
+      messageMessageReceived,
+    );
+
+    await expectMessageContainingString(
+      MESH_DOWNLOAD_DLQ_NAME,
+      invalidMeshMessageId,
+      300,
+    );
+  });
+
+  test('should handle multiple messages in inbox', async () => {
+    test.setTimeout(300_000);
+
+    const messages = Array.from({ length: 3 }, (_, i) => ({
+      meshMessageId: `${Date.now()}_MULTI_${i}_${uuidv4().slice(0, 8)}`,
+      messageReference: uuidv4(),
+      messageContent: JSON.stringify({
+        senderId,
+        messageReference: uuidv4(),
+        testData: `Test message ${i}`,
+      }),
+    }));
+
+    for (const msg of messages) {
+      await uploadMeshMessage(
+        msg.meshMessageId,
+        msg.messageReference,
+        msg.messageContent,
+      );
+    }
+
+    await invokeLambda(MESH_POLL_LAMBDA_NAME);
+
+    for (const msg of messages) {
+      await expectMeshInboxMessageReceivedEvent(msg.meshMessageId);
+    }
+  });
+});