toasty_driver_integration_suite/
test.rs

1use std::{
2    error::Error,
3    sync::{Arc, Mutex, RwLock},
4};
5
6use toasty::{Db, schema::ModelSet};
7use tokio::runtime::Runtime;
8
9use crate::{ExecLog, Isolate, LoggingDriver, Setup};
10
11/// Global lock for coordinating serial vs parallel tests.
12/// Normal tests acquire a read lock (allowing parallelism).
13/// Serial tests acquire a write lock (exclusive access).
14static TEST_LOCK: RwLock<()> = RwLock::new(());
15
16/// Wraps the Tokio runtime and ensures cleanup happens.
17///
18/// This also passes necessary
19pub struct Test {
20    /// Handle to the DB suite setup
21    setup: Arc<dyn Setup>,
22
23    /// Handles isolating tables between tests
24    isolate: Isolate,
25
26    /// Tokio runtime used by the test
27    runtime: Option<Runtime>,
28
29    exec_log: ExecLog,
30
31    /// List of all tables created during the test. These will need to be removed later.
32    tables: Vec<String>,
33
34    /// Whether this test requires exclusive (serial) execution
35    serial: bool,
36}
37
38impl Test {
39    pub fn new(setup: Arc<dyn Setup>) -> Self {
40        let runtime = tokio::runtime::Builder::new_current_thread()
41            .enable_all()
42            .build()
43            .expect("failed to create Tokio runtime");
44
45        Test {
46            setup,
47            isolate: Isolate::new(),
48            runtime: Some(runtime),
49            exec_log: ExecLog::new(Arc::new(Mutex::new(Vec::new()))),
50            tables: vec![],
51            serial: false,
52        }
53    }
54
55    /// Try to setup a database with models, returns Result for error handling
56    pub async fn try_setup_db(&mut self, models: ModelSet) -> toasty::Result<Db> {
57        self.try_setup_db_with(models, |_| {}).await
58    }
59
60    /// Try to setup a database with models, allowing the caller to customize
61    /// the [`toasty::db::Builder`] before it is built (e.g., to set pool
62    /// configuration).
63    pub async fn try_setup_db_with(
64        &mut self,
65        models: ModelSet,
66        customize: impl FnOnce(&mut toasty::db::Builder),
67    ) -> toasty::Result<Db> {
68        let mut builder = toasty::Db::builder();
69        builder.models(models);
70
71        // Set the table prefix
72        builder.table_name_prefix(&self.isolate.table_prefix());
73
74        // Apply caller customizations
75        customize(&mut builder);
76
77        // Always wrap with logging
78        let logging_driver = LoggingDriver::new(self.setup.driver());
79        let ops_log = logging_driver.ops_log_handle();
80        self.exec_log = ExecLog::new(ops_log);
81
82        // Build the database with the logging driver
83        let db = builder.build(logging_driver).await?;
84        db.push_schema().await?;
85
86        for table in &db.schema().db.tables {
87            self.tables.push(table.name.clone());
88        }
89
90        Ok(db)
91    }
92
93    /// Setup a database with models, always with logging enabled
94    pub async fn setup_db(&mut self, models: ModelSet) -> Db {
95        self.try_setup_db(models).await.unwrap()
96    }
97
98    /// Setup a database, applying the given customization to the
99    /// [`toasty::db::Builder`] before building.
100    pub async fn setup_db_with(
101        &mut self,
102        models: ModelSet,
103        customize: impl FnOnce(&mut toasty::db::Builder),
104    ) -> Db {
105        self.try_setup_db_with(models, customize).await.unwrap()
106    }
107
108    /// Get the driver capability
109    pub fn capability(&self) -> &'static toasty_core::driver::Capability {
110        self.setup.driver().capability()
111    }
112
113    /// Get the execution log for assertions
114    pub fn log(&mut self) -> &mut ExecLog {
115        &mut self.exec_log
116    }
117
118    /// Set whether this test requires exclusive (serial) execution
119    pub fn set_serial(&mut self, serial: bool) {
120        self.serial = serial;
121    }
122
123    /// Run an async test function using the internal runtime
124    pub fn run<R>(&mut self, f: impl AsyncFn(&mut Test) -> R)
125    where
126        R: Into<TestResult>,
127    {
128        // Acquire the appropriate lock: write lock for serial tests (exclusive),
129        // read lock for normal tests (parallel).
130        let _guard: Box<dyn std::any::Any> = if self.serial {
131            Box::new(TEST_LOCK.write().unwrap_or_else(|e| e.into_inner()))
132        } else {
133            Box::new(TEST_LOCK.read().unwrap_or_else(|e| e.into_inner()))
134        };
135
136        // Temporarily take the runtime to avoid borrow checker issues
137        let runtime = self.runtime.take().expect("runtime already consumed");
138        let f: std::pin::Pin<Box<dyn std::future::Future<Output = R>>> = Box::pin(f(self));
139        let result = runtime.block_on(f).into();
140
141        // now, wut
142        for table in &self.tables {
143            runtime.block_on(self.setup.delete_table(table));
144        }
145
146        if let Some(error) = result.error {
147            panic!("Driver test returned an error: {error}");
148        }
149
150        self.runtime = Some(runtime);
151    }
152}
153
154pub struct TestResult {
155    error: Option<Box<dyn Error>>,
156}
157
158impl From<()> for TestResult {
159    fn from(_: ()) -> Self {
160        TestResult { error: None }
161    }
162}
163
164impl<O, E> From<Result<O, E>> for TestResult
165where
166    E: Into<Box<dyn Error>>,
167{
168    fn from(value: Result<O, E>) -> Self {
169        TestResult {
170            error: value.err().map(Into::into),
171        }
172    }
173}
toasty_driver_integration_suite/test.rs

toasty_driver_integration_suite/
test.rs
