From 6f0e80eef9413a75d168f64d71db2dbd82e394af Mon Sep 17 00:00:00 2001
From: phazeschift <51278042+phazeschift@users.noreply.github.com>
Date: Fri, 14 Mar 2025 16:52:02 -0700
Subject: [PATCH] test: Add tests for invite/fetch

Signed-off-by: phazeschift <51278042+phazeschift@users.noreply.github.com>
---
 .../delta/src/routes/invites/invite_fetch.rs  | 185 ++++++++++++++++++
 1 file changed, 185 insertions(+)

diff --git a/crates/delta/src/routes/invites/invite_fetch.rs b/crates/delta/src/routes/invites/invite_fetch.rs
index edf54744..175fc944 100644
--- a/crates/delta/src/routes/invites/invite_fetch.rs
+++ b/crates/delta/src/routes/invites/invite_fetch.rs
@@ -69,3 +69,188 @@ pub async fn fetch(db: &State<Database>, target: Reference) -> Result<Json<v0::I
         }
     }))
 }
+
+#[cfg(test)]
+mod test {
+    use crate::{rocket, util::test::TestHarness};
+    use revolt_database::{Channel, Server};
+    use revolt_models::v0::{
+        DataCreateGroup, DataCreateServer, DataCreateServerChannel, Invite, InviteResponse,
+        LegacyServerChannelType,
+    };
+    use rocket::http::{Header, Status};
+
+    #[rocket::async_test]
+    async fn success_fetch_group_invite() {
+        let harness = TestHarness::new().await;
+        let (_, session, user) = harness.new_user().await;
+
+        let group = Channel::create_group(
+            &harness.db,
+            DataCreateGroup {
+                ..Default::default()
+            },
+            user.id.clone(),
+        )
+        .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;
+        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 {
+            Invite::Group { code, .. } => code,
+            _ => unreachable!(),
+        };
+        let response = harness
+            .client
+            .get(format!("/invites/{}", invite_code))
+            .dispatch()
+            .await;
+        assert_eq!(response.status(), Status::Ok);
+        let invite_response: InviteResponse = response.into_json().await.expect("`FetchInvite`");
+        match invite_response {
+            InviteResponse::Group {
+                code,
+                channel_id,
+                user_name,
+                ..
+            } => {
+                assert_eq!(code, invite_code);
+                assert_eq!(channel_id, group.id());
+                assert_eq!(user_name, user.username);
+            }
+            _ => unreachable!(),
+        }
+    }
+
+    #[rocket::async_test]
+    async fn fail_fetch_missing_invite() {
+        let harness = TestHarness::new().await;
+        let response = harness
+            .client
+            .get(format!("/invites/{}", TestHarness::rand_string()))
+            .dispatch()
+            .await;
+        assert_eq!(response.status(), Status::NotFound);
+    }
+
+    #[rocket::async_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 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;
+        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 {
+            Invite::Server { code, .. } => code,
+            _ => unreachable!(),
+        };
+        let response = harness
+            .client
+            .get(format!("/invites/{}", invite_code))
+            .dispatch()
+            .await;
+        assert_eq!(response.status(), Status::Ok);
+        let invite_response: InviteResponse = response.into_json().await.expect("`FetchInvite`");
+        match invite_response {
+            InviteResponse::Server {
+                code,
+                channel_id,
+                user_name,
+                ..
+            } => {
+                assert_eq!(code, invite_code);
+                assert_eq!(channel_id, channel.id());
+                assert_eq!(user_name, user.username);
+            }
+            _ => unreachable!(),
+        };
+    }
+
+    #[rocket::async_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_mut: &mut Server = &mut server.clone();
+
+        let channel = Channel::create_server_channel(
+            &harness.db,
+            server_mut,
+            DataCreateServerChannel {
+                channel_type: LegacyServerChannelType::Voice,
+                name: "Voice Channel".to_string(),
+                description: None,
+                nsfw: Some(false),
+            },
+            true,
+        )
+        .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;
+        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 {
+            Invite::Server { code, .. } => code,
+            _ => unreachable!(),
+        };
+        let response = harness
+            .client
+            .get(format!("/invites/{}", invite_code))
+            .dispatch()
+            .await;
+        assert_eq!(response.status(), Status::Ok);
+        let invite_response: InviteResponse = response.into_json().await.expect("`FetchInvite`");
+        match invite_response {
+            InviteResponse::Server {
+                code,
+                channel_id,
+                user_name,
+                ..
+            } => {
+                assert_eq!(code, invite_code);
+                assert_eq!(channel_id, channel.id());
+                assert_eq!(user_name, user.username);
+            }
+            _ => unreachable!(),
+        };
+    }
+}