kshana 0.24.0

Open, reproducible PNT-resilience simulator with quantum-sensor performance models
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

//! `ExternalPack::register_into` seam: an out-of-tree pack registers its own
//! factory into a fresh `PackRegistry` and is then buildable by id, without
//! touching core's built-in table.

use kshana::api::{ExternalPack, KshanaError, RunOutput, Scenario, ScenarioMeta};
use kshana::registry::{PackRegistry, ScenarioFactory, ScenarioId};

/// A minimal third-party scenario that lives entirely in this test.
struct DemoPack {
    src: String,
}

const DEMO_ID: &str = "demo-external-pack";

impl Scenario for DemoPack {
    fn run(&self) -> Result<RunOutput, KshanaError> {
        Ok(RunOutput {
            json: format!("{{\"src_len\":{}}}", self.src.len()),
            svg: String::new(),
            summary: format!("demo pack ran on {} bytes", self.src.len()),
        })
    }
}

impl ExternalPack for DemoPack {
    fn kind_name(&self) -> &'static str {
        DEMO_ID
    }

    fn meta(&self) -> ScenarioMeta {
        ScenarioMeta {
            name: DEMO_ID,
            description: "in-test external pack exercising the register_into seam",
            required_fields: &[],
            optional_fields: &[],
        }
    }

    fn register_into(reg: &mut PackRegistry) {
        reg.register(Box::new(DemoFactory {
            id: ScenarioId::from_static(DEMO_ID),
        }));
    }
}

/// The factory the pack installs into a registry.
struct DemoFactory {
    id: ScenarioId,
}

impl ScenarioFactory for DemoFactory {
    fn id(&self) -> &ScenarioId {
        &self.id
    }

    fn build(&self, src: &str) -> Result<Box<dyn Scenario>, String> {
        Ok(Box::new(DemoPack {
            src: src.to_string(),
        }))
    }
}

#[test]
fn register_into_makes_pack_buildable() {
    let id = ScenarioId::from_static(DEMO_ID);

    // Fresh registry: the demo id is absent until the pack registers itself.
    let mut reg = PackRegistry::default();
    assert!(
        !reg.contains(&id),
        "demo id must be absent before register_into"
    );

    // Drive the seam exactly as an external integrator would.
    DemoPack::register_into(&mut reg);

    // Now the registry knows the id and can build a runnable scenario for it.
    assert!(
        reg.contains(&id),
        "register_into must install the demo factory"
    );
    let scenario = reg
        .build(&id, "payload = 42")
        .expect("registered factory must build");
    let out = scenario.run().expect("built scenario must run");
    assert_eq!(out.summary, "demo pack ran on 12 bytes");
}

#[test]
fn register_into_default_is_noop() {
    // A pack that does NOT override register_into (relying on the defaulted no-op)
    // must leave the registry untouched — proving the default keeps existing
    // implementors source-compatible.
    struct SilentPack;
    impl Scenario for SilentPack {
        fn run(&self) -> Result<RunOutput, KshanaError> {
            Ok(RunOutput {
                json: "{}".into(),
                svg: String::new(),
                summary: String::new(),
            })
        }
    }
    impl ExternalPack for SilentPack {
        fn kind_name(&self) -> &'static str {
            "silent"
        }
        fn meta(&self) -> ScenarioMeta {
            ScenarioMeta {
                name: "silent",
                description: "",
                required_fields: &[],
                optional_fields: &[],
            }
        }
        // no register_into override — uses the defaulted no-op
    }

    let mut reg = PackRegistry::default();
    SilentPack::register_into(&mut reg);
    assert_eq!(
        reg.ids().count(),
        0,
        "defaulted register_into must be a no-op"
    );
}