Struct Report 

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

A full report. The output of one verification run.

Example

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

let mut r = Report::new("my-crate", "0.1.0").with_producer("my-harness");
r.push(CheckResult::pass("compile"));
r.finish();
assert_eq!(r.overall_verdict(), Verdict::Pass);

Fields

schema_version: u32

Schema version for this report format.

subject: String

Crate or project being reported on.

subject_version: String

Version of the subject at the time of the run.

producer: Option<String>

Producer of the report (e.g. dev-bench, dev-async).

started_at: DateTime<Utc>

Time the report was started.

finished_at: Option<DateTime<Utc>>

Time the report was finalized.

checks: Vec<CheckResult>

All individual check results in this report.

Implementations

impl Report

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

Begin a new report for the given subject and version.

Example

use dev_report::Report;

let r = Report::new("my-crate", "0.1.0");
assert_eq!(r.subject, "my-crate");
assert_eq!(r.schema_version, 1);

Examples found in repository

examples/sarif_export.rs (line 16)

fn main() {
    let mut r = Report::new("sample-subject", "0.9.3").with_producer("dev-bench");

    r.push(CheckResult::pass("compile"));
    r.push(CheckResult::skip("network"));

    r.push(
        CheckResult::fail("test::round_trip", Severity::Error)
            .with_detail("expected 42, got 41")
            .with_evidence(Evidence::file_ref_lines("site", "src/math.rs", 10, 12)),
    );

    r.push(
        CheckResult::fail("integration::startup", Severity::Critical)
            .with_detail("service refused to start")
            .with_evidence(Evidence::file_ref("source", "src/bin/server.rs")),
    );

    r.push(
        CheckResult::warn("style::trailing_ws", Severity::Warning)
            .with_detail("3 trailing-whitespace warnings"),
    );

    r.finish();

    println!("{}", r.to_sarif());
}

examples/junit_export.rs (line 17)

fn main() {
    let mut r = Report::new("sample-subject", "0.9.3").with_producer("dev-bench");

    r.push(CheckResult::pass("compile").with_duration_ms(120));
    r.push(CheckResult::pass("test::math").with_duration_ms(7));

    r.push(
        CheckResult::fail("test::round_trip", Severity::Error)
            .with_duration_ms(13)
            .with_detail("expected 42, got 41"),
    );

    r.push(
        CheckResult::fail("integration::startup", Severity::Critical)
            .with_detail("service refused to start"),
    );

    r.push(
        CheckResult::warn("style::trailing_ws", Severity::Warning)
            .with_detail("3 trailing-whitespace warnings"),
    );

    r.push(CheckResult::skip("integration::network").with_detail("no network in sandbox"));

    r.finish();

    println!("{}", r.to_junit_xml());
}

examples/schema_sample.rs (line 25)

