Good Tests

Author: nhsdevws

delta_backend/src/delta.py

@@ -28,7 +28,7 @@ def send_message(record):
         sqs_client.send_message(QueueUrl=failure_queue_url, MessageBody=json.dumps(message_body))
         logger.info("Record saved successfully to the DLQ")
     except ClientError as e:
-        logger.info(f"Error sending record to DLQ: {e}")
+        logger.error(f"Error sending record to DLQ: {e}")
 
 
 def get_vaccine_type(patientsk) -> str:
@@ -37,7 +37,7 @@ def get_vaccine_type(patientsk) -> str:
 
 
 def handler(event, context):
-
+    firehose_logger.send_log(event) 
     logger.info("Starting Delta Handler")
     log_data = dict()
     firehose_log = dict()
@@ -145,6 +145,7 @@ def handler(event, context):
                 return {"statusCode": 500, "body": "Records not processed successfully"}
 
     except Exception as e:
+
         operation_outcome["statusCode"] = "500"
         operation_outcome["statusDesc"] = "Exception"
         if intrusion_check:

delta_backend/src/log_firehose.py

@@ -22,6 +22,7 @@ def send_log(self, log_message):
         log_to_splunk = log_message
         logger.info(f"Log sent to Firehose for save: {log_to_splunk}")
         encoded_log_data = json.dumps(log_to_splunk).encode("utf-8")
+        
         try:
             response = self.firehose_client.put_record(
                 DeliveryStreamName=self.delivery_stream_name,

delta_backend/tests/test_convert_to_flat_json.py

@@ -1116,4 +1116,4 @@ def _run_test_practitioner_surname(self, expected_forename):
         self.assertEqual(flat_json[0]["PERFORMING_PROFESSIONAL_SURNAME"], expected_forename)
 
     if __name__ == "__main__":
-        unittest.main()
+        unittest.main()

delta_backend/tests/test_delta.py

@@ -1,59 +1,47 @@
 import unittest
-import os
 from unittest.mock import patch, MagicMock
 from botocore.exceptions import ClientError
-from sample_data.test_resource_data import get_test_data_resource
+import os
+from tests.sample_data.test_resource_data import get_test_data_resource
 
 # Set environment variables before importing the module
 os.environ["AWS_SQS_QUEUE_URL"] = "https://sqs.us-east-1.amazonaws.com/123456789012/MyQueue"
 os.environ["DELTA_TABLE_NAME"] = "my_delta_table"
 os.environ["SOURCE"] = "my_source"
-os.environ["SPLUNK_FIREHOSE_NAME"] = "my_firehose"
 
 from src.delta import send_message, handler  # Import after setting environment variables
 import json
 
 
+
 class DeltaTestCase(unittest.TestCase):
 
     def setUp(self):
         # Common setup if needed
         self.context = {}
+        self.logger_exception_patcher = patch("logging.Logger.exception")
+        self.mock_logger_exception = self.logger_exception_patcher.start()
+
+        self.firehose_logger_patcher = patch("src.delta.firehose_logger")
+        self.mock_firehose_logger = self.firehose_logger_patcher.start()
+        self.mock_firehose_logger.send_log = MagicMock()
+
+
+    def tearDown(self):
+        self.logger_exception_patcher.stop()
+        self.mock_firehose_logger.stop()
 
     @staticmethod
     def setup_mock_sqs(mock_boto_client, return_value={"ResponseMetadata": {"HTTPStatusCode": 200}}):
         mock_sqs = mock_boto_client.return_value
         mock_sqs.send_message.return_value = return_value
         return mock_sqs
 
-    @staticmethod
-    def setup_mock_firehose(mock_boto_client, return_value={"ResponseMetadata": {"HTTPStatusCode": 200}}):
-        mock_firehose = mock_boto_client.return_value
-        mock_firehose.put_record.return_value = return_value
-        return mock_firehose
-
-    @staticmethod
-    def setup_mock_firehose(mock_boto_client, return_value={"ResponseMetadata": {"HTTPStatusCode": 200}}):
-        mock_firehose = mock_boto_client.return_value
-        mock_firehose.put_record.return_value = return_value
-        return mock_firehose
-
-
     @staticmethod
     def setup_mock_dynamodb(mock_boto_resource, status_code=200):
-        """
-        Sets up a mock for boto3.resource("dynamodb") and its Table method.
-        """
-        # Mock the DynamoDB resource
         mock_dynamodb = mock_boto_resource.return_value
-
-        # Mock the Table method
-        mock_table = MagicMock()
-        mock_dynamodb.Table.return_value = mock_table
-
-        # Mock the put_item method of the table
+        mock_table = mock_dynamodb.Table.return_value
         mock_table.put_item.return_value = {"ResponseMetadata": {"HTTPStatusCode": status_code}}
-
         return mock_table
 
     def setUp_mock_resources(self, mock_boto_resource, mock_boto_client):
@@ -123,8 +111,8 @@ def test_send_message_success(self, mock_boto_client):
         )
 
     @patch("boto3.client")
