fail fast with no nhs_no and lambda int test

Author: motola

lambdas/mns_publisher/src/create_notification.py

@@ -28,6 +28,10 @@ def create_mns_notification(sqs_event: SQSMessage) -> MnsNotificationPayload:
 
     imms_map = new_image.get("Imms", {}).get("M", {})
     nhs_number = _unwrap_dynamodb_value(imms_map.get("NHS_NUMBER", {}))
+    if not nhs_number:
+        logger.error("Missing required field: Nhs Number")
+        raise ValueError("NHS number is required to create MNS notification")
+
     person_dob = _unwrap_dynamodb_value(imms_map.get("PERSON_DOB", {}))
     date_and_time = _unwrap_dynamodb_value(imms_map.get("DATE_AND_TIME", {}))
     site_code = _unwrap_dynamodb_value(imms_map.get("SITE_CODE", {}))
@@ -115,14 +119,11 @@ def _unwrap_dynamodb_value(value: dict) -> Any:
     if not isinstance(value, dict):
         return value
 
-    # DynamoDB type descriptors
     if "NULL" in value:
         return None
 
-    # Check other DynamoDB types
     for key in DYNAMO_DB_TYPE_DESCRIPTORS:
         if key in value:
             return value[key]
 
-    # Not a DynamoDB type, return as-is
     return value

lambdas/mns_publisher/src/process_records.py

@@ -50,6 +50,7 @@ def process_record(record: SQSMessage, mns_service: MnsService) -> None:
 
     mns_notification_payload = create_mns_notification(record)
     notification_id = mns_notification_payload.get("id")
