Skip to content

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

TypeScript fluxerfluxerapp

test(svc): drop common crate and Docker-backed svc tests

Hampusd474ed38bb7b
diff --git a/fluxer_common/Cargo.toml b/fluxer_common/Cargo.toml
index 73e61caf4..63e35f9a3 100644
--- a/fluxer_common/Cargo.toml
+++ b/fluxer_common/Cargo.toml
@@ -21,8 +21,5 @@ hmac = "0.13.0"
sha2 = "0.11.0"
thiserror = "2"
-[dev-dependencies]
-tempfile = "3.27.0"
-
[features]
healthcheck = ["dep:reqwest"]
diff --git a/fluxer_common/src/attachment_url_signature.rs b/fluxer_common/src/attachment_url_signature.rs
index c3949d1c1..5566d01ad 100644
--- a/fluxer_common/src/attachment_url_signature.rs
+++ b/fluxer_common/src/attachment_url_signature.rs
@@ -346,37 +346,6 @@ mod tests {
verify(storage_key, raw_query, secrets, now_secs).verdict
}
- #[test]
- fn a_valid_ordinary_signature_reports_the_seconds_left_and_a_data_package_reports_none() {
- let secret = secret_bytes();
- let now = ANCHOR + 10;
- let (issued, expires) = issue_window(ANCHOR, now);
- let query = ordinary_query(KEY, issued, expires, &secret);
- for probe in [issued, now, expires - 1] {
- assert_eq!(
- Some(expires - probe),
- verify(KEY, Some(&query), &[&secret], probe).remaining_secs,
- "{probe}"
- );
- }
- for refused in [
- verify(KEY, Some(&query), &[&secret], expires),
- verify(KEY, None, &[&secret], now),
- verify(KEY, Some(&query), &[&other_secret_bytes()], now),
- ] {
- assert_ne!(Verdict::Valid, refused.verdict);
- assert_eq!(None, refused.remaining_secs);
- }
- let package = verify(
- KEY,
- Some(&data_package_query(KEY, issued, &secret)),
- &[&secret],
- now,
- );
- assert_eq!(Verdict::Valid, package.verdict);
- assert_eq!(None, package.remaining_secs);
- }
-
fn ordinary_query(key: &str, issued: u64, expires: u64, secret: &[u8]) -> String {
format!(
"ex={expires:08x}&is={issued:08x}&hm={}",
@@ -508,120 +477,6 @@ mod tests {
assert!(doubled_separators >= 2);
}
- #[test]
- fn a_freshly_signed_url_verifies_at_every_second_of_its_life() {
- let secret = secret_bytes();
- let now = ANCHOR + 10;
- let signed = with_signature("https://media.test/x.gif", KEY, ANCHOR, now, &secret);
- let query = signed.split_once('?').expect("a signed url has a query").1;
- let (issued, expires) = issue_window(ANCHOR, now);
- assert!(issued <= now && now < expires);
- for probe in [issued, now, expires - 1] {
- assert_eq!(
- Verdict::Valid,
- verdict_of(KEY, Some(query), &[&secret], probe),
- "{probe}"
- );
- }
- for probe in [expires, expires + 1] {
- assert_eq!(
- Verdict::Expired,
- verdict_of(KEY, Some(query), &[&secret], probe),
- "{probe}"
- );
- }
- }
-
- #[test]
- fn a_data_package_url_never_expires() {
- let secret = secret_bytes();
- let now = ANCHOR + 3 * ATTACHMENT_URL_BUCKET_SECS + 7;
- let signed =
- with_data_package_signature("https://media.test/x.gif", KEY, ANCHOR, now, &secret);
- let query = signed.split_once('?').expect("a signed url has a query").1;
- let (issued, expires) = issue_window(ANCHOR, now);
- assert!(query.starts_with(&format!("ex=0&is={issued:08x}&hm=")));
- assert!(query.ends_with("&uc=dp"));
- for probe in [
- 0,
- issued,
- now,
- expires,
- expires + 1,
- u64::from(u32::MAX),
- u64::MAX,
- ] {
- assert_eq!(
- Verdict::Valid,
- verdict_of(KEY, Some(query), &[&secret], probe),
- "{probe}"
- );
- }
- assert_eq!(
- Verdict::Mismatch,
- verdict_of(KEY, Some(query), &[&other_secret_bytes()], now)
- );
- }
-
- #[test]
- fn the_issue_window_stays_on_the_anchor_grid() {
- for offset in [0, 1, ATTACHMENT_URL_BUCKET_SECS - 1] {
- for bucket in 0..8u64 {
- let now = ANCHOR + bucket * ATTACHMENT_URL_BUCKET_SECS + offset;
- let (issued, expires) = issue_window(ANCHOR, now);
- assert_eq!(ANCHOR + bucket * ATTACHMENT_URL_BUCKET_SECS, issued);
- assert_eq!(issued + ATTACHMENT_URL_TTL_SECS, expires);
- assert!(expires - now >= ATTACHMENT_URL_TTL_SECS - ATTACHMENT_URL_BUCKET_SECS);
- }
- }
- }
-
- #[test]
- fn a_clock_behind_the_anchor_issues_the_first_bucket() {
- let (issued, expires) = issue_window(ANCHOR, ANCHOR - 5_000);
- assert_eq!(ANCHOR, issued);
- assert_eq!(ANCHOR + ATTACHMENT_URL_TTL_SECS, expires);
- }
-
- #[test]
- fn a_window_beyond_eight_hex_digits_leaves_the_url_unchanged() {
- let secret = secret_bytes();
- let signers: [Signer; 2] = [with_signature, with_data_package_signature];
- let last_fitting_anchor = WINDOW_MAX_SECS - ATTACHMENT_URL_TTL_SECS;
- for signer in signers {
- for url in [
- "https://media.test/attachments/1/2/cat.gif",
- "https://media.test/attachments/1/2/cat.gif?width=64&ex=1&&is=2&hm=3&uc=4#top",
- ] {
- for anchor in [last_fitting_anchor + 1, WINDOW_MAX_SECS, u64::MAX] {
- assert_eq!(url, signer(url, KEY, anchor, 0, &secret), "{anchor} {url}");
- }
- assert_eq!(
- url,
- signer(
- url,
- KEY,
- last_fitting_anchor,
- last_fitting_anchor + ATTACHMENT_URL_BUCKET_SECS,
- &secret
- ),
- "{url}"
- );
- let signed = signer(url, KEY, last_fitting_anchor, 0, &secret);
- assert_ne!(url, signed, "{url}");
- assert!(signed.contains(&format!("is={last_fitting_anchor:08x}&")));
- }
- }
- let signed = with_signature(
- "https://media.test/x.gif",
- KEY,
- last_fitting_anchor,
- 0,
- &secret,
- );
- assert!(signed.contains("ex=ffffffff&"), "{signed}");
- }
-
#[test]
fn verification_tries_every_configured_secret() {
let first = secret_bytes();
@@ -906,182 +761,4 @@ mod tests {
);
}
}
-
- #[test]
- fn tolerated_input_shapes_still_verify() {
- let secret = secret_bytes();
- let now = ANCHOR;
- let (issued, expires) = issue_window(ANCHOR, now);
- let signature = sign(KEY, expires, issued, UrlKind::Ordinary, &secret);
- let package = sign(KEY, 0, issued, UrlKind::DataPackage, &secret);
- for (label, query) in [
- (
- "a trailing separator",
- format!("ex={expires:08x}&is={issued:08x}&hm={signature}&"),
- ),
- (
- "a doubled separator between the fields",
- format!("ex={expires:08x}&&is={issued:08x}&hm={signature}"),
- ),
- (
- "empty pairs around the signature",
- format!("&=&ex={expires:08x}&&is={issued:08x}&hm={signature}&&"),
- ),
- (
- "signature after other parameters",
- format!("width=64&ex={expires:08x}&is={issued:08x}&hm={signature}"),
- ),
- (
- "unknown parameters between the signature fields",
- format!("ex={expires:08x}&width=64&is={issued:08x}&format=webp&hm={signature}"),
- ),
- (
- "a data package with a trailing separator",
- format!("ex=0&is={issued:08x}&hm={package}&uc=dp&"),
- ),
- (
- "a doubled separator between the data package fields",
- format!("ex=0&is={issued:08x}&&hm={package}&uc=dp"),
- ),
- (
- "data package fields in another order",
- format!("uc=dp&width=64&hm={package}&is={issued:08x}&ex=0"),
- ),
- (
- "percent escaped uc name",
- format!("ex=0&is={issued:08x}&hm={package}&%75c=dp"),
- ),
- (
- "empty pairs around a data package",
- format!("&=&ex=0&&is={issued:08x}&hm={package}&=&uc=dp&&"),
- ),
- ] {
- assert_eq!(
- Verdict::Valid,
- verdict_of(KEY, Some(&query), &[&secret], now),
- "{label}"
- );
- }
- }
-
- #[test]
- fn every_signature_parameter_name_is_recognised_after_form_decoding() {
- for name in ["ex", "is", "hm", "uc", "%65x", "%75c", "u%63", "%68%6D"] {
- assert!(is_signature_parameter_name(name), "{name}");
- }
- for name in [
- "", "e", "exp", "UC", "u+c", "u%2Bc", "%2575c", "width", "dp",
- ] {
- assert!(!is_signature_parameter_name(name), "{name}");
- }
- }
-
- #[test]
- fn a_decoded_key_names_one_object_across_every_path_spelling() {
- for (path, expected) in [
- ("/attachments/1/2/cat.gif", "attachments/1/2/cat.gif"),
- ("///attachments/1/2/cat.gif", "attachments/1/2/cat.gif"),
- ("attachments/1/2/cat.gif", "attachments/1/2/cat.gif"),
- ("/attachments/1/2/caf%C3%A9.gif", "attachments/1/2/café.gif"),
- ("/attachments/1/2/café.gif", "attachments/1/2/café.gif"),
- ("/attachments/1/2/a%2Fb.gif", "attachments/1/2/a/b.gif"),
- ("/attachments/1/2/a+b.gif", "attachments/1/2/a+b.gif"),
- ("/attachments/1/2/a%25b.gif", "attachments/1/2/a%b.gif"),
- ("/attachments/1/2/a%2.gif", "attachments/1/2/a%2.gif"),
- ] {
- assert_eq!(Some(expected.to_owned()), decode_key(path), "{path}");
- }
- for path in [
- "/attachments/1/2/caf%C3%28.gif",
- "/attachments/1/2/%FF.gif",
- "/attachments/1/2/%ED%A0%80.gif",
- ] {
- assert_eq!(None, decode_key(path), "{path}");
- }
- }
-
- #[test]
- fn signing_replaces_an_existing_signature_and_keeps_everything_else() {
- let secret = secret_bytes();
- let now = ANCHOR;
- let canonical = "https://media.test/attachments/1/2/cat.gif?width=64&height=64#anchor";
- let key = "attachments/1/2/cat.gif";
- let signed = with_signature(canonical, key, ANCHOR, now, &secret);
- assert!(signed.contains("?ex="));
- assert!(signed.ends_with("&width=64&height=64#anchor"));
- let resigned = with_signature(
- &signed,
- key,
- ANCHOR,
- now + ATTACHMENT_URL_BUCKET_SECS,
- &secret,
- );
- let package = with_data_package_signature(&resigned, key, ANCHOR, now, &secret);
- let back = with_signature(&package, key, ANCHOR, now, &secret);
- assert_eq!(signed, back);
- for url in [&resigned, &package, &back] {
- assert_eq!(1, url.matches("ex=").count(), "{url}");
- assert_eq!(1, url.matches("is=").count(), "{url}");
- assert_eq!(1, url.matches("hm=").count(), "{url}");
- assert!(url.ends_with("&width=64&height=64#anchor"), "{url}");
- }
- assert_eq!(1, package.matches("uc=dp&").count(), "{package}");
- assert!(!resigned.contains("uc="), "{resigned}");
- assert!(!back.contains("uc="), "{back}");
- }
-
- #[test]
- fn a_bare_signed_url_ends_with_its_last_signature_field() {
- let secret = secret_bytes();
- let url = "https://media.test/attachments/1/2/cat.gif";
- let key = "attachments/1/2/cat.gif";
- for (signed, names) in [
- (
- with_signature(url, key, ANCHOR, ANCHOR, &secret),
- &["ex=", "is=", "hm="][..],
- ),
- (
- with_data_package_signature(url, key, ANCHOR, ANCHOR, &secret),
- &["ex=0", "is=", "hm=", "uc=dp"][..],
- ),
- ] {
- assert!(!signed.ends_with('&'), "{signed}");
- assert!(!signed.contains("&&"), "{signed}");
- let query = signed.split_once('?').expect("a signed url has a query").1;
- let fields: Vec<&str> = query.split('&').collect();
- assert_eq!(names.len(), fields.len(), "{signed}");
- for (field, name) in fields.iter().zip(names) {
- assert!(field.starts_with(name), "{signed}");
- }
- }
- }
-
- #[test]
- fn a_preserved_parameter_follows_one_separator() {
- let secret = secret_bytes();
- let key = "attachments/1/2/cat.gif";
- let signers: [Signer; 2] = [with_signature, with_data_package_signature];
- for signer in signers {
- for (url, tail) in [
- (
- "https://media.test/attachments/1/2/cat.gif?width=100",
- "&width=100",
- ),
- (
- "https://media.test/attachments/1/2/cat.gif?width=100&height=64#top",
- "&width=100&height=64#top",
- ),
- ("https://media.test/attachments/1/2/cat.gif#top", "#top"),
- ("https://media.test/attachments/1/2/cat.gif?&=&", ""),
- ] {
- let signed = signer(url, key, ANCHOR, ANCHOR, &secret);
- assert!(signed.ends_with(tail), "{signed}");
- assert!(!signed.contains("&&"), "{signed}");
- let head = signed
- .split_once('#')
- .map_or(signed.as_str(), |(head, _)| head);
- assert!(!head.ends_with('&'), "{signed}");
- }
- }
- }
}
diff --git a/fluxer_common/src/config.rs b/fluxer_common/src/config.rs
index cc1a588ea..e7c45708a 100644
--- a/fluxer_common/src/config.rs
+++ b/fluxer_common/src/config.rs
@@ -319,281 +319,4 @@ mod tests {
);
}
}
-
- fn reader(vars: &[(&str, &str)]) -> impl FnMut(&str) -> Option<String> {
- let vars: Vec<(String, String)> = vars
- .iter()
- .map(|(name, value)| ((*name).to_owned(), (*value).to_owned()))
- .collect();
- move |name: &str| {
- vars.iter()
- .find_map(|(key, value)| (key == name).then(|| value.clone()))
- }
- }
-
- #[test]
- fn parses_a_public_origin() {
- assert_eq!(
- Some(PublicOrigin {
- scheme: "https".to_owned(),
- domain: "chat.example.com".to_owned(),
- port: 8443,
- }),
- parse_public_origin("https://chat.example.com:8443")
- );
- assert_eq!(
- Some(PublicOrigin {
- scheme: "http".to_owned(),
- domain: "chat.example.com".to_owned(),
- port: 80,
- }),
- parse_public_origin("http://chat.example.com")
- );
- assert_eq!(
- Some(PublicOrigin {
- scheme: "http".to_owned(),
- domain: "[::1]".to_owned(),
- port: 19080,
- }),
- parse_public_origin("http://[::1]:19080")
- );
- }
-
- #[test]
- fn an_explicit_default_port_normalizes_to_the_portless_form() {
- let origin = parse_public_origin("https://chat.example.com:443").expect("origin parses");
- assert_eq!(443, origin.port);
- assert_eq!(
- "https://chat.example.com/admin/oauth2_callback",
- normalize_public_endpoint(
- "https://chat.example.com/admin/oauth2_callback",
- &origin.domain,
- Some(origin.port)
- )
- );
- assert_eq!(
- 80,
- parse_public_origin("http://chat.example.com:80")
- .expect("origin parses")
- .port
- );
- }
-
- #[test]
- fn rejects_anything_that_is_not_a_bare_origin() {
- for origin in [
- "",
- " ",
- "not a url",
- "chat.example.com:8443",
- "wss://chat.example.com",
- "https://chat.example.com/media",
- "https://chat.example.com?a=1",
- "https://user:[email protected]",
- ] {
- assert_eq!(None, parse_public_origin(origin), "origin {origin}");
- }
- }
-
- #[test]
- fn the_origin_supplies_the_domain_and_the_port() {
- let (domain, port) = resolve_public_domain_and_port(reader(&[(
- "FLUXER_PUBLIC_ORIGIN",
- "https://chat.example.com:29080",
- )]))
- .expect("origin resolves");
- assert_eq!("chat.example.com", domain);
- assert_eq!(Some(29080), port);
- }
-
- #[test]
- fn the_origin_wins_over_the_named_variables() {
- let (domain, port) = resolve_public_domain_and_port(reader(&[
- ("FLUXER_PUBLIC_ORIGIN", "https://chat.example.com:29080"),
- ("FLUXER_BASE_DOMAIN", "other.example.com"),
- ("FLUXER_PUBLIC_SCHEME", "http"),
- ("FLUXER_PUBLIC_PORT", "443"),
- ]))
- .expect("the origin resolves");
- assert_eq!("chat.example.com", domain);
- assert_eq!(Some(29080), port);
- }
-
- #[test]
- fn a_malformed_public_port_is_loud() {
- for raw in ["abc", "0", "70000", "-1"] {
- let error = resolve_public_domain_and_port(reader(&[
- ("FLUXER_BASE_DOMAIN", "chat.example.com"),
- ("FLUXER_PUBLIC_PORT", raw),
- ]))
- .expect_err("a malformed port is refused");
- assert!(
- error.to_string().contains("FLUXER_PUBLIC_PORT"),
- "port {raw}"
- );
- }
- }
-
- #[test]
- fn a_malformed_public_origin_is_loud() {
- let error = resolve_public_domain_and_port(reader(&[(
- "FLUXER_PUBLIC_ORIGIN",
- "https://chat.example.com/app",
- )]))
- .expect_err("a malformed origin is refused");
- assert!(error.to_string().contains("FLUXER_PUBLIC_ORIGIN"));
- }
-
- #[test]
- fn without_an_origin_the_named_variables_are_used_as_they_are() {
- let (domain, port) = resolve_public_domain_and_port(reader(&[
- ("FLUXER_BASE_DOMAIN", "Chat.Example.com."),
- ("FLUXER_PUBLIC_PORT", "19080"),
- ]))
- .expect("named variables resolve");
- assert_eq!("chat.example.com", domain);
- assert_eq!(Some(19080), port);
- let (domain, port) = resolve_public_domain_and_port(reader(&[])).expect("empty resolves");
- assert_eq!("", domain);
- assert_eq!(None, port);
- }
-
- fn secret_file(dir: &tempfile::TempDir, name: &str, contents: &str) -> String {
- let path = dir.path().join(name);
- fs::write(&path, contents).expect("write secret file");
- path.to_string_lossy().into_owned()
- }
-
- fn pairs_reader(pairs: Vec<(String, String)>) -> impl Fn(&str) -> Option<String> {
- move |key| {
- pairs
- .iter()
- .find_map(|(name, value)| (name == key).then(|| value.clone()))
- }
- }
-
- #[test]
- fn env_value_reads_name_file_when_name_is_blank() {
- let dir = tempfile::tempdir().expect("tempdir");
- let path = secret_file(&dir, "secret", "from-file\r\n");
- let unset = pairs_reader(vec![("X_FILE".to_owned(), path.clone())]);
- let blank = pairs_reader(vec![
- ("X".to_owned(), " ".to_owned()),
- ("X_FILE".to_owned(), path),
- ]);
- assert_eq!(
- Ok(Some("from-file".to_owned())),
- resolve_env_value("X", unset)
- );
- assert_eq!(
- Ok(Some("from-file".to_owned())),
- resolve_env_value("X", blank)
- );
- }
-
- #[test]
- fn env_value_trims_only_one_trailing_newline() {
- let dir = tempfile::tempdir().expect("tempdir");
- let pem = secret_file(&dir, "pem", "-----BEGIN-----\nabc\n-----END-----\n\n");
- let empty = secret_file(&dir, "empty", "\n");
- assert_eq!(
- Ok(Some("-----BEGIN-----\nabc\n-----END-----\n".to_owned())),
- resolve_env_value("X", pairs_reader(vec![("X_FILE".to_owned(), pem)]))
- );
- assert_eq!(
- Ok(None),
- resolve_env_value("X", pairs_reader(vec![("X_FILE".to_owned(), empty)]))
- );
- }
-
- #[test]
- fn env_value_rejects_name_and_name_file_together() {
- let reader = pairs_reader(vec![
- ("X".to_owned(), "direct".to_owned()),
- ("X_FILE".to_owned(), "/run/secrets/x".to_owned()),
- ]);
- assert_eq!(
- Err("X and X_FILE are both set, set only one".to_owned()),
- resolve_env_value("X", reader)
- );
- }
-
- #[test]
- fn env_value_names_the_file_when_it_is_missing() {
- let dir = tempfile::tempdir().expect("tempdir");
- let path = dir.path().join("missing").to_string_lossy().into_owned();
- let error = resolve_env_value("X", pairs_reader(vec![("X_FILE".to_owned(), path.clone())]))
- .expect_err("missing file fails");
- assert!(error.starts_with(&format!("X_FILE could not read {path} (")));
- }
-
- #[test]
- fn resolve_env_files_replaces_fluxer_names_with_file_values() {
- let dir = tempfile::tempdir().expect("tempdir");
- let path = secret_file(&dir, "secret", "from-file\n");
- let missing = dir.path().join("missing").to_string_lossy().into_owned();
- let resolved = resolve_env_files(vec![
- ("FLUXER_X".to_owned(), String::new()),
- ("FLUXER_X_FILE".to_owned(), path),
- ("FLUXER_Y".to_owned(), "plain".to_owned()),
- ("FLUXER_Y_FILE".to_owned(), String::new()),
- ("SSL_CERT_FILE".to_owned(), missing),
- ])
- .expect("resolves");
- let values = |key: &str| {
- resolved
- .iter()
- .filter(|(name, _)| name == key)
- .map(|(_, value)| value.as_str())
- .collect::<Vec<_>>()
- };
- assert_eq!(vec!["from-file"], values("FLUXER_X"));
- assert_eq!(vec!["plain"], values("FLUXER_Y"));
- assert!(
- resolve_env_files(vec![
- ("FLUXER_X".to_owned(), "direct".to_owned()),
- ("FLUXER_X_FILE".to_owned(), "/run/secrets/x".to_owned()),
- ])
- .is_err()
- );
- }
-
- #[test]
- fn a_blank_value_reads_as_unset() {
- unsafe {
- env::set_var("FLUXER_COMMON_TEST_BLANK_EMPTY", "");
- env::set_var("FLUXER_COMMON_TEST_BLANK_SPACES", " \t");
- env::set_var("FLUXER_COMMON_TEST_BLANK_SET", "value");
- env::set_var("FLUXER_COMMON_TEST_BLANK_TRUE", "true");
- }
- assert_eq!(None, env_value("FLUXER_COMMON_TEST_BLANK_EMPTY"));
- assert_eq!(None, env_value("FLUXER_COMMON_TEST_BLANK_SPACES"));
- assert_eq!(None, env_value("FLUXER_COMMON_TEST_BLANK_MISSING"));
- assert_eq!(
- "fallback",
- read_env("FLUXER_COMMON_TEST_BLANK_EMPTY", "fallback")
- );
- assert_eq!(
- "fallback",
- read_env("FLUXER_COMMON_TEST_BLANK_SPACES", "fallback")
- );
- assert_eq!(
- "value",
- read_env("FLUXER_COMMON_TEST_BLANK_SET", "fallback")
- );
- assert_eq!(
- "value",
- read_first_env(
- &[
- "FLUXER_COMMON_TEST_BLANK_EMPTY",
- "FLUXER_COMMON_TEST_BLANK_SPACES",
- "FLUXER_COMMON_TEST_BLANK_SET",
- ],
- "fallback"
- )
- );
- assert!(read_bool_env("FLUXER_COMMON_TEST_BLANK_EMPTY", true));
- assert!(read_bool_env("FLUXER_COMMON_TEST_BLANK_SPACES", true));
- assert!(read_bool_env("FLUXER_COMMON_TEST_BLANK_TRUE", false));
- }
}
diff --git a/fluxer_common/src/external_media_path.rs b/fluxer_common/src/external_media_path.rs
index 090107c65..1d0c7f119 100644
--- a/fluxer_common/src/external_media_path.rs
+++ b/fluxer_common/src/external_media_path.rs
@@ -328,50 +328,4 @@ mod tests {
);
}
}
-
- #[test]
- fn round_trips_every_shape() {
- for url in [
- "https://static.klipy.com/ii/c8/28/HkAKKCzZ.webp",
- "https://static.klipy.com/ii/HkAKKCzZ.webp?v=query_param&goes=here",
- "https://example.com:8443/a.png",
- "https://avatars.githubusercontent.com/u/241303489?v=4",
- "http://example.com/plain.gif",
- "https://example.com/file.png?a=1&b=2&c=3",
- ] {
- let path = build_external_media_proxy_path(url).unwrap();
- assert_eq!(
- url,
- reconstruct_original_url(&path).unwrap(),
- "round trip {url}"
- );
- }
- }
-
- #[test]
- fn does_not_double_the_question_mark() {
- let decoded = reconstruct_original_url("%3Fa%3D1/https/example.com/x.png").unwrap();
- assert_eq!("https://example.com/x.png?a=1", decoded);
- assert!(!decoded.contains("??"));
- }
-
- #[test]
- fn still_accepts_a_query_without_a_leading_question_mark() {
- assert_eq!(
- "https://example.com/x.png?a=1",
- reconstruct_original_url("a%3D1/https/example.com/x.png").unwrap()
- );
- }
-
- #[test]
- fn rejects_a_url_without_a_scheme() {
- assert!(build_external_media_proxy_path("example.com/a.png").is_err());
- }
-
- #[test]
- fn v2_path_roundtrip() {
- let path = build_opaque_external_media_proxy_path("https://example.com/a b.png?x=1");
- let decoded = reconstruct_original_url(&path).unwrap();
- assert_eq!("https://example.com/a b.png?x=1", decoded);
- }
}
diff --git a/fluxer_common/src/user_flags.rs b/fluxer_common/src/user_flags.rs
index f3c03f4dd..0dc1130fd 100644
--- a/fluxer_common/src/user_flags.rs
+++ b/fluxer_common/src/user_flags.rs
@@ -59,40 +59,6 @@ impl AccountStanding {
mod tests {
use super::*;
- const NOW: i64 = 1_790_000_000_000;
-
- fn standing(flags: i64) -> AccountStanding {
- AccountStanding {
- flags,
- ..AccountStanding::default()
- }
- }
-
- #[test]
- fn profile_hidden_follows_enforcement_state() {
- assert!(!standing(0).profile_hidden(NOW));
- assert!(standing(USER_FLAG_PROFILE_HIDDEN).profile_hidden(NOW));
- assert!(standing(USER_FLAG_SPAMMER).profile_hidden(NOW));
- assert!(!standing(USER_FLAG_DISABLED).profile_hidden(NOW));
- let banned = AccountStanding {
- temp_banned_until_ms: Some(NOW + 1),
- ..standing(USER_FLAG_DISABLED)
- };
- assert!(banned.profile_hidden(NOW));
- assert!(!banned.profile_hidden(NOW + 1));
- let deleting = |code| AccountStanding {
- pending_deletion_at_ms: Some(NOW),
- deletion_reason_code: Some(code),
- ..standing(USER_FLAG_DELETED)
- };
- assert!(deleting(3).profile_hidden(NOW));
- assert!(deleting(20).profile_hidden(NOW));
- for code in NON_ENFORCEMENT_DELETION_REASONS {
- assert!(!deleting(code).profile_hidden(NOW), "{code}");
- }
- assert!(!standing(USER_FLAG_DELETED | USER_FLAG_SPAMMER).profile_hidden(NOW));
- }
-
#[test]
fn the_hidden_bit_is_never_public() {
assert_eq!(
diff --git a/fluxer_svc/src/metrics.rs b/fluxer_svc/src/metrics.rs
index cf367c7e5..5a60ab47c 100644
--- a/fluxer_svc/src/metrics.rs
+++ b/fluxer_svc/src/metrics.rs
@@ -129,30 +129,3 @@ fn render_histogram(out: &mut String, name: &str, hist: &Histogram) {
let _ = writeln!(out, "# TYPE {name} histogram");
let _ = hist.render_series(out, name, None);
}
-
-#[cfg(test)]
-mod tests {
- use super::*;
-
- #[test]
- fn render_prometheus_produces_valid_output() {
- let m = ServiceMetrics::default();
- m.init();
- m.record_request();
- m.record_request();
- m.record_request_error();
- m.record_cache_hit();
- m.record_request_duration(42);
-
- let text = m.render_prometheus("user_svc");
- assert!(text.contains("# TYPE fluxer_user_svc_requests_total counter"));
- assert!(text.contains("fluxer_user_svc_requests_total 2"));
- assert!(text.contains("# TYPE fluxer_user_svc_request_errors_total counter"));
- assert!(text.contains("fluxer_user_svc_request_errors_total 1"));
- assert!(text.contains("# TYPE fluxer_user_svc_cache_hits_total counter"));
- assert!(text.contains("fluxer_user_svc_cache_hits_total 1"));
- assert!(text.contains("# TYPE fluxer_user_svc_request_duration_ms histogram"));
- assert!(text.contains("fluxer_user_svc_request_duration_ms_bucket{le=\"50\"} 1"));
- assert!(text.contains("# TYPE fluxer_user_svc_uptime_seconds gauge"));
- }
-}
diff --git a/fluxer_svc/src/postgres.rs b/fluxer_svc/src/postgres.rs
index 973cb05f5..4b93ceb66 100644
--- a/fluxer_svc/src/postgres.rs
+++ b/fluxer_svc/src/postgres.rs
@@ -203,12 +203,8 @@ pub async fn ensure_kv_schema(pool: &Pool, kv_table: &str) -> anyhow::Result<()>
async fn ensure_kv_schema_once(pool: &Pool, kv_table: &str) -> anyhow::Result<()> {
let table = quote_identifier(kv_table)?;
let old_partition_index = quote_identifier(&format!("{kv_table}_partition_idx"))?;
- let partition_row_index = quote_identifier(&format!("{kv_table}_partition_row_idx"))?;
let row_key_c_index = quote_identifier(&format!("{kv_table}_row_key_c_idx"))?;
let expires_index = quote_identifier(&format!("{kv_table}_expires_idx"))?;
- let messages_message_index = quote_identifier(&format!("{kv_table}_messages_message_idx"))?;
- let message_reactions_message_index =
- quote_identifier(&format!("{kv_table}_message_reactions_message_idx"))?;
let mut client = pool.get().await?;
let transaction = client
.transaction()
@@ -247,7 +243,6 @@ CREATE TABLE IF NOT EXISTS {table} (
updated_at timestamptz NOT NULL DEFAULT now(),
PRIMARY KEY (table_name, row_key)
);
-CREATE INDEX IF NOT EXISTS {partition_row_index} ON {table} (table_name, partition_key, row_key);
"#
))
.await
@@ -264,8 +259,6 @@ CREATE INDEX IF NOT EXISTS {partition_row_index} ON {table} (table_name, partiti
.batch_execute(&format!(
r#"
CREATE INDEX IF NOT EXISTS {expires_index} ON {table} (expires_at) WHERE expires_at IS NOT NULL;
-CREATE INDEX IF NOT EXISTS {messages_message_index} ON {table} (partition_key, ((CASE WHEN row_data -> 'message_id' ->> 'value' ~ '^-?[0-9]+$' THEN (row_data -> 'message_id' ->> 'value')::bigint END))) WHERE table_name = 'messages';
-CREATE INDEX IF NOT EXISTS {message_reactions_message_index} ON {table} (partition_key, ((CASE WHEN row_data -> 'message_id' ->> 'value' ~ '^-?[0-9]+$' THEN (row_data -> 'message_id' ->> 'value')::bigint END))) WHERE table_name = 'message_reactions';
"#
))
.await
@@ -506,7 +499,6 @@ impl KvClient {
let client = self.pool.get().await?;
let field_expr = json_field_expr(field_name)?;
let direction = if desc { "DESC" } else { "ASC" };
- let base = &self.get_partition_rows_sql;
let rows = match bound {
Some(BigIntBound::LessThan(value)) => {
let sql = format!(
@@ -745,27 +737,6 @@ mod tests {
use super::*;
use serde_json::json;
- fn ssl_mode_for(url: &str, ssl: bool) -> SslMode {
- let mut pg = PgConfig::from_str(url).unwrap();
- apply_ssl_mode(&mut pg, ssl);
- pg.get_ssl_mode()
- }
-
- #[test]
- fn ssl_flag_decides_tls_unless_url_names_a_mode() {
- let socket = "postgres://fluxer@/fluxer?host=/run/postgresql";
- assert_eq!(SslMode::Disable, ssl_mode_for(socket, false));
- assert_eq!(SslMode::Require, ssl_mode_for(socket, true));
- assert_eq!(
- SslMode::Require,
- ssl_mode_for("postgres://db.example.com/fluxer?sslmode=require", false)
- );
- assert_eq!(
- SslMode::Require,
- ssl_mode_for("postgres://db.example.com/fluxer?sslmode=disable", true)
- );
- }
-
#[test]
fn encodes_row_keys_like_postgres_kv_executor() {
assert_eq!(
@@ -812,76 +783,6 @@ mod tests {
assert_eq!(decoded["metadata"], json!([["kind", 9]]));
}
- fn test_postgres_config(kv_table: &str) -> PostgresConfig {
- PostgresConfig {
- url: None,
- host: "127.0.0.1".to_owned(),
- port: 5432,
- database: "fluxer".to_owned(),
- username: "fluxer".to_owned(),
- password: None,
- ssl: false,
- ssl_ca: None,
- max_connections: 1,
- kv_table: kv_table.to_owned(),
- prepared_statements: true,
- }
- }
-
- fn test_kv_client(kv_table: &str) -> KvClient {
- let pg = PgConfig::from_str("postgres://[email protected]:5432/fluxer").unwrap();
- let manager = Manager::new(pg, build_disabled_tls_connector());
- let pool = Pool::builder(manager).max_size(1).build().unwrap();
- KvClient::new(pool, &test_postgres_config(kv_table)).unwrap()
- }
-
- #[test]
- fn hoists_kv_statements_for_the_quoted_table() {
- let kv = test_kv_client("fluxer_kv");
-
- assert_eq!(
- kv.get_row_sql,
- "SELECT row_data FROM \"fluxer_kv\" WHERE table_name = $1 AND row_key = $2 AND (expires_at IS NULL OR expires_at > now()) LIMIT 1"
- );
- assert_eq!(
- kv.get_rows_sql,
- "SELECT row_key, row_data FROM \"fluxer_kv\" WHERE table_name = $1 AND row_key = ANY($2::text[]) AND (expires_at IS NULL OR expires_at > now())"
- );
- assert_eq!(
- kv.get_partition_rows_sql,
- "SELECT row_key, row_data FROM \"fluxer_kv\" WHERE table_name = $1 AND partition_key = $2 AND (expires_at IS NULL OR expires_at > now())"
- );
- assert_eq!(
- kv.delete_row_sql,
- "DELETE FROM \"fluxer_kv\" WHERE table_name = $1 AND row_key = $2"
- );
- }
-
- #[test]
- fn passes_the_prepared_statement_switch_onto_the_client() {
- let mut config = test_postgres_config("fluxer_kv");
- config.prepared_statements = false;
- let pg = PgConfig::from_str("postgres://[email protected]:5432/fluxer").unwrap();
- let manager = Manager::new(pg, build_disabled_tls_connector());
- let pool = Pool::builder(manager).max_size(1).build().unwrap();
-
- assert!(!KvClient::new(pool, &config).unwrap().prepared_statements);
- assert!(test_kv_client("fluxer_kv").prepared_statements);
- }
-
- #[test]
- fn caches_only_closed_set_json_fields() {
- assert!(is_cached_json_field("message_id"));
- assert!(!is_cached_json_field("user_id"));
- assert!(!is_cached_json_field("a0"));
- assert!(!is_cached_json_field(""));
- assert!(
- CACHED_JSON_FIELDS
- .iter()
- .all(|field| is_safe_identifier(field))
- );
- }
-
#[test]
fn rejects_unsafe_identifiers() {
assert!(quote_identifier("fluxer_kv").is_ok());
diff --git a/fluxer_svc/src/scylla.rs b/fluxer_svc/src/scylla.rs
index 56e05f420..bb0ab75e1 100644
--- a/fluxer_svc/src/scylla.rs
+++ b/fluxer_svc/src/scylla.rs
@@ -84,16 +84,3 @@ fn resolve_contact_point(host: &str) -> anyhow::Result<SocketAddr> {
.next()
.ok_or_else(|| anyhow::anyhow!("failed to resolve contact point: {host}"))
}
-
-#[cfg(test)]
-mod tests {
- use super::*;
-
- #[test]
- fn request_timeout_stays_below_the_shard_request_budget() {
- assert!(
- REQUEST_TIMEOUT < crate::router::SHARD_REQUEST_TIMEOUT,
- "scylla request timeout {REQUEST_TIMEOUT:?} outlives the shard budget"
- );
- }
-}
diff --git a/fluxer_svc/src/shard.rs b/fluxer_svc/src/shard.rs
index d45ac26f6..8df86e695 100644
--- a/fluxer_svc/src/shard.rs
+++ b/fluxer_svc/src/shard.rs
@@ -81,13 +81,10 @@ where
let is_serving = Arc::new(AtomicBool::new(false));
let request_permits = Arc::new(Semaphore::new(config.max_concurrent_requests));
- is_serving.store(true, Ordering::SeqCst);
-
let mut tasks = JoinSet::new();
let http_is_serving = is_serving.clone();
let http_metrics = metrics.clone();
- let http_name = name.clone();
tasks.spawn(async move {
crate::server::run_http(health_addr, http_is_serving, http_metrics, http_name).await
});
@@ -271,7 +268,6 @@ mod tests {
use crate::transport::InMemoryTransport;
use serde::{Deserialize, Serialize};
use std::time::Duration;
- use tokio::sync::Notify;
#[derive(Serialize, Deserialize)]
struct MockRequest {
@@ -283,24 +279,6 @@ mod tests {
key: String,
}
- struct BlockingShard {
- started: Arc<Notify>,
- }
-
- impl ShardService for BlockingShard {
- type Request = MockRequest;
- type Response = MockResponse;
-
- fn service_name(&self) -> &str {
- "mock"
- }
-
- async fn handle(&self, _request: MockRequest) -> anyhow::Result<MockResponse> {
- self.started.notify_one();
- std::future::pending().await
- }
- }
-
struct EchoShard;
impl ShardService for EchoShard {
@@ -374,56 +352,6 @@ mod tests {
shard_task.abort();
}
- #[tokio::test]
- async fn shard_sheds_requests_when_permits_are_exhausted() {
- let transport = InMemoryTransport::new();
- let started = Arc::new(Notify::new());
- let shard = BlockingShard {
- started: started.clone(),
- };
- let config = test_config(1);
- let shard_transport = transport.clone();
- let shard_task =
- tokio::spawn(async move { run_shard(&config, shard, shard_transport).await });
-
- tokio::time::sleep(Duration::from_millis(25)).await;
-
- let payload = rmp_serde::to_vec_named(&MockRequest {
- key: "a".to_owned(),
- })
- .unwrap();
-
- let client = {
- let transport = transport.clone();
- let payload = payload.clone();
- tokio::spawn(async move {
- transport
- .request("svc.mock.shard.0", &payload, Duration::from_secs(10))
- .await
- })
- };
-
- tokio::time::timeout(Duration::from_millis(250), started.notified())
- .await
- .expect("shard should start the first request and hold the only permit");
-
- let response = tokio::time::timeout(
- Duration::from_millis(250),
- transport.request("svc.mock.shard.0", &payload, Duration::from_secs(1)),
- )
- .await
- .expect("shed reply should not wait behind the in-flight request")
- .unwrap();
-
- assert_eq!(
- serde_json::from_slice::<serde_json::Value>(&response).unwrap(),
- serde_json::json!({"error": "overloaded"})
- );
-
- client.abort();
- shard_task.abort();
- }
-
fn test_config(max_concurrent_requests: usize) -> ServiceConfig {
ServiceConfig {
service_name: "mock".to_owned(),
diff --git a/fluxer_svc/tests/postgres_kv_schema.rs b/fluxer_svc/tests/postgres_kv_schema.rs
deleted file mode 100644
index 3b2eb237c..000000000
--- a/fluxer_svc/tests/postgres_kv_schema.rs
+++ /dev/null
@@ -1,279 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-
-use deadpool_postgres::Pool;
-use fluxer_svc::postgres::{PostgresConfig, connect, ensure_kv_schema};
-use std::net::TcpListener;
-use std::process::{Command, Stdio};
-use std::time::Duration;
-
-const KV_TABLE_WARMUP: &str = "svc_schema_warmup";
-const KV_TABLE_BOOT: &str = "svc_schema_boot";
-const KV_TABLE_HELPER: &str = "svc_schema_helper";
-const KV_TABLE_RACE: &str = "svc_schema_race";
-const KV_TABLE_BACKFILL: &str = "svc_schema_backfill";
-const SEPARATOR: char = '\u{1f}';
-
-fn docker_available() -> bool {
- Command::new("docker")
- .arg("version")
- .stdin(Stdio::null())
- .stdout(Stdio::null())
- .stderr(Stdio::null())
- .status()
- .is_ok_and(|status| status.success())
-}
-
-fn docker(args: &[&str]) -> anyhow::Result<()> {
- let output = Command::new("docker").args(args).output()?;
- if output.status.success() {
- return Ok(());
- }
- anyhow::bail!(
- "docker {} failed: {}",
- args.join(" "),
- String::from_utf8_lossy(&output.stderr).trim().to_owned()
- )
-}
-
-fn free_port() -> anyhow::Result<u16> {
- let listener = TcpListener::bind("127.0.0.1:0")?;
- Ok(listener.local_addr()?.port())
-}
-
-fn postgres_config(port: u16, kv_table: &str, max_connections: usize) -> PostgresConfig {
- PostgresConfig {
- url: None,
- host: "127.0.0.1".to_owned(),
- port,
- database: "fluxer".to_owned(),
- username: "fluxer".to_owned(),
- password: Some("fluxer".to_owned()),
- ssl: false,
- ssl_ca: None,
- max_connections,
- kv_table: kv_table.to_owned(),
- prepared_statements: true,
- }
-}
-
-fn start_postgres(container: &str, port: u16) -> anyhow::Result<()> {
- docker(&[
- "run",
- "-d",
- "--name",
- container,
- "-e",
- "POSTGRES_USER=fluxer",
- "-e",
- "POSTGRES_PASSWORD=fluxer",
- "-e",
- "POSTGRES_DB=fluxer",
- "-p",
- &format!("127.0.0.1:{port}:5432"),
- "postgres:16-alpine",
- "-c",
- "fsync=off",
- "-c",
- "synchronous_commit=off",
- ])
-}
-
-async fn wait_for_postgres(container: &str, port: u16) -> anyhow::Result<()> {
- for _ in 0..180 {
- tokio::time::sleep(Duration::from_millis(500)).await;
- if docker(&[
- "exec",
- container,
- "pg_isready",
- "-U",
- "fluxer",
- "-d",
- "fluxer",
- ])
- .is_err()
- {
- continue;
- }
- if let Ok(pool) = connect(&postgres_config(port, KV_TABLE_WARMUP, 1)).await {
- pool.close();
- return Ok(());
- }
- }
- anyhow::bail!("postgres never came up")
-}
-
-fn unlocked_create_table_sql(kv_table: &str) -> String {
- format!(
- r#"
-CREATE TABLE IF NOT EXISTS "{kv_table}" (
- table_name text NOT NULL,
- partition_key text COLLATE "C" NOT NULL,
- row_key text COLLATE "C" NOT NULL,
- row_data jsonb NOT NULL,
- expires_at timestamptz,
- updated_at timestamptz NOT NULL DEFAULT now(),
- PRIMARY KEY (table_name, row_key)
-);
-"#
- )
-}
-
-fn legacy_row_key(id: &str) -> String {
- format!("\"c\"{SEPARATOR}\"b\"{SEPARATOR}\"{id}\"")
-}
-
-fn migrated_partition_key() -> String {
- format!("\"c\"{SEPARATOR}\"b\"")
-}
-
-async fn insert_legacy_message(pool: &Pool, kv_table: &str, id: &str) -> anyhow::Result<()> {
- let client = pool.get().await?;
- client
- .execute(
- &format!(
- "INSERT INTO \"{kv_table}\" (table_name, partition_key, row_key, row_data) VALUES ('messages', $1, $1, '{{}}'::jsonb)"
- ),
- &[&legacy_row_key(id)],
- )
- .await?;
- Ok(())
-}
-
-async fn partition_key_of(pool: &Pool, kv_table: &str, id: &str) -> anyhow::Result<Option<String>> {
- let client = pool.get().await?;
- let row = client
- .query_opt(
- &format!(
- "SELECT partition_key FROM \"{kv_table}\" WHERE table_name = 'messages' AND row_key = $1"
- ),
- &[&legacy_row_key(id)],
- )
- .await?;
- Ok(row.map(|row| row.get::<_, String>("partition_key")))
-}
-
-async fn migration_marker_count(pool: &Pool, kv_table: &str) -> anyhow::Result<i64> {
- let client = pool.get().await?;
- let row = client
- .query_one(
- &format!(
- "SELECT count(*) AS n FROM \"{kv_table}\" WHERE table_name = '__fluxer_schema_migrations' AND row_key = 'messages_partition_key_v1'"
- ),
- &[],
- )
- .await?;
- Ok(row.get::<_, i64>("n"))
-}
-
-#[tokio::test(flavor = "multi_thread")]
-async fn concurrent_boots_all_ensure_the_kv_schema() -> anyhow::Result<()> {
- if !docker_available() {
- eprintln!("skipping: docker is not available");
- return Ok(());
- }
- let port = free_port()?;
- let container = format!("fluxer-kvschema-boot-{}-{port}", std::process::id());
- start_postgres(&container, port)?;
- let result = async {
- wait_for_postgres(&container, port).await?;
- let mut handles = Vec::new();
- for _ in 0..4 {
- handles.push(tokio::spawn(async move {
- connect(&postgres_config(port, KV_TABLE_BOOT, 2))
- .await
- .map(|pool| pool.close())
- }));
- }
- let mut outcomes = Vec::new();
- for handle in handles {
- outcomes.push(match handle.await? {
- Ok(()) => "ok".to_owned(),
- Err(err) => format!("{err:#}"),
- });
- }
- anyhow::Ok(outcomes)
- }
- .await;
- let _ = docker(&["rm", "-f", &container]);
- let outcomes = result?;
- assert_eq!(outcomes, vec!["ok".to_owned(); 4], "{outcomes:#?}");
- Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread")]
-async fn boot_survives_a_peer_that_creates_the_table_without_the_schema_lock() -> anyhow::Result<()>
-{
- if !docker_available() {
- eprintln!("skipping: docker is not available");
- return Ok(());
- }
- let port = free_port()?;
- let container = format!("fluxer-kvschema-race-{}-{port}", std::process::id());
- start_postgres(&container, port)?;
- let result = async {
- wait_for_postgres(&container, port).await?;
- let helper = connect(&postgres_config(port, KV_TABLE_HELPER, 4)).await?;
- let mut peer = helper.get().await?;
- let peer_transaction = peer.transaction().await?;
- peer_transaction
- .batch_execute(&unlocked_create_table_sql(KV_TABLE_RACE))
- .await?;
- let booting = tokio::spawn(async move {
- connect(&postgres_config(port, KV_TABLE_RACE, 2))
- .await
- .map(|pool| pool.close())
- });
- tokio::time::sleep(Duration::from_millis(500)).await;
- peer_transaction.commit().await?;
- let booted = match booting.await? {
- Ok(()) => "ok".to_owned(),
- Err(err) => format!("{err:#}"),
- };
- drop(peer);
- helper.close();
- anyhow::Ok(booted)
- }
- .await;
- let _ = docker(&["rm", "-f", &container]);
- let booted = result?;
- assert_eq!(booted, "ok");
- Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread")]
-async fn backfills_message_partition_keys_once_and_never_scans_again() -> anyhow::Result<()> {
- if !docker_available() {
- eprintln!("skipping: docker is not available");
- return Ok(());
- }
- let port = free_port()?;
- let container = format!("fluxer-kvschema-backfill-{}-{port}", std::process::id());
- start_postgres(&container, port)?;
- let result = async {
- wait_for_postgres(&container, port).await?;
- let helper = connect(&postgres_config(port, KV_TABLE_HELPER, 4)).await?;
- helper
- .get()
- .await?
- .batch_execute(&unlocked_create_table_sql(KV_TABLE_BACKFILL))
- .await?;
- insert_legacy_message(&helper, KV_TABLE_BACKFILL, "m1").await?;
- ensure_kv_schema(&helper, KV_TABLE_BACKFILL).await?;
- let first = partition_key_of(&helper, KV_TABLE_BACKFILL, "m1").await?;
- let markers = migration_marker_count(&helper, KV_TABLE_BACKFILL).await?;
- insert_legacy_message(&helper, KV_TABLE_BACKFILL, "m2").await?;
- ensure_kv_schema(&helper, KV_TABLE_BACKFILL).await?;
- let untouched = partition_key_of(&helper, KV_TABLE_BACKFILL, "m2").await?;
- let still_migrated = partition_key_of(&helper, KV_TABLE_BACKFILL, "m1").await?;
- helper.close();
- anyhow::Ok((first, markers, untouched, still_migrated))
- }
- .await;
- let _ = docker(&["rm", "-f", &container]);
- let (first, markers, untouched, still_migrated) = result?;
- assert_eq!(first, Some(migrated_partition_key()));
- assert_eq!(markers, 1);
- assert_eq!(untouched, Some(legacy_row_key("m2")));
- assert_eq!(still_migrated, Some(migrated_partition_key()));
- Ok(())
-}
diff --git a/fluxer_svc/tests/postgres_prepared_statements.rs b/fluxer_svc/tests/postgres_prepared_statements.rs
deleted file mode 100644
index 123cfbcbf..000000000
--- a/fluxer_svc/tests/postgres_prepared_statements.rs
+++ /dev/null
@@ -1,333 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-
-use deadpool_postgres::Pool;
-use fluxer_svc::postgres::{BigIntBound, KvClient, PostgresConfig, connect};
-use serde_json::{Value, json};
-use std::net::TcpListener;
-use std::process::{Command, Stdio};
-use std::time::Duration;
-use tokio_postgres::types::Type;
-
-const KV_TABLE: &str = "svc_stmt_names";
-const KV_TABLE_POOLED: &str = "svc_pooled_stmt_names";
-const TABLE_NAME: &str = "messages";
-
-fn docker_available() -> bool {
- Command::new("docker")
- .arg("version")
- .stdin(Stdio::null())
- .stdout(Stdio::null())
- .stderr(Stdio::null())
- .status()
- .is_ok_and(|status| status.success())
-}
-
-fn docker(args: &[&str]) -> anyhow::Result<()> {
- let output = Command::new("docker").args(args).output()?;
- if output.status.success() {
- return Ok(());
- }
- anyhow::bail!(
- "docker {} failed: {}",
- args.join(" "),
- String::from_utf8_lossy(&output.stderr).trim().to_owned()
- )
-}
-
-fn executed_statements(container: &str, kv_table: &str) -> anyhow::Result<Vec<String>> {
- let output = Command::new("docker").args(["logs", container]).output()?;
- let needle = format!("\"{kv_table}\"");
- Ok(String::from_utf8_lossy(&output.stderr)
- .lines()
- .chain(String::from_utf8_lossy(&output.stdout).lines())
- .filter(|line| line.contains("execute ") && line.contains(&needle))
- .map(str::to_owned)
- .collect())
-}
-
-fn free_port() -> anyhow::Result<u16> {
- let listener = TcpListener::bind("127.0.0.1:0")?;
- Ok(listener.local_addr()?.port())
-}
-
-fn postgres_config(port: u16, kv_table: &str, prepared_statements: bool) -> PostgresConfig {
- PostgresConfig {
- url: None,
- host: "127.0.0.1".to_owned(),
- port,
- database: "fluxer".to_owned(),
- username: "fluxer".to_owned(),
- password: Some("fluxer".to_owned()),
- ssl: false,
- ssl_ca: None,
- max_connections: 1,
- kv_table: kv_table.to_owned(),
- prepared_statements,
- }
-}
-
-fn tagged_bigint(value: i64) -> Value {
- json!({"__fluxer_type": "bigint", "value": value.to_string()})
-}
-
-fn seed_rows() -> Vec<(&'static str, &'static str, Value)> {
- vec![
- (
- "p0",
- "r1",
- json!({"message_id": tagged_bigint(10), "user_id": tagged_bigint(1010), "payload": "one"}),
- ),
- (
- "p0",
- "r2",
- json!({"message_id": tagged_bigint(20), "user_id": tagged_bigint(1020), "payload": "two"}),
- ),
- (
- "p0",
- "r3",
- json!({"message_id": tagged_bigint(30), "user_id": tagged_bigint(1030), "payload": "three"}),
- ),
- (
- "p1",
- "z9",
- json!({"message_id": tagged_bigint(40), "user_id": tagged_bigint(1040), "payload": "four"}),
- ),
- ]
-}
-
-async fn seed(kv: &KvClient, kv_table: &str) -> anyhow::Result<()> {
- let sql = format!(
- "INSERT INTO \"{kv_table}\" (table_name, partition_key, row_key, row_data) VALUES ($1, $2, $3, $4)"
- );
- for (partition_key, row_key, row_data) in seed_rows() {
- kv.query(
- &sql,
- &[
- (&TABLE_NAME, Type::TEXT),
- (&partition_key, Type::TEXT),
- (&row_key, Type::TEXT),
- (&row_data, Type::JSONB),
- ],
- )
- .await?;
- }
- Ok(())
-}
-
-fn render(rows: Vec<(String, Value)>) -> String {
- rows.into_iter()
- .map(|(row_key, row_data)| format!("{row_key}={row_data}"))
- .collect::<Vec<_>>()
- .join("|")
-}
-
-fn render_sorted(mut rows: Vec<(String, Value)>) -> String {
- rows.sort_by(|left, right| left.0.cmp(&right.0));
- render(rows)
-}
-
-async fn exercise_kv_shapes(kv: &KvClient) -> anyhow::Result<Vec<String>> {
- let mut observations = Vec::new();
- observations.push(format!("{:?}", kv.get_row(TABLE_NAME, "r1").await?));
- observations.push(format!("{:?}", kv.get_row(TABLE_NAME, "missing").await?));
- observations.push(render_sorted(
- kv.get_rows(TABLE_NAME, &["r1".to_owned(), "r3".to_owned()])
- .await?,
- ));
- observations.push(render_sorted(kv.get_rows(TABLE_NAME, &[]).await?));
- observations.push(render_sorted(
- kv.get_partition_rows(TABLE_NAME, "p0").await?,
- ));
- observations.push(render(
- kv.get_partition_rows_by_bigint_field(
- TABLE_NAME,
- "p0",
- "message_id",
- Some(BigIntBound::LessThan(30)),
- true,
- 10,
- )
- .await?,
- ));
- observations.push(render(
- kv.get_partition_rows_by_bigint_field(
- TABLE_NAME,
- "p0",
- "message_id",
- Some(BigIntBound::GreaterThan(10)),
- false,
- 10,
- )
- .await?,
- ));
- observations.push(render(
- kv.get_partition_rows_by_bigint_field(TABLE_NAME, "p0", "message_id", None, true, 2)
- .await?,
- ));
- observations.push(render(
- kv.get_partition_rows_by_bigint_field(TABLE_NAME, "p0", "user_id", None, false, 10)
- .await?,
- ));
- observations.push(render(
- kv.get_partition_rows_by_bigint_field(TABLE_NAME, "p0", "message_id", None, true, 0)
- .await?,
- ));
- observations.push(render_sorted(
- kv.get_partition_rows_by_bigint_field_values(TABLE_NAME, "p0", "message_id", &[10, 30])
- .await?,
- ));
- observations.push(render_sorted(
- kv.get_partition_rows_by_bigint_field_values(TABLE_NAME, "p0", "message_id", &[])
- .await?,
- ));
- kv.delete_row(TABLE_NAME, "r2").await?;
- observations.push(render_sorted(
- kv.get_partition_rows(TABLE_NAME, "p0").await?,
- ));
- Ok(observations)
-}
-
-struct KvRun {
- observations: Vec<String>,
- prepared: Vec<String>,
- after_session_reset: String,
-}
-
-async fn prepared_statement_texts(pool: &Pool) -> anyhow::Result<Vec<String>> {
- let client = pool.get().await?;
- let rows = client
- .query_typed(
- "SELECT statement FROM pg_prepared_statements ORDER BY statement",
- &[],
- )
- .await?;
- Ok(rows
- .iter()
- .map(|row| row.get::<_, String>("statement"))
- .collect())
-}
-
-async fn discard_session_state(pool: &Pool) -> anyhow::Result<()> {
- let client = pool.get().await?;
- client.simple_query("DISCARD ALL").await?;
- Ok(())
-}
-
-async fn run_kv_shapes(
- port: u16,
- kv_table: &str,
- prepared_statements: bool,
-) -> anyhow::Result<KvRun> {
- let config = postgres_config(port, kv_table, prepared_statements);
- let pool = connect(&config).await?;
- let kv = KvClient::new(pool.clone(), &config)?;
- seed(&kv, kv_table).await?;
- let observations = exercise_kv_shapes(&kv).await?;
- let prepared = prepared_statement_texts(&pool).await?;
- discard_session_state(&pool).await?;
- let after_session_reset = match kv.get_row(TABLE_NAME, "r1").await {
- Ok(row) => format!("ok:{row:?}"),
- Err(err) => format!("err:{err:#}"),
- };
- pool.close();
- Ok(KvRun {
- observations,
- prepared,
- after_session_reset,
- })
-}
-
-async fn wait_for_postgres(container: &str, port: u16) -> anyhow::Result<()> {
- for _ in 0..180 {
- tokio::time::sleep(Duration::from_millis(500)).await;
- if docker(&[
- "exec",
- container,
- "pg_isready",
- "-U",
- "fluxer",
- "-d",
- "fluxer",
- ])
- .is_err()
- {
- continue;
- }
- let config = postgres_config(port, KV_TABLE, true);
- if let Ok(pool) = connect(&config).await {
- pool.close();
- return Ok(());
- }
- }
- anyhow::bail!("postgres never came up")
-}
-
-#[tokio::test(flavor = "multi_thread")]
-async fn drops_server_side_prepared_statements_when_disabled() -> anyhow::Result<()> {
- if !docker_available() {
- eprintln!("skipping: docker is not available");
- return Ok(());
- }
- let port = free_port()?;
- let container = format!("fluxer-svcstmt-{}-{port}", std::process::id());
- docker(&[
- "run",
- "-d",
- "--name",
- &container,
- "-e",
- "POSTGRES_USER=fluxer",
- "-e",
- "POSTGRES_PASSWORD=fluxer",
- "-e",
- "POSTGRES_DB=fluxer",
- "-p",
- &format!("127.0.0.1:{port}:5432"),
- "postgres:16-alpine",
- "-c",
- "fsync=off",
- "-c",
- "log_statement=all",
- ])?;
- let result = async {
- wait_for_postgres(&container, port).await?;
- let named = run_kv_shapes(port, KV_TABLE, true).await?;
- let unnamed = run_kv_shapes(port, KV_TABLE_POOLED, false).await?;
- let named_executions = executed_statements(&container, KV_TABLE)?;
- let unnamed_executions = executed_statements(&container, KV_TABLE_POOLED)?;
- anyhow::Ok((named, unnamed, named_executions, unnamed_executions))
- }
- .await;
- let _ = docker(&["rm", "-f", &container]);
- let (named, unnamed, named_executions, unnamed_executions) = result?;
-
- assert_eq!(8, named.prepared.len(), "{:#?}", named.prepared);
- assert!(named.prepared.iter().all(|sql| sql.contains(KV_TABLE)));
- assert!(
- named.after_session_reset.contains("prepared statement"),
- "{}",
- named.after_session_reset
- );
- assert!(
- named_executions
- .iter()
- .any(|line| !line.contains("execute <unnamed>:")),
- "{named_executions:#?}"
- );
-
- assert!(unnamed.prepared.is_empty(), "{:#?}", unnamed.prepared);
- assert_eq!(
- format!("ok:{}", unnamed.observations[0]),
- unnamed.after_session_reset
- );
- assert!(!unnamed_executions.is_empty());
- assert!(
- unnamed_executions
- .iter()
- .all(|line| line.contains("execute <unnamed>:")),
- "{unnamed_executions:#?}"
- );
-
- assert_eq!(named.observations, unnamed.observations);
- Ok(())
-}