feat: add tests for db

Author: thesimplekid

bindings/dart/test/wallet_test.dart

@@ -30,6 +30,28 @@ void main() {
     expect(balance.value, equals(0));
   });
 
+  test('in-memory sqlite handles concurrent access', () async {
+    final memoryWallet = Wallet(
+      mintUrl: 'https://testnut.cashudevkit.org',
+      unit: SatCurrencyUnit(),
+      mnemonic: generateMnemonic(),
+      store: SqliteWalletStore(':memory:'),
+      config: WalletConfig(targetProofCount: null),
+    );
+
+    try {
+      final balances = await Future.wait(
+        List.generate(64, (_) => memoryWallet.totalBalance()),
+      );
+
+      for (final balance in balances) {
+        expect(balance.value, equals(0));
+      }
+    } finally {
+      memoryWallet.dispose();
+    }
+  });
+
   test('mint flow', () async {
     final quote = await wallet.mintQuote(
       paymentMethod: Bolt11PaymentMethod(),

bindings/kotlin/cdk-jvm/src/test/kotlin/org/cashudevkit/WalletTest.kt

@@ -1,5 +1,8 @@
 package org.cashudevkit
 
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.runBlocking
 import org.junit.jupiter.api.AfterEach
 import org.junit.jupiter.api.Assertions.*
@@ -37,6 +40,31 @@ class WalletTest {
         assertEquals(0UL, balance.value)
     }
 
+    @Test
+    fun `in-memory sqlite handles concurrent access`() = runBlocking {
+        val memoryWallet = Wallet(
+            mintUrl = "https://testnut.cashudevkit.org",
+            unit = CurrencyUnit.Sat,
+            mnemonic = generateMnemonic(),
+            store = WalletStore.Sqlite(path = ":memory:"),
+            config = WalletConfig(targetProofCount = null),
+        )
+
+        try {
+            val balances = coroutineScope {
+                (0 until 64).map {
+                    async { memoryWallet.totalBalance() }
+                }.awaitAll()
+            }
+
+            balances.forEach { balance ->
+                assertEquals(0UL, balance.value)
+            }
+        } finally {
+            memoryWallet.close()
+        }
+    }
+
     @Test
     fun `mint flow`() = runBlocking {
         val quote = wallet.mintQuote(

bindings/swift/Tests/CdkTests.swift

@@ -25,6 +25,36 @@ struct CdkTests {
         #expect(balance.value == 0, "New wallet should have zero balance")
     }
 
+    @Test("In-memory SQLite handles concurrent access")
+    func inMemorySqliteHandlesConcurrentAccess() async throws {
+        let memoryWallet = try Wallet(
+            mintUrl: "https://testnut.cashudevkit.org",
+            unit: .sat,
+            mnemonic: try generateMnemonic(),
+            store: .sqlite(path: ":memory:"),
+            config: WalletConfig(targetProofCount: nil)
+        )
+
+        let balances = try await withThrowingTaskGroup(of: Amount.self) { group in
+            for _ in 0..<64 {
+                group.addTask {
+                    try await memoryWallet.totalBalance()
+                }
+            }
+
+            var balances: [Amount] = []
+            for try await balance in group {
+                balances.append(balance)
+            }
+            return balances
+        }
+
+        #expect(balances.count == 64, "All concurrent balance reads should complete")
+        for balance in balances {
+            #expect(balance.value == 0, "New in-memory wallet should have zero balance")
+        }
+    }
+
     @Test("Mint flow completes successfully")
     func mintFlow() async throws {
         let quote = try await wallet.mintQuote(

crates/cdk-ffi/tests/test_kvstore.py

@@ -42,6 +42,12 @@ def create_test_db():
     return db, db_path
 
 
+def create_test_memory_db():
+    """Create an in-memory SQLite database for testing"""
+    backend = cdk_ffi.WalletDbBackend.SQLITE(path=":memory:")
+    return cdk_ffi.create_wallet_db(backend)
+
+
 def cleanup_db(db_path):
     """Clean up the temporary database file"""
     if os.path.exists(db_path):
@@ -374,6 +380,31 @@ async def test_kv_persistence_across_instances():
             os.unlink(db_path)
 
 
+async def test_kv_in_memory_concurrent_access():
+    """Test concurrent FFI access to the single-connection in-memory SQLite pool"""
+    print("\n=== Test: KV In-Memory Concurrent Access ===")
+
+    db = create_test_memory_db()
+
+    async def write_and_read(index):
+        key = f"key_{index}"
+        value = f"value_{index}".encode()
+        await db.kv_write("memory", "concurrent", key, value)
+        result = await db.kv_read("memory", "concurrent", key)
+        assert result is not None, f"Expected value for {key}"
+        assert bytes(result) == value, f"Expected {value}, got {bytes(result)}"
+
+    await asyncio.wait_for(
+        asyncio.gather(*(write_and_read(index) for index in range(64))),
+        timeout=10.0,
+    )
+
+    keys = await db.kv_list("memory", "concurrent")
+    assert len(keys) == 64, f"Expected 64 keys, got {len(keys)}"
+
+    print("  Test passed: concurrent in-memory KV access works")
+
+
 async def main():
     """Run all KV store tests"""
     print("Starting CDK FFI Key-Value Store Tests")
@@ -395,6 +426,8 @@ async def main():
         ("KV Special Key Names", test_kv_special_key_names),
         # Persistence
         ("KV Persistence Across Instances", test_kv_persistence_across_instances),
+        # In-memory SQLite pool
+        ("KV In-Memory Concurrent Access", test_kv_in_memory_concurrent_access),
     ]
 
     passed = 0

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

@@ -16,6 +16,7 @@ pub type MintSqliteAuthDatabase = SQLMintAuthDatabase<SqliteConnectionManager>;
 #[cfg(test)]
 mod test {
     use std::fs::remove_file;
+    use std::time::Duration;
 
     use cdk_common::mint_db_test;
     use cdk_sql_common::pool::Pool;
@@ -40,6 +41,17 @@ mod test {
         let _ = remove_file("test.db");
     }
 
+    #[tokio::test]
+    async fn exhausted_in_memory_pool_times_out() {
+        let config: Config = ":memory:".into();
+        let pool = Pool::<SqliteConnectionManager>::new(config);
+
+        let _conn = pool.get().await.expect("valid connection");
+        let result = pool.get_timeout(Duration::from_millis(10)).await;
+
+        assert!(matches!(result, Err(cdk_sql_common::pool::Error::Timeout)));
+    }
+
     #[tokio::test]
     async fn open_legacy_and_migrate() {
         let file = format!(