Add test for add/read/delete start_list_change_request

Author: fvacek

src/auth.rs

@@ -15,6 +15,17 @@ pub struct UserInfo {
     pub(crate) email: String,
     picture: String,
 }
+
+impl UserInfo {
+    #[cfg(test)]
+    pub fn create_test_user_info() -> UserInfo {
+        UserInfo{
+            name: "John Doe".to_string(),
+            email: "john@doe".to_string(),
+            picture: "".to_string(),
+        }
+    }
+}
 impl TryFrom<&GoogleUserInfo> for UserInfo {
     type Error = anyhow::Error;
 
@@ -46,12 +57,7 @@ pub fn generate_random_string(len: usize) -> String {
         })
         .collect()
 }
-// #[test]
-// fn test_generate_random_string() {
-//     for _i in 0 .. 50 {
-//         println!("{}", generate_random_string(10));
-//     }
-// }
+
 pub const QX_SESSION_ID: &str = "qx_session_id";
 
 /// User information to be retrieved from the Google People API.

src/changes.rs

@@ -135,7 +135,7 @@ pub async fn add_change(
                 VALUES (?, ?, ?, ?, ?, ?, ?, ?)  RETURNING id")
         .bind(&change.source)
         .bind(&change.data_type)
-        .bind(&change.data_id)
+        .bind(change.data_id)
         .bind(&change.data)
         .bind(&change.note)
         .bind(&change.user_id)
@@ -147,14 +147,21 @@ pub async fn add_change(
     Ok(id.0)
 }
 
-#[get("/event/<event_id>/changes?<from_id>")]
-async fn get_changes(event_id: EventId, from_id: Option<i64>, session_id: MaybeSessionId, state: &State<SharedQxState>, gdb: &State<DbPool>) -> Result<Template, Custom<String>> {
+#[get("/event/<event_id>/changes?<from_id>&<limit>")]
+async fn get_changes(
+    event_id: EventId,
+    from_id: Option<i64>,
+    limit: Option<i64>,
+    session_id: MaybeSessionId,
+    state: &State<SharedQxState>,
+    gdb: &State<DbPool>
+) -> Result<Template, Custom<String>> {
     let event = load_event_info(event_id, gdb).await?;
     let user = user_info_opt(session_id.0.as_ref(), state).await.map_err(anyhow_to_custom_error)?;
-    let from_id = from_id.unwrap_or(0);
     let edb = get_event_db(event_id, state).await.map_err(anyhow_to_custom_error)?;
-    let records: Vec<ChangesRecord> = sqlx::query_as("SELECT * FROM changes WHERE id>=? ORDER BY created DESC LIMIT 1000")
-        .bind(from_id)
+    let records: Vec<ChangesRecord> = sqlx::query_as("SELECT * FROM changes WHERE id>=? ORDER BY created DESC LIMIT ?")
+        .bind(from_id.unwrap_or(0))
+        .bind(limit.unwrap_or(100))
         .fetch_all(&edb)
         .await
         .map_err(sqlx_to_custom_error)?;
@@ -192,10 +199,10 @@ pub async fn add_run_update_request_change(
     note: Option<&str>,
     data: Json<RunsRecord>,
     state: &State<SharedQxState>
-) -> Result<(), Custom<String>> {
+) -> Result<Json<i64>, Custom<String>> {
     let user = user_info(&session_id, state).await?;
     let data = ChangeData::RunUpdateRequest(data.into_inner());
-    add_change(event_id, ChangesRecord{
+    let change_id = add_change(event_id, ChangesRecord{
         id: 0,
         source: "www".to_string(),
         data_type: DataType::RunUpdateRequest,
@@ -207,7 +214,7 @@ pub async fn add_run_update_request_change(
         note: note.map(|s| s.to_string()),
     }, state).await.map_err(anyhow_to_custom_error)?;
     //state.read().await.broadcast_runs_change((event_id, data_id, data)).await.map_err(anyhow_to_custom_error)?;
-    Ok(())
+    Ok(Json(change_id))
 }
 
 #[post("/api/event/current/changes/run-updated?<run_id>", data = "<change>")]
@@ -326,8 +333,15 @@ async fn changes_sse(event_id: EventId, state: &State<SharedQxState>) -> EventSt
     }
 }
 
-#[get("/api/event/<event_id>/changes?<from_id>&<data_type>&<status>")]
-async fn api_changes_get(event_id: EventId, from_id: Option<i64>, data_type: Option<&str>, status: Option<&str>, state: &State<SharedQxState>) -> Result<Json<Vec<ChangesRecord>>, Custom<String>> {
+#[get("/api/event/<event_id>/changes?<from_id>&<limit>&<data_type>&<status>")]
+async fn api_changes_get(
+    event_id: EventId,
+    from_id: Option<i64>,
+    limit: Option<i64>,
+    data_type: Option<&str>,
+    status: Option<&str>,
+    state: &State<SharedQxState>
+) -> Result<Json<Vec<ChangesRecord>>, Custom<String>> {
     let edb = get_event_db(event_id, state).await.map_err(anyhow_to_custom_error)?;
 
     let mut query_builder = QueryBuilder::new("SELECT * FROM changes WHERE id>=");
@@ -341,7 +355,11 @@ async fn api_changes_get(event_id: EventId, from_id: Option<i64>, data_type: Opt
         query_builder.push_bind(status);
     }
     query_builder.push(" ORDER BY created");
-    
+    if let Some(limit) = limit {
+        query_builder.push(" LIMIT ");
+        query_builder.push_bind(limit);
+    }
+
     let query = query_builder.build_query_as::<ChangesRecord>();
     let records: Vec<_> = query.fetch_all(&edb).await.map_err(sqlx_to_custom_error)?;
     // info!("records: {:?}", records);

src/event.rs

@@ -88,8 +88,8 @@ pub(crate) async fn save_event(event: &EventRecord, db: &State<DbPool>) -> anyho
         query("UPDATE events SET name=?, place=?, stage=?, stage_count=?, start_time=? WHERE id=?")
             .bind(&event.name)
             .bind(&event.place)
-            .bind(&event.stage)
-            .bind(&event.stage_count)
+            .bind(event.stage)
+            .bind(event.stage_count)
             .bind(event.start_time.0)
             // .bind(&event.time_zone)
             .bind(event.id)
@@ -103,8 +103,8 @@ pub(crate) async fn save_event(event: &EventRecord, db: &State<DbPool>) -> anyho
         )
             .bind(&event.name)
             .bind(&event.place)
-            .bind(&event.stage)
-            .bind(&event.stage_count)
+            .bind(event.stage)
+            .bind(event.stage_count)
             .bind(event.start_time.0)
             .bind(&event.api_token.0)
             .bind(&event.owner)
@@ -479,14 +479,16 @@ pub async fn import_runs(edb: &SqlitePool) -> anyhow::Result<()> {
     Ok(())
 }
 
-pub(crate) const TEST_API_TOKEN: &str = "plelababamak";
+pub(crate) const DEMO_API_TOKEN: &str = "plelababamak";
+#[cfg(test)]
+pub(crate) const TEST_SESSION_ID: &str = "123abc";
 
 #[get("/event/create-demo")]
 async fn create_demo_event(state: &State<SharedQxState>, gdb: &State<DbPool>) -> Result<Redirect, Custom<String>> {
     let mut event_info = EventRecord::new("fanda.vacek@gmail.com");
     event_info.name = String::from("Demo event");
     event_info.place = String::from("Deep forest 42");
-    event_info.api_token = QxApiToken(String::from(TEST_API_TOKEN));
+    event_info.api_token = QxApiToken(String::from(DEMO_API_TOKEN));
     let event_id = save_event(&event_info, gdb).await.map_err(|e| Custom(Status::BadRequest, e.to_string()))?;
     {
         // upload demo start list

src/main.rs

@@ -25,6 +25,8 @@ use async_broadcast::{broadcast};
 use rocket_dyn_templates::handlebars::{Handlebars, Helper};
 use sqlx::sqlite::{SqliteArgumentValue};
 
+#[cfg(test)]
+use crate::event::TEST_SESSION_ID;
 #[cfg(test)]
 mod tests;
 mod db;
@@ -62,7 +64,12 @@ impl<'r> request::FromRequest<'r> for QxSessionId {
             .guard::<&CookieJar<'_>>()
             .await
             .expect("request cookies");
-        if let Some(cookie) = cookies.get_private(QX_SESSION_ID) {
+        if cfg!(test) {
+            // didn't find a way, how to use private cookies with tests
+            if let Some(cookie) = cookies.get(QX_SESSION_ID) {
+                return request::Outcome::Success(Self(cookie.value().to_string()));
+            }
+        } else if let Some(cookie) = cookies.get_private(QX_SESSION_ID) {
             return request::Outcome::Success(Self(cookie.value().to_string()));
         }
         request::Outcome::Forward(Status::Unauthorized)
@@ -224,10 +231,8 @@ fn rocket() -> _ {
                                                if left <= right {
                                                    out.write("1")?;
                                                }
-                                           } else {
-                                               if left > right {
-                                                   out.write("1")?;
-                                               }
+                                           } else if left > right {
+                                               out.write("1")?;
                                            }
                                            Ok(())
                                        }));
@@ -255,7 +260,16 @@ fn rocket() -> _ {
     let db_path = figment.extract_inner::<String>("db_path").expect("db_path");
 
     let cfg = AppConfig{ server_address, server_port, db_path };
-    let state = QxState::new(cfg);
-    rocket.manage(SharedQxState::new(state))
+    #[cfg(test)]
+    {
+        let mut state = QxState::new(cfg);
+        state.sessions.insert(QxSessionId(TEST_SESSION_ID.into()), QxSession { user_info: UserInfo::create_test_user_info() });
+        rocket.manage(SharedQxState::new(state))
+    }
+    #[cfg(not(test))]
+    {
+        let state = QxState::new(cfg);
+        rocket.manage(SharedQxState::new(state))
+    }
 }