bashkit 0.5.0

Awesomely fast virtual sandbox with bash and file system
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

//! Tests for stdout/stderr output capture size limits (issue #648)

use bashkit::Bash;

async fn run(script: &str) -> bashkit::ExecResult {
    let mut bash = Bash::new();
    bash.exec(script).await.unwrap()
}

async fn run_with_limits(
    script: &str,
    max_stdout: usize,
    max_stderr: usize,
) -> bashkit::ExecResult {
    let limits = bashkit::ExecutionLimits::new()
        .max_stdout_bytes(max_stdout)
        .max_stderr_bytes(max_stderr);
    let mut bash = Bash::builder().limits(limits).build();
    bash.exec(script).await.unwrap()
}

// --- Default behavior: no truncation ---

#[tokio::test]
async fn no_truncation_by_default() {
    let result = run("echo hello").await;
    assert_eq!(result.stdout, "hello\n");
    assert!(!result.stdout_truncated);
    assert!(!result.stderr_truncated);
}

// --- stdout truncation ---

#[tokio::test]
async fn stdout_truncated_when_exceeds_limit() {
    // 10-byte limit; "hello\n" is 6 bytes, "world\n" is 6 bytes = 12 total
    let result = run_with_limits("echo hello; echo world", 10, 1_048_576).await;
    assert_eq!(result.stdout.len(), 10);
    assert!(result.stdout.starts_with("hello\n"));
    assert!(result.stdout_truncated);
    assert!(!result.stderr_truncated);
}

#[tokio::test]
async fn stdout_not_truncated_when_within_limit() {
    let result = run_with_limits("echo hi", 100, 1_048_576).await;
    assert_eq!(result.stdout, "hi\n");
    assert!(!result.stdout_truncated);
}

#[tokio::test]
async fn stdout_exact_limit_not_truncated() {
    // "hi\n" is 3 bytes, limit is 3
    let result = run_with_limits("echo hi", 3, 1_048_576).await;
    assert_eq!(result.stdout, "hi\n");
    assert!(!result.stdout_truncated);
}

#[tokio::test]
async fn stdout_one_byte_over_limit_truncated() {
    // "hi\n" is 3 bytes, limit is 2
    let result = run_with_limits("echo hi", 2, 1_048_576).await;
    assert_eq!(result.stdout.len(), 2);
    assert_eq!(result.stdout, "hi");
    assert!(result.stdout_truncated);
}

#[tokio::test]
async fn stdout_truncation_preserves_utf8_boundaries() {
    let result = run_with_limits("echo é", 1, 1_048_576).await;
    assert_eq!(result.stdout, "");
    assert!(result.stdout_truncated);
}

// --- stderr truncation ---

#[tokio::test]
async fn stderr_truncated_when_exceeds_limit() {
    let result = run_with_limits("echo err1 >&2; echo err2 >&2", 1_048_576, 8).await;
    assert!(result.stderr.len() <= 8);
    assert!(result.stderr_truncated);
}

#[tokio::test]
async fn stderr_not_truncated_when_within_limit() {
    let result = run_with_limits("echo oops >&2", 1_048_576, 100).await;
    assert!(!result.stderr_truncated);
}

#[tokio::test]
async fn stderr_truncation_preserves_utf8_boundaries() {
    let result = run_with_limits("echo é >&2", 1_048_576, 1).await;
    assert_eq!(result.stderr, "");
    assert!(result.stderr_truncated);
}

// --- Execution continues after truncation ---

#[tokio::test]
async fn execution_continues_after_stdout_truncation() {
    // Script sets a variable after producing output.
    // Even though stdout is truncated, the script should finish.
    let result = run_with_limits(r#"echo aaa; echo bbb; x=done; echo "$x""#, 5, 1_048_576).await;
    assert!(result.stdout_truncated);
    // Script still ran to completion (exit code 0)
    assert_eq!(result.exit_code, 0);
}

// --- Minimal limit ---

#[tokio::test]
async fn minimal_stdout_limit_truncates_immediately() {
    // 0 is treated as "use default" per #1181, so use 1 for minimal limit
    let result = run_with_limits("echo hello", 1, 1_048_576).await;
    assert!(result.stdout.len() <= 1);
    assert!(result.stdout_truncated);
}

// --- Both truncated ---

#[tokio::test]
async fn both_stdout_and_stderr_truncated() {
    let result = run_with_limits("echo out; echo err >&2", 3, 3).await;
    assert!(result.stdout_truncated);
    assert!(result.stderr_truncated);
    assert!(result.stdout.len() <= 3);
    assert!(result.stderr.len() <= 3);
}

// --- Default limits ---

#[tokio::test]
async fn default_limits_are_1mb() {
    let limits = bashkit::ExecutionLimits::default();
    assert_eq!(limits.max_stdout_bytes, 1_048_576);
    assert_eq!(limits.max_stderr_bytes, 1_048_576);
}

// --- Builder ---

#[tokio::test]
async fn builder_sets_limits() {
    let limits = bashkit::ExecutionLimits::new()
        .max_stdout_bytes(500)
        .max_stderr_bytes(300);
    assert_eq!(limits.max_stdout_bytes, 500);
    assert_eq!(limits.max_stderr_bytes, 300);
}