Fix requirements.py to return exclusion objects instead of booleans

SuiteRequirements properties must return exclusions.open()/closed()
objects, not bare booleans. The test runner calls .enabled_for_config()
on these values which fails on bool.

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

Author: antoineleclair

src/sqlalchemydqlite/requirements.py

@@ -1,5 +1,10 @@
 """SQLAlchemy test suite requirements for dqlite dialect."""
 
+# mypy: disable-error-code="no-untyped-call"
+
+from typing import Any
+
+from sqlalchemy.testing import exclusions
 from sqlalchemy.testing.requirements import SuiteRequirements
 
 
@@ -10,36 +15,36 @@ class Requirements(SuiteRequirements):
     """
 
     @property
-    def datetime_literals(self) -> bool:
+    def datetime_literals(self) -> Any:
         """dqlite/SQLite doesn't have native datetime literals."""
-        return False
+        return exclusions.closed()
 
     @property
-    def time_microseconds(self) -> bool:
+    def time_microseconds(self) -> Any:
         """SQLite stores time as text without microseconds."""
-        return False
+        return exclusions.closed()
 
     @property
-    def datetime_historic(self) -> bool:
+    def datetime_historic(self) -> Any:
         """SQLite date range limitation."""
-        return False
+        return exclusions.closed()
 
     @property
-    def unicode_ddl(self) -> bool:
+    def unicode_ddl(self) -> Any:
         """SQLite supports unicode in DDL."""
-        return True
+        return exclusions.open()
 
     @property
-    def savepoints(self) -> bool:
+    def savepoints(self) -> Any:
         """dqlite supports savepoints."""
-        return True
+        return exclusions.open()
 
     @property
-    def two_phase_transactions(self) -> bool:
+    def two_phase_transactions(self) -> Any:
         """dqlite doesn't support two-phase transactions."""
-        return False
+        return exclusions.closed()
 
     @property
-    def temp_table_reflection(self) -> bool:
+    def temp_table_reflection(self) -> Any:
         """SQLite supports temp table reflection."""
-        return True
+        return exclusions.open()

tests/test_requirements.py

@@ -0,0 +1,28 @@
+"""Tests for dialect requirements."""
+
+from sqlalchemydqlite.requirements import Requirements
+
+
+class TestRequirements:
+    def test_properties_return_exclusion_objects(self) -> None:
+        """All requirement properties must return exclusion objects, not bare booleans."""
+        req = Requirements()
+        properties = [
+            "datetime_literals",
+            "time_microseconds",
+            "datetime_historic",
+            "unicode_ddl",
+            "savepoints",
+            "two_phase_transactions",
+            "temp_table_reflection",
+        ]
+        for prop_name in properties:
+            value = getattr(req, prop_name)
+            assert not isinstance(value, bool), (
+                f"Requirements.{prop_name} returns a bare bool; "
+                f"should return exclusions.open() or exclusions.closed()"
+            )
+            # Should have the enabled_for_config method used by the test runner
+            assert hasattr(value, "enabled_for_config"), (
+                f"Requirements.{prop_name} return value lacks enabled_for_config method"
+            )