Struct Diff 

pub struct Diff {
    pub newly_failing: Vec<String>,
    pub newly_passing: Vec<String>,
    pub severity_changes: Vec<SeverityChange>,
    pub duration_regressions: Vec<DurationRegression>,
    pub added: Vec<String>,
    pub removed: Vec<String>,
}

Result of comparing two Reports.

All vectors are sorted alphabetically by check name so two diffs of the same input pair produce equal Diff values.

Example

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

let mut prev = Report::new("crate", "0.1.0");
prev.push(CheckResult::pass("a"));
prev.push(CheckResult::pass("b"));

let mut curr = Report::new("crate", "0.1.0");
curr.push(CheckResult::pass("a"));
curr.push(CheckResult::fail("b", Severity::Error));
curr.push(CheckResult::pass("c"));

let diff = curr.diff(&prev);
assert_eq!(diff.newly_failing, vec!["b".to_string()]);
assert_eq!(diff.added, vec!["c".to_string()]);

Fields

newly_failing: Vec<String>

Checks that are Fail in current but were not Fail in baseline (or did not exist in baseline).

newly_passing: Vec<String>

Checks that are Pass in current but were not Pass in baseline.

severity_changes: Vec<SeverityChange>

Severity transitions for checks present in both reports.

duration_regressions: Vec<DurationRegression>

Duration regressions for checks present in both reports, where the slowdown exceeds the configured threshold.

added: Vec<String>

Checks present in current but not in baseline.

removed: Vec<String>

Checks present in baseline but not in current.

Implementations

impl Diff

pub fn is_clean(&self) -> bool

true if the diff contains no differences worth flagging.

Example

use dev_report::{CheckResult, Report};

let mut a = Report::new("c", "0.1.0");
a.push(CheckResult::pass("x"));
let b = a.clone();
assert!(a.diff(&b).is_clean());

Trait Implementations

impl Clone for Diff

fn clone(&self) -> Diff

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Diff

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Diff

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Diff

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

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 Diff