fix lib tests

refinery_core/src/drivers/mysql.rs

@@ -24,7 +24,9 @@ fn query_applied_migrations(
             version,
             row.get(1).unwrap(),
             applied_on,
-            checksum.parse::<u64>().expect("checksum must be a valid u64")
+            checksum
+                .parse::<u64>()
+                .expect("checksum must be a valid u64"),
         ))
     }
     Ok(applied)

refinery_core/src/drivers/mysql_async.rs

@@ -25,7 +25,9 @@ async fn query_applied_migrations(
                 version,
                 name,
                 applied_on,
-                checksum.parse::<u64>().expect("checksum must be a valid u64")
+                checksum
+                    .parse::<u64>()
+                    .expect("checksum must be a valid u64"),
             )
         })
         .await?;

refinery_core/src/drivers/postgres.rs

@@ -17,11 +17,13 @@ fn query_applied_migrations(
             .with_timezone(&Local);
         let checksum: String = row.get(3);
 
-        applied.push(Migration::applied (
+        applied.push(Migration::applied(
             version,
             row.get(1),
             applied_on,
-            checksum.parse::<u64>().expect("checksum must be a valid u64")
+            checksum
+                .parse::<u64>()
+                .expect("checksum must be a valid u64"),
         ));
     }
     Ok(applied)

refinery_core/src/drivers/rusqlite.rs

@@ -22,7 +22,9 @@ fn query_applied_migrations(
             version,
             row.get(1)?,
             applied_on,
-            checksum.parse::<u64>().expect("checksum must be a valid u64")
+            checksum
+                .parse::<u64>()
+                .expect("checksum must be a valid u64"),
         ));
     }
     Ok(applied)

refinery_core/src/drivers/tokio_postgres.rs

@@ -23,7 +23,9 @@ async fn query_applied_migrations(
             version,
             row.get(1),
             applied_on,
-            checksum.parse::<u64>().expect("checksum must be a valid u64")
+            checksum
+                .parse::<u64>()
+                .expect("checksum must be a valid u64"),
         ));
     }
     Ok(applied)

refinery_core/src/runner.rs

