revert store fixture name convention

Author: d-v-b

tests/conftest.py

@@ -18,7 +18,7 @@
 from zarr.storage.remote import RemoteStore
 
 if TYPE_CHECKING:
-    from collections.abc import Generator
+    from collections.abc import Generator, AsyncGenerator
     from typing import Any, Literal
 
     import botocore
@@ -42,30 +42,21 @@ async def parse_store(
     s3: s3fs.S3FileSystem,  # type: ignore[name-defined]
 ) -> LocalStore | MemoryStore | RemoteStore | ZipStore:
     """
-    Take a string representation of a store + access mode, e.g. 'local_a', which would encode
-    LocalStore + access mode `a`, and convert that string representation into the appropriate store object,
-    which is then returned.
+    Take a string representation of a store and convert that string representation 
+    into the appropriate store object, which is then returned.
     """
-    store_parsed = store.split("_")
-
-    if len(store_parsed) == 1:
-        store_type = store_parsed[0]
-        # the default mode for testing is a
-        mode = "a"
-    elif len(store_parsed) == 2:
-        store_type, mode = store_parsed
-    else:
-        raise ValueError(f"Invalid store specification: {store}")
-
-    match store_type:
+
+    match store:
         case "local":
-            return await LocalStore.open(path, mode=mode)
+            return LocalStore(path, read_only=False)
         case "memory":
-            return await MemoryStore.open(mode=mode)
+            return MemoryStore(read_only=False)
         case "remote":
-            return await RemoteStore.open(fs=s3, path=test_bucket_name, mode=mode)
+            return RemoteStore(fs=s3, path=test_bucket_name, read_only=False)
         case "zip":
-            return await ZipStore.open(path + "/zarr.zip", mode=mode)
+            _store = await ZipStore.open(path + "/zarr.zip", read_only=False, mode='w')
+            return _store
+
     raise AssertionError
 
 
@@ -86,9 +77,11 @@ async def store(
     request: pytest.FixtureRequest,
     tmpdir: LEGACY_PATH,
     s3: s3fs.S3FileSystem,  # type: ignore[name-defined]
-) -> Store:
+) -> AsyncGenerator[Store, None, None]:
     param = request.param
-    return await parse_store(param, str(tmpdir), s3)
+    store_instance = await parse_store(param, str(tmpdir), s3)
+    yield store_instance
+    store_instance.close()
 
 
 @pytest.fixture(params=["local", "memory", "zip"])

tests/test_api.py

@@ -28,7 +28,7 @@
 from zarr.storage.zip import ZipStore
 
 
-@pytest.mark.parametrize("store", ["local_a", "memory_a", "remote_a", "zip_a"], indirect=True)
+@pytest.mark.parametrize("store", ["local", "memory", "remote"], indirect=True)
 def test_create_array(store: Store) -> None:
     # create array
     z = create(shape=100, store=store)
@@ -48,7 +48,7 @@ def test_create_array(store: Store) -> None:
     assert z.chunks == (40,)
 
 
