A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
test(svc): drop common crate and Docker-backed svc tests
Hampusd474ed38bb7b
diff --git a/fluxer_common/Cargo.toml b/fluxer_common/Cargo.tomlindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex d45ac26f6..8df86e695 100644--- a/fluxer_svc/src/shard.rs+++ b/fluxer_svc/src/shard.rs@@ -81,13 +81,10 @@ wherelet 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.rsdeleted file mode 100644index 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.rsdeleted file mode 100644index 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(())-}