Docs and Tracked<WorldHeader> record the first-touch value of every written key. submit applies to the live state between begin and finish and rolls back on any error, so the world is no longer cloned per commit; replay reads the commitments subjects finish() reports instead of cloning the partition. The encoding is unchanged: golden.digests is byte-identical. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
659 lines
22 KiB
Rust
659 lines
22 KiB
Rust
use super::*;
|
|
use crate::patch::{
|
|
AffordanceDeclaration, AffordanceKindName, AudienceSpec, Declaration, DraftHandle, EntityKind,
|
|
Mismatch, OutcomeBand, Precondition, Role, RoleSpec,
|
|
};
|
|
use crate::tests::{auth_principal, command, creation, owner};
|
|
use crate::{
|
|
CallerId, CommandBody, CommandId, CreateWorld, KernelError, SubjectKind, CommitReceipt,
|
|
WorldKernel, WorldPatch,
|
|
};
|
|
|
|
fn verb(path: RenderPath, roles: &[(&str, GrammarReferentKind)]) -> GrammarVerb {
|
|
GrammarVerb {
|
|
render_path: path,
|
|
roles: roles
|
|
.iter()
|
|
.map(|(role, referent)| GrammarRole {
|
|
role: (*role).into(),
|
|
referent: *referent,
|
|
})
|
|
.collect(),
|
|
}
|
|
}
|
|
|
|
/// What the fixture world's genesis needs: the kernel speak entry and the
|
|
/// fixture's own `convene`. Anything else a test wants is added to it.
|
|
fn grammar_with(extra: &[(&str, GrammarVerb)]) -> GrammarBinding {
|
|
let mut verbs = vec![
|
|
("speak".to_owned(), verb(RenderPath::Conversation, &[])),
|
|
("convene".to_owned(), verb(RenderPath::Conversation, &[])),
|
|
];
|
|
verbs.extend(
|
|
extra
|
|
.iter()
|
|
.map(|(kind, v)| ((*kind).to_owned(), v.clone())),
|
|
);
|
|
GrammarBinding::new("aetheria.grammar", 3, verbs).unwrap()
|
|
}
|
|
|
|
fn bound(grammar: Option<GrammarBinding>, title: &str) -> CreateWorld {
|
|
let mut world = creation(title);
|
|
world.grammar = grammar;
|
|
world
|
|
}
|
|
|
|
fn declare(handle: &str, kind: &str, roles: &[(&str, RefKind)]) -> Declaration {
|
|
Declaration::Affordance(AffordanceDeclaration {
|
|
handle: DraftHandle::new(handle),
|
|
kind: AffordanceKindName(kind.into()),
|
|
roles: roles
|
|
.iter()
|
|
.map(|(role, kind)| RoleSpec {
|
|
role: Role((*role).into()),
|
|
kind: *kind,
|
|
})
|
|
.collect(),
|
|
// Speech with one audience is the smallest entry the resolver does
|
|
// not refuse as inert; the grammar check does not read it.
|
|
preconditions: vec![Precondition::CanBroadcast {
|
|
via: AudienceSpec::Colocated,
|
|
}],
|
|
effect_slots: Vec::new(),
|
|
outcome_bands: vec![OutcomeBand {
|
|
weight: 1,
|
|
effects: Vec::new(),
|
|
}],
|
|
carries_speech: true,
|
|
})
|
|
}
|
|
|
|
fn patch_of(declarations: Vec<Declaration>) -> WorldPatch {
|
|
WorldPatch {
|
|
declarations,
|
|
operations: Vec::new(),
|
|
evidence: Vec::new(),
|
|
}
|
|
}
|
|
|
|
fn rejected(result: Result<impl Sized, KernelError>) -> Vec<Mismatch> {
|
|
match result {
|
|
Err(KernelError::PatchRejected(set)) => set,
|
|
Err(other) => panic!("expected a patch refusal, got {other:?}"),
|
|
Ok(_) => panic!("expected a patch refusal, the command was admitted"),
|
|
}
|
|
}
|
|
|
|
fn create(world: CreateWorld) -> Result<WorldKernel, KernelError> {
|
|
WorldKernel::create(world, &auth_principal(owner())).map(|(kernel, _)| kernel)
|
|
}
|
|
|
|
fn admit(kernel: &mut WorldKernel, patch: WorldPatch) -> Result<CommitReceipt, KernelError> {
|
|
let snapshot = kernel.snapshot().unwrap();
|
|
kernel.submit(
|
|
command(
|
|
&snapshot,
|
|
CallerId::Play,
|
|
CommandBody::AdmitPatch {
|
|
patch,
|
|
},
|
|
),
|
|
&crate::AuthenticatedCaller::verified_play(),
|
|
)
|
|
}
|
|
|
|
fn person() -> RefKind {
|
|
RefKind::Subject(Some(SubjectKind::Person))
|
|
}
|
|
|
|
fn place() -> RefKind {
|
|
RefKind::Entity(EntityKind::Place)
|
|
}
|
|
|
|
fn not_in_grammar(handle: &str) -> Vec<Mismatch> {
|
|
vec![Mismatch::AffordanceKindNotInGrammar {
|
|
handle: DraftHandle::new(handle),
|
|
}]
|
|
}
|
|
|
|
fn disagrees(handle: &str) -> Vec<Mismatch> {
|
|
vec![Mismatch::AffordanceRolesDisagreeWithGrammar {
|
|
handle: DraftHandle::new(handle),
|
|
}]
|
|
}
|
|
|
|
#[test]
|
|
fn grammar_world_refuses_an_affordance_kind_outside_the_grammar() {
|
|
// Genesis: a declared kind the binding lacks is refused.
|
|
let mut world = bound(Some(grammar_with(&[])), "Outside");
|
|
world.patch.declarations.push(declare("wave", "wave", &[]));
|
|
assert_eq!(rejected(create(world)), not_in_grammar("wave"));
|
|
|
|
// A later AdmitPatch: the same kind is refused, and a verb the grammar
|
|
// does carry is admitted by the same path.
|
|
let extra = [("hail", verb(RenderPath::Conversation, &[]))];
|
|
let kernel = create(bound(Some(grammar_with(&extra)), "Outside"));
|
|
let mut kernel = kernel.unwrap();
|
|
assert_eq!(
|
|
rejected(admit(
|
|
&mut kernel,
|
|
patch_of(vec![declare("wave", "wave", &[])])
|
|
)),
|
|
not_in_grammar("wave")
|
|
);
|
|
let receipt = admit(&mut kernel, patch_of(vec![declare("hail", "hail", &[])])).unwrap();
|
|
assert!(receipt.resulting_revision > 0);
|
|
}
|
|
|
|
#[test]
|
|
fn grammar_world_refuses_a_role_signature_the_grammar_does_not_carry() {
|
|
let extra = [
|
|
(
|
|
"meet",
|
|
verb(
|
|
RenderPath::ShipAction,
|
|
&[
|
|
("who", GrammarReferentKind::Person),
|
|
("where_", GrammarReferentKind::Place),
|
|
],
|
|
),
|
|
),
|
|
("hail", verb(RenderPath::Conversation, &[])),
|
|
];
|
|
let kernel = create(bound(Some(grammar_with(&extra)), "Signatures"));
|
|
let mut kernel = kernel.unwrap();
|
|
for (label, roles) in [
|
|
("renamed", vec![("whom", person()), ("where_", place())]),
|
|
("rekinded", vec![("who", person()), ("where_", person())]),
|
|
("swapped", vec![("where_", place()), ("who", person())]),
|
|
("short", vec![("who", person())]),
|
|
(
|
|
"long",
|
|
vec![("who", person()), ("where_", place()), ("why", person())],
|
|
),
|
|
] {
|
|
let set = rejected(admit(
|
|
&mut kernel,
|
|
patch_of(vec![declare(label, "meet", &roles)]),
|
|
));
|
|
assert_eq!(set, disagrees(label), "{label}");
|
|
}
|
|
// A role on a verb the grammar declares with none.
|
|
let set = rejected(admit(
|
|
&mut kernel,
|
|
patch_of(vec![declare("hail", "hail", &[("who", person())])]),
|
|
));
|
|
assert_eq!(set, disagrees("hail"));
|
|
// The exact signature is admitted.
|
|
let receipt = admit(
|
|
&mut kernel,
|
|
patch_of(vec![declare(
|
|
"meet",
|
|
"meet",
|
|
&[("who", person()), ("where_", place())],
|
|
)]),
|
|
)
|
|
.unwrap();
|
|
assert!(receipt.resulting_revision > 0);
|
|
}
|
|
|
|
#[test]
|
|
fn each_grammar_referent_kind_admits_exactly_its_own_kernel_kind() {
|
|
let kinds = [
|
|
(GrammarReferentKind::Person, person()),
|
|
(
|
|
GrammarReferentKind::Faction,
|
|
RefKind::Subject(Some(SubjectKind::Institution)),
|
|
),
|
|
(
|
|
GrammarReferentKind::Population,
|
|
RefKind::Subject(Some(SubjectKind::Population)),
|
|
),
|
|
(GrammarReferentKind::Place, place()),
|
|
(
|
|
GrammarReferentKind::Cargo,
|
|
RefKind::Entity(EntityKind::Resource),
|
|
),
|
|
];
|
|
for (referent, own) in &kinds {
|
|
let extra = [("act", verb(RenderPath::ShipAction, &[("with", *referent)]))];
|
|
for (_, offered) in &kinds {
|
|
let kernel = create(bound(Some(grammar_with(&extra)), "Referents"));
|
|
let mut kernel = kernel.unwrap();
|
|
let result = admit(
|
|
&mut kernel,
|
|
patch_of(vec![declare("act", "act", &[("with", *offered)])]),
|
|
);
|
|
if offered == own {
|
|
assert!(
|
|
matches!(result, Ok(_)),
|
|
"{referent:?} refused its own kind"
|
|
);
|
|
} else {
|
|
assert_eq!(
|
|
rejected(result),
|
|
disagrees("act"),
|
|
"{referent:?} admitted {offered:?}"
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn grammar_world_without_speak_refuses_the_kernel_speak_grant() {
|
|
let no_speak = GrammarBinding::new(
|
|
"aetheria.grammar",
|
|
1,
|
|
[("convene".to_owned(), verb(RenderPath::Conversation, &[]))],
|
|
)
|
|
.unwrap();
|
|
assert_eq!(
|
|
rejected(create(bound(Some(no_speak), "Mute"))),
|
|
not_in_grammar(crate::patch::KERNEL_SPEAK_HANDLE)
|
|
);
|
|
|
|
// The kernel entry is held to the signature as well as the kind.
|
|
let loud = GrammarBinding::new(
|
|
"aetheria.grammar",
|
|
1,
|
|
[
|
|
(
|
|
"speak".to_owned(),
|
|
verb(
|
|
RenderPath::Conversation,
|
|
&[("to", GrammarReferentKind::Person)],
|
|
),
|
|
),
|
|
("convene".to_owned(), verb(RenderPath::Conversation, &[])),
|
|
],
|
|
)
|
|
.unwrap();
|
|
assert_eq!(
|
|
rejected(create(bound(Some(loud), "Loud"))),
|
|
disagrees(crate::patch::KERNEL_SPEAK_HANDLE)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn unbound_world_keeps_the_open_catalog() {
|
|
let mut world = bound(None, "Open");
|
|
world
|
|
.patch
|
|
.declarations
|
|
.push(declare("wave", "wave", &[("at", person())]));
|
|
let kernel = create(world);
|
|
let mut kernel = kernel.unwrap();
|
|
let receipt = admit(
|
|
&mut kernel,
|
|
patch_of(vec![declare("beacon", "beacon", &[])]),
|
|
)
|
|
.unwrap();
|
|
assert!(receipt.resulting_revision > 0);
|
|
let snapshot = kernel.snapshot().unwrap();
|
|
assert!(snapshot.grammar.is_none());
|
|
assert!(snapshot.affordances.len() >= 4);
|
|
assert!(snapshot.affordances.iter().all(|a| a.render_path.is_none()));
|
|
|
|
// The state row of a world with no grammar carries no grammar key, so its
|
|
// bytes and digests are those of a world written before grammars existed.
|
|
let encoded = rmp_serde::to_vec_named(&kernel.state).unwrap();
|
|
let keys: std::collections::BTreeMap<String, serde::de::IgnoredAny> =
|
|
rmp_serde::from_slice(&encoded).unwrap();
|
|
assert!(!keys.contains_key("grammar"));
|
|
assert!(keys.contains_key("title"));
|
|
}
|
|
|
|
#[test]
|
|
fn a_bound_world_reports_its_grammar_and_derives_render_paths_from_it() {
|
|
let extra = [("dock", verb(RenderPath::ShipAction, &[]))];
|
|
let grammar = grammar_with(&extra);
|
|
let identity = grammar.identity();
|
|
let kernel = create(bound(Some(grammar), "Reports"));
|
|
let mut kernel = kernel.unwrap();
|
|
admit(&mut kernel, patch_of(vec![declare("dock", "dock", &[])])).unwrap();
|
|
let snapshot = kernel.snapshot().unwrap();
|
|
assert_eq!(snapshot.grammar, Some(identity));
|
|
let path_of = |kind: &str| {
|
|
snapshot
|
|
.affordances
|
|
.iter()
|
|
.find(|a| a.entry.kind.0 == kind)
|
|
.unwrap_or_else(|| panic!("{kind} is in the catalog"))
|
|
.render_path
|
|
};
|
|
assert_eq!(path_of("dock"), Some(RenderPath::ShipAction));
|
|
assert_eq!(path_of("convene"), Some(RenderPath::Conversation));
|
|
assert_eq!(path_of("speak"), Some(RenderPath::Conversation));
|
|
}
|
|
|
|
#[test]
|
|
fn a_reopened_grammar_world_still_holds_its_grammar() {
|
|
let grammar = grammar_with(&[]);
|
|
let identity = grammar.identity();
|
|
let kernel = create(bound(Some(grammar), "Reopened"));
|
|
let kernel = kernel.unwrap();
|
|
let exported = kernel.export().unwrap();
|
|
drop(kernel);
|
|
let mut reopened = WorldKernel::open(&exported).unwrap();
|
|
assert_eq!(reopened.snapshot().unwrap().grammar, Some(identity));
|
|
assert_eq!(
|
|
rejected(admit(
|
|
&mut reopened,
|
|
patch_of(vec![declare("wave", "wave", &[])])
|
|
)),
|
|
not_in_grammar("wave")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn the_bound_grammar_is_part_of_the_world_state_digest() {
|
|
let kernel = create(bound(Some(grammar_with(&[])), "Digested"));
|
|
let kernel = kernel.unwrap();
|
|
let bound_digest = crate::state_digest(&kernel.state).unwrap();
|
|
let mut state = kernel.state.clone();
|
|
state.header.get_mut().grammar = None;
|
|
let open_digest = crate::state_digest(&state).unwrap();
|
|
state.header.get_mut().grammar = Some(grammar_with(&[("dock", verb(RenderPath::ShipAction, &[]))]));
|
|
let other_digest = crate::state_digest(&state).unwrap();
|
|
assert_ne!(bound_digest, open_digest);
|
|
assert_ne!(bound_digest, other_digest);
|
|
}
|
|
|
|
#[test]
|
|
fn grammar_digest_is_derived_and_order_free() {
|
|
let forward = [
|
|
("alpha".to_owned(), verb(RenderPath::ShipAction, &[])),
|
|
(
|
|
"beta".to_owned(),
|
|
verb(
|
|
RenderPath::Conversation,
|
|
&[("to", GrammarReferentKind::Person)],
|
|
),
|
|
),
|
|
("gamma".to_owned(), verb(RenderPath::Conversation, &[])),
|
|
];
|
|
let mut reversed = forward.clone();
|
|
reversed.reverse();
|
|
let a = GrammarBinding::new("aetheria.grammar", 1, forward.clone()).unwrap();
|
|
let b = GrammarBinding::new("aetheria.grammar", 1, reversed).unwrap();
|
|
assert_eq!(a.digest, b.digest);
|
|
assert_eq!(a, b);
|
|
|
|
// Content-derived: each part of a verb moves the digest.
|
|
let changed = |edit: &dyn Fn(&mut Vec<(String, GrammarVerb)>)| {
|
|
let mut verbs = forward.to_vec();
|
|
edit(&mut verbs);
|
|
GrammarBinding::new("aetheria.grammar", 1, verbs)
|
|
.unwrap()
|
|
.digest
|
|
};
|
|
assert_ne!(
|
|
a.digest,
|
|
changed(&|v| v[0].1.render_path = RenderPath::Conversation)
|
|
);
|
|
assert_ne!(a.digest, changed(&|v| v[1].1.roles[0].role = "from".into()));
|
|
assert_ne!(
|
|
a.digest,
|
|
changed(&|v| v[1].1.roles[0].referent = GrammarReferentKind::Faction)
|
|
);
|
|
assert_ne!(a.digest, changed(&|v| v[2].0 = "delta".into()));
|
|
assert_ne!(
|
|
a.digest,
|
|
changed(&|v| {
|
|
v.pop();
|
|
})
|
|
);
|
|
// Role order is part of a verb.
|
|
let ordered = |roles: &[(&str, GrammarReferentKind)]| {
|
|
GrammarBinding::new(
|
|
"g",
|
|
1,
|
|
[("meet".to_owned(), verb(RenderPath::ShipAction, roles))],
|
|
)
|
|
.unwrap()
|
|
.digest
|
|
};
|
|
assert_ne!(
|
|
ordered(&[
|
|
("a", GrammarReferentKind::Person),
|
|
("b", GrammarReferentKind::Place)
|
|
]),
|
|
ordered(&[
|
|
("b", GrammarReferentKind::Place),
|
|
("a", GrammarReferentKind::Person)
|
|
])
|
|
);
|
|
// The identity reads the same fields back.
|
|
let identity = a.identity();
|
|
assert_eq!(identity.schema_id, "aetheria.grammar");
|
|
assert_eq!(identity.revision, 1);
|
|
assert_eq!(identity.digest, a.digest);
|
|
}
|
|
|
|
#[test]
|
|
fn a_tampered_grammar_digest_fails_to_deserialise() {
|
|
let binding = grammar_with(&[]);
|
|
let value = serde_json::to_value(&binding).unwrap();
|
|
// Untouched: the round trip holds.
|
|
let back: GrammarBinding = serde_json::from_value(value.clone()).unwrap();
|
|
assert_eq!(back, binding);
|
|
|
|
// A digest the verbs do not have.
|
|
let mut forged = value.clone();
|
|
forged["digest"] = "sha256:00".into();
|
|
assert!(serde_json::from_value::<GrammarBinding>(forged.clone()).is_err());
|
|
|
|
// A verb edited under the digest it already had.
|
|
let mut edited = value;
|
|
edited["verbs"]["convene"]["render_path"] = "ship_action".into();
|
|
assert!(serde_json::from_value::<GrammarBinding>(edited).is_err());
|
|
|
|
// The named encoding a state row uses refuses it the same way.
|
|
let bytes = rmp_serde::to_vec_named(&forged).unwrap();
|
|
assert!(rmp_serde::from_slice::<GrammarBinding>(&bytes).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn a_grammar_names_each_verb_once_and_has_a_schema() {
|
|
assert_eq!(
|
|
GrammarBinding::new("", 1, Vec::new()).unwrap_err(),
|
|
GrammarError::EmptySchemaId
|
|
);
|
|
assert_eq!(
|
|
GrammarBinding::new(
|
|
"g",
|
|
1,
|
|
[
|
|
("hail".to_owned(), verb(RenderPath::Conversation, &[])),
|
|
("hail".to_owned(), verb(RenderPath::ShipAction, &[])),
|
|
]
|
|
)
|
|
.unwrap_err(),
|
|
GrammarError::DuplicateVerb
|
|
);
|
|
}
|
|
|
|
fn submit_as(
|
|
kernel: &mut WorldKernel,
|
|
caller: CallerId,
|
|
patch: WorldPatch,
|
|
) -> Result<CommitReceipt, KernelError> {
|
|
let snapshot = kernel.snapshot().unwrap();
|
|
kernel.submit(
|
|
command(
|
|
&snapshot,
|
|
caller.clone(),
|
|
CommandBody::AdmitPatch { patch },
|
|
),
|
|
&crate::AuthenticatedCaller::fixture(caller),
|
|
)
|
|
}
|
|
|
|
/// A bound world whose revision has moved past genesis: one Play patch
|
|
/// that adds a dead-end place.
|
|
fn advanced_grammar_world() -> (WorldKernel, crate::EntityId) {
|
|
let extra = [("hail", verb(RenderPath::Conversation, &[]))];
|
|
let kernel = create(bound(Some(grammar_with(&extra)), "Advanced"));
|
|
let mut kernel = kernel.unwrap();
|
|
let commons = *kernel.state.entities.keys().next().unwrap();
|
|
admit(
|
|
&mut kernel,
|
|
patch_of(vec![
|
|
Declaration::Entity(crate::patch::EntityDeclaration {
|
|
handle: DraftHandle::new("dead-end"),
|
|
label: "The Unwalked Road".into(),
|
|
kind: EntityKind::Place,
|
|
container: None,
|
|
}),
|
|
Declaration::Route(crate::patch::RouteDeclaration {
|
|
handle: DraftHandle::new("gate"),
|
|
label: "The Field Gate".into(),
|
|
from: crate::patch::Ref::Existing(commons),
|
|
to: crate::patch::Ref::Draft(DraftHandle::new("dead-end")),
|
|
access: crate::patch::AccessKind::Public,
|
|
cost: crate::patch::Cost(1),
|
|
}),
|
|
]),
|
|
)
|
|
.unwrap();
|
|
let dead_end = *kernel
|
|
.state
|
|
.entities
|
|
.iter()
|
|
.find(|(_, record)| record.label == "The Unwalked Road")
|
|
.map(|(id, _)| id)
|
|
.unwrap();
|
|
(kernel, dead_end)
|
|
}
|
|
|
|
type Door = (&'static str, CallerId);
|
|
|
|
/// Each door refuses an outside kind and a wrong role signature, typed, and the
|
|
/// refusal leaves the revision where it was.
|
|
fn refuse_at_each_door(kernel: &mut WorldKernel, doors: Vec<Door>) {
|
|
for (door, caller) in doors {
|
|
let revision = kernel.state.revision;
|
|
let kind = submit_as(
|
|
kernel,
|
|
caller.clone(),
|
|
patch_of(vec![declare("wave", "wave", &[])]),
|
|
);
|
|
assert_eq!(rejected(kind), not_in_grammar("wave"), "{door}");
|
|
let roles = submit_as(
|
|
kernel,
|
|
caller,
|
|
patch_of(vec![declare("hail", "hail", &[("who", person())])]),
|
|
);
|
|
assert_eq!(rejected(roles), disagrees("hail"), "{door}");
|
|
assert_eq!(
|
|
kernel.state.revision, revision,
|
|
"{door} refusal moved the world"
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn play_refuses_outside_the_grammar_after_the_revision_has_moved() {
|
|
let (mut kernel, _) = advanced_grammar_world();
|
|
assert_eq!(kernel.state.revision, 1);
|
|
refuse_at_each_door(&mut kernel, vec![("play", CallerId::Play)]);
|
|
// The same path admits what the grammar carries, so the refusals above are
|
|
// the grammar's and not a closed door.
|
|
let receipt = submit_as(
|
|
&mut kernel,
|
|
CallerId::Play,
|
|
patch_of(vec![declare("hail", "hail", &[])]),
|
|
)
|
|
.unwrap();
|
|
assert!(receipt.resulting_revision > 0);
|
|
}
|
|
|
|
#[test]
|
|
fn a_grammar_that_binds_speak_as_anything_but_conversation_is_refused_at_bind() {
|
|
let ship = |roles: &[(&str, GrammarReferentKind)]| {
|
|
GrammarBinding::new(
|
|
"aetheria.grammar",
|
|
1,
|
|
[
|
|
("speak".to_owned(), verb(RenderPath::ShipAction, roles)),
|
|
("convene".to_owned(), verb(RenderPath::Conversation, &[])),
|
|
],
|
|
)
|
|
.unwrap()
|
|
};
|
|
assert_eq!(
|
|
rejected(create(bound(Some(ship(&[])), "Filmed speech"))),
|
|
vec![Mismatch::SpeakRenderPathDisagreesWithGrammar {
|
|
handle: DraftHandle::new(crate::patch::KERNEL_SPEAK_HANDLE),
|
|
}]
|
|
);
|
|
// A ShipAction speak with a role fails on the signature first and is still
|
|
// refused: no variant of speak but zero roles, Conversation, is admitted.
|
|
assert_eq!(
|
|
rejected(
|
|
create(bound(
|
|
Some(ship(&[("to", GrammarReferentKind::Person)])),
|
|
"Loud"
|
|
))
|
|
),
|
|
disagrees(crate::patch::KERNEL_SPEAK_HANDLE)
|
|
);
|
|
// The control: Conversation speak binds.
|
|
assert!(create(bound(Some(grammar_with(&[])), "Spoken")).is_ok());
|
|
}
|
|
|
|
/// `apply_effect` re-decides an effect it is handed. An effect resolved against
|
|
/// a world with no grammar must not install an entry the bound grammar lacks:
|
|
/// the catalog's only writer holds the grammar check itself.
|
|
#[test]
|
|
fn an_effect_resolved_elsewhere_cannot_install_an_entry_outside_the_grammar() {
|
|
let extra = [
|
|
(
|
|
"meet",
|
|
verb(
|
|
RenderPath::ShipAction,
|
|
&[("who", GrammarReferentKind::Person)],
|
|
),
|
|
),
|
|
("hail", verb(RenderPath::Conversation, &[])),
|
|
];
|
|
let kernel = create(bound(Some(grammar_with(&extra)), "Forged"));
|
|
let kernel = kernel.unwrap();
|
|
let mut twin = kernel.state.clone();
|
|
twin.header.get_mut().grammar = None;
|
|
let resolve = |kind: &str, roles: &[(&str, RefKind)]| {
|
|
crate::patch::resolve_patch(
|
|
&twin,
|
|
CommandId::issue(),
|
|
&patch_of(vec![declare("probe", kind, roles)]),
|
|
)
|
|
.expect("the unbound twin admits any canonical kind")
|
|
};
|
|
for (label, resolved, admitted) in [
|
|
("outside kind", resolve("wave", &[]), false),
|
|
("wrong roles", resolve("meet", &[("whom", person())]), false),
|
|
("carried verb", resolve("hail", &[]), true),
|
|
] {
|
|
let mut state = kernel.state.clone();
|
|
let catalog = state.affordance_catalog.len();
|
|
let result = crate::apply_effect(
|
|
&mut state,
|
|
CommandId::issue(),
|
|
&CallerId::Play,
|
|
&crate::WorldEffect::PatchAdmitted {
|
|
resolved,
|
|
},
|
|
);
|
|
if admitted {
|
|
result.unwrap_or_else(|error| panic!("{label}: {error:?}"));
|
|
assert_eq!(state.affordance_catalog.len(), catalog + 1, "{label}");
|
|
} else {
|
|
assert!(
|
|
matches!(result, Err(KernelError::Invariant(_))),
|
|
"{label}: {result:?}"
|
|
);
|
|
assert_eq!(state.affordance_catalog.len(), catalog, "{label}");
|
|
}
|
|
}
|
|
}
|