test: extend migrations testing

Author: crepererum

Cargo.toml

@@ -206,6 +206,11 @@ name = "sqlite-derives"
 path = "tests/sqlite/derives.rs"
 required-features = ["sqlite", "macros"]
 
+[[test]]
+name = "sqlite-migrate"
+path = "tests/sqlite/migrate.rs"
+required-features = ["sqlite", "macros", "migrate"]
+
 #
 # MySQL
 #
@@ -230,6 +235,11 @@ name = "mysql-macros"
 path = "tests/mysql/macros.rs"
 required-features = ["mysql", "macros"]
 
+[[test]]
+name = "mysql-migrate"
+path = "tests/mysql/migrate.rs"
+required-features = ["mysql", "macros", "migrate"]
+
 #
 # PostgreSQL
 #
@@ -259,6 +269,11 @@ name = "postgres-derives"
 path = "tests/postgres/derives.rs"
 required-features = ["postgres", "macros"]
 
+[[test]]
+name = "postgres-migrate"
+path = "tests/postgres/migrate.rs"
+required-features = ["postgres", "macros", "migrate"]
+
 #
 # Microsoft SQL Server (MSSQL)
 #

sqlx-test/src/lib.rs

@@ -1,6 +1,7 @@
 use sqlx::pool::PoolOptions;
 use sqlx::{Connection, Database, Pool};
 use std::env;
