Merge branch 'database-migrate-dry' into 'master'

Reuse code where possible

See merge request memri/pod!80

src/database_migrate_refinery.rs

+use r2d2::ManageConnection;
+use r2d2_sqlite::SqliteConnectionManager;
+
+pub mod embedded {
+    use refinery::embed_migrations;
+    embed_migrations!("./res/migrations");
+}
+
+pub fn migrate(sqlite: &SqliteConnectionManager) {
+    let mut refinery_connection = sqlite
+        .connect()
+        .expect("Failed to open a connection for refinery database migrations");
+    // Run "refinery" migrations to bring the core structure of items/edges up-to-date
+    embedded::migrations::runner()
+        .run(&mut refinery_connection)
+        .expect("Failed to run refinery migrations");
+}

src/lib.rs

@@ -2,7 +2,7 @@
 
 pub mod api_model;
 pub mod database_init;
+pub mod database_migrate_refinery;
 pub mod error;
 pub mod internal_api;
 pub mod sql_converters;
-pub mod warp_api;

src/main.rs

@@ -4,6 +4,7 @@ extern crate rusqlite;
 
 mod api_model;
 pub mod database_init;
+mod database_migrate_refinery;
 mod error;
 pub mod internal_api;
 mod sql_converters;
@@ -14,7 +15,6 @@ use env_logger::Env;
 use log::info;
 use log::warn;
 use pnet::datalink;
-use r2d2::ManageConnection;
 use r2d2::Pool;
 use r2d2_sqlite::SqliteConnectionManager;
 use std::env;
@@ -24,11 +24,6 @@ use std::net::IpAddr::V4;
 use std::net::IpAddr::V6;
 use std::path::PathBuf;
 
-mod embedded {
-    use refinery::embed_migrations;
-    embed_migrations!("./res/migrations");
-}
-
 #[tokio::main]
 async fn main() {
     env_logger::Builder::from_env(Env::default().filter_or("RUST_LOG", "info"))
@@ -57,13 +52,7 @@ async fn main() {
     let sqlite_manager = SqliteConnectionManager::file(&sqlite_file)
         .with_init(|c| c.execute_batch("PRAGMA foreign_keys = ON;"));
 
-    let mut refinery_connection = sqlite_manager
-        .connect()
-        .expect("Failed to open a connection for refinery database migrations");
-    // Run "refinery" migrations to bring the core structure of items/edges up-to-date
-    embedded::migrations::runner()
-        .run(&mut refinery_connection)
-        .expect("Failed to run refinery migrations");
+    database_migrate_refinery::migrate(&sqlite_manager);
 
     let sqlite: Pool<SqliteConnectionManager> =
         r2d2::Pool::new(sqlite_manager).expect("Failed to create r2d2 SQLite connection pool");

tests/test_api.rs

-extern crate pod;
-
-use pod::internal_api::*;
-use serde_json::json;
-use serde_json::Value;
-
-mod common;
-
-#[test]
-fn test_bulk_action() {
-    let sqlite = &common::SQLITE;
-
-    let json = json!({
-    "createItems": [{"uid": 1, "_type": "Person"}, {"uid": 2, "_type": "Person"}],
-    "updateItems": [{"uid": 1, "_type": "Person1"}],
-    "createEdges": [{"_type": "friend", "_source": 1, "_target": 2}]
-    });
-
-    let result1 = bulk_action(&sqlite, json);
-
-    let result2 = get_item_with_edges(&sqlite, 1);
-
-    let json = json!({"_type": "Person"});
-    let result3 = search_by_fields(&sqlite, json);
-
-    assert!(result1.is_ok());
-    assert!(result2.is_ok());
-    assert!(check_has_item(result3.ok()));
-}
-
-fn check_has_item(result: Option<Vec<Value>>) -> bool {
-    result.iter().flatten().next().is_some()
-}

tests/common.rs → tests/test_internal_api.rs

 extern crate pod;
-extern crate rusqlite;
 
 use lazy_static::lazy_static;
 use pod::database_init;
+use pod::database_migrate_refinery;
+use pod::internal_api::*;
 use r2d2::ManageConnection;
 use r2d2::Pool;
 use r2d2_sqlite::SqliteConnectionManager;
 use rusqlite::OpenFlags;
+use serde_json::json;
+use serde_json::Value;
 use std::path::PathBuf;
 
-mod embedded {
-    use refinery::embed_migrations;
-    embed_migrations!("./res/migrations");
-}
-
-// Create a SQL connection pool to a tests database
 lazy_static! {
-    pub static ref SQLITE: Pool<SqliteConnectionManager> = {
-        let sqlite_manager =
+    static ref SQLITE: Pool<SqliteConnectionManager> = {
+        let sqlite =
             SqliteConnectionManager::file(PathBuf::from("file:memdb?mode=memory&cache=shared"))
                 .with_flags(OpenFlags::SQLITE_OPEN_URI | OpenFlags::SQLITE_OPEN_READ_WRITE)
                 .with_init(|c| c.execute_batch("PRAGMA foreign_keys = ON;"));
-        let mut refinery_connection = sqlite_manager
+
+        // Cannot re-use `migrate` function from `database_migrate_refinery`.
+        // Probably due to some weird lifetime problem, didn't properly investigate yet
+        let mut refinery_connection = sqlite
             .connect()
             .expect("Failed to open a connection for refinery database migrations");
-        embedded::migrations::runner()
+        // Run "refinery" migrations to bring the core structure of items/edges up-to-date
+        database_migrate_refinery::embedded::migrations::runner()
             .run(&mut refinery_connection)
             .expect("Failed to run refinery migrations");
+        // database_migrate_refinery::migrate(&sqlite);
 
         let sqlite: Pool<SqliteConnectionManager> =
-            r2d2::Pool::new(sqlite_manager).expect("Failed to create r2d2 SQLite connection pool");
+            r2d2::Pool::new(sqlite).expect("Failed to create r2d2 SQLite connection pool");
         database_init::init(&sqlite);
         sqlite
     };
 }
+
+#[test]
+fn test_bulk_action() {
+    let sqlite = &SQLITE;
+
+    let json = json!({
+        "createItems": [{"uid": 1, "_type": "Person"}, {"uid": 2, "_type": "Person"}],
+        "updateItems": [{"uid": 1, "_type": "Person1"}],
+        "createEdges": [{"_type": "friend", "_source": 1, "_target": 2}]
+    });
+
+    let result1 = bulk_action(&sqlite, json);
+
+    let result2 = get_item_with_edges(&sqlite, 1);
+
+    let json = json!({"_type": "Person"});
+    let result3 = search_by_fields(&sqlite, json);
+
+    assert!(result1.is_ok());
+    assert!(result2.is_ok());
+    assert!(check_has_item(result3.ok()));
+}
+
+fn check_has_item(result: Option<Vec<Value>>) -> bool {
+    result.iter().flatten().next().is_some()
+}