fn build_report(producer: &str) -> Report {
    let frozen_start = chrono::Utc.with_ymd_and_hms(2026, 5, 11, 12, 0, 0).unwrap();
    let frozen_end = chrono::Utc.with_ymd_and_hms(2026, 5, 11, 12, 0, 5).unwrap();

    let mut r = Report::new("sample-subject", "0.9.3").with_producer(producer);
    r.set_started_at(frozen_start);

    // Pass with no detail, no severity, no tags, no evidence.
    let mut c1 = CheckResult::pass("compile");
    c1.at = frozen_start;
    r.push(c1);

    // Pass with a duration and a single numeric evidence.
    let mut c2 = CheckResult::pass("bench::parse")
        .with_duration_ms(7)
        .with_tag("bench")
        .with_evidence(Evidence::numeric("mean_ns", 1234.5))
        .with_evidence(Evidence::numeric_int("iterations", 1_000_000));
    c2.at = frozen_start;
    r.push(c2);

    // Warn with key-value evidence.
    let mut c3 = CheckResult::warn("env::leaked", Severity::Warning)
        .with_detail("RUST_LOG was set during test")
        .with_evidence(Evidence::kv("env", [("CI", "true"), ("RUST_LOG", "debug")]));
    c3.at = frozen_start;
    r.push(c3);

    // Fail with snippet + file_ref (no line range) + file_ref (with line range).
    let mut c4 = CheckResult::fail("test::round_trip", Severity::Error)
        .with_detail("expected 42, got 41")
        .with_duration_ms(13)
        .with_tags(["unit", "flaky"])
        .with_evidence(Evidence::snippet(
            "panic",
            "assertion `left == right` failed",
        ))
        .with_evidence(Evidence::file_ref("source", "src/math.rs"))
        .with_evidence(Evidence::file_ref_lines(
            "call_site",
            "tests/smoke.rs",
            42,
            47,
        ));
    c4.at = frozen_start;
    r.push(c4);

    // Fail with Critical severity.
    let mut c5 = CheckResult::fail("integration::startup", Severity::Critical)
        .with_detail("service refused to start");
    c5.at = frozen_start;
    r.push(c5);

    // Warn with Info severity (lowest severity, still warn verdict).
    let mut c6 = CheckResult::warn("style::trailing_ws", Severity::Info)
        .with_detail("3 trailing-whitespace warnings");
    c6.at = frozen_start;
    r.push(c6);

    // Skip with no severity.
    let mut c7 = CheckResult::skip("integration::network").with_detail("no network in sandbox");
    c7.at = frozen_start;
    r.push(c7);

    // Manually-constructed FileRef via Evidence::file_ref (covered above);
    // also exercise a standalone FileRef with line_start but no line_end —
    // valid per the schema (both are optional independently).
    let mut c8 = CheckResult::pass("doc::link_check");
    c8.at = frozen_start;
    let standalone = FileRef::new("docs/index.md").with_line_range(10, 10);
    c8 = c8.with_evidence(Evidence {
        label: "anchor".into(),
        data: dev_report::EvidenceData::FileRef(standalone),
    });
    r.push(c8);

    r.set_finished_at(Some(frozen_end));
    r
}

pub fn with_producer(self, producer: impl Into<String>) -> Self

Set the producer of this report.

Example

use dev_report::Report;

let r = Report::new("crate", "0.1.0").with_producer("dev-bench");
assert_eq!(r.producer.as_deref(), Some("dev-bench"));

Examples found in repository

examples/sarif_export.rs (line 16)

fn main() {
    let mut r = Report::new("sample-subject", "0.9.3").with_producer("dev-bench");

    r.push(CheckResult::pass("compile"));
    r.push(CheckResult::skip("network"));

    r.push(
        CheckResult::fail("test::round_trip", Severity::Error)
            .with_detail("expected 42, got 41")
            .with_evidence(Evidence::file_ref_lines("site", "src/math.rs", 10, 12)),
    );

    r.push(
        CheckResult::fail("integration::startup", Severity::Critical)
            .with_detail("service refused to start")
            .with_evidence(Evidence::file_ref("source", "src/bin/server.rs")),
    );

    r.push(
        CheckResult::warn("style::trailing_ws", Severity::Warning)
            .with_detail("3 trailing-whitespace warnings"),
    );

    r.finish();

    println!("{}", r.to_sarif());
}

examples/junit_export.rs (line 17)

fn main() {
    let mut r = Report::new("sample-subject", "0.9.3").with_producer("dev-bench");

    r.push(CheckResult::pass("compile").with_duration_ms(120));
    r.push(CheckResult::pass("test::math").with_duration_ms(7));

    r.push(
        CheckResult::fail("test::round_trip", Severity::Error)
            .with_duration_ms(13)
            .with_detail("expected 42, got 41"),
    );

    r.push(
        CheckResult::fail("integration::startup", Severity::Critical)
            .with_detail("service refused to start"),
    );

    r.push(
        CheckResult::warn("style::trailing_ws", Severity::Warning)
            .with_detail("3 trailing-whitespace warnings"),
    );

    r.push(CheckResult::skip("integration::network").with_detail("no network in sandbox"));

    r.finish();

    println!("{}", r.to_junit_xml());
}

examples/schema_sample.rs (line 25)