+use std::sync::atomic::{AtomicBool, Ordering};
 
 pub fn setup_if_needed() {
     let _ = dotenv::dotenv();
@@ -223,3 +224,31 @@ 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/migrate/macro.rs

@@ -1,21 +1,29 @@
 use sqlx::migrate::Migrator;
 use std::path::Path;
 
-static EMBEDDED: Migrator = sqlx::migrate!("tests/migrate/migrations");
+static EMBEDDED_SIMPLE: Migrator = sqlx::migrate!("tests/migrate/migrations_simple");
+static EMBEDDED_REVERSIBLE: Migrator = sqlx::migrate!("tests/migrate/migrations_reversible");
 
 #[sqlx_macros::test]
 async fn same_output() -> anyhow::Result<()> {
-    let runtime = Migrator::new(Path::new("tests/migrate/migrations")).await?;
+    let runtime_simple = Migrator::new(Path::new("tests/migrate/migrations_simple")).await?;
+    let runtime_reversible =
+        Migrator::new(Path::new("tests/migrate/migrations_reversible")).await?;
 
-    assert_eq!(runtime.migrations.len(), EMBEDDED.migrations.len());
+    assert_same(&EMBEDDED_SIMPLE, &runtime_simple);
+    assert_same(&EMBEDDED_REVERSIBLE, &runtime_reversible);
 
-    for (e, r) in EMBEDDED.iter().zip(runtime.iter()) {
+    Ok(())
+}
+
+fn assert_same(embedded: &Migrator, runtime: &Migrator) {
+    assert_eq!(runtime.migrations.len(), embedded.migrations.len());
+
+    for (e, r) in embedded.iter().zip(runtime.iter()) {
         assert_eq!(e.version, r.version);
         assert_eq!(e.description, r.description);
         assert_eq!(e.migration_type, r.migration_type);
         assert_eq!(e.sql, r.sql);
         assert_eq!(e.checksum, r.checksum);
     }
-
-    Ok(())
 }

tests/migrate/migrations/20200723212833_tweet.sql

@@ -0,0 +1 @@
+DROP TABLE migrations_reversible_test;

tests/migrate/migrations/20200723212841_accounts.sql

@@ -0,0 +1,7 @@
+CREATE TABLE migrations_reversible_test (
+    some_id BIGINT NOT NULL PRIMARY KEY,
+    some_payload BIGINT NOT NUll
+);
+
+INSERT INTO migrations_reversible_test (some_id, some_payload)
+VALUES (1, 100);

tests/migrate/migrations_reversible/20220721124650_add_table.down.sql

@@ -0,0 +1,2 @@
+UPDATE migrations_reversible_test
+SET some_payload = some_payload - 1;

tests/migrate/migrations_reversible/20220721124650_add_table.up.sql

@@ -0,0 +1,2 @@
+UPDATE migrations_reversible_test
+SET some_payload = some_payload + 1;

tests/migrate/migrations_reversible/20220721125033_modify_column.down.sql

@@ -0,0 +1,7 @@
+CREATE TABLE migrations_simple_test (
+    some_id BIGINT NOT NULL PRIMARY KEY,
+    some_payload BIGINT NOT NUll
+);
+
+INSERT INTO migrations_simple_test (some_id, some_payload)
+VALUES (1, 100);

tests/migrate/migrations_reversible/20220721125033_modify_column.up.sql

@@ -0,0 +1,34 @@
+-- Perform a tricky conversion of the payload.
+--
+-- This script will only succeed once and will fail if executed twice.
+
+-- set up temporary target column
+ALTER TABLE migrations_simple_test
+ADD some_payload_tmp TEXT;
+
+-- perform conversion
+-- This will fail if `some_payload` is already a string column due to the addition.
+-- We add a suffix after the addition to ensure that the SQL database does not silently cast the string back to an 
+-- integer.
+UPDATE migrations_simple_test
+SET some_payload_tmp = CONCAT(CAST((some_payload + 10) AS TEXT), '_suffix');
+
+-- remove original column including the content
+ALTER TABLE migrations_simple_test
+DROP COLUMN some_payload;
+
+-- prepare new payload column (nullable, so we can copy over the data)
+ALTER TABLE migrations_simple_test
+ADD some_payload TEXT;
+
+-- copy new values
+UPDATE migrations_simple_test
+SET some_payload = some_payload_tmp;
+
+-- "freeze" column
+ALTER TABLE migrations_simple_test
+ALTER COLUMN some_payload SET NOT NULL;
+
+-- clean up
+ALTER TABLE migrations_simple_test
+DROP COLUMN some_payload_tmp;

tests/migrate/migrations_simple/20220721115250_add_test_table.sql

@@ -0,0 +1,85 @@
+use sqlx::migrate::Migrator;
+use sqlx::mysql::{MySql, MySqlConnection};
+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?;
+    clean_up(&mut conn).await?;
+
+    let migrator = Migrator::new(Path::new("tests/mysql/migrations_simple")).await?;
+
+    // run migration
+    migrator.run(&mut conn).await?;
+
+    // check outcome
+    let res: String = conn
+        .fetch_one("SELECT some_payload FROM migrations_simple_test")
+        .await?
+        .get(0);
+    assert_eq!(res, "110_suffix");
+
+    // running it a 2nd time should still work
+    migrator.run(&mut conn).await?;
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn reversible() -> anyhow::Result<()> {
+    let _guard = SimpleLockGuard::acquire();
+
+    let mut conn = new::<MySql>().await?;
+    clean_up(&mut conn).await?;
+
+    let migrator = Migrator::new(Path::new("tests/mysql/migrations_reversible")).await?;
+
+    // run migration
+    migrator.run(&mut conn).await?;
+
+    // check outcome
+    let res: i64 = conn
+        .fetch_one("SELECT some_payload FROM migrations_reversible_test")
+        .await?
+        .get(0);
+    assert_eq!(res, 101);
+
+    // roll back nothing (last version)
+    migrator.undo(&mut conn, 20220721125033).await?;
+
+    // check outcome
+    let res: i64 = conn
+        .fetch_one("SELECT some_payload FROM migrations_reversible_test")
+        .await?
+        .get(0);
+    assert_eq!(res, 101);
+
+    // roll back one version
+    migrator.undo(&mut conn, 20220721124650).await?;
+
+    // check outcome
+    let res: i64 = conn
+        .fetch_one("SELECT some_payload FROM migrations_reversible_test")
+        .await?
+        .get(0);
+    assert_eq!(res, 100);
+
+    Ok(())
+}
+
+/// Ensure that we have a clean initial state.
+async fn clean_up(conn: &mut MySqlConnection) -> anyhow::Result<()> {
+    conn.execute("DROP TABLE migrations_simple_test").await.ok();
+    conn.execute("DROP TABLE migrations_reversible_test")
+        .await
+        .ok();
+    conn.execute("DROP TABLE _sqlx_migrations").await.ok();
+
+    Ok(())
+}

tests/migrate/migrations_simple/20220721115524_convert_type.sql

@@ -0,0 +1 @@
+DROP TABLE migrations_reversible_test;

tests/mysql/migrate.rs

@@ -0,0 +1,7 @@
+CREATE TABLE migrations_reversible_test (
+    some_id BIGINT NOT NULL PRIMARY KEY,
+    some_payload BIGINT NOT NUll
+);
+
+INSERT INTO migrations_reversible_test (some_id, some_payload)
+VALUES (1, 100);

tests/mysql/migrations_reversible/20220721124650_add_table.down.sql

@@ -0,0 +1,2 @@
+UPDATE migrations_reversible_test
+SET some_payload = some_payload - 1;

tests/mysql/migrations_reversible/20220721124650_add_table.up.sql

@@ -0,0 +1,2 @@
+UPDATE migrations_reversible_test
+SET some_payload = some_payload + 1;

tests/mysql/migrations_reversible/20220721125033_modify_column.down.sql

@@ -0,0 +1,7 @@
+CREATE TABLE migrations_simple_test (
+    some_id BIGINT NOT NULL PRIMARY KEY,
+    some_payload BIGINT NOT NUll
+);
+
+INSERT INTO migrations_simple_test (some_id, some_payload)
+VALUES (1, 100);

tests/mysql/migrations_reversible/20220721125033_modify_column.up.sql

@@ -0,0 +1,34 @@
+-- Perform a tricky conversion of the payload.
+--
+-- This script will only succeed once and will fail if executed twice.
+
+-- set up temporary target column
+ALTER TABLE migrations_simple_test
+ADD some_payload_tmp TEXT;
+
+-- perform conversion
+-- This will fail if `some_payload` is already a string column due to the addition.
+-- We add a suffix after the addition to ensure that the SQL database does not silently cast the string back to an 
+-- integer.
+UPDATE migrations_simple_test
+SET some_payload_tmp = CONCAT(CAST((some_payload + 10) AS CHAR(3)), '_suffix');
+
+-- remove original column including the content
+ALTER TABLE migrations_simple_test
+DROP COLUMN some_payload;
+
+-- prepare new payload column (nullable, so we can copy over the data)
+ALTER TABLE migrations_simple_test
+ADD some_payload TEXT;
+
+-- copy new values
+UPDATE migrations_simple_test
+SET some_payload = some_payload_tmp;
+
+-- "freeze" column
+ALTER TABLE migrations_simple_test
+MODIFY some_payload TEXT NOT NULL;
+
+-- clean up
+ALTER TABLE migrations_simple_test
+DROP COLUMN some_payload_tmp;