test: address review — type mode params and indexers return; consistent mode collections

- Type the `mode` parameter as the `IndexMode` literal (not `str`) across the
  test helpers (`_get`, `_async_get`, `_setitem`, `_eligible`,
  `assert_read_matches_numpy`).
- Make `_VECTORIZED_MODES` a tuple like `_INDEX_MODES` (was a `frozenset`) for
  consistency; `_INDEX_MODES` must stay an ordered sequence for `sampled_from`.
- `indexers(...)` now returns `tuple[Selection, Selection]` (the real
  `zarr.core.indexing.Selection` type) instead of `tuple[Any, Any]`.

Assisted-by: ClaudeCode:claude-opus-4.8

Author: d-v-b

src/zarr/testing/strategies.py

@@ -27,6 +27,7 @@
 from zarr.core.chunk_key_encodings import DefaultChunkKeyEncoding
 from zarr.core.common import JSON, AccessModeLiteral, ZarrFormat
 from zarr.core.dtype import get_data_type_from_native_dtype
+from zarr.core.indexing import Selection
 from zarr.core.metadata import ArrayV2Metadata, ArrayV3Metadata
 from zarr.core.metadata.v3 import RectilinearChunkGridMetadata, RegularChunkGridMetadata
 from zarr.core.sync import sync
@@ -623,7 +624,9 @@ def windows(draw: st.DrawFn, *, shape: tuple[int, ...]) -> tuple[slice, ...]:
 
 
 @st.composite
-def indexers(draw: st.DrawFn, *, mode: IndexMode, shape: tuple[int, ...]) -> tuple[Any, Any]:
+def indexers(
+    draw: st.DrawFn, *, mode: IndexMode, shape: tuple[int, ...]
+) -> tuple[Selection, Selection]:
     """A ``(zarr_selection, numpy_selection)`` pair for ``mode`` on ``shape``.
 
     One strategy covering every indexing mode, so a test can be written once and

tests/test_properties.py

@@ -22,6 +22,7 @@
 from zarr.core.metadata import ArrayV2Metadata, ArrayV3Metadata
 from zarr.core.sync import sync
 from zarr.testing.strategies import (
+    IndexMode,
     array_metadata,
     arrays,
     basic_indices,
@@ -332,11 +333,13 @@ def test_array_metadata_meets_spec(meta: ArrayV2Metadata | ArrayV3Metadata) -> N
 # The indexing modes and which Array method implements each. vindex/mask are
 # "vectorized" — they scatter through a single flat index, so an out= buffer must
 # be flat (number of selected points) rather than the multi-dimensional result.
-_INDEX_MODES = ("basic", "oindex", "vindex", "mask")
-_VECTORIZED_MODES = frozenset({"vindex", "mask"})
+_INDEX_MODES: tuple[IndexMode, ...] = ("basic", "oindex", "vindex", "mask")
+# Modes that scatter through a flat index (so an out= buffer must be flat). Kept a
+# tuple like _INDEX_MODES; membership is checked against it below.
+_VECTORIZED_MODES: tuple[IndexMode, ...] = ("vindex", "mask")
 
 
-def _get(target: zarr.Array, mode: str, zsel: Any, *, out: Any = None) -> Any:
+def _get(target: zarr.Array, mode: IndexMode, zsel: Any, *, out: Any = None) -> Any:
     """Read ``zsel`` from ``target`` via the get-method for ``mode``."""
     if mode == "basic":
         return target.get_basic_selection(zsel, out=out)
@@ -349,7 +352,7 @@ def _get(target: zarr.Array, mode: str, zsel: Any, *, out: Any = None) -> Any:
     raise AssertionError(mode)
 
 
-def _async_get(async_array: Any, mode: str, zsel: Any) -> Any:
+def _async_get(async_array: Any, mode: IndexMode, zsel: Any) -> Any:
     """The async read coroutine for ``mode`` (vindex/mask share the vectorized accessor)."""
     if mode == "basic":
         return async_array.getitem(zsel)
@@ -358,7 +361,7 @@ def _async_get(async_array: Any, mode: str, zsel: Any) -> Any:
     return async_array.vindex.getitem(zsel)
 
 
-def _setitem(zarray: zarr.Array, mode: str, zsel: Any, value: Any) -> None:
+def _setitem(zarray: zarr.Array, mode: IndexMode, zsel: Any, value: Any) -> None:
     """Write ``value`` at ``zsel`` via the set-method for ``mode``."""
     if mode == "basic":
         zarray[zsel] = value
@@ -376,7 +379,7 @@ def _has_repeated_indices(npsel: Any) -> bool:
     return any(isinstance(i, np.ndarray) and i.size != np.unique(i).size for i in sel)
 
 
-def _eligible(mode: str, shape: tuple[int, ...]) -> bool:
+def _eligible(mode: IndexMode, shape: tuple[int, ...]) -> bool:
     """Whether ``mode`` can be exercised on ``shape``.
 
     Rank-0 arrays have no interesting selections; the fancy modes
@@ -388,7 +391,7 @@ def _eligible(mode: str, shape: tuple[int, ...]) -> bool:
 
 
 def assert_read_matches_numpy(
-    target: zarr.Array, ref: np.ndarray[Any, Any], mode: str, zsel: Any, npsel: Any
+    target: zarr.Array, ref: np.ndarray[Any, Any], mode: IndexMode, zsel: Any, npsel: Any
 ) -> None:
     """Assert ``target``'s read of ``zsel`` (mode) matches ``ref[npsel]``, with/without out=.