diff options
| author | Alexander_Kabui <alexanderkabua@gmail.com> | 2026-10-08 03:00:56 +0300 |
|---|---|---|
| committer | Alexander_Kabui <alexanderkabua@gmail.com> | 2026-10-08 03:40:31 +0300 |
| commit | 3c759f2e28b4dec1561b91900a7100975a74ccc5 (patch) | |
| tree | 0d1bff99258f4714b42f9e81faaac575e58dda47 | |
| parent | 47dafd639c17e5f5401a918105e00ecc1f0d426c (diff) | |
| download | genenetwork4-3c759f2e28b4dec1561b91900a7100975a74ccc5.tar.gz | |
tests/search_selfcorrection.rs (client self-correction test): a
client recovers from the typed 422 by machine-repairing the query from the error body alone. Two malformed loops (dangling AND; the recorded mean:abc..def compound) -> assert the blessed body fields (error.type/param/message/detail.xapian_error_type) -> derive the fix from those fields -> resend -> 200 with recorded hits. Hermetic (stub gn3 + stub JWKS, forwarder forced): CI-safe, no index needed.
| -rw-r--r-- | tests/search_selfcorrection.rs | 333 |
1 files changed, 333 insertions, 0 deletions
diff --git a/tests/search_selfcorrection.rs b/tests/search_selfcorrection.rs new file mode 100644 index 0000000..4ccd39d --- /dev/null +++ b/tests/search_selfcorrection.rs @@ -0,0 +1,333 @@ +//! Client-simulation self-correction: proves the typed-422 contract +//! (the 2026-10-06 body) is mechanically SUFFICIENT for a client with +//! no other API knowledge to diagnose and repair a malformed query. +//! +//! The client here is deliberately dumb: all it can do is send a +//! query, read the error body, and re-send. Every decision in its +//! repair step is derived from the body's own fields — `error.param` +//! (which parameter is at fault), `error.message` (what the backend's +//! parser said), `error.detail.xapian_error_type` (the backend's own +//! classification) — never from hardcoded knowledge of this API's +//! grammar or of the specific query being tested. If the body were +//! missing any of those fields, the repair step would fail loudly +//! instead of guessing. +//! +//! Hermetic, CI-safe (no index, no live server, no dev index): the +//! tests/search.rs pattern — a stub axum app stands in for gn3, +//! serving the RECORDED production responses (the alcohol/phenotype +//! fixture for accepted queries, the recorded Q52 and parser +//! diagnostics for the malformed shapes), and a second stub stands in +//! for gn-auth's JWKS, with tokens minted locally against the +//! committed test key. The forwarder engine is forced with +//! SEARCH_ENGINE="" so this suite never needs a xapian index. +//! +//! One sequential test function per binary: `GN3_URL`, +//! `AUTH_SERVER_URL` and `SEARCH_ENGINE` are process-global. + +use axum::Router; +use axum::body::Body; +use axum::extract::Query; +use axum::http::{Request, StatusCode}; +use axum::routing::get; +use http_body_util::BodyExt; +use jsonwebtoken::{Algorithm, EncodingKey, Header, encode}; +use serde::Serialize; +use serde_json::{Value, json}; +use std::collections::HashMap; +use tower::ServiceExt; + +/// Recorded from production on 2026-10-03: +/// https://genenetwork.org/api3/search/?query=alcohol&type=phenotype&per_page=5 +const FIXTURE: &str = include_str!("../test/data/search_alcohol_phenotype.json"); + +/// Committed test-only key material: the JWKS the gn-auth stub serves, +/// and the matching RSA private key used to sign tokens locally. See +/// test/data/test_jwks.json. +const TEST_JWKS: &str = include_str!("../test/data/test_jwks.json"); +const TEST_PRIVATE_KEY: &str = include_str!("../test/data/test_rsa_private.pem"); + +/// True when every `field:a..b` range token in the query has numeric +/// endpoints. gn3's parser rejects a range token with non-numeric +/// endpoints on the token's SHAPE (the recorded production Q52), not +/// on whole-query identity, so the stub mirrors that. +fn range_endpoints_numeric(query: &str) -> bool { + query.split_whitespace().all(|token| { + let Some((_, value)) = token.split_once(':') else { + return true; + }; + match value.split_once("..") { + Some((begin, end)) => begin.parse::<f64>().is_ok() && end.parse::<f64>().is_ok(), + None => true, + } + }) +} + +/// Stands in for gn3's /api/search during tests, serving recorded +/// production shapes: the Q52 rejection for non-numeric range +/// endpoints, the parser's dangling-operator rejection, and the +/// alcohol/phenotype fixture for everything the parser accepts. +async fn serve_gn3(Query(params): Query<HashMap<String, String>>) -> (StatusCode, String) { + let query = params.get("query").map(String::as_str).unwrap_or(""); + if !range_endpoints_numeric(query) { + // Recorded production Q52 body (test/data/parity-fixtures/ + // Q52.json): the diagnostic under "error", the Python repr + // under "error_type". + return ( + StatusCode::BAD_REQUEST, + json!({ + "error": "Unknown range operation", + "error_type": "b'QueryParserError'" + }) + .to_string(), + ); + } + if query.split_whitespace().next_back() == Some("AND") { + // The parser's own diagnostic for a trailing operator with no + // expression after it (the shape tests/search.rs's stub + // mirrors for `&&`): same 400 diagnostic shape. + return ( + StatusCode::BAD_REQUEST, + json!({ + "error": "Syntax: <expression> AND <expression>", + "error_type": "b'QueryParserError'" + }) + .to_string(), + ); + } + (StatusCode::OK, FIXTURE.to_string()) +} + +async fn gn3_stub_url() -> String { + let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap(); + let port = listener.local_addr().unwrap().port(); + let app = Router::new().route("/api/search/", get(serve_gn3)); + tokio::spawn(async move { + axum::serve(listener, app).await.unwrap(); + }); + format!("http://127.0.0.1:{port}/api/") +} + +/// Stands in for gn-auth's GET /auth/public-jwks, so token verification +/// never needs a live gn-auth (same pattern as tests/search.rs). +async fn serve_jwks() -> (StatusCode, &'static str) { + (StatusCode::OK, TEST_JWKS) +} + +async fn gn_auth_stub_url() -> String { + let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap(); + let port = listener.local_addr().unwrap().port(); + let app = Router::new().route("/auth/public-jwks", get(serve_jwks)); + tokio::spawn(async move { + axum::serve(listener, app).await.unwrap(); + }); + format!("http://127.0.0.1:{port}") +} + +/// Signs a token locally with the committed test private key, so the +/// stub's JWKS verifies it. `issuer` must equal the AUTH_SERVER_URL the +/// app is configured with (src/auth.rs validates the `iss` claim). +fn sign_test_token(issuer: &str) -> String { + #[derive(Serialize)] + struct Claims { + sub: String, + scope: String, + iss: String, + iat: u64, + exp: u64, + } + + let now = std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .unwrap() + .as_secs(); + let claims = Claims { + sub: "selfcorrection-test-user".to_string(), + scope: "profile".to_string(), + iss: issuer.to_string(), + iat: now, + exp: now + 3600, + }; + let key = EncodingKey::from_rsa_pem(TEST_PRIVATE_KEY.as_bytes()).unwrap(); + encode(&Header::new(Algorithm::RS256), &claims, &key).unwrap() +} + +fn set(key: &str, value: &str) { + // SAFETY: this test file is the only place that touches these keys, + // in one single-threaded sequence (see the module doc comment). + unsafe { std::env::set_var(key, value) }; +} + +/// The client's whole vocabulary: send a query, get status + body. +async fn client_query(query: &str, token: &str) -> (StatusCode, Value) { + let uri = format!("/search?q={}&type=phenotype", urlencoding(query)); + let request = Request::builder() + .uri(uri) + .header("Authorization", format!("Bearer {token}")) + .body(Body::empty()) + .unwrap(); + let response = genenetwork4::app().oneshot(request).await.unwrap(); + let status = response.status(); + let body = response.into_body().collect().await.unwrap().to_bytes(); + (status, serde_json::from_slice(&body).unwrap()) +} + +/// Percent-encode just what the test's queries need (space and the +/// range token's `:`), without pulling in a urlencoding dependency. +fn urlencoding(query: &str) -> String { + let mut out = String::new(); + for byte in query.bytes() { + match byte { + b' ' => out.push_str("%20"), + b':' => out.push_str("%3A"), + b'&' => out.push_str("%26"), + b'?' => out.push_str("%3F"), + _ => out.push(byte as char), + } + } + out +} + +/// The machine correction, derived ONLY from the typed error body. +/// `error.param` says which parameter is at fault; `error.message` is +/// the backend's own diagnostic; `error.detail.xapian_error_type` is +/// the backend's classification. No fixed query, no grammar knowledge +/// beyond what the body itself states. Returns `Err` naming the field +/// whose absence blocked the repair — so a corrupted body fails the +/// test instead of a lucky guess passing it. +fn correct_from_error(query: &str, body: &Value) -> Result<String, String> { + let error = body + .get("error") + .ok_or_else(|| "body carries no typed error object".to_string())?; + let param = error + .get("param") + .and_then(Value::as_str) + .ok_or_else(|| "error.param missing".to_string())?; + if param != "query" { + return Err(format!("error.param is {param:?}, not the query parameter")); + } + let message = error + .get("message") + .and_then(Value::as_str) + .filter(|m| !m.is_empty()) + .ok_or_else(|| "error.message missing or empty".to_string())?; + if error + .get("detail") + .and_then(|d| d.get("xapian_error_type")) + .and_then(Value::as_str) + .filter(|t| !t.is_empty()) + .is_none() + { + return Err("error.detail.xapian_error_type missing".to_string()); + } + + let tokens: Vec<&str> = query.split_whitespace().collect(); + if tokens.is_empty() { + return Err("nothing to correct: the query is empty".to_string()); + } + + // Rule 1: a message naming boolean operators ("Syntax: + // <expression> AND <expression>") says every named operator needs + // an expression on both sides — drop the named operators that + // dangle at the end with nothing after them. + let named_operators: Vec<&str> = message + .split_whitespace() + .filter(|word| word.len() >= 2 && word.chars().all(|c| c.is_ascii_uppercase())) + .collect(); + if !named_operators.is_empty() { + let mut kept = tokens.clone(); + while kept + .last() + .is_some_and(|token| named_operators.contains(token)) + { + kept.pop(); + } + if kept.is_empty() { + return Err("dropping the dangling operators left no query".to_string()); + } + if kept.len() < tokens.len() { + return Ok(kept.join(" ")); + } + return Err("the message names operators but none dangle".to_string()); + } + + // Rule 2: a message about an unknown "range operation" indicts the + // range-construct tokens (the `field:a..b` shapes) — excise them, + // keeping what the message did not complain about. + if message.to_ascii_lowercase().contains("range") { + let kept: Vec<&str> = tokens + .iter() + .copied() + .filter(|token| !token.contains("..")) + .collect(); + if kept.is_empty() { + return Err("dropping the range constructs left no query".to_string()); + } + if kept.len() < tokens.len() { + return Ok(kept.join(" ")); + } + return Err("the message indicts ranges but the query has none".to_string()); + } + + Err(format!( + "the message names nothing the query can correct: {message:?}" + )) +} + +/// One full self-correction loop: send `query`, expect the blessed +/// typed 422, machine-correct from the body alone, re-send the +/// corrected query, expect 200 with the recorded hits. +async fn assert_self_corrects(query: &str, token: &str) { + // 1. The malformed query is rejected with the blessed typed body. + let (status, body) = client_query(query, token).await; + assert_eq!(status, StatusCode::UNPROCESSABLE_ENTITY, "{query:?}"); + assert_eq!(body["code"], "invalid_query", "{query:?}"); + let typed = &body["error"]; + assert_eq!(typed["type"], "invalid_query", "{query:?}"); + assert_eq!(typed["param"], "query", "{query:?}"); + assert!( + typed["message"].as_str().is_some_and(|m| !m.is_empty()), + "{query:?}" + ); + assert_eq!( + typed["detail"]["xapian_error_type"], "QueryParserError", + "{query:?}" + ); + + // 2. The client repairs using ONLY what the body says. + let corrected = correct_from_error(query, &body) + .unwrap_or_else(|e| panic!("{query:?}: the body did not suffice: {e}")); + assert_ne!(corrected, query, "the correction changed nothing"); + + // 3. The corrected query serves: 200 with the recorded hits. + let (status, body) = client_query(&corrected, token).await; + assert_eq!(status, StatusCode::OK, "{query:?} -> {corrected:?}"); + let hits = body["data"].as_array().cloned().unwrap_or_default(); + assert_eq!(hits.len(), 5, "the recorded alcohol/phenotype fixture"); + assert_eq!(hits[0]["name"], "10199"); +} + +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn client_self_corrects_from_the_typed_422_body() { + let gn3_stub = gn3_stub_url().await; + let gn_auth_stub = gn_auth_stub_url().await; + set("GN3_URL", &gn3_stub); + set("AUTH_SERVER_URL", &gn_auth_stub); + // Force the forwarder engine so this suite needs no xapian index + // even when the surrounding environment configures one. + set("SEARCH_ENGINE", ""); + + let token = sign_test_token(&gn_auth_stub); + + // Loop 1: a trailing boolean operator. The recorded production + // diagnostic ("Syntax: <expression> AND <expression>") must be + // enough for a machine to drop the dangling operator. + assert_self_corrects("alcohol AND", &token).await; + + // Loop 2: the recorded Q52 shape, a non-numeric range endpoint + // ("mean:abc..def"). A standalone malformed-only token would + // leave the client nothing to re-send once excised (an empty query + // is a 400, not a recovery), so the shape rides in a compound + // query — the diagnostic must let a machine excise the indicted + // range construct and keep the rest. + assert_self_corrects("alcohol mean:abc..def", &token).await; +} |
