test(database): cover torn WAL tail on the engine default

Bring over the torn-tail test and replay docstring from Refs #75,
adapted to engine-controlled defaults: a strict open still throws on
the torn tail while the default open keeps the first insert. The
docstring now says recovery replays up to the last complete commit and
truncates there, dropping the torn tail and anything after a damaged
record.

Author: adsharma

src_py/database.py

@@ -98,8 +98,11 @@ def __init__(
 
         throw_on_wal_replay_failure: bool, optional
             If true, any WAL replaying failure when loading the database will throw an error.
-            Otherwise, Lbug will silently ignore the failure and replay up to where the error
-            occured. If None (default), the engine default is used.
+            Otherwise (the default, as in the engine), Lbug replays the WAL up to the last
+            complete commit before the first record it cannot read and truncates the file
+            there. This drops the torn tail a crash leaves while a commit is being written,
+            and anything recorded after a damaged record.
+            If None (default), the engine default is used.
 
         enable_checksums: bool, optional
             If true, the database will use checksums to detect corruption in the
@@ -220,7 +223,8 @@ def __getstate__(self) -> dict[str, Any]:
         return state
 
     def _engine_kwargs(self) -> dict[str, Any]:
-        """Return only the explicitly set engine settings.
+        """
+        Return only the explicitly set engine settings.
 
         Unset (None) settings are omitted so the engine default applies,
         instead of this binding pinning its own copy of the default.

test/test_database.py

@@ -164,6 +164,34 @@ def test_database_throw_on_wal_replay_failure_config(tmp_path: Path) -> None:
             assert result.get_next()[0] == 1
 
 
+def test_database_opens_past_a_torn_wal_tail_by_default(tmp_path: Path) -> None:
+    database_path = get_db_file_path(tmp_path)
+    with (
+        lb.Database(database_path=database_path, auto_checkpoint=False) as db,
+        lb.Connection(db) as conn,
+    ):
+        conn.execute("CALL force_checkpoint_on_close=false")
+        conn.execute("CREATE NODE TABLE T(id INT64 PRIMARY KEY)")
+        conn.execute("CREATE (:T {id: 1})")
+        conn.execute("CREATE (:T {id: 2})")
+    # A crash while the last commit is written leaves its records cut short.
+    wal_file_path = Path(str(database_path) + ".wal")
+    with Path.open(wal_file_path, "r+b") as wal_file:
+        wal_file.truncate(wal_file_path.stat().st_size - 8)
+
+    with pytest.raises(
+        RuntimeError,
+        match=r"Checksum verification failed|Reading past the end of the file",
+    ):
+        lb.Database(database_path=database_path, throw_on_wal_replay_failure=True)
+    with (
+        lb.Database(database_path=database_path) as db,
+        lb.Connection(db) as conn,
+        conn.execute("MATCH (t:T) RETURN t.id") as result,
+    ):
+        assert result.get_all() == [[1]]
+
+
 def test_database_enable_checksums_config(tmp_path: Path) -> None:
     database_path = get_db_file_path(tmp_path)
     # first construct database file with enable_checksums=True