Merge pull request #49 from NHSDigital/AMB-1728_use_fhir_resources_in_imms_get

ewan-IW · web-flow · commit 349fcf2df25d · 2023-11-16T09:39:19.000Z
Amb 1728 use fhir resources in imms get
diff --git a/lambda_code/Makefile b/lambda_code/Makefile
@@ -6,6 +6,6 @@ package: build
 	docker run --rm -v $(shell pwd)/build:/build imms-lambda-build
 
 test:
-	DYNAMODB_TABLE_NAME=example-table python -m unittest
+	python -m unittest
 
 .PHONY: build package test
diff --git a/lambda_code/requirements.txt b/lambda_code/requirements.txt
@@ -3,3 +3,4 @@ boto3==1.28.68
 moto
 requests
 responses
+pydantic
diff --git a/lambda_code/src/dynamodb.py b/lambda_code/src/dynamodb.py
@@ -6,12 +6,13 @@
 
 
 class EventTable:
-    def __init__(self, table_name=os.environ["DYNAMODB_TABLE_NAME"], endpoint_url=None):
+    def __init__(self, table_name=None, endpoint_url=None):
+        if not table_name:
+            table_name = os.environ["DYNAMODB_TABLE_NAME"]
         db = boto3.resource("dynamodb", endpoint_url=endpoint_url, region_name='eu-west-2')
         self.table = db.Table(table_name)
 
     def get_event_by_id(self, event_id):
-        # TODO: the main index doesn't need sort-key. You can use get_item instead of query
         response = self.table.get_item(Key={"PK": event_id})
 
         if "Item" in response:
diff --git a/lambda_code/src/fhir_controller.py b/lambda_code/src/fhir_controller.py
@@ -0,0 +1,43 @@
+import json
+import re
+import uuid
+
+from fhir_service import FhirService
+from models.errors import Severity, Code, create_operation_outcome
+
+
+class FhirController:
+    immunisation_id_pattern = r"^[A-Za-z0-9\-.]{1,64}$"
+
+    def __init__(self, fhir_service: FhirService):
+        self.fhir_service = fhir_service
+
+    def get_immunisation_by_id(self, aws_event) -> dict:
+        imms_id = aws_event["pathParameters"]["id"]
+
+        if not re.match(self.immunisation_id_pattern, imms_id):
+            msg = "the provided event ID is either missing or not in the expected format."
+            api_error = create_operation_outcome(resource_id=str(uuid.uuid4()), severity=Severity.error,
+                                                 code=Code.invalid,
+                                                 diagnostics=msg)
+            return FhirController.create_response(400, json.dumps(api_error.dict()))
+
+        resource = self.fhir_service.get_immunisation_by_id(imms_id)
+        if resource:
+            return FhirController.create_response(200, resource.json())
+        else:
+            msg = "The requested resource was not found."
+            api_error = create_operation_outcome(resource_id=str(uuid.uuid4()), severity=Severity.error,
+                                                 code=Code.not_found,
+                                                 diagnostics=msg)
+            return FhirController.create_response(404, json.dumps(api_error.dict()))
+
+    @staticmethod
+    def create_response(status_code, body):
+        return {
+            "statusCode": status_code,
+            "headers": {
+                "Content-Type": "application/fhir+json",
+            },
+            "body": body
+        }
diff --git a/lambda_code/src/fhir_repository.py b/lambda_code/src/fhir_repository.py
@@ -0,0 +1,23 @@
+import json
+import os
+from typing import Optional
+
+import boto3
+
+
+class FhirRepository:
+    def __init__(self, table_name=None, endpoint_url=None):
+        if not table_name:
+            table_name = os.environ["DYNAMODB_TABLE_NAME"]
+        db = boto3.resource("dynamodb", endpoint_url=endpoint_url, region_name='eu-west-2')
+        self.table = db.Table(table_name)
+
+
+class ImmunisationRepository(FhirRepository):
+    def get_immunisation_by_id(self, imms_id: str) -> Optional[dict]:
+        response = self.table.get_item(Key={"PK": imms_id})
+
+        if "Item" in response:
+            return json.loads(response["Item"]["Event"])
+        else:
+            return None
diff --git a/lambda_code/src/fhir_service.py b/lambda_code/src/fhir_service.py
@@ -0,0 +1,20 @@
+from typing import Optional
+
+from fhir.resources.immunization import Immunization
+
+from fhir_repository import ImmunisationRepository
+
+
+class FhirService:
+
+    def __init__(self, imms_repo: ImmunisationRepository):
+        self.immunisation_repo = imms_repo
+
+    def get_immunisation_by_id(self, imms_id: str) -> Optional[Immunization]:
+        imms = self.immunisation_repo.get_immunisation_by_id(imms_id)
+        if imms:
+            # TODO: This shouldn't raise an exception since, we validate the message before storing it,
+            #  but what if the stored message is different from the requested FHIR version?
+            return Immunization.parse_obj(imms)
+        else:
+            return None
diff --git a/lambda_code/src/get_imms_handler.py b/lambda_code/src/get_imms_handler.py
@@ -1,77 +1,24 @@
 import uuid
 
