AMB-1741 wire controller into get_imms_handler.py and update tests

artronics · artronics · commit 22f3a2f81b26 · 2023-11-03T01:13:10.000Z
diff --git a/lambda_code/src/fhir_controller.py b/lambda_code/src/fhir_controller.py
@@ -3,7 +3,7 @@
 import uuid
 
 from fhir_service import FhirService
-from models.errors import ApiError, Severity, Code
+from models.errors import Severity, Code, create_operation_outcome
 
 
 class FhirController:
@@ -16,22 +16,24 @@ 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))
+            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())
+            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))
+            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):
+    def create_response(status_code, body):
         return {
             "statusCode": status_code,
             "headers": {
diff --git a/lambda_code/src/get_imms_handler.py b/lambda_code/src/get_imms_handler.py
@@ -1,62 +1,24 @@
-import json
-import re
 import uuid
 
-from dynamodb import EventTable
 from fhir_controller import FhirController
-
-
-def create_operation_outcome(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_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
+    imms_repo = ImmunisationRepository()
+    service = FhirService(imms_repo=imms_repo)
+    controller = FhirController(fhir_service=service)
 
-    if not is_valid_id(event_id) or not event_id:
-        body = json.dumps(
-            create_operation_outcome(str(uuid.uuid4()),
-                                     "the provided event ID is either missing or not in the expected format.",
-                                     "invalid"))
-        return FhirController._create_response(400, body)
+    return get_immunisation_by_id(event, controller)
 
-    query_result = dynamo_service.get_event_by_id(event_id)
-    if query_result is None:
-        body = json.dumps(
-            create_operation_outcome(str(uuid.uuid4()), "The requested resource was not found.", "not-found"))
-        return FhirController._create_response(404, body)
 
-    return FhirController._create_response(200, json.dumps(query_result))
+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
@@ -1,7 +1,6 @@
 from enum import Enum
 
 from fhir.resources.operationoutcome import OperationOutcome
-from pydantic import BaseModel
 
 
 class Severity(str, Enum):
@@ -13,35 +12,29 @@ class Code(str, Enum):
     invalid = "invalid"
 
 
-class ApiError(BaseModel, use_enum_values=True):
-    id: str
-    severity: Severity
-    code: Code
-    diagnostics: str
-
-    def to_uk_core(self) -> OperationOutcome:
-        model = {
-            "resourceType": "OperationOutcome",
-            "id": self.id,
-            "meta": {
-                "profile": [
-                    "https://simplifier.net/guide/UKCoreDevelopment2/ProfileUKCore-OperationOutcome"
-                ]
-            },
-            "issue": [
-                {
-                    "severity": self.severity,
-                    "code": self.code,
-                    "details": {
-                        "coding": [
-                            {
-                                "system": "https://fhir.nhs.uk/Codesystem/http-error-codes",
-                                "code": self.code.upper()
-                            }
-                        ]
-                    },
-                    "diagnostics": self.diagnostics
-                }
+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"
             ]
-        }
-        return OperationOutcome.parse_obj(model)
+        },
+        "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/tests/test_api_errors.py b/lambda_code/tests/test_api_errors.py
@@ -4,22 +4,22 @@
 
 sys.path.append(f"{os.path.dirname(os.path.abspath(__file__))}/../src")
 
-from models.errors import ApiError, Severity, Code
+from models.errors import Severity, Code, create_operation_outcome
 
 
 class TestApiErrors(unittest.TestCase):
-    def test_error_to_uk_core(self):
+    def test_error_to_uk_core2(self):
         code = Code.not_found
+
         severity = Severity.error
         diag = "a-diagnostic"
         error_id = "a-id"
 
-        api_error = ApiError(id=error_id, severity=severity, code=code, diagnostics=diag)
-        error = api_error.to_uk_core().dict()
+        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["code"], "not-found")
         self.assertEqual(issue["severity"], "error")
         self.assertEqual(issue["diagnostics"], diag)
-        self.assertEqual(issue["details"]["coding"][0]["code"], "NOT_FOUND")
+        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
@@ -19,7 +19,7 @@ def setUp(self):
 
     def test_create_response(self):
         """it should return application/fhir+json with correct status code"""
-        res = self.controller._create_response(42, "a body")
+        res = self.controller.create_response(42, "a body")
         headers = res["headers"]
 
         self.assertEqual(res["statusCode"], 42)
diff --git a/lambda_code/tests/test_get_imms.py b/lambda_code/tests/test_get_imms.py
@@ -3,60 +3,51 @@
 import sys
 import unittest
 import uuid
-from unittest.mock import MagicMock, create_autospec
+from unittest.mock import create_autospec
 
 sys.path.append(f"{os.path.dirname(os.path.abspath(__file__))}/../src")
 
-from dynamodb import EventTable
-from get_imms_handler import get_imms, create_operation_outcome
+from get_imms_handler import get_immunisation_by_id
+from fhir_controller import FhirController
+from models.errors import Severity, Code, create_operation_outcome
 
 
 class TestGetImmunisationById(unittest.TestCase):
     def setUp(self):
-        self.dynamodb_service = create_autospec(EventTable)
+        self.controller = create_autospec(FhirController)
 
-    def test_get_imms_happy_path(self):
-        # Arrange
-        self.dynamodb_service.get_event_by_id = MagicMock(return_value={"message": "Mocked event data"})
-        lambda_event = {"pathParameters": {"id": "sample-id"}}
+    def test_get_immunisation_by_id(self):
+        """it should return immunisation by id"""
+        lambda_event = {"pathParameters": {"id": "an-id"}}
+        exp_res = {"a-key": "a-value"}
 
-        # Act
-        result = get_imms(lambda_event, self.dynamodb_service)
+        self.controller.get_immunisation_by_id.return_value = exp_res
 
-        # Assert
-        self.dynamodb_service.get_event_by_id.assert_called_once_with(lambda_event["pathParameters"]["id"])
-        self.assertEqual(result['statusCode'], 200)
-        self.assertDictEqual(json.loads(result['body']), {"message": "Mocked event data"})
+        # When
+        act_res = get_immunisation_by_id(lambda_event, self.controller)
 
-    def test_get_imms_handler_sad_path_400(self):
-        unformatted_event = {"pathParameters": {"id": "unexpected_id"}}
+        # Then
+        self.controller.get_immunisation_by_id.assert_called_once_with(lambda_event)
+        self.assertDictEqual(exp_res, act_res)
 
-        # Act
-        result = get_imms(unformatted_event, None)
+    def test_handle_exception(self):
+        """unhandled exceptions should result in 500"""
+        lambda_event = {"pathParameters": {"id": "an-id"}}
+        error_msg = "an unhandled error"
+        self.controller.get_immunisation_by_id.side_effect = Exception(error_msg)
 
-        # Assert
-        assert result['statusCode'] == 400
-        act_body = json.loads(result['body'])
-        exp_body = create_operation_outcome(str(uuid.uuid4()),
-                                            "he provided event ID is either missing or not in the expected format.",
-                                            "invalid")
-        act_body["id"] = None
-        exp_body["id"] = None
-        self.assertDictEqual(act_body, exp_body)
+        exp_error = create_operation_outcome(resource_id=str(uuid.uuid4()), severity=Severity.error,
+                                             code=Code.not_found,
+                                             diagnostics=error_msg)
 
-    def test_get_imms_handler_sad_path_404(self):
-        # Arrange
-        self.dynamodb_service.get_event_by_id = MagicMock(return_value=None)
-        incorrect_event = {"pathParameters": {"id": "incorrectid"}}
+        # When
+        act_res = get_immunisation_by_id(lambda_event, self.controller)
 
-        # Act
-        result = get_imms(incorrect_event, self.dynamodb_service)
-
-        # Assert
-        assert result['statusCode'] == 404
-        self.assertEqual(result['headers']['Content-Type'], "application/fhir+json")
-        act_body = json.loads(result['body'])
-        exp_body = create_operation_outcome(str(uuid.uuid4()), "The requested resource was not found.", "not-found")
+        # Then
+        act_body = json.loads(act_res["body"])
         act_body["id"] = None
+        exp_body = json.loads(exp_error.json())  # to and from json so, we get from OrderedDict to Dict
         exp_body["id"] = None
+
         self.assertDictEqual(act_body, exp_body)
+        self.assertEqual(act_res["statusCode"], 500)
