Bump up codecoverage

Author: moradology

src/zarr/core/metadata/v2.py

@@ -318,7 +318,9 @@ def parse_metadata(data: ArrayV2Metadata) -> ArrayV2Metadata:
 def parse_structured_fill_value(fill_value: Any, dtype: np.dtype[Any]) -> Any:
     """Handle structured dtype/fill value pairs"""
     try:
-        if isinstance(fill_value, (tuple, list)):
+        if isinstance(fill_value, list):
+            fill_value = tuple(fill_value)
+        if isinstance(fill_value, tuple):
             fill_value = np.array([fill_value], dtype=dtype)[0]
         elif isinstance(fill_value, bytes):
             fill_value = np.frombuffer(fill_value, dtype=dtype)[0]

tests/test_v2.py

@@ -15,6 +15,7 @@
 from zarr import config
 from zarr.abc.store import Store
 from zarr.core.buffer.core import default_buffer_prototype
+from zarr.core.metadata.v2 import parse_structured_fill_value
 from zarr.core.sync import sync
 from zarr.storage import MemoryStore, StorePath
 
@@ -315,6 +316,84 @@ def test_structured_dtype_roundtrip(fill_value, tmp_path) -> None:
     assert (a == za[:]).all()
 
 
+@pytest.mark.parametrize(
+    "fill_value, dtype, expected_result",
+    [
+        (
+            ("Alice", 30),
+            np.dtype([("name", "U10"), ("age", "i4")]),
+            np.array([("Alice", 30)], dtype=[("name", "U10"), ("age", "i4")])[0],
+        ),
+        (
+            ["Bob", 25],
+            np.dtype([("name", "U10"), ("age", "i4")]),
+            np.array([("Bob", 25)], dtype=[("name", "U10"), ("age", "i4")])[0],
+        ),
+        (
+            b"\x01\x00\x00\x00\x02\x00\x00\x00",
+            np.dtype([("x", "i4"), ("y", "i4")]),
+            np.array([(1, 2)], dtype=[("x", "i4"), ("y", "i4")])[0],
+        ),
+        (
+            "BQAAAA==",
+            np.dtype([("val", "i4")]),
+            np.array([(5,)], dtype=[("val", "i4")])[0],
+        ),
+        (
+            {'x':1, 'y':2},
+            np.dtype([('location', 'O')]),
+            np.array([({'x':1, 'y':2},)], dtype=[('location', 'O')])[0]
+        ),
+        (
+            {'x':1, 'y':2, 'z':3},
+            np.dtype([('location', 'O')]),
+            np.array([({'x':1, 'y':2, 'z':3},)], dtype=[('location', 'O')])[0]
+        ),
+    ],
+    ids=[
+        "tuple_input",
+        "list_input",
+        "bytes_input",
+        "string_input",
+        "dictionary_input",
+        "dictionary_input_extra_fields"
+    ],
+)
+def test_parse_structured_fill_value_valid(
+    fill_value: Any, dtype: np.dtype[Any], expected_result: Any
+) -> None:
+    result = parse_structured_fill_value(fill_value, dtype)
+    assert result.dtype == expected_result.dtype
+    assert result == expected_result
+    if isinstance(expected_result, np.void):
+        for name in expected_result.dtype.names or []:
+            assert result[name] == expected_result[name]
+
+
+@pytest.mark.parametrize(
+    "fill_value, dtype",
+    [
+        (("Alice", 30), np.dtype([("name", "U10"), ("age", "i4"), ("city", "U20")])),
+        (b"\x01\x00\x00\x00", np.dtype([("x", "i4"), ("y", "i4")])),
+        ("this_is_not_base64", np.dtype([("val", "i4")])),
+        ("hello", np.dtype([("age", "i4")])),
+        ({'x':1, 'y':2}, np.dtype([('location', 'i4')]))
+    ],
+    ids=[
+        "tuple_list_wrong_length",
+        "bytes_wrong_length",
+        "invalid_base64",
+        "wrong_data_type",
+        "wrong_dictionary"
+    ],
+)
+def test_parse_structured_fill_value_invalid(
+    fill_value: Any, dtype: np.dtype[Any]
+) -> None:
+    with pytest.raises(ValueError):
+        parse_structured_fill_value(fill_value, dtype)
+
+
 @pytest.mark.parametrize("fill_value", [None, b"x"], ids=["no_fill", "fill"])
 def test_other_dtype_roundtrip(fill_value, tmp_path) -> None:
     a = np.array([b"a\0\0", b"bb", b"ccc"], dtype="V7")