chore(repo): remove dead code and useless tests (#3375)

fluxer_messages/src/router_impl.rs

@@ -29,10 +29,6 @@ impl RouterService for MessagesRouter {
 
     fn route_key(req: &MessageRequest) -> String {
         match req {
-            MessageRequest::GetById { channel_id, .. } => channel_id.to_string(),
-            MessageRequest::GetLatest { channel_id, .. } => channel_id.to_string(),
-            MessageRequest::GetBefore { channel_id, .. } => channel_id.to_string(),
-            MessageRequest::GetAfter { channel_id, .. } => channel_id.to_string(),
             MessageRequest::GetResponseById { channel_id, .. } => channel_id.to_string(),
             MessageRequest::BuildResponse { message, .. } => message.channel_id.to_string(),
             MessageRequest::BuildResponses { messages, .. } => messages
@@ -46,23 +42,6 @@ impl RouterService for MessagesRouter {
 
     fn coalesce_key(req: &MessageRequest) -> Option<String> {
         match req {
-            MessageRequest::GetById {
-                channel_id,
-                message_id,
-            } => Some(format!("get:{channel_id}:{message_id}")),
-            MessageRequest::GetLatest { channel_id, limit } => {
-                Some(format!("latest:{channel_id}:{limit}"))
-            }
-            MessageRequest::GetBefore {
-                channel_id,
-                before_id,
-                limit,
-            } => Some(format!("before:{channel_id}:{before_id}:{limit}")),
-            MessageRequest::GetAfter {
-                channel_id,
-                after_id,
-                limit,
-            } => Some(format!("after:{channel_id}:{after_id}:{limit}")),
             MessageRequest::GetResponseById {
                 channel_id,
                 message_id,
@@ -110,23 +89,6 @@ impl RouterService for MessagesRouter {
 mod tests {
     use super::*;
 
-    #[test]
-    fn coalesce_key_includes_message_query_shape() {
-        let latest = MessageRequest::GetLatest {
-            channel_id: 42,
-            limit: 50,
-        };
-        let before = MessageRequest::GetBefore {
-            channel_id: 42,
-            before_id: 100,
-            limit: 50,
-        };
-        assert_ne!(
-            MessagesRouter::coalesce_key(&latest),
-            MessagesRouter::coalesce_key(&before)
-        );
-    }
-
     fn list_request(threads_mask: bool, exclude_types: Vec<i32>) -> MessageRequest {
         MessageRequest::ListResponses {
             channel_id: "42".to_owned(),

fluxer_messages/src/shard_impl.rs

@@ -362,7 +362,6 @@ impl PageCursor {
 #[derive(Debug, Deserialize)]
 enum UserServiceResponse {
     FoundPartials(Vec<UserPartialServiceResponse>),
-    FoundPartial(UserPartialServiceResponse),
 }
 
 #[derive(Debug, Deserialize)]
@@ -1328,7 +1327,6 @@ impl<T: Transport> MessagesShard<T> {
             .and_then(|bytes| serde_json::from_slice::<UserServiceResponse>(&bytes).ok());
         let partials = match response {
             Some(UserServiceResponse::FoundPartials(partials)) => partials,
-            Some(UserServiceResponse::FoundPartial(partial)) => vec![partial],
             _ => Vec::new(),
         };
         users.partials.extend(
@@ -2540,33 +2538,6 @@ impl<T: Transport> ShardService for MessagesShard<T> {
 
     async fn handle(&self, request: MessageRequest) -> anyhow::Result<MessageResponse> {
         match request {
-            MessageRequest::GetById {
-                channel_id,
-                message_id,
-            } => match self.get_by_id(channel_id, message_id).await? {
-                Some(msg) => Ok(MessageResponse::Found(msg)),
-                None => Ok(MessageResponse::NotFound),
-            },
-            MessageRequest::GetLatest { channel_id, limit } => {
-                let messages = self.get_latest(channel_id, limit).await?;
-                Ok(MessageResponse::FoundMany(messages))
-            }
-            MessageRequest::GetBefore {
-                channel_id,
-                before_id,
-                limit,
-            } => {
-                let messages = self.get_before(channel_id, before_id, limit).await?;
-                Ok(MessageResponse::FoundMany(messages))
-            }
-            MessageRequest::GetAfter {
-                channel_id,
-                after_id,
-                limit,
-            } => {
-                let messages = self.get_after(channel_id, after_id, limit).await?;
-                Ok(MessageResponse::FoundMany(messages))
-            }
             MessageRequest::GetResponseById {
                 channel_id,
                 message_id,

fluxer_messages/src/types.rs

@@ -71,24 +71,6 @@ mod serde_id {
 #[serde(tag = "op")]
 #[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
 pub enum MessageRequest {
-    GetById {
-        channel_id: i64,
-        message_id: i64,
-    },
-    GetLatest {
-        channel_id: i64,
-        limit: u32,
-    },
-    GetBefore {
-        channel_id: i64,
-        before_id: i64,
-        limit: u32,
-    },
-    GetAfter {
-        channel_id: i64,
-        after_id: i64,
-        limit: u32,
-    },
     GetResponseById {
         channel_id: String,
         message_id: String,
@@ -172,8 +154,6 @@ pub enum MessageRequest {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[allow(clippy::large_enum_variant)]
 pub enum MessageResponse {
-    Found(Message),
-    FoundMany(Vec<Message>),
     FoundApi(ApiMessageResponse),
     FoundApiMany(Vec<ApiMessageResponse>),
     FoundMentions(Vec<ExtractedMentionsResponse>),

fluxer_messages/tests/message_response_logic.rs

@@ -3,19 +3,6 @@
 use fluxer_messages::mention_extractor::extract_mentions_from_markdown;
 use fluxer_messages::types::ExtractedMentionsResponse;
 
-#[test]
-fn markdown_extractor_matches_message_response_mention_rules() {
-    let mentions = extract_mentions_from_markdown(Some(
-        "ping <@101> <@!202> <@&303> <#404>\n`<@505>`\n```txt\n<#606>\n```",
-    ));
-    assert!(mentions.users.contains(&101));
-    assert!(mentions.users.contains(&202));
-    assert!(mentions.roles.contains(&303));
-    assert!(mentions.channels.contains(&404));
-    assert!(!mentions.users.contains(&505));
-    assert!(!mentions.channels.contains(&606));
-}
-
 #[test]
 fn markdown_extractor_keeps_link_text_mentions_but_not_url_mentions() {
     let mentions =
@@ -47,51 +34,3 @@ fn everyone_and_here_survive_response_conversion() {
     assert!(response.everyone);
     assert!(response.here);
 }
-
-#[test]
-fn batch_extraction_matches_individual() {
-    let contents = [
-        "<@1> <@&2>".to_owned(),
-        "`<@3>` <#4>".to_owned(),
-        "@everyone".to_owned(),
-    ];
-    let batch: Vec<_> = contents
-        .iter()
-        .map(|c| extract_mentions_from_markdown(Some(c)))
-        .collect();
-    assert!(batch[0].users.contains(&1));
-    assert!(batch[0].roles.contains(&2));
-    assert!(!batch[1].users.contains(&3));
-    assert!(batch[1].channels.contains(&4));
-    assert!(batch[2].everyone);
-}
-
-#[test]
-fn stress_test_large_message_batch() {
-    let messages: Vec<String> = (0..500)
-        .map(|i| {
-            format!(
-                "msg {i} <@{}> <@!{}> <@&{}> <#{}> `<@{}>` @everyone",
-                10_000 + i,
-                20_000 + i,
-                30_000 + i,
-                40_000 + i,
-                50_000 + i
-            )
-        })
-        .collect();
-    let results: Vec<_> = messages
-        .iter()
-        .map(|m| extract_mentions_from_markdown(Some(m)))
-        .collect();
-    assert_eq!(results.len(), 500);
-    for (i, result) in results.iter().enumerate() {
-        let i = i as i64;
-        assert!(result.users.contains(&(10_000 + i)));
-        assert!(result.users.contains(&(20_000 + i)));
-        assert!(result.roles.contains(&(30_000 + i)));
-        assert!(result.channels.contains(&(40_000 + i)));
-        assert!(!result.users.contains(&(50_000 + i)));
-        assert!(result.everyone);
-    }
-}