tidy tests

Author: nhsdevws

lambdas/id_sync/tests/test_record_processor.py

@@ -0,0 +1,13 @@
+from record_processor import process_record
+import unittest
+from unittest.mock import patch
+
+
+class TestRecordProcessor(unittest.TestCase):
+    def setUp(self):
+        self.logger_info_patcher = patch("logging.Logger.info")
+        self.mock_logger_info = self.logger_info_patcher.start()
+
+    def test_record_processor_success(self):
+        response = process_record({"key": "value"})
+        self.assertEqual(response, "hello world")

lambdas/shared/src/common/clients.py

@@ -1,6 +1,5 @@
 import os
 import logging
-import redis
 from boto3 import client as boto3_client
 
 
@@ -12,10 +11,6 @@
 CONFIG_BUCKET_NAME = os.getenv("CONFIG_BUCKET_NAME", "variconfig-bucketable-not-defined")
 
 REGION_NAME = os.getenv("AWS_REGION", "eu-west-2")
-REDIS_HOST = os.getenv("REDIS_HOST", "")
-REDIS_PORT = os.getenv("REDIS_PORT", 6379)
 
 s3_client = boto3_client("s3", region_name=REGION_NAME)
 firehose_client = boto3_client("firehose", region_name=REGION_NAME)
-logger.info(f"Connecting to Redis at {REDIS_HOST}:{REDIS_PORT}")
-redis_client = redis.StrictRedis(host=REDIS_HOST, port=REDIS_PORT, decode_responses=True)

lambdas/shared/tests/test_common/test_clients.py

@@ -1,15 +1,13 @@
 import unittest
 from unittest.mock import patch
-import common as clients
+import common.clients as clients
 import importlib
 
 
 class TestClients(unittest.TestCase):
 
     BUCKET_NAME = "default-bucket"
     AWS_REGION = "eu-west-2"
-    REDIS_HOST = "mock-redis-host"
-    REDIS_PORT = 6379
 
     def setUp(self):
         self.boto3_client_patch = patch("boto3.client")
@@ -22,15 +20,9 @@ def setUp(self):
         self.mock_getenv = self.getenv_patch.start()
         self.mock_getenv.side_effect = lambda key, default=None: {
             "CONFIG_BUCKET_NAME": self.BUCKET_NAME,
-            "AWS_REGION": self.AWS_REGION,
-            "REDIS_HOST": self.REDIS_HOST,
-            "REDIS_PORT": self.REDIS_PORT
+            "AWS_REGION": self.AWS_REGION
         }.get(key, default)
 
-        self.redis_patch = patch("redis.StrictRedis")
-        self.mock_redis = self.redis_patch.start()
-
-        self.mock_redis.return_value = self.mock_redis
         self.mock_boto3_client.return_value = self.mock_boto3_client
         self.mock_boto3_client.return_value.send_message = {}
 
@@ -42,8 +34,6 @@ def test_os_environ(self):
         importlib.reload(clients)
         self.assertEqual(clients.CONFIG_BUCKET_NAME, self.BUCKET_NAME)
         self.assertEqual(clients.REGION_NAME, self.AWS_REGION)
-        self.assertEqual(clients.REDIS_HOST, self.REDIS_HOST)
-        self.assertEqual(clients.REDIS_PORT, self.REDIS_PORT)
 
     def test_boto3_client(self):
         ''' Test boto3 client is created with correct parameters '''
@@ -55,31 +45,15 @@ def test_firehose_client(self):
         importlib.reload(clients)
         self.mock_boto3_client.assert_any_call("firehose", region_name=self.AWS_REGION)
 
-    def test_redis_client(self):
-        ''' Test redis client is created with correct parameters '''
-        importlib.reload(clients)
-        self.mock_redis.assert_called_once_with(
-            host=self.REDIS_HOST,
-            port=self.REDIS_PORT,
-            decode_responses=True
-        )
-
     def test_logging_setup(self):
         ''' Test logging is set up correctly '''
         importlib.reload(clients)
         self.assertTrue(hasattr(clients, 'logger'))
 
-        def test_logging_configuration(self):
-            ''' Test logging configuration '''
-            importlib.reload(clients)
-            clients.logger.setLevel.assert_called_once_with("INFO")
-
-    def test_redis_client_initialization(self):
-        ''' Test redis client initialization '''
+    def test_logging_configuration(self):
+        ''' Test logging configuration '''
         importlib.reload(clients)
-        self.mock_redis.assert_called_once_with(host=self.REDIS_HOST, port=self.REDIS_PORT, decode_responses=True)
-        self.assertTrue(hasattr(clients, 'redis_client'))
-        self.assertIsInstance(clients.redis_client, self.mock_redis.return_value.__class__)
+        clients.logger.setLevel.assert_called_once_with("INFO")
 
     def test_logging_initialization(self):
         ''' Test logging initialization '''

lambdas/shared/tests/test_common/test_log_decorator.py

@@ -11,10 +11,18 @@ class TestLogDecorator(unittest.TestCase):
     def setUp(self):
         self.test_stream = "test-stream"
         self.test_prefix = "test"
+        self.logger_info_patcher = patch("common.log_decorator.logger.info")
+        self.mock_logger_info = self.logger_info_patcher.start()
+        self.logger_exception_patcher = patch("common.log_decorator.logger.exception")
+        self.mock_logger_exception = self.logger_exception_patcher.start()
+        self.logger_error_patcher = patch("common.log_decorator.logger.error")
+        self.mock_logger_error = self.logger_error_patcher.start()
+
+    def tearDown(self):
+        patch.stopall()
 
     @patch("common.log_decorator.firehose_client")
