test: add in memory database setup function for handler testing

Author: rustybee42

mgmtd/src/db.rs

@@ -54,6 +54,26 @@ pub(crate) mod test {
     use super::*;
     use rusqlite::{Connection, Transaction};
 
+    pub(crate) async fn setup_with_test_data() -> Connections {
+        let conns = Connections::new_in_memory();
+
+        conns
+            .conn(|conn| {
+                let tx = conn.transaction().unwrap();
+                sqlite::migrate_schema(&tx, MIGRATIONS).unwrap();
+                // Setup test data
+                tx.execute_batch(include_str!("db/schema/test_data.sql"))
+                    .unwrap();
+                tx.commit().unwrap();
+
+                Ok(())
+            })
+            .await
+            .unwrap();
+
+        conns
+    }
+
     /// Sets ups a fresh database instance in memory and fills, with the test data set and provides
     /// a transaction handle.
     pub(crate) fn with_test_data(op: impl FnOnce(&Transaction)) {

sqlite/src/connection.rs

@@ -3,6 +3,7 @@ use rusqlite::config::DbConfig;
 use rusqlite::{Connection, Transaction, TransactionBehavior};
 use std::ops::Deref;
 use std::path::{Path, PathBuf};
+use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
@@ -79,7 +80,12 @@ pub struct InnerConnections {
     db_file: PathBuf,
 }
 
+/// Increased whenever new_in_memory is called. Makes sure that the test binary can run multiple
+/// tests in parallel with distinct in memory db instances (otherwise they would clash)
+static MEMORY_COUNTER: AtomicU64 = AtomicU64::new(0);
+
 impl Connections {
+    /// Create a new db connection pool using the given db file
     pub fn new(db_file: impl AsRef<Path>) -> Self {
         Self {
             inner: Arc::new(InnerConnections {
@@ -89,6 +95,18 @@ impl Connections {
         }
     }
 
+    /// Create a new db connection pool using an in memory db
+    pub fn new_in_memory() -> Self {
+        let count = MEMORY_COUNTER.fetch_add(1, Ordering::Relaxed);
+
+        Self {
+            inner: Arc::new(InnerConnections {
+                conns: Mutex::new(vec![]),
+                db_file: format!("file:memdb{count}?mode=memory&cache=shared").into(),
+            }),
+        }
+    }
+
     /// Start a new write (immediate) transaction. If doing writes, it is important to use this
     /// instead of `.read()` because here the busy timeout / busy handler actually works as it is
     /// applied before the transaction starts.