use bytes::Bytes;
use cpa_core::exec::{Caller, Operation};
use serde_json::Value;
use super::*;
fn fixture() -> &'static Value {
static PARSED: std::sync::OnceLock<Value> = std::sync::OnceLock::new();
PARSED.get_or_init(|| serde_json::from_str(include_str!("../tests/fixtures/antigravity_replay_go.json")).unwrap())
}
fn records(kind: &str) -> &'static [Value] {
fixture()[kind].as_array().unwrap()
}
fn s(v: &Value) -> &str {
v.as_str().unwrap_or_default()
}
fn strings(v: &Value) -> Vec<Vec<u8>> {
v.as_array()
.into_iter()
.flatten()
.map(|item| s(item).as_bytes().to_vec())
.collect()
}
fn request(r: &Value) -> ExecRequest {
let mut headers = HeaderMap::new();
for (name, values) in r["headers"].as_object().into_iter().flatten() {
let name = http::HeaderName::from_bytes(name.as_bytes()).unwrap();
for value in values.as_array().unwrap() {
headers.append(name.clone(), s(value).parse().unwrap());
}
}
let optional = |v: &Value| Some(s(v).to_owned()).filter(|v| !v.is_empty());
ExecRequest {
operation: Operation::Generate,
source_format: Format::parse(s(&r["source"])).unwrap_or(Format::Gemini),
response_format: Format::Gemini,
stream_payloads: false,
requested_model: s(&r["model"]).to_owned(),
model: s(&r["model"]).to_owned(),
original_body: Bytes::from(s(&r["original"]).to_owned()),
body: Bytes::from(s(&r["body"]).to_owned()),
stream: false,
alt: None,
session: None,
execution_session: optional(&r["execution"]),
derived_session: optional(&r["derived"]),
resolved_model: None,
usage: Default::default(),
request_path: String::new(),
headers,
caller: Caller {
principal: String::new(),
source: "authorization",
provider: String::new(),
},
}
}
fn random_session(payload: &[u8]) -> bool {
let contents = gj::get(payload, "request.contents");
let explicit = ["sessionId", "session_id", "request.sessionId", "request.session_id"]
.iter()
.any(|path| !text(&gj::get(payload, path)).is_empty());
!explicit
&& (!contents.is_array()
|| !contents
.array()
.iter()
.any(|c| *c.get("role").bytes() == *b"user" && !c.get("parts.0.text").bytes().is_empty()))
}
#[test]
fn scopes_match_go() {
let mut ran = 0;
for r in records("scope") {
let req = request(&r["request"]);
let payload = s(&r["request"]["payload"]).as_bytes();
let got = scope_from_request(&req, s(&r["request"]["model"]), payload).session;
let want = s(&r["session"]);
if got != want
&& want.starts_with("session:")
&& got.starts_with("session:")
&& random_session(payload)
&& random_session(&req.body)
{
continue;
}
assert_eq!(got, want, "{}: session key", s(&r["test"]));
ran += 1;
}
assert!(ran >= 60, "fixture lost scope cases: {ran}");
}
#[test]
fn apply_matches_go() {
let (mut ran, mut changed) = (0, 0);
for r in records("apply") {
let payload = s(&r["payload"]).as_bytes();
let schemas: Schemas = r["schemas"]
.as_object()
.into_iter()
.flatten()
.map(|(name, schema)| {
let value = GoValue::parse_f64(serde_json::to_string(schema).unwrap().as_bytes()).unwrap();
(name.as_bytes().to_vec(), value)
})
.collect();
let got = apply_items(payload, &strings(&r["items"]), &schemas);
let want_changed = r["changed"].as_bool().unwrap();
let test = s(&r["test"]);
assert_eq!(got.is_some(), want_changed, "{test}: changed");
let got = got.unwrap_or_else(|| payload.to_vec());
assert_eq!(String::from_utf8_lossy(&got), s(&r["out"]), "{test}: payload");
ran += 1;
changed += usize::from(want_changed);
}
assert!(
ran >= 400 && changed >= 100,
"fixture lost apply cases: {ran} ({changed} changed)"
);
}
#[test]
fn prepare_matches_go() {
let mut ran = 0;
for r in records("prepare") {
let test = s(&r["test"]);
let model = s(&r["request"]["model"]);
let session = s(&r["session"]);
if !model.trim().is_empty() && !session.trim().is_empty() {
cache::replay_delete_if_unchanged(model, session, &ReplaySnapshot::default());
let ledger = strings(&r["ledger"]);
if !ledger.is_empty() {
assert!(cache::replay_put(model, session, &ledger), "{test}: seed ledger");
}
}
let req = request(&r["request"]);
let payload = s(&r["request"]["payload"]).as_bytes().to_vec();
match prepare(&req, model, payload) {
Ok((out, scope)) => {
assert_eq!(s(&r["error"]), "", "{test}: Go failed");
assert_eq!(String::from_utf8_lossy(&out), s(&r["out"]), "{test}: payload");
assert_eq!(scope.session, session, "{test}: session");
}
Err(error) => assert_eq!(error, s(&r["error"]), "{test}: error"),
}
ran += 1;
}
assert!(ran >= 55, "fixture lost prepare cases: {ran}");
}
#[test]
fn accumulator_matches_go() {
let scope = Scope {
model: "gemini-3-flash".into(),
session: "accumulator-test".into(),
snapshot: ReplaySnapshot::default(),
};
let mut ran = 0;
for r in records("accumulator") {
let test = s(&r["test"]);
let mut acc = Accumulator::new(&scope, s(&r["request"]).as_bytes()).unwrap();
for payload in r["observed"].as_array().unwrap() {
acc.observe(s(payload).as_bytes());
}
if !acc.overflow {
acc.flush_all();
}
assert_eq!(acc.overflow, r["overflow"].as_bool().unwrap(), "{test}: overflow");
assert_eq!(acc.terminal, r["terminal"].as_bool().unwrap(), "{test}: terminal");
let items: Vec<String> = acc
.items
.iter()
.map(|i| String::from_utf8_lossy(i).into_owned())
.collect();
let want: Vec<String> = strings(&r["items"])
.into_iter()
.map(|i| String::from_utf8(i).unwrap())
.collect();
assert_eq!(items, want, "{test}: items");
ran += 1;
}
assert!(ran >= 25, "fixture lost accumulator cases: {ran}");
}
#[test]
fn invalid_signature_400_clears_the_entry_it_read() {
let (model, session) = ("gemini-3-flash", "responses:clear-on-400");
let item =
br#"{"type":"thought_signature","thoughtSignature":"sig-aaaaaaaaaaaaaaaa","contentIndex":1,"partIndex":0}"#;
let read = |snapshot: &mut ReplaySnapshot| {
let (items, next) = cache::replay_get_with_snapshot(model, session);
*snapshot = next;
items
};
for (status, body, cleared) in [
(429, &br#"{"error":"thought_signature"}"#[..], false),
(400, &br#"{"error":"bad request"}"#[..], false),
(400, &br#"{"error":{"message":"Invalid ThoughtSignature"}}"#[..], true),
] {
assert!(cache::replay_put(model, session, &[item.to_vec()]));
let mut snapshot = ReplaySnapshot::default();
assert!(read(&mut snapshot).is_some());
let scope = Scope {
model: model.into(),
session: session.into(),
snapshot,
};
clear_on_invalid_signature(&scope, status, body);
assert_eq!(
read(&mut ReplaySnapshot::default()).is_none(),
cleared,
"{status} {body:?}"
);
}
}
#[test]
fn system_lane_handles_the_depth_limit() {
std::thread::Builder::new()
.stack_size(2 << 20)
.spawn(|| {
let deep = |level: &str| format!(r#"{{"system":{}1{}}}"#, level.repeat(4_999), "}]".repeat(4_999));
let marked = system_lane(deep(r#"[{"cache_control":{"type":"ephemeral"},"t":"#).as_bytes());
let plain = system_lane(deep(r#"[{"t":"#).as_bytes());
assert_eq!(marked.len(), 32);
assert_eq!(marked, plain);
assert_ne!(plain, system_lane(deep(r#"[{"u":"#).as_bytes()));
})
.unwrap()
.join()
.unwrap();
}