Make tests/ mypy-clean under strict mode with a tests-only override

Configure mypy to also scan tests/ alongside src/ once
explicit_package_bases and mypy_path are set so the duplicate-conftest
path collision is resolved. A new tests.* override disables four
error codes that flag legitimate pytest patterns (method-assign for
monkey-patching, no-untyped-def/no-untyped-call for fixture-style
helpers, comparison-overlap for IntEnum-equals-int reference pins)
— production code keeps strict checks.

Concrete fixes in tests/:

- Add per-line type-ignore comments for legitimate test patterns
  (negative-test types, fake conn classes typed as DqliteConnection,
  monkey-patches that mypy can't follow through dynamic attribute
  assignment).
- Drop redundant per-line type-ignore comments now that the override
  covers the corresponding error codes.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: antoineleclair

pyproject.toml

@@ -56,6 +56,33 @@ asyncio_default_fixture_loop_scope = "function"
 [tool.mypy]
 strict = true
 python_version = "3.13"
+# Tests live under ``tests/`` with no ``__init__.py``; mypy needs
+# ``explicit_package_bases`` (or namespace packages) to avoid the
+# duplicate-conftest module-name collision when scanning sibling
+# integration/ subdirectories. ``mypy_path`` mirrors the
+# ``pythonpath = ["src"]`` declared for pytest so the source files
+# resolve under the package name (``dqlitedbapi``), not the layout
+# path (``src.dqlitedbapi``).
+explicit_package_bases = true
+mypy_path = "src"
+
+# Tests use a few patterns that mypy's strict mode flags but are
+# correct at runtime. Disabling these codes only inside ``tests.*``
+# keeps strict typing on production code while letting the test suite
+# use idiomatic patterns without per-line ``# type: ignore`` noise:
+#
+# * ``method-assign`` — monkey-patching bound methods
+#   (``conn.execute = fake_execute``) is the standard way to inject a
+#   fake without subclassing.
+# * ``no-untyped-def`` / ``no-untyped-call`` — pytest fixtures and
+#   small helpers are conventionally written without type annotations.
+# * ``comparison-overlap`` — ``assert SomeIntEnum.FOO == 0`` is the
+#   canonical "this enum matches its int value" pin against a
+#   reference table; mypy's literal-type narrowing incorrectly flags
+#   it as non-overlapping even though IntEnum's ``__eq__`` works.
+[[tool.mypy.overrides]]
+module = "tests.*"
+disable_error_code = ["method-assign", "no-untyped-def", "no-untyped-call", "comparison-overlap"]
 
 [tool.ruff]
 target-version = "py313"

tests/aio/test_messages_clear_on_closed.py

@@ -19,7 +19,7 @@
 @pytest.mark.asyncio
 async def test_async_commit_clears_messages_when_closed() -> None:
     conn = AsyncConnection("localhost:9001")
-    conn.messages.append(("sentinel", Warning("noop")))
+    conn.messages.append(("sentinel", Warning("noop")))  # type: ignore[arg-type]
     conn._closed = True
 
     with pytest.raises(InterfaceError):
@@ -31,7 +31,7 @@ async def test_async_commit_clears_messages_when_closed() -> None:
 @pytest.mark.asyncio
 async def test_async_rollback_clears_messages_when_closed() -> None:
     conn = AsyncConnection("localhost:9001")
-    conn.messages.append(("sentinel", Warning("noop")))
+    conn.messages.append(("sentinel", Warning("noop")))  # type: ignore[arg-type]
     conn._closed = True
 
     with pytest.raises(InterfaceError):
@@ -43,7 +43,7 @@ async def test_async_rollback_clears_messages_when_closed() -> None:
 @pytest.mark.asyncio
 async def test_async_commit_clears_messages_when_never_connected() -> None:
     conn = AsyncConnection("localhost:9001")
-    conn.messages.append(("sentinel", Warning("noop")))
+    conn.messages.append(("sentinel", Warning("noop")))  # type: ignore[arg-type]
     # _async_conn stays None until first use — commit returns silently
     # in this branch, but the messages clear must still happen.
     assert conn._async_conn is None
@@ -54,7 +54,7 @@ async def test_async_commit_clears_messages_when_never_connected() -> None:
 @pytest.mark.asyncio
 async def test_async_rollback_clears_messages_when_never_connected() -> None:
     conn = AsyncConnection("localhost:9001")
-    conn.messages.append(("sentinel", Warning("noop")))
+    conn.messages.append(("sentinel", Warning("noop")))  # type: ignore[arg-type]
     assert conn._async_conn is None
     await conn.rollback()
     assert list(conn.messages) == []

tests/integration/test_datetime_conversion.py