fn build_report(producer: &str) -> Report {
    let frozen_start = chrono::Utc.with_ymd_and_hms(2026, 5, 11, 12, 0, 0).unwrap();
    let frozen_end = chrono::Utc.with_ymd_and_hms(2026, 5, 11, 12, 0, 5).unwrap();

    let mut r = Report::new("sample-subject", "0.9.3").with_producer(producer);
    r.set_started_at(frozen_start);

    // Pass with no detail, no severity, no tags, no evidence.
    let mut c1 = CheckResult::pass("compile");
    c1.at = frozen_start;
    r.push(c1);

    // Pass with a duration and a single numeric evidence.
    let mut c2 = CheckResult::pass("bench::parse")
        .with_duration_ms(7)
        .with_tag("bench")
        .with_evidence(Evidence::numeric("mean_ns", 1234.5))
        .with_evidence(Evidence::numeric_int("iterations", 1_000_000));
    c2.at = frozen_start;
    r.push(c2);

    // Warn with key-value evidence.
    let mut c3 = CheckResult::warn("env::leaked", Severity::Warning)
        .with_detail("RUST_LOG was set during test")
        .with_evidence(Evidence::kv("env", [("CI", "true"), ("RUST_LOG", "debug")]));
    c3.at = frozen_start;
    r.push(c3);

    // Fail with snippet + file_ref (no line range) + file_ref (with line range).
    let mut c4 = CheckResult::fail("test::round_trip", Severity::Error)
        .with_detail("expected 42, got 41")
        .with_duration_ms(13)
        .with_tags(["unit", "flaky"])
        .with_evidence(Evidence::snippet(
            "panic",
            "assertion `left == right` failed",
        ))
        .with_evidence(Evidence::file_ref("source", "src/math.rs"))
        .with_evidence(Evidence::file_ref_lines(
            "call_site",
            "tests/smoke.rs",
            42,
            47,
        ));
    c4.at = frozen_start;
    r.push(c4);

    // Fail with Critical severity.
    let mut c5 = CheckResult::fail("integration::startup", Severity::Critical)
        .with_detail("service refused to start");
    c5.at = frozen_start;
    r.push(c5);

    // Warn with Info severity (lowest severity, still warn verdict).
    let mut c6 = CheckResult::warn("style::trailing_ws", Severity::Info)
        .with_detail("3 trailing-whitespace warnings");
    c6.at = frozen_start;
    r.push(c6);

    // Skip with no severity.
    let mut c7 = CheckResult::skip("integration::network").with_detail("no network in sandbox");
    c7.at = frozen_start;
    r.push(c7);

    // Manually-constructed FileRef via Evidence::file_ref (covered above);
    // also exercise a standalone FileRef with line_start but no line_end —
    // valid per the schema (both are optional independently).
    let mut c8 = CheckResult::pass("doc::link_check");
    c8.at = frozen_start;
    let standalone = FileRef::new("docs/index.md").with_line_range(10, 10);
    c8 = c8.with_evidence(Evidence {
        label: "anchor".into(),
        data: dev_report::EvidenceData::FileRef(standalone),
    });
    r.push(c8);

    r.set_finished_at(Some(frozen_end));
    r
}

pub fn push(&mut self, result: CheckResult)

Append a check result to this report.

Example

use dev_report::{CheckResult, Report};

let mut r = Report::new("crate", "0.1.0");
r.push(CheckResult::pass("compile"));
assert_eq!(r.checks.len(), 1);

Examples found in repository

examples/sarif_export.rs (line 18)

fn main() {
    let mut r = Report::new("sample-subject", "0.9.3").with_producer("dev-bench");

    r.push(CheckResult::pass("compile"));
    r.push(CheckResult::skip("network"));

    r.push(
        CheckResult::fail("test::round_trip", Severity::Error)
            .with_detail("expected 42, got 41")
            .with_evidence(Evidence::file_ref_lines("site", "src/math.rs", 10, 12)),
    );

    r.push(
        CheckResult::fail("integration::startup", Severity::Critical)
            .with_detail("service refused to start")
            .with_evidence(Evidence::file_ref("source", "src/bin/server.rs")),
    );

    r.push(
        CheckResult::warn("style::trailing_ws", Severity::Warning)
            .with_detail("3 trailing-whitespace warnings"),
    );

    r.finish();

    println!("{}", r.to_sarif());
}

examples/junit_export.rs (line 19)

