AMB-1741 add controller->service->repository pattern

Author: artronics

lambda_code/src/dynamodb.py

@@ -13,7 +13,6 @@ def __init__(self, table_name=None, endpoint_url=None):
         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:

lambda_code/src/fhir_controller.py

@@ -1,22 +1,34 @@
-from dataclasses import dataclass
+import json
+import re
+import uuid
 
-from fhir.resources.resource import Resource
-
-
-@dataclass
-class FhirResponse:
-    headers: dict
-    body: Resource
-    status_code: int
+from fhir_service import FhirService
+from models.errors import ApiError, Severity, Code
 
 
 class FhirController:
+    immunisation_id_pattern = r"^[A-Za-z0-9\-.]{1,64}$"
 
-    def __init__(self, fhir_service):
+    def __init__(self, fhir_service: FhirService):
         self.fhir_service = fhir_service
 
-    def get_immunisation_by_id(self, aws_event) -> FhirResponse:
-        pass
+    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):
+            api_error = ApiError(id=str(uuid.uuid4()), severity=Severity.error, code=Code.invalid,
+                                 diagnostics="the provided event ID is either missing or not in the expected format.")
+            res_body = api_error.to_uk_core().dict()
+            return FhirController._create_response(400, json.dumps(res_body))
+
+        resource = self.fhir_service.get_immunisation_by_id(imms_id)
+        if resource:
+            return FhirController._create_response(200, resource.json())
+        else:
+            api_error = ApiError(id=str(uuid.uuid4()), severity=Severity.error, code=Code.not_found,
+                                 diagnostics="The requested resource was not found.")
+            res_body = api_error.to_uk_core().dict()
+            return FhirController._create_response(404, json.dumps(res_body))
 
     @staticmethod
     def _create_response(status_code, body):

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

lambda_code/src/fhir_service.py

@@ -1,2 +1,15 @@
+from typing import Optional
+
+from fhir.resources.immunization import Immunization
+
+from fhir_repository import ImmunisationRepository
+
+
 class FhirService:
-    pass
+
+    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)
+        return Immunization.parse_obj(imms)

lambda_code/src/get_imms_handler.py

@@ -49,7 +49,7 @@ def is_valid_id(_event_id):
     if not is_valid_id(event_id) or not event_id:
         body = json.dumps(
             create_operation_outcome(str(uuid.uuid4()),
-                                     "he provided event ID is either missing or not in the expected format.",
+                                     "the provided event ID is either missing or not in the expected format.",
                                      "invalid"))
         return FhirController._create_response(400, body)
 

lambda_code/src/models/errors.py

@@ -9,7 +9,8 @@ class Severity(str, Enum):
 
 
 class Code(str, Enum):
-    not_found = "not_found"
+    not_found = "not-found"
+    invalid = "invalid"
 
 
 class ApiError(BaseModel, use_enum_values=True):

lambda_code/tests/test_api_errors.py

@@ -4,7 +4,7 @@
 
 sys.path.append(f"{os.path.dirname(os.path.abspath(__file__))}/../src")
 
-from models.errors import  ApiError, Severity, Code
+from models.errors import ApiError, Severity, Code
 
 
 class TestApiErrors(unittest.TestCase):
@@ -23,5 +23,3 @@ def test_error_to_uk_core(self):
         self.assertEqual(issue["severity"], "error")
         self.assertEqual(issue["diagnostics"], diag)
         self.assertEqual(issue["details"]["coding"][0]["code"], "NOT_FOUND")
-
-

lambda_code/tests/test_fhir_controller.py

@@ -1,8 +1,11 @@
+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
@@ -23,4 +26,56 @@ def test_create_response(self):
         self.assertDictEqual(headers, {
             "Content-Type": "application/fhir+json",
         })
-        self.assertEqual(res["body"], "a bodys")
+        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")

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

lambda_code/tests/test_fhir_service.py

@@ -0,0 +1,62 @@
+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_repository import ImmunisationRepository
+from fhir_service import FhirService
+
+
+class TestFhirService(unittest.TestCase):
+    def setUp(self):
+        self.imms_repo = create_autospec(ImmunisationRepository)
+        self.fhir_service = FhirService(self.imms_repo)
+
+    def test_get_immunisation_by_id(self):
+        """it should find an Immunization by id"""
+        imms_id = "a-id"
+
+        self.imms_repo.get_immunisation_by_id.return_value = self._create_an_immunisation_obj(imms_id).dict()
+
+        # When
+        act_imms = self.fhir_service.get_immunisation_by_id(imms_id)
+
+        # Then
+        self.imms_repo.get_immunisation_by_id.assert_called_once_with(imms_id)
+        self.assertEqual(act_imms.id, imms_id)
+
+    @staticmethod
+    def _create_an_immunisation_obj(imms_id) -> Immunization:
+        base_imms = {
+            "resourceType": "Immunization",
+            "id": imms_id,
+            "identifier": [
+                {
+                    "system": "https://supplierABC/ODSCode",
+                    "value": imms_id
+                }
+            ],
+            "status": "completed",
+            "occurrenceDateTime": "2020-12-14T10:08:15+00:00",
+            "patient": {
+                "reference": "urn:uuid:124fcb63-669c-4a3c-af2b-caf55de167ec",
+                "type": "Patient",
+                "identifier": {
+                    "system": "https://fhir.nhs.uk/Id/nhs-number",
+                    "value": "9000000009"
+                }
+            },
+            "vaccineCode": {
+                "coding": [{
+                    "system": "http://snomed.info/sct",
+                    "code": "39114911000001105",
+                    "display": "some text"
+                }]
+            },
+        }
+        return Immunization.parse_obj(base_imms)
+