make clean_str_attr function more robust

Author: lukaspie

src/pynxtools/dataconverter/helpers.py

@@ -1191,17 +1191,28 @@ def nested_dict_to_slash_separated_path(
 
 
 def clean_str_attr(
-    attr: Optional[Union[str, bytes]], encoding="utf-8"
+    attr: Optional[Union[str, bytes]], encoding: str = "utf-8"
 ) -> Optional[str]:
     """
-    Cleans the string attribute which means it will decode bytes to str if necessary.
-    If `attr` is not str, bytes or None it raises a TypeError.
+    Return the attribute as a string.
+
+    - If `attr` is `bytes`, decode it using the given encoding.
+    - If `attr` is already a string, return it unchanged.
+    - If `attr` is `None`, return `None`.
+    - Otherwise, raise TypeError.
+
+    Args:
+        attr: A string, bytes, or None.
+        encoding: The character encoding to use when decoding bytes.
+
+    Returns:
+        The attribute as a string, or None if input was None.
+
+    Raises:
+        TypeError: If `attr` is not str, bytes, or None.
     """
-    if attr is None:
+    if attr is None or isinstance(attr, str):
         return attr
     if isinstance(attr, bytes):
         return attr.decode(encoding)
-    if isinstance(attr, str):
-        return attr
-
-    return attr
+    raise TypeError(f"Expected str, bytes, or None; got {type(attr).__name__}")

tests/dataconverter/test_helpers.py

@@ -217,3 +217,40 @@ def test_warning_on_definition_changed_by_reader(caplog):
 
     assert "/ENTRY[entry]/definition" in template.keys()
     assert template["/ENTRY[entry]/definition"] == "NXtest"
+
+
+@pytest.mark.parametrize(
+    "attr,encoding,expected",
+    [
+        (None, "utf-8", None),  # None stays None
+        ("hello", "utf-8", "hello"),  # string unchanged
+        (b"hello", "utf-8", "hello"),  # UTF-8 bytes
+        ("café".encode("latin-1"), "latin-1", "café"),  # custom encoding
+        ("café".encode(), "utf-8", "café"),  # UTF-8 with Unicode
+        ("", "utf-8", ""),  # empty string
+        (b"", "utf-8", ""),  # empty bytes
+    ],
+)
+def test_clean_str_attr_valid(attr, encoding, expected):
+    assert helpers.clean_str_attr(attr, encoding) == expected
+
+
+@pytest.mark.parametrize(
+    "attr,expected_type",
+    [
+        (123, "int"),
+        ([b"test"], "list"),
+        ({}, "dict"),
+    ],
+)
+def test_clean_str_attr_invalid_type(attr, expected_type):
+    with pytest.raises(
+        TypeError, match=f"Expected str, bytes, or None; got {expected_type}"
+    ):
+        helpers.clean_str_attr(attr)
+
+
+def test_clean_str_attr_invalid_encoding():
+    with pytest.raises(UnicodeDecodeError):
+        # invalid in UTF-8
+        helpers.clean_str_attr(b"\xff", encoding="utf-8")