Generalize array metadata spec verification test

Author: moradology

tests/test_properties.py

@@ -1,5 +1,6 @@
 import dataclasses
 import json
+from numbers import Real
 
 import numpy as np
 import pytest
@@ -230,24 +231,63 @@ def test_roundtrip_array_metadata_from_json(data: st.DataObject, zarr_format: in
 #     assert_array_equal(nparray, zarray[:])
 
 
-@given(npst.from_dtype(dtype=np.dtype("float64"), allow_nan=True, allow_infinity=True))
-def test_v2meta_nan_and_infinity(fill_value):
-    metadata = ArrayV2Metadata(
-        shape=[10],
-        dtype=np.dtype("float64"),
-        chunks=[5],
-        fill_value=fill_value,
-        order="C",
-    )
+def serialized_float_is_valid(serialized):
+    """
+    Validate that the serialized representation of a float conforms to the spec.
 
-    buffer_dict = metadata.to_buffer_dict(prototype=default_buffer_prototype())
-    zarray_dict = json.loads(buffer_dict[ZARRAY_JSON].to_bytes().decode())
-
-    if np.isnan(fill_value):
-        assert zarray_dict["fill_value"] == "NaN"
-    elif np.isinf(fill_value) and fill_value > 0:
-        assert zarray_dict["fill_value"] == "Infinity"
-    elif np.isinf(fill_value):
-        assert zarray_dict["fill_value"] == "-Infinity"
+    The specification requires that a serialized float must be either:
+      - A JSON number, or
+      - One of the strings "NaN", "Infinity", or "-Infinity".
+
+    Args:
+        serialized: The value produced by JSON serialization for a floating point number.
+
+    Returns:
+        bool: True if the serialized value is valid according to the spec, False otherwise.
+    """
+    if isinstance(serialized, Real):
+        return True
+    return serialized in ("NaN", "Infinity", "-Infinity")
+
+
+@given(meta=array_metadata())  # type: ignore[misc]
+def test_array_metadata_meets_spec(meta: ArrayV2Metadata | ArrayV3Metadata) -> None:
+    """
+    Validate that the array metadata produced by the library conforms to the relevant spec (V2 vs V3).
+
+    For ArrayV2Metadata:
+      - Ensures that 'zarr_format' is 2.
+      - Verifies that 'filters' is either None or a tuple (and not an empty tuple).
+    For ArrayV3Metadata:
+      - Ensures that 'zarr_format' is 3.
+
+    For both versions:
+      - If the dtype is a floating point of some kind, verifies of fill values:
+          * NaN is serialized as the string "NaN"
+          * Positive Infinity is serialized as the string "Infinity"
+          * Negative Infinity is serialized as the string "-Infinity"
+          * Other fill values are preserved as-is.
+      - If the dtype is a complex number of some kind, verifies that each component of the fill
+        value (real and imaginary) satisfies the serialization rules for floating point numbers.
+
+    Note:
+      This test validates spec-compliance for array metadata serialization.
+      It is a work-in-progress and should be expanded as further edge cases are identified.
+    """
+    asdict_dict = meta.to_dict()
+
+    # version-specific validations
+    if isinstance(meta, ArrayV2Metadata):
+        assert asdict_dict["filters"] != ()
+        assert asdict_dict["filters"] is None or isinstance(asdict_dict["filters"], tuple)
+        assert asdict_dict["zarr_format"] == 2
     else:
-        assert zarray_dict["fill_value"] == fill_value
+        assert asdict_dict["zarr_format"] == 3
+
+    # version-agnostic validations
+    if meta.dtype.kind == "f":
+        assert serialized_float_is_valid(asdict_dict["fill_value"])
+    if meta.dtype.kind == "c":
+        # fill_value should be a two-element array [real, imag].
+        assert serialized_float_is_valid(asdict_dict["fill_value"].real)
+        assert serialized_float_is_valid(asdict_dict["fill_value"].imag)