test: add tests to bot routes

crates/delta/src/routes/bots/invite.rs

@@ -1,29 +1,15 @@
 use revolt_database::util::permissions::DatabasePermissionQuery;
 use revolt_database::Member;
 use revolt_database::{util::reference::Reference, Database, User};
-use revolt_permissions::{calculate_server_permissions, ChannelPermission};
+use revolt_models::v0;
+use revolt_permissions::{
+    calculate_channel_permissions, calculate_server_permissions, ChannelPermission,
+};
 use revolt_result::{create_error, Result};
 use rocket::State;
 
 use rocket::serde::json::Json;
 use rocket_empty::EmptyResponse;
-use serde::Deserialize;
-
-/// # Invite Destination
-#[derive(Deserialize, JsonSchema)]
-#[serde(untagged)]
-pub enum InviteBotDestination {
-    /// Invite to a server
-    Server {
-        /// Server Id
-        server: String,
-    },
-    /// Invite to a group
-    Group {
-        /// Group Id
-        group: String,
-    },
-}
 
 /// # Invite Bot
 ///
@@ -34,7 +20,7 @@ pub async fn invite_bot(
     db: &State<Database>,
     user: User,
     target: Reference,
-    dest: Json<InviteBotDestination>,
+    dest: Json<v0::InviteBotDestination>,
 ) -> Result<EmptyResponse> {
     if user.bot.is_some() {
         return Err(create_error!(IsBot));
@@ -48,7 +34,7 @@ pub async fn invite_bot(
     let bot_user = db.fetch_user(&bot.id).await?;
 
     match dest.into_inner() {
-        InviteBotDestination::Server { server } => {
+        v0::InviteBotDestination::Server { server } => {
             let server = db.fetch_server(&server).await?;
 
             let mut query = DatabasePermissionQuery::new(db, &user).server(&server);
@@ -60,11 +46,11 @@ pub async fn invite_bot(
                 .await
                 .map(|_| EmptyResponse)
         }
-        InviteBotDestination::Group { group } => {
+        v0::InviteBotDestination::Group { group } => {
             let mut channel = db.fetch_channel(&group).await?;
 
             let mut query = DatabasePermissionQuery::new(db, &user).channel(&channel);
-            calculate_server_permissions(&mut query)
+            calculate_channel_permissions(&mut query)
                 .await
                 .throw_if_lacking_channel_permission(ChannelPermission::InviteOthers)?;
 
@@ -75,3 +61,124 @@ pub async fn invite_bot(
         }
     }
 }
+
+#[cfg(test)]
+mod test {
+    use crate::{rocket, util::test::TestHarness};
+    use revolt_database::{events::client::EventV1, Bot, Channel, Server};
+    use revolt_models::v0;
+    use rocket::http::{ContentType, Header, Status};
+
+    #[rocket::async_test]
+    async fn invite_bot_to_group() {
+        let mut harness = TestHarness::new().await;
+        let (_, session, user) = harness.new_user().await;
+
+        let bot = Bot::create(&harness.db, TestHarness::rand_string(), &user, None)
+            .await
+            .expect("`Bot`");
+
+        // FIXME: Channel::create_group
+        let group = Channel::Group {
+            id: ulid::Ulid::new().to_string(),
+            name: TestHarness::rand_string(),
+            owner: user.id.to_string(),
+            description: None,
+            last_message_id: None,
+            icon: None,
+            nsfw: false,
+            permissions: None,
+            recipients: vec![user.id.to_string()],
+        };
+
+        group.create(&harness.db).await.unwrap();
+
+        let response = harness
+            .client
+            .post(format!("/bots/{}/invite", bot.id))
+            .header(ContentType::JSON)
+            .body(json!(v0::InviteBotDestination::Group { group: group.id() }).to_string())
+            .header(Header::new("x-session-token", session.token.to_string()))
+            .dispatch()
+            .await;
+
+        assert_eq!(response.status(), Status::NoContent);
+        drop(response);
+
+        let event = harness
+            .wait_for_event(|event| match event {
+                EventV1::ChannelGroupJoin { id, .. } => id == &group.id(),
+                _ => false,
+            })
+            .await;
+
+        match event {
+            EventV1::ChannelGroupJoin { user, .. } => {
+                assert_eq!(bot.id, user);
+            }
+            _ => unreachable!(),
+        }
+    }
+
+    #[rocket::async_test]
+    async fn invite_bot_to_server() {
+        let mut harness = TestHarness::new().await;
+        let (_, session, user) = harness.new_user().await;
+
+        let bot = Bot::create(&harness.db, TestHarness::rand_string(), &user, None)
+            .await
+            .expect("`Bot`");
+
+        // FIXME: Server::create_server
+        let server = Server {
+            id: ulid::Ulid::new().to_string(),
+            name: TestHarness::rand_string(),
+            owner: user.id.to_string(),
+            analytics: false,
+            discoverable: false,
+            nsfw: false,
+            banner: None,
+            icon: None,
+            categories: None,
+            channels: vec![],
+            default_permissions: 0,
+            description: None,
+            flags: None,
+            roles: Default::default(),
+            system_messages: None,
+        };
+
+        server.create(&harness.db).await.unwrap();
+
+        let response = harness
+            .client
+            .post(format!("/bots/{}/invite", bot.id))
+            .header(ContentType::JSON)
+            .body(
+                json!(v0::InviteBotDestination::Server {
+                    server: server.id.to_string()
+                })
+                .to_string(),
+            )
+            .header(Header::new("x-session-token", session.token.to_string()))
+            .dispatch()
+            .await;
+
+        assert_eq!(response.status(), Status::NoContent);
+        drop(response);
+
+        let event = harness
+            .wait_for_event(|event| match event {
+                EventV1::ServerMemberJoin { id, .. } => id == &server.id,
+                _ => false,
+            })
+            .await;
+
+        match event {
+            EventV1::ServerMemberJoin { user, .. } => {
+                assert_eq!(bot.id, user);
+            }
+            _ => unreachable!(),
+        }
+    }
+}