category tests and other minor testing changes

Author: SpawnCycle

Cargo.lock

@@ -9,6 +9,7 @@ services = { path = "../services" }
 serde = { workspace = true }
 sea-orm = { workspace = true }
 argon2 = { workspace = true }
+anyhow = { workspace = true }
 regex = "1.12.3"
 
 [lints]

dtos/Cargo.toml

@@ -1,7 +1,7 @@
 use entity::category;
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Clone, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct CategoryPostDto {
     pub name: String,
 }

dtos/src/category/post.rs

@@ -1,5 +1,6 @@
 //! variant of <https://stackoverflow.com/questions/74482350/adding-length-limit-when-deserializing-a-string-a-vec-or-an-array>
 
+use anyhow::anyhow;
 use regex::Regex;
 use serde::{de, ser};
 use std::{ops::Deref, sync::LazyLock};
@@ -15,6 +16,18 @@ impl Deref for EmailString {
     }
 }
 
+impl TryFrom<String> for EmailString {
+    type Error = anyhow::Error;
+
+    fn try_from(value: String) -> Result<Self, Self::Error> {
+        if EMAIL_RX.is_match(&value) {
+            Ok(EmailString(value))
+        } else {
+            Err(anyhow!("The string is not an email string"))
+        }
+    }
+}
+
 impl From<EmailString> for String {
     fn from(v: EmailString) -> Self {
         v.0
@@ -30,13 +43,8 @@ impl<'de> de::Deserialize<'de> for EmailString {
     where
         D: de::Deserializer<'de>,
     {
-        <String as de::Deserialize>::deserialize(deserializer).and_then(|inner| {
-            if EMAIL_RX.is_match(&inner) {
-                Ok(EmailString(inner))
-            } else {
-                Err(de::Error::custom("The string is not an email string"))
-            }
-        })
+        <String as de::Deserialize>::deserialize(deserializer)
+            .and_then(|inner| Self::try_from(inner).map_err(de::Error::custom))
     }
 }
 

dtos/src/email_string.rs

@@ -5,6 +5,8 @@ use rocket::{
     fairing::{self, Fairing, Info, Kind},
 };
 
+use crate::constants::AdminEmail;
+
 use super::{ADMIN_EMAIL, JWT_SECRET};
 
 pub struct LazyProcFairing;
@@ -25,6 +27,8 @@ impl Fairing for LazyProcFairing {
         };
         let _ = LazyLock::<_>::force(&ADMIN_EMAIL);
 
+        let r = r.manage(AdminEmail(ADMIN_EMAIL.clone()));
+
         Ok(r)
     }
 }

src/constants/fairing.rs

@@ -27,11 +27,11 @@ pub static JWT_SECRET: LazyLock<Option<&str>> =
         }
     });
 
