moonpool-sim 0.7.0

Simulation engine for the moonpool framework
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
128
129
130
131
132
133

//! Integration tests for the `IterationControl::CoveragePlateau` stop condition.
//!
//! These exercise the runner's ability to terminate early when
//! `assert_sometimes!` / `assert_reachable!` coverage stops growing,
//! both with and without fork-based exploration enabled.

use async_trait::async_trait;
use moonpool_sim::{
    ExplorationConfig, SimContext, SimulationBuilder, SimulationReport, SimulationResult, Workload,
};

fn run_simulation(builder: SimulationBuilder) -> SimulationReport {
    builder.run()
}

/// Workload firing three sometimes assertions deterministically. The full
/// coverage surface is exhausted after the first seed.
struct ThreeAlwaysHitWorkload;

#[async_trait]
impl Workload for ThreeAlwaysHitWorkload {
    fn name(&self) -> &'static str {
        "client"
    }

    async fn run(&mut self, _ctx: &SimContext) -> SimulationResult<()> {
        moonpool_sim::assert_sometimes!(true, "gate 1");
        moonpool_sim::assert_sometimes!(true, "gate 2");
        moonpool_sim::assert_sometimes!(true, "gate 3");
        Ok(())
    }
}

/// Workload whose third assertion only fires in roughly 1-in-5 seeds.
/// `require_all_sometimes=true` should refuse to stop until it has hit.
struct RareGateWorkload;

#[async_trait]
impl Workload for RareGateWorkload {
    fn name(&self) -> &'static str {
        "client"
    }

    async fn run(&mut self, _ctx: &SimContext) -> SimulationResult<()> {
        moonpool_sim::assert_sometimes!(true, "gate 1");
        moonpool_sim::assert_sometimes!(true, "gate 2");
        let rare = moonpool_sim::sim_random_range(0u32..5) == 0;
        moonpool_sim::assert_sometimes!(rare, "rare gate");
        Ok(())
    }
}

/// With no exploration enabled, plateau detection should still fire because
/// the assertion table is initialised unconditionally.
#[test]
fn test_plateau_no_exploration() {
    let report = run_simulation(
        SimulationBuilder::new()
            .until_coverage_plateau(3, 100)
            .workload(ThreeAlwaysHitWorkload),
    );

    assert!(
        report.iterations < 100,
        "plateau should stop early; ran {} iterations",
        report.iterations
    );
    assert!(
        report.iterations >= 4,
        "need at least seed 1 + 3 plateau seeds; got {}",
        report.iterations
    );
    assert!(
        !report.convergence_timeout,
        "should not be marked as a convergence timeout"
    );
    assert_eq!(report.failed_runs, 0);
}

/// Same condition with exploration enabled — children write into the shared
/// assertion table, so the plateau accumulator sees the full coverage too.
#[test]
fn test_plateau_with_exploration() {
    let report = run_simulation(
        SimulationBuilder::new()
            .enable_exploration(ExplorationConfig {
                max_depth: 1,
                timelines_per_split: 2,
                global_energy: 20,
                adaptive: None,
                parallelism: None,
            })
            .until_coverage_plateau(3, 100)
            .workload(ThreeAlwaysHitWorkload),
    );

    assert!(
        report.iterations < 100,
        "plateau should stop early; ran {} iterations",
        report.iterations
    );
    assert!(
        !report.convergence_timeout,
        "should not be marked as a convergence timeout"
    );
    assert_eq!(report.failed_runs, 0);
}

/// With `require_all_sometimes=true`, the runner must keep going until the
/// rare gate has fired even if the other two assertions plateaued early.
#[test]
fn test_plateau_requires_all_sometimes() {
    let report = run_simulation(
        SimulationBuilder::new()
            .until_coverage_plateau_with(2, true, 200)
            .workload(RareGateWorkload),
    );

    assert!(
        !report.convergence_timeout,
        "rare gate should fire within 200 seeds; got convergence_timeout={}",
        report.convergence_timeout
    );

    let rare_hit = report
        .assertion_details
        .iter()
        .any(|d| d.msg == "rare gate" && d.pass_count > 0);
    assert!(
        rare_hit,
        "expected the rare gate to have fired before stopping"
    );
}