WIP

nhsdevws · nhsdevws · commit 0dbc62aaf182 · 2025-08-20T16:25:27.000+01:00
diff --git a/ack_backend/Makefile b/ack_backend/Makefile
@@ -6,6 +6,6 @@ package: build
 	docker run --rm -v $(shell pwd)/build:/build ack-lambda-build
 	
 test:
-	python -m unittest
+	@PYTHONPATH=src:tests python -m unittest
 
 .PHONY: build package 
diff --git a/ack_backend/src/update_ack_file.py b/ack_backend/src/update_ack_file.py
@@ -76,16 +76,12 @@ def upload_ack_file(
 ) -> None:
     """Adds the data row to the uploaded ack file"""
     for row in ack_data_rows:
-        print(f"add row {row} to ack file")
         data_row_str = [str(item) for item in row.values()]
         cleaned_row = "|".join(data_row_str).replace(" |", "|").replace("| ", "|").strip()
         accumulated_csv_content.write(cleaned_row + "\n")
 
-
     csv_file_like_object = BytesIO(accumulated_csv_content.getvalue().encode("utf-8"))
     s3_client.upload_fileobj(csv_file_like_object, ACK_BUCKET_NAME, temp_ack_file_key)
-    
-    debug_print("upload_ack_file...2")
 
     row_count_source = get_row_count(SOURCE_BUCKET_NAME, f"processing/{file_key}")
     row_count_destination = get_row_count(ACK_BUCKET_NAME, temp_ack_file_key)
diff --git a/ack_backend/src/utils_for_ack_lambda.py b/ack_backend/src/utils_for_ack_lambda.py
@@ -1,34 +1,11 @@
 """Utils for ack lambda"""
 
 from clients import s3_client
-from tests.utils.values_for_ack_backend_tests import MessageDetails
 
 def get_row_count(bucket_name: str, file_key: str) -> int:
     """
     Looks in the given bucket and returns the count of the number of lines in the given file.
     NOTE: Blank lines are not included in the count.
     """