fn main() {
    let mut r = Report::new("sample-subject", "0.9.3").with_producer("dev-bench");

    r.push(CheckResult::pass("compile").with_duration_ms(120));
    r.push(CheckResult::pass("test::math").with_duration_ms(7));

    r.push(
        CheckResult::fail("test::round_trip", Severity::Error)
            .with_duration_ms(13)
            .with_detail("expected 42, got 41"),
    );

    r.push(
        CheckResult::fail("integration::startup", Severity::Critical)
            .with_detail("service refused to start"),
    );

    r.push(
        CheckResult::warn("style::trailing_ws", Severity::Warning)
            .with_detail("3 trailing-whitespace warnings"),
    );

    r.push(CheckResult::skip("integration::network").with_detail("no network in sandbox"));

    r.finish();

    println!("{}", r.to_junit_xml());
}

examples/schema_sample.rs (line 31)

fn build_report(producer: &str) -> Report {
    let frozen_start = chrono::Utc.with_ymd_and_hms(2026, 5, 11, 12, 0, 0).unwrap();
    let frozen_end = chrono::Utc.with_ymd_and_hms(2026, 5, 11, 12, 0, 5).unwrap();

    let mut r = Report::new("sample-subject", "0.9.3").with_producer(producer);
    r.set_started_at(frozen_start);

    // Pass with no detail, no severity, no tags, no evidence.
    let mut c1 = CheckResult::pass("compile");
    c1.at = frozen_start;
    r.push(c1);

    // Pass with a duration and a single numeric evidence.
    let mut c2 = CheckResult::pass("bench::parse")
        .with_duration_ms(7)
        .with_tag("bench")
        .with_evidence(Evidence::numeric("mean_ns", 1234.5))
        .with_evidence(Evidence::numeric_int("iterations", 1_000_000));
    c2.at = frozen_start;
    r.push(c2);

    // Warn with key-value evidence.
    let mut c3 = CheckResult::warn("env::leaked", Severity::Warning)
        .with_detail("RUST_LOG was set during test")
        .with_evidence(Evidence::kv("env", [("CI", "true"), ("RUST_LOG", "debug")]));
    c3.at = frozen_start;
    r.push(c3);

    // Fail with snippet + file_ref (no line range) + file_ref (with line range).
    let mut c4 = CheckResult::fail("test::round_trip", Severity::Error)
        .with_detail("expected 42, got 41")
        .with_duration_ms(13)
        .with_tags(["unit", "flaky"])
        .with_evidence(Evidence::snippet(
            "panic",
            "assertion `left == right` failed",
        ))
        .with_evidence(Evidence::file_ref("source", "src/math.rs"))
        .with_evidence(Evidence::file_ref_lines(
            "call_site",
            "tests/smoke.rs",
            42,
            47,
        ));
    c4.at = frozen_start;
    r.push(c4);

    // Fail with Critical severity.
    let mut c5 = CheckResult::fail("integration::startup", Severity::Critical)
        .with_detail("service refused to start");
    c5.at = frozen_start;
    r.push(c5);

    // Warn with Info severity (lowest severity, still warn verdict).
    let mut c6 = CheckResult::warn("style::trailing_ws", Severity::Info)
        .with_detail("3 trailing-whitespace warnings");
    c6.at = frozen_start;
    r.push(c6);

    // Skip with no severity.
    let mut c7 = CheckResult::skip("integration::network").with_detail("no network in sandbox");
    c7.at = frozen_start;
    r.push(c7);

    // Manually-constructed FileRef via Evidence::file_ref (covered above);
    // also exercise a standalone FileRef with line_start but no line_end —
    // valid per the schema (both are optional independently).
    let mut c8 = CheckResult::pass("doc::link_check");
    c8.at = frozen_start;
    let standalone = FileRef::new("docs/index.md").with_line_range(10, 10);
    c8 = c8.with_evidence(Evidence {
        label: "anchor".into(),
        data: dev_report::EvidenceData::FileRef(standalone),
    });
    r.push(c8);

    r.set_finished_at(Some(frozen_end));
    r
}

pub fn finish(&mut self)

Mark the report as finished, stamping the finish time.

