Desk wire envelope delta: failing tests first (empty deciders refused at decode, minItems 1, refusal round trip)

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
Eureka 2026-11-10 20:43:31 +00:00
commit 0e590f3638
3 changed files with 61 additions and 14 deletions

View file

@ -1561,25 +1561,29 @@ mod tests {
}
#[test]
fn a_duplicate_decider_is_refused_naming_deciders_and_an_empty_list_decodes() {
fn an_empty_or_duplicated_decider_list_is_refused_at_decode_and_one_is_accepted() {
let mut mind = desk();
let hash = hash_of(&mind, FORK);
let before = (head(&mind), stored_count(&mind, FORK));
let mut twice = list_of(3);
twice.push(s("d1"));
for sent in desk_requests(INSTANCE, &twice, &hash) {
let failure = through_the_door(&sent).unwrap_err();
assert_eq!(failure.code, "payload-not-a-request");
assert!(failure.message.contains("deciders") && !failure.message.contains("d1"), "{}", failure.message);
for (what, list) in [("empty", vec![]), ("duplicate", twice)] {
for sent in desk_requests(INSTANCE, &list, &hash) {
let failure = through_the_door(&sent).unwrap_err();
assert_eq!(failure.code, "payload-not-a-request", "{what} {}", sent.operation());
assert!(failure.message.contains("deciders") && !failure.message.contains("d1"), "{what} {}: {}", sent.operation(), failure.message);
}
}
// An empty list is a list: it decodes, and the Mind's showability gate is what says no.
let before = head(&mind);
let [answer, forks, fork] = desk_requests(INSTANCE, &[], &hash);
assert!(through_the_door(&forks).is_ok() && through_the_door(&fork).is_ok());
let DeskRequest::Answer { subject, authority, deciders, request, .. } = through_the_door(&answer).unwrap() else { panic!("not an answer") };
assert!(deciders.is_empty());
let refused = not_stored(mind.desk_answer(&deciders, subject, authority, request, now()).0);
// One decider is a list.
for sent in desk_requests(INSTANCE, &list_of(1), &hash) {
assert_eq!(through_the_door(&sent).unwrap(), sent);
}
assert_eq!((head(&mind), stored_count(&mind, FORK)), before);
// The Mind's showability gate is the second line: an empty list handed to it directly
// still refuses the fork and stores nothing.
let refused = not_stored(mind.desk_answer(&[], s("d0"), DeskAuthority::Member, wire(FORK, &hash), now()).0);
assert_eq!(refused.code, ForkRefusalCode::ForkUnknown);
assert_eq!(head(&mind), before);
assert_eq!((head(&mind), stored_count(&mind, FORK)), before);
}
#[test]

View file

@ -630,4 +630,47 @@ mod tests {
assert!(wire(&message) <= DESK_MAX_RESPONSE_BYTES && wire(&message) > 4000, "{}", wire(&message));
assert_eq!(decode_desk_response(&message).unwrap().1, Ok(response));
}
/// A desk call's refusal rides `huginn.desk_response.v1` whole: code and detail survive the
/// wire, and the published schema declares the variant. One row per refusal a desk call can
/// return, the four the door maps to `NotStored` included, because the response type can
/// carry any of them.
#[test]
fn every_refusal_a_desk_call_can_return_round_trips_losslessly() {
use crate::desk_wire::DESK_RESPONSE_SCHEMA_JSON;
use eureka_pipeline::{PipelineKind, PipelineRefusal};
let refusals = [
MindRefusal::Unavailable { detail: "the store did not answer".into() },
MindRefusal::ForeignInstance { declared: OTHER.into(), mind: INSTANCE.into() },
MindRefusal::MissingIdentity,
MindRefusal::DeskAnswerOutsideDesk { id: "eureka-state:desk_answer:Q1.n1".into() },
MindRefusal::MissingReference { kind: PipelineKind::Question, id: "eureka-state:question:Q9".into() },
MindRefusal::CampaignMoved { campaign: "eureka-state".into(), to: OTHER.into() },
MindRefusal::DeskRequestInvalid { field: "desk_answer.note".into() },
MindRefusal::DeskRequestIdConflict { request_id: "00000000-0000-4000-8000-000000000001".into() },
MindRefusal::Document(PipelineRefusal::FieldBound { field: "note".into(), limit: 4000, actual: 4001 }),
MindRefusal::Document(PipelineRefusal::InvalidFormat { field: "request_id".into(), value: "x".into() }),
MindRefusal::Document(PipelineRefusal::InvalidIdentity { kind: PipelineKind::DeskAnswer, key: "k".into(), expected: "e".into() }),
MindRefusal::Document(PipelineRefusal::DuplicateRepo { field: "repos".into(), repo: "GameCult/Huginn".into() }),
MindRefusal::Document(PipelineRefusal::ForeignStore { r#type: "other".into() }),
];
let schema: serde_json::Value = serde_json::from_str(DESK_RESPONSE_SCHEMA_JSON).unwrap();
assert!(schema["$defs"]["MindRefusal"].is_object() && schema["$defs"]["PipelineRefusal"].is_object());
let declared = serde_json::to_string(&schema).unwrap();
for refusal in refusals {
let response = DeskResponse::Refused(refusal.clone());
let message = encode_desk_response("m-12", "answer", &response, "huginn-yggdrasil").unwrap();
let (_, decoded) = decode_desk_response(&message).unwrap();
assert_eq!(decoded, Ok(DeskResponse::Refused(refusal.clone())), "{refusal:?}");
let value = serde_json::to_value(&refusal).unwrap();
let variant = value.as_str().map(str::to_string).or_else(|| value.as_object().and_then(|object| object.keys().next().cloned())).unwrap();
assert!(declared.contains(&format!("\"{variant}\"")), "the published schema declares {variant}");
// Each detail field is declared too, so a validator can hold the payload to the schema.
if let Some(object) = value.get(&variant).and_then(|inner| inner.as_object()) {
for field in object.keys() {
assert!(declared.contains(&format!("\"{field}\"")), "{variant}.{field} is declared");
}
}
}
}
}

View file

@ -592,7 +592,7 @@ mod tests {
assert_eq!(DESK_REQUEST_SCHEMA_JSON.replace("\r\n", "\n"), request);
assert_eq!(DESK_RESPONSE_SCHEMA_JSON.replace("\r\n", "\n"), response);
// The deciders bound is in the published schema, not only in the decoder.
assert!(request.contains("\"maxItems\": 64") && request.contains("\"uniqueItems\": true"), "deciders bound");
assert!(request.contains("\"maxItems\": 64") && request.contains("\"uniqueItems\": true") && request.contains("\"minItems\": 1"), "deciders bound");
let index: serde_json::Value = serde_json::from_str(include_str!("../../../schemas/cultnet/index.json")).unwrap();
for (id, title) in [(DESK_REQUEST_SCHEMA, "Huginn desk request"), (DESK_RESPONSE_SCHEMA, "Huginn desk response")] {
let rows: Vec<_> = index["schemas"].as_array().unwrap().iter().filter(|row| row["schemaId"] == id).collect();