VED-856: Improve Code Coverage in Codebase (#1319)

* test coverage on backend and common models

Author: motola

lambdas/backend/Makefile

@@ -9,7 +9,6 @@ package: build
 
 test:
 	$(TEST_ENV) python -m unittest
-
 coverage-run:
 	$(TEST_ENV) coverage run --source=src -m unittest discover
 

lambdas/backend/src/get_status_handler.py

@@ -0,0 +1,19 @@
+import os
+import tempfile
+import unittest
+
+from local_lambda import load_string
+
+
+class TestLoadString(unittest.TestCase):
+    def test_reads_file_contents(self):
+        fd, path = tempfile.mkstemp()
+        self.addCleanup(os.unlink, path)
+        with os.fdopen(fd, "w") as f:
+            f.write("hello world")
+
+        self.assertEqual(load_string(path), "hello world")
+
+    def test_raises_if_file_not_found(self):
+        with self.assertRaises(FileNotFoundError):
+            load_string("/nonexistent/file/path.py")

lambdas/backend/tests/test_local_lambda.py

@@ -0,0 +1,86 @@
+import json
+import unittest
+
+from not_found_handler import ALLOWED_METHODS, not_found
+
+
+class TestNotFoundHandler(unittest.TestCase):
+    """Tests for the not_found_handler functionality"""
+
+    def test_method_not_allowed_unsupported_method(self):
+        """Test that unsupported HTTP methods return 405 Method Not Allowed"""
+        event = {"httpMethod": "PATCH"}
+
+        response = not_found(event, None)
+
+        self.assertEqual(response["statusCode"], 405)
+        self.assertEqual(response["headers"]["Content-Type"], "application/json")
+        self.assertEqual(response["headers"]["Allow"], "GET, POST, DELETE, PUT")
+
+        # Verify the response body structure
+        body = json.loads(response["body"])
+        self.assertEqual(body["resourceType"], "OperationOutcome")
+        self.assertEqual(body["issue"][0]["severity"], "error")
+        self.assertEqual(body["issue"][0]["code"], "not-supported")
+        self.assertEqual(body["issue"][0]["diagnostics"], "Method Not Allowed")
+
+    def test_method_not_allowed_other_unsupported_method(self):
+        """Test that other unsupported HTTP methods also return 405"""
+        unsupported_methods = ["PUTT", "PATCH", "HEAD", "OPTIONS", "TRACE", "CONNECT"]
+
+        for method in unsupported_methods:
+            with self.subTest(method=method):
+                event = {"httpMethod": method}
+                response = not_found(event, None)
+
+                self.assertEqual(response["statusCode"], 405)
+                self.assertEqual(response["headers"]["Allow"], "GET, POST, DELETE, PUT")
+
+    def test_not_found_allowed_method(self):
+        """Test that allowed HTTP methods return 404 Not Found"""
+        allowed_methods = ALLOWED_METHODS  # ["GET", "POST", "DELETE", "PUT"]
+
+        for method in allowed_methods:
+            with self.subTest(method=method):
+                event = {"httpMethod": method}
+                response = not_found(event, None)
+
+                self.assertEqual(response["statusCode"], 404)
+                self.assertEqual(response["headers"]["Content-Type"], "application/json")
+                self.assertNotIn("Allow", response["headers"])  # No Allow header for 404
+
+                # Verify the response body structure
+                body = json.loads(response["body"])
+                self.assertEqual(body["resourceType"], "OperationOutcome")
+                self.assertEqual(body["issue"][0]["severity"], "error")
+                self.assertEqual(body["issue"][0]["code"], "not-found")
+                self.assertEqual(body["issue"][0]["diagnostics"], "The requested resource was not found.")
+
+    def test_not_found_missing_http_method(self):
+        """Test that missing httpMethod defaults to 405 Method Not Allowed"""
+        event = {}
+
+        response = not_found(event, None)
+
+        self.assertEqual(response["statusCode"], 405)
+        self.assertEqual(response["headers"]["Content-Type"], "application/json")
+        self.assertEqual(response["headers"]["Allow"], "GET, POST, DELETE, PUT")
+
+    def test_not_found_none_http_method(self):
+        """Test that None httpMethod defaults to 405 Method Not Allowed"""
+        event = {"httpMethod": None}
+
+        response = not_found(event, None)
+
+        self.assertEqual(response["statusCode"], 405)
+        self.assertEqual(response["headers"]["Content-Type"], "application/json")
+        self.assertEqual(response["headers"]["Allow"], "GET, POST, DELETE, PUT")
+
+    def test_allowed_methods_constant(self):
+        """Test that ALLOWED_METHODS contains the expected HTTP methods"""
+        expected_methods = ["GET", "POST", "DELETE", "PUT"]
+        self.assertEqual(ALLOWED_METHODS, expected_methods)
+
+
+if __name__ == "__main__":
+    unittest.main()

lambdas/backend/tests/test_not_found_handler.py

@@ -0,0 +1,34 @@
+import unittest
+from unittest.mock import patch
+
+from timer import timed
+
+
+class TestTimedDecorator(unittest.TestCase):
+    @patch("timer.time")
+    @patch("timer.logger")
+    def test_timed_logs_correct_execution_time(self, mock_logger, mock_time):
+        mock_time.time.side_effect = [1000.0, 1000.12345]
+
+        @timed
+        def sample_function():
+            return "success"
+
+        result = sample_function()
+
+        self.assertEqual(result, "success")
+        mock_logger.info.assert_called_once_with({"time_taken": "sample_function ran in 0.12345s"})
+
+    @patch("timer.time")
+    @patch("timer.logger")
+    def test_timed_preserves_function_name(self, mock_logger, mock_time):
+        mock_time.time.side_effect = [0.0, 0.0]
+
+        @timed
+        def my_named_function():
+            pass
+
+        my_named_function()
+
+        logged_payload = mock_logger.info.call_args[0][0]
+        self.assertIn("my_named_function", logged_payload["time_taken"])

lambdas/backend/tests/test_timer.py

@@ -1,9 +1,21 @@
 """Tests for generic utils"""
 
+import datetime
 import unittest
 from copy import deepcopy
 from unittest.mock import Mock, patch
 
+from common.models.utils.generic_utils import (
+    check_keys_in_sources,
+    create_diagnostics,
+    create_diagnostics_error,
+    extract_file_key_elements,
+    generate_field_location_for_name,
+    get_contained_practitioner,
+    get_nhs_number,
+    get_occurrence_datetime,
+    is_actor_referencing_contained_resource,
+)
 from common.models.utils.validation_utils import (
     convert_disease_codes_to_vaccine_type,
     get_vaccine_type,
@@ -25,6 +37,127 @@ def tearDown(self):
         """Tear down after each test. This runs after every test"""
         self.redis_getter_patcher.stop()
 
+    def test_get_nhs_number_success(self):
+        """Test get_nhs_number returns NHS number when present"""
+        expected_nhs = "1234567890"
+        imms = {"contained": [{"resourceType": "Patient", "identifier": [{"value": expected_nhs}]}]}
+        result = get_nhs_number(imms)
+        self.assertEqual(result, expected_nhs)
+
+    def test_get_nhs_number_missing_patient(self):
+        """Test get_nhs_number returns 'TBC' when patient not found"""
+        imms = {"contained": []}
+        result = get_nhs_number(imms)
+        self.assertEqual(result, "TBC")
+
+    def test_get_nhs_number_missing_identifier(self):
+        """Test get_nhs_number returns 'TBC' when identifier not found"""
+        imms = {"contained": [{"resourceType": "Patient"}]}
+        result = get_nhs_number(imms)
+        self.assertEqual(result, "TBC")
+
+    def test_get_contained_practitioner(self):
+        """Test get_contained_practitioner returns practitioner resource"""
+        imms = {
+            "contained": [
+                {"resourceType": "Patient", "id": "patient1"},
+                {"resourceType": "Practitioner", "id": "practitioner1"},
+            ]
+        }
+        result = get_contained_practitioner(imms)
+        self.assertEqual(result["id"], "practitioner1")
+
+    def test_is_actor_referencing_contained_resource_true(self):
+        """Test is_actor_referencing_contained_resource returns True for matching reference"""
+        element = {"actor": {"reference": "#patient1"}}
+        result = is_actor_referencing_contained_resource(element, "patient1")
+        self.assertTrue(result)
+
+    def test_is_actor_referencing_contained_resource_false(self):
+        """Test is_actor_referencing_contained_resource returns False for non-matching reference"""
+        element = {"actor": {"reference": "#patient2"}}
+        result = is_actor_referencing_contained_resource(element, "patient1")
+        self.assertFalse(result)
+
+    def test_is_actor_referencing_contained_resource_missing_key(self):
+        """Test is_actor_referencing_contained_resource returns False when keys missing"""
+        element = {}
+        result = is_actor_referencing_contained_resource(element, "patient1")
+        self.assertFalse(result)
+
+    def test_get_occurrence_datetime_valid(self):
+        """Test get_occurrence_datetime returns datetime for valid occurrenceDateTime"""
+        immunization = {"occurrenceDateTime": "2023-01-15T10:30:00Z"}
+        result = get_occurrence_datetime(immunization)
+        # The result will be timezone-aware due to the 'Z' in the ISO string
+        expected = datetime.datetime(2023, 1, 15, 10, 30, 0, tzinfo=datetime.UTC)
+        self.assertEqual(result, expected)
+
+    def test_get_occurrence_datetime_none(self):
+        """Test get_occurrence_datetime returns None when occurrenceDateTime missing"""
+        immunization = {}
+        result = get_occurrence_datetime(immunization)
+        self.assertIsNone(result)
+
+    def test_create_diagnostics(self):
+        """Test create_diagnostics returns expected error structure"""
+        result = create_diagnostics()
+        expected = {
+            "diagnostics": "Validation errors: contained[?(@.resourceType=='Patient')].identifier[?(@.system=='https://fhir.nhs.uk/Id/nhs-number')].value does not exists."
+        }
+        self.assertEqual(result, expected)
+
+    def test_create_diagnostics_error_system(self):
+        """Test create_diagnostics_error for system mismatch"""
+        result = create_diagnostics_error("system")
+        expected = {"diagnostics": "Validation errors: identifier[0].system doesn't match with the stored content"}
+        self.assertEqual(result, expected)
+
+    def test_create_diagnostics_error_value(self):
+        """Test create_diagnostics_error for value mismatch"""
+        result = create_diagnostics_error("value")
+        expected = {"diagnostics": "Validation errors: identifier[0].value doesn't match with the stored content"}
+        self.assertEqual(result, expected)
+
+    def test_create_diagnostics_error_both(self):
+        """Test create_diagnostics_error for both system and value mismatch"""
+        result = create_diagnostics_error("Both")
+        expected = {
+            "diagnostics": "Validation errors: identifier[0].system and identifier[0].value doesn't match with the stored content"
+        }
+        self.assertEqual(result, expected)
+
+    def test_check_keys_in_sources_query_params(self):
+        """Test check_keys_in_sources with queryStringParameters"""
+        event = {"queryStringParameters": {"key1": "value1", "key2": "value2"}}
+        not_required_keys = ["key1"]
+        result = check_keys_in_sources(event, not_required_keys)
+        self.assertEqual(result, ["key1"])
+
+    def test_check_keys_in_sources_body(self):
+        """Test check_keys_in_sources with body content"""
+        import base64
+
+        body_data = "key1=value1&key2=value2"
+        encoded_body = base64.b64encode(body_data.encode()).decode()
+        event = {"body": encoded_body}
+        not_required_keys = ["key1"]
+        result = check_keys_in_sources(event, not_required_keys)
+        self.assertEqual(result, ["key1"])
+
+    def test_generate_field_location_for_name(self):
+        """Test generate_field_location_for_name creates correct path"""
+        result = generate_field_location_for_name("0", "given", "Patient")
+        expected = "contained[?(@.resourceType=='Patient')].name[0].given"
+        self.assertEqual(result, expected)
+
+    def test_extract_file_key_elements(self):
+        """Test extract_file_key_elements extracts vaccine type from file key"""
+        file_key = "COVID_VACCINE_DATA.JSON"
+        result = extract_file_key_elements(file_key)
+        expected = {"vaccine_type": "COVID"}
+        self.assertEqual(result, expected)
+
     def test_convert_disease_codes_to_vaccine_type_returns_vaccine_type(self):
         """
         If the mock returns a vaccine type, convert_disease_codes_to_vaccine_type returns that vaccine type.

lambdas/shared/tests/test_common/test_generic_utils.py

@@ -0,0 +1,19 @@
+import unittest
+
+from fhir.resources.R4B.identifier import Identifier
+
+from common.models.immunization_record_metadata import ImmunizationRecordMetadata
+
+
+class TestImmunizationRecordMetadata(unittest.TestCase):
+    def test_initialization(self):
+        identifier = Identifier.construct(value="12345")
+
+        metadata = ImmunizationRecordMetadata(
+            identifier=identifier, resource_version=1, is_deleted=False, is_reinstated=False
+        )
+
+        self.assertEqual(metadata.identifier.value, "12345")
+        self.assertEqual(metadata.resource_version, 1)
+        self.assertFalse(metadata.is_deleted)
+        self.assertFalse(metadata.is_reinstated)