Schedule message (#15)

Reviewed-on: phoenix/textsender_api#15

tests/test.rs

@@ -1,8 +1,6 @@
 // use std::io::Write;
 
 // use common_multipart_rfc7578::client::multipart::{Body as MultipartBody, Form as MultipartForm};
-// use tower::ServiceExt;
-
 use textsender_api::db;
 
 mod db_mgr {
@@ -43,6 +41,29 @@ mod db_mgr {
         }
     }
 
+    pub async fn get_database_ready() -> (
+        sqlx::Pool<sqlx::Postgres>,
+        String,
+        sqlx::Pool<sqlx::Postgres>,
+    ) {
+        let tm_pool = get_pool().await.unwrap();
+        let db_name = generate_db_name().await;
+
+        match create_database(&tm_pool, &db_name).await {
+            Ok(_) => {
+                println!("Success");
+            }
+            Err(err) => {
+                assert!(false, "Error: {:?}", err);
+            }
+        }
+
+        let pool = connect_to_db(&db_name).await.unwrap();
+        migrations(&pool).await;
+
+        (tm_pool, db_name, pool)
+    }
+
     // Function to drop a database
     pub async fn drop_database(
         template_pool: &sqlx::PgPool,
@@ -73,16 +94,9 @@ mod db_mgr {
         }
     }
 
-    /*
     pub async fn migrations(pool: &sqlx::PgPool) {
-        // Run migrations using the sqlx::migrate! macro
-        // Assumes your test migrations are in a ./test_migrations folder relative to Cargo.toml
-        sqlx::migrate!("./migrations")
-            .run(pool)
-            .await
-            .expect("Failed to run migrations");
+        super::db::migrations(pool).await;
     }
-    */
 }
 
 mod init {
@@ -301,6 +315,46 @@ mod request {
                 Err(err) => Err(err),
             }
         }
