dstest 0.1.0

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
64
65
66
67
68
69
70
71
72

use std::collections::HashMap;
use std::sync::Arc;

use mlua::{Lua, Result, Table};

use crate::bindings::context::BindingContext;
use crate::substrate::docker::DockerSubjectData;

pub fn register(lua: &Lua, dstest: &Table, ctx: &BindingContext) -> Result<()> {
    let state = Arc::clone(&ctx.state);
    let docker = Arc::clone(&ctx.docker);
    let config = Arc::clone(&ctx.config);

    let setup =
        lua.create_function(
            move |_, (substrate_type, config_tbl): (Option<String>, Table)| {
                let cfg = config.lock().expect("poisoned config lock");
                let substrate = substrate_type
                    .or_else(|| cfg.substrate.clone())
                    .ok_or_else(|| {
                        mlua::Error::RuntimeError(
                            "no substrate configured: call dstest.config({ substrate = \"docker\" }) first".to_string(),
                        )
                    })?;

                match substrate.as_str() {
                    "docker" => {
                        let image: String = config_tbl.get("image")?;
                        let ports: Option<Vec<u16>> = config_tbl.get("ports").ok();
                        let cmd: Option<Vec<String>> = config_tbl.get("cmd").ok();
                        let volumes: Option<Vec<String>> = config_tbl.get("volumes").ok();
                        let env: Option<HashMap<String, String>> = config_tbl.get("env").ok();
                        let env = env
                            .map(|e| e.into_iter().map(|(k, v)| format!("{}={}", k, v)).collect());

                        let data = DockerSubjectData {
                            image,
                            cmd,
                            ports,
                            volumes,
                            env,
                        };

                        let container_id =
                            docker.host(&data).map_err(mlua::Error::RuntimeError)?;

                        let mut state = state.lock().expect("poisoned engine state lock");

                        if let Some(ref p) = data.ports.as_ref().and_then(|ports| ports.first()) {
                            state.subject_hosts.insert(
                                format!("docker/{}", container_id),
                                format!("localhost:{}", p),
                            );
                        }

                        state
                            .subjects
                            .push((format!("docker/{}", container_id), data));

                        Ok(format!("docker/{}", container_id))
                    }
                    _ => Err(mlua::Error::RuntimeError(format!(
                        "unknown substrate type: {}",
                        substrate
                    ))),
                }
            },
        )?;

    dstest.set("setup", setup)?;
    Ok(())
}