PDS

Author: nhsdevws

immunisation-fhir-api.code-workspace

@@ -1,41 +1,41 @@
 {
 	"folders": [
-        {
-            "path": "."
-        },
-        {
-            "path": "backend"
-        },
-        {
-            "path": "filenameprocessor"
-        },
-        {
-            "path": "recordprocessor"
-        },
-        {
-            "path": "ack_backend"
-        },
-        {
-            "path": "delta_backend"
-        },
-        {
-            "path": "mesh_processor"
-        },
-        {
-            "path": "e2e"
-        },
-        {
-            "path": "e2e_batch"
-        },
-        {
-            "path": "redis_sync"
-        },
-        {
-            "path": "lambdas/id_sync"
-        },
-        {
-            "path": "lambdas/shared"
-        }
-    ],
-	"settings": {},
+		{
+			"path": "."
+		},
+		{
+			"path": "backend"
+		},
+		{
+			"path": "filenameprocessor"
+		},
+		{
+			"path": "recordprocessor"
+		},
+		{
+			"path": "ack_backend"
+		},
+		{
+			"path": "delta_backend"
+		},
+		{
+			"path": "mesh_processor"
+		},
+		{
+			"path": "e2e"
+		},
+		{
+			"path": "e2e_batch"
+		},
+		{
+			"path": "redis_sync"
+		},
+		{
+			"path": "lambdas/id_sync"
+		},
+		{
+			"path": "lambdas/shared"
+		}
+	],
+	"settings": {}
 }

lambdas/id_sync/src/clients.py

@@ -0,0 +1,4 @@
+import os
+
+
+pds_env: str = os.getenv("PDS_ENV", "int")

lambdas/id_sync/src/pds_details.py

@@ -0,0 +1,29 @@
+'''
+    record Processor
+'''
+from common.clients import logger, secrets_manager_client
+from clients import pds_env
+from cache import Cache
+from common.pds_service import PdsService
+from common.authentication import AppRestrictedAuth, Service
+
+
+def get_pds_patient_details(id: str) -> dict:
+    try:
+        logger.info(f"Get PDS patient details for {id}")
+
+        cache = Cache(directory="/tmp")
+        authenticator = AppRestrictedAuth(
+            service=Service.PDS,
+            secret_manager_client=secrets_manager_client,
+            environment=pds_env,
+            cache=cache,
+        )
+        pds_service = PdsService(authenticator, pds_env)
+
+        details = pds_service.get_patient_details(id)
+
+        return details.get("id")
+    except Exception:
+        logger.exception(f"Error getting PDS patient details for {id}")
+        return None

lambdas/id_sync/src/record_processor.py

@@ -39,6 +39,16 @@ def check_records_exist(id: str) -> bool:
 def get_pds_patient_details(id: str) -> dict:
     # TODO: Implement logic to retrieve patient details from PDS
     logger.info(f"TODO Get patient details for {id}")
+
+    authenticator = AppRestrictedAuth(
+        service=Service.PDS,
+        secret_manager_client=boto3.client("secretsmanager", config=boto_config),
+        environment=pds_env,
+        cache=cache,
+    )
+    pds_service = PdsService(authenticator, pds_env)
+
+
     return {"id": id, "name": "Mr Man"}
 
 

lambdas/id_sync/tests/test_pds_details.py

