refactor: tests for more group routes

crates/delta/src/routes/channels/group_create.rs

@@ -1,4 +1,3 @@
-use revolt_config::config;
 use revolt_database::{Channel, Database, RelationshipStatus, User};
 use revolt_models::v0;
 use revolt_result::{create_error, Result};
@@ -17,26 +16,17 @@ pub async fn create_group(
     user: User,
     data: Json<v0::DataCreateGroup>,
 ) -> Result<Json<v0::Channel>> {
-    let config = config().await;
     if user.bot.is_some() {
         return Err(create_error!(IsBot));
     }
 
-    let mut data = data.into_inner();
+    let data = data.into_inner();
     data.validate().map_err(|error| {
         create_error!(FailedValidation {
             error: error.to_string()
         })
     })?;
 
-    data.users.insert(user.id.to_string());
-
-    if data.users.len() > config.features.limits.default.group_size {
-        return Err(create_error!(GroupTooLarge {
-            max: config.features.limits.default.group_size,
-        }));
-    }
-
     for target in &data.users {
         match user.relationship_with(target) {
             RelationshipStatus::Friend | RelationshipStatus::User => {}
@@ -52,12 +42,13 @@ pub async fn create_group(
 #[cfg(test)]
 mod test {
     use crate::{rocket, util::test::TestHarness};
+    use revolt_database::events::client::EventV1;
     use revolt_models::v0;
     use rocket::http::{ContentType, Header, Status};
 
     #[rocket::async_test]
     async fn create_group() {
-        let harness = TestHarness::new().await;
+        let mut harness = TestHarness::new().await;
         let (_, session, user) = harness.new_user().await;
 
         let response = harness
@@ -88,7 +79,22 @@ mod test {
                 assert_eq!(recipients.len(), 1);
                 assert!(harness.db.fetch_channel(&id).await.is_ok());
 
-                // TODO: does not check for events
+                let event = harness
+                    .wait_for_event(&format!("{}!", user.id), |event| match event {
+                        EventV1::ChannelCreate(channel) => channel.id() == id,
+                        _ => false,
+                    })
+                    .await;
+
+                match event {
+                    EventV1::ChannelCreate(v0::Channel::Group {
+                        owner: channel_owner,
+                        ..
+                    }) => {
+                        assert_eq!(owner, channel_owner);
+                    }
+                    _ => unreachable!(),
+                }
             }
             _ => unreachable!(),
         }