feat: add utility to test last_seen persistence

Author: 110CodingP

crates/testenv/src/persist_test_utils.rs

@@ -1,14 +1,15 @@
 use crate::block_id;
+use crate::hash;
 use bdk_chain::bitcoin::{self, hashes::Hash};
 use bdk_chain::miniscript::{Descriptor, DescriptorPublicKey};
 use bdk_chain::{
     bitcoin::{absolute, transaction, Amount, OutPoint, ScriptBuf, Transaction, TxIn, TxOut, Txid},
     indexer::keychain_txout,
-    local_chain, tx_graph, ConfirmationBlockTime, DescriptorExt, Merge
+    local_chain, tx_graph, ConfirmationBlockTime, DescriptorExt, Merge,
 };
-use crate::hash;
 use std::path::Path;
 use std::sync::Arc;
+use std::collections::{BTreeMap, BTreeSet};
 
 pub fn create_one_inp_one_out_tx(txid: Txid, amount: u64) -> Transaction {
     Transaction {
@@ -183,11 +184,7 @@ pub fn persist_local_chain_changeset<Db, CreateDb, Initialize, Persist>(
 
     // create a local_chain_changeset, persist that and read it
     let local_chain_changeset = local_chain::ChangeSet {
-        blocks: [
-            (0, Some(hash!("B"))),
-            (1, Some(hash!("D"))),
-        ]
-        .into(),
+        blocks: [(0, Some(hash!("B"))), (1, Some(hash!("D")))].into(),
     };
     let changeset = initialize(&mut db).expect("should load empty changeset");
     assert_eq!(changeset, local_chain::ChangeSet::default());
@@ -207,10 +204,117 @@ pub fn persist_local_chain_changeset<Db, CreateDb, Initialize, Persist>(
     let changeset = initialize(&mut db).unwrap();
 
     let local_chain_changeset = local_chain::ChangeSet {
-        blocks: [(0, Some(hash!("B"))), (1, Some(hash!("D"))), (2, Some(hash!("K")))].into(),
+        blocks: [
+            (0, Some(hash!("B"))),
+            (1, Some(hash!("D"))),
+            (2, Some(hash!("K"))),
+        ]
+        .into(),
     };
 
     assert_eq!(local_chain_changeset, changeset);
 }
 
+// no use of adding a persist_blocks fn since local_chain is just blocks rn
+// pub fn persist_blocks<Db, CreateDb, Initialize, Persist>(
+//     filename: &str,
+//     create_db: CreateDb,
+//     initialize: Initialize,
+//     persist: Persist,
+// ) where
+//     CreateDb: Fn(&Path) -> anyhow::Result<Db>,
+//     Initialize: Fn(&mut Db) -> anyhow::Result<local_chain::ChangeSet>,
+//     Persist: Fn(&mut Db, &local_chain::ChangeSet) -> anyhow::Result<()>,
+// {
+//     let temp_dir = tempfile::tempdir().expect("must create tempdir");
+//     let file_path = temp_dir.path().join(filename);
+//     let mut db = create_db(&file_path).expect("db should get created");
+
+//     // create a local_chain_changeset, persist that and read it
+//     let local_chain_changeset = local_chain::ChangeSet {
+//         blocks: [
+//             (0, Some(hash!("B"))),
+//             (1, Some(hash!("D"))),
+//         ]
+//         .into(),
+//     };
+//     let changeset = initialize(&mut db).expect("should load empty changeset");
+//     assert_eq!(changeset, local_chain::ChangeSet::default());
+
+//     persist(&mut db, &local_chain_changeset).expect("should persist changeset");
+
+//     let changeset = initialize(&mut db).expect("should load persisted changeset");
+//     assert_eq!(local_chain_changeset, changeset);
+
+//     // create another local_chain_changeset, persist that and read it
+//     let local_chain_changeset = local_chain::ChangeSet {
+//         blocks: [(2, Some(hash!("K")))].into(),
+//     };
+
+//     persist(&mut db, &local_chain_changeset).expect("should persist changeset");
+
+//     let changeset = initialize(&mut db).unwrap();
+
+//     let local_chain_changeset = local_chain::ChangeSet {
+//         blocks: [(0, Some(hash!("B"))), (1, Some(hash!("D"))), (2, Some(hash!("K")))].into(),
+//     };
+
+//     assert_eq!(local_chain_changeset, changeset);
+// }
+
 // perhaps add test for file_store, sqlite, redb here.
+
+pub fn persist_last_seen<Db, CreateDb, Initialize, Persist>(
+    filename: &str,
+    create_db: CreateDb,
+    initialize: Initialize,
+    persist: Persist,
+) where
+    CreateDb: Fn(&Path) -> anyhow::Result<Db>,
+    Initialize: Fn(&mut Db) -> anyhow::Result<tx_graph::ChangeSet<ConfirmationBlockTime>>,
+    Persist: Fn(&mut Db, &tx_graph::ChangeSet<ConfirmationBlockTime>) -> anyhow::Result<()>,
+{
+    use tx_graph::ChangeSet;
+    let temp_dir = tempfile::tempdir().expect("must create tempdir");
+    let file_path = temp_dir.path().join(filename);
+    let mut db = create_db(&file_path).expect("db should get created");
+
+    let tx1 = Arc::new(create_one_inp_one_out_tx(
+        Txid::from_byte_array([0; 32]),
+        30_000,
+    ));
+    let tx2 = Arc::new(create_one_inp_one_out_tx(tx1.compute_txid(), 20_000));
+    let tx3 = Arc::new(create_one_inp_one_out_tx(tx2.compute_txid(), 19_000));
+
+    // try persisting and reading last_seen
+    let txs: BTreeSet<Arc<Transaction>> = [tx1.clone(), tx2.clone()].into();
+    let mut last_seen: BTreeMap<Txid, u64> =
+        [(tx1.compute_txid(), 100), (tx2.compute_txid(), 120)].into();
+    
+
+    let changeset = initialize(&mut db).expect("db should initialize and we should get empty changeset");
+    assert_eq!(changeset, ChangeSet::default());
+
+    let changeset = ChangeSet {txs: txs, ..ChangeSet::default()};
+    persist(&mut db, &changeset).expect("should persist changeset");
+
+    // to hit the branch for the case when tx is persisted but not in changeset
+    let txs: BTreeSet<Arc<Transaction>> = BTreeSet::new();
+
+    let changeset = ChangeSet { txs: txs, last_seen: last_seen.clone(), ..ChangeSet::default()};
+    persist(&mut db, &changeset).expect("should persist changeset");
+
+    let changeset_read = initialize(&mut db).expect("should load persisted changeset");
+    assert_eq!(changeset_read.last_seen, last_seen);
+
+    // persist another last_seen and see if what is read is same as merged one
+    let txs_new: BTreeSet<Arc<Transaction>> = [tx3.clone()].into();
+    let last_seen_new: BTreeMap<Txid, u64> = [(tx3.compute_txid(), 200)].into();
+
+    let changeset = ChangeSet { txs: txs_new, last_seen: last_seen_new.clone(), ..ChangeSet::default()};
+    persist(&mut db, &changeset).expect("should persist changeset");
+
+    let changeset_read_new = initialize(&mut db).expect("should load persisted changeset");
+    last_seen.merge(last_seen_new);
+    assert_eq!(changeset_read_new.last_seen, last_seen);
+}