Example

use dev_report::Report;

let mut r = Report::new("crate", "0.1.0");
r.finish();
assert!(r.finished_at.is_some());

Examples found in repository

examples/sarif_export.rs (line 38)

fn main() {
    let mut r = Report::new("sample-subject", "0.9.3").with_producer("dev-bench");

    r.push(CheckResult::pass("compile"));
    r.push(CheckResult::skip("network"));

    r.push(
        CheckResult::fail("test::round_trip", Severity::Error)
            .with_detail("expected 42, got 41")
            .with_evidence(Evidence::file_ref_lines("site", "src/math.rs", 10, 12)),
    );

    r.push(
        CheckResult::fail("integration::startup", Severity::Critical)
            .with_detail("service refused to start")
            .with_evidence(Evidence::file_ref("source", "src/bin/server.rs")),
    );

    r.push(
        CheckResult::warn("style::trailing_ws", Severity::Warning)
            .with_detail("3 trailing-whitespace warnings"),
    );

    r.finish();

    println!("{}", r.to_sarif());
}

examples/junit_export.rs (line 40)

fn main() {
    let mut r = Report::new("sample-subject", "0.9.3").with_producer("dev-bench");

    r.push(CheckResult::pass("compile").with_duration_ms(120));
    r.push(CheckResult::pass("test::math").with_duration_ms(7));

    r.push(
        CheckResult::fail("test::round_trip", Severity::Error)
            .with_duration_ms(13)
            .with_detail("expected 42, got 41"),
    );

    r.push(
        CheckResult::fail("integration::startup", Severity::Critical)
            .with_detail("service refused to start"),
    );

    r.push(
        CheckResult::warn("style::trailing_ws", Severity::Warning)
            .with_detail("3 trailing-whitespace warnings"),
    );

    r.push(CheckResult::skip("integration::network").with_detail("no network in sandbox"));

    r.finish();

    println!("{}", r.to_junit_xml());
}

pub fn set_started_at(&mut self, ts: DateTime<Utc>)

Override started_at with a fixed timestamp.

Useful when reconstructing a Report from external data (replay, import from a different schema, deterministic test fixtures). Most producers should let Report::new capture the real start time and not call this.

Example

use chrono::TimeZone;
use dev_report::Report;

let mut r = Report::new("crate", "0.1.0");
let frozen = chrono::Utc.with_ymd_and_hms(2026, 1, 1, 0, 0, 0).unwrap();
r.set_started_at(frozen);
assert_eq!(r.started_at, frozen);

Examples found in repository

examples/schema_sample.rs (line 26)

