monty-runtime 0.0.21

A sandboxed, snapshotable Python interpreter written in Rust.
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

// every test here drives the standalone CLI, which a worker-only build refuses
#![cfg(feature = "standalone")]

use std::{fs, process::Command};

use tempfile::TempDir;

/// Runs the CLI binary and returns trimmed, ANSI-free stderr for exact assertions.
fn run_monty(args: &[&str]) -> (bool, String) {
    let output = Command::new(env!("CARGO_BIN_EXE_monty"))
        .args(args)
        .output()
        .expect("monty CLI should run");

    (
        output.status.success(),
        strip_ansi(&String::from_utf8(output.stderr).expect("stderr should be valid UTF-8"))
            .trim()
            .to_owned(),
    )
}

/// Removes ANSI escape sequences so tests can assert on the actual error text.
fn strip_ansi(s: &str) -> String {
    let mut out = String::with_capacity(s.len());
    let mut chars = s.chars().peekable();

    while let Some(ch) = chars.next() {
        if ch != '\u{1b}' {
            out.push(ch);
            continue;
        }

        if chars.next_if_eq(&'[').is_none() {
            continue;
        }

        for next in chars.by_ref() {
            if next.is_ascii_alphabetic() {
                break;
            }
        }
    }

    out
}

/// Writes `code` to a temporary Python file and returns the containing temp dir.
fn script_dir(code: &str) -> TempDir {
    let dir = TempDir::new().expect("tempdir should be created");
    fs::write(dir.path().join("script.py"), code).expect("script should be written");
    dir
}

#[test]
fn unmounted_paths_report_permission_error() {
    let host_dir = TempDir::new().expect("tempdir should be created");
    let script_dir = script_dir("from pathlib import Path\nPath('/outside.txt').read_text()\n");
    let mount = format!("{}::/mnt", host_dir.path().display());
    let script = script_dir.path().join("script.py");

    let (success, stderr) = run_monty(&["-m", &mount, script.to_str().expect("utf-8 path")]);

    assert!(!success, "CLI should fail for unmounted filesystem access");
    assert!(
        stderr.contains("PermissionError: Permission denied: '/outside.txt'"),
        "unexpected stderr: {stderr}"
    );
}

#[test]
fn mount_write_limit_is_enforced_from_cli_spec() {
    let host_dir = TempDir::new().expect("tempdir should be created");
    let script_dir = script_dir("from pathlib import Path\nPath('/mnt/out.txt').write_text('hello')\n");
    let mount = format!("{}::/mnt::rw::4", host_dir.path().display());
    let script = script_dir.path().join("script.py");

    let (success, stderr) = run_monty(&["-m", &mount, script.to_str().expect("utf-8 path")]);

    assert!(!success, "CLI should fail when the configured write limit is exceeded");
    assert!(
        stderr.contains("OSError: disk write limit of 4 bytes exceeded"),
        "unexpected stderr: {stderr}"
    );
}

#[test]
fn invalid_write_limit_is_rejected_during_mount_parsing() {
    let script_dir = script_dir("1\n");
    let mount = format!("{}::/mnt::rw::abc", script_dir.path().display());
    let script = script_dir.path().join("script.py");

    let (success, stderr) = run_monty(&["-m", &mount, script.to_str().expect("utf-8 path")]);

    assert!(!success, "CLI should reject invalid mount write limits");
    assert_eq!(
        stderr,
        "error: invalid write limit 'abc' in '".to_owned() + &mount + "': expected a non-negative integer"
    );
}