Struct MultiReport

Source

pub struct MultiReport {
    pub schema_version: u32,
    pub subject: String,
    pub subject_version: String,
    pub started_at: DateTime<Utc>,
    pub finished_at: Option<DateTime<Utc>>,
    pub reports: Vec<Report>,
}

Expand description

Aggregate of multiple Reports emitted in a single run.

Identity of a check is (producer, name). Two checks with the same name from different producers are kept separate.

§Example

use dev_report::{CheckResult, MultiReport, Report, Severity, Verdict};

let mut bench = Report::new("crate", "0.1.0").with_producer("dev-bench");
bench.push(CheckResult::pass("hot_path"));

let mut chaos = Report::new("crate", "0.1.0").with_producer("dev-chaos");
chaos.push(CheckResult::fail("recover", Severity::Error));

let mut multi = MultiReport::new("crate", "0.1.0");
multi.push(bench);
multi.push(chaos);
multi.finish();

assert_eq!(multi.overall_verdict(), Verdict::Fail);
assert_eq!(multi.total_check_count(), 2);

Fields§

§schema_version: u32

Schema version. Tracks the same number as Report::schema_version.

§subject: String

Crate or project being reported on.

§subject_version: String

Version of the subject.

§started_at: DateTime<Utc>

When aggregation started.

§finished_at: Option<DateTime<Utc>>

When aggregation finished, if known.

§reports: Vec<Report>

Constituent reports.

Implementations§

Source §

impl MultiReport

Source

pub fn new( subject: impl Into<String>, subject_version: impl Into<String>, ) -> Self

Begin a new aggregate for the given subject and version.

Source

pub fn push(&mut self, r: Report)

Append a constituent report.

Source

pub fn finish(&mut self)

Mark aggregation finished, stamping the finish time.

Source

pub fn overall_verdict(&self) -> Verdict

Compute the overall verdict across every check in every report.

Follows the same precedence as Report::overall_verdict: Fail > Warn > Pass > Skip.

Source

pub fn total_check_count(&self) -> usize

Total number of checks across all constituent reports.

Source

pub fn iter_reports(&self) -> impl Iterator<Item = &Report>

Iterate over the constituent reports.

Equivalent to self.reports.iter() but reads cleaner at the call site and makes the public iteration API explicit.

§Example

use dev_report::{CheckResult, MultiReport, Report};

let mut bench = Report::new("c", "0.1.0").with_producer("dev-bench");
bench.push(CheckResult::pass("hot"));
let mut multi = MultiReport::new("c", "0.1.0");
multi.push(bench);

for r in multi.iter_reports() {
    assert_eq!(r.subject, "c");
}

Source

pub fn report_from(&self, producer: &str) -> Option<&Report>

Find the constituent report from a specific producer, if any.

Returns the first match (MultiReport doesn’t enforce uniqueness; producers can appear multiple times).

§Example

use dev_report::{CheckResult, MultiReport, Report};

let mut bench = Report::new("c", "0.1.0").with_producer("dev-bench");
bench.push(CheckResult::pass("hot"));
let mut multi = MultiReport::new("c", "0.1.0");
multi.push(bench);

let found = multi.report_from("dev-bench").unwrap();
assert_eq!(found.checks.len(), 1);

Source

pub fn verdict_counts(&self) -> (usize, usize, usize, usize)

Aggregate verdict counts across all constituent reports as (pass, fail, warn, skip).

§Example

use dev_report::{CheckResult, MultiReport, Report, Severity};

let mut a = Report::new("c", "0.1.0").with_producer("a");
a.push(CheckResult::pass("x"));
a.push(CheckResult::fail("y", Severity::Error));
let mut b = Report::new("c", "0.1.0").with_producer("b");
b.push(CheckResult::pass("z"));
let mut multi = MultiReport::new("c", "0.1.0");
multi.push(a);
multi.push(b);
assert_eq!(multi.verdict_counts(), (2, 1, 0, 0));

Source

pub fn iter_checks(&self) -> impl Iterator<Item = (Option<&str>, &CheckResult)>

Iterate over every check across every constituent report, paired with the producer that emitted it.

Producers without a producer field are emitted as None.

Source

pub fn checks_with_tag<'a>( &'a self, tag: &'a str, ) -> impl Iterator<Item = (Option<&'a str>, &'a CheckResult)>

Iterate over checks carrying the given tag, paired with their producer.

§Example

use dev_report::{CheckResult, MultiReport, Report};

let mut bench = Report::new("c", "0.1.0").with_producer("dev-bench");
bench.push(CheckResult::pass("hot").with_tag("slow"));
bench.push(CheckResult::pass("cold"));

let mut multi = MultiReport::new("c", "0.1.0");
multi.push(bench);

let slow: Vec<_> = multi.checks_with_tag("slow").collect();
assert_eq!(slow.len(), 1);
assert_eq!(slow[0].0, Some("dev-bench"));

Source

pub fn to_json(&self) -> Result<String>

Serialize this multi-report to JSON.

Source

pub fn from_json(s: &str) -> Result<Self>

Deserialize a multi-report from JSON.

Source

pub fn passed(&self) -> bool

true when overall_verdict is Pass.

Source

pub fn failed(&self) -> bool

true when overall_verdict is Fail.

Source

pub fn warned(&self) -> bool

true when overall_verdict is Warn.

Source

pub fn skipped(&self) -> bool

true when overall_verdict is Skip.

Source

pub fn checks_with_severity( &self, severity: Severity, ) -> impl Iterator<Item = (Option<&str>, &CheckResult)>

Iterate over checks with the given severity, paired with their producer.

§Example

use dev_report::{CheckResult, MultiReport, Report, Severity};

let mut bench = Report::new("c", "0.1.0").with_producer("dev-bench");
bench.push(CheckResult::fail("a", Severity::Error));

let mut multi = MultiReport::new("c", "0.1.0");
multi.push(bench);

let errors: Vec<_> = multi.checks_with_severity(Severity::Error).collect();
assert_eq!(errors.len(), 1);