migratrom-sqlite 0.2.0

SQLite (sqlx) adapter for migratrom.
Documentation
//! End-to-end SQLite tests against a real in-memory database.

use migratrom::operations::create_table;
use migratrom::{ApplyOptions, ColumnDef, Migration, MigratromError, PrimaryKey, SqliteDialect};
use migratrom_sqlite::apply_migrations;
use sqlx::sqlite::SqlitePoolOptions;
use sqlx::{Row, SqlitePool};

/// A single shared in-memory connection so state persists across `apply` calls.
async fn pool() -> SqlitePool {
    SqlitePoolOptions::new()
        .max_connections(1)
        .connect("sqlite::memory:")
        .await
        .expect("connect in-memory sqlite")
}

fn users_migration() -> Migration {
    let dialect = SqliteDialect;
    let op = create_table(
        "main",
        "users",
        &[
            ColumnDef::new("id", "INTEGER"),
            ColumnDef::new("email", "TEXT"),
        ],
        Some(&PrimaryKey {
            columns: vec!["id".into()],
        }),
        &dialect,
    )
    .expect("build create_table");
    Migration::new(1, None, vec![op])
}

#[tokio::test]
async fn applies_then_skips_on_reapply() {
    let pool = pool().await;
    let opts = ApplyOptions::default();

    let first = apply_migrations(&[users_migration()], &pool, &opts)
        .await
        .unwrap();
    assert_eq!(first.applied, vec![1]);

    // The table really exists.
    let count: i64 =
        sqlx::query("SELECT COUNT(*) FROM \"main\".sqlite_master WHERE name = 'users'")
            .fetch_one(&pool)
            .await
            .unwrap()
            .get(0);
    assert_eq!(count, 1);

    // Re-applying is a no-op: migration 1 is already in history.
    let second = apply_migrations(&[users_migration()], &pool, &opts)
        .await
        .unwrap();
    assert!(second.applied.is_empty());
}

#[tokio::test]
async fn rejects_edited_applied_migration() {
    let pool = pool().await;
    let opts = ApplyOptions::default();
    apply_migrations(&[users_migration()], &pool, &opts)
        .await
        .unwrap();

    // Same id, different body => checksum mismatch.
    let dialect = SqliteDialect;
    let edited_op = create_table(
        "main",
        "users",
        &[ColumnDef::new("id", "INTEGER")],
        Some(&PrimaryKey {
            columns: vec!["id".into()],
        }),
        &dialect,
    )
    .unwrap();
    let edited = Migration::new(1, None, vec![edited_op]);

    let err = apply_migrations(&[edited], &pool, &opts).await.unwrap_err();
    assert!(matches!(
        err,
        MigratromError::ChecksumMismatch { id: 1, .. }
    ));
}