@@ -0,0 +1,171 @@
+import unittest
+from unittest.mock import patch, MagicMock
+from pds_details import get_pds_patient_details
+
+
+class TestGetPdsPatientDetails(unittest.TestCase):
+
+    def setUp(self):
+        """Set up test fixtures and mocks"""
+        # Mock the dependencies
+        self.mock_boto3_client = MagicMock()
+        self.test_patient_id = "9912003888"
+
+        # Patch all external dependencies
+        self.logger_patcher = patch('pds_details.logger')
+        self.mock_logger = self.logger_patcher.start()
+
+        self.secrets_manager_patcher = patch('pds_details.secrets_manager_client')
+        self.mock_secrets_manager = self.secrets_manager_patcher.start()
+
+        self.pds_env_patcher = patch('pds_details.pds_env')
+        self.mock_pds_env = self.pds_env_patcher.start()
+
+        self.cache_patcher = patch('pds_details.Cache')
+        self.mock_cache_class = self.cache_patcher.start()
+        self.mock_cache_instance = MagicMock()
+        self.mock_cache_class.return_value = self.mock_cache_instance
+
+        self.auth_patcher = patch('pds_details.AppRestrictedAuth')
+        self.mock_auth_class = self.auth_patcher.start()
+        self.mock_auth_instance = MagicMock()
+        self.mock_auth_class.return_value = self.mock_auth_instance
+
+        self.pds_service_patcher = patch('pds_details.PdsService')
+        self.mock_pds_service_class = self.pds_service_patcher.start()
+        self.mock_pds_service_instance = MagicMock()
+        self.mock_pds_service_class.return_value = self.mock_pds_service_instance
+
+    def tearDown(self):
+        """Clean up patches"""
+        patch.stopall()
+
+    def test_get_pds_patient_details_success(self):
+        """Test successful retrieval of patient details"""
+        # Arrange
+        expected_patient_data = {
+            "id": "9912003888",
+            "name": "John Doe",
+            "birthDate": "1990-01-01",
+            "gender": "male"
+        }
+        self.mock_pds_service_instance.get_patient_details.return_value = expected_patient_data
+
+        # Act
+        result = get_pds_patient_details(self.test_patient_id, self.mock_boto3_client)
+
+        # Assert
+        self.assertEqual(result, "9912003888")
+
+        # Verify Cache was initialized correctly
+        self.mock_cache_class.assert_called_once_with(directory="/tmp")
+
+        # Verify AppRestrictedAuth was initialized correctly
+        from common.authentication import Service
+        self.mock_auth_class.assert_called_once_with(
+            service=Service.PDS,
+            secret_manager_client=self.mock_secrets_manager,
+            environment=self.mock_pds_env,
+            cache=self.mock_cache_instance
+        )
+
+        # Verify PdsService was initialized correctly
+        self.mock_pds_service_class.assert_called_once_with(
+            self.mock_auth_instance,
+            self.mock_pds_env
+        )
+
+        # Verify get_patient_details was called
+        self.mock_pds_service_instance.get_patient_details.assert_called_once_with(self.test_patient_id)
+
+    def test_get_pds_patient_details_missing_id_in_response(self):
+        """Test when PDS response doesn't contain 'id' field"""
+        # Arrange
+        patient_data_without_id = {
+            "name": "John Doe",
+            "birthDate": "1990-01-01",
+            "gender": "male"
+            # Missing 'id' field
+        }
+        self.mock_pds_service_instance.get_patient_details.return_value = patient_data_without_id
+
+        # Act
+        result = get_pds_patient_details(self.test_patient_id, self.mock_boto3_client)
+
+        # Assert
+        self.assertIsNone(result)
+        self.mock_pds_service_instance.get_patient_details.assert_called_once_with(self.test_patient_id)
+
+    def test_get_pds_patient_details_empty_response(self):
+        """Test when PDS returns empty response"""
+        # Arrange
+        self.mock_pds_service_instance.get_patient_details.return_value = {}
+
+        # Act
+        result = get_pds_patient_details(self.test_patient_id, self.mock_boto3_client)
+
+        # Assert
+        self.assertIsNone(result)
+        self.mock_pds_service_instance.get_patient_details.assert_called_once_with(self.test_patient_id)
+
+    def test_get_pds_patient_details_none_response(self):
+        """Test when PDS returns None"""
+        # Arrange
+        self.mock_pds_service_instance.get_patient_details.return_value = None
+
+        # Act
+        with self.assertRaises(AttributeError):
+            get_pds_patient_details(self.test_patient_id, self.mock_boto3_client)
+
+        # Assert
+        self.mock_pds_service_instance.get_patient_details.assert_called_once_with(self.test_patient_id)
+
+    def test_get_pds_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")
+
+        # Act & Assert
+        with self.assertRaises(Exception) as context:
+            get_pds_patient_details(self.test_patient_id, self.mock_boto3_client)
+
+        self.assertEqual(str(context.exception), "PDS API error")
+        self.mock_pds_service_instance.get_patient_details.assert_called_once_with(self.test_patient_id)
+
+    def test_get_pds_patient_details_cache_initialization_error(self):
+        """Test when Cache initialization fails"""
+        # Arrange
+        self.mock_cache_class.side_effect = OSError("Cannot write to /tmp")
+
+        # Act & Assert
+        with self.assertRaises(OSError) as context:
+            get_pds_patient_details(self.test_patient_id, self.mock_boto3_client)
+
+        self.assertEqual(str(context.exception), "Cannot write to /tmp")
+        self.mock_cache_class.assert_called_once_with(directory="/tmp")
+
+    def test_get_pds_patient_details_auth_initialization_error(self):
+        """Test when AppRestrictedAuth initialization fails"""
+        # Arrange
+        self.mock_auth_class.side_effect = ValueError("Invalid authentication parameters")
+
+        # Act & Assert
+        with self.assertRaises(ValueError) as context:
+            get_pds_patient_details(self.test_patient_id, self.mock_boto3_client)
+
+        self.assertEqual(str(context.exception), "Invalid authentication parameters")
+
+    def test_get_pds_patient_details_exception(self):
+        """Test when an exception occurs"""
+        # Arrange
+        self.mock_logger.info.side_effect = Exception("Logging system failure")
+
+        # Act
+        result = get_pds_patient_details(self.test_patient_id, self.mock_boto3_client)
+
+        # Assert
+        self.assertIsNone(result)
+
+        # 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}")

