Skip to content

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

TypeScript fluxerfluxerapp

feat(media-proxy): serve branding at full size, drop unit tests

Hampus7bd6ffcdfd82
diff --git a/fluxer_media_proxy/src/constants.rs b/fluxer_media_proxy/src/constants.rs
index 27165747d..d09c82ede 100644
--- a/fluxer_media_proxy/src/constants.rs
+++ b/fluxer_media_proxy/src/constants.rs
@@ -2,6 +2,7 @@
pub const MAX_MEDIA_PROXY_BYTES: usize = 500 * 1024 * 1024;
pub const DESKTOP_APP_ORIGIN: &str = "fluxer-app://app";
+pub(crate) const OPERATOR_WALL_PATH_PREFIX: &str = "/operator-wall/";
pub const OUTBOUND_USER_AGENT: &str =
"Mozilla/5.0 (compatible; Fluxerbot/1.0; +https://fluxer.app)";
@@ -55,6 +56,7 @@ pub enum AssetKind {
EmbedSplash,
Emoji,
Sticker,
+ Branding,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
@@ -149,6 +151,7 @@ pub fn dims_for(kind: AssetKind) -> Dims {
},
AssetKind::Emoji => Dims { min: 32, max: 512 },
AssetKind::Sticker => Dims { min: 128, max: 512 },
+ AssetKind::Branding => Dims { min: 16, max: 4096 },
}
}
@@ -157,57 +160,3 @@ pub fn clamp_size(raw_target: u32, kind: AssetKind) -> u32 {
let dims = dims_for(kind);
value.clamp(dims.min, dims.max)
}
-
-#[cfg(test)]
-mod tests {
- use super::*;
-
- fn asset_cache_key(raw: Option<&str>, kind: AssetKind) -> u32 {
- clamp_size(parse_image_size(raw), kind)
- }
-
- #[test]
- fn off_ladder_size_never_serves_fewer_pixels_than_requested() {
- for requested in 1..=4096u32 {
- let served = parse_image_size(Some(&requested.to_string()));
- assert!(
- served >= requested,
- "size={requested} served {served}, a silent downscale"
- );
- }
- }
-
- #[test]
- fn sub_minimum_sizes_collapse_to_one_avatar_cache_key() {
- let canonical = asset_cache_key(Some("128"), AssetKind::Avatar);
- assert_eq!(128, canonical);
- for below in IMAGE_SIZES.iter().take_while(|rung| **rung < 128) {
- assert_eq!(
- canonical,
- asset_cache_key(Some(&below.to_string()), AssetKind::Avatar),
- "size={below} minted a second avatar cache key"
- );
- }
- }
-
- #[test]
- fn sub_minimum_sizes_collapse_to_one_banner_cache_key() {
- let canonical = asset_cache_key(Some("480"), AssetKind::Banner);
- assert_eq!(480, canonical);
- for below in IMAGE_SIZES.iter().take_while(|rung| **rung < 480) {
- assert_eq!(
- canonical,
- asset_cache_key(Some(&below.to_string()), AssetKind::Banner),
- "size={below} minted a second banner cache key"
- );
- }
- }
-
- #[test]
- fn oversize_requests_collapse_onto_the_kind_maximum() {
- assert_eq!(1024, asset_cache_key(Some("99999"), AssetKind::Avatar));
- assert_eq!(1024, asset_cache_key(Some("1024"), AssetKind::Avatar));
- assert_eq!(512, asset_cache_key(Some("99999"), AssetKind::Emoji));
- assert_eq!(512, asset_cache_key(Some("99999"), AssetKind::Sticker));
- }
-}
diff --git a/fluxer_media_proxy/src/server/stored/mod.rs b/fluxer_media_proxy/src/server/stored/mod.rs
index 573468d50..a42789085 100644
--- a/fluxer_media_proxy/src/server/stored/mod.rs
+++ b/fluxer_media_proxy/src/server/stored/mod.rs
@@ -2,8 +2,6 @@
pub(in crate::server) mod passthrough;
pub(in crate::server) mod response;
-#[cfg(test)]
-mod tests;
use crate::{
coalescer::CoalescerError,
@@ -67,13 +65,16 @@ pub(in crate::server) async fn serve_asset_image(
let range_header = headers.get(header::RANGE).and_then(|v| v.to_str().ok());
let requested_download = bool_param(params, "download", false);
let asset_filename = asset_filename_hint(&asset);
- let size = constants::parse_image_size(params.get("size").map(String::as_str));
+ let requested_size = match (asset.kind, params.get("size")) {
+ (AssetKind::Branding, None) => None,
+ (_, raw) => Some(constants::parse_image_size(raw.map(String::as_str))),
+ };
let requested_manual_format = asset_manual_format_override(params, asset.original_ext);
let manual_format_override = asset.forced_output_format.or(requested_manual_format);
let selected = output_format::select_url_variant(output_format::Input {
kind: asset.kind,
original: asset.original_ext,
- requested_size: Some(size),
+ requested_size,
manual_format_override,
});
let animated = asset_wants_animated(params, &asset.hash);
diff --git a/fluxer_media_proxy/src/server/transform/cache_key.rs b/fluxer_media_proxy/src/server/transform/cache_key.rs
index 5b46946fb..060bedfad 100644
--- a/fluxer_media_proxy/src/server/transform/cache_key.rs
+++ b/fluxer_media_proxy/src/server/transform/cache_key.rs
@@ -74,6 +74,7 @@ fn asset_kind_name(kind: AssetKind) -> &'static str {
AssetKind::EmbedSplash => "embed_splash",
AssetKind::Emoji => "emoji",
AssetKind::Sticker => "sticker",
+ AssetKind::Branding => "branding",
}
}
@@ -95,88 +96,3 @@ fn serialize_optional_number(value: Option<impl ToString>) -> String {
pub(in crate::server) fn sha256_hex(data: &[u8]) -> String {
hex::encode(Sha256::digest(data))
}
-
-#[cfg(test)]
-mod tests {
- use super::*;
-
- fn input<'a>(route: TransformRoute, identity: &'a str) -> TransformCacheKeyInput<'a> {
- TransformCacheKeyInput {
- route,
- asset_kind: None,
- cache_identity: identity,
- width: None,
- height: None,
- format: OutputFormat::WebP,
- quality: None,
- animated: false,
- effort: None,
- resize_mode: None,
- }
- }
-
- #[test]
- fn cache_key_serializes_every_transform_decision() {
- let key = transform_cache_key(TransformCacheKeyInput {
- route: TransformRoute::Attachment,
- asset_kind: None,
- cache_identity: "attachment/1",
- width: Some(128),
- height: Some(256),
- format: OutputFormat::PNG,
- quality: Some(ImageQuality::Lossless),
- animated: true,
- effort: EncodeEffort::parse_lenient("3"),
- resize_mode: Some(ResizeMode::Cover),
- });
- assert_eq!(
- "attachment:attachment/1|asset_kind=not-applicable|w=128|h=256|fmt=png|q=lossless|anim=true|effort=3|resize=cover",
- key
- );
- assert_ne!(
- key,
- transform_cache_key(input(TransformRoute::Attachment, "attachment/1"))
- );
- }
-
- #[test]
- fn external_cache_identity_is_hashed_and_route_namespaces_are_distinct() {
- let raw = "https://user:[email protected]/media.png?token=private";
- let external = transform_cache_key(input(TransformRoute::External, raw));
- assert!(external.starts_with("external:"));
- assert!(!external.contains(raw));
- assert!(!external.contains("secret"));
- assert_ne!(
- external,
- transform_cache_key(input(TransformRoute::Stored, raw))
- );
- assert_eq!(64, sha256_hex(b"abc").len());
- }
-
- #[test]
- fn asset_keys_name_their_kind_and_stay_distinct_per_kind() {
- let emoji = transform_cache_key(TransformCacheKeyInput {
- asset_kind: Some(AssetKind::Emoji),
- resize_mode: Some(ResizeMode::Cover),
- ..input(TransformRoute::Asset, "identity")
- });
- assert_eq!(
- "asset:identity|asset_kind=emoji|w=none|h=none|fmt=webp|q=default|anim=false|effort=none|resize=cover",
- emoji
- );
- assert_ne!(
- emoji,
- transform_cache_key(TransformCacheKeyInput {
- asset_kind: Some(AssetKind::Sticker),
- resize_mode: Some(ResizeMode::Cover),
- ..input(TransformRoute::Asset, "identity")
- })
- );
- }
-
- #[test]
- #[should_panic(expected = "an asset transform cache key requires its kind")]
- fn an_asset_key_without_a_kind_is_a_programming_error() {
- let _ = transform_cache_key(input(TransformRoute::Asset, "identity"));
- }
-}