+
+        pub mod scheduling {
+            use time::format_description::well_known::Iso8601;
+            use tower::ServiceExt;
+
+            pub async fn create_scheduled_message(
+                app: &axum::Router,
+            ) -> Result<axum::response::Response, axum::http::Error> {
+                let now = time::OffsetDateTime::now_utc();
+                let scheduled = now + std::time::Duration::from_secs(60 * 60);
+                let scheduled = match scheduled.format(&Iso8601::DEFAULT) {
+                    Ok(t) => t,
+                    Err(err) => {
+                        assert!(false, "Error: {err:?}");
+                        String::new()
+                    }
+                };
+
+                let payload = serde_json::json!({
+                    "scheduled": scheduled,
+                    "status": textsender_models::message::scheduling::PENDING,
+                    "user_id": super::super::super::TEST_USER_ID,
+                });
+
+                match super::super::run_post(
+                    Some(&payload),
+                    textsender_api::caller::endpoints::SCHEDULE_MESSAGE,
+                    axum::http::Method::POST,
+                    true,
+                )
+                .await
+                {
+                    Ok(req) => match app.clone().oneshot(req).await {
+                        Ok(response) => Ok(response),
+                        Err(err) => Err(axum::http::Error::from(err)),
+                    },
+                    Err(err) => Err(err),
+                }
+            }
+        }
     }
 
     pub async fn run_post(
@@ -337,21 +391,7 @@ mod request {
 
 #[tokio::test]
 async fn test_create_contact() {
-    let tm_pool = db_mgr::get_pool().await.unwrap();
-    let db_name = db_mgr::generate_db_name().await;
-
-    match db_mgr::create_database(&tm_pool, &db_name).await {
-        Ok(_) => {
-            println!("Success");
-        }
-        Err(err) => {
-            assert!(false, "Error: {:?}", err);
-        }
-    }
-
-    let pool = db_mgr::connect_to_db(&db_name).await.unwrap();
-    db::migrations(&pool).await;
-
+    let (tm_pool, db_name, pool) = db_mgr::get_database_ready().await;
     let app = init::app(pool).await;
 
     // Send request
@@ -373,21 +413,7 @@ async fn test_create_contact() {
 
 #[tokio::test]
 async fn test_get_contact() {
-    let tm_pool = db_mgr::get_pool().await.unwrap();
-    let db_name = db_mgr::generate_db_name().await;
-
-    match db_mgr::create_database(&tm_pool, &db_name).await {
-        Ok(_) => {
-            println!("Success");
-        }
-        Err(err) => {
-            assert!(false, "Error: {:?}", err);
-        }
-    }
-
-    let pool = db_mgr::connect_to_db(&db_name).await.unwrap();
-    db::migrations(&pool).await;
-
+    let (tm_pool, db_name, pool) = db_mgr::get_database_ready().await;
     let app = init::app(pool).await;
 
     // Send request
@@ -428,21 +454,7 @@ async fn test_get_contact() {
 
 #[tokio::test]
 async fn test_update_contact_names() {
-    let tm_pool = db_mgr::get_pool().await.unwrap();
-    let db_name = db_mgr::generate_db_name().await;
-
-    match db_mgr::create_database(&tm_pool, &db_name).await {
-        Ok(_) => {
-            println!("Success");
-        }
-        Err(err) => {
-            assert!(false, "Error: {:?}", err);
-        }
-    }
-
-    let pool = db_mgr::connect_to_db(&db_name).await.unwrap();
-    db::migrations(&pool).await;
-
+    let (tm_pool, db_name, pool) = db_mgr::get_database_ready().await;
     let app = init::app(pool).await;
 
     let mut opt_contact: Option<textsender_models::contact::Contact> = None;
@@ -519,21 +531,7 @@ async fn test_update_contact_names() {
 
 #[tokio::test]
 async fn test_create_message() {
-    let tm_pool = db_mgr::get_pool().await.unwrap();
-    let db_name = db_mgr::generate_db_name().await;
-
-    match db_mgr::create_database(&tm_pool, &db_name).await {
-        Ok(_) => {
-            println!("Success");
-        }
-        Err(err) => {
-            assert!(false, "Error: {:?}", err);
-        }
-    }
-
-    let pool = db_mgr::connect_to_db(&db_name).await.unwrap();
-    db::migrations(&pool).await;
-
+    let (tm_pool, db_name, pool) = db_mgr::get_database_ready().await;
     let app = init::app(pool).await;
 
     // Send request
@@ -560,21 +558,7 @@ async fn test_create_message() {
 
 #[tokio::test]
 async fn test_get_message() {
-    let tm_pool = db_mgr::get_pool().await.unwrap();
-    let db_name = db_mgr::generate_db_name().await;
-
-    match db_mgr::create_database(&tm_pool, &db_name).await {
-        Ok(_) => {
-            println!("Success");
-        }
-        Err(err) => {
-            assert!(false, "Error: {:?}", err);
-        }
-    }
-
-    let pool = db_mgr::connect_to_db(&db_name).await.unwrap();
-    db::migrations(&pool).await;
-
+    let (tm_pool, db_name, pool) = db_mgr::get_database_ready().await;
     let app = init::app(pool).await;
     let mut message_result: Option<textsender_models::message::Message> = None;
 
@@ -617,3 +601,26 @@ async fn test_get_message() {
 
     let _ = db_mgr::drop_database(&tm_pool, &db_name).await;
 }
+
+#[tokio::test]
+async fn test_schedule_message() {
+    let (tm_pool, db_name, pool) = db_mgr::get_database_ready().await;
+    let app = init::app(pool).await;
+
+    match request::message::scheduling::create_scheduled_message(&app).await {
+        Ok(response) => {
+            eprintln!("Response: {response:?}");
+            println!("Response: {response:?}");
+            let resp = util::get_resp_data::<
+                textsender_api::caller::message::scheduling::response::ScheduleMessageResponse,
+            >(response)
+            .await;
+            assert_eq!(false, resp.data.is_empty(), "Should not be empty");
+        }
+        Err(err) => {
+            assert!(false, "Error: {err:?}");
+        }
+    }
+
+    let _ = db_mgr::drop_database(&tm_pool, &db_name).await;
+}