-from dynamodb import EventTable
-import json
-import re
-
-
-def create_response(event_id, message, code):
-    return {
-        "resourceType": "OperationOutcome",
-        "id": event_id,
-        "meta": {
-            "profile": [
-                "https://simplifier.net/guide/UKCoreDevelopment2/ProfileUKCore-OperationOutcome"
-            ]
-        },
-        "issue": [
-            {
-                "severity": "error",
-                "code": code,
-                "details": {
-                    "coding": [
-                        {
-                            "system": "https://fhir.nhs.uk/Codesystem/http-error-codes",
-                            "code": code.upper()
-                        }
-                    ]
-                },
-                "diagnostics": message
-            }
-        ]
-    }
+from fhir_controller import FhirController
+from fhir_repository import ImmunisationRepository
+from fhir_service import FhirService
+from models.errors import Severity, Code, create_operation_outcome
 
 
 def get_imms_handler(event, context):
-    dynamo_service = EventTable()
-    return get_imms(event, dynamo_service)
-
-
-# create function which receives event and instance of dynamodb
-def get_imms(event, dynamo_service):
-    event_id = event["pathParameters"]["id"]
-
-    def is_valid_id(_event_id):
-        pattern = r'^[A-Za-z0-9\-.]{1,64}$'
-        return re.match(pattern, _event_id) is not None
-
-    if not is_valid_id(event_id) or not event_id:
-        return {
-            "statusCode": 400,
-            "headers": {
-                "Content-Type": "application/fhir+json",
-            },
-            "body": json.dumps(
-                create_response(str(uuid.uuid4()),
-                                "he provided event ID is either missing or not in the expected format.",
-                                "invalid"))
-        }
+    imms_repo = ImmunisationRepository()
+    service = FhirService(imms_repo=imms_repo)
+    controller = FhirController(fhir_service=service)
 
-    message = dynamo_service.get_event_by_id(event_id)
-    if message is None:
+    return get_immunisation_by_id(event, controller)
 
-        return {
-            "statusCode": 404,
-            "headers": {
-                "Content-Type": "application/fhir+json",
-            },
-            "body": json.dumps(create_response(str(uuid.uuid4()), "The requested resource was not found.", "not-found"))
-        }
 
-    return {
-        'statusCode': 200,
-        "headers": {
-            "Content-Type": "application/fhir+json",
-        },
-        'body': json.dumps(message)
-    }
+def get_immunisation_by_id(event, controller: FhirController):
+    try:
+        return controller.get_immunisation_by_id(event)
+    except Exception as e:
+        exp_error = create_operation_outcome(resource_id=str(uuid.uuid4()), severity=Severity.error,
+                                             code=Code.not_found,
+                                             diagnostics=str(e))
+        return FhirController.create_response(500, exp_error.json())
diff --git a/lambda_code/src/models/errors.py b/lambda_code/src/models/errors.py
@@ -0,0 +1,40 @@
+from enum import Enum
+
+from fhir.resources.operationoutcome import OperationOutcome
+
+
+class Severity(str, Enum):
+    error = "error"
+
+
+class Code(str, Enum):
+    not_found = "not-found"
+    invalid = "invalid"
+
+
+def create_operation_outcome(resource_id: str, severity: Severity, code: Code, diagnostics: str) -> OperationOutcome:
+    model = {
+        "resourceType": "OperationOutcome",
+        "id": resource_id,
+        "meta": {
+            "profile": [
+                "https://simplifier.net/guide/UKCoreDevelopment2/ProfileUKCore-OperationOutcome"
+            ]
+        },
+        "issue": [
+            {
+                "severity": severity,
+                "code": code,
+                "details": {
+                    "coding": [
+                        {
+                            "system": "https://fhir.nhs.uk/Codesystem/http-error-codes",
+                            "code": code.upper()
+                        }
+                    ]
+                },
+                "diagnostics": diagnostics
+            }
+        ]
+    }
+    return OperationOutcome.parse_obj(model)
diff --git a/lambda_code/src/requirements.txt b/lambda_code/src/requirements.txt
@@ -1,3 +1,4 @@
 fhir.resources==7.0.2
 boto3==1.28.68
 requests