lambdas/shared/src/common/cache.py

@@ -0,0 +1,34 @@
+import json
+from typing import Optional
+
+
+class Cache:
+    """Key-value file cache"""
+
+    def __init__(self, directory):
+        filename = f"{directory}/cache.json"
+        with open(filename, "a+") as self.cache_file:
+            self.cache_file.seek(0)
+            content = self.cache_file.read()
+        if len(content) == 0:
+            self.cache = {}
+        else:
+            self.cache = json.loads(content)
+
+    def put(self, key: str, value: dict):
+        self.cache[key] = value
+        self._overwrite()
+
+    def get(self, key: str) -> Optional[dict]:
+        return self.cache.get(key, None)
+
+    def delete(self, key: str):
+        if key not in self.cache:
+            return
+        del self.cache[key]
+
+    def _overwrite(self):
+        with open(self.cache_file.name, "w") as self.cache_file:
+            self.cache_file.seek(0)
+            self.cache_file.write(json.dumps(self.cache))
+            self.cache_file.truncate()

lambdas/shared/src/common/clients.py

@@ -1,6 +1,7 @@
 import os
 import logging
 from boto3 import client as boto3_client
+# from botocore.config import Config
 
 
 logging.basicConfig(level="INFO")
@@ -14,3 +15,7 @@
 
 s3_client = boto3_client("s3", region_name=REGION_NAME)
 firehose_client = boto3_client("firehose", region_name=REGION_NAME)
+
+# boto_config = Config(region_name=REGION_NAME)
+# secretsmanager_client = boto3_client("secretsmanager", config=boto_config)
+secrets_manager_client = boto3_client("secretsmanager", region_name=REGION_NAME)

terraform/id_sync_lambda.tf

@@ -3,15 +3,15 @@ locals {
   lambdas_dir            = abspath("${path.root}/../lambdas")
   shared_dir             = abspath("${path.root}/../lambdas/shared")
   id_sync_lambda_dir     = abspath("${path.root}/../lambdas/id_sync")
-  
+
   # Get files from both directories
   shared_files           = fileset(local.shared_dir, "**")
   id_sync_lambda_files   = fileset(local.id_sync_lambda_dir, "**")
-  
+
   # Calculate SHA for both directories
   shared_dir_sha         = sha1(join("", [for f in local.shared_files : filesha1("${local.shared_dir}/${f}")]))
   id_sync_lambda_dir_sha = sha1(join("", [for f in local.id_sync_lambda_files : filesha1("${local.id_sync_lambda_dir}/${f}")]))
-  
+
   # Combined SHA to trigger rebuild when either directory changes
   combined_sha           = sha1("${local.shared_dir_sha}${local.id_sync_lambda_dir_sha}")
 }
@@ -303,6 +303,7 @@ resource "aws_lambda_function" "id_sync_lambda" {
     variables = {
       ID_SYNC_PROC_LAMBDA_NAME = "imms-${local.env}-id_sync_lambda"
       SPLUNK_FIREHOSE_NAME        = module.splunk.firehose_stream_name
+      PDS_ENV                     = local.environment == "prod" ? "prod" : local.environment == "ref" ? "ref" : "int"
     }
   }
   kms_key_arn = data.aws_kms_key.existing_lambda_encryption_key.arn
@@ -322,11 +323,11 @@ resource "aws_cloudwatch_log_group" "id_sync_log_group" {
 resource "aws_lambda_event_source_mapping" "id_sync_sqs_trigger" {
   event_source_arn = data.aws_sqs_queue.existing_sqs_queue.arn
   function_name    = aws_lambda_function.id_sync_lambda.arn
-  
+
   # Optional: Configure batch size and other settings
   batch_size                         = 10
   maximum_batching_window_in_seconds = 5
-  
+
   # Optional: Configure error handling
   function_response_types = ["ReportBatchItemFailures"]
-}
+}