eip

Author: nhsdevws

lambdas/id_sync/src/pds_details.py

@@ -31,16 +31,29 @@ def pds_get_patient_details(nhs_number: str) -> dict:
         logger.info("SAW...4")
         patient = pds_service.get_patient_details(nhs_number)
         logger.info("SAW...5")
-        logger.info("SAW...5.1 check Patient details")
-        if patient:
-            logger.info(f"Patient details found for NHS number: {nhs_number}")
-            logger.info(f"Patient details: {patient}")
-            pds_nhs_number = patient["identifier"][0]["value"]
-            return pds_nhs_number
-        else:
-            logger.info(f"No patient details found for ID: {nhs_number}")
-            return None
+        return patient
     except Exception as e:
         msg = f"Error getting PDS patient details for {nhs_number}"
         logger.exception(msg)
         raise IdSyncException(message=msg, exception=e)
+
+
+def pds_get_patient_id(nhs_number: str) -> str:
+    """
+    Get PDS patient ID from NHS number.
+    :param nhs_number: NHS number of the patient
+    :return: PDS patient ID
+    """
+    try:
+        logger.info(f"get_pds_patient_id. nhs_number: {nhs_number}")
+        patient_details = pds_get_patient_details(nhs_number)
+        if not patient_details:
+            return None
+
+        return patient_details["identifier"][0]["value"]
+
+    # ✅ Remove the IdSyncException catch since you're just re-raising
+    except Exception as e:
+        msg = f"Error getting PDS patient ID for {nhs_number}"
+        logger.exception(msg)
+        raise IdSyncException(message=msg, exception=e)

lambdas/id_sync/src/record_processor.py

