add to_json_tests

Author: d-v-b

tests/test_codecs/test_blosc.py

@@ -8,7 +8,7 @@
 import zarr
 from zarr.abc.store import Store
 from zarr.codecs import BloscCodec
-from zarr.codecs.blosc import BLOSC_CNAME, BLOSC_SHUFFLE, BloscCname, BloscJSON_V2, BloscShuffle
+from zarr.codecs.blosc import BLOSC_CNAME, BLOSC_SHUFFLE, BloscCname, BloscJSON_V2, BloscJSON_V3, BloscShuffle
 from zarr.core.buffer import default_buffer_prototype
 from zarr.storage import StorePath
 

tests/test_codecs/test_bytes.py

@@ -6,10 +6,27 @@
 import zarr
 from zarr.abc.store import Store
 from zarr.codecs import BytesCodec
+from zarr.codecs.bytes import BytesJSON_V2, BytesJSON_V3
 from zarr.storage import StorePath
 
 from .test_codecs import _AsyncArrayProxy
 
+@pytest.mark.parametrize("endian", ["big", "little"])
+def test_bytescodec_to_json(endian: Literal["big", "little"]) -> None:
+    codec = BytesCodec(endian=endian)
+    expected_v2: BytesJSON_V2 = {
+        "id": "bytes",
+        "endian": endian,
+    }
+    expected_v3: BytesJSON_V3 = {
+        "name": "bytes",
+        "configuration": {
+            "endian": endian,
+        },
+    }
+    assert codec.to_json(zarr_format=2) == expected_v2
+    assert codec.to_json(zarr_format=3) == expected_v3
+
 
 @pytest.mark.filterwarnings("ignore:The endianness of the requested serializer")
 @pytest.mark.parametrize("store", ["local", "memory"], indirect=["store"])

tests/test_codecs/test_gzip.py

@@ -4,8 +4,25 @@
 import zarr
 from zarr.abc.store import Store
 from zarr.codecs import GzipCodec
+from zarr.codecs.gzip import GZipJSON_V2, GZipJSON_V3
 from zarr.storage import StorePath
 
+@pytest.mark.parametrize("level", [1, 5, 9])
+def test_json(level: int) -> None:
+    codec = GzipCodec(level=level)
+    expected_v2: GZipJSON_V2 = {
+        "id": "gzip",
+        "level": level,
+    }
+    expected_v3: GZipJSON_V3 = {
+        "name": "gzip",
+        "configuration": {
+            "level": level,
+        },
+    }
+    assert codec.to_json(zarr_format=2) == expected_v2
+    assert codec.to_json(zarr_format=3) == expected_v3
+
 
 @pytest.mark.parametrize("store", ["local", "memory"], indirect=["store"])
 def test_gzip(store: Store) -> None:

tests/test_codecs/test_sharding.py

@@ -1,5 +1,6 @@
+from codecs import Codec
 import pickle
-from typing import Any
+from typing import Any, Literal
 
 import numpy as np
 import numpy.typing as npt
@@ -16,13 +17,42 @@
     ShardingCodecIndexLocation,
     TransposeCodec,
 )
+from zarr.codecs.bytes import BytesCodec
+from zarr.codecs.crc32c_ import Crc32cCodec
+from zarr.codecs.sharding import ShardingJSON_V2, ShardingJSON_V3
 from zarr.core.buffer import NDArrayLike, default_buffer_prototype
 from zarr.storage import StorePath
 
 from ..conftest import ArrayRequest
 from .test_codecs import _AsyncArrayProxy, order_from_dim
 
 
