Saving changes

src/main.rs

@@ -59,8 +59,6 @@ mod init {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use std::{env, str::FromStr};
-    use uuid::Uuid;
 
     use axum::{
         body::Body,
@@ -77,55 +75,75 @@ mod tests {
         pub data: icarus_auth::models::common::User,
     }
 
-    async fn connect_to_db(db_name: &str) -> Result<sqlx::PgPool, sqlx::Error> {
+    mod db_mgr {
-        let db_url =
+        use std::str::FromStr;
-            env::var("TEST_DATABASE_URL").expect("TEST_DATABASE_URL must be set for tests");
-        let options = sqlx::postgres::PgConnectOptions::from_str(&db_url)?.database(db_name);
-        sqlx::PgPool::connect_with(options).await
-    }
 
-    async fn create_database(
+        pub const LIMIT: usize = 6;
-        template_pool: &sqlx::PgPool,
+
-        db_name: &str,
+        pub async fn eeee() -> Result<sqlx::PgPool, sqlx::Error> {
-    ) -> Result<(), sqlx::Error> {
+            let tm_db_url = std::env::var("DATABASE_URL").expect("DATABASE_URL must be present");
-        let create_query = format!("CREATE DATABASE {}", db_name);
+            let tm_options = sqlx::postgres::PgConnectOptions::from_str(&tm_db_url).unwrap();
-        match sqlx::query(&create_query).execute(template_pool).await {
+            sqlx::PgPool::connect_with(tm_options).await
-            Ok(_) => Ok(()),
-            Err(e) => Err(e),
         }
-        // Ok(())
-    }
 
-    // Function to drop a database
+        pub async fn generate_db_name() -> String {
-    async fn drop_database(template_pool: &sqlx::PgPool, db_name: &str) -> Result<(), sqlx::Error> {
+            let db_name =
-        let drop_query = format!("DROP DATABASE IF EXISTS {} WITH (FORCE)", db_name);
+                get_database_name().unwrap() + &"_" + &uuid::Uuid::new_v4().to_string()[..LIMIT];
-        sqlx::query(&drop_query).execute(template_pool).await?;
+            db_name
-        Ok(())
+        }
-    }
 
-    fn get_database_name() -> Result<String, Box<dyn std::error::Error>> {
+        pub async fn connect_to_db(db_name: &str) -> Result<sqlx::PgPool, sqlx::Error> {
-        dotenvy::dotenv().ok(); // Load .env file if it exists
+            let db_url = std::env::var("TEST_DATABASE_URL")
+                .expect("TEST_DATABASE_URL must be set for tests");
+            let options = sqlx::postgres::PgConnectOptions::from_str(&db_url)?.database(db_name);
+            sqlx::PgPool::connect_with(options).await
+        }
 
-        match std::env::var("TEST_DATABASE_URL") {
+        pub async fn create_database(
-            Ok(database_url) => {
+            template_pool: &sqlx::PgPool,
-                let parsed_url = url::Url::parse(&database_url)?;
+            db_name: &str,
-                if parsed_url.scheme() == "postgres" || parsed_url.scheme() == "postgresql" {
+        ) -> Result<(), sqlx::Error> {
-                    match parsed_url
+            let create_query = format!("CREATE DATABASE {}", db_name);
-                        .path_segments()
+            match sqlx::query(&create_query).execute(template_pool).await {
-                        .and_then(|segments| segments.last().map(|s| s.to_string()))
+                Ok(_) => Ok(()),
-                    {
+                Err(e) => Err(e),
-                        Some(sss) => Ok(sss),
+            }
-                        None => Err("Error parsing".into()),
+        }
+
+        // Function to drop a database
+        pub async fn drop_database(
+            template_pool: &sqlx::PgPool,
+            db_name: &str,
+        ) -> Result<(), sqlx::Error> {
+            let drop_query = format!("DROP DATABASE IF EXISTS {} WITH (FORCE)", db_name);
+            sqlx::query(&drop_query).execute(template_pool).await?;
+            Ok(())
+        }
+
+        pub fn get_database_name() -> Result<String, Box<dyn std::error::Error>> {
+            dotenvy::dotenv().ok(); // Load .env file if it exists
+
+            match std::env::var("TEST_DATABASE_URL") {
+                Ok(database_url) => {
+                    let parsed_url = url::Url::parse(&database_url)?;
+                    if parsed_url.scheme() == "postgres" || parsed_url.scheme() == "postgresql" {
+                        match parsed_url
+                            .path_segments()
+                            .and_then(|segments| segments.last().map(|s| s.to_string()))
+                        {
+                            Some(sss) => Ok(sss),
+                            None => Err("Error parsing".into()),
+                        }
+                    } else {
+                        // Handle other database types if needed
+                        Err("Error parsing".into())
                     }
-                } else {
+                }
-                    // Handle other database types if needed
+                Err(_) => {
+                    // TEST_DATABASE_URL environment variable not found
                     Err("Error parsing".into())
                 }
             }
-            Err(_) => {
-                // TEST_DATABASE_URL environment variable not found
-                Err("Error parsing".into())
-            }
         }
     }
 
@@ -153,14 +171,11 @@ mod tests {
 
     #[tokio::test]
     async fn test_register_user() {
-        let tm_db_url = env::var("DATABASE_URL").expect("DATABASE_URL must be present");
+        let tm_pool = db_mgr::eeee().await.unwrap();
-        let tm_options = sqlx::postgres::PgConnectOptions::from_str(&tm_db_url).unwrap();
-        let tm_pool = sqlx::PgPool::connect_with(tm_options).await.unwrap();
 
-        let db_name = get_database_name().unwrap() + &"_" + &uuid::Uuid::new_v4().to_string()[..5];
+        let db_name = db_mgr::generate_db_name().await;
-        // assert_eq!(true, db_name.is_empty(), "{:?} {:?}", db_name, tm_db_url);
+
-        // assert!(db_name.is_empty(), "eee {:?}", tm_db_url);
+        match db_mgr::create_database(&tm_pool, &db_name).await {
-        match create_database(&tm_pool, &db_name).await {
             Ok(_) => {
                 println!("Success");
             }
@@ -169,16 +184,10 @@ mod tests {
             }
         }
 
-        let pool = connect_to_db(&db_name).await.unwrap();
+        let pool = db_mgr::connect_to_db(&db_name).await.unwrap();
 
-        /*
-        let pool = icarus_auth::db_pool::create_pool()
-            .await
-            .expect("Failed to create pool");
-        */
         db::migrations(&pool).await;
 
-        // let mut tx = pool.begin().await.unwrap();
         let app = init::routes().await.layer(axum::Extension(pool));
 
         let usr = icarus_auth::models::common::CreateUser {
@@ -220,8 +229,6 @@ mod tests {
             }
         };
 
-        drop_database(&tm_pool, &db_name).await;
+        let _ = db_mgr::drop_database(&tm_pool, &db_name).await;
-
-        // tx.rollback().await.unwrap();
     }
 }