+
     action_flag = mns_notification_payload.get("filtering", {}).get("action")
     logger.info(
         "Processing message",

…mbdas/mns_publisher/tests/sqs_event.json …blisher/tests/sample_data/sqs_event.jsonlambdas/mns_publisher/tests/sqs_event.json renamed to lambdas/mns_publisher/tests/sample_data/sqs_event.json lambdas/mns_publisher/tests/sqs_event.json renamed to lambdas/mns_publisher/tests/sample_data/sqs_event.json

@@ -73,7 +73,7 @@ def setUp(self):
     @patch("create_notification.get_practitioner_details_from_pds")
     @patch("create_notification.get_service_url")
     @patch("create_notification.uuid.uuid4")
-    def test_create_mns_notification_success_with_real_payload(self, mock_uuid, mock_get_service_url, mock_get_gp):
+    def test_create_mns_notification_complete_payload(self, mock_uuid, mock_get_service_url, mock_get_gp):
         mock_uuid.return_value = MagicMock(hex="236a1d4a-5d69-4fa9-9c7f-e72bf505aa5b")
         mock_get_service_url.return_value = self.expected_immunisation_url
         mock_get_gp.return_value = self.expected_gp_ods_code
@@ -84,47 +84,33 @@ def test_create_mns_notification_success_with_real_payload(self, mock_uuid, mock
         self.assertEqual(result["type"], IMMUNISATION_TYPE)
         self.assertEqual(result["source"], self.expected_immunisation_url)
         self.assertEqual(result["subject"], "9481152782")
-        self.assertIn("id", result)
-        self.assertIn("time", result)
-        self.assertIn("dataref", result)
-        self.assertIn("filtering", result)
-
-    @patch("create_notification.get_practitioner_details_from_pds")
-    @patch("create_notification.get_service_url")
-    def test_create_mns_notification_dataref_format_real_payload(self, mock_get_service_url, mock_get_gp):
-        mock_get_service_url.return_value = self.expected_immunisation_url
-        mock_get_gp.return_value = self.expected_gp_ods_code
-
-        result = create_mns_notification(self.sample_sqs_event)
 
         expected_dataref = f"{self.expected_immunisation_url}/Immunization/d058014c-b0fd-4471-8db9-3316175eb825"
         self.assertEqual(result["dataref"], expected_dataref)
 
-    @patch("create_notification.get_practitioner_details_from_pds")
-    @patch("create_notification.get_service_url")
-    def test_create_mns_notification_filtering_fields_real_payload(self, mock_get_service_url, mock_get_gp):
-        mock_get_service_url.return_value = self.expected_immunisation_url
-        mock_get_gp.return_value = self.expected_gp_ods_code
-
-        result = create_mns_notification(self.sample_sqs_event)
-
         filtering = result["filtering"]
         self.assertEqual(filtering["generalpractitioner"], self.expected_gp_ods_code)
         self.assertEqual(filtering["sourceorganisation"], "B0C4P")
         self.assertEqual(filtering["sourceapplication"], "TPP")
         self.assertEqual(filtering["immunisationtype"], "hib")
         self.assertEqual(filtering["action"], "CREATE")
-        self.assertIsInstance(filtering["subjectage"], str)
+        self.assertEqual(filtering["subjectage"], "21")
+
+        self.assertIn("id", result)
+        self.assertIsInstance(result["id"], str)
 
     @patch("create_notification.get_practitioner_details_from_pds")
     @patch("create_notification.get_service_url")
-    def test_create_mns_notification_age_calculation_real_payload(self, mock_get_service_url, mock_get_gp):
-        mock_get_service_url.return_value = self.expected_immunisation_url
-        mock_get_gp.return_value = self.expected_gp_ods_code
+    def test_create_mns_notification_missing_nhs_number(self, mock_get_service_url, mock_get_gp):
+        sqs_event_data = copy.deepcopy(self.sample_sqs_event)
 
-        result = create_mns_notification(self.sample_sqs_event)
+        body = json.loads(sqs_event_data["body"])
+        body["dynamodb"]["NewImage"]["Imms"]["M"]["NHS_NUMBER"]["S"] = ""
+        sqs_event_data["body"] = json.dumps(body)
 
-        self.assertEqual(result["filtering"]["subjectage"], "21")
+        with self.assertRaises(ValueError) as context:
+            create_mns_notification(sqs_event_data)
+        self.assertIn("NHS number is required", str(context.exception))
 
     @patch("create_notification.get_practitioner_details_from_pds")
     @patch("create_notification.get_service_url")
@@ -136,17 +122,6 @@ def test_create_mns_notification_calls_get_practitioner_real_payload(self, mock_
 
         mock_get_gp.assert_called_once_with("9481152782")
 
-    @patch("create_notification.get_practitioner_details_from_pds")
-    @patch("create_notification.get_service_url")
-    def test_create_mns_notification_uuid_generated(self, mock_get_service_url, mock_get_gp):
-        mock_get_service_url.return_value = self.expected_immunisation_url
-        mock_get_gp.return_value = self.expected_gp_ods_code
-
-        result1 = create_mns_notification(self.sample_sqs_event)
-        result2 = create_mns_notification(self.sample_sqs_event)
-
-        self.assertNotEqual(result1["id"], result2["id"])
-
     @patch("create_notification.get_practitioner_details_from_pds")
     @patch("create_notification.get_service_url")
     def test_create_mns_notification_invalid_json_body(self, mock_get_service_url, mock_get_gp):
@@ -200,7 +175,7 @@ def test_create_mns_notification_missing_imms_data_field(self, mock_get_service_
             "body": json.dumps({"dynamodb": {"NewImage": {"ImmsID": {"S": "test-id"}}}}),
         }
 
-        with self.assertRaises((KeyError, TypeError)):
+        with self.assertRaises((KeyError, TypeError, ValueError)):
             create_mns_notification(incomplete_event)
 
     @patch("create_notification.get_practitioner_details_from_pds")
@@ -385,7 +360,3 @@ def test_unwrap_list_type(self):
         value = {"L": [{"S": "item1"}, {"S": "item2"}]}
         result = _unwrap_dynamodb_value(value)
         self.assertEqual(result, [{"S": "item1"}, {"S": "item2"}])
-
-
-if __name__ == "__main__":
-    unittest.main()

lambdas/mns_publisher/tests/test_create_notification.py

@@ -1,11 +1,14 @@
 import json
 import unittest
-from pathlib import Path
 from unittest.mock import Mock, patch
 
+import boto3
+import responses
+from moto import mock_aws
+
 from lambda_handler import lambda_handler
 from process_records import extract_trace_ids, process_record, process_records
-from test_utils import load_sample_sqs_event
+from test_utils import generate_private_key_b64, load_sample_sqs_event
 
 
 class TestExtractTraceIds(unittest.TestCase):
@@ -119,14 +122,7 @@ class TestProcessRecords(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
         """Load the sample SQS event once for all tests."""
-        sample_event_path = Path(__file__).parent.parent / "tests/sqs_event.json"
-        with open(sample_event_path, "r") as f:
-            raw_event = json.load(f)
-
-        if isinstance(raw_event.get("body"), dict):
-            raw_event["body"] = json.dumps(raw_event["body"])
-
-        cls.sample_sqs_record = raw_event
+        cls.sample_sqs_record = load_sample_sqs_event()
 
     @patch("process_records.logger")
     @patch("process_records.get_mns_service")
@@ -168,7 +164,7 @@ def test_process_records_partial_failure(self, mock_process_record, mock_get_mns
 
         self.assertEqual(len(result["batchItemFailures"]), 1)
         self.assertEqual(result["batchItemFailures"][0]["itemIdentifier"], "msg-456")
-        mock_logger.exception.assert_called_once()
+        mock_logger.warning.assert_called_with("Batch completed with 1 failures")
 
     @patch("process_records.logger")
     @patch("process_records.get_mns_service")
@@ -241,5 +237,66 @@ def test_lambda_handler_empty_records(self, mock_process_records):
         mock_process_records.assert_called_once_with([])
 
 
+@mock_aws
+class TestLambdaHandlerIntegration(unittest.TestCase):
+    """
+    Integration tests
+    """
+
+    def setUp(self):
+        """Set up mocked AWS services and test data."""
+        self.sample_sqs_record = load_sample_sqs_event()
+        self.secrets_client = boto3.client("secretsmanager", region_name="eu-west-2")
+        self.secrets_client.create_secret(
+            Name="imms/pds/int/jwt-secrets",
+            SecretString=json.dumps(
+                {"api_key": "fake-pds-api-key", "kid": "fake-kid-123", "private_key_b64": generate_private_key_b64()}
+            ),
+        )
+
+    @responses.activate
+    @patch("common.api_clients.authentication.AppRestrictedAuth.get_access_token")
+    @patch("process_records.logger")
+    def test_successful_notification_creation_with_gp(self, mock_logger, mock_get_token):
+        # Mock OAuth token response issued from Apigee
+        mock_oauth_response = Mock()
+        mock_oauth_response.status_code = 200
+        mock_oauth_response.json.return_value = {"access_token": "fake-token"}
+        mock_get_token.return_value = mock_oauth_response
+
+        # Intercepts actual request call to PDS and returns mocked responses
+        responses.add(
+            responses.GET,
+            "https://int.api.service.nhs.uk/personal-demographics/FHIR/R4/Patient/9481152782",
+            json={"generalPractitioner": [{"identifier": {"value": "Y12345", "period": {"start": "2024-01-01"}}}]},
+            status=200,
+        )
+
+        mns_response = responses.add(
+            responses.POST,
+            "https://int.api.service.nhs.uk/multicast-notification-service/events",
+            json={"id": "236a1d4a-5d69-4fa9-9c7f-e72bf505aa5b"},
+            status=200,
+        )
+
+        sqs_event = {"Records": [self.sample_sqs_record]}
+        result = lambda_handler(sqs_event, Mock())
+
+        self.assertEqual(result, {"batchItemFailures": []})
+
+        self.assertEqual(mns_response.call_count, 1)
+        self.assertEqual(mns_response.calls[0].response.status_code, 200)
+        mns_payload = json.loads(mns_response.calls[0].request.body)
+        self.assertEqual(mns_payload["subject"], "9481152782")
+        self.assertEqual(mns_payload["filtering"]["generalpractitioner"], "Y12345")
+        self.assertEqual(mns_payload["filtering"]["sourceorganisation"], "B0C4P")
+        self.assertEqual(mns_payload["filtering"]["sourceapplication"], "TPP")
+        self.assertEqual(mns_payload["filtering"]["immunisationtype"], "hib")
+        self.assertEqual(mns_payload["filtering"]["action"], "CREATE")
+        self.assertEqual(mns_payload["filtering"]["subjectage"], "21")
+
+        mock_logger.info.assert_any_call("Successfully processed all 1 messages")
+
+
 if __name__ == "__main__":
     unittest.main()

lambdas/mns_publisher/tests/test_lambda_handler.py

@@ -1,13 +1,28 @@
+import base64
 import json
 from pathlib import Path
 
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric import rsa
+
+
+def generate_private_key_b64() -> str:
+    # Generate a real RSA private key (PKCS8) and base64 encode the PEM
+    private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
+    pem_bytes = private_key.private_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PrivateFormat.PKCS8,
+        encryption_algorithm=serialization.NoEncryption(),
+    )
+    return base64.b64encode(pem_bytes).decode("utf-8")
+
 
 def load_sample_sqs_event() -> dict:
     """
     Loads the sample SQS event and normalises body to a JSON string (as SQS delivers it).
     Expects: lambdas/mns_publisher/tests/sqs_event.json
     """
-    sample_event_path = Path(__file__).parent / "sqs_event.json"
+    sample_event_path = Path(__file__).parent / "sample_data" / "sqs_event.json"
     with open(sample_event_path, "r") as f:
         raw_event = json.load(f)