-pub static ADMIN_EMAIL: LazyLock<Option<&str>> =
+pub static ADMIN_EMAIL: LazyLock<Option<String>> =
     LazyLock::new(|| match dotenvy::var("ADMIN_EMAIL") {
         Ok(var) => {
             if dtos::email_string::EMAIL_RX.is_match(&var) {
-                Some(var.leak())
+                Some(var)
             } else {
                 log::warn!("ADMIN_EMAIL doesn't match the email regex");
                 None
@@ -42,3 +42,7 @@ pub static ADMIN_EMAIL: LazyLock<Option<&str>> =
             None
         }
     });
+
+/// The type in which rocket manages the admin email
+#[allow(dead_code)]
+pub struct AdminEmail(pub Option<String>);

src/constants/mod.rs

@@ -59,7 +59,7 @@ impl Fairing for DatabaseFairing {
 }
 
 async fn register_admin(db: &DbConn) -> Result<(), DbErr> {
-    let Some(email) = *ADMIN_EMAIL else {
+    let Some(email) = &*ADMIN_EMAIL else {
         return Ok(());
     };
     let Some(user) = User::find_by_email(email).one(db).await? else {

src/database.rs

@@ -178,6 +178,8 @@ impl<'a> FromRequest<'a> for JwtClaims {
         };
         let jwt = jwt.to_string();
 
+        let jwt = jwt.clone().split_once(";").map_or(jwt, |s| s.0.to_string());
+
         let Some((_key, jwt)) = jwt.split_once("=") else {
             jar.remove(JWT_KEY);
             return Outcome::Error((

src/jwt.rs

@@ -40,10 +40,10 @@ pub enum Responder {
     Conflict(String),
     #[response(status = 404)]
     NotFound(String),
-    #[response(status = 403)]
-    BadRequest(String),
     #[response(status = 401)]
     Unauhorized(String),
+    #[response(status = 400)]
+    BadRequest(String),
 }
 
 impl Display for Responder {

src/responder/mod.rs

@@ -26,3 +26,126 @@ pub async fn all(db: &State<DbConn>) -> Result<Json<Vec<CategoryGetDto>>, Respon
 
     Ok(Json(categories))
 }
+
+#[cfg(test)]
+mod tests {
+    use anyhow::anyhow;
+    use dtos::CategoryGetDto;
+    use rocket::local::asynchronous::Client;
+
+    use super::*;
+    use crate::testing::{self, category};
+
+    #[tokio::test]
+    async fn categories_get_all_tracked() -> anyhow::Result<()> {
+        let db = category::db().await?;
+        let r = category::rocket(db).await?;
+
+        let client = Client::tracked(r).await?;
+
+        let req = client.get("/api/categories/");
+        let res = req.dispatch().await;
+        let categories = res
+            .into_json::<Vec<CategoryGetDto>>()
+            .await
+            .ok_or(anyhow!("Couldn't parse into json"))?;
+
+        // testing::category::seed_db has 3 non-deleted rows
+        assert_eq!(categories.len(), 3);
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn categories_get_all_func() -> anyhow::Result<()> {
+        let db = category::db().await?;
+        let db = State::from(&db);
+
+        let categories = all(db).await?;
+
+        // testing::category::seed_db has 3 non-deleted rows
+        assert_eq!(categories.len(), 3);
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn categories_get_by_id_exists_tracked() -> anyhow::Result<()> {
+        let db = category::db().await?;
+        let r = category::rocket(db).await?;
+
+        let client = Client::tracked(r).await?;
+
+        let req = client.get("/api/categories/1");
+        let res = req.dispatch().await;
+        let category = res.into_json::<CategoryGetDto>().await;
+
+        assert!(category.is_some(), "The first category is not deleted");
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn categories_get_by_id_deleted_tracked() -> anyhow::Result<()> {
+        let db = category::db().await?;
+        let r = category::rocket(db).await?;
+
+        let client = Client::tracked(r).await?;
+
+        let req = client.get("/api/categories/5");
+        let res = req.dispatch().await;
+
+        assert_eq!(res.status().code, 404, "The fifth category is deleted");
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn categories_get_by_id_not_existant_tracked() -> anyhow::Result<()> {
+        let db = category::db().await?;
+        let r = category::rocket(db).await?;
+
+        let client = Client::tracked(r).await?;
+
+        let req = client.get("/api/categories/1000");
+        let res = req.dispatch().await;
+
+        assert_eq!(res.status().code, 404, "The 1000th category does not exist");
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn categories_get_by_id_exists_func() -> anyhow::Result<()> {
+        let db = category::db().await?;
+        let db = State::from(&db);
+
+        let res = one(1, db).await;
+        assert!(res.is_ok(), "The first category is not deleted");
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn categories_get_by_id_deleted_func() -> anyhow::Result<()> {
+        let db = testing::db().await?;
+        let db = State::from(&db);
+        testing::category::seed_db(db).await?;
+
+        let res = one(5, db).await;
+        assert!(res.is_err(), "The fifth category is deleted");
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn categories_get_by_id_not_existant_tracked_func() -> anyhow::Result<()> {
+        let db = category::db().await?;
+        let db = State::from(&db);
+
+        let res = one(1000, db).await;
+        assert!(res.is_err(), "The 1000th category does not exist");
+
+        Ok(())
+    }
+}