Delegate 'no active transaction' swallow to the DBAPI layer

The do_commit / do_rollback overrides used a brittle substring match
on 'no transaction is active' to swallow the server's error when the
connection had no open tx. That workaround now lives inside the
dbapi's commit() / rollback() themselves (matching stdlib sqlite3
semantics), so the dialect no longer needs an override — it
inherits the parent dialect's default delegation to the DBAPI.

Keeps one dialect-level test that verifies real rollback errors
(e.g. "database is locked") still propagate through the dialect.

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

Author: antoineleclair

src/sqlalchemydqlite/base.py

@@ -110,41 +110,11 @@ def set_isolation_level(self, dbapi_connection: DBAPIConnection, level: str | No
                 stacklevel=2,
             )
 
-    def do_rollback(self, dbapi_connection: DBAPIConnection) -> None:
-        """Rollback the current transaction.
-
-        dqlite throws an error if we try to rollback when no transaction
-        is active, so we catch and ignore that specific error.
-        """
-        import dqliteclient.exceptions
-        import dqlitedbapi.exceptions
-
-        try:
-            dbapi_connection.rollback()
-        except (
-            dqlitedbapi.exceptions.OperationalError,
-            dqliteclient.exceptions.OperationalError,
-        ) as e:
-            if "no transaction is active" not in str(e).lower():
-                raise
-
-    def do_commit(self, dbapi_connection: DBAPIConnection) -> None:
-        """Commit the current transaction.
-
-        dqlite throws an error if we try to commit when no transaction
-        is active, so we catch and ignore that specific error.
-        """
-        import dqliteclient.exceptions
-        import dqlitedbapi.exceptions
-
-        try:
-            dbapi_connection.commit()
-        except (
-            dqlitedbapi.exceptions.OperationalError,
-            dqliteclient.exceptions.OperationalError,
-        ) as e:
-            if "no transaction is active" not in str(e).lower():
-                raise
+    # do_rollback / do_commit are intentionally left inherited from the
+    # parent dialect. The "cannot commit/rollback — no transaction is
+    # active" error is swallowed at the DBAPI layer (dqlitedbapi's
+    # Connection.commit / rollback), so the dialect doesn't need its own
+    # workaround. Matches stdlib sqlite3 semantics.
 
     _dqlite_disconnect_messages = (
         "Connection closed",

tests/test_dialect.py

@@ -153,70 +153,15 @@ def test_async_dialect_returns_underlying_connection(self) -> None:
 
 
 class TestDoRollbackCommit:
-    def test_do_rollback_catches_only_operational_error(self) -> None:
-        """do_rollback should only catch OperationalError, not bare Exception."""
-        import ast
-        import inspect
-        import textwrap
-
-        source = textwrap.dedent(inspect.getsource(DqliteDialect.do_rollback))
-        tree = ast.parse(source)
-
-        for node in ast.walk(tree):
-            if isinstance(node, ast.ExceptHandler):
-                assert node.type is not None, "do_rollback uses bare except"
-                if isinstance(node.type, ast.Name):
-                    assert node.type.id != "Exception", (
-                        "do_rollback catches bare Exception; "
-                        "should catch a specific dqlite exception type"
-                    )
-
-    def test_do_commit_catches_only_operational_error(self) -> None:
-        """do_commit should only catch OperationalError, not bare Exception."""
-        import ast
-        import inspect
-        import textwrap
-
-        source = textwrap.dedent(inspect.getsource(DqliteDialect.do_commit))
-        tree = ast.parse(source)
-
-        for node in ast.walk(tree):
-            if isinstance(node, ast.ExceptHandler):
-                assert node.type is not None, "do_commit uses bare except"
-                if isinstance(node.type, ast.Name):
-                    assert node.type.id != "Exception", (
-                        "do_commit catches bare Exception; "
-                        "should catch a specific dqlite exception type"
-                    )
-
-    def test_do_rollback_suppresses_no_transaction_error(self) -> None:
-        """do_rollback should suppress 'no transaction is active' errors."""
-        from unittest.mock import MagicMock
-
-        import dqlitedbapi.exceptions
-
-        dialect = DqliteDialect()
-        mock_conn = MagicMock()
-        mock_conn.rollback.side_effect = dqlitedbapi.exceptions.OperationalError(
-            "no transaction is active"
-        )
-        dialect.do_rollback(mock_conn)
-
-    def test_do_rollback_suppresses_client_no_transaction_error(self) -> None:
-        """do_rollback should suppress dqliteclient 'no transaction' errors too."""
-        from unittest.mock import MagicMock
-
-        import dqliteclient.exceptions
-
-        dialect = DqliteDialect()
-        mock_conn = MagicMock()
-        mock_conn.rollback.side_effect = dqliteclient.exceptions.OperationalError(
-            1, "cannot rollback - no transaction is active"
-        )
-        dialect.do_rollback(mock_conn)
-
-    def test_do_rollback_raises_other_errors(self) -> None:
-        """do_rollback should re-raise errors other than 'no transaction'."""
+    """The 'no transaction is active' swallow moved down to the DBAPI
+    layer (python-dqlite-dbapi). The dialect now inherits do_commit /
+    do_rollback from the parent and delegates straight to the DBAPI,
+    which handles the no-active-tx case. These tests verify the dialect
+    doesn't wrap the DBAPI's errors when a real problem occurs.
+    """
+
+    def test_do_rollback_propagates_real_errors(self) -> None:
+        """Real (not 'no transaction') errors propagate through the dialect."""
         from unittest.mock import MagicMock
 
         import pytest