@@ -35,7 +35,7 @@ def test_naive_datetime_stays_naive(self, cluster_address: str) -> None:
             cursor.execute("DELETE FROM dt_naive")
             cursor.execute("INSERT INTO dt_naive (ts) VALUES (?)", [dt])
             cursor.execute("SELECT ts FROM dt_naive")
-            (value,) = cursor.fetchone()
+            (value,) = cursor.fetchone()  # type: ignore[misc]
             assert isinstance(value, datetime.datetime)
             assert value.tzinfo is None, f"expected naive, got tzinfo={value.tzinfo}"
             assert value == dt
@@ -53,7 +53,7 @@ def test_aware_datetime_preserves_offset(self, cluster_address: str) -> None:
             cursor.execute("DELETE FROM dt_aware")
             cursor.execute("INSERT INTO dt_aware (ts) VALUES (?)", [dt])
             cursor.execute("SELECT ts FROM dt_aware")
-            (value,) = cursor.fetchone()
+            (value,) = cursor.fetchone()  # type: ignore[misc]
             assert isinstance(value, datetime.datetime)
             assert value == dt
             assert value.utcoffset() == datetime.timedelta(hours=5, minutes=30)
@@ -68,7 +68,7 @@ def test_microseconds_preserved(self, cluster_address: str) -> None:
             cursor.execute("DELETE FROM dt_us")
             cursor.execute("INSERT INTO dt_us (ts) VALUES (?)", [dt])
             cursor.execute("SELECT ts FROM dt_us")
-            (value,) = cursor.fetchone()
+            (value,) = cursor.fetchone()  # type: ignore[misc]
             assert value.microsecond == 123456
             cursor.execute("DROP TABLE dt_us")
 
@@ -82,7 +82,7 @@ def test_null_datetime_returns_none(self, cluster_address: str) -> None:
             cursor.execute("DELETE FROM dt_null")
             cursor.execute("INSERT INTO dt_null (ts) VALUES (NULL)")
             cursor.execute("SELECT ts FROM dt_null")
-            (value,) = cursor.fetchone()
+            (value,) = cursor.fetchone()  # type: ignore[misc]
             assert value is None
             cursor.execute("DROP TABLE dt_null")
 
@@ -101,7 +101,7 @@ def test_date_bind_param(self, cluster_address: str) -> None:
             cursor.execute("DELETE FROM dt_date")
             cursor.execute("INSERT INTO dt_date (d) VALUES (?)", [d])
             cursor.execute("SELECT d FROM dt_date")
-            (value,) = cursor.fetchone()
+            (value,) = cursor.fetchone()  # type: ignore[misc]
             assert isinstance(value, datetime.datetime)
             assert value.date() == d
             cursor.execute("DROP TABLE dt_date")
@@ -125,7 +125,7 @@ def test_naive_time_round_trips_as_string(self, cluster_address: str) -> None:
             cursor.execute("DELETE FROM t_naive")
             cursor.execute("INSERT INTO t_naive (v) VALUES (?)", [t])
             cursor.execute("SELECT v FROM t_naive")
-            (value,) = cursor.fetchone()
+            (value,) = cursor.fetchone()  # type: ignore[misc]
             assert value == "12:30:45"
             cursor.execute("DROP TABLE t_naive")
 
@@ -137,7 +137,7 @@ def test_time_with_microseconds_and_utc(self, cluster_address: str) -> None:
             cursor.execute("DELETE FROM t_us")
             cursor.execute("INSERT INTO t_us (v) VALUES (?)", [t])
             cursor.execute("SELECT v FROM t_us")
-            (value,) = cursor.fetchone()
+            (value,) = cursor.fetchone()  # type: ignore[misc]
             assert value == "12:30:45.123456+00:00"
             cursor.execute("DROP TABLE t_us")
 
