backend: let get_test_ uuid return a result to prepare for changes needed to test delete_user route.

Author: ffreddow

backend/src/routes/auth/recovery.rs

@@ -369,7 +369,7 @@ mod tests {
             let pool = test_connection_pool();
             let mut conn = pool.get().unwrap();
             let res: Vec<AllowedUser> = allowed_users
-                .filter(user_id.eq(get_test_uuid(&user.mail)))
+                .filter(user_id.eq(get_test_uuid(&user.mail).unwrap()))
                 .filter(valid.eq(true))
                 .select(AllowedUser::as_select())
                 .load(&mut conn)

backend/src/routes/auth/start_recovery.rs

@@ -181,7 +181,7 @@ pub mod tests {
         let resp = test::call_service(&app, req).await;
         assert_eq!(resp.status(), 200);
 
-        let uid = get_test_uuid(&mail);
+        let uid = get_test_uuid(&mail).unwrap();
         let pool = test_connection_pool();
         let mut conn = pool.get().unwrap();
         let token: RecoveryToken = recovery_tokens
@@ -208,7 +208,7 @@ pub mod tests {
         let resp = test::call_service(&app, req).await;
         assert_eq!(resp.status(), 200);
 
-        let uid = get_test_uuid(&mail);
+        let uid = get_test_uuid(&mail).unwrap();
         let pool = test_connection_pool();
         let mut conn = pool.get().unwrap();
         let token: RecoveryToken = recovery_tokens

backend/src/routes/charger/add.rs

@@ -554,7 +554,7 @@ pub(crate) mod tests {
             .to_request();
 
         let resp = test::call_service(&app, req).await;
-        remove_test_keys(&mail);
+        let _ = remove_test_keys(&mail);
         remove_allowed_test_users(cid);
         remove_test_charger(cid);
         println!("{:?}", resp);

backend/src/routes/charger/remove.rs

@@ -34,7 +34,7 @@ pub struct DeleteChargerSchema {
     charger: i32,
 }
 
-async fn delete_all_keys(cid: i32, state: &web::Data<AppState>) -> Result<(), actix_web::Error> {
+pub async fn delete_all_keys(cid: i32, state: &web::Data<AppState>) -> Result<(), actix_web::Error> {
     use db_connector::schema::wg_keys::dsl::*;
 
     let mut conn = get_connection(state)?;
@@ -49,7 +49,7 @@ async fn delete_all_keys(cid: i32, state: &web::Data<AppState>) -> Result<(), ac
     Ok(())
 }
 
-async fn delete_all_allowed_users(
+pub async fn delete_all_allowed_users(
     cid: i32,
     state: &web::Data<AppState>,
 ) -> Result<(), actix_web::Error> {
@@ -67,6 +67,20 @@ async fn delete_all_allowed_users(
     Ok(())
 }
 
+pub async fn delete_charger(charger: i32, state: &web::Data<AppState>) -> actix_web::Result<()> {
+    use db_connector::schema::chargers::dsl::*;
+    let mut conn = get_connection(&state)?;
+    web_block_unpacked(move || {
+        match diesel::delete(chargers.filter(id.eq(charger))).execute(&mut conn) {
+            Ok(_) => Ok(()),
+            Err(_err) => Err(Error::InternalError),
+        }
+    })
+    .await?;
+
+    Ok(())
+}
+
 #[utoipa::path(
     context_path = "/charger",
     request_body = DeleteChargerSchema,
@@ -84,23 +98,14 @@ pub async fn remove(
     uid: crate::models::uuid::Uuid,
     data: web::Json<DeleteChargerSchema>,
 ) -> Result<impl Responder, actix_web::Error> {
-    use db_connector::schema::chargers::dsl::*;
 
     if !charger_belongs_to_user(&state, uid.clone().into(), data.charger.clone()).await? {
         return Err(Error::UserIsNotOwner.into());
     }
 
     delete_all_keys(data.charger.clone(), &state).await?;
     delete_all_allowed_users(data.charger.clone(), &state).await?;
-
-    let mut conn = get_connection(&state)?;
-    web_block_unpacked(move || {
-        match diesel::delete(chargers.filter(id.eq(data.charger.clone()))).execute(&mut conn) {
-            Ok(_) => Ok(()),
-            Err(_err) => Err(Error::InternalError),
-        }
-    })
-    .await?;
+    delete_charger(data.charger, &state).await?;
 
     Ok(HttpResponse::Ok())
 }
@@ -124,16 +129,17 @@ pub(crate) mod tests {
         tests::configure,
     };
 
-    pub fn remove_test_keys(mail: &str) {
+    pub fn remove_test_keys(mail: &str) -> anyhow::Result<()> {
         use db_connector::schema::wg_keys::dsl::*;
 
-        let uid = get_test_uuid(mail);
+        let uid = get_test_uuid(mail)?;
 
         let pool = test_connection_pool();
         let mut conn = pool.get().unwrap();
         diesel::delete(wg_keys.filter(user_id.eq(uid)))
-            .execute(&mut conn)
-            .unwrap();
+            .execute(&mut conn)?;
+
+        Ok(())
     }
 
     pub fn remove_allowed_test_users(cid: i32) {

backend/src/routes/management.rs

@@ -378,6 +378,6 @@ mod tests {
                 .unwrap();
             user.user_id
         };
-        assert_eq!(get_test_uuid(&user.mail), user_id);
+        assert_eq!(get_test_uuid(&user.mail).unwrap(), user_id);
     }
 }

backend/src/routes/user/logout.rs

@@ -86,7 +86,7 @@ pub async fn logout(
         .body(""))
 }
 
-async fn delete_all_refresh_tokens(
+pub async fn delete_all_refresh_tokens(
     uid: uuid::Uuid,
     state: &web::Data<AppState>,
 ) -> actix_web::Result<()> {

backend/src/routes/user/mod.rs

@@ -22,6 +22,7 @@ pub mod logout;
 pub mod me;
 pub mod update_password;
 pub mod update_user;
+pub mod delete;
 
 use crate::{
     error::Error,
@@ -42,6 +43,7 @@ pub fn configure(cfg: &mut ServiceConfig) {
         .service(update_password::update_password)
         .service(get_secret::get_secret)
         .service(logout::logout)
+        .service(delete::delete_user)
         .service(me::me);
     cfg.service(scope);
 }
@@ -155,18 +157,17 @@ pub mod tests {
     };
 
     // Get the uuid for an test user.
-    pub fn get_test_uuid(mail: &str) -> uuid::Uuid {
+    pub fn get_test_uuid(mail: &str) -> Result<uuid::Uuid, anyhow::Error> {
         use db_connector::schema::users::dsl::*;
 
         let pool = test_connection_pool();
         let mut conn = pool.get().unwrap();
         let user: User = users
             .filter(email.eq(mail))
             .select(User::as_select())
-            .get_result(&mut conn)
-            .unwrap();
+            .get_result(&mut conn)?;
 
-        user.id
+        Ok(user.id)
     }
 
     /**
@@ -333,7 +334,7 @@ pub mod tests {
     impl Drop for TestUser {
         fn drop(&mut self) {
             while let Some(charger) = self.charger.pop() {
-                remove_test_keys(&self.mail);
+                let _ = remove_test_keys(&self.mail);
                 remove_allowed_test_users(charger);
                 remove_test_charger(charger);
             }

db_connector/src/models/allowed_users.rs

@@ -1,7 +1,7 @@
 use diesel::prelude::*;
 use super::{users::User, chargers::Charger};
 
-#[derive(Debug, Clone, Queryable, Selectable, Insertable, Identifiable, Associations)]
+#[derive(Debug, Clone, Queryable, Selectable, Insertable, Identifiable, Associations, PartialEq)]
 #[diesel(belongs_to(User))]
 #[diesel(belongs_to(Charger))]
 #[diesel(table_name = crate::schema::allowed_users)]

db_connector/src/models/chargers.rs

@@ -1,7 +1,7 @@
 use diesel::{associations::Identifiable, deserialize::Queryable, prelude::Insertable, query_builder::AsChangeset, Selectable};
 use ipnetwork::IpNetwork;
 
-#[derive(Debug, Clone, Queryable, Selectable, Insertable, Identifiable, AsChangeset)]
+#[derive(Debug, Clone, Queryable, Selectable, Insertable, Identifiable, AsChangeset, PartialEq)]
 #[diesel(table_name = crate::schema::chargers)]
 #[diesel(check_for_backend(diesel::pg::Pg))]
 pub struct Charger {

db_connector/src/models/users.rs

@@ -1,6 +1,6 @@
 use diesel::{associations::Identifiable, deserialize::Queryable, prelude::Insertable, Selectable};
 
-#[derive(Debug, Clone, Queryable, Selectable, Insertable, Identifiable)]
+#[derive(Debug, Clone, Queryable, Selectable, Insertable, Identifiable, PartialEq)]
 #[diesel(table_name = crate::schema::users)]
 #[diesel(check_for_backend(diesel::pg::Pg))]
 pub struct User {