adk-sandbox 0.7.0

Isolated code execution runtime for ADK agents
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

//! Integration tests for `ProcessBackend`.
//!
//! These tests require external tools (rustc, python3, node) and are marked
//! `#[ignore]` so they only run when explicitly requested:
//!
//! ```bash
//! cargo test -p adk-sandbox --test process_integration -- --ignored
//! ```

use adk_sandbox::{ExecRequest, Language, ProcessBackend, SandboxBackend, SandboxError};
use std::collections::HashMap;
use std::time::Duration;

fn backend() -> ProcessBackend {
    ProcessBackend::default()
}

fn env_with_path() -> HashMap<String, String> {
    let mut env = HashMap::new();
    if let Ok(path) = std::env::var("PATH") {
        env.insert("PATH".to_string(), path);
    }
    env
}

// ---------------------------------------------------------------------------
// Rust
// ---------------------------------------------------------------------------

#[tokio::test]
#[ignore]
async fn rust_valid_snippet_compiles_and_runs() {
    let backend = backend();
    let request = ExecRequest {
        language: Language::Rust,
        code: r#"fn main() { println!("hello"); }"#.to_string(),
        stdin: None,
        timeout: Duration::from_secs(30),
        memory_limit_mb: None,
        env: env_with_path(),
    };

    let result = backend.execute(request).await.expect("should succeed");
    assert_eq!(result.exit_code, 0);
    assert!(result.stdout.contains("hello"));
}

#[tokio::test]
#[ignore]
async fn rust_invalid_snippet_returns_nonzero_exit_code() {
    let backend = backend();
    let request = ExecRequest {
        language: Language::Rust,
        code: "fn main() { let x: i32 = \"not a number\"; }".to_string(),
        stdin: None,
        timeout: Duration::from_secs(30),
        memory_limit_mb: None,
        env: env_with_path(),
    };

    // Non-zero exit code is a valid result, NOT a SandboxError.
    let result = backend.execute(request).await.expect("should return ExecResult, not error");
    assert_ne!(result.exit_code, 0, "compile error should produce non-zero exit code");
    assert!(!result.stderr.is_empty(), "stderr should contain compiler diagnostics");
}

// ---------------------------------------------------------------------------
// Timeout
// ---------------------------------------------------------------------------

#[tokio::test]
#[ignore]
async fn timeout_enforcement_returns_sandbox_error() {
    let backend = backend();
    let request = ExecRequest {
        language: Language::Command,
        code: "sleep 60".to_string(),
        stdin: None,
        timeout: Duration::from_secs(1),
        memory_limit_mb: None,
        env: env_with_path(),
    };

    let err = backend.execute(request).await.expect_err("should timeout");
    assert!(
        matches!(err, SandboxError::Timeout { .. }),
        "expected SandboxError::Timeout, got: {err:?}"
    );
}

// ---------------------------------------------------------------------------
// Python
// ---------------------------------------------------------------------------

#[tokio::test]
#[ignore]
async fn python_snippet_executes() {
    let backend = backend();
    let request = ExecRequest {
        language: Language::Python,
        code: "print('hello from python')".to_string(),
        stdin: None,
        timeout: Duration::from_secs(30),
        memory_limit_mb: None,
        env: env_with_path(),
    };

    let result = backend.execute(request).await.expect("python3 should be available");
    assert_eq!(result.exit_code, 0);
    assert!(result.stdout.contains("hello from python"));
}

// ---------------------------------------------------------------------------
// JavaScript
// ---------------------------------------------------------------------------

#[tokio::test]
#[ignore]
async fn javascript_snippet_executes() {
    let backend = backend();
    let request = ExecRequest {
        language: Language::JavaScript,
        code: "console.log('hello from js')".to_string(),
        stdin: None,
        timeout: Duration::from_secs(30),
        memory_limit_mb: None,
        env: env_with_path(),
    };

    let result = backend.execute(request).await.expect("node should be available");
    assert_eq!(result.exit_code, 0);
    assert!(result.stdout.contains("hello from js"));
}