correct unit test

Author: Akol125

delta_backend/.coverage

@@ -100,9 +100,14 @@ def _log_error(self, fieldName, fieldValue, e, code=ExceptionMessages.RECORD_CHE
         if isinstance(e, Exception):
             message = ExceptionMessages.MESSAGES[ExceptionMessages.UNEXPECTED_EXCEPTION] % (e.__class__.__name__, str(e))
         else:
-            message = str(e)  # if a simple string message was passed
+            message = str(e)  # if a simple string message was passed 
+
+        # Ensure message-level deduplication
+        if any(existing.get("message") == message for existing in self.errorRecords):
+            return 
+
         self.errorRecords.append({
-            "code":code,
+            "code": code,
             "field": fieldName,
             "value": fieldValue,
             "message": message

delta_backend/src/ConversionChecker.py

@@ -28,6 +28,24 @@ class Converter:
     def __init__(self, fhir_data):
         self.FHIRData = fhir_data  # Store JSON data directly
         self.SchemaFile = ConversionLayout.ConvertLayout
+        # self.ErrorRecords = []
+    
+    # Utility logs tailored to conveter class errors
+    def _log_error(self,e,code=ExceptionMessages.UNEXPECTED_EXCEPTION): 
+        message = str(e)  # if a simple string message was passed 
+    
+        if any(existing.get("message") == message for existing in ErrorRecords): 
+            return
+        
+        error_obj = {
+        "code": code,
+        "message": message
+        }
+
+        # Ensure message-level deduplication
+        # if not any(existing.get("message") == message for existing in self.ErrorRecords):
+        ErrorRecords.append(error_obj)
+        return error_obj
 
     # create a FHIR  parser - uses fhir json data from delta 
     # (helper methods to extract values from the nested FHIR structure)
@@ -74,10 +92,8 @@ def runConversion(self, json_data, summarise=False, report_unexpected_exception=
             dataParser = self._getFHIRParser(self.FHIRData)
         except Exception as e:
             if report_unexpected_exception:
-                message = "FHIR Parser Unexpected exception [%s]: %s" % (e.__class__.__name__, e)
-                p = {"code": 0, "message": message}
-                ErrorRecords.append(p)
-                return p
+                error = self._log_error("FHIR Parser Unexpected exception [%s]: %s" % (e.__class__.__name__, e),code=0)
+                return error
 
         try:
             schemaParser = self._getSchemaParser(self.SchemaFile)
@@ -87,6 +103,9 @@ def runConversion(self, json_data, summarise=False, report_unexpected_exception=
                 p = {"code": 0, "message": message}
                 ErrorRecords.append(p)
                 return p
+                # error = self._log_error("FHIR Parser Unexpected exception [%s]: %s" % (e.__class__.__name__, e),code=0)
+                # return error
+
 
         try:
             ConversionValidate = ConversionChecker(dataParser, summarise, report_unexpected_exception)
@@ -128,6 +147,9 @@ def runConversion(self, json_data, summarise=False, report_unexpected_exception=
     def getErrorRecords(self):
         return ErrorRecords
 
+    # def getErrorRecords(self):
+    #     return self.ErrorRecords
+    
     def extract_patient_details(self, json_data, FlatFieldName):
         if not hasattr(self, "_cached_values"):
             self._cached_values = {}

delta_backend/src/Converter.py

@@ -46,7 +46,7 @@
         "coding": [
           {
             "system": "http://snomed.info/sct",
-            "code": "13246810000001",
+            "code": "13246810000001git",
             "display": "Administration of first dose of severe acute respiratory syndrome coronavirus 2 vaccine (procedure)"
           }
         ]

delta_backend/tests/sample_data/fhir_sample.json

@@ -25,7 +25,7 @@
 request_json_data = ValuesForTests.json_data
 with patch.dict("os.environ", MOCK_ENV_VARS):
     from delta import handler, Converter
-    from Converter import imms, ErrorRecords
+    from Converter import imms
 
 
 @patch.dict("os.environ", MOCK_ENV_VARS, clear=True)
@@ -215,22 +215,27 @@ def test_fhir_parser_exception(self, mock_fhir_parser):
         self.assertEqual(len(response), 2)
         self.assertIn("FHIR Parser Unexpected exception", converter.getErrorRecords()[0]["message"])
         self.assertEqual(converter.getErrorRecords()[0]["code"], 0)
-
+    
+    @patch("Converter.FHIRParser")
     @patch("Converter.SchemaParser")
-    def test_schema_parser_exception(self, mock_schema_parser):
+    def test_schema_parser_exception(self, mock_schema_parser, mock_fhir_parser):
+
+        # Mock FHIRParser to return normally
+        mock_fhir_instance = Mock()
+        mock_fhir_instance.parseFHIRData.return_value = None
+        mock_fhir_parser.return_value = mock_fhir_instance
+
         # Mock SchemaParser to raise an exception
         mock_schema_parser.side_effect = Exception("Schema Parsing Error")
-        converter = Converter(fhir_data="some_data")
+        converter = Converter(fhir_data="{}")
 
-        response = converter.runConversion("some_data")
+        converter.runConversion("some_data")
 
         # Check if the error message was added to ErrorRecords
-        self.assertEqual(len(response), 2)
-        self.assertIn(
-            "FHIR Parser Unexpected exception [JSONDecodeError]: Expecting value: line 1 column 1 (char 0)",
-            converter.getErrorRecords()[0]["message"],
-        )
-        self.assertEqual(converter.getErrorRecords()[0]["code"], 0)
+        errors = converter.getErrorRecords()
+        self.assertEqual(len(errors), 3)
+        self.assertIn("Schema Parser Unexpected exception", errors[2]["message"])
+        self.assertEqual(errors[0]["code"], 0)
 
     @patch("Converter.ConversionChecker")
     def test_conversion_checker_exception(self, mock_conversion_checker):
@@ -257,7 +262,7 @@ def test_get_conversions_exception(self, mock_get_conversions):
         response = converter.runConversion(ValuesForTests.json_data)
 
         # Check if the error message was added to ErrorRecords
-        self.assertEqual(len(converter.getErrorRecords()), 3)
+        self.assertEqual(len(converter.getErrorRecords()), 2)
         self.assertIn(
             "FHIR Parser Unexpected exception [JSONDecodeError]: Expecting value: line 1 column 1 (char 0)",
             converter.getErrorRecords()[0]["message"],
@@ -269,7 +274,6 @@ def test_get_conversions_exception(self, mock_get_conversions):
     def test_conversion_exceptions(self, mock_get_key_value, mock_get_conversions):
         mock_get_conversions.side_effect = Exception("Error while getting conversions")
         mock_get_key_value.side_effect = Exception("Key value retrieval failed")
-        ErrorRecords.clear()
         converter = Converter(fhir_data="some_data")
 
         schema = {
@@ -383,7 +387,7 @@ def test_convert_to_date(self, MockLookUpData):
         self.assertIn("Date cannot be in the future", messages)
 
         # Confirm Total Errors Per conversion
-        self.assertEqual(len(checker.errorRecords), 5)
+        self.assertEqual(len(checker.errorRecords), 4)
 
     @patch("ConversionChecker.LookUpData")
     def test_convert_to_date_time(self, MockLookUpData):
@@ -536,6 +540,7 @@ def _run_test(self, expected_forename):
         flat_json = self.converter.runConversion(request_json_data, False, True)
         self.assertEqual(flat_json[0]["PERSON_FORENAME"], expected_forename)
 
+
 class TestPersonSurNameToFlatJson(unittest.TestCase):
 
     def test_person_surname_multiple_names_official(self):
@@ -624,6 +629,7 @@ def _run_test_surname(self, expected_forename):
         flat_json = self.converter.runConversion(request_json_data, False, True)
         self.assertEqual(flat_json[0]["PERSON_SURNAME"], expected_forename)
 
+
 class TestPersonPostalCodeToFlatJson(unittest.TestCase):
     def test_person_postal_code_single_address(self):
         """Test case where only one address instance exists"""
@@ -712,6 +718,7 @@ def _run_postal_code_test(self, expected_postal_code):
         flat_json = self.converter.runConversion(request_json_data, False, True)
         self.assertEqual(flat_json[0]["PERSON_POSTCODE"], expected_postal_code)
 
+
 class TestPersonSiteCodeToFlatJson(unittest.TestCase):
     def test_site_code_single_performer(self):
         """Test case where only one performer instance exists"""
@@ -830,6 +837,7 @@ def _run_site_code_test(self, expected_site_code):
         flat_json = self.converter.runConversion(request_json_data, False, True)
         self.assertEqual(flat_json[0].get("SITE_CODE"), expected_site_code)
 
+
 class TestPersonSiteUriToFlatJson(unittest.TestCase):
     def test_site_uri_single_performer(self):
         """Test case where only one performer instance exists"""
@@ -920,6 +928,7 @@ def _run_site_uri_test(self, expected_site_code):
         flat_json = self.converter.runConversion(request_json_data, False, True)
         self.assertEqual(flat_json[0].get("SITE_CODE_TYPE_URI"), expected_site_code)
 
+
 class TestPractitionerForeNameToFlatJson(unittest.TestCase):
     def test_practitioner_forename_multiple_names_official(self):
         """Test case where multiple name instances exist, and one has use=official with period covering vaccination date"""
@@ -1035,6 +1044,7 @@ def _run_practitioner_test(self, expected_forename):
         flat_json = self.converter.runConversion(request_json_data, False, True)
         self.assertEqual(flat_json[0]["PERFORMING_PROFESSIONAL_FORENAME"], expected_forename)
 
+
 class TestPractitionerSurNameToFlatJson(unittest.TestCase):
     def test_practitioner_surname_multiple_names_official(self):
         """Test case where multiple name instances exist, and one has use=official with period covering vaccination date"""

delta_backend/tests/test_convert_to_flat_json.py

@@ -11,6 +11,7 @@
 from src.delta import send_message, handler  # Import after setting environment variables
 import json
 
+
 class DeltaTestCase(unittest.TestCase):
 
     def setUp(self):