pepepper/fluxer
1
0 Fork 0
mirror of https://github.com/fluxerapp/fluxer synced 2026-10-18 05:25:40 +09:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Hampus authored and GitHub committed 2026-10-10 21:43:29 +02:00
1 parent 7e177a1c90
commit 1cd62eb661
1391 files changed
+783 -120415
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

fluxer_media_proxy/src/request_log/mod.rs
-219
View File
@@ -315,53 +315,6 @@ fn default_reason(status: StatusCode) -> &'static str {
#[cfg(test)]
mod tests {
use super::*;
use crate::metrics::Metrics;
use axum::{
Router,
body::Body,
middleware,
response::IntoResponse,
routing::{get, post},
};
use std::sync::Mutex;
use tower::ServiceExt;
use tracing_subscriber::fmt::MakeWriter;
#[derive(Clone, Default)]
struct CapturedLog(Arc<Mutex<Vec<u8>>>);
impl CapturedLog {
fn text(&self) -> String {
String::from_utf8(self.0.lock().expect("captured log is not poisoned").clone())
.expect("captured log is utf-8")
}
}
impl std::io::Write for CapturedLog {
fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
self.0
.lock()
.expect("captured log is not poisoned")
.extend_from_slice(buf);
Ok(buf.len())
}
fn flush(&mut self) -> std::io::Result<()> {
Ok(())
}
}
impl<'a> MakeWriter<'a> for CapturedLog {
type Writer = Self;
fn make_writer(&'a self) -> Self::Writer {
self.clone()
}
}
fn req_id_is_alphabet_only(id: &str) -> bool {
id.len() == ID_LEN && id.bytes().all(|c| ID_ALPHABET.contains(&c))
}
fn observation_with_headers(headers: HeaderMap) -> RequestObservation {
RequestObservation::new(
@@ -373,36 +326,6 @@ mod tests {
)
}
#[test]
fn request_id_is_stable_length_and_alphabet() {
let id = RequestId::generate();
assert!(req_id_is_alphabet_only(id.as_str()));
}
#[test]
fn two_back_to_back_ids_differ() {
assert_ne!(RequestId::generate().0, RequestId::generate().0);
}
#[test]
fn classify_route_buckets_known_prefixes() {
assert_eq!(RequestKind::Health, classify_route("/_health"));
assert_eq!(RequestKind::Metadata, classify_route("/_metadata"));
assert_eq!(RequestKind::Sniff, classify_route("/_sniff"));
assert_eq!(RequestKind::Other, classify_route("/_metrics"));
assert_eq!(RequestKind::Upload, classify_route("/v1/relay/abc"));
assert_eq!(RequestKind::External, classify_route("/external/x/y"));
assert_eq!(RequestKind::Attachment, classify_route("/attachments/a/b"));
assert_eq!(RequestKind::Themes, classify_route("/themes/x.css"));
assert_eq!(
RequestKind::GuildMemberImage,
classify_route("/guilds/1/users/2/avatars/h.png")
);
assert_eq!(RequestKind::AssetImage, classify_route("/emojis/1.png"));
assert_eq!(RequestKind::AssetImage, classify_route("/icons/1/h.png"));
assert_eq!(RequestKind::Other, classify_route("/unknown"));
}
#[test]
fn clip_never_splits_a_multibyte_character() {
let key = "\u{597d}".repeat(8);
@@ -495,12 +418,6 @@ mod tests {
);
}
#[test]
fn clip_truncates_with_marker() {
assert_eq!("abc", clip("abc", 8));
assert_eq!("abcdefgh~", clip("abcdefghIJ", 8));
}
#[test]
fn credentialed_referer_is_redacted_before_it_reaches_the_log() {
let mut headers = HeaderMap::new();
@@ -529,140 +446,4 @@ mod tests {
assert_eq!("size=128", observation.query);
assert_eq!(RequestKind::Attachment, observation.kind);
}
#[tokio::test]
async fn middleware_inserts_request_id_into_extensions() {
async fn handler(req: Request) -> impl IntoResponse {
let id = req
.extensions()
.get::<RequestId>()
.expect("middleware must inject RequestId")
.clone();
id.0
}
let app = Router::new()
.route("/", get(handler))
.layer(middleware::from_fn_with_state(
Arc::new(RequestMetrics::new()),
trace,
));
let resp = app
.oneshot(
axum::http::Request::builder()
.uri("/")
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(StatusCode::OK, resp.status());
let bytes = axum::body::to_bytes(resp.into_body(), 64).await.unwrap();
let body = std::str::from_utf8(&bytes).unwrap();
assert!(req_id_is_alphabet_only(body));
}
#[tokio::test]
async fn middleware_records_metrics_and_reads_error_reason() {
async fn handler() -> Response {
let mut resp = Response::new(Body::from("boom"));
*resp.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
resp.extensions_mut()
.insert(ErrorReason::with_message("transcode_failed", "vips OOM"));
resp
}
let metrics = Metrics::new();
let app = Router::new()
.route("/", get(handler))
.layer(middleware::from_fn_with_state(metrics.request(), trace));
let resp = app
.oneshot(
axum::http::Request::builder()
.uri("/")
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(StatusCode::INTERNAL_SERVER_ERROR, resp.status());
let reason = resp.extensions().get::<ErrorReason>().unwrap();
assert_eq!("transcode_failed", reason.code);
assert_eq!(Some("vips OOM".to_owned()), reason.source);
let rendered = metrics.render();
assert!(rendered.contains("fluxer_media_proxy_requests_5xx_total{kind=\"other\"} 1\n"));
assert!(rendered.contains("fluxer_media_proxy_request_duration_ms_count 1\n"));
}
#[tokio::test]
async fn a_successful_sniff_writes_its_own_request_line_and_series() {
let metrics = Metrics::new();
let app = Router::new()
.route("/_sniff", post(|| async { "{\"content_type\":null}" }))
.route("/_metrics", get(|| async { "" }))
.layer(middleware::from_fn_with_state(metrics.request(), trace));
let captured = CapturedLog::default();
let subscriber = tracing_subscriber::fmt()
.with_writer(captured.clone())
.with_ansi(false)
.with_max_level(tracing::Level::TRACE)
.finish();
{
let _guard = tracing::subscriber::set_default(subscriber);
for (method, uri) in [(Method::POST, "/_sniff"), (Method::GET, "/_metrics")] {
let response = app
.clone()
.oneshot(
axum::http::Request::builder()
.method(method)
.uri(uri)
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(StatusCode::OK, response.status(), "{uri}");
}
}
let log = captured.text();
let request_lines: Vec<&str> = log
.lines()
.filter(|line| line.contains(" request "))
.collect();
assert_eq!(1, request_lines.len(), "{log}");
assert!(request_lines[0].contains("kind=\"sniff\""), "{log}");
assert!(request_lines[0].contains("method=POST"), "{log}");
assert!(request_lines[0].contains("path=/_sniff"), "{log}");
assert!(request_lines[0].contains("status=200"), "{log}");
let rendered = metrics.render();
assert!(rendered.contains("fluxer_media_proxy_requests_2xx_total{kind=\"sniff\"} 1\n"));
assert!(rendered.contains("fluxer_media_proxy_requests_2xx_total{kind=\"other\"} 1\n"));
assert!(
rendered.contains(
"fluxer_media_proxy_request_duration_by_route_ms_count{kind=\"sniff\"} 1\n"
)
);
}
#[tokio::test]
async fn trace_public_request_observes_a_non_axum_request() {
let metrics = Metrics::new();
let response = trace_public_request(
metrics.request().as_ref(),
RequestId::generate(),
Method::GET,
"/attachments/1/2/a.png?size=128",
&HeaderMap::new(),
async {
record_stage(Stage::Fetch, 3);
record_stage(Stage::Transform, 5);
record_stage(Stage::Nsfw, 7);
Response::new(Body::empty())
},
)
.await;
assert_eq!(StatusCode::OK, response.status());
let rendered = metrics.render();
assert!(
rendered.contains("fluxer_media_proxy_requests_2xx_total{kind=\"attachment\"} 1\n")
);
}
}
fluxer_media_proxy/src/request_log/stage.rs
-46
View File
@@ -74,49 +74,3 @@ where
{
STAGES.scope(stages, future).await
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn each_stage_accumulates_into_its_own_slot() {
let stages = Arc::new(StageTimings::default());
scope(Arc::clone(&stages), async {
record_stage(Stage::Fetch, 3);
record_stage(Stage::Fetch, 4);
record_stage(Stage::Transform, 5);
record_stage(Stage::Nsfw, 6);
})
.await;
let snapshot = stages.snapshot();
assert_eq!(7, snapshot.fetch_ms);
assert_eq!(5, snapshot.transform_ms);
assert_eq!(6, snapshot.nsfw_ms);
}
#[tokio::test]
async fn recording_outside_a_scope_is_a_no_op() {
record_stage(Stage::Fetch, 9);
let stages = Arc::new(StageTimings::default());
let snapshot = scope(Arc::clone(&stages), async { stages.snapshot() }).await;
assert_eq!(0, snapshot.fetch_ms);
}
#[tokio::test]
async fn timed_stage_charges_the_elapsed_time_to_the_stage() {
let stages = Arc::new(StageTimings::default());
let value = scope(Arc::clone(&stages), async {
timed_stage(Stage::Transform, async {
tokio::time::sleep(std::time::Duration::from_millis(12)).await;
"done"
})
.await
})
.await;
assert_eq!("done", value);
let snapshot = stages.snapshot();
assert!(snapshot.transform_ms >= 10);
assert_eq!(0, snapshot.fetch_ms);
}
}