refactor: Optimize Mock PDS service initialization in lambda_handler

- Removed the global service retrieval function and directly initialized the MockPdsService with a Redis client and rate limiter.
- Updated the lambda_handler to use the initialized service directly, improving performance and readability.
- Adjusted unit tests to accommodate the new service initialization approach, ensuring proper mocking and error handling.

Author: Thomas-Boyle

lambdas/mock_pds/src/lambda_handler.py

@@ -9,32 +9,25 @@
 logger = logging.getLogger()
 logger.setLevel(logging.INFO)
 
-_mock_pds_service: MockPdsService | None = None
-
-
-def get_mock_pds_service() -> MockPdsService:
-    global _mock_pds_service
-    if _mock_pds_service is None:
-        redis_client = redis.Redis(
-            host=os.environ["REDIS_HOST"],
-            port=int(os.getenv("REDIS_PORT", "6379")),
-            decode_responses=True,
-        )
-        rate_limiter = FixedWindowRateLimiter(
-            redis_client=redis_client,
-            key_prefix="mock-pds",
-            average_limit=int(os.getenv("MOCK_PDS_AVERAGE_LIMIT", "125")),
-            average_window_seconds=int(os.getenv("MOCK_PDS_AVERAGE_WINDOW_SECONDS", "60")),
-            spike_limit=int(os.getenv("MOCK_PDS_SPIKE_LIMIT", "450")),
-            spike_window_seconds=int(os.getenv("MOCK_PDS_SPIKE_WINDOW_SECONDS", "1")),
-        )
-        _mock_pds_service = MockPdsService(rate_limiter, os.getenv("MOCK_PDS_GP_ODS_CODE", "Y12345"))
-    return _mock_pds_service
+_redis_client = redis.Redis(
+    host=os.environ["REDIS_HOST"],
+    port=int(os.getenv("REDIS_PORT", "6379")),
+    decode_responses=True,
+)
+_rate_limiter = FixedWindowRateLimiter(
+    redis_client=_redis_client,
+    key_prefix="mock-pds",
+    average_limit=int(os.getenv("MOCK_PDS_AVERAGE_LIMIT", "125")),
+    average_window_seconds=int(os.getenv("MOCK_PDS_AVERAGE_WINDOW_SECONDS", "60")),
+    spike_limit=int(os.getenv("MOCK_PDS_SPIKE_LIMIT", "450")),
+    spike_window_seconds=int(os.getenv("MOCK_PDS_SPIKE_WINDOW_SECONDS", "1")),
+)
+_mock_pds_service = MockPdsService(_rate_limiter, os.getenv("MOCK_PDS_GP_ODS_CODE", "Y12345"))
 
 
 def lambda_handler(event, context):
     try:
-        return get_mock_pds_service().handle(event)
+        return _mock_pds_service.handle(event)
     except Exception:
         logger.exception("Mock PDS failed to handle request")
         return {

lambdas/mock_pds/tests/test_mock_pds_service.py

@@ -1,8 +1,13 @@
+import importlib
 import json
+import os
 import unittest
 from unittest.mock import Mock, patch
 
-from lambda_handler import get_mock_pds_service, lambda_handler
+os.environ.setdefault("REDIS_HOST", "test-redis-host")
+os.environ.setdefault("REDIS_PORT", "6379")
+
+import lambda_handler as lambda_handler_module
 from mock_pds_service import RATE_LIMIT_MESSAGE, MockPdsService
 from rate_limiter import FixedWindowRateLimiter, RateLimitDecision
 
@@ -47,7 +52,7 @@ def test_rejects_non_get_requests(self):
 
 class TestLambdaHandler(unittest.TestCase):
     def tearDown(self):
-        get_mock_pds_service.__globals__["_mock_pds_service"] = None
+        importlib.reload(lambda_handler_module)
 
     @patch.dict(
         "os.environ",
@@ -60,23 +65,25 @@ def tearDown(self):
         },
         clear=False,
     )
-    @patch("lambda_handler.redis.Redis")
-    def test_lambda_handler_uses_cached_service(self, mock_redis):
+    @patch("mock_pds_service.MockPdsService")
+    @patch("redis.Redis")
+    def test_lambda_handler_uses_cached_service(self, mock_redis, mock_pds_cls):
         mock_service = Mock()
         mock_service.handle.return_value = {"statusCode": 200}
+        mock_pds_cls.return_value = mock_service
 
-        with patch("lambda_handler.MockPdsService", return_value=mock_service):
-            first_response = lambda_handler(_event(nhs_number="123"), None)
-            second_response = lambda_handler(_event(nhs_number="456"), None)
+        importlib.reload(lambda_handler_module)
+        first_response = lambda_handler_module.lambda_handler(_event(nhs_number="123"), None)
+        second_response = lambda_handler_module.lambda_handler(_event(nhs_number="456"), None)
 
         self.assertEqual(first_response, {"statusCode": 200})
         self.assertEqual(second_response, {"statusCode": 200})
         mock_redis.assert_called_once_with(host="mock-redis", port=6379, decode_responses=True)
 
-    @patch("lambda_handler.get_mock_pds_service")
-    def test_lambda_handler_returns_500_on_unhandled_error(self, mock_get_service):
-        mock_get_service.return_value.handle.side_effect = RuntimeError("boom")
-
-        response = lambda_handler(_event(nhs_number="123"), None)
+    def test_lambda_handler_returns_500_on_unhandled_error(self):
+        mock_svc = Mock()
+        mock_svc.handle.side_effect = RuntimeError("boom")
+        with patch.object(lambda_handler_module, "_mock_pds_service", mock_svc):
+            response = lambda_handler_module.lambda_handler(_event(nhs_number="123"), None)
 
         self.assertEqual(response["statusCode"], 500)