fn build_report(producer: &str) -> Report {
    let frozen_start = chrono::Utc.with_ymd_and_hms(2026, 5, 11, 12, 0, 0).unwrap();
    let frozen_end = chrono::Utc.with_ymd_and_hms(2026, 5, 11, 12, 0, 5).unwrap();

    let mut r = Report::new("sample-subject", "0.9.3").with_producer(producer);
    r.set_started_at(frozen_start);

    // Pass with no detail, no severity, no tags, no evidence.
    let mut c1 = CheckResult::pass("compile");
    c1.at = frozen_start;
    r.push(c1);

    // Pass with a duration and a single numeric evidence.
    let mut c2 = CheckResult::pass("bench::parse")
        .with_duration_ms(7)
        .with_tag("bench")
        .with_evidence(Evidence::numeric("mean_ns", 1234.5))
        .with_evidence(Evidence::numeric_int("iterations", 1_000_000));
    c2.at = frozen_start;
    r.push(c2);

    // Warn with key-value evidence.
    let mut c3 = CheckResult::warn("env::leaked", Severity::Warning)
        .with_detail("RUST_LOG was set during test")
        .with_evidence(Evidence::kv("env", [("CI", "true"), ("RUST_LOG", "debug")]));
    c3.at = frozen_start;
    r.push(c3);

    // Fail with snippet + file_ref (no line range) + file_ref (with line range).
    let mut c4 = CheckResult::fail("test::round_trip", Severity::Error)
        .with_detail("expected 42, got 41")
        .with_duration_ms(13)
        .with_tags(["unit", "flaky"])
        .with_evidence(Evidence::snippet(
            "panic",
            "assertion `left == right` failed",
        ))
        .with_evidence(Evidence::file_ref("source", "src/math.rs"))
        .with_evidence(Evidence::file_ref_lines(
            "call_site",
            "tests/smoke.rs",
            42,
            47,
        ));
    c4.at = frozen_start;
    r.push(c4);

    // Fail with Critical severity.
    let mut c5 = CheckResult::fail("integration::startup", Severity::Critical)
        .with_detail("service refused to start");
    c5.at = frozen_start;
    r.push(c5);

    // Warn with Info severity (lowest severity, still warn verdict).
    let mut c6 = CheckResult::warn("style::trailing_ws", Severity::Info)
        .with_detail("3 trailing-whitespace warnings");
    c6.at = frozen_start;
    r.push(c6);

    // Skip with no severity.
    let mut c7 = CheckResult::skip("integration::network").with_detail("no network in sandbox");
    c7.at = frozen_start;
    r.push(c7);

    // Manually-constructed FileRef via Evidence::file_ref (covered above);
    // also exercise a standalone FileRef with line_start but no line_end —
    // valid per the schema (both are optional independently).
    let mut c8 = CheckResult::pass("doc::link_check");
    c8.at = frozen_start;
    let standalone = FileRef::new("docs/index.md").with_line_range(10, 10);
    c8 = c8.with_evidence(Evidence {
        label: "anchor".into(),
        data: dev_report::EvidenceData::FileRef(standalone),
    });
    r.push(c8);

    r.set_finished_at(Some(frozen_end));
    r
}

pub fn set_finished_at(&mut self, ts: Option<DateTime<Utc>>)

Override finished_at with a fixed timestamp.

Useful for replay / import scenarios where the real finish time is known but Utc::now() would be wrong.

Example

use chrono::TimeZone;
use dev_report::Report;

let mut r = Report::new("crate", "0.1.0");
let frozen = chrono::Utc.with_ymd_and_hms(2026, 1, 1, 0, 0, 1).unwrap();
r.set_finished_at(Some(frozen));
assert_eq!(r.finished_at, Some(frozen));

Examples found in repository

examples/schema_sample.rs (line 97)

fn build_report(producer: &str) -> Report {
    let frozen_start = chrono::Utc.with_ymd_and_hms(2026, 5, 11, 12, 0, 0).unwrap();
    let frozen_end = chrono::Utc.with_ymd_and_hms(2026, 5, 11, 12, 0, 5).unwrap();

    let mut r = Report::new("sample-subject", "0.9.3").with_producer(producer);
    r.set_started_at(frozen_start);

    // Pass with no detail, no severity, no tags, no evidence.
    let mut c1 = CheckResult::pass("compile");
    c1.at = frozen_start;
    r.push(c1);

    // Pass with a duration and a single numeric evidence.
    let mut c2 = CheckResult::pass("bench::parse")
        .with_duration_ms(7)
        .with_tag("bench")
        .with_evidence(Evidence::numeric("mean_ns", 1234.5))
        .with_evidence(Evidence::numeric_int("iterations", 1_000_000));
    c2.at = frozen_start;
    r.push(c2);

    // Warn with key-value evidence.
    let mut c3 = CheckResult::warn("env::leaked", Severity::Warning)
        .with_detail("RUST_LOG was set during test")
        .with_evidence(Evidence::kv("env", [("CI", "true"), ("RUST_LOG", "debug")]));
    c3.at = frozen_start;
    r.push(c3);

    // Fail with snippet + file_ref (no line range) + file_ref (with line range).
    let mut c4 = CheckResult::fail("test::round_trip", Severity::Error)
        .with_detail("expected 42, got 41")
        .with_duration_ms(13)
        .with_tags(["unit", "flaky"])
        .with_evidence(Evidence::snippet(
            "panic",
            "assertion `left == right` failed",
        ))
        .with_evidence(Evidence::file_ref("source", "src/math.rs"))
        .with_evidence(Evidence::file_ref_lines(
            "call_site",
            "tests/smoke.rs",
            42,
            47,
        ));
    c4.at = frozen_start;
    r.push(c4);

    // Fail with Critical severity.
    let mut c5 = CheckResult::fail("integration::startup", Severity::Critical)
        .with_detail("service refused to start");
    c5.at = frozen_start;
    r.push(c5);

    // Warn with Info severity (lowest severity, still warn verdict).
    let mut c6 = CheckResult::warn("style::trailing_ws", Severity::Info)
        .with_detail("3 trailing-whitespace warnings");
    c6.at = frozen_start;
    r.push(c6);

    // Skip with no severity.
    let mut c7 = CheckResult::skip("integration::network").with_detail("no network in sandbox");
    c7.at = frozen_start;
    r.push(c7);

    // Manually-constructed FileRef via Evidence::file_ref (covered above);
    // also exercise a standalone FileRef with line_start but no line_end —
    // valid per the schema (both are optional independently).
    let mut c8 = CheckResult::pass("doc::link_check");
    c8.at = frozen_start;
    let standalone = FileRef::new("docs/index.md").with_line_range(10, 10);
    c8 = c8.with_evidence(Evidence {
        label: "anchor".into(),
        data: dev_report::EvidenceData::FileRef(standalone),
    });
    r.push(c8);

    r.set_finished_at(Some(frozen_end));
    r
}

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

