refactor: move tests

crates/cashu/src/nuts/nut01/public_key.rs

@@ -142,19 +142,17 @@ mod tests {
     #[test]
     pub fn test_public_key_from_hex() {
         // Compressed
-        assert!(
-            (PublicKey::from_hex(
-                "02194603ffa36356f4a56b7df9371fc3192472351453ec7398b8da8117e7c3e104"
-            )
-            .is_ok())
-        );
+        assert!(PublicKey::from_hex(
+            "02194603ffa36356f4a56b7df9371fc3192472351453ec7398b8da8117e7c3e104"
+        )
+        .is_ok());
     }
 
     #[test]
     pub fn test_invalid_public_key_from_hex() {
         // Uncompressed (is valid but is cashu must be compressed?)
-        assert!((PublicKey::from_hex("04fd4ce5a16b65576145949e6f99f445f8249fee17c606b688b504a849cdc452de3625246cb2c27dac965cb7200a5986467eee92eb7d496bbf1453b074e223e481")
-            .is_err()))
+        assert!(PublicKey::from_hex("04fd4ce5a16b65576145949e6f99f445f8249fee17c606b688b504a849cdc452de3625246cb2c27dac965cb7200a5986467eee92eb7d496bbf1453b074e223e481")
+            .is_err())
     }
 }
 

crates/cdk-common/src/database/mint/test.rs

@@ -4,17 +4,19 @@
 //! implementation
 use std::str::FromStr;
 
+// For derivation path parsing
+use bitcoin::bip32::DerivationPath;
 use cashu::secret::Secret;
 use cashu::{Amount, CurrencyUnit, SecretKey};
 
 use super::*;
-use crate::database;
+use crate::database::MintKVStoreDatabase;
 use crate::mint::MintKeySetInfo;
 
 #[inline]
 async fn setup_keyset<DB>(db: &DB) -> Id
 where
