bashkit 0.2.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

// Integration tests for cancellation support (issue #541)

use bashkit::Bash;
use std::sync::atomic::Ordering;

#[tokio::test]
async fn cancel_aborts_execution() {
    let mut bash = Bash::new();
    let token = bash.cancellation_token();

    // Pre-set cancellation flag
    token.store(true, Ordering::Relaxed);

    let result = bash.exec("echo hello").await;
    assert!(result.is_err());
    let err = result.unwrap_err();
    assert_eq!(err.to_string(), "execution cancelled");
}

#[tokio::test]
async fn cancel_resets_manually() {
    let mut bash = Bash::new();
    let token = bash.cancellation_token();

    // Cancel first execution
    token.store(true, Ordering::Relaxed);
    let result = bash.exec("echo first").await;
    assert!(result.is_err());

    // Reset flag and verify next execution succeeds
    token.store(false, Ordering::Relaxed);
    let result = bash.exec("echo second").await;
    assert!(result.is_ok());
    assert_eq!(result.unwrap().stdout.trim(), "second");
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn cancel_mid_execution() {
    let mut bash = Bash::new();
    let token = bash.cancellation_token();

    // Spawn a task that cancels after a short delay
    let cancel_token = token.clone();
    tokio::spawn(async move {
        tokio::time::sleep(std::time::Duration::from_millis(10)).await;
        cancel_token.store(true, Ordering::Relaxed);
    });

    // Run a long script — should be cancelled before completion
    let result = bash.exec("for i in $(seq 1 10000); do echo $i; done").await;
    assert!(result.is_err());
    assert_eq!(result.unwrap_err().to_string(), "execution cancelled");

    // Clean up
    token.store(false, Ordering::Relaxed);
}

#[tokio::test]
async fn uncancelled_execution_succeeds() {
    let mut bash = Bash::new();
    let _token = bash.cancellation_token();

    // Getting the token without setting it should not affect execution
    let result = bash.exec("echo works").await;
    assert!(result.is_ok());
    assert_eq!(result.unwrap().stdout.trim(), "works");
}

#[tokio::test]
async fn cancellation_token_is_shared() {
    let bash = Bash::new();
    let token1 = bash.cancellation_token();
    let token2 = bash.cancellation_token();

    // Both tokens point to the same AtomicBool
    token1.store(true, Ordering::Relaxed);
    assert!(token2.load(Ordering::Relaxed));
}