@@ -166,7 +166,7 @@ def test_integer_value_in_datetime_column_decodes_as_datetime(
             # tags the column as DQLITE_UNIXTIME on readback.
             cursor.execute("INSERT INTO ut_test (ts) VALUES (?)", [epoch])
             cursor.execute("SELECT ts FROM ut_test")
-            (value,) = cursor.fetchone()
+            (value,) = cursor.fetchone()  # type: ignore[misc]
             assert isinstance(value, datetime.datetime)
             assert value == expected
             cursor.execute("DROP TABLE ut_test")
@@ -214,7 +214,7 @@ async def scenario() -> datetime.datetime:
                 row = await cursor.fetchone()
                 await cursor.execute("DROP TABLE async_dt")
                 assert row is not None
-                return row[0]
+                return row[0]  # type: ignore[no-any-return]
 
         value = asyncio.run(scenario())
         assert isinstance(value, datetime.datetime)

tests/integration/test_lastrowid_returning.py

@@ -31,7 +31,7 @@ def test_lastrowid_not_updated_by_insert_returning(self, cluster_address: str) -
             # DDL surfaces last_insert_id=0 on its Exec response.
             lastrowid_after_ddl = cursor.lastrowid
             cursor.execute("INSERT INTO lri_test (v) VALUES (?) RETURNING id", (42,))
-            returned_id = cursor.fetchone()[0]
+            returned_id = cursor.fetchone()[0]  # type: ignore[index]
             # The only authoritative source of the rowid is the returned row.
             assert returned_id >= 1
             # lastrowid is NOT updated by the RETURNING path — it still

tests/integration/test_misc_coverage.py

@@ -98,7 +98,7 @@ def test_multi_megabyte_blob(self, cluster_address: str) -> None:
             c.execute("INSERT INTO big_blob (data) VALUES (?)", [payload])
             conn.commit()
             c.execute("SELECT data FROM big_blob")
-            (value,) = c.fetchone()
+            (value,) = c.fetchone()  # type: ignore[misc]
             assert value == payload
             c.execute("DROP TABLE big_blob")
 
@@ -119,7 +119,7 @@ def test_binary_constructor_blob_round_trip(self, cluster_address: str) -> None:
             c.execute("INSERT INTO bin_ctor (data) VALUES (?)", [dqlitedbapi.Binary(payload)])
             conn.commit()
             c.execute("SELECT data FROM bin_ctor")
-            (value,) = c.fetchone()
+            (value,) = c.fetchone()  # type: ignore[misc]
             assert value == payload
             c.execute("DROP TABLE bin_ctor")
 
@@ -134,7 +134,7 @@ def test_unicode_identifier_and_emoji_value(self, cluster_address: str) -> None:
             c.execute('INSERT INTO "café" ("☕") VALUES (?)', ["hello 🚀 world"])
             conn.commit()
             c.execute('SELECT "☕" FROM "café"')
-            (value,) = c.fetchone()
+            (value,) = c.fetchone()  # type: ignore[misc]
             assert value == "hello 🚀 world"
             assert c.description is not None
             assert c.description[0][0] == "☕"
@@ -151,7 +151,7 @@ def test_non_bmp_codepoint_round_trip(self, cluster_address: str) -> None:
             c.execute("INSERT INTO nbmp (s) VALUES (?)", [payload])
             conn.commit()
             c.execute("SELECT s FROM nbmp")
-            (value,) = c.fetchone()
+            (value,) = c.fetchone()  # type: ignore[misc]
             assert value == payload
             c.execute("DROP TABLE nbmp")
 

tests/test_aexit_rollback_debug_log.py

@@ -33,9 +33,9 @@ def _connection_with_failing_rollback(rollback_exc: BaseException) -> AsyncConne
     conn._op_lock = None
     conn._loop_ref = None
     conn.messages = []
-    conn.commit = AsyncMock()  # type: ignore[method-assign]
-    conn.rollback = AsyncMock(side_effect=rollback_exc)  # type: ignore[method-assign]
-    conn.close = AsyncMock()  # type: ignore[method-assign]
+    conn.commit = AsyncMock()
+    conn.rollback = AsyncMock(side_effect=rollback_exc)
+    conn.close = AsyncMock()
     return conn
 
 

tests/test_aio_commit_rollback_no_tx.py

@@ -29,23 +29,23 @@ class TestAsyncCommitNoTxSwallow:
     async def test_commit_swallows_no_transaction_error(self) -> None:
         conn = _prime()
         assert conn._async_conn is not None
-        conn._async_conn.execute.side_effect = _client_exc.OperationalError(
+        conn._async_conn.execute.side_effect = _client_exc.OperationalError(  # type: ignore[attr-defined]
             1, "cannot commit - no transaction is active"
         )
         await conn.commit()  # silent no-op
 
     async def test_rollback_swallows_no_transaction_error(self) -> None:
         conn = _prime()
         assert conn._async_conn is not None
-        conn._async_conn.execute.side_effect = _client_exc.OperationalError(
+        conn._async_conn.execute.side_effect = _client_exc.OperationalError(  # type: ignore[attr-defined]
             1, "cannot rollback - no transaction is active"
         )
         await conn.rollback()  # silent no-op
 
     async def test_commit_re_raises_other_operational_errors(self) -> None:
         conn = _prime()
         assert conn._async_conn is not None
-        conn._async_conn.execute.side_effect = _client_exc.OperationalError(
+        conn._async_conn.execute.side_effect = _client_exc.OperationalError(  # type: ignore[attr-defined]
             10, "some unrelated error"
         )
         # The client-layer OperationalError is wrapped into the PEP 249
@@ -59,7 +59,7 @@ async def test_commit_re_raises_other_operational_errors(self) -> None:
     async def test_rollback_re_raises_other_operational_errors(self) -> None:
         conn = _prime()
         assert conn._async_conn is not None
-        conn._async_conn.execute.side_effect = _client_exc.OperationalError(
+        conn._async_conn.execute.side_effect = _client_exc.OperationalError(  # type: ignore[attr-defined]
             10, "some unrelated error"
         )
         with pytest.raises(_dbapi_exc.OperationalError, match="some unrelated error"):

tests/test_aio_commit_rollback_wrapping.py

@@ -80,7 +80,7 @@ async def test_commit_wraps_client_exceptions(
     ) -> None:
         conn = _prime()
         assert conn._async_conn is not None
-        conn._async_conn.execute.side_effect = raise_exc
+        conn._async_conn.execute.side_effect = raise_exc  # type: ignore[attr-defined]
 
         with pytest.raises(expect_cls) as exc_info:
             await conn.commit()
@@ -101,7 +101,7 @@ async def test_commit_integrity_error_carries_code(self) -> None:
         """
         conn = _prime()
         assert conn._async_conn is not None
-        conn._async_conn.execute.side_effect = _client_exc.OperationalError(
+        conn._async_conn.execute.side_effect = _client_exc.OperationalError(  # type: ignore[attr-defined]
             19, "UNIQUE constraint failed"
         )
         with pytest.raises(_dbapi_exc.IntegrityError) as exc_info:
@@ -116,7 +116,7 @@ async def test_rollback_wraps_client_exceptions(
     ) -> None:
         conn = _prime()
         assert conn._async_conn is not None
-        conn._async_conn.execute.side_effect = raise_exc
+        conn._async_conn.execute.side_effect = raise_exc  # type: ignore[attr-defined]
 
         with pytest.raises(expect_cls) as exc_info:
             await conn.rollback()
@@ -135,15 +135,15 @@ class TestAsyncNoTxSwallowSurvivesWrapping:
     async def test_commit_no_tx_still_silent(self) -> None:
         conn = _prime()
         assert conn._async_conn is not None
-        conn._async_conn.execute.side_effect = _client_exc.OperationalError(
+        conn._async_conn.execute.side_effect = _client_exc.OperationalError(  # type: ignore[attr-defined]
             1, "cannot commit - no transaction is active"
         )
         await conn.commit()  # silent no-op
 
     async def test_rollback_no_tx_still_silent(self) -> None:
         conn = _prime()
         assert conn._async_conn is not None
-        conn._async_conn.execute.side_effect = _client_exc.OperationalError(
+        conn._async_conn.execute.side_effect = _client_exc.OperationalError(  # type: ignore[attr-defined]
             1, "cannot rollback - no transaction is active"
         )
         await conn.rollback()  # silent no-op

tests/test_arraysize_validation.py

@@ -66,7 +66,7 @@ def test_float_rejected_sync(self) -> None:
     def test_bool_rejected_sync(self) -> None:
         c = self._sync_cursor()
         with pytest.raises(ProgrammingError, match="bool"):
-            c.arraysize = True  # type: ignore[assignment]
+            c.arraysize = True
 
     def test_none_rejected_async(self) -> None:
         c = self._async_cursor()
@@ -86,4 +86,4 @@ def test_float_rejected_async(self) -> None:
     def test_bool_rejected_async(self) -> None:
         c = self._async_cursor()
         with pytest.raises(ProgrammingError, match="bool"):
-            c.arraysize = True  # type: ignore[assignment]
+            c.arraysize = True

tests/test_async_close_race.py

@@ -28,7 +28,7 @@ async def slow_execute(_sql: str, _params: object) -> tuple[int, int]:
         order.append("execute:end")
         return (0, 0)
 
-    async def fake_query_raw_typed(_sql: str, _params: object) -> tuple[list, list, list, list]:
+    async def fake_query_raw_typed(_sql: str, _params: object) -> tuple[list, list, list, list]:  # type: ignore[type-arg]
         return ([], [], [], [])
 
     with patch("dqlitedbapi.connection.DqliteConnection") as MockDqliteConn:
@@ -100,7 +100,7 @@ async def slow_close(*args: object, **kwargs: object) -> None:
             await close_release.wait()
             await real_close(*args, **kwargs)
 
-        inner.close = slow_close  # type: ignore[assignment]
+        inner.close = slow_close
 
         close_task = asyncio.create_task(conn.close())
         # Yield so close() acquires op_lock.