use base64::Engine;
use serde_json::Value;
use super::*;
fn vectors() -> Vec<Value> {
serde_json::from_str(include_str!("../tests/fixtures/codex_live_go.json")).expect("fixture JSON")
}
fn bytes(v: &Value) -> Vec<u8> {
let s = v.as_str().unwrap_or_default();
match s.strip_prefix("b64:") {
Some(b64) => base64::engine::general_purpose::STANDARD.decode(b64).expect("base64"),
None => s.as_bytes().to_vec(),
}
}
fn text(v: &Value) -> String {
v.as_str().unwrap_or_default().to_owned()
}
fn err(v: &Value) -> Option<String> {
v.as_str().map(str::to_owned)
}
fn show(b: &[u8]) -> String {
String::from_utf8_lossy(b).into_owned()
}
fn call_out(result: Result<Call, ShapeError>) -> Value {
match result {
Ok(call) => serde_json::json!({
"body": show(&call.body), "content_type": call.content_type, "model": call.model, "err": null,
}),
Err(ShapeError::Invalid(e)) => serde_json::json!({"body": "", "content_type": "", "model": "", "err": e}),
Err(ShapeError::NilMap) => serde_json::json!({"panic": true}),
}
}
fn expect_call(out: &Value) -> Value {
if out.get("panic").is_some() {
return serde_json::json!({"panic": true});
}
serde_json::json!({
"body": show(&bytes(&out["body"])),
"content_type": out["content_type"],
"model": out["model"],
"err": out["err"],
})
}
#[test]
fn shaping_matches_go() {
let mut checked = 0;
let mut failures = Vec::new();
for v in vectors() {
let (fn_name, input, out) = (v["fn"].as_str().unwrap(), &v["in"], &v["out"]);
let body = bytes(&input["body"]);
let ct = text(&input["content_type"]);
let (got, want) = match fn_name {
"prepare" => (call_out(prepare(&body, &ct)), expect_call(out)),
"pipeline" => {
let session = bytes(&input["session"]);
let got = prepare(&body, &ct)
.and_then(|c| apply_client_secret(c, &session))
.and_then(rewrite_model);
let mut want = expect_call(out);
if want["err"].is_string() {
want["body"] = "".into();
want["content_type"] = "".into();
want["model"] = "".into();
}
(call_out(got), want)
}
"rewrite_model" => {
let call = Call {
body: body.clone(),
content_type: ct.clone(),
model: text(&input["model"]),
};
let got = match rewrite_model(call) {
Ok(c) => serde_json::json!({"body": show(&c.body), "model": c.model, "err": null}),
Err(ShapeError::Invalid(e)) => serde_json::json!({"body": "", "model": "", "err": e}),
Err(ShapeError::NilMap) => serde_json::json!({"panic": true}),
};
let want = if out.get("panic").is_some() {
out.clone()
} else {
serde_json::json!({"body": show(&bytes(&out["body"])), "model": out["model"], "err": out["err"]})
};
(got, want)
}
"model_from_json" => (Value::String(model_from_json(&body)), out["model"].clone()),
"call_request_sdp" => {
let got = match request_sdp(&body, &ct) {
Ok(s) => serde_json::json!({"sdp": s, "err": null}),
Err(e) => serde_json::json!({"sdp": "", "err": e}),
};
(got, serde_json::json!({"sdp": out["sdp"], "err": out["err"]}))
}
"response_sdp" => {
let got = match response_sdp(&body, &ct) {
Ok(s) => serde_json::json!({"sdp": s, "err": null}),
Err(e) => serde_json::json!({"sdp": "", "err": e}),
};
(got, serde_json::json!({"sdp": out["sdp"], "err": out["err"]}))
}
"replace_sdp" => {
let got = match replace_sdp(&body, &ct, &text(&input["sdp"])) {
Ok((b, c)) => serde_json::json!({"body": show(&b), "content_type": c, "err": null}),
Err(ShapeError::Invalid(e)) => serde_json::json!({"body": "", "content_type": "", "err": e}),
Err(ShapeError::NilMap) => serde_json::json!({"panic": true}),
};
let want = if out.get("panic").is_some() {
out.clone()
} else {
serde_json::json!({"body": show(&bytes(&out["body"])), "content_type": out["content_type"], "err": out["err"]})
};
(got, want)
}
"codex_model" => (Value::String(codex_model(&text(&input["model"]))), out["model"].clone()),
"call_id_from_location" => (
Value::String(call_id_from_location(&text(&input["location"]))),
out["call_id"].clone(),
),
"call_id_valid" => (
Value::Bool(valid_call_id(&text(&input["call_id"]))),
out["valid"].clone(),
),
"normalize_secret" => {
let got = match normalize_client_secret_session(&bytes(&input["session"])) {
Ok((c, u)) => serde_json::json!({"client": show(&c), "upstream": show(&u), "err": null}),
Err(SessionError::Invalid(e) | SessionError::Unsupported(e)) => {
serde_json::json!({"client": "", "upstream": "", "err": e})
}
};
let want = serde_json::json!({
"client": show(&bytes(&out["client"])), "upstream": show(&bytes(&out["upstream"])), "err": out["err"],
});
(got, want)
}
"session_response" => {
if out.get("skip").is_some() {
continue;
}
let (client, _) = normalize_client_secret_session(&bytes(&input["session"])).expect("normalized");
let got = session_response(&client, "sess_fixed", 1_700_000_000).map(|v| show(&v.marshal()));
(serde_json::json!(got), serde_json::json!(show(&bytes(&out["body"]))))
}
"session_update" => {
let got = match session_update(&bytes(&input["session"])) {
Ok(b) => serde_json::json!({"body": show(&b), "err": null}),
Err(e) => serde_json::json!({"body": "", "err": e}),
};
(
got,
serde_json::json!({"body": show(&bytes(&out["body"])), "err": out["err"]}),
)
}
"sideband_url" => {
let style = match input["style"].as_i64().unwrap() {
0 => Sideband::Frameless,
1 => Sideband::Calls,
_ => Sideband::Query,
};
let url = sideband_url(&text(&input["base"]), style, &text(&input["call_id"]));
let http = http_url(&url);
(
serde_json::json!([url, http]),
serde_json::json!([out["url"], out["http_url"]]),
)
}
"direct_url" => (
serde_json::json!([direct_url(API_BASE, &text(&input["model"])), http_base(API_BASE)]),
serde_json::json!([out["url"], out["hangup_base"]]),
),
"bearer" => (
Value::String(bearer_token(&text(&input["authorization"])).to_owned()),
out["token"].clone(),
),
"lifetime" => {
let expires = input["set"]
.as_bool()
.unwrap()
.then(|| (text(&input["anchor"]), input["seconds"].as_i64().unwrap()));
let got = match client_secret_lifetime(expires.as_ref()) {
Ok(d) => serde_json::json!({"seconds": d.as_secs(), "err": null}),
Err(e) => serde_json::json!({"seconds": 0, "err": e}),
};
(got, serde_json::json!({"seconds": out["seconds"], "err": out["err"]}))
}
"secret_request" => {
let got = match decode_secret_request(text(&input["body"]).as_bytes()) {
Some(r) => {
let mut v = serde_json::json!({"ok": true, "session": show(&r.session)});
if let Some((anchor, seconds)) = r.expires_after {
v["anchor"] = anchor.into();
v["seconds"] = seconds.into();
}
v
}
None => serde_json::json!({"ok": false}),
};
(got, out.clone())
}
"quoted_printable" => {
let got = match form::quoted_printable(&body, None) {
Ok(b) => serde_json::json!({"body": show(&b), "err": null}),
Err(e) => serde_json::json!({"err": e}),
};
let want = match out["err"].as_str() {
Some(e) => serde_json::json!({"err": e}),
None => serde_json::json!({"body": show(&bytes(&out["body"])), "err": null}),
};
(got, want)
}
other => panic!("unknown vector kind {other}"),
};
checked += 1;
if got != want {
failures.push(format!("{fn_name} {input}\n got {got}\n want {want}"));
}
}
assert!(checked > 600, "only {checked} vectors checked");
assert!(
failures.is_empty(),
"{} mismatches:\n{}",
failures.len(),
failures.join("\n")
);
}
#[test]
fn fixture_covers_error_and_panic_paths() {
let all = vectors();
let errors = all.iter().filter(|v| err(&v["out"]["err"]).is_some()).count();
let panics = all.iter().filter(|v| v["out"].get("panic").is_some()).count();
assert!(errors > 50 && panics >= 3, "errors={errors} panics={panics}");
}
#[test]
fn protocol_headers_keep_values_and_canonical_names() {
let mut client = HeaderMap::new();
client.append("openai-alpha", "quicksilver=v2".parse().unwrap());
client.append("x-session-id", "a".parse().unwrap());
client.append("x-session-id", "b".parse().unwrap());
client.append("authorization", "Bearer client-key".parse().unwrap());
let headers = protocol_headers(&client);
assert_eq!(
headers,
vec![
("Openai-Alpha".to_owned(), "quicksilver=v2".to_owned()),
("X-Session-Id".to_owned(), "a".to_owned()),
("X-Session-Id".to_owned(), "b".to_owned()),
],
"only the live protocol headers, never the client key"
);
let direct = direct_headers(&client);
assert!(direct.iter().all(|(n, _)| n != "Openai-Alpha"));
assert!(direct.contains(&("Originator".to_owned(), "Codex Desktop".to_owned())));
client.insert("originator", "Codex CLI".parse().unwrap());
assert!(direct_headers(&client).contains(&("Originator".to_owned(), "Codex CLI".to_owned())));
}
#[test]
fn redact_sdp_hides_ice_credentials_in_every_wrapping() {
let raw = b"v=0\r\na=ice-ufrag:Ufr4g\r\na=ice-pwd:s3cret+pass/word\r\na=mid:0\r\n";
assert_eq!(
&*redact_sdp(raw),
b"v=0\r\na=ice-ufrag:[REDACTED]\r\na=ice-pwd:[REDACTED]\r\na=mid:0\r\n"
);
assert_eq!(
&*redact_sdp(b"a=ice-pwd:p1\na=ice-pwd:p2"),
b"a=ice-pwd:[REDACTED]\na=ice-pwd:[REDACTED]"
);
let json = br#"{"sdp":"v=0\r\na=ice-pwd:ab\/cd\r\na=ice-ufrag:uf","session":{}}"#;
assert_eq!(
&*redact_sdp(json),
br#"{"sdp":"v=0\r\na=ice-pwd:[REDACTED]\r\na=ice-ufrag:[REDACTED]","session":{}}"#
);
let multipart = b"--b\r\nContent-Disposition: form-data; name=\"sdp\"\r\n\r\na=ice-pwd:mp\r\n--b--\r\n";
assert_eq!(
&*redact_sdp(multipart),
b"--b\r\nContent-Disposition: form-data; name=\"sdp\"\r\n\r\na=ice-pwd:[REDACTED]\r\n--b--\r\n"
);
assert!(matches!(
redact_sdp(b"v=0\r\na=mid:0\r\n"),
std::borrow::Cow::Borrowed(_)
));
assert_eq!(&*redact_sdp(b"a=ice-pwd:\r\n"), b"a=ice-pwd:\r\n");
}
#[test]
fn redact_sdp_follows_json_escapes_to_the_end_of_the_credential() {
let json = br#"{"sdp":"a=ice-pwd:\u0073ecret\"x\\y\r\na=ice-ufrag:u\u0066rag\u000d\u000Aa=mid:0"}"#;
assert_eq!(
&*redact_sdp(json),
br#"{"sdp":"a=ice-pwd:[REDACTED]\r\na=ice-ufrag:[REDACTED]\u000d\u000Aa=mid:0"}"#
);
assert_eq!(&*redact_sdp(br"a=ice-pwd:ab\"), b"a=ice-pwd:[REDACTED]");
assert_eq!(&*redact_sdp(br"a=ice-pwd:ab\u00"), b"a=ice-pwd:[REDACTED]");
}
#[test]
fn redact_sdp_scans_many_markers_in_one_pass() {
let markers = 100_000;
let body = "a=ice-pwd:secret\r\na=ice-ufrag:frag\r\n".repeat(markers / 2);
let started = std::time::Instant::now();
let redacted = redact_sdp(body.as_bytes());
assert!(
started.elapsed() < std::time::Duration::from_secs(5),
"{:?}",
started.elapsed()
);
assert_eq!(
&*redacted,
"a=ice-pwd:[REDACTED]\r\na=ice-ufrag:[REDACTED]\r\n"
.repeat(markers / 2)
.as_bytes()
);
}
#[test]
fn redact_sdp_recognises_an_escaped_equals_sign() {
let json = br#"{"sdp":"a\u003dice-pwd:secret\r\na\u003Dice-ufrag:frag\r\na\u003dmid:0","note":"a\u003dice"}"#;
assert_eq!(
&*redact_sdp(json),
br#"{"sdp":"a\u003dice-pwd:[REDACTED]\r\na\u003Dice-ufrag:[REDACTED]\r\na\u003dmid:0","note":"a\u003dice"}"#
);
}