Count of checks per verdict, returned as (pass, fail, warn, skip).

Example

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

let mut r = Report::new("c", "0.1.0");
r.push(CheckResult::pass("a"));
r.push(CheckResult::pass("b"));
r.push(CheckResult::fail("c", Severity::Error));
let (pass, fail, warn, skip) = r.verdict_counts();
assert_eq!((pass, fail, warn, skip), (2, 1, 0, 0));

pub fn overall_verdict(&self) -> Verdict

Compute the overall verdict for this report.

Rules:

• Any Fail -> Fail
• Else any Warn -> Warn
• Else any Pass -> Pass
• Else (all Skip or empty) -> Skip

Example

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

let mut r = Report::new("crate", "0.1.0");
r.push(CheckResult::pass("a"));
r.push(CheckResult::fail("b", Severity::Error));
assert_eq!(r.overall_verdict(), Verdict::Fail);

pub fn passed(&self) -> bool

true when overall_verdict is Pass.

Example

use dev_report::{CheckResult, Report};

let mut r = Report::new("c", "0.1.0");
r.push(CheckResult::pass("ok"));
assert!(r.passed());

pub fn failed(&self) -> bool

true when overall_verdict is Fail.

Example

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

let mut r = Report::new("c", "0.1.0");
r.push(CheckResult::fail("oops", Severity::Error));
assert!(r.failed());

pub fn warned(&self) -> bool

true when overall_verdict is Warn.

pub fn skipped(&self) -> bool

true when overall_verdict is Skip (all checks were skipped, or there were no checks).

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

Iterate over checks whose severity matches the given level.

Pass and Skip checks have severity = None and never match.

Example

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

let mut r = Report::new("c", "0.1.0");
r.push(CheckResult::fail("a", Severity::Error));
r.push(CheckResult::warn("b", Severity::Warning));
r.push(CheckResult::fail("c", Severity::Error));

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

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

Iterate over checks that carry the given tag.

Example

use dev_report::{CheckResult, Report};

let mut r = Report::new("crate", "0.1.0");
r.push(CheckResult::pass("a").with_tag("slow"));
r.push(CheckResult::pass("b"));
r.push(CheckResult::pass("c").with_tag("slow"));

let slow: Vec<_> = r.checks_with_tag("slow").collect();
assert_eq!(slow.len(), 2);

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

Serialize this report to JSON.

Example

use dev_report::Report;

let r = Report::new("crate", "0.1.0");
let json = r.to_json().unwrap();
assert!(json.contains("\"subject\": \"crate\""));

Examples found in repository

examples/schema_sample.rs (line 121)

fn main() {
    let arg = std::env::args()
        .nth(1)
        .unwrap_or_else(|| "report".to_string());
    let json = match arg.as_str() {
        "multi" => build_multi().to_json().expect("serialize MultiReport"),
        _ => build_report("dev-bench")
            .to_json()
            .expect("serialize Report"),
    };
    println!("{}", json);
}

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

