start-command 0.18.0

Gamification of coding, execute any command with ability to auto-report issues on GitHub
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

use super::*;

#[test]
fn test_docker_runtime_status_lines_empty() {
    assert!(docker_runtime_status_lines(&[], &[], &[], false, None, &[]).is_empty());
}

#[test]
fn test_docker_runtime_status_lines_populated() {
    let lines = docker_runtime_status_lines(
        &["/h:/c:ro".to_string()],
        &["type=bind,src=/h,dst=/c".to_string()],
        &["FOO=bar".to_string()],
        true,
        Some("hive-formal-ai"),
        &["formal-ai".to_string(), "checker".to_string()],
    );
    assert_eq!(
        lines,
        vec![
            "[Isolation] Volumes: /h:/c:ro".to_string(),
            "[Isolation] Mounts: type=bind,src=/h,dst=/c".to_string(),
            "[Isolation] Env: FOO=bar".to_string(),
            "[Isolation] Privileged: true".to_string(),
            "[Isolation] Network: hive-formal-ai".to_string(),
            "[Isolation] Network aliases: formal-ai, checker".to_string(),
        ]
    );
}

#[test]
fn test_docker_runtime_status_lines_joins_multiple() {
    let lines = docker_runtime_status_lines(
        &["/a:/a".to_string(), "/b:/b".to_string()],
        &[],
        &[],
        false,
        None,
        &[],
    );
    assert_eq!(lines, vec!["[Isolation] Volumes: /a:/a, /b:/b".to_string()]);
}

#[test]
fn test_docker_runtime_metadata_empty() {
    assert!(docker_runtime_metadata(&[], &[], &[], false, None, &[]).is_empty());
}

#[test]
fn test_docker_runtime_metadata_populated() {
    let entries = docker_runtime_metadata(
        &["/h:/c".to_string()],
        &["type=bind,src=/h,dst=/c".to_string()],
        &["FOO=bar".to_string()],
        true,
        Some("hive-formal-ai"),
        &["formal-ai".to_string(), "checker".to_string()],
    );
    let map: std::collections::HashMap<_, _> = entries.into_iter().collect();
    assert_eq!(
        map.get("volumes"),
        Some(&serde_json::json!(["/h:/c".to_string()]))
    );
    assert_eq!(
        map.get("mounts"),
        Some(&serde_json::json!(["type=bind,src=/h,dst=/c".to_string()]))
    );
    assert_eq!(
        map.get("env"),
        Some(&serde_json::json!(["FOO=bar".to_string()]))
    );
    assert_eq!(map.get("privileged"), Some(&serde_json::Value::Bool(true)));
    assert_eq!(
        map.get("network"),
        Some(&serde_json::json!("hive-formal-ai"))
    );
    assert_eq!(
        map.get("networkAliases"),
        Some(&serde_json::json!(["formal-ai", "checker"]))
    );
}

#[test]
fn test_docker_runtime_metadata_omits_privileged_when_false() {
    let entries = docker_runtime_metadata(&["/h:/c".to_string()], &[], &[], false, None, &[]);
    let map: std::collections::HashMap<_, _> = entries.into_iter().collect();
    assert!(map.contains_key("volumes"));
    assert!(!map.contains_key("privileged"));
    assert!(!map.contains_key("mounts"));
    assert!(!map.contains_key("env"));
}

#[test]
fn test_build_isolation_options_map_basic() {
    let opts = WrapperOptions::default();
    let map = build_isolation_options_map(
        Some("docker"),
        "detached",
        "my-session",
        Some("alpine:latest"),
        &opts,
        None,
    );
    assert_eq!(map.get("isolated"), Some(&serde_json::json!("docker")));
    assert_eq!(
        map.get("isolationMode"),
        Some(&serde_json::json!("detached"))
    );
    assert_eq!(
        map.get("sessionName"),
        Some(&serde_json::json!("my-session"))
    );
    assert_eq!(map.get("image"), Some(&serde_json::json!("alpine:latest")));
    assert_eq!(map.get("keepAlive"), Some(&serde_json::Value::Bool(false)));
    assert!(!map.contains_key("volumes"));
}

#[test]
fn test_build_isolation_options_map_includes_runtime_options() {
    let opts = WrapperOptions {
        volumes: vec!["/h:/c:ro".to_string()],
        env: vec!["TOKEN=abc".to_string()],
        privileged: true,
        network: Some("hive-formal-ai".to_string()),
        network_aliases: vec!["formal-ai".to_string(), "checker".to_string()],
        ..Default::default()
    };
    let map = build_isolation_options_map(
        Some("docker"),
        "attached",
        "s",
        Some("konard/hive-mind-dind:latest"),
        &opts,
        Some("isolated-user"),
    );
    assert_eq!(
        map.get("volumes"),
        Some(&serde_json::json!(["/h:/c:ro".to_string()]))
    );
    assert_eq!(
        map.get("env"),
        Some(&serde_json::json!(["TOKEN=abc".to_string()]))
    );
    assert_eq!(map.get("privileged"), Some(&serde_json::Value::Bool(true)));
    assert_eq!(
        map.get("network"),
        Some(&serde_json::json!("hive-formal-ai"))
    );
    assert_eq!(
        map.get("networkAliases"),
        Some(&serde_json::json!(["formal-ai", "checker"]))
    );
    assert_eq!(map.get("user"), Some(&serde_json::json!("isolated-user")));
}