test: add utilities for common setup

Signed-off-by: phazeschift <51278042+phazeschift@users.noreply.github.com>

crates/delta/src/routes/invites/invite_fetch.rs

@@ -75,10 +75,9 @@ mod test {
     use crate::{rocket, util::test::TestHarness};
     use revolt_database::{Channel, Server};
     use revolt_models::v0::{
-        DataCreateGroup, DataCreateServer, DataCreateServerChannel, Invite, InviteResponse,
-        LegacyServerChannelType,
+        DataCreateGroup, DataCreateServerChannel, Invite, InviteResponse, LegacyServerChannelType,
     };
-    use rocket::http::{Header, Status};
+    use rocket::http::Status;
 
     #[rocket::async_test]
     async fn success_fetch_group_invite() {
@@ -94,12 +93,13 @@ mod test {
         )
         .await
         .expect("`Channel`");
-        let create_response = harness
-            .client
-            .post(format!("/channels/{}/invites", group.id()))
-            .header(Header::new("x-session-token", session.token.to_string()))
-            .dispatch()
-            .await;
+        let create_response = TestHarness::with_session(
+            session,
+            harness
+                .client
+                .post(format!("/channels/{}/invites", group.id())),
+        )
+        .await;
         assert_eq!(create_response.status(), Status::Ok);
         let invite_from_create: Invite = create_response.into_json().await.expect("`Invite`");
         let invite_code = match invite_from_create {
@@ -143,25 +143,15 @@ mod test {
     async fn success_fetch_text_channel_invite() {
         let harness = TestHarness::new().await;
         let (_, session, user) = harness.new_user().await;
-        let (_, channels) = Server::create(
-            &harness.db,
-            DataCreateServer {
-                name: "Test Server".to_string(),
-                ..Default::default()
-            },
-            &user,
-            true,
-        )
-        .await
-        .expect("Failed to create test server");
-
+        let (_, channels) = harness.new_server(&user).await;
         let channel = channels.first().expect("Server Channel");
-        let create_response = harness
-            .client
-            .post(format!("/channels/{}/invites", channel.id()))
-            .header(Header::new("x-session-token", session.token.to_string()))
-            .dispatch()
-            .await;
+        let create_response = TestHarness::with_session(
+            session,
+            harness
+                .client
+                .post(format!("/channels/{}/invites", channel.id())),
+        )
+        .await;
         assert_eq!(create_response.status(), Status::Ok);
         let invite_from_create: Invite = create_response.into_json().await.expect("`Invite`");
         let invite_code = match invite_from_create {
@@ -194,17 +184,7 @@ mod test {
     async fn success_fetch_voice_channel_invite() {
         let harness = TestHarness::new().await;
         let (_, session, user) = harness.new_user().await;
-        let (server, _) = Server::create(
-            &harness.db,
-            DataCreateServer {
-                name: "Test Server".to_string(),
-                ..Default::default()
-            },
-            &user,
-            true,
-        )
-        .await
-        .expect("Failed to create test server");
+        let (server, _) = harness.new_server(&user).await;
         let server_mut: &mut Server = &mut server.clone();
 
         let channel = Channel::create_server_channel(
@@ -220,12 +200,13 @@ mod test {
         )
         .await
         .expect("Failed to make new channel");
-        let create_response = harness
-            .client
-            .post(format!("/channels/{}/invites", channel.id()))
-            .header(Header::new("x-session-token", session.token.to_string()))
-            .dispatch()
-            .await;
+        let create_response = TestHarness::with_session(
+            session,
+            harness
+                .client
+                .post(format!("/channels/{}/invites", channel.id())),
+        )
+        .await;
         assert_eq!(create_response.status(), Status::Ok);
         let invite_from_create: Invite = create_response.into_json().await.expect("`Invite`");
         let invite_code = match invite_from_create {

crates/delta/src/util/test.rs

@@ -5,9 +5,13 @@ use authifier::{
 use futures::StreamExt;
 use rand::Rng;
 use redis_kiss::redis::aio::PubSub;
-use revolt_database::{events::client::EventV1, Database, User, AMQP};
+use revolt_database::util::idempotency::IdempotencyKey;
+use revolt_database::{
+    events::client::EventV1, Channel, Database, Member, Message, Server, User, AMQP,
+};
 use revolt_models::v0;
-use rocket::local::asynchronous::Client;
+use rocket::http::Header;
+use rocket::local::asynchronous::{Client, LocalRequest, LocalResponse};
 
 pub struct TestHarness {
     pub client: Client,
@@ -104,6 +108,67 @@ impl TestHarness {
         (account, session, user)
     }
 
+    pub async fn new_server(&self, user: &User) -> (Server, Vec<Channel>) {
+        Server::create(
+            &self.db,
+            v0::DataCreateServer {
+                name: "Test Server".to_string(),
+                ..Default::default()
+            },
+            user,
+            true,
+        )
+        .await
+        .expect("Failed to create test server")
+    }
+
+    pub async fn new_message(
+        &self,
+        user: &User,
+        server: &Server,
+        channels: Vec<Channel>,
+    ) -> (Channel, Member, Message) {
+        let (member, channels) = Member::create(&self.db, server, user, Some(channels))
+            .await
+            .expect("Failed to create member");
+        let channel = &channels[0];
+        let message = Message::create_from_api(
+            &self.db,
+            None,
+            channel.clone(),
+            v0::DataMessageSend {
+                content: Some("Test message".to_string()),
+                nonce: None,
+                attachments: None,
+                replies: None,
+                embeds: None,
+                masquerade: None,
+                interactions: None,
+                flags: None,
+            },
+            v0::MessageAuthor::User(&user.clone().into(&self.db, Some(user)).await),
+            Some(user.clone().into(&self.db, Some(user)).await),
+            Some(member.clone().into()),
+            user.limits().await,
+            IdempotencyKey::unchecked_from_string("0".to_string()),
+            false,
+            false,
+        )
+        .await
+        .expect("Failed to create message");
+        (channel.clone(), member, message)
+    }
+
+    pub async fn with_session<'c>(
+        session: Session,
+        request: LocalRequest<'c>,
+    ) -> LocalResponse<'c> {
+        request
+            .header(Header::new("x-session-token", session.token.to_string()))
+            .dispatch()
+            .await
+    }
+
     pub async fn wait_for_event<F>(&mut self, topic: &str, predicate: F) -> EventV1
     where
         F: Fn(&EventV1) -> bool,