tidy

Author: nhsdevws

recordprocessor/src/redis_cacher.py

@@ -1,14 +1,39 @@
 "Upload the content from a config file in S3 to ElastiCache (Redis)"
-from redis_cacher import RedisCacher
 
+import json
+import redis
 from constants import DISEASE_MAPPING_FILE_KEY
 
 
+class RedisCacher():
+    """ RedisCacher abstraction class to decouple application code
+    from direct use of Redis client."""
+
+    def __init__(self, redis_host, redis_port, logger):
+        try:
+            # Attempt to connect to Redis
+            self.redis_client = redis.StrictRedis(redis_host, redis_port, decode_responses=True)
+            # Check the connection with a PING command
+            if self.redis_client.ping():
+                logger.info("Successfully connected to Redis.")
+            else:
+                logger.error("Failed to connect to Redis.")
+        except Exception as e:
+            logger.exception(f"Connection to Redis failed: {e}")
+
+    def get(self, key: str) -> dict:
+        """Gets the value from Redis cache for the given key."""
+        value = self.redis_client.get(key)
+        if value is not None:
+            return json.loads(value)
+        return {}
+
+
 class DiseaseMapping:
     """Class to handle disease mapping operations."""
     # redis_cache instance is found in clients.py
     def __init__(self, redis_cache: RedisCacher):
-        mapping = redis_cache.get_cache(DISEASE_MAPPING_FILE_KEY)
+        mapping = redis_cache.get(DISEASE_MAPPING_FILE_KEY)
         self.vaccines = mapping["vaccine"]
         self.diseases = mapping["disease"]
         self.load_vaccines_into_diseases()
@@ -43,14 +68,14 @@ def load_vaccines_into_diseases(self):
                 if vaccine not in self.diseases[disease]["vaccines"]:
                     self.diseases[disease]["vaccines"].append(vaccine)
 
-    def get_diseases(self, vaccine: str) -> list:
+    def get_diseases_from_vaccine(self, vaccine: str) -> list:
         """Returns a list of diseases for the given vaccine."""
         vaccine = self.vaccines.get(vaccine, {})
         if not vaccine:
             return []
         return vaccine.get("diseases", [])
 
-    def get_vaccines(self, disease: str) -> list:
+    def get_vaccines_from_disease(self, disease: str) -> list:
         """Returns a list of vaccines for the given disease."""
         disease = self.disease_map.get(disease, {})
         if not disease:

recordprocessor/src/redis_disease_mapping.py

@@ -1,10 +1,69 @@
 import unittest
 from unittest.mock import patch, MagicMock
-from src.redis_disease_mapping import DiseaseMapping
-from src.redis_cacher import RedisCacher
+from src.redis_disease_mapping import DiseaseMapping, RedisCacher
 from src.constants import DISEASE_MAPPING_FILE_KEY
 
 
+class TestRedisCacher(unittest.TestCase):
+    def setUp(self):
+
+        self.strict_redis_patcher = patch("redis.StrictRedis")
+        self.strict_redis = self.strict_redis_patcher.start()
+        self.mock_redis_client = MagicMock()
+        self.strict_redis.return_value = self.mock_redis_client
+
+        self.logger_info_patcher = patch("logging.Logger.info")
+        self.mock_logger_info = self.logger_info_patcher.start()
+
+        self.logger_exception_patcher = patch("logging.Logger.exception")
+        self.mock_logger_exception = self.logger_exception_patcher.start()
+
+        self.logger_warning_patcher = patch("logging.Logger.warning")
+        self.mock_logger_warning = self.logger_warning_patcher.start()
+
+        self.logger_error_patcher = patch("logging.Logger.error")
+        self.mock_logger_error = self.logger_error_patcher.start()
+
+    def tearDown(self):
+        self.strict_redis_patcher.stop()
+        self.logger_info_patcher.stop()
+        self.logger_exception_patcher.stop()
+        self.logger_warning_patcher.stop()
+        self.logger_error_patcher.stop()
+
+    def test_successful_connection(self):
+        self.mock_redis_client.ping.return_value = True
+        cacher = RedisCacher("localhost", 6379)
+        self.assertTrue(hasattr(cacher, "redis_client"))
+        self.mock_logger_info.assert_called_once()
+        self.mock_redis_client.ping.assert_called_once()
+        print("test_successful_connection...Done")
+
+    def test_failed_connection(self):
+        self.mock_redis_client.ping.return_value = False
+        cacher = RedisCacher("localhost", 6379)
+        self.assertTrue(hasattr(cacher, "redis_client"))
+        self.mock_redis_client.ping.assert_called_once()
+        print("test_failed_connection...Done")
+
+    def test_get_cache_returns_dict(self):
+        self.mock_redis_client.ping.return_value = True
+        self.mock_redis_client.get.return_value = '{"foo": "bar"}'
+        cacher = RedisCacher("localhost", 6379)
+        result = cacher.get_cache("some_key")
+        self.assertEqual(result, {"foo": "bar"})
+        self.mock_redis_client.get.assert_called_once_with("some_key")
+        print("test_get_cache_returns_dict...Done")
+
+    def test_get_cache_returns_empty_dict(self):
+        self.mock_redis_client.ping.return_value = True
+        self.mock_redis_client.get.return_value = None
+        cacher = RedisCacher("localhost", 6379)
+        result = cacher.get_cache("missing_key")
+        self.assertEqual(result, {})
+        self.mock_redis_client.get.assert_called_once_with("missing_key")
+
+
 class TestDiseaseMapping(unittest.TestCase):
 
     basic_cache = {