Method test_indexing

xarray/tests/test_backends.py:4273–4320

(
        self,
        cls_name: Literal["Variable", "DataArray", "Dataset"],
        method: Literal["sel", "isel"],
        indexer,
        target_zarr_class,
    )

        ],
    )
    async def test_indexing(
        self,
        cls_name: Literal["Variable", "DataArray", "Dataset"],
        method: Literal["sel", "isel"],
        indexer,
        target_zarr_class,
    ) -> None:
        if not has_zarr_v3_async_oindex and target_zarr_class in (
            "zarr.core.indexing.AsyncOIndex",
            "zarr.core.indexing.AsyncVIndex",
        ):
            pytest.skip(
                "current version of zarr does not support orthogonal or vectorized async indexing"
            )

        if cls_name == "Variable" and method == "sel":
            pytest.skip("Variable doesn't have a .sel method")

        # Each type of indexing ends up calling a different zarr indexing method
        # They all use a method named .getitem, but on a different internal zarr class
        def _resolve_class_from_string(class_path: str) -> type[Any]:
            """Resolve a string class path like 'zarr.AsyncArray' to the actual class."""
            module_path, class_name = class_path.rsplit(".", 1)
            module = import_module(module_path)
            return getattr(module, class_name)

        target_class = _resolve_class_from_string(target_zarr_class)
        method_name = "getitem"
        original_method = getattr(target_class, method_name)

        original = create_test_data()
        with self.create_zarr_target() as store:
            original.to_zarr(store, consolidated=False, zarr_format=3)

            with patch.object(
                target_class, method_name, wraps=original_method, autospec=True
            ) as mocked_meth:
                xr_obj = get_xr_obj(store, cls_name)

                # TODO we're not actually testing that these indexing methods are not blocking...
                result = await getattr(xr_obj, method)(**indexer).load_async()

                mocked_meth.assert_called()
                mocked_meth.assert_awaited()
                assert mocked_meth.call_count > 0

            expected = getattr(xr_obj, method)(**indexer).load()
            xrt.assert_identical(result, expected)

    @pytest.mark.asyncio
    @pytest.mark.parametrize(