Remove NEW & array

Author: nhsdevws

.gitignore

@@ -29,3 +29,4 @@ openapi.json
 !**/.vscode/settings.json.default
 
 devtools/volume/
+delta_backend/deploy_lambda.sh

delta_backend/poetry.lock

@@ -19,7 +19,6 @@
 class Converter:
 
     def __init__(self, fhir_data):
-        self.imms = []
         self.converted = {}
         self.error_records = []
         self.fhir_data = fhir_data  # Store JSON data directly
@@ -126,8 +125,7 @@ def runConversion(self, json_data, summarise=False, report_unexpected_exception=
             error_summary = ""
         self.converted["CONVERSION_ERRORS"] = error_summary
 
-        self.imms.append(self.converted)
-        return self.imms
+        return self.converted
 
     def getErrorRecords(self):
         return self.error_records

delta_backend/src/Converter.py

@@ -68,13 +68,14 @@ def handler(event, context):
                 supplier_system = new_image["SupplierSystem"]["S"]
                 if supplier_system not in ("DPSFULL", "DPSREDUCED"):
                     operation = new_image["Operation"]["S"]
-                    if operation == "CREATE":
-                        operation = "NEW"
+                    # TODO check NEW is correct
+                    # action_flag = "NEW" if operation == "CREATE" else operation
+                    action_flag = operation
                     resource_json = json.loads(new_image["Resource"]["S"])
                     FHIRConverter = Converter(json.dumps(resource_json))
                     flat_json = FHIRConverter.runConversion(resource_json)  # Get the flat JSON
                     error_records = FHIRConverter.getErrorRecords()
-                    flat_json[0]["ACTION_FLAG"] = operation
+                    flat_json["ACTION_FLAG"] = action_flag
                     response = delta_table.put_item(
                         Item={
                             "PK": str(uuid.uuid4()),
@@ -84,7 +85,7 @@ def handler(event, context):
                             "SupplierSystem": supplier_system,
                             "DateTimeStamp": approximate_creation_time.isoformat(),
                             "Source": delta_source,
-                            "Imms": str(flat_json),
+                            "Imms": flat_json,
                             "ExpiresAt": expiry_time_epoch,
                         }
                     )

delta_backend/src/delta.py

@@ -1,18 +1,10 @@
 import json
 import unittest
-import os
-import time
-from datetime import datetime, timedelta
-from decimal import Decimal
 from copy import deepcopy
-from unittest import TestCase
 from unittest.mock import patch, Mock
 from moto import mock_dynamodb, mock_sqs
-from boto3 import resource as boto3_resource, client as boto3_client
+from boto3 import resource as boto3_resource
 from tests.utils_for_converter_tests import ValuesForTests, ErrorValuesForTests
-from botocore.config import Config
-from pathlib import Path
-from zoneinfo import ZoneInfo
 from SchemaParser import SchemaParser
 from Converter import Converter
 from ConversionChecker import ConversionChecker, RecordError
@@ -130,11 +122,16 @@ def assert_dynamodb_record(self, operation_flag, items, expected_values, expecte
         self.assertGreater(len(filtered_items), 0, f"No matching item found for {operation_flag}")
 
         imms_data = filtered_items[0]["Imms"]
-        self.assertIsInstance(imms_data, str)
+        self.assertIsInstance(imms_data, dict)
         self.assertGreater(len(imms_data), 0)
 
         # Check Imms JSON structure matches exactly
-        self.assertEqual(imms_data, str(expected_imms), "Imms data does not match expected JSON structure")
+        # self.assertEqual(imms_data, expected_imms, "Imms data does not match expected JSON structure")
+        for key, expected_value in expected_imms.items():
+            actual = imms_data.get(key)
+            print(f"Key: {key}, Actual: {actual}, Expected: {expected_value}")
+            self.assertEqual(actual, expected_value, f"{key} mismatch")
+
 
         for key, expected_value in expected_values.items():
             self.assertIn(key, filtered_items[0], f"{key} is missing")
@@ -169,13 +166,12 @@ def test_fhir_converter_json_error_scenario(self):
             errorRecords = FHIRConverter.getErrorRecords()
 
             # Check if bad data creates error records
-            print(f"Error Test Case, {len(errorRecords)}")
             self.assertTrue(len(errorRecords) > 0)
 
     def test_handler_imms_convert_to_flat_json(self):
         """Test that the Imms field contains the correct flat JSON data for CREATE, UPDATE, and DELETE operations."""
         expected_action_flags = [
-            {"Operation": "CREATE", "EXPECTED_ACTION_FLAG": "NEW"},
+            {"Operation": "CREATE", "EXPECTED_ACTION_FLAG": "CREATE"},
             {"Operation": "UPDATE", "EXPECTED_ACTION_FLAG": "UPDATE"},
             {"Operation": "DELETE", "EXPECTED_ACTION_FLAG": "DELETE"},
         ]
@@ -435,7 +431,6 @@ def test_convert_to_date(self, MockLookUpData):
 
         # 7 Validate all error logs of various responses
         messages = [err["message"] for err in checker.errorRecords]
-        print(f"Error Test Case, {messages}")
 
         self.assertIn("Value is not a string", messages)
 
@@ -486,7 +481,6 @@ def test_convert_to_date_time(self, MockLookUpData):
         self.assertEqual(result, "")
 
         messages = [err["message"] for err in checker.errorRecords]
-        print(f"Error Test Case, {messages}")
 
         self.assertIn("Unexpected exception [ValueError]", messages[0])
         self.assertIn("Unsupported Format or offset", messages[1])
@@ -676,7 +670,7 @@ def _run_test(self, expected_forename):
         """Helper function to run the test"""
         self.converter = Converter(json.dumps(request_json_data))
         flat_json = self.converter.runConversion(request_json_data, False, True)
-        self.assertEqual(flat_json[0]["PERSON_FORENAME"], expected_forename)
+        self.assertEqual(flat_json["PERSON_FORENAME"], expected_forename)
 
 class TestPersonSurNameToFlatJson(unittest.TestCase):
 
@@ -764,7 +758,7 @@ def _run_test_surname(self, expected_forename):
         """Helper function to run the test"""
         self.converter = Converter(json.dumps(request_json_data))
         flat_json = self.converter.runConversion(request_json_data, False, True)
-        self.assertEqual(flat_json[0]["PERSON_SURNAME"], expected_forename)
+        self.assertEqual(flat_json["PERSON_SURNAME"], expected_forename)
 
 
 class TestPersonPostalCodeToFlatJson(unittest.TestCase):
@@ -853,7 +847,7 @@ def _run_postal_code_test(self, expected_postal_code):
         """Helper function to run the test"""
         self.converter = Converter(json.dumps(request_json_data))
         flat_json = self.converter.runConversion(request_json_data, False, True)
-        self.assertEqual(flat_json[0]["PERSON_POSTCODE"], expected_postal_code)
+        self.assertEqual(flat_json["PERSON_POSTCODE"], expected_postal_code)
 
 
 class TestPersonSiteCodeToFlatJson(unittest.TestCase):
@@ -972,7 +966,7 @@ def _run_site_code_test(self, expected_site_code):
         """Helper function to run the test"""
         self.converter = Converter(json.dumps(request_json_data))
         flat_json = self.converter.runConversion(request_json_data, False, True)
-        self.assertEqual(flat_json[0].get("SITE_CODE"), expected_site_code)
+        self.assertEqual(flat_json.get("SITE_CODE"), expected_site_code)
 
 
 class TestPersonSiteUriToFlatJson(unittest.TestCase):
@@ -1063,7 +1057,7 @@ def _run_site_uri_test(self, expected_site_code):
         """Helper function to run the test"""
         self.converter = Converter(json.dumps(request_json_data))
         flat_json = self.converter.runConversion(request_json_data, False, True)
-        self.assertEqual(flat_json[0].get("SITE_CODE_TYPE_URI"), expected_site_code)
+        self.assertEqual(flat_json.get("SITE_CODE_TYPE_URI"), expected_site_code)
 
 
 class TestPractitionerForeNameToFlatJson(unittest.TestCase):
@@ -1179,7 +1173,7 @@ def _run_practitioner_test(self, expected_forename):
         """Helper function to run the test"""
         self.converter = Converter(json.dumps(request_json_data))
         flat_json = self.converter.runConversion(request_json_data, False, True)
-        self.assertEqual(flat_json[0]["PERFORMING_PROFESSIONAL_FORENAME"], expected_forename)
+        self.assertEqual(flat_json["PERFORMING_PROFESSIONAL_FORENAME"], expected_forename)
 
 
 class TestPractitionerSurNameToFlatJson(unittest.TestCase):
@@ -1293,7 +1287,7 @@ def _run_test_practitioner_surname(self, expected_forename):
         """Helper function to run the test"""
         self.converter = Converter(json.dumps(request_json_data))
         flat_json = self.converter.runConversion(request_json_data, False, True)
-        self.assertEqual(flat_json[0]["PERFORMING_PROFESSIONAL_SURNAME"], expected_forename)
+        self.assertEqual(flat_json["PERFORMING_PROFESSIONAL_SURNAME"], expected_forename)
 
     if __name__ == "__main__":
         unittest.main()

delta_backend/tests/test_convert_to_flat_json.py

@@ -78,9 +78,9 @@ def test_runConversion_success(self, mock_checker, mock_schema_parser, mock_fhir
 
         result = converter.runConversion(json_data={"occurrenceDateTime": "2023-01-01T12:00:00"})
 
-        self.assertEqual(len(result), 1)
-        self.assertIn("someFlatField", result[0])
-        self.assertEqual(result[0]["someFlatField"], "converted_value")
+        self.assertEqual(len(result), 2)
+        self.assertIn("someFlatField", result)
+        self.assertEqual(result["someFlatField"], "converted_value")
 
     @patch('Converter.extract_person_names', return_value=("John", "Doe"))
     @patch('Converter.get_valid_address', return_value="12345")

delta_backend/tests/test_converter.py

@@ -167,8 +167,7 @@ def get_event(event_name="INSERT", operation="CREATE", supplier="EMIS"):
     @staticmethod
     def get_expected_imms(expected_action_flag):
         """Returns expected Imms JSON data with the given action flag."""
-        return [
-            {
+        return {
                 "NHS_NUMBER": "9000000009",
                 "PERSON_FORENAME": "Sam",
                 "PERSON_SURNAME": "Trailor",
@@ -205,10 +204,8 @@ def get_expected_imms(expected_action_flag):
                 "LOCATION_CODE_TYPE_URI": "https://fhir.nhs.uk/Id/ods-organization-code",
                 "CONVERSION_ERRORS": ''
             }
-        ]
 
-    expected_imms = [
-        {
+    expected_imms = {
             "NHS_NUMBER": "9000000009",
             "PERSON_FORENAME": "Sam",
             "PERSON_SURNAME": "Trailor",
@@ -245,10 +242,8 @@ def get_expected_imms(expected_action_flag):
             "LOCATION_CODE_TYPE_URI": "https://fhir.nhs.uk/Id/ods-organization-code",
             "CONVERSION_ERRORS": ''
         }
-    ]
 
-    expected_imms2 = [
-        {
+    expected_imms2 = {
             "NHS_NUMBER": "9000000009",
             "PERSON_FORENAME": "Sam",
             "PERSON_SURNAME": "Trailor",
@@ -285,7 +280,6 @@ def get_expected_imms(expected_action_flag):
             "LOCATION_CODE_TYPE_URI": "https://fhir.nhs.uk/Id/ods-organization-code",
             "CONVERSION_ERRORS": ''
         }
-    ]
 
 
 class ErrorValuesForTests: