Merge branch 'master' into VED-1143-Create-Subscription-SQS-Queue

Author: motola

lambdas/ack_backend/poetry.lock

@@ -11,11 +11,11 @@ packages = [
 
 [tool.poetry.dependencies]
 python = "~3.11"
-boto3 = "~1.42.37"
-mypy-boto3-dynamodb = "^1.42.33"
+boto3 = "~1.42.74"
+mypy-boto3-dynamodb = "^1.42.73"
 freezegun      = "^1.5.2"
-moto           = "^5.1.20"
-coverage = "^7.13.2"
+moto           = "^5.1.22"
+coverage = "^7.13.5"
 
 
 [build-system]

lambdas/ack_backend/pyproject.toml

@@ -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/Makefile

@@ -12,21 +12,21 @@ packages = [
 [tool.poetry.dependencies]
 python                  = "~3.11"
 "fhir.resources"        = "~7.0.2"
-boto3                   = "~1.42.37"
-boto3-stubs-lite        = {extras = ["dynamodb"], version = "~1.42.37"}
+boto3                   = "~1.42.74"
+boto3-stubs-lite        = {extras = ["dynamodb"], version = "~1.42.74"}
 aws-lambda-typing       = "~2.20.0"
 redis                   = "^4.6.0"
-moto                    = "^5.1.20"
+moto                    = "^5.1.22"
 requests                = "~2.32.5"
-responses               = "~0.25.7"
+responses               = "~0.26.0"
 pydantic                = "~1.10.13"
-pyjwt                   = {extras = ["crypto"], version = "^2.12.0"}
-jsonpath-ng             = "^1.6.0"
+pyjwt                   = {extras = ["crypto"], version = "^2.12.1"}
+jsonpath-ng             = "^1.8.0"
 simplejson              = "^3.20.2"
 structlog               = "^24.1.0"
 python-stdnum           = "^2.1"
 freezegun               = "^1.5.1"
-coverage                = "^7.13.2"
+coverage                = "^7.13.5"
 
 [build-system]
 requires      = ["poetry-core ~= 1.5.0"]

lambdas/backend/poetry.lock

@@ -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/pyproject.toml

@@ -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/src/get_status_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"])