+pydantic
diff --git a/lambda_code/tests/test_api_errors.py b/lambda_code/tests/test_api_errors.py
@@ -0,0 +1,25 @@
+import os
+import sys
+import unittest
+
+sys.path.append(f"{os.path.dirname(os.path.abspath(__file__))}/../src")
+
+from models.errors import Severity, Code, create_operation_outcome
+
+
+class TestApiErrors(unittest.TestCase):
+    def test_error_to_uk_core2(self):
+        code = Code.not_found
+
+        severity = Severity.error
+        diag = "a-diagnostic"
+        error_id = "a-id"
+
+        error = create_operation_outcome(resource_id=error_id, severity=severity, code=code, diagnostics=diag).dict()
+
+        issue = error["issue"][0]
+        self.assertEqual(error["id"], error_id)
+        self.assertEqual(issue["code"], "not-found")
+        self.assertEqual(issue["severity"], "error")
+        self.assertEqual(issue["diagnostics"], diag)
+        self.assertEqual(issue["details"]["coding"][0]["code"], "NOT-FOUND")
diff --git a/lambda_code/tests/test_fhir_controller.py b/lambda_code/tests/test_fhir_controller.py
@@ -0,0 +1,81 @@
+import json
+import os
+import sys
+import unittest
+from unittest.mock import create_autospec
+
+from fhir.resources.immunization import Immunization
+
+sys.path.append(f"{os.path.dirname(os.path.abspath(__file__))}/../src")
+
+from fhir_controller import FhirController
+from fhir_service import FhirService
+
+
+class TestFhirController(unittest.TestCase):
+    def setUp(self):
+        self.service = create_autospec(FhirService)
+        self.controller = FhirController(self.service)
+
+    def test_create_response(self):
+        """it should return application/fhir+json with correct status code"""
+        res = self.controller.create_response(42, "a body")
+        headers = res["headers"]
+
+        self.assertEqual(res["statusCode"], 42)
+        self.assertDictEqual(headers, {
+            "Content-Type": "application/fhir+json",
+        })
+        self.assertEqual(res["body"], "a body")
+
+
+class TestFhirControllerGetImmunisationById(unittest.TestCase):
+    def setUp(self):
+        self.service = create_autospec(FhirService)
+        self.controller = FhirController(self.service)
+
+    def test_get_imms_by_id(self):
+        """it should return Immunization resource if it exists"""
+        # Given
+        imms_id = "a-id"
+        self.service.get_immunisation_by_id.return_value = Immunization.construct()
+        lambda_event = {"pathParameters": {"id": imms_id}}
+
+        # When
+        response = self.controller.get_immunisation_by_id(lambda_event)
+
+        # Then
+        self.service.get_immunisation_by_id.assert_called_once_with(imms_id)
+
+        self.assertEqual(response["statusCode"], 200)
+        body = json.loads(response["body"])
+        self.assertEqual(body["resourceType"], "Immunization")
+
+    def test_not_found(self):
+        """it should return not-found OperationOutcome if it doesn't exist"""
+        # Given
+        imms_id = "a-non-existing-id"
+        self.service.get_immunisation_by_id.return_value = None
+        lambda_event = {"pathParameters": {"id": imms_id}}
+
+        # When
+        response = self.controller.get_immunisation_by_id(lambda_event)
+
+        # Then
+        self.service.get_immunisation_by_id.assert_called_once_with(imms_id)
+
+        self.assertEqual(response["statusCode"], 404)
+        body = json.loads(response["body"])
+        self.assertEqual(body["resourceType"], "OperationOutcome")
+        self.assertEqual(body["issue"][0]["code"], "not-found")
+
+    def test_validate_imms_id(self):
+        """it should validate lambda's immunisation id"""
+        invalid_id = {"pathParameters": {"id": "invalid %$ id"}}
+
+        response = self.controller.get_immunisation_by_id(invalid_id)
+
+        self.assertEqual(self.service.get_immunisation_by_id.call_count, 0)
+        self.assertEqual(response["statusCode"], 400)
+        outcome = json.loads(response["body"])
+        self.assertEqual(outcome["resourceType"], "OperationOutcome")
diff --git a/lambda_code/tests/test_fhir_repository.py b/lambda_code/tests/test_fhir_repository.py
@@ -0,0 +1,16 @@
+import os
+import sys
+import unittest
+
+sys.path.append(f"{os.path.dirname(os.path.abspath(__file__))}/../src")
+
+from fhir_repository import ImmunisationRepository
+
+
+class TestImmunisationRepository(unittest.TestCase):
+    def setUp(self):
+        self.repository = ImmunisationRepository(table_name="a-table")
+
+    def test_get_immunisation_by_id(self):
+        """it should find an Immunization by id"""
+        pass
diff --git a/lambda_code/tests/test_fhir_service.py b/lambda_code/tests/test_fhir_service.py
diff --git a/lambda_code/tests/test_get_imms.py b/lambda_code/tests/test_get_imms.py
diff --git a/lambda_code/tests/test_immunisation_api.py b/lambda_code/tests/test_immunisation_api.py
diff --git a/tests/test_immunisation_api.py b/tests/test_immunisation_api.py
