chore: Write tests for pinning

crates/core/database/src/models/server_members/model.rs

@@ -81,7 +81,7 @@ impl Member {
         server: &Server,
         user: &User,
         channels: Option<Vec<Channel>>,
-    ) -> Result<Vec<Channel>> {
+    ) -> Result<(Member, Vec<Channel>)> {
         if db.fetch_ban(&server.id, &user.id).await.is_ok() {
             return Err(create_error!(Banned));
         }
@@ -155,7 +155,7 @@ impl Member {
             .ok();
         }
 
-        Ok(channels)
+        Ok((member, channels))
     }
 
     /// Update member data

crates/core/database/src/util/idempotency.rs

@@ -18,6 +18,10 @@ static TOKEN_CACHE: Lazy<Mutex<lru::LruCache<String, ()>>> =
     Lazy::new(|| Mutex::new(lru::LruCache::new(NonZeroUsize::new(1000).unwrap())));
 
 impl IdempotencyKey {
+    pub fn unchecked_from_string(key: String) -> Self {
+        Self { key }
+    }
+
     // Backwards compatibility.
     // Issue #109
     pub async fn consume_nonce(&mut self, v: Option<String>) -> Result<()> {

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

@@ -37,3 +37,84 @@ pub async fn message_pin(
 
     Ok(EmptyResponse)
 }
+
+#[cfg(test)]
+mod test {
+    use crate::{rocket, util::test::TestHarness};
+    use revolt_database::{events::client::EventV1, util::{idempotency::IdempotencyKey, reference::Reference}, Member, Message, Server};
+    use revolt_models::v0;
+    use rocket::http::{Header, Status};
+
+    #[rocket::async_test]
+    async fn pin_message() {
+        let mut harness = TestHarness::new().await;
+        let (_, session, user) = harness.new_user().await;
+
+        let (server, channels) = Server::create(
+            &harness.db,
+            v0::DataCreateServer {
+                name: "Test Server".to_string(),
+                ..Default::default()
+            },
+            &user,
+            true
+        ).await.expect("Failed to create test server");
+
+        let (member, channels) = Member::create(&harness.db, &server, &user, Some(channels)).await.expect("Failed to create member");
+        let channel = &channels[0];
+
+        let message = Message::create_from_api(
+            &harness.db,
+            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(&harness.db, Some(&user)).await),
+            Some(user.clone().into(&harness.db, Some(&user)).await),
+            Some(member.into()),
+            user.limits().await,
+            IdempotencyKey::unchecked_from_string("0".to_string()),
+            false,
+            false
+        )
+        .await
+        .expect("Failed to create message");
+
+        let response = harness
+            .client
+            .post(format!("/channels/{}/messages/{}/pin", channel.id(), &message.id))
+            .header(Header::new("x-session-token", session.token.to_string()))
+            .dispatch()
+            .await;
+
+        assert_eq!(response.status(), Status::NoContent);
+        drop(response);
+
+        harness.wait_for_event(&channel.id(), |event| {
+            match event {
+                EventV1::MessageUpdate { id, channel: channel_id, data, .. } => {
+                    assert_eq!(id, &message.id);
+                    assert_eq!(channel_id, &channel.id());
+                    assert_eq!(data.pinned, Some(true));
+
+                    true
+                },
+                _ => false
+            }
+        }).await;
+
+        let updated_message = Reference::from_unchecked(message.id)
+            .as_message(&harness.db)
+            .await
+            .expect("Failed to find updated message");
+
+        assert_eq!(updated_message.pinned, Some(true));
+    }
+}

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

@@ -1,5 +1,5 @@
 use revolt_database::{
-    util::{permissions::DatabasePermissionQuery, reference::Reference}, Database, PartialMessage, User
+    util::{permissions::DatabasePermissionQuery, reference::Reference}, Database, FieldsMessage, PartialMessage, User
 };
 use revolt_permissions::{calculate_channel_permissions, ChannelPermission};
 use revolt_result::{create_error, Result};
@@ -10,7 +10,7 @@ use rocket_empty::EmptyResponse;
 ///
 /// Unpins a message by its id.
 #[openapi(tag = "Messaging")]
-#[post("/<target>/messages/<msg>/unpin")]
+#[delete("/<target>/messages/<msg>/pin")]
 pub async fn message_unpin(
     db: &State<Database>,
     user: User,
@@ -37,3 +37,97 @@ pub async fn message_unpin(
 
     Ok(EmptyResponse)
 }
+
+#[cfg(test)]
+mod test {
+    use crate::{rocket, util::test::TestHarness};
+    use revolt_database::{events::client::EventV1, util::{idempotency::IdempotencyKey, reference::Reference}, Member, Message, PartialMessage, Server};
+    use revolt_models::v0;
+    use rocket::http::{Header, Status};
+
+    #[rocket::async_test]
+    async fn unpin_message() {
+        let mut harness = TestHarness::new().await;
+        let (_, session, user) = harness.new_user().await;
+
+        let (server, channels) = Server::create(
+            &harness.db,
+            v0::DataCreateServer {
+                name: "Test Server".to_string(),
+                ..Default::default()
+            },
+            &user,
+            true
+        ).await.expect("Failed to create test server");
+
+        let channel = &channels[0];
+
+        Member::create(&harness.db, &server, &user, Some(channels.clone())).await.expect("Failed to create member");
+        let member = Reference::from_unchecked(user.id.clone()).as_member(&harness.db, &server.id).await.expect("Failed to get member");
+
+        let mut message = Message::create_from_api(
+            &harness.db,
+            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(&harness.db, Some(&user)).await),
+            Some(user.clone().into(&harness.db, Some(&user)).await),
+            Some(member.into()),
+            user.limits().await,
+            IdempotencyKey::unchecked_from_string("0".to_string()),
+            false,
+            false
+        )
+        .await
+        .expect("Failed to create message");
+
+        harness.db.update_message(
+            &message.id,
+            &PartialMessage {
+                pinned: Some(true),
+                ..Default::default()
+            },
+            vec![]
+        ).await.expect("Failed to update message");
+
+        let response = harness
+            .client
+            .delete(format!("/channels/{}/messages/{}/pin", channel.id(), &message.id))
+            .header(Header::new("x-session-token", session.token.to_string()))
+            .dispatch()
+            .await;
+
+        assert_eq!(response.status(), Status::NoContent);
+        drop(response);
+
+        harness.wait_for_event(&channel.id(), |event| {
+            match event {
+                EventV1::MessageUpdate { id, data, .. } => {
+                    if id != &message.id {
+                        return false
+                    };
+
+                    assert_eq!(data.pinned, Some(false));
+
+                    true
+                },
+                _ => false
+            }
+        }).await;
+
+        let updated_message = Reference::from_unchecked(message.id)
+            .as_message(&harness.db)
+            .await
+            .expect("Failed to find updated message");
+
+        assert_eq!(updated_message.pinned, None);
+    }
+}

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

@@ -23,7 +23,8 @@ pub async fn join(
     match &invite {
         Invite::Server { server, .. } => {
             let server = db.fetch_server(server).await?;
-            let channels = Member::create(db, &server, &user, None).await?;
+            let (_, channels) = Member::create(db, &server, &user, None).await?;
+
             Ok(Json(InviteJoinResponse::Server {
                 channels: channels.into_iter().map(|c| c.into()).collect(),
                 server: server.into(),

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

@@ -30,7 +30,7 @@ pub async fn create_server(
     user.can_acquire_server(db).await?;
 
     let (server, channels) = Server::create(db, data, &user, true).await?;
-    let channels = Member::create(db, &server, &user, Some(channels)).await?;
+    let (_, channels) = Member::create(db, &server, &user, Some(channels)).await?;
 
     Ok(Json(v0::CreateServerLegacyResponse {
         server: server.into(),