-    try:
-        response = s3_client.get_object(Bucket=bucket_name, Key=file_key)
-        if "Body" not in response or response["Body"] is None:
-            print(f"Error getting row count: No Body in response for {bucket_name}/{file_key}")
-            return 0
-        ret=sum(1 for line in response["Body"].iter_lines() if line.strip())
-        print(f"Row count {bucket_name}-{file_key}: {ret}")
-    except Exception as e:
-        print(f"Row count {bucket_name}-{file_key}: 0")
-        return 0
-
-from constants import ACK_HEADERS, SOURCE_BUCKET_NAME, ACK_BUCKET_NAME, FILE_NAME_PROC_LAMBDA_NAME
-
-def debug_print(title, show_source=False):
-    rsv_ravs = MessageDetails("RSV", "RAVS", "X26")
-    print(f"Debug rowcount: {title}")
-
-    if show_source:
-        row_count_source = get_row_count(SOURCE_BUCKET_NAME, f"processing/{rsv_ravs.file_key}")
-        print(f"Row count in source bucket: {row_count_source}")    
-    
-    row_count_destination = get_row_count(ACK_BUCKET_NAME, "TempAck/RSV_Vaccinations_v5_X26_20210730T12000000_BusAck_20211120T12000000.csv")
-
-    print(f"Row count in destination bucket: {row_count_destination}")
+    response = s3_client.get_object(Bucket=bucket_name, Key=file_key)
+    return sum(1 for line in response["Body"].iter_lines() if line.strip())
diff --git a/ack_backend/tests/test_ack_processor2.py b/ack_backend/tests/test_ack_processor2.py
@@ -0,0 +1,82 @@
+import unittest
+from unittest.mock import patch, MagicMock
+import json
+
+from ack_processor import lambda_handler
+
+
+class TestAckLambdaHandler(unittest.TestCase):
+    def setUp(self):
+        convert_patcher = patch("ack_processor.convert_message_to_ack_row")
+        self.mock_convert = convert_patcher.start()
+        update_patcher = patch("ack_processor.update_ack_file")
+        self.mock_update = update_patcher.start()
+        decorator_patcher = patch("ack_processor.ack_lambda_handler_logging_decorator", lambda x: x)
+        self.mock_decorator = decorator_patcher.start()
+
+        # Mock behavior
+        self.mock_convert.side_effect = lambda message, created_at: {
+            "row_id": message["row_id"],
+            "status": "ACK"
+        }
+
+    def tearDown(self):
+        patch.stopall()
+
+    def test_lambda_handler_success(self):
+        message_body = [
+            {
+                "file_key": "file1.csv",
+                "row_id": "123^abc",
+                "vaccine_type": "typeA",
+                "supplier": "supplierX",
+                "created_at_formatted_string": "2025-01-01T00:00:00Z"
+            },
+            {
+                "file_key": "file1.csv",
+                "row_id": "124^def",
+                "vaccine_type": "typeA",
+                "supplier": "supplierX",
+                "created_at_formatted_string": "2025-01-01T00:00:00Z"
+            }
+        ]
+        event = {
+            "Records": [
+                {"body": json.dumps(message_body)}
+            ]
+        }
+
+        result = lambda_handler(event, None)
+
+        self.assertEqual(result["statusCode"], 200)
+        self.assertIn("Lambda function executed successfully", result["body"])
+        self.mock_update.assert_called_once()
+        self.assertEqual(self.mock_convert.call_count, 2)
+
+    def test_lambda_handler_no_records(self):
+        event = {}
+
+        with self.assertRaises(ValueError) as context:
+            lambda_handler(event, None)
+
+        self.assertIn("No records found in the event", str(context.exception))
+        self.mock_update.assert_not_called()
+        self.mock_convert.assert_not_called()
+
+    def test_lambda_handler_body_json_decode_error(self):
+        event = {
+            "Records": [
+                {"body": "{invalid_json"}
+            ]
+        }
+
+        with self.assertRaises(ValueError) as context:
+            lambda_handler(event, None)
+
+        self.assertIn("Could not load incoming message body", str(context.exception))
+        self.mock_update.assert_not_called()
+        self.mock_convert.assert_not_called()
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/ack_backend/tests/test_logging_decorators.py b/ack_backend/tests/test_logging_decorators.py
@@ -0,0 +1,131 @@
+import unittest
+from unittest.mock import patch, MagicMock, call
+import logging_decorators
+import json
+import time
+
+class TestLoggingDecorators(unittest.TestCase):
+    def setUp(self):
+        # Patch logger and firehose_client
+        self.logger_patcher = patch('logging_decorators.logger')
+        self.mock_logger = self.logger_patcher.start()
+        self.firehose_patcher = patch('logging_decorators.firehose_client')
+        self.mock_firehose = self.firehose_patcher.start()
+
+    def tearDown(self):
+        self.logger_patcher.stop()
+        self.firehose_patcher.stop()
+
+    def test_send_log_to_firehose_success(self):
+        log_data = {"foo": "bar"}
+        logging_decorators.send_log_to_firehose(log_data)
+        self.mock_firehose.put_record.assert_called_once()
+        self.mock_logger.info.assert_called_with("Log sent to Firehose")
+
+    def test_send_log_to_firehose_exception(self):
+        self.mock_firehose.put_record.side_effect = Exception("fail!")
+        log_data = {"foo": "bar"}
+        logging_decorators.send_log_to_firehose(log_data)
+        self.mock_logger.exception.assert_called()
+        self.assertIn("Error sending log to Firehose", self.mock_logger.exception.call_args[0][0])
+
+    def test_generate_and_send_logs_info(self):
+        start_time = time.time() - 1
+        base_log_data = {"base": "data"}
+        additional_log_data = {"extra": "info"}
+        logging_decorators.generate_and_send_logs(start_time, base_log_data, additional_log_data)
+        self.mock_logger.info.assert_called()
+        self.mock_firehose.put_record.assert_called_once()
+
+    def test_generate_and_send_logs_error(self):
+        start_time = time.time() - 1
+        base_log_data = {"base": "data"}
+        additional_log_data = {"extra": "info"}
+        logging_decorators.generate_and_send_logs(start_time, base_log_data, additional_log_data, is_error_log=True)
+        self.mock_logger.error.assert_called()
+        self.mock_firehose.put_record.assert_called_once()
+
+    def test_process_diagnostics_dict(self):
+        diagnostics = {"statusCode": 400, "error_message": "bad request"}
+        result = logging_decorators.process_diagnostics(diagnostics, "file.csv", "msg-1")
+        self.assertEqual(result["status"], "fail")
+        self.assertEqual(result["statusCode"], 400)
+        self.assertEqual(result["diagnostics"], "bad request")
+
+    def test_process_diagnostics_string(self):
+        diagnostics = "some error"
+        result = logging_decorators.process_diagnostics(diagnostics, "file.csv", "msg-1")
+        self.assertEqual(result["status"], "fail")
+        self.assertEqual(result["statusCode"], 500)
+        self.assertEqual(result["diagnostics"], "Unable to determine diagnostics issue")
+
+    def test_process_diagnostics_missing_keys(self):
+        result = logging_decorators.process_diagnostics(None, "file_key_missing", "unknown")
+        self.assertEqual(result["status"], "fail")
+        self.assertEqual(result["statusCode"], 500)
+        self.assertIn("unhandled error", result["diagnostics"])
+
+    def test_process_diagnostics_success(self):
+        result = logging_decorators.process_diagnostics(None, "file.csv", "msg-1")
+        self.assertEqual(result["status"], "success")
+        self.assertEqual(result["statusCode"], 200)
+        self.assertIn("Operation completed successfully", result["diagnostics"])
+
+    def test_convert_message_to_ack_row_logging_decorator_success(self):
+        @logging_decorators.convert_message_to_ack_row_logging_decorator
+        def dummy_func(message, created_at_formatted_string):
+            return "ok"
+
+        message = {
+            "file_key": "file.csv",
+            "row_id": "row-1",
+            "vaccine_type": "type",
+            "supplier": "sup",
+            "local_id": "loc",
+            "operation_requested": "op"
+        }
+        result = dummy_func(message, "2024-08-20T12:00:00Z")
+        self.assertEqual(result, "ok")
+        self.mock_logger.info.assert_called()
+        self.mock_firehose.put_record.assert_called()
+
+    def test_convert_message_to_ack_row_logging_decorator_exception(self):
+        @logging_decorators.convert_message_to_ack_row_logging_decorator
+        def dummy_func(message, created_at_formatted_string):
+            raise ValueError("fail!")
+
+        message = {
+            "file_key": "file.csv",
+            "row_id": "row-1",
+            "vaccine_type": "type",
+            "supplier": "sup",
+            "local_id": "loc",
+            "operation_requested": "op"
+        }
+        with self.assertRaises(ValueError):
+            dummy_func(message, "2024-08-20T12:00:00Z")
+        self.mock_logger.error.assert_called()
+        self.mock_firehose.put_record.assert_called()
+
+    def test_ack_lambda_handler_logging_decorator_success(self):
+        @logging_decorators.ack_lambda_handler_logging_decorator
+        def dummy_lambda(event, context):
+            return "lambda-ok"
+
+        result = dummy_lambda({}, {})
+        self.assertEqual(result, "lambda-ok")
+        self.mock_logger.info.assert_called()
+        self.mock_firehose.put_record.assert_called()
+
+    def test_ack_lambda_handler_logging_decorator_exception(self):
+        @logging_decorators.ack_lambda_handler_logging_decorator
+        def dummy_lambda(event, context):
+            raise RuntimeError("fail!")
+
+        with self.assertRaises(RuntimeError):
+            dummy_lambda({}, {})
+        self.mock_logger.error.assert_called()
+        self.mock_firehose.put_record.assert_called()
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/ack_backend/tests/test_update_ack_file.py b/ack_backend/tests/test_update_ack_file.py
diff --git a/ack_backend/tests/test_update_ack_file2.py b/ack_backend/tests/test_update_ack_file2.py
