refactor: simplify migration testing

Author: crepererum

sqlx-test/src/lib.rs

@@ -1,7 +1,6 @@
 use sqlx::pool::PoolOptions;
 use sqlx::{Connection, Database, Pool};
 use std::env;
-use std::sync::atomic::{AtomicBool, Ordering};
 
 pub fn setup_if_needed() {
     let _ = dotenvy::dotenv();
@@ -224,31 +223,3 @@ macro_rules! Postgres_query_for_test_prepared_type {
         "SELECT ({0} is not distinct from $1)::int4, {0}, $2"
     };
 }
-
-/// Global lock that prevents multiple tests in this module to be executed at the same time.
-static GLOBAL_LOCK: AtomicBool = AtomicBool::new(false);
-
-/// Simple lock guard that should not be used in production but that is `Send` (i.e. can easily be used with tokio).
-///
-/// This may be helpful for tests that modify the database state, e.g. migrations.
-pub struct SimpleLockGuard;
-
-impl SimpleLockGuard {
-    /// Acquire global lock.
-    pub fn acquire() -> Self {
-        loop {
-            let was_locked = GLOBAL_LOCK.fetch_or(true, Ordering::SeqCst);
-            if !was_locked {
-                break;
-            }
-            std::thread::sleep(std::time::Duration::from_millis(10));
-        }
-        Self
-    }
-}
-
-impl Drop for SimpleLockGuard {
-    fn drop(&mut self) {
-        GLOBAL_LOCK.store(false, Ordering::SeqCst);
-    }
-}

tests/mysql/migrate.rs

@@ -1,16 +1,12 @@
 use sqlx::migrate::Migrator;
 use sqlx::mysql::{MySql, MySqlConnection};
+use sqlx::pool::PoolConnection;
 use sqlx::Executor;
 use sqlx::Row;
 use std::path::Path;
 
-use sqlx_test::{new, SimpleLockGuard};
-
-#[sqlx_macros::test]
-async fn simple() -> anyhow::Result<()> {
-    let _guard = SimpleLockGuard::acquire();
-
-    let mut conn = new::<MySql>().await?;
+#[sqlx::test(migrations = false)]
+async fn simple(mut conn: PoolConnection<MySql>) -> anyhow::Result<()> {
     clean_up(&mut conn).await?;
 
     let migrator = Migrator::new(Path::new("tests/mysql/migrations_simple")).await?;
@@ -31,11 +27,8 @@ async fn simple() -> anyhow::Result<()> {
     Ok(())
 }
 
-#[sqlx_macros::test]
-async fn reversible() -> anyhow::Result<()> {
-    let _guard = SimpleLockGuard::acquire();
-
-    let mut conn = new::<MySql>().await?;
+#[sqlx::test(migrations = false)]
+async fn reversible(mut conn: PoolConnection<MySql>) -> anyhow::Result<()> {
     clean_up(&mut conn).await?;
 
     let migrator = Migrator::new(Path::new("tests/mysql/migrations_reversible")).await?;

tests/postgres/migrate.rs

@@ -1,16 +1,12 @@
 use sqlx::migrate::Migrator;
+use sqlx::pool::PoolConnection;
 use sqlx::postgres::{PgConnection, Postgres};
 use sqlx::Executor;
 use sqlx::Row;
 use std::path::Path;
 
-use sqlx_test::{new, SimpleLockGuard};
-
-#[sqlx_macros::test]
-async fn simple() -> anyhow::Result<()> {
-    let _guard = SimpleLockGuard::acquire();
-
-    let mut conn = new::<Postgres>().await?;
+#[sqlx::test(migrations = false)]
+async fn simple(mut conn: PoolConnection<Postgres>) -> anyhow::Result<()> {
     clean_up(&mut conn).await?;
 
     let migrator = Migrator::new(Path::new("tests/postgres/migrations_simple")).await?;
@@ -31,11 +27,8 @@ async fn simple() -> anyhow::Result<()> {
     Ok(())
 }
 
-#[sqlx_macros::test]
-async fn reversible() -> anyhow::Result<()> {
-    let _guard = SimpleLockGuard::acquire();
-
-    let mut conn = new::<Postgres>().await?;
+#[sqlx::test(migrations = false)]
+async fn reversible(mut conn: PoolConnection<Postgres>) -> anyhow::Result<()> {
     clean_up(&mut conn).await?;
 
     let migrator = Migrator::new(Path::new("tests/postgres/migrations_reversible")).await?;

tests/sqlite/migrate.rs

@@ -1,16 +1,12 @@
 use sqlx::migrate::Migrator;
+use sqlx::pool::PoolConnection;
 use sqlx::sqlite::{Sqlite, SqliteConnection};
 use sqlx::Executor;
 use sqlx::Row;
 use std::path::Path;
 
-use sqlx_test::{new, SimpleLockGuard};
-
-#[sqlx_macros::test]
-async fn simple() -> anyhow::Result<()> {
-    let _guard = SimpleLockGuard::acquire();
-
-    let mut conn = new::<Sqlite>().await?;
+#[sqlx::test(migrations = false)]
+async fn simple(mut conn: PoolConnection<Sqlite>) -> anyhow::Result<()> {
     clean_up(&mut conn).await?;
 
     let migrator = Migrator::new(Path::new("tests/sqlite/migrations_simple")).await?;
@@ -31,11 +27,8 @@ async fn simple() -> anyhow::Result<()> {
     Ok(())
 }
 
-#[sqlx_macros::test]
-async fn reversible() -> anyhow::Result<()> {
-    let _guard = SimpleLockGuard::acquire();
-
-    let mut conn = new::<Sqlite>().await?;
+#[sqlx::test(migrations = false)]
+async fn reversible(mut conn: PoolConnection<Sqlite>) -> anyhow::Result<()> {
     clean_up(&mut conn).await?;
 
     let migrator = Migrator::new(Path::new("tests/sqlite/migrations_reversible")).await?;