connector-usage-only: regenerate v4 goldens and schemas, format, fix tests

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Meta Vens 2026-10-31 04:51:05 +01:00
commit bb8909f2c2
24 changed files with 206 additions and 201 deletions

View file

@ -762,8 +762,15 @@ mod tests {
#[test]
fn the_invocations_identity_covers_its_request() {
let one = invocation();
let mut other = one.clone();
other.request.max_output_tokens += 1;
let mut request = one.request.clone();
request.max_output_tokens += 1;
let other = TransportInvocation::new(
one.caller_runtime_id.clone(),
one.expires_at_unix_ms,
one.native_request_sha256,
request,
)
.unwrap();
assert_ne!(
canonical_invocation_bytes(&one).unwrap(),
canonical_invocation_bytes(&other).unwrap()

View file

@ -67,14 +67,6 @@ impl FlakyStore {
pub(crate) fn allowance(&self) -> Arc<AtomicUsize> {
self.pushes_allowed.clone()
}
/// A store over the same records that accepts `pushes_allowed` more writes.
pub(crate) fn reopened(&self, pushes_allowed: usize) -> Self {
Self {
held: self.held.clone(),
pushes_allowed: Arc::new(AtomicUsize::new(pushes_allowed)),
}
}
}
#[cfg(feature = "daemon")]
@ -133,7 +125,6 @@ pub(crate) fn request() -> ProviderRequest {
request
}
pub(crate) fn invocation() -> TransportInvocation {
TransportInvocation::new("epiphany-yggdrasil", 2_000, [7; 32], request()).unwrap()
}

View file

@ -9,7 +9,6 @@ use crate::contract::ContractError;
pub const USAGE_READOUT_SCHEMA_ID: &str = "gamecult.model.usage_readout.v1";
/// One window of the subscription plan, as the provider reported it.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
#[serde(deny_unknown_fields)]

View file

@ -382,10 +382,7 @@ mod tests {
FailureKind, Refusal, TransportDisposition, TransportEvent, TransportEventPayload,
TransportInvocation, TransportOutcome, TransportResult,
};
use crate::fixtures::{
TestStore, caller, invocation_for, receipt,
request,
};
use crate::fixtures::{TestStore, caller, invocation_for, receipt, request};
const CALLER: &str = "epiphany-yggdrasil";
const KEY: &str = "epiphany-distinct-test-key";
@ -461,13 +458,7 @@ mod tests {
let (sender, receiver) = std::sync::mpsc::channel();
let path = path.to_path_buf();
thread::spawn(move || {
let _ = sender.send(serve(
listener,
limits,
admissions,
&path,
backend,
));
let _ = sender.send(serve(listener, limits, admissions, &path, backend));
});
receiver.recv_timeout(Duration::from_secs(2)).ok()
}
@ -493,15 +484,7 @@ mod tests {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let endpoint = listener.local_addr().unwrap();
let path = store.path.clone();
thread::spawn(move || {
serve(
listener,
limits(),
admissions,
&path,
backend,
)
});
thread::spawn(move || serve(listener, limits(), admissions, &path, backend));
let client =
ConnectorClient::new(endpoint, KEY, FRAME, Some(Duration::from_secs(5))).unwrap();
(client, endpoint)
@ -770,10 +753,9 @@ mod tests {
let envelope =
crate::envelope::encrypt_invocation(&invocation, &crate::fixtures::security(KEY))
.unwrap();
let TransportAdmission::Execute(claim) =
service
.begin(&envelope, now_ms(), &PlanQuotaSnapshot::default(), 1 << 20)
.unwrap()
let TransportAdmission::Execute(claim) = service
.begin(&envelope, now_ms(), &PlanQuotaSnapshot::default(), 1 << 20)
.unwrap()
else {
panic!("a fresh request must execute");
};
@ -881,12 +863,7 @@ mod tests {
fn the_smallest_frame_also_carries_the_failure_that_stands_in_for_a_result() {
let long = "x".repeat(crate::envelope::MAX_IDENTITY_BYTES);
let plaintext = crate::contract::wire_encode(&crate::service::result_size_failure(
&long,
&long,
&long,
[0xff; 32],
[0xff; 32],
0,
&long, &long, &long, [0xff; 32], [0xff; 32], 0,
))
.unwrap()
.len();
@ -994,16 +971,7 @@ mod tests {
}
fn admission(id: &str, key: &str, slots: usize, payload: usize) -> CallerAdmission {
CallerAdmission::new(
id,
key,
1,
["gpt-5.4".to_string()],
slots,
payload,
32_768,
)
.unwrap()
CallerAdmission::new(id, key, 1, ["gpt-5.4".to_string()], slots, payload, 32_768).unwrap()
}
/// `Some(field)` when serve refused the configuration, `None` while it serves.
@ -1233,10 +1201,9 @@ mod tests {
&crate::fixtures::security(KEY),
)
.unwrap();
let TransportAdmission::Execute(claim) =
service
.begin(&envelope, now_ms(), &PlanQuotaSnapshot::default(), 1 << 20)
.unwrap()
let TransportAdmission::Execute(claim) = service
.begin(&envelope, now_ms(), &PlanQuotaSnapshot::default(), 1 << 20)
.unwrap()
else {
panic!("a fresh request must execute");
};
@ -1385,15 +1352,7 @@ mod tests {
let backend = CountingBackend::new(true);
let path = store.path.clone();
let served = backend.clone();
thread::spawn(move || {
serve(
listener,
limits(),
admissions,
&path,
served,
)
});
thread::spawn(move || serve(listener, limits(), admissions, &path, served));
let client =
ConnectorClient::new(endpoint, KEY, FRAME, Some(Duration::from_secs(5))).unwrap();
client.execute(&fresh("request-key")).unwrap();

View file

@ -524,7 +524,8 @@ impl TransportService {
.get::<ReplayRecord>(&replay_key(&identity))
.map_err(replay_store_error)?
.ok_or(ServiceError::NoActiveRequest)?;
if active.state != ReplayState::Active || active.invocation_sha256 != claim.invocation_sha256
if active.state != ReplayState::Active
|| active.invocation_sha256 != claim.invocation_sha256
{
return Err(ServiceError::ActiveRequestMismatch);
}
@ -897,13 +898,9 @@ mod tests {
let mut changed_request = request();
changed_request.instructions.push_str(" Different cargo.");
let conflicting = TransportInvocation::new(
"epiphany-yggdrasil",
2_000,
[7; 32],
changed_request,
)
.unwrap();
let conflicting =
TransportInvocation::new("epiphany-yggdrasil", 2_000, [7; 32], changed_request)
.unwrap();
let refusal = match service
.begin_unplanned(
&encrypt_invocation(&conflicting, &security).unwrap(),
@ -932,7 +929,9 @@ mod tests {
let mut service = open_service(&store, 1);
let first_envelope = encrypt_invocation(&first, &security).unwrap();
assert!(matches!(
service.begin_unplanned(&first_envelope, 1_000, FRAME).unwrap(),
service
.begin_unplanned(&first_envelope, 1_000, FRAME)
.unwrap(),
TransportAdmission::Execute(_)
));
@ -1035,10 +1034,12 @@ mod tests {
) -> (TransportAdmission, TransportInvocation) {
let mut request = invocation_for(CALLER, request_id).request;
edit(&mut request);
let invocation =
TransportInvocation::new(CALLER, 2_000, [7; 32], request).unwrap();
let invocation = TransportInvocation::new(CALLER, 2_000, [7; 32], request).unwrap();
let envelope = encrypt_invocation(&invocation, &security(KEY)).unwrap();
(service.begin_unplanned(&envelope, 1_000, FRAME).unwrap(), invocation)
(
service.begin_unplanned(&envelope, 1_000, FRAME).unwrap(),
invocation,
)
}
fn refusal_of(admission: TransportAdmission, invocation: &TransportInvocation) -> Refusal {
@ -1118,14 +1119,9 @@ mod tests {
32_768,
)
.unwrap();
TransportService::open(
&store.path,
"fixture-sse",
[admission],
5_000,
)
.unwrap()
.begin_unplanned(&envelope, 1_000, FRAME)
TransportService::open(&store.path, "fixture-sse", [admission], 5_000)
.unwrap()
.begin_unplanned(&envelope, 1_000, FRAME)
};
assert!(matches!(admit(size), Ok(TransportAdmission::Execute(_))));
let refused = admit(size - 1).unwrap();
@ -1272,15 +1268,7 @@ mod tests {
#[test]
fn identities_are_bounded_at_admission_and_on_the_request() {
let admit = |caller_id: String, model: String| {
CallerAdmission::new(
caller_id,
KEY,
1,
[model],
4,
64 * 1024,
32_768,
)
CallerAdmission::new(caller_id, KEY, 1, [model], 4, 64 * 1024, 32_768)
};
let at = "i".repeat(MAX_IDENTITY_BYTES);
let over = "i".repeat(MAX_IDENTITY_BYTES + 1);
@ -1298,7 +1286,9 @@ mod tests {
let mut service = open_service(&store, 8);
let ok = invocation_for(CALLER, &at);
assert!(matches!(
service.begin_unplanned(&raw_envelope(&ok), 1_000, FRAME).unwrap(),
service
.begin_unplanned(&raw_envelope(&ok), 1_000, FRAME)
.unwrap(),
TransportAdmission::Execute(_)
));
}
@ -1315,8 +1305,9 @@ mod tests {
let mut service = open_service(&store, 1);
let id = "i".repeat(length);
let long = invocation_for(CALLER, &id);
let TransportAdmission::Reply(reply) =
service.begin_unplanned(&raw_envelope(&long), 1_000, FRAME).unwrap()
let TransportAdmission::Reply(reply) = service
.begin_unplanned(&raw_envelope(&long), 1_000, FRAME)
.unwrap()
else {
panic!("an over-long id must be refused, not executed ({length})");
};
@ -1353,7 +1344,9 @@ mod tests {
let store = TestStore::new();
let mut service = open_service(&store, 1);
assert!(matches!(
service.begin_unplanned(&raw_envelope(&long), 1_000, frame_cap).unwrap(),
service
.begin_unplanned(&raw_envelope(&long), 1_000, frame_cap)
.unwrap(),
TransportAdmission::Reply(_)
));
assert_eq!(
@ -1543,7 +1536,9 @@ mod tests {
let big = text_result(claim.call(), "y");
service.complete(*claim, big, FRAME).unwrap();
assert_eq!(
service.begin_unplanned(&raw_envelope(&invocation), 1_000, 10).err(),
service
.begin_unplanned(&raw_envelope(&invocation), 1_000, 10)
.err(),
Some(ServiceError::FrameBound)
);
}
@ -1758,25 +1753,15 @@ mod tests {
for tag in ["", " ", STAND_IN_PROVIDER] {
assert!(
matches!(
TransportService::open(
&store.path,
tag,
[caller(CALLER, KEY, 1)],
5_000
),
TransportService::open(&store.path, tag, [caller(CALLER, KEY, 1)], 5_000),
Err(ServiceError::InvalidAdmission)
),
"{tag:?}"
);
}
assert!(
TransportService::open(
&store.path,
"fixture-sse",
[caller(CALLER, KEY, 1)],
5_000
)
.is_ok()
TransportService::open(&store.path, "fixture-sse", [caller(CALLER, KEY, 1)], 5_000)
.is_ok()
);
}
@ -2060,12 +2045,7 @@ mod tests {
.unwrap();
}
assert!(matches!(
TransportService::open(
&store.path,
"fixture-sse",
[caller(CALLER, KEY, 1)],
5_000
),
TransportService::open(&store.path, "fixture-sse", [caller(CALLER, KEY, 1)], 5_000),
Err(ServiceError::ReplayStore(_))
));
}

View file

@ -128,16 +128,10 @@ mod tests {
TransportService::open(
&store.path,
"fixture-sse",
[CallerAdmission::new(
CALLER,
KEY,
1,
["gpt-5.4".to_string()],
1,
65_536,
32_768,
)
.unwrap()],
[
CallerAdmission::new(CALLER, KEY, 1, ["gpt-5.4".to_string()], 1, 65_536, 32_768)
.unwrap(),
],
5_000,
)
.unwrap()
@ -185,7 +179,10 @@ mod tests {
fn a_lease_is_named_by_its_invocation() {
let store = TestStore::new();
let mut service = open(&store);
assert_eq!(granted(lease(&mut service, "run-1")).lease_id, "lease:run-1");
assert_eq!(
granted(lease(&mut service, "run-1")).lease_id,
"lease:run-1"
);
}
#[test]
@ -231,14 +228,28 @@ mod tests {
);
assert_eq!(
service
.begin_lease(CALLER, LeaseTurn::SelfRun, "run-2", NOW + 99, NOW + 9, &none())
.begin_lease(
CALLER,
LeaseTurn::SelfRun,
"run-2",
NOW + 99,
NOW + 9,
&none()
)
.unwrap(),
LeaseAdmission::Refused(LeaseRefusal::Busy),
"one millisecond before its expiry the lease still holds"
);
granted(
service
.begin_lease(CALLER, LeaseTurn::SelfRun, "run-2", NOW + 99, NOW + 10, &none())
.begin_lease(
CALLER,
LeaseTurn::SelfRun,
"run-2",
NOW + 99,
NOW + 10,
&none(),
)
.unwrap(),
);
}
@ -249,7 +260,14 @@ mod tests {
let mut service = open(&store);
assert_eq!(
service
.begin_lease("stranger", LeaseTurn::SelfRun, "run-1", NOW + 1, NOW, &none())
.begin_lease(
"stranger",
LeaseTurn::SelfRun,
"run-1",
NOW + 1,
NOW,
&none()
)
.unwrap(),
LeaseAdmission::Refused(LeaseRefusal::UnknownCaller)
);
@ -286,8 +304,7 @@ mod tests {
let call = |service: &mut TransportService, now: u64, plan: &PlanQuotaSnapshot| {
let mut asked = request();
asked.request_id = format!("call-{now}");
let invocation =
TransportInvocation::new(CALLER, now + 1_000, [7; 32], asked).unwrap();
let invocation = TransportInvocation::new(CALLER, now + 1_000, [7; 32], asked).unwrap();
let sealed = crate::envelope::encrypt_message(
CALLER,
invocation.request_id(),
@ -301,7 +318,8 @@ mod tests {
else {
return None;
};
let result = crate::envelope::decrypt_result(&reply, &security(KEY), &invocation).unwrap();
let result =
crate::envelope::decrypt_result(&reply, &security(KEY), &invocation).unwrap();
match result.disposition {
TransportDisposition::Refused(refusal) => Some(refusal),
other => panic!("unexpected {other:?}"),
@ -361,7 +379,12 @@ mod tests {
let store = TestStore::new();
let mut service = open(&store);
let longest = "r".repeat(MAX_IDENTITY_BYTES - LEASE_PREFIX.len() - PERSONA_SUFFIX.len());
let grant = granted(lease_in(&mut service, LeaseTurn::PersonaTurn, &longest, &none()));
let grant = granted(lease_in(
&mut service,
LeaseTurn::PersonaTurn,
&longest,
&none(),
));
assert_eq!(grant.lease_id.len(), MAX_IDENTITY_BYTES);
assert!(lease_try(&mut service, LeaseTurn::PersonaTurn, &format!("{longest}r")).is_err());
}