dstest 0.1.3

Deterministic Simulation Testing for containerised services
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

use tracing::{debug, warn};

use crate::bindings::{BindingContext, register_all};

pub struct Engine {
    ctx: BindingContext,
}

impl Engine {
    pub fn new() -> Self {
        let ctx = BindingContext::new();
        let globals = ctx.lua.globals();
        let dstest = ctx
            .lua
            .create_table()
            .expect("failed to create dstest table");

        let _ = globals.set(
            "print",
            ctx.lua
                .create_function(|_, msg: String| {
                    tracing::info!("lua: {}", msg);
                    Ok(())
                })
                .expect("failed to create print function"),
        );

        register_all(&ctx.lua, &dstest, &ctx).expect("failed to register bindings");
        globals
            .set("dstest", dstest)
            .expect("failed to set global dstest");

        Engine { ctx }
    }

    pub fn execute(&self, script: &str) -> mlua::Result<()> {
        self.ctx.lua.load(script).exec()
    }
}

impl Default for Engine {
    fn default() -> Self {
        Self::new()
    }
}

impl Drop for Engine {
    fn drop(&mut self) {
        let subjects = {
            let mut state = self.ctx.state.lock().expect("poisoned engine state lock");
            std::mem::take(&mut state.subjects)
        };

        for (id, _) in subjects {
            let subject = crate::substrate::Subject::new(id.clone());
            if let Err(e) = self.ctx.substrate.teardown(subject) {
                warn!("RAII teardown failed for subject {}: {}", id, e);
            } else {
                debug!("teardown complete for subject {}", id);
            }
        }
    }
}