Fix typing errors in test_logging

Author: dstansby

pyproject.toml

@@ -366,6 +366,7 @@ module = [
     "tests.test_store.test_memory",
     "tests.test_codecs.test_codecs",
     "tests.test_store.test_core",
+    "tests.test_store.test_logging",
 ]
 strict = false
 
@@ -374,7 +375,6 @@ strict = false
 [[tool.mypy.overrides]]
 module = [
     "tests.test_metadata.*",
-    "tests.test_store.test_logging",
     "tests.test_store.test_object",
     "tests.test_store.test_stateful",
     "tests.test_store.test_wrapper",

src/zarr/testing/store.py

@@ -75,7 +75,15 @@ def test_store_supports_partial_writes(self, store: S) -> None: ...
     def test_store_supports_listing(self, store: S) -> None: ...
 
     @pytest.fixture
-    def open_kwargs(self, store_kwargs: dict[str, Any]) -> dict[str, Any]:
+    def open_kwargs(
+        self, store_kwargs: dict[str, Any], *args: Any, **kwargs: Any
+    ) -> dict[str, Any]:
+        """
+        Kwargs for opening a store.
+
+        By default uses the result of the store_kwargs fixture,
+        but can be overridden to be different.
+        """
         return store_kwargs
 
     @pytest.fixture

tests/test_store/test_logging.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 import pytest
 
@@ -11,60 +11,62 @@
 from zarr.testing.store import StoreTests
 
 if TYPE_CHECKING:
-    from _pytest.compat import LEGACY_PATH
+    from pathlib import Path
 
     from zarr.abc.store import Store
 
 
-class TestLoggingStore(StoreTests[LoggingStore, cpu.Buffer]):
+class TestLoggingStore(StoreTests[LoggingStore[LocalStore], cpu.Buffer]):
     store_cls = LoggingStore
     buffer_cls = cpu.Buffer
 
-    async def get(self, store: LoggingStore, key: str) -> Buffer:
+    async def get(self, store: LoggingStore[LocalStore], key: str) -> Buffer:
         return self.buffer_cls.from_bytes((store._store.root / key).read_bytes())
 
-    async def set(self, store: LoggingStore, key: str, value: Buffer) -> None:
+    async def set(self, store: LoggingStore[LocalStore], key: str, value: Buffer) -> None:
         parent = (store._store.root / key).parent
         if not parent.exists():
             parent.mkdir(parents=True)
         (store._store.root / key).write_bytes(value.to_bytes())
 
     @pytest.fixture
-    def store_kwargs(self, tmpdir: LEGACY_PATH) -> dict[str, str]:
-        return {"store": LocalStore(str(tmpdir)), "log_level": "DEBUG"}
+    def store_kwargs(self, tmp_path: Path) -> dict[str, str | LocalStore]:
+        return {"store": LocalStore(str(tmp_path)), "log_level": "DEBUG"}
 
     @pytest.fixture
-    def open_kwargs(self, tmpdir) -> dict[str, str]:
-        return {"store_cls": LocalStore, "root": str(tmpdir), "log_level": "DEBUG"}
+    def open_kwargs(self, store_kwargs: dict[str, Any], tmp_path: Path) -> dict[str, Any]:
+        return {"store_cls": LocalStore, "root": str(tmp_path), "log_level": "DEBUG"}
 
     @pytest.fixture
-    def store(self, store_kwargs: str | dict[str, Buffer] | None) -> LoggingStore:
+    async def store(self, store_kwargs: dict[str, Any]) -> LoggingStore[LocalStore]:
         return self.store_cls(**store_kwargs)
 
-    def test_store_supports_writes(self, store: LoggingStore) -> None:
+    def test_store_supports_writes(self, store: LoggingStore[LocalStore]) -> None:
         assert store.supports_writes
 
-    def test_store_supports_partial_writes(self, store: LoggingStore) -> None:
+    def test_store_supports_partial_writes(self, store: LoggingStore[LocalStore]) -> None:
         assert store.supports_partial_writes
 
-    def test_store_supports_listing(self, store: LoggingStore) -> None:
+    def test_store_supports_listing(self, store: LoggingStore[LocalStore]) -> None:
         assert store.supports_listing
 
-    def test_store_repr(self, store: LoggingStore) -> None:
+    def test_store_repr(self, store: LoggingStore[LocalStore]) -> None:
         assert f"{store!r}" == f"LoggingStore(LocalStore, 'file://{store._store.root.as_posix()}')"
 
-    def test_store_str(self, store: LoggingStore) -> None:
+    def test_store_str(self, store: LoggingStore[LocalStore]) -> None:
         assert str(store) == f"logging-file://{store._store.root.as_posix()}"
 
-    async def test_default_handler(self, local_store, capsys) -> None:
+    async def test_default_handler(
+        self, local_store: LocalStore, capsys: pytest.CaptureFixture[str]
+    ) -> None:
         # Store and then remove existing handlers to enter default handler code path
         handlers = logging.getLogger().handlers[:]
         for h in handlers:
             logging.getLogger().removeHandler(h)
         # Test logs are sent to stdout
         wrapped = LoggingStore(store=local_store)
         buffer = default_buffer_prototype().buffer
-        res = await wrapped.set("foo/bar/c/0", buffer.from_bytes(b"\x01\x02\x03\x04"))
+        res = await wrapped.set("foo/bar/c/0", buffer.from_bytes(b"\x01\x02\x03\x04"))  # type: ignore[func-returns-value]
         assert res is None
         captured = capsys.readouterr()
         assert len(captured) == 2
@@ -74,7 +76,7 @@ async def test_default_handler(self, local_store, capsys) -> None:
         for h in handlers:
             logging.getLogger().addHandler(h)
 
-    def test_is_open_setter_raises(self, store: LoggingStore) -> None:
+    def test_is_open_setter_raises(self, store: LoggingStore[LocalStore]) -> None:
         "Test that a user cannot change `_is_open` without opening the underlying store."
         with pytest.raises(
             NotImplementedError, match="LoggingStore must be opened via the `_open` method"
@@ -83,12 +85,12 @@ def test_is_open_setter_raises(self, store: LoggingStore) -> None:
 
 
 @pytest.mark.parametrize("store", ["local", "memory", "zip"], indirect=["store"])
-async def test_logging_store(store: Store, caplog) -> None:
+async def test_logging_store(store: Store, caplog: pytest.LogCaptureFixture) -> None:
     wrapped = LoggingStore(store=store, log_level="DEBUG")
     buffer = default_buffer_prototype().buffer
 
     caplog.clear()
-    res = await wrapped.set("foo/bar/c/0", buffer.from_bytes(b"\x01\x02\x03\x04"))
+    res = await wrapped.set("foo/bar/c/0", buffer.from_bytes(b"\x01\x02\x03\x04"))  # type: ignore[func-returns-value]
     assert res is None
     assert len(caplog.record_tuples) == 2
     for tup in caplog.record_tuples: