Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp

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.rs
index 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.rs
index 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.rs
index 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(&copy),
- CROSSPOST_SOURCE_CHANNEL_ID
- );
- let attachment = signed_attachment_response(&copy);
- 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), copy.channel_id);
- let attachment = signed_attachment_response(&copy);
- 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(&copy), None);
- let deleted = DeletedMessageKeys::default();
- let shard = recording_shard(&deleted);
- let fetched = shard
- .fetch_referenced_messages(std::slice::from_ref(&copy), &build_options())
- .await;
- assert!(fetched.is_empty());
-
- let response = serialized_response(&copy, &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(&copy), None);
- let response = serialized_response(&copy, &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.rs
index 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-later
pub 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.rs
index 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.rs
index 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<UserPa
Ok(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.rs
index 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)
- );
- }
}