test(converter): add tests to check that logger is called in generic modification functions

Author: SimonClo

converter/tests/test_utils.py

@@ -71,27 +71,103 @@ def test_format_object_nested():
     assert result == expected
 
 
-def test_delete_paths():
-    data = {"a": {"b": {"c": 1, "d": 2}, "e": 3}, "f": 4}
+class TestDeletePaths(unittest.TestCase):
+    def test_delete_paths(self):
+        data = {"a": {"b": {"c": 1, "d": 2}, "e": 3}, "f": 4}
+
+        paths = ["a.b.c", "f"]
+        delete_paths(data, paths)
+
+        assert "c" not in data["a"]["b"]
+        assert "f" not in data
+        assert data["a"]["b"]["d"] == 2
+
+    def test_delete_paths_missing(self):
+        data = {"a": {"b": 1}}
+        delete_paths(data, ["a.x.y", "z"])
+        assert data == {"a": {"b": 1}}
+
+    def test_delete_paths_cleanup(self):
+        data = {"a": {"b": {"c": 1}}}
+        delete_paths(data, ["a.b.c"])
+        assert data == {}  # Empty dictionaries should be cleaned up
+
+    def test_delete_paths_with_list(self):
+        data = {
+            "a": {
+                "b": {
+                    "c": [
+                        {"delete": 1, "keep": 2},
+                        {"delete": 2, "keep": 3},
+                        {"delete": 4, "keep": 5},
+                    ],
+                    "d": 2,
+                },
+                "e": 3,
+            },
+            "f": 4,
+        }
+        delete_paths(data, ["a.b.c[].delete"])
+
+        assert data["a"]["b"]["c"] == [{"keep": 2}, {"keep": 3}, {"keep": 5}]
+        assert len(data["a"]["b"]["c"]) == 3
+        assert data["a"]["b"]["d"] == 2
+        assert data["a"]["e"] == 3
+        assert data["f"] == 4
+
+    def test_delete_paths_with_wrong_list(self):
+        data = {
+            "a": {
+                "b": {
+                    "c": [
+                        {"delete": 1, "keep": 2},
+                        {"delete": 2, "keep": 3},
+                        {"delete": 4, "keep": 5},
+                    ],
+                    "d": 2,
+                },
+                "e": 3,
+            },
+            "f": 4,
+        }
+        delete_paths(data, ["a.b.c[].toto"])
+
+        assert data["a"]["b"]["c"] == [
+            {"delete": 1, "keep": 2},
+            {"delete": 2, "keep": 3},
+            {"delete": 4, "keep": 5},
+        ]
+        assert len(data["a"]["b"]["c"]) == 3
+        assert data["a"]["b"]["d"] == 2
+        assert data["a"]["e"] == 3
+        assert data["f"] == 4
 
-    paths = ["a.b.c", "f"]
-    delete_paths(data, paths)
+    @patch("converter.utils.logger")
+    def test_delete_paths_logs_info(self, mock_logger):
+        # Arrange
+        data = {
+            "a": 1,
+            "b": {
+                "c": 2,
+                "d": 3,
+            },
+        }
 
-    assert "c" not in data["a"]["b"]
-    assert "f" not in data
-    assert data["a"]["b"]["d"] == 2
+        # Act
+        delete_paths(data, ["a", "b.c"])
 
+        # Assert logger has been called twice
+        assert mock_logger.info.call_count == 2
 
-def test_delete_paths_missing():
-    data = {"a": {"b": 1}}
-    delete_paths(data, ["a.x.y", "z"])
-    assert data == {"a": {"b": 1}}
+        # Check the log message content
+        first_call_args, _ = mock_logger.info.call_args_list[0]
+        second_call_args, _ = mock_logger.info.call_args_list[1]
 
+        assert first_call_args[0] == "Deleting key: %s"
+        assert first_call_args[1] == "a"
 
-def test_delete_paths_cleanup():
-    data = {"a": {"b": {"c": 1}}}
-    delete_paths(data, ["a.b.c"])
-    assert data == {}  # Empty dictionaries should be cleaned up
+        assert second_call_args[0] == "Deleting key: %s"
+        assert second_call_args[1] == "c"
 
 
 def test_translate_keys():
@@ -118,58 +194,6 @@ def test_empty_concatenate():
     assert concatenate_values(data) == ""
 
 
