fix: modify persistence helper

Modified the persistence helper to return a `String` as error in order
to be more expressive while keeping things simple. Also modified the
helper to load and check the `ChangeSet` after each `ChangeSet` in
`changesets` is persisted. It also checks if the `ChangeSet` loaded
after reopening the `Store` matches the final aggregate `ChangeSet`.

Author: 110CodingP

crates/chain/Cargo.toml

@@ -30,7 +30,7 @@ proptest = "1.2.0"
 bdk_testenv = { path = "../testenv" }
 criterion = { version = "0.7" }
 tempfile = "3"
-anyhow = "1.0.102"
+anyhow = "1"
 
 [features]
 default = ["std", "miniscript"]

crates/chain/tests/test_rusqlite_impl.rs

@@ -1,4 +1,5 @@
 #![cfg(feature = "rusqlite")]
+use anyhow::anyhow;
 use bdk_chain::{keychain_txout, local_chain, tx_graph, ConfirmationBlockTime};
 use bdk_testenv::persist_test_utils::{
     assert_persist_changesets, keychain_txout_changesets, local_chain_changesets,
@@ -9,17 +10,17 @@ use bdk_testenv::persist_test_utils::{
 fn txgraph_is_persisted() -> anyhow::Result<()> {
     let temp_dir = tempfile::tempdir().unwrap();
     let changesets = tx_graph_changesets();
-    Ok(assert_persist_changesets(
+    assert_persist_changesets(
         || {
-            Ok(rusqlite::Connection::open(
-                temp_dir.path().join("wallet.sqlite"),
-            )?)
+            let mut db = rusqlite::Connection::open(temp_dir.path().join("wallet.sqlite"))?;
+            let db_tx = db.transaction()?;
+            tx_graph::ChangeSet::<ConfirmationBlockTime>::init_sqlite_tables(&db_tx)?;
+            db_tx.commit()?;
+            Ok(db)
         },
         |db| {
             let db_tx = db.transaction()?;
-            tx_graph::ChangeSet::<ConfirmationBlockTime>::init_sqlite_tables(&db_tx)?;
             let changeset = tx_graph::ChangeSet::<ConfirmationBlockTime>::from_sqlite(&db_tx)?;
-            db_tx.commit()?;
             Ok(changeset)
         },
         |db, changeset| {
@@ -29,24 +30,25 @@ fn txgraph_is_persisted() -> anyhow::Result<()> {
             Ok(())
         },
         &changesets,
-    )?)
+    )
+    .map_err(|err| anyhow!(err))
 }
 
 #[test]
 fn indexer_is_persisted() -> anyhow::Result<()> {
     let temp_dir = tempfile::tempdir().unwrap();
     let changesets = keychain_txout_changesets();
-    Ok(assert_persist_changesets(
+    assert_persist_changesets(
         || {
-            Ok(rusqlite::Connection::open(
-                temp_dir.path().join("wallet.sqlite"),
-            )?)
+            let mut db = rusqlite::Connection::open(temp_dir.path().join("wallet.sqlite"))?;
+            let db_tx = db.transaction()?;
+            keychain_txout::ChangeSet::init_sqlite_tables(&db_tx)?;
+            db_tx.commit()?;
+            Ok(db)
         },
         |db| {
             let db_tx = db.transaction()?;
-            keychain_txout::ChangeSet::init_sqlite_tables(&db_tx)?;
             let changeset = keychain_txout::ChangeSet::from_sqlite(&db_tx)?;
-            db_tx.commit()?;
             Ok(changeset)
         },
         |db, changeset| {
@@ -56,24 +58,25 @@ fn indexer_is_persisted() -> anyhow::Result<()> {
             Ok(())
         },
         &changesets,
-    )?)
+    )
+    .map_err(|err| anyhow!(err))
 }
 
 #[test]
 fn local_chain_is_persisted() -> anyhow::Result<()> {
     let temp_dir = tempfile::tempdir().unwrap();
     let changesets = local_chain_changesets();
-    Ok(assert_persist_changesets(
+    assert_persist_changesets(
         || {
-            Ok(rusqlite::Connection::open(
-                temp_dir.path().join("wallet.sqlite"),
-            )?)
+            let mut db = rusqlite::Connection::open(temp_dir.path().join("wallet.sqlite"))?;
+            let db_tx = db.transaction()?;
+            local_chain::ChangeSet::init_sqlite_tables(&db_tx)?;
+            db_tx.commit()?;
+            Ok(db)
         },
         |db| {
             let db_tx = db.transaction()?;
-            local_chain::ChangeSet::init_sqlite_tables(&db_tx)?;
             let changeset = local_chain::ChangeSet::from_sqlite(&db_tx)?;
-            db_tx.commit()?;
             Ok(changeset)
         },
         |db, changeset| {
@@ -83,5 +86,6 @@ fn local_chain_is_persisted() -> anyhow::Result<()> {
             Ok(())
         },
         &changesets,
-    )?)
+    )
+    .map_err(|err| anyhow!(err))
 }

crates/file_store/src/store.rs

@@ -291,6 +291,8 @@ mod test {
         io::{Seek, Write},
     };
 
+    use anyhow::anyhow;
+
     const TEST_MAGIC_BYTES_LEN: usize = 12;
     const TEST_MAGIC_BYTES: [u8; TEST_MAGIC_BYTES_LEN] =
         [98, 100, 107, 102, 115, 49, 49, 49, 49, 49, 49, 49];
@@ -609,50 +611,38 @@ mod test {
     fn txgraph_is_persisted() -> anyhow::Result<()> {
         let temp_dir = tempfile::tempdir().unwrap();
         let changesets = tx_graph_changesets();
-        Ok(assert_persist_changesets(
-            || {
-                Ok(Store::create(
-                    &TEST_MAGIC_BYTES,
-                    temp_dir.path().join("store.db"),
-                )?)
-            },
+        assert_persist_changesets(
+            || Ok(Store::load_or_create(&TEST_MAGIC_BYTES, temp_dir.path().join("store.db"))?.0),
             |db| Ok(db.dump().map(Option::unwrap_or_default)?),
             |db, changeset| Ok(db.append(changeset)?),
             &changesets,
-        )?)
+        )
+        .map_err(|err| anyhow!(err))
     }
 
     #[test]
     fn indexer_is_persisted() -> anyhow::Result<()> {
         let temp_dir = tempfile::tempdir().unwrap();
         let changesets = keychain_txout_changesets();
-        Ok(assert_persist_changesets(
-            || {
-                Ok(Store::create(
-                    &TEST_MAGIC_BYTES,
-                    temp_dir.path().join("store.db"),
-                )?)
-            },
+        assert_persist_changesets(
+            || Ok(Store::load_or_create(&TEST_MAGIC_BYTES, temp_dir.path().join("store.db"))?.0),
             |db| Ok(db.dump().map(Option::unwrap_or_default)?),
             |db, changeset| Ok(db.append(changeset)?),
             &changesets,
-        )?)
+        )
+        .map_err(|err| anyhow!(err))
     }
 
     #[test]
     fn local_chain_is_persisted() -> anyhow::Result<()> {
         let temp_dir = tempfile::tempdir().unwrap();
         let changesets = local_chain_changesets();
-        Ok(assert_persist_changesets(
-            || {
-                Ok(Store::create(
-                    &TEST_MAGIC_BYTES,
-                    temp_dir.path().join("store.db"),
-                )?)
-            },
+        assert_persist_changesets(
+            || Ok(Store::load_or_create(&TEST_MAGIC_BYTES, temp_dir.path().join("store.db"))?.0),
             |db| Ok(db.dump().map(Option::unwrap_or_default)?),
             |db, changeset| Ok(db.append(changeset)?),
             &changesets,
-        )?)
+        )
+        .map_err(|err| anyhow!(err))
     }
 }

crates/testenv/src/persist_test_utils.rs

@@ -8,10 +8,7 @@ use bdk_chain::{
 
 #[cfg(feature = "miniscript")]
 use bdk_chain::{indexer::keychain_txout, DescriptorExt, SpkIterator};
-use core::{
-    cmp::PartialEq,
-    fmt::{Debug, Display},
-};
+use core::{cmp::PartialEq, fmt::Debug};
 
 use core::error::Error as Err;
 
@@ -25,83 +22,79 @@ const ADDRS: [&str; 2] = [
     "bcrt1q8an5jfmpq8w2hr648nn34ecf9zdtxk0qyqtrfl",
 ];
 
-/// Errors caused by a failed persister test.
-#[derive(Debug)]
-pub enum PersistErr<C: Debug> {
-    /// ChangeSet Mismatch
-    ChangeSetMismatch {
-        /// the resulting changeset
-        got: Box<C>,
-        /// the expected changeset
-        expected: Box<C>,
-    },
-    /// Errors thrown by underlying persistence backend.
-    Persister(Box<dyn Err + 'static + Send + Sync>),
-}
-
-impl<C: Debug> From<Box<dyn Err + 'static + Send + Sync>> for PersistErr<C> {
-    fn from(value: Box<dyn Err + 'static + Send + Sync>) -> Self {
-        PersistErr::Persister(value)
-    }
-}
-
-impl<C: Debug> Display for PersistErr<C> {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        match self {
-            PersistErr::ChangeSetMismatch { got, expected } => write!(
-                f,
-                "ChangeSet mismatch! Got: {:?}, Expected: {:?}",
-                got, expected
-            ),
-            PersistErr::Persister(err) => write!(f, "{err}"),
-        }
-    }
-}
-
-impl<C: Debug> Err for PersistErr<C> {}
-
-/// Tests if `ChangeSet` is being persisted correctly.
+/// A helper to check if a custom persistence backend persists `ChangeSet`s correctly.
+///
+/// This first tries to create a `Store` using `init`, `load`s from it and checks if
+/// the result is an empty `ChangeSet`.
+/// It then tries to `persist` each `ChangeSet` in `changesets` one by one, doing a `load`
+/// each time and checks that the aggregated `ChangeSet` matches the one loaded.
 ///
-/// We create a dummy `ChangeSet`, persist it and check if loaded `ChangeSet` matches
-/// the persisted one. We then create another such dummy `ChangeSet`, persist it and load it to
-/// check if merged `ChangeSet` is returned.
-pub fn assert_persist_changesets<CS, Store, CreateStore, Initialize, Persist>(
-    create_store: CreateStore,
-    initialize: Initialize,
+/// Finally it closes the `Store`, reopens it using `init`, `load`s from it and checks if the loaded
+/// `ChangeSet` matches the final aggregated `ChangeSet`.
+pub fn assert_persist_changesets<C, Store, Init, Load, Persist>(
+    init: Init,
+    load: Load,
     persist: Persist,
-    changesets: &[CS],
-) -> Result<(), PersistErr<CS>>
+    changesets: &[C],
+) -> Result<(), String>
 where
-    CS: Debug + PartialEq + Default + Merge + Clone,
-    CreateStore: Fn() -> Result<Store, Box<dyn Err + 'static + Send + Sync>>,
-    Initialize: Fn(&mut Store) -> Result<CS, Box<dyn Err + 'static + Send + Sync>>,
-    Persist: Fn(&mut Store, &CS) -> Result<(), Box<dyn Err + 'static + Send + Sync>>,
+    C: Debug + PartialEq + Default + Merge + Clone,
+    Init: Fn() -> Result<Store, Box<dyn Err>>,
+    Load: Fn(&mut Store) -> Result<C, Box<dyn Err>>,
+    Persist: Fn(&mut Store, &C) -> Result<(), Box<dyn Err>>,
 {
-    let mut store = create_store()?;
+    let mut merged_changeset = C::default();
+    {
+        let mut store = init().map_err(|err| {
+            format!(
+                "Encountered an error from the persister while initializing the store.\nGot:\n{}",
+                err
+            )
+        })?;
+
+        let init_changeset = load(&mut store).map_err(|err| format!("Encountered an error from the persister while loading from the new store.\nGot:\n{}",err))?;
+
+        if init_changeset != C::default() {
+            Err("Loading from a new store should return an empty changeset.")?;
+        }
 
-    let init_changeset = initialize(&mut store)?;
+        for (i, changeset) in changesets.iter().enumerate() {
+            persist(&mut store, changeset).map_err(|err| format!("Persisting changeset no. {} failed. Got an error from the persister instead:\n{} ", i+1, err) )?;
 
-    if init_changeset != CS::default() {
-        return Err(PersistErr::ChangeSetMismatch {
-            expected: Box::new(CS::default()),
-            got: Box::new(init_changeset),
-        });
-    }
+            merged_changeset.merge(changeset.clone());
 
-    let mut merged_changeset = CS::default();
+            let persisted_changeset = load(&mut store).map_err(|err| format!("Encountered an error from the persister while loading (after persisting changeset no. {}).\nGot:\n {}", i+1, err))?;
 
-    for changeset in changesets {
-        persist(&mut store, changeset)?;
-        merged_changeset.merge(changeset.clone());
+            if persisted_changeset != merged_changeset {
+                Err(format!(
+                    "Persisting changeset no. {} failed.\nExpected:\n\n{:?}\n\n\nLoaded:\n\n{:?};",
+                    i + 1,
+                    merged_changeset,
+                    persisted_changeset
+                ))?;
+            }
+        }
     }
 
-    let persisted_changeset = initialize(&mut store)?;
+    let mut store = init().map_err(|err| {
+        format!(
+            "Encountered an error while reopening the store.\nGot:\n{}",
+            err
+        )
+    })?;
+
+    let persisted_changeset = load(&mut store).map_err(|err| {
+        format!(
+            "Unable to load the persisted changeset after reopening the store.\nGot an error from the persister:\n{}",
+            err
+        )
+    })?;
 
     if persisted_changeset != merged_changeset {
-        return Err(PersistErr::ChangeSetMismatch {
-            expected: Box::new(merged_changeset),
-            got: Box::new(persisted_changeset),
-        });
+        Err(format!(
+            "Did not get the expected changeset after reopening the store and loading.\nExpected:\n\n{:?}\n\n\nLoaded:\n\n{:?};",
+            merged_changeset, persisted_changeset
+        ))?;
     }
 
     Ok(())