Struct TestId 

pub struct TestId {
    pub runner: Runner,
    pub name: String,
}

The stable identity of a test: the runner that owns it and the name that runner knows it by.

Derived from the path a claim already names, which is what makes the migration from test: <path> deterministic and empty of data entry. test/cases/84_x.sh is the case test/run.sh calls 84_x; apps/majordomus-cli/tests/why.rs is the binary cargo test --test why runs. Both spellings already exist in the repository; this only names the join.

use majordomus_cli::evidence::{Runner, TestId};

let id = TestId::of("test/cases/07_scope.sh").unwrap();
assert_eq!(id, TestId { runner: Runner::Suite, name: "07_scope".into() });

// the identity and the path are two spellings of one thing, so the derivation is
// reversible and no claim in `docs/CLAIMS.yaml` has to be rewritten to carry an id
assert_eq!(TestId::of(&id.source()).unwrap(), id);

Example

use majordomus_cli::evidence::TestId;
let t = TestId::of("apps/majordomus-cli/tests/product.rs").unwrap();
assert_eq!(t.as_string(), "crate:product");
assert_eq!(t.reproduce(), "cargo test --test product");
assert!(TestId::of("lib/nothing.sh").is_none());

Fields

runner: Runner

Which runner owns it.

name: String

The name that runner knows it by: a case’s file stem, a test binary’s file stem.

Implementations

impl TestId

pub fn as_string(&self) -> String

The canonical string form: suite:84_distribution_model, crate:why.

This is the ledger’s key. Every execution is stored and looked up under it, which is why the runner is part of it rather than context a reader is expected to carry.

use majordomus_cli::evidence::TestId;
assert_eq!(
    TestId::of("test/cases/07_scope.sh").unwrap().as_string(),
    "suite:07_scope"
);
assert_eq!(
    TestId::of("apps/majordomus-cli/tests/why.rs").unwrap().as_string(),
    "crate:why"
);

pub fn of(path: &str) -> Option<TestId>

The test a path names, when a runner in this repository produces it.

None is an answer, not a failure: a claim may name a file no runner drives (a template, a fixture, a document), and the report says so rather than counting it.

use majordomus_cli::evidence::{Runner, TestId};
assert_eq!(
    TestId::of("test/cases/84_distribution_model.sh").unwrap().as_string(),
    "suite:84_distribution_model"
);
assert_eq!(TestId::of("apps/majordomus-cli/tests/why.rs").unwrap().runner, Runner::Crate);
assert!(TestId::of("share/install/install.sh.in").is_none());
assert!(TestId::of("-").is_none());

pub fn named(runner: Runner, name: &str) -> Option<TestId>

A test named directly, validated by the same rule TestId::of applies to a path.

The identity form (suite:84_x) and the path form (test/cases/84_x.sh) name the same thing, so they must agree about what a name may be. They did not: the path form rejected a name containing a separator and the identity form did not, so suite:../../x produced the source test/cases/../../x.sh. Two parsers for one grammar is the one-way check this repository keeps finding; this is the grammar, and both forms go through it.

use majordomus_cli::evidence::{Runner, TestId};
assert_eq!(TestId::named(Runner::Suite, "84_x").unwrap().as_string(), "suite:84_x");
assert!(TestId::named(Runner::Suite, "../../x").is_none(), "a name is not a path");
assert!(TestId::named(Runner::Suite, "").is_none());
assert!(TestId::named(Runner::Crate, "a/b").is_none());
assert!(TestId::named(Runner::Suite, ".hidden").is_none());

pub fn source(&self) -> String

The repository-relative path of the test’s own source: the file that is hashed into Execution::digest, and one of the paths a claim’s staleness is measured over.

use majordomus_cli::evidence::TestId;
let id = TestId::of("apps/majordomus-cli/tests/why.rs").unwrap();
assert_eq!(id.source(), "apps/majordomus-cli/tests/why.rs");
// a case's source is the file the runner executes, not the runner
assert_eq!(
    TestId::of("test/cases/07_scope.sh").unwrap().source(),
    "test/cases/07_scope.sh"
);

pub fn reproduce(&self) -> String

The exact command that runs this one test, for a reader who wants the proof again rather than the claim that it exists.

One test, not the suite: a finding a reader can settle in seconds is settled, and one that costs a full run is argued about instead.

use majordomus_cli::evidence::TestId;
assert_eq!(
    TestId::of("test/cases/84_distribution_model.sh").unwrap().reproduce(),
    "bash test/run.sh 84_distribution_model"
);
assert_eq!(
    TestId::of("apps/majordomus-cli/tests/why.rs").unwrap().reproduce(),
    "cargo test --test why"
);

Trait Implementations

impl Clone for TestId

fn clone(&self) -> TestId

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TestId

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TestId

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for TestId

impl JsonSchema for TestId

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 Ord for TestId

fn cmp(&self, other: &TestId) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for TestId

fn eq(&self, other: &TestId) -> 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 PartialOrd for TestId

fn partial_cmp(&self, other: &TestId) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for TestId

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 TestId