A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
feat: give the system user the instance's name, drop shard tests
Hampus161fa44e20a1
diff --git a/fluxer_common/src/user_partial.rs b/fluxer_common/src/user_partial.rsindex 5acd38cbd..2955d4b47 100644--- a/fluxer_common/src/user_partial.rs+++ b/fluxer_common/src/user_partial.rs@@ -4,8 +4,12 @@ use crate::user_flags::{USER_FLAG_STAFF, visible_user_flags};use serde::{Deserialize, Serialize};pub const FLUXER_SYSTEM_USER_ID: i64 = 0;-pub const FLUXER_SYSTEM_USERNAME: &str = "Fluxer";pub const FLUXER_SYSTEM_DISCRIMINATOR: i32 = 0;+const UPSTREAM_INSTANCE_NAME: &str = "Fluxer";++pub fn default_instance_name() -> String {+ UPSTREAM_INSTANCE_NAME.to_owned()+}#[derive(Debug, Clone, Serialize, Deserialize)]pub struct ApiUserPartial {@@ -40,7 +44,7 @@ pub struct UserPartialFields {impl From<UserPartialFields> for ApiUserPartial {fn from(partial: UserPartialFields) -> Self {if partial.user_id == FLUXER_SYSTEM_USER_ID {- return fluxer_system_user();+ return fluxer_system_user(partial.username);}Self {id: partial.user_id.to_string(),@@ -57,10 +61,10 @@ impl From<UserPartialFields> for ApiUserPartial {}}-pub fn fluxer_system_user() -> ApiUserPartial {+pub fn fluxer_system_user(instance_name: String) -> ApiUserPartial {ApiUserPartial {id: FLUXER_SYSTEM_USER_ID.to_string(),- username: FLUXER_SYSTEM_USERNAME.to_owned(),+ username: instance_name,discriminator: format!("{:04}", FLUXER_SYSTEM_DISCRIMINATOR),global_name: None,avatar: None,diff --git a/fluxer_messages/src/router_impl.rs b/fluxer_messages/src/router_impl.rsindex aab2ada9d..1d93c9a4f 100644--- a/fluxer_messages/src/router_impl.rs+++ b/fluxer_messages/src/router_impl.rs@@ -56,9 +56,10 @@ impl RouterService for MessagesRouter {tts,include_hidden,threads_mask,+ instance_name,..} => Some(format!(- "api-get:{channel_id}:{message_id}:{viewer_user_id}:{source_guild_id:?}:{message_history_cutoff_ms:?}:{can_read_message_history}:{media_endpoint}:{include_reactions:?}:{attachment_decay:?}:{nonce:?}:{tts:?}:{include_hidden}:{threads_mask}"+ "api-get:{channel_id}:{message_id}:{viewer_user_id}:{source_guild_id:?}:{message_history_cutoff_ms:?}:{can_read_message_history}:{media_endpoint}:{include_reactions:?}:{attachment_decay:?}:{nonce:?}:{tts:?}:{include_hidden}:{threads_mask}:{instance_name}")),MessageRequest::BuildResponse { .. } => None,MessageRequest::BuildResponses { .. } => None,@@ -78,98 +79,12 @@ impl RouterService for MessagesRouter {include_hidden,threads_mask,exclude_types,+ instance_name,..} => Some(format!(- "api-list:{channel_id}:{viewer_user_id}:{limit}:{before_id:?}:{after_id:?}:{around_id:?}:{source_guild_id:?}:{message_history_cutoff_ms:?}:{can_read_message_history}:{media_endpoint}:{include_reactions:?}:{attachment_decay:?}:{include_hidden}:{threads_mask}:{exclude_types:?}"+ "api-list:{channel_id}:{viewer_user_id}:{limit}:{before_id:?}:{after_id:?}:{around_id:?}:{source_guild_id:?}:{message_history_cutoff_ms:?}:{can_read_message_history}:{media_endpoint}:{include_reactions:?}:{attachment_decay:?}:{include_hidden}:{threads_mask}:{exclude_types:?}:{instance_name}")),MessageRequest::ExtractMentions { .. } => None,}}}--#[cfg(test)]-mod tests {- use super::*;-- fn list_request(threads_mask: bool, exclude_types: Vec<i32>) -> MessageRequest {- MessageRequest::ListResponses {- channel_id: "42".to_owned(),- viewer_user_id: "7".to_owned(),- limit: 50,- before_id: None,- after_id: None,- around_id: None,- source_guild_id: Some("9".to_owned()),- message_history_cutoff_ms: None,- can_read_message_history: true,- media_endpoint: "https://media.test".to_owned(),- media_proxy_secret_key: "secret".to_owned(),- attachment_url_secret_base64: None,- include_reactions: None,- attachment_decay: None,- include_hidden: false,- threads_mask,- exclude_types,- }- }-- fn get_request(threads_mask: bool) -> MessageRequest {- MessageRequest::GetResponseById {- channel_id: "42".to_owned(),- message_id: "43".to_owned(),- viewer_user_id: "7".to_owned(),- source_guild_id: Some("9".to_owned()),- message_history_cutoff_ms: None,- can_read_message_history: true,- media_endpoint: "https://media.test".to_owned(),- media_proxy_secret_key: "secret".to_owned(),- attachment_url_secret_base64: None,- include_reactions: None,- attachment_decay: None,- nonce: None,- tts: None,- include_hidden: false,- threads_mask,- }- }-- #[test]- fn coalesce_key_separates_thread_masked_and_type_excluded_lists() {- let control = MessagesRouter::coalesce_key(&list_request(false, Vec::new()));- let masked = MessagesRouter::coalesce_key(&list_request(true, Vec::new()));- let excluded = MessagesRouter::coalesce_key(&list_request(false, vec![18]));- assert_ne!(control, masked);- assert_ne!(control, excluded);- assert_ne!(masked, excluded);- assert_ne!(- MessagesRouter::coalesce_key(&get_request(false)),- MessagesRouter::coalesce_key(&get_request(true))- );- }-- #[test]- fn coalesce_key_separates_attachment_decay_states() {- let mut list = list_request(false, Vec::new());- if let MessageRequest::ListResponses {- attachment_decay, ..- } = &mut list- {- *attachment_decay = Some(false);- }- let mut get = get_request(false);- if let MessageRequest::GetResponseById {- attachment_decay, ..- } = &mut get- {- *attachment_decay = Some(false);- }- assert_ne!(- MessagesRouter::coalesce_key(&list_request(false, Vec::new())),- MessagesRouter::coalesce_key(&list)- );- assert_ne!(- MessagesRouter::coalesce_key(&get_request(false)),- MessagesRouter::coalesce_key(&get)- );- }-}diff --git a/fluxer_messages/src/shard_impl.rs b/fluxer_messages/src/shard_impl.rsindex 18be9f787..10c4b7eed 100644--- a/fluxer_messages/src/shard_impl.rs+++ b/fluxer_messages/src/shard_impl.rs@@ -137,64 +137,6 @@ enum MessagesStorage {Scylla(Box<ScyllaMessagesStorage>),#[cfg(test)]Deletions(DeletedMessageKeys),- #[cfg(test)]- Memory(std::sync::Arc<Vec<Message>>),- #[cfg(test)]- Expiries(std::sync::Arc<HashMap<i64, DateTime<Utc>>>),-}--#[cfg(test)]-fn memory_buckets(- messages: &[Message],- channel_id: i64,- min_bucket: i32,- max_bucket: i32,- limit: u32,- descending: bool,-) -> Vec<i32> {- let mut buckets = messages- .iter()- .filter(|message| message.channel_id == channel_id)- .map(|message| snowflake_to_bucket(message.message_id))- .filter(|bucket| (min_bucket..=max_bucket).contains(bucket))- .collect::<Vec<_>>();- buckets.sort_unstable();- buckets.dedup();- if descending {- buckets.reverse();- }- buckets.truncate(limit as usize);- buckets-}--#[cfg(test)]-fn memory_bucket(- messages: &[Message],- channel_id: i64,- bucket: i32,- bound: Option<BucketBound>,- limit: i32,-) -> Vec<Message> {- let mut rows = messages- .iter()- .filter(|message| {- message.channel_id == channel_id- && snowflake_to_bucket(message.message_id) == bucket- && match bound {- Some(BucketBound::Before(id)) => message.message_id < id,- Some(BucketBound::After(id)) => message.message_id > id,- None => true,- }- })- .cloned()- .collect::<Vec<_>>();- if matches!(bound, Some(BucketBound::After(_))) {- rows.sort_unstable_by_key(|message| message.message_id);- } else {- rows.sort_unstable_by_key(|message| std::cmp::Reverse(message.message_id));- }- rows.truncate(limit.max(0) as usize);- rows}#[derive(Clone)]@@ -396,6 +338,7 @@ struct ResponseBuildOptions {threads_mask: bool,excluded_types: Vec<i32>,attachment_decay: bool,+ instance_name: String,}impl ResponseBuildOptions {@@ -648,71 +591,6 @@ impl<T: Transport> MessagesShard<T> {Ok(messages)}- async fn list_buckets_desc(- &self,- channel_id: i64,- min_bucket: i32,- max_bucket: i32,- limit: u32,- ) -> anyhow::Result<Vec<i32>> {- if min_bucket > max_bucket || limit == 0 {- return Ok(Vec::new());- }- self.storage- .list_buckets_desc(channel_id, min_bucket, max_bucket, limit)- .await- }-- async fn list_buckets_asc(- &self,- channel_id: i64,- min_bucket: i32,- max_bucket: i32,- limit: u32,- ) -> anyhow::Result<Vec<i32>> {- if min_bucket > max_bucket || limit == 0 {- return Ok(Vec::new());- }- self.storage- .list_buckets_asc(channel_id, min_bucket, max_bucket, limit)- .await- }-- async fn fetch_latest_bucket(- &self,- channel_id: i64,- bucket: i32,- limit: i32,- ) -> anyhow::Result<Vec<Message>> {- self.storage- .fetch_latest_bucket(channel_id, bucket, limit)- .await- }-- async fn fetch_before_bucket(- &self,- channel_id: i64,- bucket: i32,- before_id: i64,- limit: i32,- ) -> anyhow::Result<Vec<Message>> {- self.storage- .fetch_before_bucket(channel_id, bucket, before_id, limit)- .await- }-- async fn fetch_after_bucket(- &self,- channel_id: i64,- bucket: i32,- after_id: i64,- limit: i32,- ) -> anyhow::Result<Vec<Message>> {- self.storage- .fetch_after_bucket(channel_id, bucket, after_id, limit)- .await- }-async fn fetch_page(&self,channel_id: i64,@@ -1069,7 +947,8 @@ impl<T: Transport> MessagesShard<T> {}).chain(sources.values().filter_map(|(author_id, _)| *author_id)).collect::<HashSet<_>>();- self.load_user_partials(user_ids, users).await;+ self.load_user_partials(user_ids, &options.instance_name, users)+ .await;messages.iter().filter(|message| {@@ -1150,7 +1029,7 @@ impl<T: Transport> MessagesShard<T> {let reactions_future = self.fetch_reactions_for_messages(messages, options);let attachment_decay_future = self.fetch_attachment_decay(attachment_ids);let channel_mentions_future = self.resolve_channel_mentions(channel_ids, options);- let users_future = self.load_user_partials(user_ids, &mut users);+ let users_future = self.load_user_partials(user_ids, &options.instance_name, &mut users);let (reactions, attachment_decay, channel_mentions, ()) = tokio::join!(reactions_future,attachment_decay_future,@@ -1307,7 +1186,12 @@ impl<T: Transport> MessagesShard<T> {.await}- async fn load_user_partials(&self, user_ids: HashSet<i64>, users: &mut UserLookup) {+ async fn load_user_partials(+ &self,+ user_ids: HashSet<i64>,+ instance_name: &str,+ users: &mut UserLookup,+ ) {let mut missing = user_ids.into_iter().filter(|user_id| users.requested.insert(*user_id))@@ -1319,6 +1203,7 @@ impl<T: Transport> MessagesShard<T> {let payload = serde_json::json!({"op": "GetPartialsByIds","user_ids": missing,+ "instance_name": instance_name,});let payload_bytes = serde_json::to_vec(&payload).unwrap_or_default();let response = self@@ -1411,7 +1296,7 @@ impl<T: Transport> MessagesShard<T> {context: &ResponseContext,include_referenced_message: bool,) -> ApiMessageResponse {- let author = self.resolve_author(message, context);+ let author = self.resolve_author(message, options, context);let storage_channel_id = attachment_storage_channel_id(message);let attachments = message.attachments@@ -1546,13 +1431,18 @@ impl<T: Transport> MessagesShard<T> {}}- fn resolve_author(&self, message: &Message, context: &ResponseContext) -> ApiUserPartial {+ fn resolve_author(+ &self,+ message: &Message,+ options: &ResponseBuildOptions,+ context: &ResponseContext,+ ) -> ApiUserPartial {if let Some(author_id) = message.author_id {return context.users.get(&author_id).cloned()- .unwrap_or_else(|| deleted_user(author_id));+ .unwrap_or_else(|| deleted_user(author_id, &options.instance_name));}if let (Some(webhook_id), Some(webhook_name)) =(message.webhook_id, message.webhook_name.clone())@@ -1570,7 +1460,7 @@ impl<T: Transport> MessagesShard<T> {mention_flags: None,};}- deleted_user(0)+ deleted_user(0, &options.instance_name)}fn map_attachment(@@ -1865,14 +1755,7 @@ impl MessagesStorage {storage.get_by_id(channel_id, bucket, message_id).await}#[cfg(test)]- MessagesStorage::Deletions(_) | MessagesStorage::Expiries(_) => Ok(None),- #[cfg(test)]- MessagesStorage::Memory(messages) => Ok(messages- .iter()- .find(|message| {- message.channel_id == channel_id && message.message_id == message_id- })- .cloned()),+ MessagesStorage::Deletions(_) => Ok(None),}}@@ -1896,21 +1779,8 @@ impl MessagesStorage {.await}#[cfg(test)]- MessagesStorage::Deletions(_) | MessagesStorage::Expiries(_) => Ok(Vec::new()),- #[cfg(test)]- MessagesStorage::Memory(messages) => Ok(memory_buckets(- messages, channel_id, min_bucket, max_bucket, limit, true,- )),+ MessagesStorage::Deletions(_) => Ok(Vec::new()),}- }-- async fn list_buckets_asc(- &self,- channel_id: i64,- min_bucket: i32,- max_bucket: i32,- limit: u32,- ) -> anyhow::Result<Vec<i32>> {match self {MessagesStorage::Postgres(storage) => {storage@@ -1924,11 +1794,7 @@ impl MessagesStorage {.await}#[cfg(test)]- MessagesStorage::Deletions(_) | MessagesStorage::Expiries(_) => Ok(Vec::new()),- #[cfg(test)]- MessagesStorage::Memory(messages) => Ok(memory_buckets(- messages, channel_id, min_bucket, max_bucket, limit, false,- )),+ MessagesStorage::Deletions(_) => Ok(Vec::new()),}}@@ -1949,21 +1815,8 @@ impl MessagesStorage {storage.fetch_latest_bucket(channel_id, bucket, limit).await}#[cfg(test)]- MessagesStorage::Deletions(_) | MessagesStorage::Expiries(_) => Ok(Vec::new()),- #[cfg(test)]- MessagesStorage::Memory(messages) => {- Ok(memory_bucket(messages, channel_id, bucket, None, limit))- }+ MessagesStorage::Deletions(_) => Ok(Vec::new()),}- }-- async fn fetch_before_bucket(- &self,- channel_id: i64,- bucket: i32,- before_id: i64,- limit: i32,- ) -> anyhow::Result<Vec<Message>> {match self {MessagesStorage::Postgres(storage) => {storage@@ -1983,15 +1836,7 @@ impl MessagesStorage {.await}#[cfg(test)]- MessagesStorage::Deletions(_) | MessagesStorage::Expiries(_) => Ok(Vec::new()),- #[cfg(test)]- MessagesStorage::Memory(messages) => Ok(memory_bucket(- messages,- channel_id,- bucket,- Some(BucketBound::Before(before_id)),- limit,- )),+ MessagesStorage::Deletions(_) => Ok(Vec::new()),}}@@ -2021,15 +1866,7 @@ impl MessagesStorage {.await}#[cfg(test)]- MessagesStorage::Deletions(_) | MessagesStorage::Expiries(_) => Ok(Vec::new()),- #[cfg(test)]- MessagesStorage::Memory(messages) => Ok(memory_bucket(- messages,- channel_id,- bucket,- Some(BucketBound::After(after_id)),- limit,- )),+ MessagesStorage::Deletions(_) => Ok(Vec::new()),}}@@ -2055,8 +1892,6 @@ impl MessagesStorage {.push((channel_id, bucket, message_id));Ok(())}- #[cfg(test)]- MessagesStorage::Memory(_) | MessagesStorage::Expiries(_) => Ok(()),}}@@ -2090,9 +1925,7 @@ impl MessagesStorage {.await}#[cfg(test)]- MessagesStorage::Deletions(_)- | MessagesStorage::Memory(_)- | MessagesStorage::Expiries(_) => HashMap::new(),+ MessagesStorage::Deletions(_) => HashMap::new(),}}@@ -2109,12 +1942,7 @@ impl MessagesStorage {storage.fetch_attachment_decay_batch(attachment_ids).await}#[cfg(test)]- MessagesStorage::Deletions(_) | MessagesStorage::Memory(_) => Ok(HashMap::new()),- #[cfg(test)]- MessagesStorage::Expiries(expiries) => Ok(attachment_ids- .into_iter()- .filter_map(|id| expiries.get(&id).map(|expires_at| (id, *expires_at)))- .collect()),+ MessagesStorage::Deletions(_) => Ok(HashMap::new()),}}}@@ -2147,9 +1975,6 @@ impl PostgresMessagesStorage {limit: u32,desc: bool,) -> anyhow::Result<Vec<i32>> {- if min_bucket > max_bucket || limit == 0 {- return Ok(Vec::new());- }let partition_key = postgres::kv_key(&[KeyPart::BigInt(channel_id)])?;let mut buckets = self.kv@@ -2563,6 +2388,7 @@ impl<T: Transport> ShardService for MessagesShard<T> {tts,include_hidden,threads_mask,+ instance_name,} => {let channel_id = parse_i64(&channel_id, "channel_id")?;let message_id = parse_i64(&message_id, "message_id")?;@@ -2592,6 +2418,7 @@ impl<T: Transport> ShardService for MessagesShard<T> {include_hidden,threads_mask,excluded_types: Vec::new(),+ instance_name,},).await?;@@ -2615,6 +2442,7 @@ impl<T: Transport> ShardService for MessagesShard<T> {tts,include_hidden,threads_mask,+ instance_name,} => {let viewer_user_id = parse_i64(&viewer_user_id, "viewer_user_id")?;let source_guild_id = source_guild_id@@ -2641,6 +2469,7 @@ impl<T: Transport> ShardService for MessagesShard<T> {include_hidden,threads_mask,excluded_types: Vec::new(),+ instance_name,},).await?;@@ -2662,6 +2491,7 @@ impl<T: Transport> ShardService for MessagesShard<T> {attachment_decay,include_hidden,threads_mask,+ instance_name,} => {let viewer_user_id = parse_i64(&viewer_user_id, "viewer_user_id")?;let source_guild_id = source_guild_id@@ -2688,6 +2518,7 @@ impl<T: Transport> ShardService for MessagesShard<T> {include_hidden,threads_mask,excluded_types: Vec::new(),+ instance_name,},).await?;@@ -2711,6 +2542,7 @@ impl<T: Transport> ShardService for MessagesShard<T> {include_hidden,threads_mask,mut exclude_types,+ instance_name,} => {let channel_id = parse_i64(&channel_id, "channel_id")?;if threads_mask && !exclude_types.contains(&MESSAGE_TYPE_THREAD_CREATED) {@@ -2757,6 +2589,7 @@ impl<T: Transport> ShardService for MessagesShard<T> {include_hidden,threads_mask,excluded_types: exclude_types,+ instance_name,},).await?;@@ -3151,9 +2984,9 @@ fn map_user_partial(partial: UserPartialServiceResponse) -> ApiUserPartial {})}-fn deleted_user(user_id: i64) -> ApiUserPartial {+fn deleted_user(user_id: i64, instance_name: &str) -> ApiUserPartial {if user_id == FLUXER_SYSTEM_USER_ID {- return fluxer_system_user();+ return fluxer_system_user(instance_name.to_owned());}ApiUserPartial {id: user_id.to_string(),@@ -3663,51 +3496,9 @@ impl From<MessageDbRow> for Message {#[cfg(test)]mod tests {use super::*;- use fluxer_svc::transport::{- InMemoryTransport, TransportMessage, TransportSubscriber, reply_message,- };+ use fluxer_svc::transport::InMemoryTransport;use serde_json::json;- #[test]- fn missing_id_zero_fallback_is_fluxer_system_user() {- let mapped = deleted_user(0);-- assert_eq!(mapped.id, "0");- assert_eq!(mapped.username, "Fluxer");- assert_eq!(mapped.global_name, None);- assert_eq!(mapped.bot, Some(true));- assert_eq!(mapped.system, Some(true));- }-- #[test]- fn missing_regular_user_fallback_is_not_bot_or_system() {- let mapped = deleted_user(42);-- assert_eq!(mapped.id, "42");- assert_eq!(mapped.username, DELETED_USER_USERNAME);- assert_eq!(- mapped.global_name,- Some(DELETED_USER_GLOBAL_NAME.to_owned())- );- assert_eq!(mapped.bot, None);- assert_eq!(mapped.system, None);- }-- fn reaction(- user_id: i64,- emoji_id: i64,- emoji_name: &str,- created_at_ms: i64,- ) -> MessageReactionDbRow {- MessageReactionDbRow {- user_id,- emoji_id,- emoji_name: emoji_name.to_owned(),- emoji_animated: Some(false),- created_at: DateTime::<Utc>::from_timestamp_millis(created_at_ms),- }- }-#[test]fn postgres_message_decoder_maps_tagged_kv_payload() {let message = decode_postgres_message(json!({@@ -3789,44 +3580,6 @@ mod tests {assert_eq!(messages[0].version, 0);}- #[test]- fn mention_context_includes_embed_user_ids_for_message_and_snapshots() {- let message: Message = serde_json::from_value(json!({- "message_id": "10",- "channel_id": "20",- "bucket": 1,- "author_id": "30",- "type": 0,- "version": 0,- "content": "hello <@40>",- "mention_users": ["40"],- "embeds": [{- "title": "title <@50>",- "description": "description <@60>",- "footer": {"text": "footer <@70>"},- "fields": [{"name": "field <@80>", "value": "value <@90>"}]- }],- "message_snapshots": [{- "content": "snapshot <@100>",- "embeds": [{"description": "snapshot embed <@110>"}]- }]- }))- .unwrap();- let message_ref = &message;- let messages = std::slice::from_ref(&message_ref);-- let mention_context = build_message_mention_context(messages);- let entry = mention_context.get(&10).unwrap();-- assert_eq!(entry.content.users, HashSet::from([40]));- assert_eq!(entry.embed_users, HashSet::from([50, 60, 70, 80, 90, 110]));- assert_eq!(entry.snapshots[0].users, HashSet::from([100]));- assert_eq!(- collect_user_ids(messages, &mention_context),- HashSet::from([30, 40, 50, 60, 70, 80, 90, 100, 110])- );- }-#[test]fn postgres_reaction_decoder_maps_created_at() {let (message_id, reaction) = decode_postgres_reaction(json!({@@ -3848,97 +3601,6 @@ mod tests {);}- #[tokio::test]- async fn bucket_scan_stops_once_the_newest_buckets_fill_the_page() {- let buckets = (0..50).map(|index| 500 - index).collect::<Vec<i32>>();- let scanned = std::sync::Mutex::new(Vec::new());- let mut collected: Vec<i64> = Vec::new();-- collect_bucket_waves(&buckets, 50, &mut collected, |bucket| {- let scanned = &scanned;- async move {- scanned.lock().expect("scan log").push(bucket);- let rows = (0..200)- .map(|row| i64::from(bucket) * 1_000 + row)- .collect::<Vec<i64>>();- Ok(rows)- }- })- .await- .expect("bucket scan succeeds");-- let mut scanned = scanned.into_inner().expect("scan log");- scanned.sort_unstable_by(|left, right| right.cmp(left));- assert_eq!(scanned, buckets[..BUCKET_SCAN_WAVE]);-- let newest_skipped_id = i64::from(buckets[BUCKET_SCAN_WAVE]) * 1_000 + 199;- assert!(collected.iter().all(|id| *id > newest_skipped_id));- }-- #[tokio::test]- async fn bucket_scan_walks_the_whole_page_when_buckets_are_sparse() {- let buckets = (0..50).map(|index| 500 - index).collect::<Vec<i32>>();- let scanned = std::sync::Mutex::new(0_usize);- let mut collected: Vec<i64> = Vec::new();-- collect_bucket_waves(&buckets, 50, &mut collected, |bucket| {- let scanned = &scanned;- async move {- *scanned.lock().expect("scan count") += 1;- Ok(vec![i64::from(bucket)])- }- })- .await- .expect("bucket scan succeeds");-- assert_eq!(scanned.into_inner().expect("scan count"), buckets.len());- assert_eq!(collected.len(), buckets.len());- }-- #[test]- fn reference_with_no_stored_type_is_treated_as_a_reply_everywhere() {- let legacy = MessageReference {- channel_id: Some(1),- message_id: Some(2),- guild_id: None,- reference_type: None,- };- let explicit = MessageReference {- reference_type: Some(MESSAGE_REFERENCE_TYPE_DEFAULT),- ..legacy.clone()- };- let forward = MessageReference {- reference_type: Some(MESSAGE_REFERENCE_TYPE_DEFAULT + 1),- ..legacy.clone()- };-- assert_eq!(- effective_reference_type(&legacy),- MESSAGE_REFERENCE_TYPE_DEFAULT- );- assert_eq!(- effective_reference_type(&legacy),- effective_reference_type(&explicit)- );- assert_ne!(- effective_reference_type(&forward),- MESSAGE_REFERENCE_TYPE_DEFAULT- );-- let mapped = map_message_reference(&legacy).expect("legacy reference maps");- assert_eq!(mapped.reference_type, MESSAGE_REFERENCE_TYPE_DEFAULT);- }-- #[test]- fn around_window_limits_match_reference_api() {- assert_eq!(around_window_limits(0), (0, 0));- assert_eq!(around_window_limits(1), (0, 0));- assert_eq!(around_window_limits(2), (1, 0));- assert_eq!(around_window_limits(3), (1, 1));- assert_eq!(around_window_limits(50), (25, 24));- assert_eq!(around_window_limits(51), (25, 25));- }-#[test]fn epoch_bucket_matches_snowflake_bucket() {let message_id = 1_509_197_195_776_110_592;@@ -3955,122 +3617,6 @@ mod tests {assert_eq!(snowflake_to_bucket(1_509_256_674_043_502_592), 416);}- #[test]- fn embed_field_response_defaults_null_name_and_value_to_empty_strings() {- let response = map_embed_field_response(MessageEmbedField {- name: None,- value: None,- is_inline: None,- });-- assert_eq!(response.name, "");- assert_eq!(response.value, "");- assert!(!response.is_inline);- }-- #[test]- fn embed_media_response_hides_the_owned_attachment_flag() {- let shard = recording_shard(&DeletedMessageKeys::default());- let response = shard- .map_embed_media(- MessageEmbedMedia {- url: Some("https://media.example.com/attachments/1/2/a.png".to_owned()),- width: None,- height: None,- duration: None,- description: None,- content_type: None,- content_hash: None,- placeholder: None,- flags: Some(EMBED_MEDIA_OWNED_ATTACHMENT_FLAG | (1 << 3)),- },- &build_options(),- )- .unwrap();-- assert_eq!(response.flags, Some(1 << 3));- }-- #[test]- fn reactions_are_grouped_sorted_and_viewer_aware() {- let mapped = map_reactions(- vec![- reaction(10, 0, "z", 300),- reaction(11, 0, "a", 100),- reaction(12, 0, "a", 200),- reaction(11, 99, "party", 50),- ],- 12,- );- assert_eq!(mapped.len(), 3);- assert_eq!(mapped[0].emoji.id.as_deref(), Some("99"));- assert_eq!(mapped[0].emoji.name, "party");- assert_eq!(mapped[0].count, 1);- assert_eq!(mapped[1].emoji.name, "a");- assert_eq!(mapped[1].count, 2);- assert_eq!(mapped[1].me, Some(true));- assert_eq!(mapped[2].emoji.name, "z");- }-- #[test]- fn response_context_id_collection_spans_referenced_messages() {- let message = decode_postgres_message(json!({- "channel_id": {"__fluxer_type": "bigint", "value": "10"},- "bucket": 416,- "message_id": {"__fluxer_type": "bigint", "value": "100"},- "author_id": {"__fluxer_type": "bigint", "value": "1"},- "content": "hey <@2> over in <#20>",- "mention_users": {"__fluxer_type": "set", "value": [- {"__fluxer_type": "bigint", "value": "2"}- ]},- "mention_channels": {"__fluxer_type": "set", "value": [- {"__fluxer_type": "bigint", "value": "20"}- ]},- "attachments": [{- "attachment_id": {"__fluxer_type": "bigint", "value": "1000"},- "filename": "a.png"- }]- }))- .unwrap();- let referenced = decode_postgres_message(json!({- "channel_id": {"__fluxer_type": "bigint", "value": "10"},- "bucket": 416,- "message_id": {"__fluxer_type": "bigint", "value": "99"},- "author_id": {"__fluxer_type": "bigint", "value": "3"},- "content": "look at <#21>",- "mention_channels": {"__fluxer_type": "set", "value": [- {"__fluxer_type": "bigint", "value": "21"}- ]},- "attachments": [{- "attachment_id": {"__fluxer_type": "bigint", "value": "1001"},- "filename": "b.png"- }]- }))- .unwrap();- let messages = [message];- let referenced_messages: HashMap<(i64, i64), Message> =- [((10, 99), referenced)].into_iter().collect();-- let all_messages = messages- .iter()- .chain(referenced_messages.values())- .collect::<Vec<_>>();- let mention_context = build_message_mention_context(&all_messages);-- assert_eq!(- collect_attachment_ids(&all_messages),- HashSet::from([1000, 1001])- );- assert_eq!(- collect_channel_mention_ids(&all_messages, &mention_context),- HashSet::from([20, 21])- );- assert_eq!(- collect_user_ids(&all_messages, &mention_context),- HashSet::from([1, 2, 3])- );- }-fn recording_shard(deleted: &DeletedMessageKeys) -> MessagesShard<InMemoryTransport> {MessagesShard {storage: MessagesStorage::Deletions(deleted.clone()),@@ -4094,277 +3640,36 @@ mod tests {threads_mask: false,excluded_types: Vec::new(),attachment_decay: true,+ instance_name: "Fluxer".to_owned(),}}- fn orphaned_message(message_id: i64) -> Message {- decode_postgres_message(json!({- "channel_id": {"__fluxer_type": "bigint", "value": "10"},- "bucket": 416,- "message_id": {"__fluxer_type": "bigint", "value": message_id.to_string()},- "content": "orphan"- }))- .unwrap()- }-- fn webhook_message(message_id: i64) -> Message {- decode_postgres_message(json!({- "channel_id": {"__fluxer_type": "bigint", "value": "10"},- "bucket": 416,- "message_id": {"__fluxer_type": "bigint", "value": message_id.to_string()},- "webhook_id": {"__fluxer_type": "bigint", "value": "77"},- "webhook_name": "hook",- "content": "kept"- }))- .unwrap()- }+ const SIGNATURE_VECTORS: &str =+ include_str!("../../fluxer_common/src/testdata/attachment_url_signature_vectors.json");+ const SIGNED_CHANNEL_ID: i64 = 1_544_725_486_800_732_163;+ const SIGNED_ATTACHMENT_ID: i64 = 1_544_971_349_200_470_016;+ const SIGNED_FILENAME: &str = "cat.gif";+ const SIGNED_ANCHOR_SECS: u64 = 1_788_420_273;- fn authored_message(message_id: i64) -> Message {- decode_postgres_message(json!({- "channel_id": {"__fluxer_type": "bigint", "value": "10"},- "bucket": 416,- "message_id": {"__fluxer_type": "bigint", "value": message_id.to_string()},- "author_id": {"__fluxer_type": "bigint", "value": "1472426752046002208"},- "content": "kept"- }))- .unwrap()+ fn signing_options() -> ResponseBuildOptions {+ ResponseBuildOptions {+ media_endpoint: "https://media.test".to_owned(),+ attachment_url_secret: (0u8..32).collect(),+ ..build_options()+ }}- fn legacy_string_author_message(message_id: i64) -> Message {- decode_postgres_message(json!({- "channel_id": {"__fluxer_type": "bigint", "value": "10"},- "bucket": 416,- "message_id": {"__fluxer_type": "bigint", "value": message_id.to_string()},- "author_id": "1472426752046002208",- "content": "kept"+ fn signed_attachment() -> MessageAttachment {+ serde_json::from_value(json!({+ "attachment_id": SIGNED_ATTACHMENT_ID.to_string(),+ "filename": SIGNED_FILENAME,+ "size": 1024,})).unwrap()}- async fn stub_user_service(transport: &InMemoryTransport) -> tokio::task::JoinHandle<()> {- let mut subscriber = transport.subscribe("svc.users").await.unwrap();- let transport = transport.clone();- tokio::spawn(async move {- while let Some(message) = subscriber.next().await {- let _ = reply_message(&message, &transport, b"\"NotFound\"").await;- }- })- }-- fn recorded_deletions(deleted: &DeletedMessageKeys) -> Vec<(i64, i32, i64)> {- deleted.lock().unwrap().clone()- }-- #[tokio::test]- async fn build_path_keeps_authored_rows_from_older_releases() {- let deleted = DeletedMessageKeys::default();- let shard = recording_shard(&deleted);- let users = stub_user_service(&shard.transport).await;- let wrapped_id = 1_509_197_195_776_110_592;- let legacy_id = 1_509_197_195_776_110_593;-- let responses = shard- .build_api_responses_from_messages(- vec![- authored_message(wrapped_id),- legacy_string_author_message(legacy_id),- ],- build_options(),- )- .await- .unwrap();- users.abort();-- assert_eq!(responses.len(), 2);- assert_eq!(responses[0].id, wrapped_id.to_string());- assert_eq!(responses[1].id, legacy_id.to_string());- assert_eq!(responses[0].author.id, "1472426752046002208");- assert_eq!(responses[1].author.id, "1472426752046002208");- assert!(recorded_deletions(&deleted).is_empty());- }-- #[tokio::test]- async fn build_path_reaps_orphaned_messages() {- let deleted = DeletedMessageKeys::default();- let shard = recording_shard(&deleted);- let orphan_id = 1_509_197_195_776_110_592;- let kept_id = 1_509_197_195_776_110_593;-- let responses = shard- .build_api_responses_from_messages(- vec![orphaned_message(orphan_id), webhook_message(kept_id)],- build_options(),- )- .await- .unwrap();-- assert_eq!(responses.len(), 1);- assert_eq!(responses[0].id, kept_id.to_string());- assert_eq!(- recorded_deletions(&deleted),- vec![(10, snowflake_to_bucket(orphan_id), orphan_id)]- );- }-- #[tokio::test]- async fn build_path_reaps_orphans_of_each_batch_separately() {- let deleted = DeletedMessageKeys::default();- let shard = recording_shard(&deleted);- let first_orphan_id = 1_509_197_195_776_110_592;- let second_orphan_id = 1_509_197_195_776_110_594;-- shard- .build_api_responses_from_messages(- vec![- orphaned_message(first_orphan_id),- webhook_message(1_509_197_195_776_110_593),- ],- build_options(),- )- .await- .unwrap();- shard- .build_api_responses_from_messages(- vec![orphaned_message(second_orphan_id)],- build_options(),- )- .await- .unwrap();-- assert_eq!(- recorded_deletions(&deleted),- vec![- (10, snowflake_to_bucket(first_orphan_id), first_orphan_id),- (10, snowflake_to_bucket(second_orphan_id), second_orphan_id),- ]- );- }-- #[tokio::test]- async fn build_path_reaps_a_repeated_orphan_without_failing() {- let deleted = DeletedMessageKeys::default();- let shard = recording_shard(&deleted);- let orphan_id = 1_509_197_195_776_110_592;-- for _ in 0..2 {- let responses = shard- .build_api_responses_from_messages(- vec![orphaned_message(orphan_id)],- build_options(),- )- .await- .unwrap();- assert!(responses.is_empty());- }-- assert_eq!(- recorded_deletions(&deleted),- vec![- (10, snowflake_to_bucket(orphan_id), orphan_id),- (10, snowflake_to_bucket(orphan_id), orphan_id),- ]- );- }-- #[tokio::test]- async fn build_path_leaves_orphans_the_requester_cannot_see() {- let deleted = DeletedMessageKeys::default();- let shard = recording_shard(&deleted);- let orphan_id = 1_509_197_195_776_110_592;- let options = ResponseBuildOptions {- can_read_message_history: false,- message_history_cutoff_ms: Some(snowflake_to_epoch_millis(orphan_id) + 1),- ..build_options()- };-- let responses = shard- .build_api_responses_from_messages(vec![orphaned_message(orphan_id)], options)- .await- .unwrap();-- assert!(responses.is_empty());- assert!(recorded_deletions(&deleted).is_empty());- }-- #[tokio::test]- async fn single_build_path_reaps_an_orphaned_message() {- let deleted = DeletedMessageKeys::default();- let shard = recording_shard(&deleted);- let orphan_id = 1_509_197_195_776_110_592;- let kept_id = 1_509_197_195_776_110_593;-- let orphan_response = shard- .build_api_response_from_message(orphaned_message(orphan_id), build_options())- .await- .unwrap();- let kept_response = shard- .build_api_response_from_message(webhook_message(kept_id), build_options())- .await- .unwrap();-- assert!(orphan_response.is_none());- assert_eq!(kept_response.unwrap().id, kept_id.to_string());- assert_eq!(- recorded_deletions(&deleted),- vec![(10, snowflake_to_bucket(orphan_id), orphan_id)]- );- }-- #[tokio::test]- async fn single_build_path_leaves_an_orphan_the_requester_cannot_see() {- let deleted = DeletedMessageKeys::default();- let shard = recording_shard(&deleted);- let orphan_id = 1_509_197_195_776_110_592;- let options = ResponseBuildOptions {- can_read_message_history: false,- message_history_cutoff_ms: Some(snowflake_to_epoch_millis(orphan_id) + 1),- ..build_options()- };-- let response = shard- .build_api_response_from_message(orphaned_message(orphan_id), options)- .await- .unwrap();-- assert!(response.is_none());- assert!(recorded_deletions(&deleted).is_empty());- }-- const SIGNATURE_VECTORS: &str =- include_str!("../../fluxer_common/src/testdata/attachment_url_signature_vectors.json");- const SIGNED_CHANNEL_ID: i64 = 1_544_725_486_800_732_163;- const SIGNED_ATTACHMENT_ID: i64 = 1_544_971_349_200_470_016;- const SIGNED_FILENAME: &str = "cat.gif";- const SIGNED_ANCHOR_SECS: u64 = 1_788_420_273;-- fn signing_options() -> ResponseBuildOptions {- ResponseBuildOptions {- media_endpoint: "https://media.test".to_owned(),- attachment_url_secret: (0u8..32).collect(),- ..build_options()- }- }-- fn signed_attachment() -> MessageAttachment {- serde_json::from_value(json!({- "attachment_id": SIGNED_ATTACHMENT_ID.to_string(),- "filename": SIGNED_FILENAME,- "size": 1024,- }))- .unwrap()- }-- fn signed_storage_key() -> String {- make_attachment_cdn_key(SIGNED_CHANNEL_ID, SIGNED_ATTACHMENT_ID, SIGNED_FILENAME)- }-- fn unsigned_attachment_url(options: &ResponseBuildOptions) -> String {- make_attachment_cdn_url(- &options.media_endpoint,- SIGNED_CHANNEL_ID,- SIGNED_ATTACHMENT_ID,- SIGNED_FILENAME,- )+ fn signed_storage_key() -> String {+ make_attachment_cdn_key(SIGNED_CHANNEL_ID, SIGNED_ATTACHMENT_ID, SIGNED_FILENAME)}fn assert_signs(url: &str, unsigned_prefix: &str, options: &ResponseBuildOptions, now: u64) {@@ -4465,85 +3770,6 @@ mod tests {assert!(data_packages >= 1);}- #[test]- fn an_attachment_signs_url_and_proxy_url_identically() {- let deleted = DeletedMessageKeys::default();- let shard = recording_shard(&deleted);- let options = signing_options();- let mapped = shard- .map_attachment(- SIGNED_CHANNEL_ID,- &signed_attachment(),- &options,- &ResponseContext::default(),- )- .expect("an attachment with an id maps");-- let url = mapped.url.expect("a live attachment has a url");- assert_eq!(Some(url.clone()), mapped.proxy_url);- assert_signs(- &url,- &unsigned_attachment_url(&options),- &options,- unix_seconds(),- );- }-- #[test]- fn an_own_url_whose_filename_contains_a_slash_is_signed() {- let options = signing_options();- let now = SIGNED_ANCHOR_SECS + 10;- let key = "attachments/1544725486800732163/1544971349200470016/a/b.gif";-- for url in [- format!("{}/{key}", options.media_endpoint),- format!(- "{}/attachments/1544725486800732163/1544971349200470016/a%2Fb.gif",- options.media_endpoint- ),- ] {- let signed = media_proxy_url_at(&url, &options, now);- assert_eq!(- Some(format!("{url}?")),- signed.split_once("ex=").map(|(head, _)| head.to_owned()),- "{url}"- );- let query = signed.split_once('?').expect("a signed url has a query").1;- assert_eq!(- fluxer_common::attachment_url_signature::Verdict::Valid,- fluxer_common::attachment_url_signature::verify(- key,- Some(query),- &[&options.attachment_url_secret],- now,- )- .verdict,- "{url}"- );- }-- for refused in [- format!(- "{}/attachments/1544725486800732163/1544971349200470016/a//b.gif",- options.media_endpoint- ),- format!(- "{}/attachments/1544725486800732163/1544971349200470016/a/../b.gif",- options.media_endpoint- ),- format!(- "{}/attachments/1544725486800732163/1544971349200470016/a/",- options.media_endpoint- ),- ] {- assert_eq!(- refused,- media_proxy_url_at(&refused, &options, now),- "{refused}"- );- }- }-#[test]fn a_decayed_attachment_is_never_signed() {let deleted = DeletedMessageKeys::default();@@ -4568,115 +3794,6 @@ mod tests {assert_eq!(Some(true), mapped.expired);}- #[test]- fn attachment_expiry_is_only_looked_up_while_decay_is_on() {- let mut message = orphaned_message(1);- message.attachments = Some(vec![signed_attachment()]);- let off = ResponseBuildOptions {- attachment_decay: false,- ..build_options()- };-- assert_eq!(- HashSet::from([SIGNED_ATTACHMENT_ID]),- build_options().expiring_attachment_ids(&[&message])- );- assert!(off.expiring_attachment_ids(&[&message]).is_empty());- }-- #[tokio::test]- async fn a_passed_expiry_is_ignored_in_responses_while_decay_is_off() {- let shard = MessagesShard {- storage: MessagesStorage::Expiries(std::sync::Arc::new(HashMap::from([(- SIGNED_ATTACHMENT_ID,- DateTime::<Utc>::from_timestamp_millis(unix_millis() - 1_000).unwrap(),- )]))),- transport: InMemoryTransport::new(),- };- let users = stub_user_service(&shard.transport).await;- let mut message = authored_message(1_509_197_195_776_110_592);- message.attachments = Some(vec![signed_attachment()]);- let off = ResponseBuildOptions {- attachment_decay: false,- ..signing_options()- };-- let while_on = shard- .build_api_response_from_message(message.clone(), signing_options())- .await- .unwrap()- .expect("the message is visible");- let while_off = shard- .build_api_response_from_message(message.clone(), off.clone())- .await- .unwrap()- .expect("the message is visible");- let listed_while_off = shard- .build_api_responses_from_messages(vec![message], off)- .await- .unwrap();- users.abort();-- let expired = &while_on.attachments[0];- assert_eq!(Some(true), expired.expired);- assert_eq!(None, expired.url);- assert!(expired.expires_at.is_some());- for response in [&while_off, &listed_while_off[0]] {- let kept = &response.attachments[0];- assert_eq!(None, kept.expired);- assert_eq!(None, kept.expires_at);- assert!(kept.url.is_some());- }- }-- #[test]- fn an_attachment_backed_embed_signs_every_own_url_field() {- let deleted = DeletedMessageKeys::default();- let shard = recording_shard(&deleted);- let options = signing_options();- let unsigned = unsigned_attachment_url(&options);- let embed: MessageEmbed = serde_json::from_value(json!({- "type": "rich",- "url": unsigned,- "author": {"name": "author", "url": unsigned, "icon_url": unsigned},- "provider": {"name": "provider", "url": unsigned},- "footer": {"text": "footer", "icon_url": unsigned},- "image": {"url": unsigned},- "thumbnail": {"url": unsigned},- }))- .unwrap();-- let mapped = shard.map_embed(&embed, &options);-- let now = unix_seconds();- let base = mapped.base;- let author = base.author.expect("the embed has an author");- let provider = base.provider.expect("the embed has a provider");- let footer = base.footer.expect("the embed has a footer");- let image = base.image.expect("the embed has an image");- let thumbnail = base.thumbnail.expect("the embed has a thumbnail");- for signed in [- base.url.expect("the embed has a url"),- author.url.expect("the author has a url"),- author.icon_url.expect("the author has an icon url"),- author- .proxy_icon_url- .expect("the author has a proxy icon url"),- provider.url.expect("the provider has a url"),- footer.icon_url.expect("the footer has an icon url"),- footer- .proxy_icon_url- .expect("the footer has a proxy icon url"),- image.url.clone(),- image.proxy_url.clone(),- thumbnail.url,- thumbnail.proxy_url,- ] {- assert_signs(&signed, &unsigned, &options, now);- }- assert_eq!(image.url, image.proxy_url);- }-#[test]fn a_foreign_embed_url_is_never_rewritten() {let deleted = DeletedMessageKeys::default();@@ -4708,127 +3825,6 @@ mod tests {);}- #[test]- fn an_own_attachment_embed_url_is_signed_for_every_origin_spelling() {- let options = signing_options();- let now = SIGNED_ANCHOR_SECS;- for prefix in [- "https://media.test",- "https://MEDIA.test",- "https://Media.Test",- "https://media.test:443",- ] {- let input = format!("{prefix}/{}", signed_storage_key());- let signed = media_proxy_url_at(&input, &options, now);- assert_signs(&signed, &input, &options, now);- }- }-- #[test]- fn an_own_attachment_embed_url_keeps_its_transform_parameters_and_fragment() {- let options = signing_options();- let now = SIGNED_ANCHOR_SECS;- let input = format!(- "https://media.test/{}?width=64&format=webp#frame",- signed_storage_key()- );-- let signed = media_proxy_url_at(&input, &options, now);-- assert!(signed.ends_with("&width=64&format=webp#frame"), "{signed}");- assert!(!signed.contains("/external/"), "{signed}");- let query = signed- .split_once('?')- .expect("a signed url has a query")- .1- .split_once('#')- .expect("the fragment is kept")- .0;- assert_eq!(- fluxer_common::attachment_url_signature::Verdict::Valid,- fluxer_common::attachment_url_signature::verify(- &signed_storage_key(),- Some(query),- &[&options.attachment_url_secret],- now,- )- .verdict- );- }-- #[test]- fn an_own_endpoint_url_outside_attachments_passes_through_unsigned() {- let options = signing_options();- let now = SIGNED_ANCHOR_SECS;- for input in [- "https://media.test/emojis/1544725486800732163.webp",- "https://media.test/avatars/1/abc.png",- "https://media.test/stickers/1/abc.png",- "https://media.test/attachments/1544725486800732163",- "https://media.test/attachments/1544725486800732163/1544971349200470016",- "https://media.test/attachments/1544725486800732163/1544971349200470016/",- "https://media.test/attachments/1544725486800732163/not-a-snowflake/cat.gif",- ] {- assert_eq!(input, media_proxy_url_at(input, &options, now), "{input}");- }- }-- #[test]- fn a_foreign_url_is_still_wrapped_into_the_external_path() {- let options = signing_options();- let now = SIGNED_ANCHOR_SECS;- for input in [- "https://example.com/attachments/1544725486800732163/1544971349200470016/cat.gif",- "https://media.test.example.com/attachments/1/2/cat.gif",- "http://media.test/attachments/1/2/cat.gif",- "https://media.test:8443/attachments/1/2/cat.gif",- ] {- let wrapped = media_proxy_url_at(input, &options, now);- assert!(- wrapped.starts_with("https://media.test/external/"),- "{input}"- );- assert!(!wrapped.contains("ex="), "{input}");- }- }-- #[test]- fn an_absent_attachment_secret_leaves_every_url_unsigned() {- let deleted = DeletedMessageKeys::default();- let shard = recording_shard(&deleted);- let options = ResponseBuildOptions {- attachment_url_secret: Vec::new(),- ..signing_options()- };- let unsigned = unsigned_attachment_url(&options);-- let mapped = shard- .map_attachment(- SIGNED_CHANNEL_ID,- &signed_attachment(),- &options,- &ResponseContext::default(),- )- .expect("an attachment with an id maps");-- assert_eq!(Some(unsigned.clone()), mapped.url);- assert_eq!(Some(unsigned.clone()), mapped.proxy_url);- assert_eq!(- unsigned,- media_proxy_url_at(&unsigned, &options, SIGNED_ANCHOR_SECS)- );- assert_eq!(- unsigned,- attachment_cdn_url(- SIGNED_CHANNEL_ID,- SIGNED_ATTACHMENT_ID,- SIGNED_FILENAME,- &options,- SIGNED_ANCHOR_SECS- )- );- }-#[test]fn a_self_hosted_path_prefix_only_matches_whole_segments() {let options = ResponseBuildOptions {@@ -4848,33 +3844,6 @@ mod tests {);}- #[test]- fn a_percent_encoded_filename_signs_the_decoded_key() {- let options = signing_options();- let now = SIGNED_ANCHOR_SECS;- let encoded =- "https://media.test/attachments/1544725486800732163/1544971349200470016/caf%C3%A9.gif";- let decoded =- "https://media.test/attachments/1544725486800732163/1544971349200470016/café.gif";- let key = "attachments/1544725486800732163/1544971349200470016/café.gif";-- for input in [encoded, decoded] {- let signed = media_proxy_url_at(input, &options, now);- let query = signed.split_once('?').expect("a signed url has a query").1;- assert_eq!(- fluxer_common::attachment_url_signature::Verdict::Valid,- fluxer_common::attachment_url_signature::verify(- key,- Some(query),- &[&options.attachment_url_secret],- now,- )- .verdict,- "{input}"- );- }- }-#[test]fn a_percent_encoded_slash_signs_the_key_the_media_proxy_decodes() {let options = signing_options();@@ -4927,1095 +3896,4 @@ mod tests {assert_eq!(input, media_proxy_url_at(input, &options, now), "{input}");}}-- #[test]- fn a_request_without_the_secret_field_still_decodes() {- let request: MessageRequest = serde_json::from_value(json!({- "op": "ListResponses",- "channel_id": "10",- "viewer_user_id": "1",- "limit": 50,- "can_read_message_history": true,- "media_endpoint": "https://media.test",- "media_proxy_secret_key": "secret",- }))- .expect("an older caller omits the attachment secret");-- match request {- MessageRequest::ListResponses {- attachment_url_secret_base64,- ..- } => assert_eq!(None, attachment_url_secret_base64),- other => panic!("unexpected request {other:?}"),- }- }-- #[test]- fn a_secret_that_is_not_base64_disables_signing() {- assert!(decode_attachment_url_secret(None).is_empty());- assert!(decode_attachment_url_secret(Some("")).is_empty());- assert!(decode_attachment_url_secret(Some("not base64!")).is_empty());- assert_eq!(- (0u8..32).collect::<Vec<u8>>(),- decode_attachment_url_secret(Some("AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8="))- );- }-- fn typed_message(message_id: i64, message_type: i32, flags: i64) -> Message {- serde_json::from_value(json!({- "message_id": message_id.to_string(),- "channel_id": "10",- "bucket": 416,- "author_id": "1472426752046002208",- "type": message_type,- "flags": flags,- "version": 1- }))- .unwrap()- }-- fn masked_options() -> ResponseBuildOptions {- ResponseBuildOptions {- threads_mask: true,- ..build_options()- }- }-- #[tokio::test]- async fn excluded_types_refill_the_page_past_hidden_rows() {- let channel = [- (100, 18),- (99, 0),- (98, 18),- (97, 18),- (96, 0),- (95, 0),- (94, 0),- ]- .map(|(id, message_type)| typed_message(id, message_type, 0));- let fetches = std::sync::Mutex::new(Vec::new());-- let collected = collect_excluding(3, &[18], None, |cursor, size| {- let fetches = &fetches;- let channel = &channel;- async move {- fetches.lock().unwrap().push((cursor, size));- Ok(channel- .iter()- .filter(|message| cursor.is_none_or(|cursor| message.message_id < cursor))- .take(size as usize)- .cloned()- .collect())- }- })- .await- .unwrap();-- assert_eq!(- collected.iter().map(|m| m.message_id).collect::<Vec<_>>(),- vec![99, 96, 95]- );- assert_eq!(- *fetches.lock().unwrap(),- vec![(None, 3), (Some(98), EXCLUDED_TYPE_REFILL_PAGE_SIZE)]- );- }-- #[tokio::test]- async fn excluded_types_stop_at_the_end_of_the_channel() {- let channel = [(100, 18), (99, 0), (98, 18)]- .map(|(id, message_type)| typed_message(id, message_type, 0));- let fetches = std::sync::Mutex::new(0_usize);-- let collected = collect_excluding(2, &[18], None, |cursor, size| {- let fetches = &fetches;- let channel = &channel;- async move {- *fetches.lock().unwrap() += 1;- Ok(channel- .iter()- .filter(|message| cursor.is_none_or(|cursor| message.message_id < cursor))- .take(size as usize)- .cloned()- .collect())- }- })- .await- .unwrap();-- assert_eq!(- collected.iter().map(|m| m.message_id).collect::<Vec<_>>(),- vec![99]- );- assert_eq!(*fetches.lock().unwrap(), 2);- }-- #[tokio::test]- async fn excluded_types_reach_past_a_long_hidden_run() {- let channel = (0..3_000_i64)- .map(|offset| typed_message(10_000 - offset, 18, 0))- .chain([typed_message(6_999, 0, 0), typed_message(6_998, 0, 0)])- .collect::<Vec<_>>();-- let collected = collect_excluding(2, &[18], None, |cursor, size| {- let channel = &channel;- async move {- Ok(channel- .iter()- .filter(|message| cursor.is_none_or(|cursor| message.message_id < cursor))- .take(size as usize)- .cloned()- .collect())- }- })- .await- .unwrap();-- assert_eq!(- collected.iter().map(|m| m.message_id).collect::<Vec<_>>(),- vec![6_999, 6_998]- );- }-- #[tokio::test]- async fn excluded_types_stop_at_the_scan_row_cap() {- let scanned = std::sync::Mutex::new(0_usize);-- let collected = collect_excluding(2, &[18], None, |cursor, size| {- let scanned = &scanned;- async move {- *scanned.lock().unwrap() += size as usize;- let top = cursor.unwrap_or(1_000_000);- Ok((1..=i64::from(size))- .map(|offset| typed_message(top - offset, 18, 0))- .collect())- }- })- .await- .unwrap();-- assert!(collected.is_empty());- let scanned = *scanned.lock().unwrap();- assert!(scanned >= EXCLUDED_TYPE_SCAN_ROW_CAP);- assert!(scanned < EXCLUDED_TYPE_SCAN_ROW_CAP + EXCLUDED_TYPE_REFILL_PAGE_SIZE as usize);- }-- const LISTED_BASE_ID: i64 = 1_509_197_195_776_110_592;-- async fn listed_ids(- types: &[i32],- limit: u32,- before: Option<i64>,- after: Option<i64>,- around: Option<i64>,- excluded_types: &[i32],- ) -> Vec<i64> {- let rows = types- .iter()- .enumerate()- .map(|(index, message_type)| {- typed_message(LISTED_BASE_ID + index as i64 + 1, *message_type, 0)- })- .collect::<Vec<_>>();- let shard = MessagesShard {- storage: MessagesStorage::Memory(std::sync::Arc::new(rows)),- transport: InMemoryTransport::new(),- };- let users = stub_user_service(&shard.transport).await;- let at = |offset: i64| LISTED_BASE_ID + offset;- let responses = shard- .list_api_responses(- 10,- limit,- before.map(at),- after.map(at),- around.map(at),- ResponseBuildOptions {- excluded_types: excluded_types.to_vec(),- ..build_options()- },- )- .await- .unwrap();- users.abort();- responses- .iter()- .map(|response| response.id.parse::<i64>().unwrap() - LISTED_BASE_ID)- .collect()- }-- #[tokio::test]- async fn excluded_types_list_the_latest_page_past_hidden_rows() {- let types = [0, 0, 18, 0, 18, 18, 0, 18];-- assert_eq!(- listed_ids(&types, 3, None, None, None, &[18]).await,- [7, 4, 2]- );- assert_eq!(- listed_ids(&types, 3, None, None, None, &[]).await,- [8, 7, 6]- );- }-- #[tokio::test]- async fn excluded_types_list_after_an_id_in_ascending_pages() {- let types = [18, 18, 18, 0, 18, 0, 0, 0];-- assert_eq!(- listed_ids(&types, 3, None, Some(0), None, &[18]).await,- [7, 6, 4]- );- assert_eq!(- listed_ids(&types, 3, None, Some(0), None, &[]).await,- [3, 2, 1]- );- }-- #[tokio::test]- async fn excluded_types_keep_a_before_and_after_window_inside_its_bounds() {- let types = [0, 0, 0, 18, 0, 18, 18, 0];-- assert_eq!(- listed_ids(&types, 3, Some(9), Some(1), None, &[18]).await,- [8, 5, 3]- );- assert_eq!(- listed_ids(&types, 3, Some(9), Some(4), None, &[18]).await,- [8, 5]- );- assert_eq!(- listed_ids(&types, 3, Some(9), Some(1), None, &[]).await,- [8, 7, 6]- );- }-- #[tokio::test]- async fn excluded_types_drop_a_hidden_around_target_and_refill_both_sides() {- let types = [0, 0, 18, 0, 18, 0, 18, 0, 0];-- assert_eq!(- listed_ids(&types, 5, None, None, Some(5), &[18]).await,- [8, 6, 4, 2]- );- assert_eq!(- listed_ids(&types, 5, None, None, Some(5), &[]).await,- [7, 6, 5, 4, 3]- );- }-- #[tokio::test]- async fn threads_mask_drops_thread_created_rows_and_clears_thread_flags() {- let deleted = DeletedMessageKeys::default();- let shard = recording_shard(&deleted);- let users = stub_user_service(&shard.transport).await;- let mut forwarded = typed_message(1_509_197_195_776_110_594, 0, 0x120 | 0x4);- forwarded.message_snapshots = Some(vec![- serde_json::from_value(json!({"content": "x", "type": 0, "flags": 0x124})).unwrap(),- ]);- let messages = vec![- forwarded,- typed_message(1_509_197_195_776_110_593, MESSAGE_TYPE_THREAD_CREATED, 0),- ];-- let masked = shard- .build_api_responses_from_messages(messages.clone(), masked_options())- .await- .unwrap();- let control = shard- .build_api_responses_from_messages(messages, build_options())- .await- .unwrap();- users.abort();-- assert_eq!(masked.len(), 1);- assert_eq!(masked[0].flags, 0x4);- assert_eq!(masked[0].message_snapshots.as_ref().unwrap()[0].flags, 0x4);- assert_eq!(control.len(), 2);- assert_eq!(control[0].flags, 0x124);- assert_eq!(- control[0].message_snapshots.as_ref().unwrap()[0].flags,- 0x124- );- assert_eq!(control[1].message_type, MESSAGE_TYPE_THREAD_CREATED);- assert!(recorded_deletions(&deleted).is_empty());- }-- #[tokio::test]- async fn threads_mask_drops_a_single_thread_created_row() {- let deleted = DeletedMessageKeys::default();- let shard = recording_shard(&deleted);- let users = stub_user_service(&shard.transport).await;- let starter = typed_message(1_509_197_195_776_110_593, MESSAGE_TYPE_THREAD_CREATED, 0);-- let masked = shard- .build_api_response_from_message(starter.clone(), masked_options())- .await- .unwrap();- let control = shard- .build_api_response_from_message(starter, build_options())- .await- .unwrap();- users.abort();-- assert!(masked.is_none());- assert!(control.is_some());- }-- #[test]- fn threads_mask_clears_nested_referenced_flags_and_nulls_a_thread_created_reference() {- let shard = recording_shard(&DeletedMessageKeys::default());- let reply_to = |target: i64| {- let mut reply = typed_message(1_509_197_195_776_110_600, 19, 0x20);- reply.message_reference = Some(MessageReference {- channel_id: Some(10),- message_id: Some(target),- guild_id: None,- reference_type: Some(0),- });- reply- };- let referenced = typed_message(1_509_197_195_776_110_590, 0, 0x120);- let thread_created =- typed_message(1_509_197_195_776_110_591, MESSAGE_TYPE_THREAD_CREATED, 0);- let context = ResponseContext {- referenced_messages: HashMap::from([- ((10, referenced.message_id), referenced.clone()),- ((10, thread_created.message_id), thread_created.clone()),- ]),- ..ResponseContext::default()- };-- let masked = shard.map_message_response(- &reply_to(referenced.message_id),- &masked_options(),- &context,- true,- );- assert_eq!(masked.flags, 0);- let nested = masked.referenced_message.unwrap().unwrap();- assert_eq!(nested.flags, 0);-- let control = shard.map_message_response(- &reply_to(referenced.message_id),- &build_options(),- &context,- true,- );- assert_eq!(control.flags, 0x20);- assert_eq!(control.referenced_message.unwrap().unwrap().flags, 0x120);-- let masked_starter = shard.map_message_response(- &reply_to(thread_created.message_id),- &masked_options(),- &context,- true,- );- assert!(matches!(masked_starter.referenced_message, Some(None)));- let control_starter = shard.map_message_response(- &reply_to(thread_created.message_id),- &build_options(),- &context,- true,- );- assert!(matches!(control_starter.referenced_message, Some(Some(_))));- }-- #[test]- fn thread_options_default_to_off_for_older_callers() {- let list: MessageRequest = serde_json::from_value(json!({- "op": "ListResponses",- "channel_id": "10",- "viewer_user_id": "1",- "limit": 50,- "can_read_message_history": true,- "media_endpoint": "https://media.test",- "media_proxy_secret_key": "secret",- }))- .unwrap();- match list {- MessageRequest::ListResponses {- threads_mask,- exclude_types,- ..- } => {- assert!(!threads_mask);- assert!(exclude_types.is_empty());- }- other => panic!("unexpected request {other:?}"),- }- let get: MessageRequest = serde_json::from_value(json!({- "op": "GetResponseById",- "channel_id": "10",- "message_id": "11",- "viewer_user_id": "1",- "can_read_message_history": true,- "media_endpoint": "https://media.test",- "media_proxy_secret_key": "secret",- }))- .unwrap();- match get {- MessageRequest::GetResponseById { threads_mask, .. } => assert!(!threads_mask),- other => panic!("unexpected request {other:?}"),- }- let options = build_options();- assert_eq!(options.mask_flags(0x1ff), 0x1ff);- assert!(!options.hides(&typed_message(1, MESSAGE_TYPE_THREAD_CREATED, 0)));- }-- #[test]- fn a_reference_without_a_message_id_round_trips() {- let message: Message = serde_json::from_value(json!({- "message_id": "1509197195776110592",- "channel_id": "10",- "bucket": 416,- "author_id": "1472426752046002208",- "type": MESSAGE_TYPE_THREAD_CREATED,- "version": 1,- "message_reference": {"channel_id": "1509197195776110500", "guild_id": "7", "type": 0}- }))- .unwrap();- let reference = message.message_reference.as_ref().unwrap();- assert_eq!(reference.message_id, None);-- let mapped = map_message_reference(reference).expect("a thread reference maps");- assert_eq!(mapped.message_id, None);- let encoded = serde_json::to_value(&mapped).unwrap();- assert_eq!(- encoded,- json!({"channel_id": "1509197195776110500", "guild_id": "7", "type": 0})- );- let decoded: ApiMessageReferenceResponse = serde_json::from_value(encoded).unwrap();- assert_eq!(decoded.message_id, None);-- let shard = recording_shard(&DeletedMessageKeys::default());- let response = shard.map_message_response(- &message,- &build_options(),- &ResponseContext::default(),- true,- );- assert!(response.referenced_message.is_none());- let packed = rmp_serde::to_vec_named(&response).unwrap();- let unpacked: ApiMessageResponse = rmp_serde::from_slice(&packed).unwrap();- let unpacked_reference = unpacked.message_reference.unwrap();- assert_eq!(unpacked_reference.message_id, None);- assert_eq!(unpacked_reference.channel_id, "1509197195776110500");-- let reply = MessageReference {- channel_id: Some(1),- message_id: Some(2),- guild_id: None,- reference_type: None,- };- assert_eq!(- serde_json::to_value(map_message_reference(&reply).unwrap()).unwrap(),- json!({"channel_id": "1", "message_id": "2", "type": 0})- );- }-- async fn stub_channel_mentions(- transport: &InMemoryTransport,- payloads: std::sync::Arc<std::sync::Mutex<Vec<serde_json::Value>>>,- ) -> tokio::task::JoinHandle<()> {- let mut subscriber = transport- .subscribe("rpc.gateway.guild.resolve_channel_mentions")- .await- .unwrap();- let transport = transport.clone();- tokio::spawn(async move {- while let Some(message) = subscriber.next().await {- payloads- .lock()- .unwrap()- .push(serde_json::from_slice(TransportMessage::payload(&message)).unwrap());- let reply = json!({"ok": true, "result": {"channels": [- {"id": "20", "name": "general", "type": 0},- {"id": "21", "name": "thread", "type": 11},- {"id": "22", "name": "forum", "type": 15},- {"id": "23", "name": "news-thread", "type": 10}- ]}});- let _ = reply_message(&message, &transport, reply.to_string().as_bytes()).await;- }- })- }-- #[tokio::test]- async fn threads_mask_excludes_thread_channels_from_mention_resolution() {- let shard = recording_shard(&DeletedMessageKeys::default());- let payloads = std::sync::Arc::new(std::sync::Mutex::new(Vec::new()));- let stub = stub_channel_mentions(&shard.transport, payloads.clone()).await;- let ids = HashSet::from([20, 21, 22, 23]);-- let masked = shard- .resolve_channel_mentions(- ids.clone(),- &ResponseBuildOptions {- source_guild_id: Some(7),- ..masked_options()- },- )- .await;- let control = shard- .resolve_channel_mentions(- ids,- &ResponseBuildOptions {- source_guild_id: Some(7),- ..build_options()- },- )- .await;- stub.abort();-- let mut masked_ids = masked.into_keys().collect::<Vec<_>>();- masked_ids.sort();- assert_eq!(masked_ids, vec!["20"]);- assert_eq!(control.len(), 4);- assert_eq!(control["23"].channel_type, 10);- let payloads = payloads.lock().unwrap();- assert_eq!(payloads[0]["exclude_thread_channels"], json!(true));- assert!(payloads[1].get("exclude_thread_channels").is_none());- }-- const CROSSPOST_SOURCE_CHANNEL_ID: i64 = 500;- const CROSSPOST_SOURCE_GUILD_ID: i64 = 600;- const CROSSPOST_SOURCE_MESSAGE_ID: i64 = 1_509_197_195_776_110_590;-- fn referencing_message(message_type: i32, flags: i64, reference: serde_json::Value) -> Message {- decode_postgres_message(json!({- "channel_id": {"__fluxer_type": "bigint", "value": "10"},- "bucket": 416,- "message_id": {"__fluxer_type": "bigint", "value": "1509197195776110600"},- "webhook_id": {"__fluxer_type": "bigint", "value": "77"},- "webhook_name": "Source #news",- "type": message_type,- "flags": flags,- "content": "published",- "message_reference": reference- }))- .unwrap()- }-- fn source_reference() -> serde_json::Value {- json!({- "channel_id": CROSSPOST_SOURCE_CHANNEL_ID.to_string(),- "message_id": CROSSPOST_SOURCE_MESSAGE_ID.to_string(),- "guild_id": CROSSPOST_SOURCE_GUILD_ID.to_string(),- "type": MESSAGE_REFERENCE_TYPE_DEFAULT- })- }-- fn source_message() -> Message {- decode_postgres_message(json!({- "channel_id": {"__fluxer_type": "bigint", "value": CROSSPOST_SOURCE_CHANNEL_ID.to_string()},- "bucket": 416,- "message_id": {"__fluxer_type": "bigint", "value": CROSSPOST_SOURCE_MESSAGE_ID.to_string()},- "author_id": {"__fluxer_type": "bigint", "value": "1472426752046002208"},- "flags": 1,- "content": "published"- }))- .unwrap()- }-- fn context_with_source() -> ResponseContext {- ResponseContext {- referenced_messages: [(- (CROSSPOST_SOURCE_CHANNEL_ID, CROSSPOST_SOURCE_MESSAGE_ID),- source_message(),- )]- .into_iter()- .collect(),- ..ResponseContext::default()- }- }-- fn serialized_response(message: &Message, context: &ResponseContext) -> serde_json::Value {- let deleted = DeletedMessageKeys::default();- let shard = recording_shard(&deleted);- serde_json::to_value(shard.map_message_response(message, &build_options(), context, true))- .expect("response serialises")- }-- fn signed_attachment_response(message: &Message) -> serde_json::Value {- let deleted = DeletedMessageKeys::default();- let shard = recording_shard(&deleted);- let response = serde_json::to_value(shard.map_message_response(- message,- &signing_options(),- &ResponseContext::default(),- true,- ))- .expect("response serialises");- response["attachments"][0].clone()- }-- fn assert_attachment_signed_for_channel(attachment: &serde_json::Value, channel_id: i64) {- let options = signing_options();- let storage_key =- make_attachment_cdn_key(channel_id, SIGNED_ATTACHMENT_ID, SIGNED_FILENAME);- let unsigned = make_attachment_cdn_url(- &options.media_endpoint,- channel_id,- SIGNED_ATTACHMENT_ID,- SIGNED_FILENAME,- );- let url = attachment["url"]- .as_str()- .expect("a live attachment has a url");- assert_eq!(attachment["proxy_url"], attachment["url"]);- assert_eq!(attachment["id"], json!(SIGNED_ATTACHMENT_ID.to_string()));- assert_eq!(- Some(format!("{unsigned}?")),- url.split_once("ex=").map(|(head, _)| head.to_owned()),- "{url}"- );- let query = url.split_once('?').expect("a signed url has a query").1;- assert_eq!(- fluxer_common::attachment_url_signature::Verdict::Valid,- fluxer_common::attachment_url_signature::verify(- &storage_key,- Some(query),- &[&options.attachment_url_secret],- unix_seconds(),- )- .verdict,- "{url}"- );- }-- #[test]- fn crosspost_copy_attachment_urls_point_at_the_source_channel() {- let mut copy = referencing_message(0, MESSAGE_FLAG_IS_CROSSPOST, source_reference());- copy.attachments = Some(vec![signed_attachment()]);-- assert_eq!(- attachment_storage_channel_id(©),- CROSSPOST_SOURCE_CHANNEL_ID- );- let attachment = signed_attachment_response(©);- assert_attachment_signed_for_channel(&attachment, CROSSPOST_SOURCE_CHANNEL_ID);- assert!(- !attachment["url"]- .as_str()- .unwrap()- .contains(&format!("/attachments/{}/", copy.channel_id)),- "{attachment}"- );- }-- #[test]- fn a_message_without_the_copy_flag_keeps_its_own_channel_for_attachments() {- for message in [- referencing_message(19, 0, source_reference()),- referencing_message(0, 0, source_reference()),- webhook_message(1_509_197_195_776_110_600),- ] {- let mut message = message;- message.attachments = Some(vec![signed_attachment()]);- assert_eq!(attachment_storage_channel_id(&message), message.channel_id);- let attachment = signed_attachment_response(&message);- assert_attachment_signed_for_channel(&attachment, message.channel_id);- }- }-- #[test]- fn a_copy_without_a_reference_channel_falls_back_to_its_own_channel() {- let mut copy = referencing_message(0, MESSAGE_FLAG_IS_CROSSPOST, source_reference());- copy.message_reference = None;- copy.attachments = Some(vec![signed_attachment()]);-- assert_eq!(attachment_storage_channel_id(©), copy.channel_id);- let attachment = signed_attachment_response(©);- assert_attachment_signed_for_channel(&attachment, copy.channel_id);- }-- #[tokio::test]- async fn crosspost_copy_omits_referenced_message_and_requests_no_fetch() {- let copy = referencing_message(0, MESSAGE_FLAG_IS_CROSSPOST, source_reference());-- assert_eq!(reply_target(©), None);- let deleted = DeletedMessageKeys::default();- let shard = recording_shard(&deleted);- let fetched = shard- .fetch_referenced_messages(std::slice::from_ref(©), &build_options())- .await;- assert!(fetched.is_empty());-- let response = serialized_response(©, &context_with_source());- let object = response.as_object().expect("response is an object");- assert!(!object.contains_key("referenced_message"));- assert_eq!(- response["message_reference"],- json!({- "channel_id": CROSSPOST_SOURCE_CHANNEL_ID.to_string(),- "message_id": CROSSPOST_SOURCE_MESSAGE_ID.to_string(),- "guild_id": CROSSPOST_SOURCE_GUILD_ID.to_string(),- "type": MESSAGE_REFERENCE_TYPE_DEFAULT- })- );- assert_eq!(response["flags"], json!(MESSAGE_FLAG_IS_CROSSPOST));- }-- #[test]- fn crosspost_copy_with_other_flags_still_omits_referenced_message() {- let copy = referencing_message(- 0,- MESSAGE_FLAG_IS_CROSSPOST | MESSAGE_FLAG_SUPPRESS_EMBEDS | (1 << 3),- source_reference(),- );-- assert_eq!(reply_target(©), None);- let response = serialized_response(©, &context_with_source());- assert!(response.get("referenced_message").is_none());- }-- #[test]- fn reply_with_the_same_reference_still_resolves() {- let reply = referencing_message(19, 0, source_reference());-- assert_eq!(- reply_target(&reply),- Some((CROSSPOST_SOURCE_CHANNEL_ID, CROSSPOST_SOURCE_MESSAGE_ID))- );- let response = serialized_response(&reply, &context_with_source());- assert_eq!(- response["referenced_message"]["id"],- json!(CROSSPOST_SOURCE_MESSAGE_ID.to_string())- );- assert_eq!(- response["referenced_message"]["content"],- json!("published")- );- }-- #[test]- fn reply_whose_target_is_missing_serialises_referenced_message_null() {- let reply = referencing_message(19, 0, source_reference());-- let response = serialized_response(&reply, &ResponseContext::default());- assert_eq!(- response.get("referenced_message"),- Some(&serde_json::Value::Null)- );- }-- #[tokio::test]- async fn follow_add_reference_without_message_id_keeps_channel_and_guild() {- let follow_add = referencing_message(- 12,- 0,- json!({- "channel_id": CROSSPOST_SOURCE_CHANNEL_ID.to_string(),- "guild_id": CROSSPOST_SOURCE_GUILD_ID.to_string(),- "type": MESSAGE_REFERENCE_TYPE_DEFAULT- }),- );-- assert_eq!(reply_target(&follow_add), None);- let deleted = DeletedMessageKeys::default();- let shard = recording_shard(&deleted);- let fetched = shard- .fetch_referenced_messages(std::slice::from_ref(&follow_add), &build_options())- .await;- assert!(fetched.is_empty());-- let response = serialized_response(&follow_add, &context_with_source());- assert_eq!(response["type"], json!(12));- assert!(response.get("referenced_message").is_none());- assert_eq!(- response["message_reference"],- json!({- "channel_id": CROSSPOST_SOURCE_CHANNEL_ID.to_string(),- "guild_id": CROSSPOST_SOURCE_GUILD_ID.to_string(),- "type": MESSAGE_REFERENCE_TYPE_DEFAULT- })- );- }-- #[test]- fn map_message_reference_emits_every_field_for_a_copy() {- let mapped = map_message_reference(&MessageReference {- channel_id: Some(CROSSPOST_SOURCE_CHANNEL_ID),- message_id: Some(CROSSPOST_SOURCE_MESSAGE_ID),- guild_id: Some(CROSSPOST_SOURCE_GUILD_ID),- reference_type: Some(MESSAGE_REFERENCE_TYPE_DEFAULT),- })- .expect("copy reference maps");-- assert_eq!(mapped.channel_id, CROSSPOST_SOURCE_CHANNEL_ID.to_string());- assert_eq!(- mapped.message_id,- Some(CROSSPOST_SOURCE_MESSAGE_ID.to_string())- );- assert_eq!(mapped.guild_id, Some(CROSSPOST_SOURCE_GUILD_ID.to_string()));- assert_eq!(mapped.reference_type, MESSAGE_REFERENCE_TYPE_DEFAULT);- }-- #[test]- fn map_message_reference_still_requires_a_channel_id() {- let mapped = map_message_reference(&MessageReference {- channel_id: None,- message_id: Some(CROSSPOST_SOURCE_MESSAGE_ID),- guild_id: Some(CROSSPOST_SOURCE_GUILD_ID),- reference_type: None,- });-- assert!(mapped.is_none());- }-- const HIDDEN_AUTHOR: i64 = 1_472_426_752_046_002_301;- const OTHER_AUTHOR: i64 = 1_472_426_752_046_002_302;- const CHANNEL: i64 = 10;- const WINDOW_MS: i64 = 1_790_000_000_000;-- fn snowflake_at(epoch_millis: i64, sequence: i64) -> i64 {- ((epoch_millis - FLUXER_EPOCH_MS) << 22) | sequence- }-- fn message_by(author_id: i64, message_id: i64, extra: serde_json::Value) -> Message {- let mut row = json!({- "channel_id": {"__fluxer_type": "bigint", "value": CHANNEL.to_string()},- "bucket": snowflake_to_bucket(message_id),- "message_id": {"__fluxer_type": "bigint", "value": message_id.to_string()},- "author_id": {"__fluxer_type": "bigint", "value": author_id.to_string()},- "content": format!("message {message_id}"),- });- row.as_object_mut()- .unwrap()- .extend(extra.as_object().unwrap().clone());- decode_postgres_message(row).unwrap()- }-- async fn user_service(- transport: &InMemoryTransport,- hidden_since: Option<i64>,- ) -> tokio::task::JoinHandle<()> {- let mut subscriber = transport.subscribe("svc.users").await.unwrap();- let transport = transport.clone();- tokio::spawn(async move {- while let Some(message) = subscriber.next().await {- let request: serde_json::Value = serde_json::from_slice(message.payload()).unwrap();- let partials = request["user_ids"]- .as_array()- .unwrap()- .iter()- .map(|id| {- let id = id.as_i64().unwrap();- json!({- "user_id": id,- "username": format!("user{id}"),- "discriminator": 1,- "content_hidden_since": (id == HIDDEN_AUTHOR).then_some(hidden_since).flatten(),- })- })- .collect::<Vec<_>>();- let reply = serde_json::to_vec(&json!({"FoundPartials": partials})).unwrap();- let _ = reply_message(&message, &transport, &reply).await;- }- })- }-- fn memory_shard(messages: Vec<Message>) -> MessagesShard<InMemoryTransport> {- MessagesShard {- storage: MessagesStorage::Memory(std::sync::Arc::new(messages)),- transport: InMemoryTransport::new(),- }- }-- fn channel_history() -> (Vec<Message>, Vec<i64>, Vec<i64>) {- let mut messages = Vec::new();- let mut hidden = Vec::new();- let mut visible = Vec::new();- for offset in 0..3 {- let id = snowflake_at(WINDOW_MS - 60_000 + offset, 0);- messages.push(message_by(HIDDEN_AUTHOR, id, json!({})));- visible.push(id);- }- for offset in 0..2 {- let id = snowflake_at(WINDOW_MS - 30_000 + offset, 0);- messages.push(message_by(OTHER_AUTHOR, id, json!({})));- visible.push(id);- }- hidden.push(snowflake_at(WINDOW_MS, 0));- messages.push(message_by(HIDDEN_AUTHOR, hidden[0], json!({})));- for offset in 1..7 {- let id = snowflake_at(WINDOW_MS + offset * 1_000, 0);- messages.push(message_by(HIDDEN_AUTHOR, id, json!({})));- hidden.push(id);- }- visible.sort_unstable_by_key(|id| std::cmp::Reverse(*id));- (messages, hidden, visible)- }-- fn ids(responses: &[ApiMessageResponse]) -> Vec<i64> {- responses- .iter()- .map(|response| response.id.parse().unwrap())- .collect()- }-- #[tokio::test]- async fn hidden_window_drops_messages_from_every_list_shape_and_refills_the_page() {- let (messages, hidden, visible) = channel_history();- let shard = memory_shard(messages);- let users = user_service(&shard.transport, Some(WINDOW_MS)).await;-- let latest = shard- .list_api_responses(CHANNEL, 3, None, None, None, build_options())- .await- .unwrap();- assert_eq!(ids(&latest), visible[..3].to_vec());-- let before = shard- .list_api_responses(CHANNEL, 50, Some(hidden[6]), None, None, build_options())- .await- .unwrap();- assert_eq!(ids(&before), visible);-- let after = shard- .list_api_responses(CHANNEL, 50, None, Some(visible[1]), None, build_options())- .await- .unwrap();- assert_eq!(ids(&after), vec![visible[0]]);-- let around = shard- .list_api_responses(CHANNEL, 4, None, None, Some(hidden[0]), build_options())- .await- .unwrap();- assert!(ids(&around).iter().all(|id| visible.contains(id)));- assert!(!around.is_empty());-- let mut staff_view = build_options();- staff_view.include_hidden = true;- let all = shard- .list_api_responses(CHANNEL, 50, None, None, None, staff_view)- .await- .unwrap();- assert_eq!(all.len(), visible.len() + hidden.len());- users.abort();- }-- #[tokio::test]- async fn clearing_the_window_restores_every_message() {- let (messages, hidden, visible) = channel_history();- let shard = memory_shard(messages);- let users = user_service(&shard.transport, None).await;-- let latest = shard- .list_api_responses(CHANNEL, 50, None, None, None, build_options())- .await- .unwrap();- assert_eq!(latest.len(), visible.len() + hidden.len());- let single = shard- .get_api_response(CHANNEL, hidden[0], build_options())- .await- .unwrap();- assert_eq!(single.unwrap().id, hidden[0].to_string());- users.abort();- }-- #[tokio::test]- async fn single_fetch_hides_messages_inside_the_window_only() {- let (messages, hidden, visible) = channel_history();- let shard = memory_shard(messages);- let users = user_service(&shard.transport, Some(WINDOW_MS)).await;-- for id in &hidden {- let response = shard- .get_api_response(CHANNEL, *id, build_options())- .await- .unwrap();- assert!(response.is_none(), "{id}");- }- let earlier = visible.last().copied().unwrap();- let response = shard- .get_api_response(CHANNEL, earlier, build_options())- .await- .unwrap();- assert_eq!(response.unwrap().author.id, HIDDEN_AUTHOR.to_string());-- let mut staff_view = build_options();- staff_view.include_hidden = true;- assert!(- shard- .get_api_response(CHANNEL, hidden[0], staff_view)- .await- .unwrap()- .is_some()- );- users.abort();- }-- #[tokio::test]- async fn search_pins_and_saved_builds_drop_hidden_messages() {- let (messages, hidden, visible) = channel_history();- let shard = memory_shard(messages.clone());- let users = user_service(&shard.transport, Some(WINDOW_MS)).await;-- let built = shard- .build_api_responses_from_messages(messages.clone(), build_options())- .await- .unwrap();- let mut built_ids = ids(&built);- built_ids.sort_unstable_by_key(|id| std::cmp::Reverse(*id));- assert_eq!(built_ids, visible);- assert!(built_ids.iter().all(|id| !hidden.contains(id)));- users.abort();-- let shard = memory_shard(messages.clone());- let users = user_service(&shard.transport, None).await;- let restored = shard- .build_api_responses_from_messages(messages, build_options())- .await- .unwrap();- assert_eq!(restored.len(), visible.len() + hidden.len());- users.abort();- }-- #[tokio::test]- async fn replies_lose_their_preview_and_forwards_vanish_when_the_source_is_hidden() {- let (mut messages, hidden, _) = channel_history();- let reply_id = snowflake_at(WINDOW_MS + 20_000, 0);- let forward_id = snowflake_at(WINDOW_MS + 21_000, 0);- let reference = |kind: i32| {- json!({"message_reference": {- "channel_id": {"__fluxer_type": "bigint", "value": CHANNEL.to_string()},- "message_id": {"__fluxer_type": "bigint", "value": hidden[1].to_string()},- "type": kind,- }})- };- messages.push(message_by(OTHER_AUTHOR, reply_id, reference(0)));- let mut forward = reference(1);- forward["message_snapshots"] = json!([{"content": "copied", "type": 0}]);- forward["content"] = json!("");- messages.push(message_by(OTHER_AUTHOR, forward_id, forward));- let shard = memory_shard(messages);- let users = user_service(&shard.transport, Some(WINDOW_MS)).await;-- let reply = shard- .get_api_response(CHANNEL, reply_id, build_options())- .await- .unwrap()- .unwrap();- let reply = serde_json::to_value(&reply).unwrap();- assert!(reply["referenced_message"].is_null());- assert_eq!(- reply["message_reference"]["message_id"],- hidden[1].to_string()- );- assert!(- shard- .get_api_response(CHANNEL, forward_id, build_options())- .await- .unwrap()- .is_none()- );- let latest = shard- .list_api_responses(CHANNEL, 2, None, None, None, build_options())- .await- .unwrap();- assert_eq!(ids(&latest)[0], reply_id);- assert!(!ids(&latest).contains(&forward_id));- users.abort();- }}diff --git a/fluxer_messages/src/types.rs b/fluxer_messages/src/types.rsindex 9174ec104..2678a2f03 100644--- a/fluxer_messages/src/types.rs+++ b/fluxer_messages/src/types.rs@@ -1,6 +1,7 @@// SPDX-License-Identifier: AGPL-3.0-or-laterpub use fluxer_common::user_partial::ApiUserPartial;+use fluxer_common::user_partial::default_instance_name;use serde::{Deserialize, Serialize};@@ -92,6 +93,8 @@ pub enum MessageRequest {include_hidden: bool,#[serde(default)]threads_mask: bool,+ #[serde(default = "default_instance_name")]+ instance_name: String,},BuildResponse {message: Message,@@ -111,6 +114,8 @@ pub enum MessageRequest {include_hidden: bool,#[serde(default)]threads_mask: bool,+ #[serde(default = "default_instance_name")]+ instance_name: String,},BuildResponses {messages: Vec<Message>,@@ -128,6 +133,8 @@ pub enum MessageRequest {include_hidden: bool,#[serde(default)]threads_mask: bool,+ #[serde(default = "default_instance_name")]+ instance_name: String,},ListResponses {channel_id: String,@@ -151,6 +158,8 @@ pub enum MessageRequest {threads_mask: bool,#[serde(default)]exclude_types: Vec<i32>,+ #[serde(default = "default_instance_name")]+ instance_name: String,},ExtractMentions {contents: Vec<String>,diff --git a/fluxer_users/src/router_impl.rs b/fluxer_users/src/router_impl.rsindex c5f41528a..c8d9d1ffc 100644--- a/fluxer_users/src/router_impl.rs+++ b/fluxer_users/src/router_impl.rs@@ -18,12 +18,12 @@ impl RouterService for UsersRouter {fn route_key(req: &UserRequest) -> String {match req {UserRequest::Invalidate { user_id } => user_id.to_string(),- UserRequest::GetPartialsByIds { user_ids } => user_ids+ UserRequest::GetPartialsByIds { user_ids, .. } => user_ids.iter().min().map(ToString::to_string).unwrap_or_else(|| "0".to_owned()),- UserRequest::GetApiPartialsByIds { user_ids } => user_ids+ UserRequest::GetApiPartialsByIds { user_ids, .. } => user_ids.iter().min().cloned()@@ -33,23 +33,29 @@ impl RouterService for UsersRouter {fn coalesce_key(req: &UserRequest) -> Option<String> {match req {- UserRequest::GetPartialsByIds { user_ids } => {+ UserRequest::GetPartialsByIds {+ user_ids,+ instance_name,+ } => {let mut ids = user_ids.clone();ids.sort_unstable();ids.dedup();Some(format!(- "partials:{}",+ "partials:{instance_name}:{}",ids.iter().map(ToString::to_string).collect::<Vec<_>>().join(",")))}- UserRequest::GetApiPartialsByIds { user_ids } => {+ UserRequest::GetApiPartialsByIds {+ user_ids,+ instance_name,+ } => {let mut ids = user_ids.clone();ids.sort_unstable();ids.dedup();- Some(format!("api_partials:{}", ids.join(",")))+ Some(format!("api_partials:{instance_name}:{}", ids.join(",")))}UserRequest::Invalidate { .. } => None,}@@ -63,44 +69,3 @@ impl RouterService for UsersRouter {matches!(response, UserResponse::Invalidated)}}--#[cfg(test)]-mod tests {- use super::*;-- #[test]- fn coalesce_key_ignores_batch_id_order() {- let forward = UserRequest::GetPartialsByIds {- user_ids: vec![7, 42, 7],- };- let reversed = UserRequest::GetPartialsByIds {- user_ids: vec![42, 7],- };- assert_eq!(- UsersRouter::coalesce_key(&forward),- UsersRouter::coalesce_key(&reversed)- );- }-- #[test]- fn coalesce_key_separates_batches_with_different_ids() {- let left = UserRequest::GetApiPartialsByIds {- user_ids: vec!["7".to_owned(), "42".to_owned()],- };- let right = UserRequest::GetApiPartialsByIds {- user_ids: vec!["7".to_owned()],- };- assert_ne!(- UsersRouter::coalesce_key(&left),- UsersRouter::coalesce_key(&right)- );- }-- #[test]- fn invalidations_are_never_coalesced() {- assert_eq!(- UsersRouter::coalesce_key(&UserRequest::Invalidate { user_id: 42 }),- None- );- }-}diff --git a/fluxer_users/src/shard_impl.rs b/fluxer_users/src/shard_impl.rsindex 77864e66f..f710e0597 100644--- a/fluxer_users/src/shard_impl.rs+++ b/fluxer_users/src/shard_impl.rs@@ -5,9 +5,7 @@ use crate::types::{ApiUserPartial, UserPartial, UserRequest, UserResponse};use chrono::{DateTime, Utc};use fluxer_common::time::unix_millis;use fluxer_common::user_flags::{AccountStanding, USER_FLAG_STAFF};-use fluxer_common::user_partial::{- FLUXER_SYSTEM_DISCRIMINATOR, FLUXER_SYSTEM_USER_ID, FLUXER_SYSTEM_USERNAME,-};+use fluxer_common::user_partial::{FLUXER_SYSTEM_DISCRIMINATOR, FLUXER_SYSTEM_USER_ID};use fluxer_svc::shard::ShardService;use fluxer_svc::{postgres, postgres::KeyPart};use futures::stream::{self, StreamExt};@@ -263,22 +261,23 @@ impl UsersShard {}async fn get_partial_user(&self, user_id: i64) -> anyhow::Result<Option<UserPartial>> {- if user_id == FLUXER_SYSTEM_USER_ID {- return Ok(Some(system_user_partial()));- }self.caches.get_or_fetch_partial(user_id, self.storage.fetch_partial_user(user_id)).await}- async fn get_partial_users(&self, mut user_ids: Vec<i64>) -> anyhow::Result<Vec<UserPartial>> {+ async fn get_partial_users(+ &self,+ mut user_ids: Vec<i64>,+ instance_name: &str,+ ) -> anyhow::Result<Vec<UserPartial>> {user_ids.sort_unstable();user_ids.dedup();let mut partials = Vec::new();let mut misses = Vec::new();for user_id in user_ids {if user_id == FLUXER_SYSTEM_USER_ID {- partials.push(system_user_partial());+ partials.push(system_user_partial(instance_name));continue;}match self.caches.get_partial(user_id).await {@@ -308,13 +307,14 @@ impl UsersShard {async fn get_api_partial_users(&self,user_ids: Vec<String>,+ instance_name: &str,) -> anyhow::Result<Vec<ApiUserPartial>> {let user_ids = user_ids.iter().map(|user_id| parse_user_id(user_id)).collect::<anyhow::Result<Vec<_>>>()?;Ok(self- .get_partial_users(user_ids)+ .get_partial_users(user_ids, instance_name).await?.into_iter().map(|partial| partial.to_api_partial())@@ -452,10 +452,10 @@ fn decode_postgres_user_partial(row: serde_json::Value) -> anyhow::Result<UserPaOk(row.into())}-fn system_user_partial() -> UserPartial {+fn system_user_partial(instance_name: &str) -> UserPartial {UserPartial {user_id: FLUXER_SYSTEM_USER_ID,- username: FLUXER_SYSTEM_USERNAME.to_owned(),+ username: instance_name.to_owned(),discriminator: FLUXER_SYSTEM_DISCRIMINATOR,global_name: None,avatar_hash: None,@@ -502,11 +502,17 @@ impl ShardService for UsersShard {async fn handle(&self, request: UserRequest) -> anyhow::Result<UserResponse> {match request {- UserRequest::GetPartialsByIds { user_ids } => Ok(UserResponse::FoundPartials(- self.get_partial_users(user_ids).await?,+ UserRequest::GetPartialsByIds {+ user_ids,+ instance_name,+ } => Ok(UserResponse::FoundPartials(+ self.get_partial_users(user_ids, &instance_name).await?,)),- UserRequest::GetApiPartialsByIds { user_ids } => Ok(UserResponse::FoundApiPartials(- self.get_api_partial_users(user_ids).await?,+ UserRequest::GetApiPartialsByIds {+ user_ids,+ instance_name,+ } => Ok(UserResponse::FoundApiPartials(+ self.get_api_partial_users(user_ids, &instance_name).await?,)),UserRequest::Invalidate { user_id } => {self.caches.invalidate(user_id).await;@@ -561,7 +567,6 @@ impl From<PartialUserDbRow> for UserPartial {#[cfg(test)]mod tests {use super::*;- use serde_json::json;fn test_user(user_id: i64) -> PartialUserDbRow {PartialUserDbRow {@@ -585,83 +590,6 @@ mod tests {}}- fn caches() -> UserCaches {- UserCaches::new(16, Duration::from_secs(60))- }-- #[tokio::test]- async fn partial_cache_hits_do_not_reach_storage_again() {- let caches = caches();- let partial = UserPartial::from(test_user(42));- caches- .get_or_fetch_partial(42, async { Ok(Some(partial)) })- .await- .unwrap();-- let fetched = caches- .get_or_fetch_partial(42, async { Ok(Some(UserPartial::from(test_user(7)))) })- .await- .unwrap()- .unwrap();-- assert_eq!(fetched.user_id, 42);- }-- #[tokio::test]- async fn invalidation_clears_a_partial_only_entry() {- let caches = caches();- caches- .get_or_fetch_partial(42, async { Ok(Some(UserPartial::from(test_user(42)))) })- .await- .unwrap();-- caches.invalidate(42).await;-- assert!(caches.get_partial(42).await.is_none());- }-- #[cfg(feature = "scylla")]- #[test]- fn partial_columns_match_the_user_partial_fields_exactly() {- use std::collections::BTreeSet;-- let columns = PARTIAL_USER_COLUMNS- .split(',')- .map(str::trim)- .collect::<BTreeSet<_>>();- let mut user = test_user(42);- user.content_hidden_since = Some(1);- let partial = serde_json::to_value(UserPartial::from(user.clone())).unwrap();- let mut fields = partial- .as_object()- .unwrap()- .keys()- .map(String::as_str)- .collect::<BTreeSet<_>>();- fields.extend([- "temp_banned_until",- "pending_deletion_at",- "deletion_reason_code",- ]);-- assert_eq!(columns, fields);- }-- #[test]- fn fluxer_system_user_partial_is_virtual_id_zero() {- let partial = system_user_partial();-- assert_eq!(partial.user_id, 0);- assert_eq!(partial.username, "Fluxer");- assert_eq!(partial.discriminator, 0);- assert_eq!(partial.global_name, None);- assert_eq!(partial.bot, Some(true));- assert_eq!(partial.system, Some(true));- assert_eq!(partial.flags, Some(USER_FLAG_STAFF));- assert_eq!(partial.avatar_hash, None);- assert_eq!(partial.avatar_color, None);- }-const SPAMMER: i64 = 1 << 6;const DISABLED: i64 = 1 << 38;const PROFILE_HIDDEN: i64 = 1 << 7;@@ -724,95 +652,4 @@ mod tests {assert_eq!(user.avatar_hash.as_deref(), Some("avatar_hash"));}}-- #[test]- fn lifted_bans_self_disables_and_normal_accounts_keep_their_partial() {- let now = unix_millis();- let mut expired = styled(45, DISABLED);- expired.temp_banned_until = Some(now - 60_000);- let mut self_deleting = styled(46, 0);- self_deleting.pending_deletion_at = Some(now + 60_000);- self_deleting.deletion_reason_code = Some(1);- for user in [styled(47, 0), styled(48, DISABLED), expired, self_deleting] {- let partial = UserPartial::from(user.clone());- assert_eq!(partial.username, "Ada", "{}", user.user_id);- assert_eq!(partial.global_name.as_deref(), Some("Ada Lovelace"));- assert_eq!(partial.banner_hash.as_deref(), Some("banner_hash"));- assert_eq!(partial.discriminator, 7);- assert_eq!(partial.flags.unwrap_or_default() & PROFILE_HIDDEN, 0);- }- }-- #[test]- fn postgres_partial_rows_apply_the_mask_from_ban_state() {- let until = |ms: i64| {- let at = chrono::DateTime::from_timestamp_millis(ms).unwrap();- json!({"__fluxer_type": "date", "value": at.to_rfc3339_opts(chrono::SecondsFormat::Millis, true)})- };- let row = |ms: i64| {- json!({- "user_id": {"__fluxer_type": "bigint", "value": "42"},- "username": "ada",- "discriminator": 7,- "global_name": "Ada",- "avatar_hash": "avatar_hash",- "flags": {"__fluxer_type": "bigint", "value": DISABLED.to_string()},- "temp_banned_until": until(ms),- })- };- let now = unix_millis();- assert_hidden(&decode_postgres_user_partial(row(now + 60_000)).unwrap());- let lifted = decode_postgres_user_partial(row(now - 60_000)).unwrap();- assert_eq!(lifted.username, "ada");- assert_eq!(lifted.avatar_hash.as_deref(), Some("avatar_hash"));- }-- #[test]- fn the_message_hide_window_reaches_the_partial_independently_of_the_profile_mask() {- let since = 1_790_000_000_000;- let mut hidden = styled(49, 0);- hidden.content_hidden_since = Some(since);- let partial = UserPartial::from(hidden.clone());- assert_eq!(partial.content_hidden_since, Some(since));- assert_eq!(partial.username, "Ada");- let mut masked = styled(50, PROFILE_HIDDEN);- masked.content_hidden_since = Some(since);- let partial = UserPartial::from(masked.clone());- assert_hidden(&partial);- assert_eq!(partial.content_hidden_since, Some(since));- assert_eq!(- UserPartial::from(styled(51, PROFILE_HIDDEN)).content_hidden_since,- None- );- let wire = serde_json::to_value(UserPartial::from(styled(52, 0))).unwrap();- assert!(wire.get("content_hidden_since").is_none());- assert!(- serde_json::to_value(UserPartial::from(hidden.clone()).to_api_partial())- .unwrap()- .get("content_hidden_since")- .is_none()- );- }-- #[test]- fn postgres_partial_rows_read_the_message_hide_window() {- let since = 1_790_000_000_000_i64;- let at = chrono::DateTime::from_timestamp_millis(since).unwrap();- let row = json!({- "user_id": {"__fluxer_type": "bigint", "value": "42"},- "username": "ada",- "discriminator": 7,- "content_hidden_since": {"__fluxer_type": "date", "value": at.to_rfc3339_opts(chrono::SecondsFormat::Millis, true)},- });- let partial = decode_postgres_user_partial(row).unwrap();- assert_eq!(partial.content_hidden_since, Some(since));- assert_eq!(partial.username, "ada");- let cleared = decode_postgres_user_partial(json!({- "user_id": {"__fluxer_type": "bigint", "value": "42"},- "username": "ada",- "discriminator": 7,- }))- .unwrap();- assert_eq!(cleared.content_hidden_since, None);- }}diff --git a/fluxer_users/src/types.rs b/fluxer_users/src/types.rsindex 1d848b4d7..56b567624 100644--- a/fluxer_users/src/types.rs+++ b/fluxer_users/src/types.rs@@ -7,9 +7,9 @@ use fluxer_common::user_flags::USER_FLAG_STAFF;#[cfg(test)]use fluxer_common::user_flags::{USER_FLAG_PARTNER, USER_FLAG_STAFF_HIDDEN};pub use fluxer_common::user_partial::ApiUserPartial;-#[cfg(test)]-use fluxer_common::user_partial::FLUXER_SYSTEM_USERNAME;-use fluxer_common::user_partial::{FLUXER_SYSTEM_USER_ID, UserPartialFields};+use fluxer_common::user_partial::{+ FLUXER_SYSTEM_USER_ID, UserPartialFields, default_instance_name,+};use serde::{Deserialize, Deserializer, Serialize};#[derive(Debug, Clone, Serialize, Deserialize)]@@ -17,9 +17,13 @@ use serde::{Deserialize, Deserializer, Serialize};pub enum UserRequest {GetPartialsByIds {user_ids: Vec<i64>,+ #[serde(default = "default_instance_name")]+ instance_name: String,},GetApiPartialsByIds {user_ids: Vec<String>,+ #[serde(default = "default_instance_name")]+ instance_name: String,},Invalidate {#[serde(deserialize_with = "deserialize_i64_from_number_or_string")]@@ -109,9 +113,7 @@ where#[cfg(test)]mod tests {use super::*;- use serde_json::{Value, json};-- const USER_FLAG_DELETED: i64 = 1 << 34;+ use serde_json::json;fn partial_with_flags(user_id: i64, flags: i64) -> UserPartial {UserPartial {@@ -136,13 +138,18 @@ mod tests {fn api_partial_requests_use_string_snowflakes() {let request: UserRequest = serde_json::from_value(json!({"op": "GetApiPartialsByIds",- "user_ids": ["9007199254740993", "9223372036854775807"]+ "user_ids": ["9007199254740993", "9223372036854775807"],+ "instance_name": "Example Chat"})).unwrap();match request {- UserRequest::GetApiPartialsByIds { user_ids } => {+ UserRequest::GetApiPartialsByIds {+ user_ids,+ instance_name,+ } => {assert_eq!(user_ids, vec!["9007199254740993", "9223372036854775807"]);+ assert_eq!(instance_name, "Example Chat");}other => panic!("unexpected request: {other:?}"),}@@ -206,27 +213,4 @@ mod tests {assert_eq!(api_partial.system, None);assert_eq!(api_partial.mention_flags, None);}-- #[test]- fn api_partial_preserves_stored_fields_when_deleted_flag_is_set() {- let deleted = partial_with_flags(123, USER_FLAG_DELETED).to_api_partial();-- assert_eq!(deleted.username, "Ada");- assert_eq!(deleted.global_name, Some("Ada Lovelace".to_owned()));- assert_eq!(deleted.avatar, Some("avatar_hash".to_owned()));- assert_eq!(deleted.flags, 0);- }-- #[test]- fn api_partial_maps_system_user_like_the_api_mapper() {- let system = partial_with_flags(FLUXER_SYSTEM_USER_ID, USER_FLAG_STAFF).to_api_partial();-- assert_eq!(system.username, FLUXER_SYSTEM_USERNAME);- assert_eq!(system.bot, Some(true));- assert_eq!(system.system, Some(true));- assert_eq!(- serde_json::to_value(system).unwrap()["system"],- Value::Bool(true)- );- }}