@@ -3,7 +3,7 @@
 '''
 from common.clients import logger
 from typing import Optional
-from pds_details import pds_get_patient_details
+from pds_details import pds_get_patient_id
 from ieds_db_operations import ieds_check_exist, ieds_update_patient_id
 import json
 import ast
@@ -38,19 +38,11 @@ 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)
-    logger.info(f"process_nhs_number. Patient details: {patient_details}")
-    if not patient_details:
-        return {"status": "error", "message": f"No records returned for ID: {nhs_number}"}
-
-    logger.info(f"process_nhs_number.get ID: from {patient_details.get('id')}")
-    if patient_details and "identifier" in patient_details and patient_details["identifier"]:
-        patient_details_id = patient_details["identifier"][0]["value"]
-    else:
-        return {"status": "error", "message": f"No records returned for ID: {nhs_number}"}
+    patient_details_id = pds_get_patient_id(nhs_number)
 
     base_log_data = {"nhs_number": nhs_number}
     if patient_details_id:
+        logger.info(f"process_nhs_number. Patient details ID: {patient_details_id}")
         # if patient NHS != id, update patient index of vax events to new number
         if patient_details_id != nhs_number and patient_details_id:
             if ieds_check_exist(patient_details_id):
@@ -60,6 +52,6 @@ def process_nhs_number(nhs_number: str) -> Optional[str]:
         else:
             return {"status": "success", "message": "No update required"}
     else:
-        response = {"status": "error", "message": f"No patient ID found for NHS number: {nhs_number}"}
+        response = {"status": "success", "message": f"No patient ID found for NHS number: {nhs_number}"}
     response.update(base_log_data)
     return response

lambdas/id_sync/tests/test_pds_details.py

@@ -1,6 +1,6 @@
 import unittest
 from unittest.mock import patch, MagicMock
-from pds_details import pds_get_patient_details
+from pds_details import pds_get_patient_details, pds_get_patient_id
 from models.id_sync_exception import IdSyncException
 
 
@@ -57,7 +57,7 @@ def test_pds_get_patient_details_success(self):
         result = pds_get_patient_details(self.test_patient_id)
 
         # Assert
-        self.assertEqual(result, "9912003888")
+        self.assertEqual(result["identifier"][0]["value"], "9912003888")
 
         # Verify Cache was initialized correctly
         self.mock_cache_class.assert_called_once()
@@ -76,114 +76,19 @@ def test_pds_get_patient_details_no_patient_found(self):
         # Assert
         self.assertIsNone(result)
 
-        # Verify both logger calls
-        self.mock_logger.info.assert_any_call(f"No patient details found for ID: {self.test_patient_id}")
-
         self.mock_pds_service_instance.get_patient_details.assert_called_once_with(self.test_patient_id)
 
     def test_pds_get_patient_details_empty_response(self):
         """Test when PDS returns empty dict (falsy)"""
         # Arrange
-        self.mock_pds_service_instance.get_patient_details.return_value = {}
+        self.mock_pds_service_instance.get_patient_details.return_value = None
 
         # Act
         result = pds_get_patient_details(self.test_patient_id)
 
         # Assert
         self.assertIsNone(result)
 
-        # Verify both logger calls
-        self.mock_logger.info.assert_any_call(f"No patient details found for ID: {self.test_patient_id}")
-
-    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",
-            "gender": "male"
-            # Missing 'identifier' field
-        }
-        self.mock_pds_service_instance.get_patient_details.return_value = patient_data_without_identifier
-
-        # Act
-        with self.assertRaises(IdSyncException) as context:
-            pds_get_patient_details(test_nhs_number)
-
-        exception = context.exception
-
-        # Assert
-        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 {test_nhs_number}")
-
-    def test_pds_get_patient_details_empty_identifier_array(self):
-        """Test when identifier array is empty"""
-        # Arrange
-        patient_data_empty_identifier = {
-            "identifier": [],  # Empty array
-            "name": "John Doe"
-        }
-        self.mock_pds_service_instance.get_patient_details.return_value = patient_data_empty_identifier
-
-        # Act
-        with self.assertRaises(IdSyncException) as context:
-            pds_get_patient_details(self.test_patient_id)
-
-        # Assert
-        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(
-            f"Error getting PDS patient details for {self.test_patient_id}")
-
-    def test_pds_get_patient_details_identifier_missing_value(self):
-        """Test when identifier object doesn't have 'value' field"""
-        # Arrange
-        patient_data_missing_value = {
-            "identifier": [
-                {"system": "https://fhir.nhs.uk/Id/nhs-number"}  # Missing 'value'
-            ]
-        }
-        self.mock_pds_service_instance.get_patient_details.return_value = patient_data_missing_value
-
-        # Act
-        with self.assertRaises(IdSyncException) as context:
-            pds_get_patient_details(self.test_patient_id)
-
-        exception = context.exception
-
-        # Assert
-        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(
-            f"Error getting PDS patient details for {self.test_patient_id}")
-
-    def test_pds_get_patient_details_multiple_identifiers(self):
-        """Test when patient has multiple identifiers - should return first one"""
-        # Arrange
-        patient_data_multiple_identifiers = {
-            "identifier": [
-                {"value": "9912003888"},  # First identifier
-                {"value": "9912003999"}   # Second identifier
-            ]
-        }
-        self.mock_pds_service_instance.get_patient_details.return_value = patient_data_multiple_identifiers
-
-        # Act
-        result = pds_get_patient_details(self.test_patient_id)
-
-        # Assert
-        self.assertEqual(result, "9912003888")  # Should return first identifier
-
     def test_pds_get_patient_details_pds_service_exception(self):
         """Test when PdsService.get_patient_details raises an exception"""
         # Arrange
@@ -286,7 +191,7 @@ def test_pds_get_patient_details_different_patient_ids(self):
                 result = pds_get_patient_details(patient_id)
 
                 # Assert
-                self.assertEqual(result, patient_id)
+                self.assertEqual(result, test_cases[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):
@@ -299,7 +204,7 @@ def test_pds_get_patient_details_service_dependencies(self):
         result = pds_get_patient_details(self.test_patient_id)
 
         # Assert service initialization order and parameters
-        self.assertEqual(result, "9912003888")
+        self.assertEqual(result["identifier"][0]["value"], "9912003888")
 
         # Verify initialization order by checking call counts
         self.assertEqual(self.mock_cache_class.call_count, 1)
@@ -315,15 +220,60 @@ def test_pds_get_patient_details(self):
         # Arrange
         test_nhs_number = "9912003888"
         pds_id = "abcefghijkl"
-        self.mock_pds_service_instance.get_patient_details.return_value = {"identifier": [{"value": pds_id}]}
-
+        mock_pds_response = {"identifier": [{"value": pds_id}]}
+        self.mock_pds_service_instance.get_patient_details.return_value = mock_pds_response
         # Act
         result = pds_get_patient_details(test_nhs_number)
 
         # Assert - function should extract the value from first identifier
-        self.assertEqual(result, pds_id)
+        self.assertEqual(result, mock_pds_response)
         self.mock_pds_service_instance.get_patient_details.assert_called_once_with(test_nhs_number)
 
 
-if __name__ == '__main__':
-    unittest.main()
+# test pds_get_patient_id function
+class TestGetPdsPatientId(unittest.TestCase):
+    def setUp(self):
+        """Set up test fixtures and mocks"""
+        self.test_nhs_number = "9912003888"
+
+        # Patch all external dependencies
+        self.logger_patcher = patch('pds_details.logger')
+        self.mock_logger = self.logger_patcher.start()
+
+        self.pds_get_patient_details_patcher = patch('pds_details.pds_get_patient_details')
+        self.mock_pds_get_patient_details = self.pds_get_patient_details_patcher.start()
+
+    def tearDown(self):
+        """Clean up patches"""
+        patch.stopall()
+
+    def test_pds_get_patient_id_success(self):
+        """Test successful retrieval of PDS patient ID"""
+        # Arrange
+        expected_id = "1234567890"
+        self.mock_pds_get_patient_details.return_value = {"identifier": [{"value": expected_id}]}
+
+        # Act
+        result = pds_get_patient_id(self.test_nhs_number)
+
+        # Assert
+        self.assertEqual(result, expected_id)
+
+    def test_pds_get_patient_id_empty_identifier_array(self):
+        """Test when identifier array is empty"""
+        # Arrange
+        patient_data_empty_identifier = {
+            "identifier": [],  # Empty array
+            "name": "John Doe"
+        }
+        self.mock_pds_get_patient_details.return_value = patient_data_empty_identifier
+
+        # Act
+        with self.assertRaises(IdSyncException) as context:
+            pds_get_patient_id(self.test_nhs_number)
+
+        # Assert
+        exception = context.exception
+        self.assertEqual(exception.message, f"Error getting PDS patient ID for {self.test_nhs_number}")
+        self.assertEqual(exception.nhs_numbers, None)
+

lambdas/id_sync/tests/test_record_processor.py

@@ -12,8 +12,8 @@ def setUp(self):
         self.mock_logger = self.logger_patcher.start()
 
         # Mock external dependencies
-        self.pds_get_patient_details_patcher = patch('record_processor.pds_get_patient_details')
-        self.mock_pds_get_patient_details = self.pds_get_patient_details_patcher.start()
+        self.pds_get_patient_id_patcher = patch('record_processor.pds_get_patient_id')
+        self.mock_pds_get_patient_id = self.pds_get_patient_id_patcher.start()
 
         # mock record_processor.ieds_check_exist
         self.ieds_check_exist_patcher = patch('record_processor.ieds_check_exist')
@@ -33,7 +33,7 @@ def test_process_record_success_no_update_required(self):
         with patch('record_processor.ieds_check_exist', return_value=True):
 
             test_record = {"body": {"subject": test_id}}
-            self.mock_pds_get_patient_details.return_value = {"identifier": [{"value": test_id}]}
+            self.mock_pds_get_patient_id.return_value = test_id
 
             # Act
             result = process_record(test_record)
@@ -43,7 +43,7 @@ def test_process_record_success_no_update_required(self):
             self.assertEqual(result, expected_result)
 
             # Verify calls
-            self.mock_pds_get_patient_details.assert_called_once_with(test_id)
+            self.mock_pds_get_patient_id.assert_called_once_with(test_id)
 
     def test_process_record_success_update_required(self):
         """Test successful processing when patient ID differs"""
@@ -52,7 +52,7 @@ def test_process_record_success_update_required(self):
         nhs_number = "nhs-number-1"
 
         test_sqs_record = {"body": {"subject": nhs_number}}
-        self.mock_pds_get_patient_details.return_value = {"identifier": [{"value": pds_id}]}
+        self.mock_pds_get_patient_id.return_value = pds_id
         success_response = {"status": "success"}
         self.mock_ieds_update_patient_id.return_value = success_response
         # Act
@@ -63,7 +63,7 @@ def test_process_record_success_update_required(self):
         self.assertEqual(result, expected_result)
 
         # Verify calls
-        self.mock_pds_get_patient_details.assert_called_once_with(nhs_number)
+        self.mock_pds_get_patient_id.assert_called_once_with(nhs_number)
 
     def test_process_record_no_records_exist(self):
         """Test when no records exist for the patient ID"""
@@ -81,18 +81,18 @@ def test_process_record_no_records_exist(self):
             self.assertEqual(result["message"], f"No records returned for ID: {test_id}")
 
             # Verify PDS was not called
-            self.mock_pds_get_patient_details.assert_called_once()
+            self.mock_pds_get_patient_id.assert_called_once()
 
     def test_process_record_pds_returns_none_id(self):
         """Test when PDS returns none """
         # Arrange
         test_id = "12345a"
-        self.mock_pds_get_patient_details.return_value = {}
+        self.mock_pds_get_patient_id.return_value = None
         test_record = {"body": {"subject": test_id}}
         # Act & Assert
         result = process_record(test_record)
-        expected_result = {"status": "error", "message": f"No records returned for ID: {test_id}"}
-        self.assertEqual(result, expected_result)
+        self.assertEqual(result["status"], "success")
+        self.assertEqual(result["message"], f"No patient ID found for NHS number: {test_id}")
         self.mock_ieds_check_exist.assert_not_called()
         self.mock_ieds_update_patient_id.assert_not_called()
 
@@ -101,7 +101,7 @@ def test_process_record_ieds_returns_false(self):
         # Arrange
         test_id = "12345a"
         pds_id = "pds-id-1"
-        self.mock_pds_get_patient_details.return_value = {"id": pds_id}
+        self.mock_pds_get_patient_id.return_value = pds_id
         self.mock_ieds_check_exist.return_value = False
         # Act & Assert
         result = process_record({"body": {"subject": test_id}})
@@ -114,7 +114,7 @@ def test_body_is_string(self):
         test_record = {"body": "{'subject': 'nhs-number-1'}"}
         new_test_id = "nhs-number-2"
 
-        self.mock_pds_get_patient_details.return_value = {"identifier": [{"value": new_test_id}]}
+        self.mock_pds_get_patient_id.return_value = new_test_id
         self.mock_ieds_update_patient_id.return_value = {"status": "success"}
         # Act
         result = process_record(test_record)