-def test_delete_paths_with_list():
-    data = {
-        "a": {
-            "b": {
-                "c": [
-                    {"delete": 1, "keep": 2},
-                    {"delete": 2, "keep": 3},
-                    {"delete": 4, "keep": 5},
-                ],
-                "d": 2,
-            },
-            "e": 3,
-        },
-        "f": 4,
-    }
-    delete_paths(data, ["a.b.c[].delete"])
-
-    assert data["a"]["b"]["c"] == [{"keep": 2}, {"keep": 3}, {"keep": 5}]
-    assert len(data["a"]["b"]["c"]) == 3
-    assert data["a"]["b"]["d"] == 2
-    assert data["a"]["e"] == 3
-    assert data["f"] == 4
-
-
-def test_delete_paths_with_wrong_list():
-    data = {
-        "a": {
-            "b": {
-                "c": [
-                    {"delete": 1, "keep": 2},
-                    {"delete": 2, "keep": 3},
-                    {"delete": 4, "keep": 5},
-                ],
-                "d": 2,
-            },
-            "e": 3,
-        },
-        "f": 4,
-    }
-    delete_paths(data, ["a.b.c[].toto"])
-
-    assert data["a"]["b"]["c"] == [
-        {"delete": 1, "keep": 2},
-        {"delete": 2, "keep": 3},
-        {"delete": 4, "keep": 5},
-    ]
-    assert len(data["a"]["b"]["c"]) == 3
-    assert data["a"]["b"]["d"] == 2
-    assert data["a"]["e"] == 3
-    assert data["f"] == 4
-
-
 class TestIsFieldCompleted(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
@@ -319,6 +343,24 @@ def test_update_json_value_logs_error(self, mock_logger):
             "Error raised in update_json_value: Parse error near the end of string!"
         )
 
+    @patch("converter.utils.logger")
+    def test_update_json_value_logs_info(self, mock_logger):
+        # Arrange
+        data = {"qualification": {"details": {"priority": "P1"}}}
+
+        # Act
+        update_json_value(data, "$.qualification.details.priority", "P2")
+
+        # Assert logger has been called
+        assert mock_logger.info.call_count == 1
+
+        # Check the log message content
+        args, kwargs = mock_logger.info.call_args
+        assert args[0] == "Updating value from %s to %s at path %s"
+        assert args[1] == "P1"
+        assert args[2] == "P2"
+        assert str(args[3]) == "qualification.details.priority"
+
 
 class TestAddToMedicalNotes(unittest.TestCase):
     @patch("converter.utils.random")
@@ -419,6 +461,36 @@ def test_add_to_medical_notes(self, mock_choices):
         self.assertEqual(json_data.get("medicalNote"), expected_medical_notes)
         self.assertEqual(len(json_data.get("medicalNote")), 3)
 
+    @patch("converter.utils.logger")
+    def test_add_to_medical_notes_logs_info(self, mock_logger):
+        # Arrange
+        data = {
+            "patient": [
+                {
+                    "patientId": "fr.health.samuH.ERTYUI.GHK",
+                    "key1": "value1",
+                }
+            ],
+            "medicalNote": [],
+        }
+
+        # Act
+        add_to_medical_notes(
+            data,
+            data["patient"][0],
+            [
+                {"path": "key1", "label": "key 1 label: "},
+            ],
+        )
+
+        # Assert logger has been called
+        assert mock_logger.info.call_count == 1
+
+        # Check the log message content
+        args, kwargs = mock_logger.info.call_args
+        assert args[0] == "Adding field %s to medical notes"
+        assert args[1] == "key1"
+
 
 class TestMapToNewValue(unittest.TestCase):
     def test_value_map_to_new_value_with_valid_mapping(self):
@@ -486,6 +558,22 @@ def test_set_deep_path(self):
         self.assertTrue(is_field_completed(data, "$.a.b.c.d"))
         self.assertTrue(is_field_completed(data, "$.a.b.c.d.e"))
 
+    @patch("converter.utils.logger")
+    def test_set_value_logs_info(self, mock_logger):
+        # Arrange
+        data = {}
+
+        # Act
+        set_value(data, "$.a", "b")
+
+        # Assert logger has been called
+        assert mock_logger.info.call_count == 1
+
+        # Check the log message content
+        args, kwargs = mock_logger.info.call_args
+        assert args[0] == "Setting value at path %s"
+        assert args[1] == "$.a"
+
 
 class TestExtractMessageTypeFromMessageContent(unittest.TestCase):
     def test_returns_unknown_when_only_unwanted_keys(self):
@@ -559,3 +647,26 @@ def test_switch_field_name_with_nested_field(self):
         self.assertIn(new_field_name, json_data["parent"])
         self.assertEqual(json_data["parent"][new_field_name], "value1")
         self.assertNotIn(previous_field_name, json_data["parent"])
+
+    @patch("converter.utils.set_value")
+    @patch("converter.utils.delete_paths")
+    @patch("converter.utils.logger")
+    def test_switch_field_logs_info(
+        self, mock_logger, mock_delete_paths, mock_set_value
+    ):
+        # Arrange
+        data = {
+            "a": "value1",
+        }
+
+        # Act
+        switch_field_name(data, "$.a", "$.b")
+
+        # Assert logger has been called
+        assert mock_logger.info.call_count == 1
+
+        # Check the log message content
+        args, kwargs = mock_logger.info.call_args
+        assert args[0] == "Transforming field name from %s to %s"
+        assert args[1] == "$.a"
+        assert args[2] == "$.b"