diff --git a/tests/test.rs b/tests/test.rs
index 1011a45..df7c426 100644
--- a/tests/test.rs
+++ b/tests/test.rs
@@ -391,6 +391,25 @@ mod request {
                     Err(err) => Err(err),
                 }
             }
+
+            pub async fn get_message_event_response(
+                app: &axum::Router,
+                id: &uuid::Uuid,
+            ) -> Result<axum::response::Response, axum::http::Error> {
+                let uri = format!(
+                    "{}?id={}",
+                    textsender_api::caller::endpoints::GET_MESSAGE_EVENT_RESPONSE,
+                    id
+                );
+
+                match super::super::run_post(None, &uri, axum::http::Method::GET, false).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 mod scheduling {
@@ -1481,3 +1500,153 @@ async fn test_record_message_event_response() {
 
     let _ = db_mgr::drop_database(&tm_pool, &db_name).await;
 }
+
+#[tokio::test]
+async fn test_get_message_event_response() {
+    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();
+    let mut scheduled_message_event_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");
+            let scheduled_message_event = &resp.data[0];
+            scheduled_message_event_id = scheduled_message_event.id;
+        }
+        Err(err) => {
+            assert!(false, "Error: {err:?}");
+        }
+    }
+
+    match request::message::scheduling::update_scheduled_message_status(
+        &app,
+        &scheduled_message_id,
+        textsender_models::message::scheduling::READY,
+    )
+    .await
+    {
+        Ok(response) => {
+            let resp = util::get_resp_data::<
+                textsender_api::caller::message::scheduling::response::UpdateScheduledMessageStatusResponse,
+            >(response)
+            .await;
+            assert_eq!(false, resp.data.is_empty(), "Should not be empty");
+        }
+        Err(err) => {
+            assert!(false, "Error: {err:?}");
+        }
+    }
+
+    match request::message::scheduling::fetch_scheduled_message(&app).await {
+        Ok(response) => {
+            let resp = util::get_resp_data::<
+                textsender_api::caller::message::scheduling::response::FetchScheduledMessageResponse,
+            >(response)
+            .await;
+            assert_eq!(false, resp.data.is_empty(), "Should not be empty");
+        }
+        Err(err) => {
+            assert!(false, "Error: {err:?}");
+        }
+    }
+
+    assert_eq!(
+        false,
+        scheduled_message_event_id.is_nil(),
+        "Scheduled Message Event Id should not be empty"
+    );
+
+    match request::message::event::record_message_event_response(
+        &app,
+        &scheduled_message_event_id,
+        &TEST_USER_ID,
+        &contact_id,
+        &message_id,
+    )
+    .await
+    {
+        Ok(response) => {
+            let resp = util::get_resp_data::<
+                textsender_api::caller::message::event::response::RecordMessageEventResponse,
+            >(response)
+            .await;
+            assert_eq!(false, resp.data.is_empty(), "Should not be empty");
+            let mer = &resp.data[0];
+            match request::message::event::get_message_event_response(&app, &mer.id).await {
+                Ok(response) => {
+                    let resp = util::get_resp_data::<
+                        textsender_api::caller::message::event::response::GetMERResponse,
+                    >(response)
+                    .await;
+                    assert_eq!(false, resp.data.is_empty(), "Should not be empty");
+                }
+                Err(err) => {
+                    assert!(false, "Error: {err:?}");
+                }
+            }
+        }
+        Err(err) => {
+            assert!(false, "Error: {err:?}");
+        }
+    }
+
+    let _ = db_mgr::drop_database(&tm_pool, &db_name).await;
+}