-    @patch("common.log_decorator.logger")
-    def test_send_log_to_firehose_success(self, mock_logger, mock_firehose_client):
+    def test_send_log_to_firehose_success(self, mock_firehose_client):
         """Test send_log_to_firehose with successful firehose response"""
         # Arrange
         test_log_data = {"function_name": "test_func", "result": "success"}
@@ -30,12 +38,9 @@ def test_send_log_to_firehose_success(self, mock_logger, mock_firehose_client):
             DeliveryStreamName=self.test_stream,
             Record=expected_record
         )
-        mock_logger.info.assert_called_once_with("Log sent to Firehose: %s", mock_response)
-        mock_logger.exception.assert_not_called()
 
     @patch("common.log_decorator.firehose_client")
-    @patch("common.log_decorator.logger")
-    def test_send_log_to_firehose_exception(self, mock_logger, mock_firehose_client):
+    def test_send_log_to_firehose_exception(self, mock_firehose_client):
         """Test send_log_to_firehose with firehose exception"""
         # Arrange
         test_log_data = {"function_name": "test_func", "result": "error"}
@@ -46,16 +51,14 @@ def test_send_log_to_firehose_exception(self, mock_logger, mock_firehose_client)
 
         # Assert
         mock_firehose_client.put_record.assert_called_once()
-        mock_logger.exception.assert_called_once_with(
+        self.mock_logger_exception.assert_called_once_with(
             "Error sending log to Firehose: %s",
             mock_firehose_client.put_record.side_effect
         )
-        mock_logger.info.assert_not_called()
 
     @patch("common.log_decorator.send_log_to_firehose")
-    @patch("common.log_decorator.logger")
     @patch("time.time")
-    def test_generate_and_send_logs_success(self, mock_time, mock_logger, mock_send_log):
+    def test_generate_and_send_logs_success(self, mock_time, mock_send_log):
         """Test generate_and_send_logs with successful log generation"""
         # Arrange
         mock_time.return_value = 1000.5
@@ -74,14 +77,12 @@ def test_generate_and_send_logs_success(self, mock_time, mock_logger, mock_send_
             "statusCode": 200,
             "result": "success"
         }
-        mock_logger.info.assert_called_once_with(json.dumps(expected_log_data))
-        mock_logger.error.assert_not_called()
+        self.mock_logger_error.assert_not_called()
         mock_send_log.assert_called_once_with(self.test_stream, expected_log_data)
 
     @patch("common.log_decorator.send_log_to_firehose")
-    @patch("common.log_decorator.logger")
     @patch("time.time")
-    def test_generate_and_send_logs_error(self, mock_time, mock_logger, mock_send_log):
+    def test_generate_and_send_logs_error(self, mock_time, mock_send_log):
         """Test generate_and_send_logs with error log generation"""
         # Arrange
         mock_time.return_value = 1000.75
@@ -100,15 +101,13 @@ def test_generate_and_send_logs_error(self, mock_time, mock_logger, mock_send_lo
             "statusCode": 500,
             "error": "Test error"
         }
-        mock_logger.error.assert_called_once_with(json.dumps(expected_log_data))
-        mock_logger.info.assert_not_called()
+        self.mock_logger_error.assert_called_once_with(json.dumps(expected_log_data))
         mock_send_log.assert_called_once_with(self.test_stream, expected_log_data)
 
     @patch("common.log_decorator.generate_and_send_logs")
-    @patch("common.log_decorator.logger")
     @patch("common.log_decorator.time")
     @patch("common.log_decorator.datetime")
-    def test_logging_decorator_success(self, mock_datetime, mock_time, mock_logger, mock_generate_send):
+    def test_logging_decorator_success(self, mock_datetime, mock_time, mock_generate_send):
         """Test logging_decorator with successful function execution"""
         # Arrange
         mock_datetime.now.return_value = datetime(2023, 1, 1, 12, 0, 0)
@@ -124,7 +123,6 @@ def test_function(x, y):
 
         # Assert
         self.assertEqual(result, {"statusCode": 200, "result": 5})
-        mock_logger.info.assert_called_once_with("Starting function: %s", "test_function")
 
         # Verify generate_and_send_logs was called with correct parameters
         mock_generate_send.assert_called_once()
@@ -137,10 +135,9 @@ def test_function(x, y):
         self.assertNotIn("is_error_log", call_kwargs)  # Should not be error log
 
     @patch("common.log_decorator.generate_and_send_logs")
-    @patch("common.log_decorator.logger")
     @patch("common.log_decorator.time")
     @patch("common.log_decorator.datetime")
-    def test_logging_decorator_exception(self, mock_datetime, mock_time, mock_logger, mock_generate_send):
+    def test_logging_decorator_exception(self, mock_datetime, mock_time, mock_generate_send):
         """Test logging_decorator with function raising exception"""
         # Arrange
         mock_datetime.now.return_value = datetime(2023, 1, 1, 12, 0, 0)
@@ -155,8 +152,6 @@ def test_function_with_error():
         with self.assertRaises(ValueError):
             test_function_with_error()
 
-        mock_logger.info.assert_called_once_with("Starting function: %s", "test_function_with_error")
-
         # Verify generate_and_send_logs was called with error parameters
         mock_generate_send.assert_called_once()
         call_args = mock_generate_send.call_args[0]
@@ -169,8 +164,7 @@ def test_function_with_error():
         self.assertTrue(call_kwargs.get("is_error_log", False))  # Should be error log
 
     @patch("common.log_decorator.generate_and_send_logs")
-    @patch("common.log_decorator.logger")
-    def test_logging_decorator_preserves_function_metadata(self, mock_logger, mock_generate_send):
+    def test_logging_decorator_preserves_function_metadata(self, mock_generate_send):
         """Test that the decorator preserves the original function's metadata"""
         # Arrange
         mock_generate_send.return_value = None