create tests for model/rower.rs, Closes #32

src/model/logbook.rs

@@ -57,6 +57,7 @@ pub struct LogbookWithBoatAndRowers {
 pub enum LogbookUpdateError {
     NotYourEntry,
     TooManyRowers(usize, usize),
+    RowerCreateError(i64, String),
 }
 
 pub enum LogbookCreateError {
@@ -66,6 +67,7 @@ pub enum LogbookCreateError {
     TooManyRowers(usize, usize),
     ShipmasterAlreadyOnWater,
     RowerAlreadyOnWater(User),
+    RowerCreateError(i64, String),
 }
 
 impl Logbook {
@@ -164,8 +166,8 @@ ORDER BY departure DESC
 
     pub async fn create(db: &SqlitePool, log: LogToAdd) -> Result<(), LogbookCreateError> {
         let Some(boat) = Boat::find_by_id(db, log.boat_id).await else {
-                 return Err(LogbookCreateError::BoatNotFound);
-             };
+            return Err(LogbookCreateError::BoatNotFound);
+        };
 
         if boat.is_locked(db).await {
             return Err(LogbookCreateError::BoatLocked);
@@ -217,7 +219,11 @@ ORDER BY departure DESC
             .await.unwrap();
 
         for rower in &log.rower {
-            Rower::create(&mut tx, inserted_row.id, *rower).await;
+            Rower::create(&mut tx, inserted_row.id, *rower)
+                .await
+                .map_err(|e| {
+                    return LogbookCreateError::RowerCreateError(*rower, e.to_string());
+                })?;
         }
 
         tx.commit().await.unwrap();
@@ -289,7 +295,9 @@ ORDER BY departure DESC
         self.remove_rowers(&mut tx).await;
 
         for rower in &log.rower {
-            Rower::create(&mut tx, self.id, *rower).await;
+            Rower::create(&mut tx, self.id, *rower).await.map_err(|e| {
+                return LogbookUpdateError::RowerCreateError(*rower, e.to_string());
+            })?;
         }
 
         tx.commit().await.unwrap();

src/model/rower.rs

@@ -25,14 +25,69 @@ WHERE id in (SELECT rower_id FROM rower WHERE logbook_id=?)
         .unwrap()
     }
 
-    pub async fn create(db: &mut Transaction<'_, Sqlite>, logbook_id: i64, rower_id: i64) {
-        let _ = sqlx::query!(
+    pub async fn create(
+        db: &mut Transaction<'_, Sqlite>,
+        logbook_id: i64,
+        rower_id: i64,
+    ) -> Result<(), String> {
+        //TODO: Check if rower is allowed to row
+
+        sqlx::query!(
             "INSERT INTO rower(logbook_id, rower_id) VALUES (?,?)",
             logbook_id,
             rower_id
         )
         .execute(db)
         .await
-        .unwrap();
+        .map_err(|e| return e.to_string())?;
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use sqlx::SqlitePool;
+
+    use super::Logbook;
+    use crate::model::{rower::Rower, user::User};
+    use crate::testdb;
+
+    #[sqlx::test]
+    fn test_for_log() {
+        let pool = testdb!();
+
+        let logbook = Logbook::find_by_id(&pool, 3).await.unwrap();
+        let rowers = Rower::for_log(&pool, &logbook).await;
+        let expected = User::find_by_id(&pool, 3).await.unwrap();
+        assert_eq!(rowers, vec![expected]);
+    }
+
+    #[sqlx::test]
+    fn test_for_log_none() {
+        let pool = testdb!();
+
+        let logbook = Logbook::find_by_id(&pool, 2).await.unwrap();
+        let rowers = Rower::for_log(&pool, &logbook).await;
+        assert_eq!(rowers, vec![]);
+    }
+
+    #[sqlx::test]
+    fn test_create() {
+        let pool = testdb!();
+
+        let logbook = Logbook::find_by_id(&pool, 3).await.unwrap();
+
+        let mut tx = pool.begin().await.unwrap();
+        Rower::create(&mut tx, logbook.id, 2).await.unwrap();
+        tx.commit().await.unwrap();
+        let rowers = Rower::for_log(&pool, &logbook).await;
+        assert_eq!(
+            rowers,
+            vec![
+                User::find_by_id(&pool, 2).await.unwrap(),
+                User::find_by_id(&pool, 3).await.unwrap()
+            ]
+        );
     }
 }

src/model/user.rs

@@ -27,6 +27,12 @@ pub struct User {
     pub last_access: Option<chrono::NaiveDateTime>,
 }
 
+impl PartialEq for User {
+    fn eq(&self, other: &Self) -> bool {
+        self.id == other.id
+    }
+}
+
 #[derive(Debug)]
 pub enum LoginError {
     InvalidAuthenticationCombo,