+@pytest.mark.parametrize("index_location", ["start", "end"])
+@pytest.mark.parametrize("chunk_shape", [(32, 32), (64, 64)])
+@pytest.mark.parametrize('codecs', [(BytesCodec(),)])
+@pytest.mark.parametrize('index_codecs', [(Crc32cCodec(),)])
+def test_sharding_codec_to_json(index_location: Literal["start", "end"], chunk_shape: tuple[int, ...], codecs: tuple[Codec, ...], index_codecs: tuple[Codec, ...]) -> None:
+    codec = ShardingCodec(chunk_shape=chunk_shape, codecs=codecs, index_location=index_location, index_codecs=index_codecs)
+    expected_v2: ShardingJSON_V2 = {
+        "id": "sharding_indexed",
+        "chunk_shape": chunk_shape,
+        "codecs": tuple(c.to_json(zarr_format=2) for c in codecs),
+        "index_codecs": tuple(c.to_json(zarr_format=2) for c in index_codecs),
+        "index_location": index_location,
+    }
+    expected_v3: ShardingJSON_V3 = {
+        "name": "sharding_indexed",
+        "configuration": {
+        "chunk_shape": chunk_shape,
+        "codecs": tuple(c.to_json(zarr_format=3) for c in codecs),
+        "index_codecs": tuple(c.to_json(zarr_format=3) for c in index_codecs),
+        "index_location": index_location,
+        },
+    }
+    assert codec.to_json(zarr_format=2) == expected_v2
+    assert codec.to_json(zarr_format=3) == expected_v3
+
+
 @pytest.mark.parametrize("store", ["local", "memory", "zip"], indirect=["store"])
 @pytest.mark.parametrize("index_location", ["start", "end"])
 @pytest.mark.parametrize(

tests/test_codecs/test_transpose.py

@@ -5,12 +5,24 @@
 from zarr import AsyncArray, config
 from zarr.abc.store import Store
 from zarr.codecs import TransposeCodec
+from zarr.codecs.transpose import TransposeJSON_V2, TransposeJSON_V3
 from zarr.core.common import MemoryOrder
 from zarr.storage import StorePath
 
 from .test_codecs import _AsyncArrayProxy
 
 
+@pytest.mark.parametrize("order", [(1,2,3), (2,1,0)])
+def test_transpose_to_json(order: tuple[int, ...]) -> None:
+    codec = TransposeCodec(order=order)
+    expected_v2: TransposeJSON_V2 = {"id": "transpose", "order": order}
+    expected_v3: TransposeJSON_V3 = {
+        "name": "transpose",
+        "configuration": {"order": order},
+    }
+    assert codec.to_json(zarr_format=2) == expected_v2
+    assert codec.to_json(zarr_format=3) == expected_v3
+
 @pytest.mark.parametrize("input_order", ["F", "C"])
 @pytest.mark.parametrize("runtime_write_order", ["F", "C"])
 @pytest.mark.parametrize("runtime_read_order", ["F", "C"])

tests/test_codecs/test_vlen.py

@@ -8,6 +8,7 @@
 from zarr.abc.codec import Codec
 from zarr.abc.store import Store
 from zarr.codecs import ZstdCodec
+from zarr.codecs.vlen_utf8 import VLenUTF8Codec, VLenUTF8JSON_V2, VLenUTF8JSON_V3
 from zarr.core.dtype import get_data_type_from_native_dtype
 from zarr.core.dtype.npy.string import _NUMPY_SUPPORTS_VLEN_STRING
 from zarr.core.metadata.v3 import ArrayV3Metadata
@@ -21,6 +22,16 @@
 else:
     expected_array_string_dtype = np.dtype("O")
 
+def test_vlen_utf8_to_json() -> None:
+    codec = VLenUTF8Codec()
+    expected_v2: VLenUTF8JSON_V2 = {
+        "id": "vlen-utf8"}
+    expected_v3: VLenUTF8JSON_V3 = {
+        "name": "vlen-utf8",
+    }
+    assert codec.to_json(zarr_format=2) == expected_v2
+    assert codec.to_json(zarr_format=3) == expected_v3
+
 
 @pytest.mark.filterwarnings("ignore::zarr.core.dtype.common.UnstableSpecificationWarning")
 @pytest.mark.parametrize("store", ["memory", "local"], indirect=["store"])

tests/test_codecs/test_zstd.py

@@ -4,8 +4,26 @@
 import zarr
 from zarr.abc.store import Store
 from zarr.codecs import ZstdCodec
+from zarr.codecs.zstd import ZstdJSON_V2, ZstdJSON_V3
 from zarr.storage import StorePath
 
+@pytest.mark.parametrize("level", [1, 5, 9])
+@pytest.mark.parametrize('checksum', [True, False])
+def test_json(level: int, checksum: bool) -> None:
+    codec = ZstdCodec(level=level, checksum=checksum)
+    expected_v2: ZstdJSON_V2 = {
+        "id": "zstd",
+        "level": level,
+    }
+    expected_v3: ZstdJSON_V3 = {
+        "name": "zstd",
+        "configuration": {
+            "level": level,
+            "checksum": checksum
+        },
+    }
+    assert codec.to_json(zarr_format=2) == expected_v2
+    assert codec.to_json(zarr_format=3) == expected_v3
 
 @pytest.mark.parametrize("store", ["local", "memory"], indirect=["store"])
 @pytest.mark.parametrize("checksum", [True, False])