-    DB: KeysDatabase<Err = database::Error>,
+    DB: KeysDatabase<Err = crate::database::Error>,
 {
     let keyset_id = Id::from_str("00916bbf7ef91a36").unwrap();
     let keyset_info = MintKeySetInfo {
@@ -23,7 +25,7 @@ where
         active: true,
         valid_from: 0,
         final_expiry: None,
-        derivation_path: bitcoin::bip32::DerivationPath::from_str("m/0'/0'/0'").unwrap(),
+        derivation_path: DerivationPath::from_str("m/0'/0'/0'").unwrap(),
         derivation_path_index: Some(0),
         max_order: 32,
         input_fee_ppk: 0,
@@ -37,7 +39,7 @@ where
 /// State transition test
 pub async fn state_transition<DB>(db: DB)
 where
-    DB: Database<database::Error> + KeysDatabase<Err = database::Error>,
+    DB: Database<crate::database::Error> + KeysDatabase<Err = crate::database::Error>,
 {
     let keyset_id = setup_keyset(&db).await;
 
@@ -83,7 +85,7 @@ where
 /// other tests
 pub async fn add_and_find_proofs<DB>(db: DB)
 where
-    DB: Database<database::Error> + KeysDatabase<Err = database::Error>,
+    DB: Database<crate::database::Error> + KeysDatabase<Err = crate::database::Error>,
 {
     let keyset_id = setup_keyset(&db).await;
 
@@ -122,12 +124,99 @@ where
     assert_eq!(proofs_from_db.unwrap().len(), 2);
 }
 
+/// Test KV store functionality including write, read, list, update, and remove operations
+pub async fn kvstore_functionality<DB>(db: DB)
+where
+    DB: Database<crate::database::Error> + MintKVStoreDatabase<Err = crate::database::Error>,
+{
+    // Test basic read/write operations in transaction
+    {
+        let mut tx = Database::begin_transaction(&db).await.unwrap();
+
+        // Write some test data
+        tx.kv_write("test_namespace", "sub_namespace", "key1", b"value1")
+            .await
+            .unwrap();
+        tx.kv_write("test_namespace", "sub_namespace", "key2", b"value2")
+            .await
+            .unwrap();
+        tx.kv_write("test_namespace", "other_sub", "key3", b"value3")
+            .await
+            .unwrap();
+
+        // Read back the data in the transaction
+        let value1 = tx
+            .kv_read("test_namespace", "sub_namespace", "key1")
+            .await
+            .unwrap();
+        assert_eq!(value1, Some(b"value1".to_vec()));
+
+        // List keys in namespace
+        let keys = tx.kv_list("test_namespace", "sub_namespace").await.unwrap();
+        assert_eq!(keys, vec!["key1", "key2"]);
+
+        // Commit transaction
+        tx.commit().await.unwrap();
+    }
+
+    // Test read operations after commit
+    {
+        let value1 = db
+            .kv_read("test_namespace", "sub_namespace", "key1")
+            .await
+            .unwrap();
+        assert_eq!(value1, Some(b"value1".to_vec()));
+
+        let keys = db.kv_list("test_namespace", "sub_namespace").await.unwrap();
+        assert_eq!(keys, vec!["key1", "key2"]);
+
+        let other_keys = db.kv_list("test_namespace", "other_sub").await.unwrap();
+        assert_eq!(other_keys, vec!["key3"]);
+    }
+
+    // Test update and remove operations
+    {
+        let mut tx = Database::begin_transaction(&db).await.unwrap();
+
+        // Update existing key
+        tx.kv_write("test_namespace", "sub_namespace", "key1", b"updated_value1")
+            .await
+            .unwrap();
+
+        // Remove a key
+        tx.kv_remove("test_namespace", "sub_namespace", "key2")
+            .await
+            .unwrap();
+
+        tx.commit().await.unwrap();
+    }
+
+    // Verify updates
+    {
+        let value1 = db
+            .kv_read("test_namespace", "sub_namespace", "key1")
+            .await
+            .unwrap();
+        assert_eq!(value1, Some(b"updated_value1".to_vec()));
+
+        let value2 = db
+            .kv_read("test_namespace", "sub_namespace", "key2")
+            .await
+            .unwrap();
+        assert_eq!(value2, None);
+
+        let keys = db.kv_list("test_namespace", "sub_namespace").await.unwrap();
+        assert_eq!(keys, vec!["key1"]);
+    }
+}
+
 /// Unit test that is expected to be passed for a correct database implementation
 #[macro_export]
 macro_rules! mint_db_test {
     ($make_db_fn:ident) => {
         mint_db_test!(state_transition, $make_db_fn);
         mint_db_test!(add_and_find_proofs, $make_db_fn);
+        mint_db_test!(kvstore_functionality, $make_db_fn);
     };
     ($name:ident, $make_db_fn:ident) => {
         #[tokio::test]

crates/cdk-sqlite/src/mint/mod.rs

@@ -32,93 +32,6 @@ mod test {
     mint_db_test!(provide_db);
 
     #[tokio::test]
-    async fn test_kvstore_functionality() {
-        use cdk_common::database::{MintDatabase, MintKVStoreDatabase};
-
-        let db = provide_db().await;
-
-        // Test basic read/write operations in transaction
-        {
-            let mut tx = db.begin_transaction().await.unwrap();
-
-            // Write some test data
-            tx.kv_write("test_namespace", "sub_namespace", "key1", b"value1")
-                .await
-                .unwrap();
-            tx.kv_write("test_namespace", "sub_namespace", "key2", b"value2")
-                .await
-                .unwrap();
-            tx.kv_write("test_namespace", "other_sub", "key3", b"value3")
-                .await
-                .unwrap();
-
-            // Read back the data in the transaction
-            let value1 = tx
-                .kv_read("test_namespace", "sub_namespace", "key1")
-                .await
-                .unwrap();
-            assert_eq!(value1, Some(b"value1".to_vec()));
-
-            // List keys in namespace
-            let keys = tx.kv_list("test_namespace", "sub_namespace").await.unwrap();
-            assert_eq!(keys, vec!["key1", "key2"]);
-
-            // Commit transaction
-            tx.commit().await.unwrap();
-        }
-
-        // Test read operations after commit
-        {
-            let value1 = db
-                .kv_read("test_namespace", "sub_namespace", "key1")
-                .await
-                .unwrap();
-            assert_eq!(value1, Some(b"value1".to_vec()));
-
-            let keys = db.kv_list("test_namespace", "sub_namespace").await.unwrap();
-            assert_eq!(keys, vec!["key1", "key2"]);
-
-            let other_keys = db.kv_list("test_namespace", "other_sub").await.unwrap();
-            assert_eq!(other_keys, vec!["key3"]);
-        }
-
-        // Test update and remove operations
-        {
-            let mut tx = db.begin_transaction().await.unwrap();
-
-            // Update existing key
-            tx.kv_write("test_namespace", "sub_namespace", "key1", b"updated_value1")
-                .await
-                .unwrap();
-
-            // Remove a key
-            tx.kv_remove("test_namespace", "sub_namespace", "key2")
-                .await
-                .unwrap();
-
-            tx.commit().await.unwrap();
-        }
-
-        // Verify updates
-        {
-            let value1 = db
-                .kv_read("test_namespace", "sub_namespace", "key1")
-                .await
-                .unwrap();
-            assert_eq!(value1, Some(b"updated_value1".to_vec()));
-
-            let value2 = db
-                .kv_read("test_namespace", "sub_namespace", "key2")
-                .await
-                .unwrap();
-            assert_eq!(value2, None);
-
-            let keys = db.kv_list("test_namespace", "sub_namespace").await.unwrap();
-            assert_eq!(keys, vec!["key1"]);
-        }
-    }
-
-    #[tokio::test]
     async fn open_legacy_and_migrate() {
         let file = format!(
             "{}/db.sqlite",