test: begin writing test for role editing

crates/delta/src/routes/servers/roles_edit_positions.rs

@@ -72,3 +72,54 @@ pub async fn edit_role_ranks(
 
     Ok(Json(server.into()))
 }
+
+#[cfg(test)]
+mod test {
+    use revolt_database::fixture;
+    use revolt_models::v0;
+    use rocket::http::{ContentType, Header, Status};
+
+    use crate::util::test::TestHarness;
+
+    #[rocket::async_test]
+    async fn edit_role_rankings() {
+        let harness = TestHarness::new().await;
+
+        fixture!(harness.db, "server_with_roles",
+            owner user 0
+            moderator user 1
+            user user 2
+            server server 4);
+
+        // Moderator can re-order the roles below them
+        let (_, moderator_session) = harness.account_from_user(moderator.id).await;
+        let mut target_order: Vec<String> = server
+            .ordered_roles()
+            .into_iter()
+            .map(|(id, _)| id)
+            .collect();
+
+        // Swap the two lower ranked roles
+        target_order.swap(2, 3);
+
+        let response = harness
+            .client
+            .post(format!("/servers/{}/roles/ranks", server.id))
+            .header(ContentType::JSON)
+            .body(
+                json!(v0::DataEditRoleRanks {
+                    ranks: target_order.clone()
+                })
+                .to_string(),
+            )
+            .header(Header::new(
+                "x-session-token",
+                moderator_session.token.to_string(),
+            ))
+            .dispatch()
+            .await;
+
+        assert_eq!(response.status(), Status::Ok);
+        drop(response);
+    }
+}

crates/delta/src/util/test.rs

@@ -1,5 +1,5 @@
 use authifier::{
-    models::{Account, Session},
+    models::{Account, EmailVerification, Session},
     Authifier,
 };
 use futures::StreamExt;
@@ -83,30 +83,41 @@ impl TestHarness {
     }
 
     pub async fn new_user(&self) -> (Account, Session, User) {
-        let account = Account::new(
-            &self.authifier,
-            format!("{}@revolt.chat", TestHarness::rand_string()),
-            "password".to_string(),
-            false,
-        )
-        .await
-        .expect("`Account`");
+        let user = User::create(&self.db, TestHarness::rand_string(), None, None)
+            .await
+            .expect("`User`");
+
+        let (account, session) = self.account_from_user(user.id.clone()).await;
+
+        (account, session, user)
+    }
+
+    pub async fn account_from_user(&self, id: String) -> (Account, Session) {
+        let account = Account {
+            id,
+            email: format!("{}@revolt.chat", TestHarness::rand_string()),
+            password: Default::default(),
+            email_normalised: Default::default(),
+            deletion: None,
+            disabled: false,
+            lockout: None,
+            mfa: Default::default(),
+            password_reset: None,
+            verification: EmailVerification::Verified,
+        };
+
+        self.authifier
+            .database
+            .save_account(&account)
+            .await
+            .expect("`Account`");
 
         let session = account
             .create_session(&self.authifier, String::new())
             .await
             .expect("`Session`");
 
-        let user = User::create(
-            &self.db,
-            TestHarness::rand_string(),
-            account.id.to_string(),
-            None,
-        )
-        .await
-        .expect("`User`");
-
-        (account, session, user)
+        (account, session)
     }
 
     pub async fn new_server(&self, user: &User) -> (Server, Vec<Channel>) {