-@pytest.mark.parametrize("store", ["local_a", "memory_a", "remote_a", "zip_a"], indirect=True)
+@pytest.mark.parametrize("store", ["local", "memory", "remote", "zip"], indirect=True)
 @pytest.mark.parametrize("path", ["foo", "/", "/foo", "///foo/bar"])
 @pytest.mark.parametrize("node_type", ["array", "group"])
 def test_open_normalized_path(
@@ -63,7 +63,7 @@ def test_open_normalized_path(
     assert node.path == normalize_path(path)
 
 
-@pytest.mark.parametrize("store", ["local_a", "memory_a", "remote_a", "zip_a"], indirect=True)
+@pytest.mark.parametrize("store", ["local", "memory", "remote", "zip"], indirect=True)
 async def test_open_array(store: Store, zarr_format: ZarrFormat) -> None:
     # open array, create if doesn't exist
     z = open(store=store, shape=100, zarr_format=zarr_format)
@@ -101,7 +101,7 @@ async def test_open_array(store: Store, zarr_format: ZarrFormat) -> None:
 # zipstore is marked as xfail because you cannot open a zipstore in read-only mode if it doesn't exist in the first place.
 @pytest.mark.parametrize(
     "store",
-    ["local_r", "memory_r", "remote_r", pytest.param("zip_r", marks=pytest.mark.xfail)],
+    ["local", "memory", "remote", "zip"],
     indirect=True,
 )
 def test_open_path_not_found(store: Store, zarr_format: ZarrFormat) -> None:
@@ -111,7 +111,7 @@ def test_open_path_not_found(store: Store, zarr_format: ZarrFormat) -> None:
 
 @pytest.mark.parametrize(
     "store",
-    ["local_a", "memory_a", "remote_a", "zip_a"],
+    ["local", "memory", "remote", "zip"],
     indirect=True,
 )
 async def test_open_group(store: Store) -> None:
@@ -144,7 +144,7 @@ async def test_open_group(store: Store) -> None:
 
 @pytest.mark.parametrize(
     "store",
-    ["local_a", "memory_a", "remote_a", "zip_a"],
+    ["local", "memory", "remote", "zip"],
     indirect=True,
 )
 async def test_open_array_or_group(zarr_format: ZarrFormat, store: Store) -> None:
@@ -172,7 +172,7 @@ async def test_open_array_or_group(zarr_format: ZarrFormat, store: Store) -> Non
 
 @pytest.mark.parametrize(
     "store",
-    ["local_a", "memory_a", "remote_a", "zip_a"],
+    ["local", "memory", "remote", "zip"],
     indirect=True,
 )
 @pytest.mark.parametrize("zarr_format", [None, 2, 3])
@@ -244,7 +244,7 @@ def test_save_errors() -> None:
 
 @pytest.mark.parametrize(
     "store",
-    ["local_a", "memory_a", "remote_a", pytest.param("zip_a", marks=pytest.mark.xfail)],
+    ["local", "memory", "remote", pytest.param("zip", marks=pytest.mark.xfail)],
     indirect=True,
 )
 def test_open_with_mode_r(store: Store) -> None:
@@ -265,7 +265,7 @@ def test_open_with_mode_r(store: Store) -> None:
 
 @pytest.mark.parametrize(
     "store",
-    ["local_a", "memory_a", "remote_a", pytest.param("zip_a", marks=pytest.mark.xfail)],
+    ["local", "memory", "remote", pytest.param("zip", marks=pytest.mark.xfail)],
     indirect=True,
 )
 def test_open_with_mode_r_plus(store: Store) -> None:
@@ -281,7 +281,7 @@ def test_open_with_mode_r_plus(store: Store) -> None:
 
 @pytest.mark.parametrize(
     "store",
-    ["local_a", "memory_a", "remote_a", pytest.param("zip_a", marks=pytest.mark.xfail)],
+    ["local", "memory", "remote", pytest.param("zip", marks=pytest.mark.xfail)],
     indirect=True,
 )
 async def test_open_with_mode_a(store: Store) -> None:
@@ -303,7 +303,7 @@ async def test_open_with_mode_a(store: Store) -> None:
 
 @pytest.mark.parametrize(
     "store",
-    ["local_a", "memory_a", "remote_a", pytest.param("zip_a", marks=pytest.mark.xfail)],
+    ["local", "memory", "remote", pytest.param("zip", marks=pytest.mark.xfail)],
     indirect=True,
 )
 def test_open_with_mode_w(store: Store) -> None:
@@ -320,7 +320,7 @@ def test_open_with_mode_w(store: Store) -> None:
 
 @pytest.mark.parametrize(
     "store",
-    ["local_a", "memory_a", "remote_a", pytest.param("zip_a", marks=pytest.mark.xfail)],
+    ["local", "memory", "remote", pytest.param("zip", marks=pytest.mark.xfail)],
     indirect=True,
 )
 def test_open_with_mode_w_minus(store: Store) -> None:
@@ -364,7 +364,7 @@ def test_array_order(order: MemoryOrder | None, zarr_format: ZarrFormat) -> None
 #     assert "LazyLoader: " in repr(loader)
 
 
-@pytest.mark.parametrize("store", ["local_a", "memory_a", "remote_a", "zip_a"], indirect=True)
+@pytest.mark.parametrize("store", ["local", "memory", "remote", "zip"], indirect=True)
 def test_load_array(store: Store) -> None:
     foo = np.arange(100)
     bar = np.arange(100, 0, -1)
@@ -1093,7 +1093,7 @@ def test_open_group_positional_args_deprecated() -> None:
         open_group(store, "w")
 
 
-@pytest.mark.parametrize("store", ["local_a", "memory_a", "remote_a", "zip_a"], indirect=True)
+@pytest.mark.parametrize("store", ["local", "memory", "remote", "zip"], indirect=True)
 def test_open_falls_back_to_open_group(store: Store) -> None:
     # https://github.com/zarr-developers/zarr-python/issues/2309
     zarr.open_group(store, attributes={"key": "value"})
@@ -1103,7 +1103,7 @@ def test_open_falls_back_to_open_group(store: Store) -> None:
     assert group.attrs == {"key": "value"}
 
 
-@pytest.mark.parametrize("store", ["local_a", "memory_a", "remote_a", "zip_a"], indirect=True)
+@pytest.mark.parametrize("store", ["local", "memory", "remote", "zip"], indirect=True)
 async def test_open_falls_back_to_open_group_async(store: Store) -> None:
     # https://github.com/zarr-developers/zarr-python/issues/2309
     await zarr.api.asynchronous.open_group(store, attributes={"key": "value"})

tests/test_array.py

@@ -10,21 +10,19 @@
 import zarr.api.asynchronous
 from zarr import Array, AsyncArray, Group
 from zarr.codecs import BytesCodec, VLenBytesCodec
-from zarr.core._info import ArrayInfo
 from zarr.core.array import chunks_initialized
 from zarr.core.buffer import default_buffer_prototype
 from zarr.core.buffer.cpu import NDBuffer
 from zarr.core.common import JSON, MemoryOrder, ZarrFormat
 from zarr.core.group import AsyncGroup
 from zarr.core.indexing import ceildiv
-from zarr.core.metadata.v3 import DataType
 from zarr.core.sync import sync
 from zarr.errors import ContainsArrayError, ContainsGroupError
 from zarr.storage import LocalStore, MemoryStore
 from zarr.storage.common import StorePath
 
 
-@pytest.mark.parametrize("store", ["local_a", "memory_a", "zip_a", "remote_a"], indirect=["store"])
+@pytest.mark.parametrize("store", ["local", "memory", "zip", "remote"], indirect=["store"])
 @pytest.mark.parametrize("zarr_format", [2, 3])
 @pytest.mark.parametrize("exists_ok", [True, False])
 @pytest.mark.parametrize("extant_node", ["array", "group"])
@@ -75,7 +73,7 @@ def test_array_creation_existing_node(
             )
 
 
-@pytest.mark.parametrize("store", ["local_a", "memory_a", "zip_a", "remote_a"], indirect=["store"])
+@pytest.mark.parametrize("store", ["local", "memory", "zip", "remote"], indirect=["store"])
 @pytest.mark.parametrize("zarr_format", [2, 3])
 async def test_create_creates_parents(
     store: LocalStore | MemoryStore, zarr_format: ZarrFormat
@@ -115,7 +113,7 @@ async def test_create_creates_parents(
         assert isinstance(g, AsyncGroup)
 
 
-@pytest.mark.parametrize("store", ["local_a", "memory_a", "zip_a", "remote_a"], indirect=["store"])
+@pytest.mark.parametrize("store", ["local", "memory", "zip", "remote"], indirect=["store"])
 @pytest.mark.parametrize("zarr_format", [2, 3])
 def test_array_name_properties_no_group(
     store: LocalStore | MemoryStore, zarr_format: ZarrFormat
@@ -126,7 +124,7 @@ def test_array_name_properties_no_group(
     assert arr.basename is None
 
 
-@pytest.mark.parametrize("store", ["local_a", "memory_a", "zip_a"], indirect=["store"])
+@pytest.mark.parametrize("store", ["local", "memory", "zip"], indirect=["store"])
 @pytest.mark.parametrize("zarr_format", [2, 3])
 def test_array_name_properties_with_group(
     store: LocalStore | MemoryStore, zarr_format: ZarrFormat
@@ -145,7 +143,7 @@ def test_array_name_properties_with_group(
     assert spam.basename == "spam"
 
 
-@pytest.mark.parametrize("store", ["memory_a"], indirect=True)
+@pytest.mark.parametrize("store", ["memory"], indirect=True)
 @pytest.mark.parametrize("specifiy_fill_value", [True, False])
 @pytest.mark.parametrize("dtype_str", ["bool", "uint8", "complex64"])
 def test_array_v3_fill_value_default(
@@ -175,7 +173,7 @@ def test_array_v3_fill_value_default(
     assert arr.fill_value.dtype == arr.dtype
 
 
-@pytest.mark.parametrize("store", ["memory_a"], indirect=True)
+@pytest.mark.parametrize("store", ["memory"], indirect=True)
 @pytest.mark.parametrize(
     ("dtype_str", "fill_value"),
     [("bool", True), ("uint8", 99), ("float32", -99.9), ("complex64", 3 + 4j)],
@@ -236,7 +234,7 @@ def test_selection_positional_args_deprecated() -> None:
         arr.set_block_selection((0, slice(None)), 1, None)
 
 
-@pytest.mark.parametrize("store", ["memory_a"], indirect=True)
+@pytest.mark.parametrize("store", ["memory"], indirect=True)
 async def test_array_v3_nan_fill_value(store: MemoryStore) -> None:
     shape = (10,)
     arr = Array.create(
@@ -255,7 +253,7 @@ async def test_array_v3_nan_fill_value(store: MemoryStore) -> None:
     assert len([a async for a in store.list_prefix("/")]) == 0
 
 
-@pytest.mark.parametrize("store", ["local_a"], indirect=["store"])
+@pytest.mark.parametrize("store", ["local"], indirect=["store"])
 @pytest.mark.parametrize("zarr_format", [2, 3])
 async def test_serializable_async_array(
     store: LocalStore | MemoryStore, zarr_format: ZarrFormat
@@ -273,7 +271,7 @@ async def test_serializable_async_array(
     # TODO: uncomment the parts of this test that will be impacted by the config/prototype changes in flight
 
 
-@pytest.mark.parametrize("store", ["local_a"], indirect=["store"])
+@pytest.mark.parametrize("store", ["local"], indirect=["store"])
 @pytest.mark.parametrize("zarr_format", [2, 3])
 def test_serializable_sync_array(store: LocalStore, zarr_format: ZarrFormat) -> None:
     expected = Array.create(
@@ -288,7 +286,7 @@ def test_serializable_sync_array(store: LocalStore, zarr_format: ZarrFormat) ->
     np.testing.assert_array_equal(actual[:], expected[:])
 
 
-@pytest.mark.parametrize("store", ["memory_a"], indirect=True)
+@pytest.mark.parametrize("store", ["memory"], indirect=True)
 def test_storage_transformers(store: MemoryStore) -> None:
     """
     Test that providing an actual storage transformer produces a warning and otherwise passes through
@@ -418,7 +416,7 @@ def test_update_attrs(zarr_format: int) -> None:
     assert arr2.attrs["foo"] == "bar"
 
 
-@pytest.mark.parametrize("store", ["memory_a"], indirect=True)
+@pytest.mark.parametrize("store", ["memory"], indirect=True)
 @pytest.mark.parametrize("zarr_format", [2, 3])
 def test_resize_1d(store: MemoryStore, zarr_format: int) -> None:
     z = zarr.create(
@@ -457,7 +455,7 @@ def test_resize_1d(store: MemoryStore, zarr_format: int) -> None:
     assert new_shape == z[:].shape
 
 
-@pytest.mark.parametrize("store", ["memory_a"], indirect=True)
+@pytest.mark.parametrize("store", ["memory"], indirect=True)
 @pytest.mark.parametrize("zarr_format", [2, 3])
 def test_resize_2d(store: MemoryStore, zarr_format: int) -> None:
     z = zarr.create(
@@ -519,7 +517,7 @@ def test_resize_2d(store: MemoryStore, zarr_format: int) -> None:
     assert new_shape == z[:].shape
 
 
-@pytest.mark.parametrize("store", ["memory_a"], indirect=True)
+@pytest.mark.parametrize("store", ["memory"], indirect=True)
 @pytest.mark.parametrize("zarr_format", [2, 3])
 def test_append_1d(store: MemoryStore, zarr_format: int) -> None:
     a = np.arange(105)
@@ -549,7 +547,7 @@ def test_append_1d(store: MemoryStore, zarr_format: int) -> None:
     np.testing.assert_array_equal(f, z[:])
 
 
-@pytest.mark.parametrize("store", ["memory_a"], indirect=True)
+@pytest.mark.parametrize("store", ["memory"], indirect=True)
 @pytest.mark.parametrize("zarr_format", [2, 3])
 def test_append_2d(store: MemoryStore, zarr_format: int) -> None:
     a = np.arange(105 * 105, dtype="i4").reshape((105, 105))
@@ -573,7 +571,7 @@ def test_append_2d(store: MemoryStore, zarr_format: int) -> None:
     np.testing.assert_array_equal(e, actual)
 
 
-@pytest.mark.parametrize("store", ["memory_a"], indirect=True)
+@pytest.mark.parametrize("store", ["memory"], indirect=True)
 @pytest.mark.parametrize("zarr_format", [2, 3])
 def test_append_2d_axis(store: MemoryStore, zarr_format: int) -> None:
     a = np.arange(105 * 105, dtype="i4").reshape((105, 105))
@@ -595,7 +593,7 @@ def test_append_2d_axis(store: MemoryStore, zarr_format: int) -> None:
     np.testing.assert_array_equal(e, z[:])
 
 
-@pytest.mark.parametrize("store", ["memory_a"], indirect=True)
+@pytest.mark.parametrize("store", ["memory"], indirect=True)
 @pytest.mark.parametrize("zarr_format", [2, 3])
 def test_append_bad_shape(store: MemoryStore, zarr_format: int) -> None:
     a = np.arange(100)
@@ -608,7 +606,7 @@ def test_append_bad_shape(store: MemoryStore, zarr_format: int) -> None:
 
 @pytest.mark.parametrize("order", ["C", "F", None])
 @pytest.mark.parametrize("zarr_format", [2, 3])
-@pytest.mark.parametrize("store", ["memory_a"], indirect=True)
+@pytest.mark.parametrize("store", ["memory"], indirect=True)
 def test_array_create_order(
     order: MemoryOrder | None, zarr_format: int, store: MemoryStore
 ) -> None: