Struct Expectations 

pub struct Expectations {

    pub outcome: OutcomeExpectation,
    pub acts: Option<Vec<ActExpectation>>,
    pub target_resolution: Vec<TargetExpectation>,
    pub commands: Option<Vec<String>>,
    pub events: Option<Vec<String>>,
    pub case_revision: Vec<RevisionExpectation>,
    pub interaction_status: Vec<InteractionStatusExpectation>,
    pub case_state: Vec<StateExpectation>,
    pub workflow_state: Vec<WorkflowStateExpectation>,
    pub case_count: Vec<CaseCountExpectation>,
    pub blocks: Option<Vec<BlockKind>>,
    pub turn_phase: Option<TurnPhase>,
    pub forbid: ForbiddenEffects,
    pub understanding: Option<UnderstandingExpectation>,
}

What must be true after the turn, checked without a model (spec §27.6).

Every field is optional and every one of them means the same thing when absent: this item does not assert on it. A field that is present is an exact claim — commands = [] asserts that the turn compiled no command at all, which is a different and much stronger statement than leaving the key out.

Fields

outcome: OutcomeExpectation

Whether the turn must complete at all. Defaults to OutcomeExpectation::Succeeds, so a crashed turn fails an item even when every other expectation is trivially satisfied by the wreckage.

acts: Option<Vec<ActExpectation>>

The acts the message was understood to ask for, in order.

target_resolution: Vec<TargetExpectation>

How each act’s target resolved.

commands: Option<Vec<String>>

The command types journaled this turn, in admission order.

events: Option<Vec<String>>

The event types committed this turn, in append order.

case_revision: Vec<RevisionExpectation>

The revision each case ends the turn at.

interaction_status: Vec<InteractionStatusExpectation>

The status of the cards on a case.

case_state: Vec<StateExpectation>

What a case’s state says after the turn, field by field.

The two questions it answers are not the same one. equals asks what a value ended up being, which is how a scenario about a user changing their mind, Porto and then Lisbon, can say which one survived; the events alone cannot, because both stories commit the same event. unchanged asks that a value did not move at all, which is what a turn whose correct answer writes nothing needs.

workflow_state: Vec<WorkflowStateExpectation>

What some case of a workflow holds at the end, seeded or created by the conversation, for a case whose identifier no file can know.

case_count: Vec<CaseCountExpectation>

How many cases of a workflow exist at the end, seeded and created.

blocks: Option<Vec<BlockKind>>

The kinds of response block, in order.

turn_phase: Option<TurnPhase>

The phase the turn finished in.

forbid: ForbiddenEffects

Effects that must not appear.

understanding: Option<UnderstandingExpectation>

What each understanding task must make of the message.

Implementations

impl Expectations

pub fn validate(&self) -> Result<(), CorpusError>

Checks the expectations do not contradict each other.

Errors

CorpusError::Invalid when an act names an operation its kind cannot carry, when a resolution names a case it cannot have, or when the same command or event is both required and forbidden.

pub fn is_empty(&self) -> bool

Returns true when nothing at all is asserted deterministically.

Trait Implementations

impl Clone for Expectations

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Expectations

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Expectations

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Expectations

where Expectations: Default,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Expectations

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Expectations

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Expectations