somatize-worker 0.3.0

Worker daemon for distributed execution in the Soma runtime
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

//! End-to-end tests for EnvManager: creates real venvs, installs packages.
//!
//! These tests require `python3` to be available on the system.
//! They create temporary directories and real virtual environments.

use somatize_worker::env_manager::{EnvManager, EnvType};

fn has_python3() -> bool {
    std::process::Command::new("python3")
        .args(["--version"])
        .output()
        .map(|o| o.status.success())
        .unwrap_or(false)
}

#[test]
fn create_venv_and_get_python() {
    if !has_python3() {
        eprintln!("Skipping: python3 not found");
        return;
    }

    let tmp = tempfile::tempdir().unwrap();
    let mgr = EnvManager::new(tmp.path(), EnvType::Venv);

    // Create env with no requirements
    let python = mgr.ensure_env("test_pipeline", "").unwrap();

    // Python binary should exist
    assert!(
        python.exists(),
        "Python binary should exist at {}",
        python.display()
    );

    // Should be inside the temp dir
    assert!(python.starts_with(tmp.path()));

    // Python should be executable
    let output = std::process::Command::new(&python)
        .args(["--version"])
        .output()
        .unwrap();
    assert!(output.status.success());
    let version = String::from_utf8_lossy(&output.stdout);
    assert!(
        version.contains("Python 3"),
        "Should be Python 3, got: {version}"
    );
}

#[test]
fn reuse_existing_venv() {
    if !has_python3() {
        eprintln!("Skipping: python3 not found");
        return;
    }

    let tmp = tempfile::tempdir().unwrap();
    let mgr = EnvManager::new(tmp.path(), EnvType::Venv);

    // Create env
    let python1 = mgr.ensure_env("reuse_test", "").unwrap();

    // Call again with same requirements → should reuse
    let python2 = mgr.ensure_env("reuse_test", "").unwrap();

    assert_eq!(python1, python2, "should return same python path");
}

#[test]
fn different_requirements_trigger_update() {
    if !has_python3() {
        eprintln!("Skipping: python3 not found");
        return;
    }

    let tmp = tempfile::tempdir().unwrap();
    let mgr = EnvManager::new(tmp.path(), EnvType::Venv);

    // Create with requirements v1
    let _python1 = mgr.ensure_env("update_test", "").unwrap();

    // Update with different requirements (just a comment change triggers hash change)
    let python2 = mgr.ensure_env("update_test", "# updated\n").unwrap();

    // Should still work
    assert!(python2.exists());
}

#[test]
fn install_real_package() {
    if !has_python3() {
        eprintln!("Skipping: python3 not found");
        return;
    }

    let tmp = tempfile::tempdir().unwrap();
    let mgr = EnvManager::new(tmp.path(), EnvType::Venv);

    // Install a small, fast package
    let python = mgr.ensure_env("pkg_test", "six\n").unwrap();

    // Verify the package is importable
    let output = std::process::Command::new(&python)
        .args(["-c", "import six; print(six.__version__)"])
        .output()
        .unwrap();
    assert!(
        output.status.success(),
        "six should be importable. stderr: {}",
        String::from_utf8_lossy(&output.stderr)
    );
}

#[test]
fn cleanup_old_envs() {
    if !has_python3() {
        eprintln!("Skipping: python3 not found");
        return;
    }

    let tmp = tempfile::tempdir().unwrap();
    let mgr = EnvManager::new(tmp.path(), EnvType::Venv);

    // Create an env
    let _python = mgr.ensure_env("cleanup_test", "").unwrap();

    // Cleanup with 0 duration → should remove everything
    let removed = mgr.cleanup(std::time::Duration::from_secs(0));
    assert!(removed >= 1, "should have removed at least 1 env");
}

#[test]
fn lockfile_persists_between_calls() {
    if !has_python3() {
        eprintln!("Skipping: python3 not found");
        return;
    }

    let tmp = tempfile::tempdir().unwrap();
    let mgr = EnvManager::new(tmp.path(), EnvType::Venv);

    let _python = mgr.ensure_env("lock_test", "six==1.17.0\n").unwrap();

    // Lockfile should exist
    let lockfile_path = tmp.path().join("env-lock_test").join("lockfile.json");
    assert!(lockfile_path.exists(), "lockfile should be written");

    // Parse and verify
    let content = std::fs::read_to_string(&lockfile_path).unwrap();
    let lockfile: serde_json::Value = serde_json::from_str(&content).unwrap();
    assert!(lockfile["packages"]["six"].is_string());
}