Create scheduled message event (#17)

Reviewed-on: phoenix/textsender_api#17

tests/test.rs

@@ -1,6 +1,3 @@
-// use std::io::Write;
-
-// use common_multipart_rfc7578::client::multipart::{Body as MultipartBody, Form as MultipartForm};
 use textsender_api::db;
 
 mod db_mgr {
@@ -178,6 +175,19 @@ pub async fn test_token() -> Result<String, josekit::JoseError> {
     }
 }
 
+pub fn test_valid_schedulable_time() -> time::OffsetDateTime {
+    let now = time::OffsetDateTime::now_utc();
+    now + std::time::Duration::from_secs(60 * 60)
+}
+
+pub fn convert_time_to_iso(time: time::OffsetDateTime) -> Result<String, time::error::Format> {
+    use time::format_description::well_known::Iso8601;
+    match time.format(&Iso8601::DEFAULT) {
+        Ok(converted) => Ok(converted),
+        Err(err) => Err(err),
+    }
+}
+
 pub async fn bearer_auth() -> String {
     let token = match test_token().await {
         Ok(access_token) => access_token,
@@ -191,9 +201,6 @@ pub async fn bearer_auth() -> String {
 }
 
 mod request {
-    // use common_multipart_rfc7578::client::multipart::{
-    //     Body as MultipartBody, Form as MultipartForm,
-    // };
     use tower::ServiceExt;
 
     pub async fn create_contact(
@@ -317,15 +324,13 @@ mod request {
         }
 
         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) {
+                let scheduled = super::super::super::test_valid_schedulable_time();
+                let scheduled = match super::super::super::convert_time_to_iso(scheduled) {
                     Ok(t) => t,
                     Err(err) => {
                         assert!(false, "Error: {err:?}");
@@ -373,6 +378,36 @@ mod request {
                     Err(err) => Err(err),
                 }
             }
+
+            pub async fn create_scheduled_message_event(
+                app: &axum::Router,
+                contact_id: &uuid::Uuid,
+                message_id: &uuid::Uuid,
+                scheduled_message_id: &uuid::Uuid,
+            ) -> Result<axum::response::Response, axum::http::Error> {
+                let payload = serde_json::json!({
+                    "contact_id": contact_id,
+                    "message_id": message_id,
+                    "scheduled_message_id": scheduled_message_id
+                });
+
+                println!("Payload: {payload:?}");
+
+                match super::super::run_post(
+                    Some(&payload),
+                    textsender_api::caller::endpoints::CREATE_SCHEDULED_MESSAGE_EVENT,
+                    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),
+                }
+            }
         }
     }
 
@@ -628,8 +663,6 @@ async fn test_schedule_message() {
 
     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)
@@ -653,8 +686,6 @@ async fn test_get_scheduled_message() {
 
     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)
@@ -687,3 +718,78 @@ async fn test_get_scheduled_message() {
 
     let _ = db_mgr::drop_database(&tm_pool, &db_name).await;
 }
+
+#[tokio::test]
+async fn test_create_scheduled_message_event() {
+    let (tm_pool, db_name, pool) = db_mgr::get_database_ready().await;
+    let app = init::app(pool).await;
+
+    let mut contact_id: uuid::Uuid = uuid::Uuid::nil();
+    let mut message_id: uuid::Uuid = uuid::Uuid::nil();
+    let mut scheduled_message_id: uuid::Uuid = uuid::Uuid::nil();
+
+    match request::create_contact(&app).await {
+        Ok(response) => {
+            let resp = util::get_resp_data::<
+                textsender_api::caller::contact::response::AddContactResponse,
+            >(response)
+            .await;
+            assert_eq!(false, resp.data.is_empty(), "Should not be empty");
+            contact_id = resp.data[0].id.unwrap();
+        }
+        Err(err) => {
+            assert!(false, "Error: {:?}", err);
+        }
+    };
+
+    match request::message::create_message(&app).await {
+        Ok(response) => {
+            let resp = util::get_resp_data::<
+                textsender_api::caller::message::response::AddMessageResponse,
+            >(response)
+            .await;
+            assert_eq!(false, resp.data.is_empty(), "Should not be empty");
+            let message = &resp.data[0];
+            message_id = message.id.unwrap();
+        }
+        Err(err) => {
+            assert!(false, "Error: {:?}", err);
+        }
+    };
+
+    match request::message::scheduling::create_scheduled_message(&app).await {
+        Ok(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");
+            scheduled_message_id = resp.data[0].id;
+        }
+        Err(err) => {
+            assert!(false, "Error: {err:?}");
+        }
+    }
+
+    match request::message::scheduling::create_scheduled_message_event(
+        &app,
+        &contact_id,
+        &message_id,
+        &scheduled_message_id,
+    )
+    .await
+    {
+        Ok(response) => {
+            let resp = util::get_resp_data::<
+                textsender_api::caller::message::scheduling::response::CreateScheduleMessageEventResponse,
+            >(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;
+}