trellis-testing 0.1.1

Companion testing support for Trellis graph invariants.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

use core::fmt::Write;

use trellis_core::HostResourceOutcome;

use crate::{ResourceLedger, TraceRedactor};

impl<C> ResourceLedger<C> {
    /// Returns deterministic redacted debug output for resource ledger snapshots.
    pub fn to_redacted_debug_string(&self, redactor: &impl TraceRedactor) -> String {
        let mut out = String::new();
        writeln!(&mut out, "ResourceLedger").expect("writing to String cannot fail");

        writeln!(&mut out, "Live:").expect("writing to String cannot fail");
        for (key, snapshot) in &self.resources {
            writeln!(
                &mut out,
                "  key={:?} owners={:?} open={} close={} replace={} revision={:?} generation={}",
                redactor.resource_key(key),
                snapshot.owners,
                snapshot.open_count,
                snapshot.close_count,
                snapshot.replace_count,
                snapshot.command_revision,
                snapshot.generation
            )
            .expect("writing to String cannot fail");
        }

        writeln!(&mut out, "History:").expect("writing to String cannot fail");
        for (key, snapshot) in &self.history {
            writeln!(
                &mut out,
                "  key={:?} owners={:?} revision={:?} generation={}",
                redactor.resource_key(key),
                snapshot.owners,
                snapshot.command_revision,
                snapshot.generation
            )
            .expect("writing to String cannot fail");
        }

        writeln!(&mut out, "Commands:").expect("writing to String cannot fail");
        for command in &self.command_trace {
            writeln!(
                &mut out,
                "  key={:?} scope={:?} kind={:?} transition={:?}",
                redactor.resource_key(&command.key),
                command.scope,
                command.kind,
                command.transition
            )
            .expect("writing to String cannot fail");
        }

        writeln!(&mut out, "Status:").expect("writing to String cannot fail");
        for record in &self.status_records {
            writeln!(
                &mut out,
                "  class={:?} key={:?} scope={:?} command_revision={:?} status_revision={:?} outcome={}",
                record.class,
                redactor.resource_key(&record.status.resource_key),
                record.status.scope,
                record.status.command_revision,
                record.status.status_revision,
                status_kind(&record.status.status)
            )
            .expect("writing to String cannot fail");
        }

        out
    }
}

fn status_kind(status: &HostResourceOutcome) -> &'static str {
    match status {
        HostResourceOutcome::Unknown => "Unknown",
        HostResourceOutcome::Open => "Open",
        HostResourceOutcome::Failed(_) => "Failed",
        HostResourceOutcome::Closed => "Closed",
        HostResourceOutcome::Unsupported(_) => "Unsupported",
    }
}