-    @patch("logging.Logger.info")
-    def test_send_message_client_error(self, mock_logger_info, mock_boto_client):
+    @patch("logging.Logger.error")
+    def test_send_message_client_error(self, mock_logger_error, mock_boto_client):
         # Arrange
         mock_sqs = MagicMock()
         mock_boto_client.return_value = mock_sqs
@@ -138,33 +126,27 @@ def test_send_message_client_error(self, mock_logger_info, mock_boto_client):
         send_message(record)
 
         # Assert
-        mock_logger_info.assert_called_once_with(
+        mock_logger_error.assert_called_once_with(
             f"Error sending record to DLQ: An error occurred (500) when calling the SendMessage operation: Internal Server Error"
         )
 
-    @patch("delta.FirehoseLogger.send_log")
     @patch("boto3.resource")
-    def test_handler_success_insert(self, mock_boto_resource, mock_send_log):
+    def test_handler_success_insert(self, mock_boto_resource):
         # Arrange
-        mock_send_log.return_value = None
         self.setup_mock_dynamodb(mock_boto_resource)
         suppilers = ["DPS", "EMIS"]
         for supplier in suppilers:
             event = self.get_event(supplier=supplier)
-            for record in event["Records"]:
-                record["dynamodb"]["NewImage"]["Resource"]["S"] = json.dumps(get_test_data_resource())
 
             # Act
             result = handler(event, self.context)
 
             # Assert
             self.assertEqual(result["statusCode"], 200)
 
-    @patch("delta.FirehoseLogger.send_log")
     @patch("boto3.resource")
-    def test_handler_failure(self, mock_boto_resource, mock_send_log):
+    def test_handler_failure(self, mock_boto_resource):
         # Arrange
-        mock_send_log.return_value = None
         self.setup_mock_dynamodb(mock_boto_resource, status_code=500)
         event = self.get_event()
 
@@ -174,11 +156,9 @@ def test_handler_failure(self, mock_boto_resource, mock_send_log):
         # Assert
         self.assertEqual(result["statusCode"], 500)
 
-    @patch("delta.FirehoseLogger.send_log")
     @patch("boto3.resource")
-    def test_handler_success_update(self, mock_boto_resource, mock_send_log):
+    def test_handler_success_update(self, mock_boto_resource):
         # Arrange
-        mock_send_log.return_value = None
         self.setup_mock_dynamodb(mock_boto_resource)
         event = self.get_event(event_name="UPDATE", operation="UPDATE")
 
@@ -188,11 +168,9 @@ def test_handler_success_update(self, mock_boto_resource, mock_send_log):
         # Assert
         self.assertEqual(result["statusCode"], 200)
 
-    @patch("delta.FirehoseLogger.send_log")
     @patch("boto3.resource")
-    def test_handler_success_remove(self, mock_boto_resource, mock_send_log):
+    def test_handler_success_remove(self, mock_boto_resource):
         # Arrange
-        mock_send_log.return_value = None
         self.setup_mock_dynamodb(mock_boto_resource)
         event = self.get_event(event_name="REMOVE", operation="DELETE")
 
@@ -202,12 +180,10 @@ def test_handler_success_remove(self, mock_boto_resource, mock_send_log):
         # Assert
         self.assertEqual(result["statusCode"], 200)
 
-    @patch("delta.FirehoseLogger.send_log")  # Patch the method directly
     @patch("boto3.resource")
     @patch("boto3.client")
-    def test_handler_exception_intrusion_check(self, mock_boto_resource, mock_boto_client, mock_send_log):
+    def test_handler_exception_intrusion_check(self, mock_boto_resource, mock_boto_client):
         # Arrange
-        mock_send_log.return_value = None
         self.setup_mock_dynamodb(mock_boto_resource, status_code=500)
         mock_boto_client.return_value = MagicMock()
         event = self.get_event()
@@ -217,73 +193,53 @@ def test_handler_exception_intrusion_check(self, mock_boto_resource, mock_boto_c
         result = handler(event, self.context)
         self.assertEqual(result["statusCode"], 500)
 
-    @patch("delta.FirehoseLogger.send_log")  # Patch the method directly
     @patch("boto3.resource")
     @patch("boto3.client")
-    def test_handler_exception_intrusion(self, mock_boto_resource, mock_boto_client, mock_send_log):
+    def test_handler_exception_intrusion(self, mock_boto_client, mock_boto_resource):
         # Arrange
         self.setUp_mock_resources(mock_boto_resource, mock_boto_client)
-        mock_send_log.return_value = None
+
         event = self.get_event()
         context = {}
 
         # Act & Assert
         with self.assertRaises(Exception):
             handler(event, context)
 
-    @patch("delta.FirehoseLogger.send_log")
+        self.mock_logger_exception.assert_called_once_with("Delta Lambda failure: Test Exception")
+
     @patch("boto3.resource")
     @patch("delta.handler")
-    def test_handler_exception_intrusion_check_false(self, mock_boto_resource, mock_boto_client, mock_send_log):
+    def test_handler_exception_intrusion_check_false(self, mocked_intrusion, mock_boto_client):
         # Arrange
-        mock_send_log.return_value = None
-        self.setUp_mock_resources(mock_boto_resource, mock_boto_client)
+        self.setUp_mock_resources(mocked_intrusion, mock_boto_client)
         event = self.get_event()
         context = {}
 
         # Act & Assert
         with self.assertRaises(Exception):
             handler(event, context)
 
-    @patch("delta.FirehoseLogger.send_log")  # Patch the method directly
-    @patch("boto3.client")
-    @patch("delta.logger.info")
-    def test_dps_record_skipped(self, mock_logger_info, mock_boto_client, mock_send_log):
-        """
-        Test that DPSFULL records are skipped and Firehose put_record is mocked.
-        """
-        # Arrange
-        mock_firehose_client = self.setup_mock_firehose(mock_boto_client)
-
-        mock_send_log.return_value = None
+    @patch("delta.logger.info")  # Mock logging
+    def test_dps_record_skipped(self, mock_logger_info):
 
-        # Create a test event with supplier "DPSFULL"
         event = self.get_event(supplier="DPSFULL")
         context = {}
 
-        # Act
         response = handler(event, context)
+        print(f"final response1: {response}")
 
-        # Assert
-        # check send_log was called
-        mock_send_log.assert_called_once()
         self.assertEqual(response["statusCode"], 200)
         self.assertEqual(response["body"], "Record from DPS skipped for 12345")
 
-        # Check logging was called
+        # Check logging and Firehose were called
         mock_logger_info.assert_called_with("Record from DPS skipped for 12345")
 
-        # Ensure Firehose put_record was not called since DPSFULL records are skipped
-        mock_firehose_client.put_record.assert_not_called()
-
-    # # TODO - amend test once error handling implemented
-    @patch("delta.FirehoseLogger.send_log")  # Patch the method directly
+    # TODO - amend test once error handling implemented
     @patch("delta.logger.info")
     @patch("Converter.Converter")
     @patch("delta.boto3.resource")
-    def test_partial_success_with_errors(self, mock_dynamodb, mock_converter, mock_logger_info, mock_send_log):
-
-        mock_send_log.return_value = None
+    def test_partial_success_with_errors(self, mock_dynamodb, mock_converter, mock_logger_info):
         mock_converter_instance = MagicMock()
         mock_converter_instance.runConversion.return_value = [{}]
         mock_converter_instance.getErrorRecords.return_value = [{"error": "Invalid field"}]

delta_backend/tests/test_log_firehose.py

@@ -0,0 +1,62 @@
+import unittest
+from unittest.mock import patch, MagicMock
+import json
+from src.log_firehose import FirehoseLogger
+
+
+class TestFirehoseLogger(unittest.TestCase):
+
+    @patch("boto3.client")
+    def test_send_log(self, mock_boto_client):
+        """it should send log message to Firehose"""
+
+        # Arrange
+        mock_response = {
+            "RecordId": "shardId-000000000000000000000001",
+            "ResponseMetadata": {
+            "RequestId": "12345abcde67890fghijk",
+            "HTTPStatusCode": 200, 
+            "RetryAttempts": 0
+            }
+        }        
+        mock_firehose_client = MagicMock()
+        mock_boto_client.return_value = mock_firehose_client
+        mock_firehose_client.put_record.return_value = mock_response
+        
+        stream_name = "stream_name"
+        firehose_logger = FirehoseLogger(boto_client=mock_firehose_client, stream_name=stream_name)    
+        log_message = {"text": "Test log message"}
+
+        # Act
+        firehose_logger.send_log(log_message)
+
+        # Assert
+        mock_firehose_client.put_record.assert_called_once()
+        self.assertEqual(mock_firehose_client.put_record.return_value, mock_response)
+
+    @patch("boto3.client")
+    def test_send_log_failure(self, mock_boto_client):
+        """Test that send_log logs an exception when put_record fails."""
+
+        # Arrange
+        mock_firehose_client = MagicMock()
+        mock_boto_client.return_value = mock_firehose_client
+        mock_firehose_client.put_record.side_effect = Exception("Test exception")
+
+        stream_name = "test-stream"
+        firehose_logger = FirehoseLogger(boto_client=mock_firehose_client, stream_name=stream_name)
+        log_message = {"key": "value"}
+
+        with patch("src.log_firehose.logger.exception") as mock_logger_exception:
+            # Act
+            firehose_logger.send_log(log_message)
+
+            # Assert
+            mock_firehose_client.put_record.assert_called_once_with(
+                DeliveryStreamName="test-stream",
+                Record={"Data": json.dumps(log_message).encode("utf-8")},
+            )
+            mock_logger_exception.assert_called_once_with("Error sending log to Firehose: Test exception")
+
+if __name__ == "__main__":
+    unittest.main()