assay-sim 2.15.0

Simulation harness for Assay (internal, API unstable)
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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use anyhow::Result;
use assay_evidence::bundle::writer::{ErrorClass, ErrorCode};
use serde::Serialize;

#[derive(Debug, Serialize, Clone)]
pub struct SimReport {
    pub suite: String,
    pub seed: u64,
    pub summary: SimSummary,
    pub results: Vec<AttackResult>,
}

#[derive(Debug, Serialize, Clone, Default)]
pub struct SimSummary {
    pub total: usize,
    pub passed: usize,   // New: For invariants
    pub blocked: usize,  // For attacks
    pub bypassed: usize, // For attacks
    pub failed: usize,   // New: For invariants
    pub errors: usize,
}

#[derive(Debug, Serialize, Clone)]
pub struct AttackResult {
    pub name: String,
    pub status: AttackStatus,
    pub error_class: Option<String>,
    pub error_code: Option<String>,
    pub message: Option<String>,
    pub duration_ms: u64, // New: DX requirement
}

#[derive(Debug, Serialize, Clone, PartialEq, Eq)]
pub enum AttackStatus {
    Passed,   // New: Invariant held
    Failed,   // New: Invariant broken
    Blocked,  // Attack was stopped
    Bypassed, // Attack succeeded
    Error,    // Infrastructure error
}

impl SimReport {
    pub fn new(suite: &str, seed: u64) -> Self {
        Self {
            suite: suite.to_string(),
            seed,
            summary: SimSummary::default(),
            results: Vec::new(),
        }
    }

    pub fn add_attack(
        &mut self,
        name: &str,
        result: Result<(ErrorClass, ErrorCode), anyhow::Error>,
        duration_ms: u64,
    ) {
        self.summary.total += 1;
        let res = match result {
            Ok((class, code)) => {
                self.summary.blocked += 1;
                AttackResult {
                    name: name.to_string(),
                    status: AttackStatus::Blocked,
                    error_class: Some(format!("{:?}", class)),
                    error_code: Some(format!("{:?}", code)),
                    message: None,
                    duration_ms,
                }
            }
            Err(e) => {
                self.summary.bypassed += 1;
                AttackResult {
                    name: name.to_string(),
                    status: AttackStatus::Bypassed,
                    error_class: None,
                    error_code: None,
                    message: Some(e.to_string()),
                    duration_ms,
                }
            }
        };
        self.results.push(res);
    }

    /// Add a pre-built AttackResult directly.
    pub fn add_result(&mut self, result: AttackResult) {
        self.summary.total += 1;
        match result.status {
            AttackStatus::Passed => self.summary.passed += 1,
            AttackStatus::Failed => self.summary.failed += 1,
            AttackStatus::Blocked => self.summary.blocked += 1,
            AttackStatus::Bypassed => self.summary.bypassed += 1,
            AttackStatus::Error => self.summary.errors += 1,
        }
        self.results.push(result);
    }

    pub fn add_check(&mut self, name: &str, result: Result<()>, duration_ms: u64) {
        self.summary.total += 1;
        let res = match result {
            Ok(_) => {
                self.summary.passed += 1;
                AttackResult {
                    name: name.to_string(),
                    status: AttackStatus::Passed,
                    error_class: None,
                    error_code: None,
                    message: None,
                    duration_ms,
                }
            }
            Err(e) => {
                self.summary.failed += 1;
                AttackResult {
                    name: name.to_string(),
                    status: AttackStatus::Failed,
                    error_class: None,
                    error_code: None,
                    message: Some(e.to_string()),
                    duration_ms,
                }
            }
        };
        self.results.push(res);
    }
}