evalbox 0.1.1

Unprivileged sandbox for arbitrary code execution
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

//! Integration tests for evalbox.
//!
//! These tests verify the full runtime detection and probing workflow.

use std::path::Path;

use evalbox::{Probe, ProbeCache};

#[cfg(feature = "python")]
mod python_integration {
    use super::*;
    use evalbox::PythonProbe;

    #[test]
    fn test_python_probe_cache_workflow() {
        let cache = ProbeCache::new();
        let probe = PythonProbe::new();

        // Try to detect Python
        let Some(binary) = probe.detect() else {
            // Python not installed, skip test
            eprintln!("Skipping: Python not found");
            return;
        };

        // First probe - should populate cache
        let result1 = cache.get_or_probe(&probe, &binary);
        assert!(result1.is_ok(), "First probe should succeed");
        assert_eq!(cache.len(), 1, "Cache should have one entry");

        // Second probe - should hit cache
        let result2 = cache.get_or_probe(&probe, &binary);
        assert!(result2.is_ok(), "Second probe should succeed");

        // Results should be identical
        let info1 = result1.unwrap();
        let info2 = result2.unwrap();
        assert_eq!(info1.binary, info2.binary);
        assert_eq!(info1.mounts.len(), info2.mounts.len());
    }

    #[test]
    fn test_python_runtime_info_valid() {
        let probe = PythonProbe::new();

        let Some(binary) = probe.detect() else {
            eprintln!("Skipping: Python not found");
            return;
        };

        let info = probe.probe(&binary).expect("Probe should succeed");

        // Verify runtime info
        assert!(info.binary.exists(), "Binary should exist");
        assert!(!info.mounts.is_empty(), "Should have mounts");

        // All mount sources should exist
        for mount in &info.mounts {
            assert!(
                mount.source.exists(),
                "Mount source should exist: {}",
                mount.source.display()
            );
        }

        // Should have PYTHONHOME set
        assert!(info.env.contains_key("PYTHONHOME"), "Should set PYTHONHOME");
    }
}

#[cfg(feature = "go")]
mod go_integration {
    use super::*;
    use evalbox::GoProbe;

    #[test]
    fn test_go_probe_cache_workflow() {
        let cache = ProbeCache::new();
        let probe = GoProbe::new();

        let Some(binary) = probe.detect() else {
            eprintln!("Skipping: Go not found");
            return;
        };

        // First probe
        let result1 = cache.get_or_probe(&probe, &binary);
        assert!(result1.is_ok(), "First probe should succeed");

        // Second probe - cache hit
        let result2 = cache.get_or_probe(&probe, &binary);
        assert!(result2.is_ok(), "Second probe should succeed");

        let info1 = result1.unwrap();
        let info2 = result2.unwrap();
        assert_eq!(info1.binary, info2.binary);
    }

    #[test]
    fn test_go_runtime_info_valid() {
        let probe = GoProbe::new();

        let Some(binary) = probe.detect() else {
            eprintln!("Skipping: Go not found");
            return;
        };

        let info = probe.probe(&binary).expect("Probe should succeed");

        // Verify runtime info
        assert!(info.binary.exists(), "Binary should exist");
        assert!(!info.mounts.is_empty(), "Should have mounts");

        // Should have GOROOT set
        assert!(info.env.contains_key("GOROOT"), "Should set GOROOT");

        // GOROOT mount should exist
        let goroot = &info.env["GOROOT"];
        assert!(Path::new(goroot).exists(), "GOROOT should exist: {goroot}");
    }
}