Enum IntentEvidenceState 

pub enum IntentEvidenceState {
    Current,
    Stale,
    Failing,
    NotRun,
    NotDerivable,
    Unresolved,
}

What the evidence behind one criterion says, as a word. Only Current meets a criterion: a stale, failing, unrecorded or underivable reference never does, and neither does one that resolves to nothing.

Whether a recorded run is current is not decided here. A test or claim criterion is judged by the evidence module’s one truth table (evidence::freshness()) at the working tree and read through evidence::current, the same judgement the claim report and the subject pages make; IntentEvidenceState::judged is the whole of the translation. So the state follows the evidence both ways: a criterion met today reads stale or failing the moment the ledger or the tree says so, and met again once a current pass is recorded.

use majordomus_cli::intent::IntentEvidenceState;
assert_eq!(serde_json::to_string(&IntentEvidenceState::NotRun).unwrap(), "\"not_run\"");
assert_ne!(IntentEvidenceState::Stale, IntentEvidenceState::Current);

Variants

Current

A passing run that is current evidence at the working tree: its commit is in this history, it measured a tree that was its commit, the test still hashes to what ran, and nothing the criterion names has changed since — for a test, its source and the source and implementation of every claim that test proves; for a claim, what the claim names. A change the criterion does not name, the evidence ledger’s own included, leaves it current. A test that proves no claim naming an implementation names no code under test, so for it nothing but the ledger may have changed since the run. The only state that meets a criterion; the criterion’s proof says whether it rests on proven or on inputs_unchanged.

Stale

A pass that is not current evidence: something the criterion names has changed since it, it names no code under test and anything but the ledger and the plan’s own records has changed since, the test no longer hashes to what ran, the run’s commit is not in this history (or git could not compare it), or the run measured a tree that was not its commit — a run on a dirty tree, which no later tree can be matched against.

Failing

The latest recorded run failed, timed out or errored.

NotRun

The reference resolves and no run counts for it: none was recorded, the latest run declined to run (a skip), or the claim names no test a runner drives.

NotDerivable

The reference resolves, and this kind of evidence (command, deployment) is not derivable from the ledger, so it never meets a criterion by itself.

Unresolved

The reference is empty or names nothing this repository holds.

Implementations

impl IntentEvidenceState

pub fn as_str(self) -> &'static str

The word every surface prints for this state, the same one serde writes.

use majordomus_cli::intent::IntentEvidenceState;
assert_eq!(IntentEvidenceState::NotDerivable.as_str(), "not_derivable");

pub fn judged(state: ProofState, recorded: TreeState) -> IntentEvidenceState

A verdict of the evidence module’s truth table, in this vocabulary: current only when evidence::current says so, of a run on the tree recorded (the execution’s own working_tree; TreeState::Unknown when there is none). A pass that is not current is stale — including a run on a dirty tree whose inputs read unchanged — a skip and an absence are not run, and a failure is failing.

use majordomus_cli::evidence::{ProofState, TreeState};
use majordomus_cli::intent::IntentEvidenceState;

let judged = IntentEvidenceState::judged;
assert_eq!(judged(ProofState::InputsUnchanged, TreeState::Clean), IntentEvidenceState::Current);
// a run on a tree that was not its commit proves nothing about a later one
assert_eq!(judged(ProofState::InputsUnchanged, TreeState::Dirty), IntentEvidenceState::Stale);
assert_eq!(judged(ProofState::Failing, TreeState::Clean), IntentEvidenceState::Failing);

Trait Implementations

impl Clone for IntentEvidenceState

fn clone(&self) -> IntentEvidenceState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for IntentEvidenceState

impl Debug for IntentEvidenceState

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for IntentEvidenceState

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for IntentEvidenceState

impl JsonSchema for IntentEvidenceState

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for IntentEvidenceState

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for IntentEvidenceState

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 IntentEvidenceState