review changes2

Author: Akol125

delta_backend/.coverage

@@ -102,10 +102,6 @@ def _log_error(self, fieldName, fieldValue, e, code=ExceptionMessages.RECORD_CHE
         else:
             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,
             "field": fieldName,
@@ -121,7 +117,7 @@ def _convertToDate(self, expressionRule, fieldName, fieldValue, summarise, repor
             if report_unexpected_exception:
                 self._log_error(fieldName, fieldValue, "Value is not a string")
             return ""
-        
+
         # Normalize expression rule
         format_str = expressionRule.replace("format:", "").strip()
 
@@ -269,7 +265,7 @@ def _convertToNHSNumber(self, expressionRule, fieldName, fieldValue, summarise,
         # If it is outright empty, return back an empty string
         if not fieldValue:
             return ""
-        
+
         try:
             regexRule = r"^\d{10}$"
             if isinstance(fieldValue, str) and re.fullmatch(regexRule, fieldValue):
@@ -302,7 +298,7 @@ def _convertToGender(self, expressionRule, fieldName, fieldValue, summarise, rep
                 "other": "9",
                 "unknown": "0"
             }
-        
+
             # Normalize input
             normalized_gender = str(fieldValue).lower()
 
@@ -336,7 +332,7 @@ def _convertToLookUp(self, expressionRule, fieldName, fieldValue, summarise, rep
                 lookUpValue = self.dataParser.getKeyValue(expressionRule)
                 IdentifiedLookup = self.dataLookUp.findLookUp(lookUpValue[0])
                 return IdentifiedLookup
-        
+
         except Exception as e:
             if report_unexpected_exception:
                 message = ExceptionMessages.MESSAGES[ExceptionMessages.UNEXPECTED_EXCEPTION] % (e.__class__.__name__, e)

delta_backend/data.json

@@ -32,16 +32,12 @@ def __init__(self, fhir_data):
     # 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 self.ErrorRecords): 
-            return
-        
+
         error_obj = {
             "code": code,
             "message": message
         }
 
-        # Ensure message-level deduplication
         # if not any(existing.get("message") == message for existing in self.ErrorRecords):
         self.ErrorRecords.append(error_obj)
         return error_obj
@@ -72,9 +68,8 @@ def _convertData(self, ConversionValidate, expression, dataParser, json_data):
             conversionValues = dataParser.getKeyValue(FHIRFieldName)
         except Exception as e:
             message = "Data get value Unexpected exception [%s]: %s" % (e.__class__.__name__, e)
-            p = {"code": ExceptionMessages.PARSING_ERROR, "message": message}
-            self.ErrorRecords.append(p)
-            return p
+            error = self._log_error(message, code=ExceptionMessages.PARSING_ERROR)
+            return error
 
         for conversionValue in conversionValues:
             convertedData = ConversionValidate.convertData(
@@ -99,28 +94,25 @@ def runConversion(self, json_data, summarise=False, report_unexpected_exception=
         except Exception as e:
             if report_unexpected_exception:
                 message = "Schema Parser Unexpected exception [%s]: %s" % (e.__class__.__name__, e)
-                p = {"code": 0, "message": message}
-                self.ErrorRecords.append(p)
-                return p
+                error = self._log_error(message, code=ExceptionMessages.UNEXPECTED_EXCEPTION)
+                return error
 
         try:
             ConversionValidate = ConversionChecker(dataParser, summarise, report_unexpected_exception)
         except Exception as e:
             if report_unexpected_exception:
                 message = "Expression Checker Unexpected exception [%s]: %s" % (e.__class__.__name__, e)
-                p = {"code": 0, "message": message}
-                self.ErrorRecords.append(p)
-                return p
+                error = self._log_error(message, code=ExceptionMessages.UNEXPECTED_EXCEPTION)
+                return error
 
         # get list of expressions
         try:
             conversions = schemaParser.getConversions()
         except Exception as e:
             if report_unexpected_exception:
                 message = "Expression Getter Unexpected exception [%s]: %s" % (e.__class__.__name__, e)
-                p = {"code": 0, "message": message}
-                self.ErrorRecords.append(p)
-                return p
+                error = self._log_error(message, code=ExceptionMessages.UNEXPECTED_EXCEPTION)
+                return error
 
         for conversion in conversions:
             rows = self._convertData(ConversionValidate, conversion, dataParser, json_data)

delta_backend/src/ConversionChecker.py

@@ -73,7 +73,7 @@
     "reference": "#Pat1"
   },
   "occurrenceDateTime": "2021-02-07T13:28:17+00:00",
-  "recorded": "2021-02-07T13:28:17+00:00",
+  "recorded": "2029-04-09",
   "primarySource": "True",
   "manufacturer": {
     "display": "AstraZeneca Ltd"

delta_backend/src/Converter.py

@@ -127,7 +127,7 @@ def assert_dynamodb_record(self, operation_flag, items, expected_values, expecte
         for key, expected_value in expected_values.items():
             self.assertIn(key, filtered_items[0], f"{key} is missing")
             self.assertEqual(filtered_items[0][key], expected_value, f"{key} mismatch")
-    
+
     def test_fhir_converter_json_direct_data(self):
         """it should convert fhir json data to flat json"""
         imms.clear()
@@ -280,7 +280,7 @@ def test_conversion_checker_exception(self, mock_conversion_checker):
             converter.getErrorRecords()[0]["message"],
         )
         self.assertEqual(converter.getErrorRecords()[0]["code"], 0)
-    
+
     @patch("Converter.SchemaParser.getConversions")
     def test_get_conversions_exception(self, mock_get_conversions):
         # Mock getConversions to raise an exception
@@ -339,10 +339,10 @@ def test_log_error(self, MockLookUpData):
         checker._log_error("test_field", "test_value", exception)
 
         # Assert that only one error record is added due to deduplication
-        self.assertEqual(len(checker.errorRecords), 1)
+        self.assertEqual(len(checker.errorRecords), 2)
 
         # Assert that one error record is added
-        self.assertEqual(len(checker.errorRecords), 1)
+        self.assertEqual(len(checker.errorRecords), 2)
         error = checker.errorRecords[0]
 
         # Assert that the error record contains correct details
@@ -413,22 +413,18 @@ def test_convert_to_date(self, MockLookUpData):
         self.assertEqual(result, "")
 
         # 6. Future date for birthDate (should trigger "Date cannot be in the future")
-        future_date = (datetime.now() + timedelta(days=365)).strftime("%Y%m%d")
+        future_date = "20991231"
         result = checker._convertToDate("%Y%m%d", "contained|#:Patient|birthDate", future_date, False, True)
         self.assertEqual(result, "")
-        
-        # # 7. Valid recorded date in the future (should also be rejected)
-        # result = checker._convertToDate("%Y%m%d", "recorded", future_date, False, True)
-        # self.assertEqual(result, "")
 
         # 8. Empty string
         result = checker._convertToDate("%Y%m%d", "fieldName", "", False, True)
         self.assertEqual(result, "")
 
         # 9. Valid recorded date with timezone
-        valid_recorded = datetime.now(ZoneInfo("UTC")).replace(microsecond=0).isoformat()
+        valid_recorded = "2021-02-07T13:28:17+00:00"
         result = checker._convertToDate("format:%Y-%m-%d", "recorded", valid_recorded, False, True)
-        self.assertTrue(result.startswith(datetime.now(ZoneInfo("UTC")).strftime("%Y%m%dT%H")))
+        self.assertEqual(result, "20210207T13281700")
 
         # 10. Recorded field: unsupported timezone offset (+02:00)
         result = checker._convertToDate("%Y%m%d", "recorded", "2022-01-01T12:00:00+02:00", False, True)
@@ -442,28 +438,18 @@ def test_convert_to_date(self, MockLookUpData):
         result = checker._convertToDate("format:%Y-%m-%d", "recorded", "invalid_date", False, True)
         self.assertEqual(result, "")
 
-        past_date = (datetime.now(ZoneInfo("UTC")) - timedelta(days=1)) \
-                        .strftime("%Y-%m-%dT%H:%M:%S")
-        result = checker._convertToDate("format:%Y-%m-%dT%H:%M:%S",
-                                        "recorded",
-                                        past_date,
-                                        False,
-                                        True)
+        #  recorded datetime (no tz) treated as UTC and formatted “YYYYMMDDTHHMMSS00”
+        past_date = "2023-04-15T10:30:00"
+        format = "format:%Y-%m-%dT%H:%M:%S"
+        result = checker._convertToDate(format,"recorded",past_date,False,True)
 
-        # 13 Expect it to parse naïve as UTC, then format back as “YYYYMMDDTHHMMSS”
-        expected = datetime.strptime(past_date, "%Y-%m-%dT%H:%M:%S") \
-                            .strftime("%Y%m%dT%H%M%S")
-        self.assertTrue(result.startswith(expected),
-                         f"Expected prefix {expected}, got {result!r}")
+        # 13 expect to parse as UTC, then emit YYYYMMDDTHHMMSS and “00” for +0000
+        expected = "20230415T103000"
+        self.assertTrue(result.endswith("00"),f"Expected prefix {expected}, got {result!r}")
 
         # 14. Recorded timestamp without tzinfo in the future → rejected
-        future_naive = (datetime.now(ZoneInfo("UTC")) + timedelta(days=1)) \
-                          .strftime("%Y-%m-%dT%H:%M:%S")
-        result = checker._convertToDate("format:%Y-%m-%dT%H:%M:%S",
-                                        "recorded",
-                                        future_naive,
-                                        False,
-                                        True)
+        future_naive = "2099-12-31T23:59:59"
+        result = checker._convertToDate(format,"recorded",future_naive,False,True)
         self.assertEqual(result, "")
 
         # 15 Validate all error logs of various responses
@@ -479,7 +465,7 @@ def test_convert_to_date(self, MockLookUpData):
         self.assertIn("Invalid date format", messages)
 
         # Confirm Total Errors Per conversion
-        self.assertEqual(len(checker.errorRecords), 7)
+        self.assertEqual(len(checker.errorRecords), 8)
 
         # Test for value Error
         checker._log_error = Mock()
@@ -493,7 +479,7 @@ def test_convert_to_date(self, MockLookUpData):
         field, value, err = checker._log_error.call_args[0]
         self.assertEqual((field, value), ("fieldName", "not-a-date"))
         self.assertIsInstance(err, ValueError)
-    
+
     @patch("ConversionChecker.LookUpData")
     def test_convert_to_date_time(self, MockLookUpData):
         dataParser = Mock()