restructured

Author: nhsdevws

lambdas/id_sync/src/id_sync.py

@@ -2,25 +2,18 @@
 from common.clients import STREAM_NAME
 from common.log_decorator import logging_decorator
 from common.aws_lambda_event import AwsLambdaEvent
+from models.id_sync_exception import IdSyncException
 from record_processor import process_record
 '''
 Lambda function handler for processing SQS events.Lambda for ID Sync. Fired by SQS
 '''
 
 
-class IdSyncException(Exception):
-    """Custom exception for ID Sync errors."""
-    def __init__(self, message: str, nhs_numbers: list = None, exception=None):
-        self.message = message
-        self.nhs_numbers = nhs_numbers
-        self.exception = exception
-        super().__init__(message)
-
-
 @logging_decorator(prefix="id_sync", stream_name=STREAM_NAME)
 def handler(event_data, _):
 
     try:
+        logger.info("id_sync handler invoked")
         event = AwsLambdaEvent(event_data)
         record_count = len(event.records)
         if record_count > 0:

lambdas/id_sync/src/models/__init__.py

@@ -0,0 +1,7 @@
+class IdSyncException(Exception):
+    """Custom exception for ID Sync errors."""
+    def __init__(self, message: str, nhs_numbers: list = None, exception=None):
+        self.message = message
+        self.nhs_numbers = nhs_numbers
+        self.inner_exception = exception
+        super().__init__(message)

lambdas/id_sync/src/models/id_sync_exception.py

@@ -7,14 +7,15 @@
 from os_vars import get_pds_env
 from common.pds_service import PdsService
 from common.authentication import AppRestrictedAuth, Service
+from models.id_sync_exception import IdSyncException
 
 pds_env = get_pds_env()
 safe_tmp_dir = tempfile.mkdtemp(dir="/tmp")  # NOSONAR
 
 
 def pds_get_patient_details(nhs_number: str) -> dict:
     try:
-        logger.info(f"Get PDS patient details for {nhs_number}")
+        logger.debug(f"pds_get_patient_details. nhs_number: {nhs_number}")
 
         cache = Cache(directory=safe_tmp_dir)
         authenticator = AppRestrictedAuth(
@@ -33,6 +34,7 @@ def pds_get_patient_details(nhs_number: str) -> dict:
         else:
             logger.info(f"No patient details found for ID: {nhs_number}")
             return None
-    except Exception:
-        logger.exception(f"Error getting PDS patient details for {nhs_number}")
-        return None
+    except Exception as e:
+        msg = f"Error getting PDS patient details for {nhs_number}"
+        logger.exception(msg)
+        raise IdSyncException(message=msg, exception=e)

lambdas/id_sync/src/pds_details.py

@@ -11,7 +11,7 @@
 
 def process_record(event_record):
 
-    logger.info("Processing record: %s", event_record)
+    logger.info("process_record. Processing record: %s", event_record)
     body_text = event_record.get('body', '')
 
     # convert body to json
@@ -37,6 +37,7 @@ def process_record(event_record):
 
 def process_nhs_number(nhs_number: str) -> Optional[str]:
     # get patient details from PDS
+    logger.debug(f"process_nhs_number. Processing NHS number: {nhs_number}")
     patient_details = pds_get_patient_details(nhs_number)
     if not patient_details:
         return {"status": "error", "message": f"No records returned for ID: {nhs_number}"}

lambdas/id_sync/src/record_processor.py

@@ -5,7 +5,7 @@
 with patch('common.log_decorator.logging_decorator') as mock_decorator:
     mock_decorator.return_value = lambda f: f  # Pass-through decorator
     from id_sync import handler
-    from id_sync import IdSyncException
+    from models.id_sync_exception import IdSyncException
 
 
 class TestIdSyncHandler(unittest.TestCase):
@@ -174,7 +174,7 @@ def test_handler_empty_records(self):
 
         # Assertions
         self.mock_aws_lambda_event.assert_called_once_with(self.empty_event)
-        self.mock_logger.info.assert_called_once_with("No records found in event")
+        self.mock_logger.info.assert_any_call("No records found in event")
         self.mock_process_record.assert_not_called()
 
         self.assertEqual(result["status"], "success")
@@ -192,7 +192,7 @@ def test_handler_no_records_key(self):
 
         # Assertions
         self.mock_aws_lambda_event.assert_called_once_with(self.no_records_event)
-        self.mock_logger.info.assert_called_once_with("No records found in event")
+        self.mock_logger.info.assert_any_call("No records found in event")
         self.mock_process_record.assert_not_called()
 
         self.assertEqual(result["status"], "success")

lambdas/id_sync/tests/test_id_sync.py

@@ -1,6 +1,7 @@
 import unittest
 from unittest.mock import patch, MagicMock
 from pds_details import pds_get_patient_details
+from models.id_sync_exception import IdSyncException
 
 
 class TestGetPdsPatientDetails(unittest.TestCase):
@@ -58,9 +59,6 @@ def test_pds_get_patient_details_success(self):
         # Assert
         self.assertEqual(result, "9912003888")
 
-        # Verify logger was called
-        self.mock_logger.info.assert_called_once_with(f"Get PDS patient details for {self.test_patient_id}")
-
         # Verify Cache was initialized correctly
         self.mock_cache_class.assert_called_once()
 
@@ -79,9 +77,7 @@ def test_pds_get_patient_details_no_patient_found(self):
         self.assertIsNone(result)
 
         # Verify both logger calls
-        self.mock_logger.info.assert_any_call(f"Get PDS patient details for {self.test_patient_id}")
         self.mock_logger.info.assert_any_call(f"No patient details found for ID: {self.test_patient_id}")
-        self.assertEqual(self.mock_logger.info.call_count, 2)
 
         self.mock_pds_service_instance.get_patient_details.assert_called_once_with(self.test_patient_id)
 
@@ -97,13 +93,12 @@ def test_pds_get_patient_details_empty_response(self):
         self.assertIsNone(result)
 
         # Verify both logger calls
-        self.mock_logger.info.assert_any_call(f"Get PDS patient details for {self.test_patient_id}")
         self.mock_logger.info.assert_any_call(f"No patient details found for ID: {self.test_patient_id}")
-        self.assertEqual(self.mock_logger.info.call_count, 2)
 
     def test_pds_get_patient_details_missing_identifier_field(self):
         """Test when PDS response doesn't contain 'identifier' field"""
         # Arrange
+        test_nhs_number = "my-nhs-number"
         patient_data_without_identifier = {
             "name": "John Doe",
             "birthDate": "1990-01-01",
@@ -113,14 +108,18 @@ def test_pds_get_patient_details_missing_identifier_field(self):
         self.mock_pds_service_instance.get_patient_details.return_value = patient_data_without_identifier
 
         # Act
-        result = pds_get_patient_details(self.test_patient_id)
+        with self.assertRaises(IdSyncException) as context:
+            pds_get_patient_details(test_nhs_number)
+
+        exception = context.exception
 
         # Assert
-        self.assertIsNone(result)
+        self.assertEqual(exception.message, f"Error getting PDS patient details for {test_nhs_number}")
+        self.assertEqual(exception.nhs_numbers, None)
 
         # Verify exception was logged
         self.mock_logger.exception.assert_called_once_with(
-            f"Error getting PDS patient details for {self.test_patient_id}")
+            f"Error getting PDS patient details for {test_nhs_number}")
 
     def test_pds_get_patient_details_empty_identifier_array(self):
         """Test when identifier array is empty"""
@@ -132,10 +131,13 @@ def test_pds_get_patient_details_empty_identifier_array(self):
         self.mock_pds_service_instance.get_patient_details.return_value = patient_data_empty_identifier
 
         # Act
-        result = pds_get_patient_details(self.test_patient_id)
+        with self.assertRaises(IdSyncException) as context:
+            pds_get_patient_details(self.test_patient_id)
 
         # Assert
-        self.assertIsNone(result)
+        exception = context.exception
+        self.assertEqual(exception.message, f"Error getting PDS patient details for {self.test_patient_id}")
+        self.assertEqual(exception.nhs_numbers, None)
 
         # Verify exception was logged due to IndexError
         self.mock_logger.exception.assert_called_once_with(
@@ -152,10 +154,14 @@ def test_pds_get_patient_details_identifier_missing_value(self):
         self.mock_pds_service_instance.get_patient_details.return_value = patient_data_missing_value
 
         # Act
-        result = pds_get_patient_details(self.test_patient_id)
+        with self.assertRaises(IdSyncException) as context:
+            pds_get_patient_details(self.test_patient_id)
+
+        exception = context.exception
 
         # Assert
-        self.assertIsNone(result)
+        self.assertEqual(exception.message, f"Error getting PDS patient details for {self.test_patient_id}")
+        self.assertEqual(exception.nhs_numbers, None)
 
         # Verify exception was logged due to KeyError
         self.mock_logger.exception.assert_called_once_with(
@@ -181,13 +187,19 @@ def test_pds_get_patient_details_multiple_identifiers(self):
     def test_pds_get_patient_details_pds_service_exception(self):
         """Test when PdsService.get_patient_details raises an exception"""
         # Arrange
-        self.mock_pds_service_instance.get_patient_details.side_effect = Exception("PDS API error")
+        mock_exception = Exception("My custom error")
+        self.mock_pds_service_instance.get_patient_details.side_effect = mock_exception
 
         # Act
-        result = pds_get_patient_details(self.test_patient_id)
+        with self.assertRaises(IdSyncException) as context:
+            pds_get_patient_details(self.test_patient_id)
+
+        exception = context.exception
 
         # Assert
-        self.assertIsNone(result)
+        self.assertEqual(exception.inner_exception, mock_exception)
+        self.assertEqual(exception.message, f"Error getting PDS patient details for {self.test_patient_id}")
+        self.assertEqual(exception.nhs_numbers, None)
 
         # Verify exception was logged
         self.mock_logger.exception.assert_called_once_with(
@@ -201,10 +213,13 @@ def test_pds_get_patient_details_cache_initialization_error(self):
         self.mock_cache_class.side_effect = OSError("Cannot write to /tmp")
 
         # Act
-        result = pds_get_patient_details(self.test_patient_id)
+        with self.assertRaises(IdSyncException) as context:
+            pds_get_patient_details(self.test_patient_id)
 
         # Assert
-        self.assertIsNone(result)
+        exception = context.exception
+        self.assertEqual(exception.message, f"Error getting PDS patient details for {self.test_patient_id}")
+        self.assertEqual(exception.nhs_numbers, None)
 
         # Verify exception was logged
         self.mock_logger.exception.assert_called_once_with(
@@ -218,37 +233,37 @@ def test_pds_get_patient_details_auth_initialization_error(self):
         self.mock_auth_class.side_effect = ValueError("Invalid authentication parameters")
 
         # Act
-        result = pds_get_patient_details(self.test_patient_id)
+        with self.assertRaises(IdSyncException) as context:
+            pds_get_patient_details(self.test_patient_id)
 
         # Assert
-        self.assertIsNone(result)
+        exception = context.exception
+        self.assertEqual(exception.message, f"Error getting PDS patient details for {self.test_patient_id}")
+        self.assertEqual(exception.nhs_numbers, None)
 
         # Verify exception was logged
         self.mock_logger.exception.assert_called_once_with(
             f"Error getting PDS patient details for {self.test_patient_id}")
 
-    def test_pds_get_patient_details_logger_info_exception(self):
+    def test_pds_get_patient_details_exception(self):
         """Test when logger.info throws an exception"""
         # Arrange
-        self.mock_logger.info.side_effect = Exception("Logging system failure")
+        test_exception = Exception("some-random-error")
+        self.mock_pds_service_class.side_effect = test_exception
+        test_nhs_number = "another-nhs-number"
 
         # Act
-        result = pds_get_patient_details(self.test_patient_id)
+        with self.assertRaises(Exception) as context:
+            pds_get_patient_details(test_nhs_number)
 
+        exception = context.exception
         # Assert
-        self.assertIsNone(result)
-
-        # Verify logger.info was called and raised exception
-        self.mock_logger.info.assert_called_once_with(f"Get PDS patient details for {self.test_patient_id}")
-
+        self.assertEqual(exception.inner_exception, test_exception)
+        self.assertEqual(exception.message, f"Error getting PDS patient details for {test_nhs_number}")
+        self.assertEqual(exception.nhs_numbers, None)
         # Verify logger.exception was called due to the caught exception
         self.mock_logger.exception.assert_called_once_with(
-            f"Error getting PDS patient details for {self.test_patient_id}")
-
-        # Verify that no other services were initialized since exception occurred early
-        self.mock_cache_class.assert_not_called()
-        self.mock_auth_class.assert_not_called()
-        self.mock_pds_service_class.assert_not_called()
+            f"Error getting PDS patient details for {test_nhs_number}")
 
     def test_pds_get_patient_details_different_patient_ids(self):
         """Test with different patient ID formats"""
@@ -272,7 +287,6 @@ def test_pds_get_patient_details_different_patient_ids(self):
 
                 # Assert
                 self.assertEqual(result, patient_id)
-                self.mock_logger.info.assert_called_once_with(f"Get PDS patient details for {patient_id}")
                 self.mock_pds_service_instance.get_patient_details.assert_called_once_with(patient_id)
 
     def test_pds_get_patient_details_service_dependencies(self):