@@ -52,7 +52,7 @@ pub struct Migration {
     version: i32,
     prefix: Type,
     sql: Option<String>,
-    applied_on: Option<DateTime<Local>>
+    applied_on: Option<DateTime<Local>>,
 }
 
 impl Migration {
@@ -83,7 +83,12 @@ impl Migration {
     }
 
     // Create a migration from an applied migration on the database
-    pub(crate) fn applied(version: i32, name: String, applied_on: DateTime<Local>, checksum: u64) -> Migration {
+    pub(crate) fn applied(
+        version: i32,
+        name: String,
+        applied_on: DateTime<Local>,
+        checksum: u64,
+    ) -> Migration {
         Migration {
             state: State::Applied,
             name,
@@ -92,7 +97,7 @@ impl Migration {
             // applied migrations are always versioned
             prefix: Type::Versioned,
             sql: None,
-            applied_on: Some(applied_on)
+            applied_on: Some(applied_on),
         }
     }
 
@@ -255,10 +260,7 @@ impl Runner {
     }
 
     /// Queries the database for all previous applied migrations
-    pub fn get_applied_migrations<'a, C>(
-        &self,
-        conn: &'a mut C,
-    ) -> Result<Vec<Migration>, Error>
+    pub fn get_applied_migrations<'a, C>(&self, conn: &'a mut C) -> Result<Vec<Migration>, Error>
     where
         C: Migrate,
     {

refinery_core/src/traits/async.rs

@@ -38,7 +38,10 @@ async fn migrate<T: AsyncTransaction>(
                 "INSERT INTO refinery_schema_history (version, name, applied_on, checksum) VALUES ({}, '{}', '{}', '{}')",
                 migration.version(), migration.name(), Local::now().to_rfc3339(), migration.checksum().to_string());
         transaction
-            .execute(&[migration.sql().as_ref().expect("sql must be Some!"), update_query])
+            .execute(&[
+                migration.sql().as_ref().expect("sql must be Some!"),
+                update_query,
+            ])
             .await
             .migration_err(&format!("error applying migration {}", migration))?;
     }

refinery_core/src/traits/mod.rs

@@ -91,32 +91,32 @@ pub(crate) const GET_LAST_APPLIED_MIGRATION_QUERY: &str =
 
 #[cfg(test)]
 mod tests {
-    use super::{check_missing_divergent,Error, Migration};
+    use super::{check_missing_divergent, Error, Migration};
 
     fn get_migrations() -> Vec<Migration> {
-        let migration1 = Migration::from_filename(
+        let migration1 = Migration::unapplied(
             "V1__initial.sql",
             include_str!("../../../refinery/tests/sql_migrations/V1-2/V1__initial.sql"),
         )
         .unwrap();
 
-        let migration2 = Migration::from_filename(
+        let migration2 = Migration::unapplied(
             "V2__add_cars_and_motos_table.sql",
             include_str!(
                 "../../../refinery/tests/sql_migrations/V1-2/V2__add_cars_and_motos_table.sql"
             ),
         )
         .unwrap();
 
-        let migration3 = Migration::from_filename(
+        let migration3 = Migration::unapplied(
             "V3__add_brand_to_cars_table",
             include_str!(
                 "../../../refinery/tests/sql_migrations/V3/V3__add_brand_to_cars_table.sql"
             ),
         )
         .unwrap();
 
-        let migration4 = Migration::from_filename(
+        let migration4 = Migration::unapplied(
             "V4__add_year_field_to_cars",
             &"ALTER TABLE cars ADD year INTEGER;",
         )
@@ -137,9 +137,9 @@ mod tests {
     fn check_missing_divergent_returns_unapplied() {
         let migrations = get_migrations();
         let applied: Vec<Migration> = vec![
-            migrations[0].clone().as_applied(),
-            migrations[1].clone().as_applied(),
-            migrations[2].clone().as_applied(),
+            migrations[0].clone(),
+            migrations[1].clone(),
+            migrations[2].clone(),
         ];
         let remaining = vec![migrations[3].clone()];
         let result = check_missing_divergent(applied, migrations, true, true).unwrap();
@@ -149,18 +149,24 @@ mod tests {
     #[test]
     fn check_missing_divergent_fails_on_divergent() {
         let migrations = get_migrations();
-        let mut applied: Vec<Migration> = vec![
-            migrations[0].clone().as_applied(),
-            migrations[1].clone().as_applied(),
-            migrations[2].clone().as_applied(),
+        let applied: Vec<Migration> = vec![
+            migrations[0].clone(),
+            migrations[1].clone(),
+            Migration::unapplied(
+                "V3__add_brand_to_cars_tableeee",
+                include_str!(
+                    "../../../refinery/tests/sql_migrations/V3/V3__add_brand_to_cars_table.sql"
+                ),
+            )
+            .unwrap(),
         ];
-        applied[2].checksum = "3a6d3a3".into();
+
         let migration = migrations[2].clone();
         let err = check_missing_divergent(applied, migrations, true, true).unwrap_err();
         match err {
             Error::DivergentVersion(applied, divergent) => {
                 assert_eq!(migration, divergent);
-                assert_eq!("add_brand_to_cars_table", applied.name);
+                assert_eq!("add_brand_to_cars_tableeee", applied.name());
             }
             _ => panic!("failed test"),
         }
@@ -169,12 +175,17 @@ mod tests {
     #[test]
     fn check_missing_divergent_doesnt_fail_on_divergent() {
         let migrations = get_migrations();
-        let mut applied: Vec<Migration> = vec![
-            migrations[0].clone().as_applied(),
-            migrations[1].clone().as_applied(),
-            migrations[2].clone().as_applied(),
+        let applied: Vec<Migration> = vec![
+            migrations[0].clone(),
+            migrations[1].clone(),
+            Migration::unapplied(
+                "V3__add_brand_to_cars_tableeee",
+                include_str!(
+                    "../../../refinery/tests/sql_migrations/V3/V3__add_brand_to_cars_table.sql"
+                ),
+            )
+            .unwrap(),
         ];
-        applied[2].checksum = "3a6d3a3".into();
         let remaining = vec![migrations[3].clone()];
         let result = check_missing_divergent(applied, migrations, false, true).unwrap();
         assert_eq!(remaining, result);
@@ -183,15 +194,12 @@ mod tests {
     #[test]
     fn check_missing_divergent_fails_on_missing_on_applied() {
         let migrations = get_migrations();
-        let applied: Vec<Migration> = vec![
-            migrations[0].clone().as_applied(),
-            migrations[2].clone().as_applied(),
-        ];
+        let applied: Vec<Migration> = vec![migrations[0].clone(), migrations[2].clone()];
         let migration = migrations[1].clone();
         let err = check_missing_divergent(applied, migrations, true, true).unwrap_err();
         match err {
             Error::MissingVersion(missing) => {
-                assert_eq!(migration.as_applied(), missing);
+                assert_eq!(migration, missing);
             }
             _ => panic!("failed test"),
         }
@@ -201,15 +209,15 @@ mod tests {
     fn check_missing_divergent_fails_on_missing_on_filesystem() {
         let mut migrations = get_migrations();
         let applied: Vec<Migration> = vec![
-            migrations[0].clone().as_applied(),
-            migrations[1].clone().as_applied(),
-            migrations[2].clone().as_applied(),
+            migrations[0].clone(),
+            migrations[1].clone(),
+            migrations[2].clone(),
         ];
         let migration = migrations.remove(1);
         let err = check_missing_divergent(applied, migrations, true, true).unwrap_err();
         match err {
             Error::MissingVersion(missing) => {
-                assert_eq!(migration.as_applied(), missing);
+                assert_eq!(migration, missing);
             }
             _ => panic!("failed test"),
         }
@@ -218,10 +226,7 @@ mod tests {
     #[test]
     fn check_missing_divergent_doesnt_fail_on_missing_on_applied() {
         let migrations = get_migrations();
-        let applied: Vec<Migration> = vec![
-            migrations[0].clone().as_applied(),
-            migrations[2].clone().as_applied(),
-        ];
+        let applied: Vec<Migration> = vec![migrations[0].clone(), migrations[2].clone()];
         let remaining = vec![migrations[3].clone()];
         let result = check_missing_divergent(applied, migrations, true, false).unwrap();
         assert_eq!(remaining, result);
@@ -231,9 +236,9 @@ mod tests {
     fn check_missing_divergent_doesnt_fail_on_missing_on_filesystem() {
         let mut migrations = get_migrations();
         let applied: Vec<Migration> = vec![
-            migrations[0].clone().as_applied(),
-            migrations[1].clone().as_applied(),
-            migrations[2].clone().as_applied(),
+            migrations[0].clone(),
+            migrations[1].clone(),
+            migrations[2].clone(),
         ];
         migrations.remove(1);
         let remaining = vec![migrations[2].clone()];