Deserialize a report from JSON.

Example

use dev_report::Report;

let r = Report::new("crate", "0.1.0");
let json = r.to_json().unwrap();
let parsed = Report::from_json(&json).unwrap();
assert_eq!(parsed.subject, "crate");

pub fn to_terminal(&self) -> String

Available on crate feature terminal only.

Render this report to a TTY-friendly string. Monochrome.

Available with the terminal feature.

pub fn to_terminal_color(&self) -> String

Available on crate feature terminal only.

Render this report with ANSI color codes.

Available with the terminal feature.

pub fn to_markdown(&self) -> String

Available on crate feature markdown only.

Render this report to a Markdown string.

Available with the markdown feature.

pub fn to_sarif(&self) -> String

Available on crate feature sarif only.

Render this report as a SARIF 2.1.0 document.

Only Fail and Warn checks are emitted; Pass and Skip are omitted (SARIF is a defect report format). See crate::sarif for the severity-to-level mapping.

Available with the sarif feature.

Examples found in repository

examples/sarif_export.rs (line 40)

fn main() {
    let mut r = Report::new("sample-subject", "0.9.3").with_producer("dev-bench");

    r.push(CheckResult::pass("compile"));
    r.push(CheckResult::skip("network"));

    r.push(
        CheckResult::fail("test::round_trip", Severity::Error)
            .with_detail("expected 42, got 41")
            .with_evidence(Evidence::file_ref_lines("site", "src/math.rs", 10, 12)),
    );

    r.push(
        CheckResult::fail("integration::startup", Severity::Critical)
            .with_detail("service refused to start")
            .with_evidence(Evidence::file_ref("source", "src/bin/server.rs")),
    );

    r.push(
        CheckResult::warn("style::trailing_ws", Severity::Warning)
            .with_detail("3 trailing-whitespace warnings"),
    );

    r.finish();

    println!("{}", r.to_sarif());
}

pub fn to_junit_xml(&self) -> String

Available on crate feature junit only.

Render this report as a JUnit XML document.

Every check becomes a <testcase>; fail verdicts emit a <failure> child, skip verdicts emit a <skipped/> child. See crate::junit for the verdict-to-element mapping.

Available with the junit feature.

Examples found in repository

examples/junit_export.rs (line 42)

fn main() {
    let mut r = Report::new("sample-subject", "0.9.3").with_producer("dev-bench");

    r.push(CheckResult::pass("compile").with_duration_ms(120));
    r.push(CheckResult::pass("test::math").with_duration_ms(7));

    r.push(
        CheckResult::fail("test::round_trip", Severity::Error)
            .with_duration_ms(13)
            .with_detail("expected 42, got 41"),
    );

    r.push(
        CheckResult::fail("integration::startup", Severity::Critical)
            .with_detail("service refused to start"),
    );

    r.push(
        CheckResult::warn("style::trailing_ws", Severity::Warning)
            .with_detail("3 trailing-whitespace warnings"),
    );

    r.push(CheckResult::skip("integration::network").with_detail("no network in sandbox"));

    r.finish();

    println!("{}", r.to_junit_xml());
}

pub fn diff(&self, baseline: &Self) -> Diff

Compare this report against a baseline using default options.

self is the new report; baseline is the previous one. Default options flag duration regressions over 20% slower.

Example

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

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

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

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

pub fn diff_with(&self, baseline: &Self, opts: &DiffOptions) -> Diff

Compare this report against a baseline using custom options.

Example

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

let mut prev = Report::new("c", "0.1.0");
prev.push(CheckResult::pass("a").with_duration_ms(100));

let mut curr = Report::new("c", "0.1.0");
curr.push(CheckResult::pass("a").with_duration_ms(150));

let opts = DiffOptions {
    duration_regression_pct: Some(10.0),
    duration_regression_abs_ms: None,
};
let diff = curr.diff_with(&prev, &opts);
assert_eq!(diff.duration_regressions.len(), 1);

Trait Implementations

impl Clone for Report

fn clone(&self) -> Report

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Report

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Report

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Report

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

where __S: Serializer,

Serialize this value into the given Serde serializer.