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
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

//! Integration tests for mkfifo and named pipe (FIFO) support
//!
//! Tests mkfifo builtin, test -p, file command, and FIFO read/write behavior.

use bashkit::Bash;

#[tokio::test]
async fn mkfifo_creates_fifo_in_vfs() {
    let mut bash = Bash::new();
    let result = bash.exec("mkfifo /tmp/pipe && echo ok").await.unwrap();
    assert_eq!(result.exit_code, 0);
    assert_eq!(result.stdout.trim(), "ok");
}

#[tokio::test]
async fn test_p_detects_fifo() {
    let mut bash = Bash::new();
    let result = bash
        .exec("mkfifo /tmp/pipe && test -p /tmp/pipe && echo yes || echo no")
        .await
        .unwrap();
    assert_eq!(result.exit_code, 0);
    assert_eq!(result.stdout.trim(), "yes");
}

#[tokio::test]
async fn test_p_false_for_regular_file() {
    let mut bash = Bash::new();
    let result = bash
        .exec("echo hi > /tmp/file && test -p /tmp/file && echo yes || echo no")
        .await
        .unwrap();
    assert_eq!(result.stdout.trim(), "no");
}

#[tokio::test]
async fn test_p_false_for_directory() {
    let mut bash = Bash::new();
    let result = bash
        .exec("mkdir -p /tmp/dir && test -p /tmp/dir && echo yes || echo no")
        .await
        .unwrap();
    assert_eq!(result.stdout.trim(), "no");
}

#[tokio::test]
async fn test_p_false_for_nonexistent() {
    let mut bash = Bash::new();
    let result = bash
        .exec("test -p /tmp/nope && echo yes || echo no")
        .await
        .unwrap();
    assert_eq!(result.stdout.trim(), "no");
}

#[tokio::test]
async fn file_identifies_fifo() {
    let mut bash = Bash::new();
    let result = bash
        .exec("mkfifo /tmp/pipe && file /tmp/pipe")
        .await
        .unwrap();
    assert_eq!(result.exit_code, 0);
    assert!(result.stdout.contains("fifo"));
    assert!(result.stdout.contains("named pipe"));
}

#[tokio::test]
async fn stat_identifies_fifo() {
    let mut bash = Bash::new();
    let result = bash
        .exec("mkfifo /tmp/pipe && stat /tmp/pipe")
        .await
        .unwrap();
    assert_eq!(result.exit_code, 0);
    assert!(result.stdout.contains("fifo") || result.stdout.contains("named pipe"));
}

#[tokio::test]
async fn fifo_write_and_read() {
    let mut bash = Bash::new();
    let result = bash
        .exec("mkfifo /tmp/pipe && echo hello > /tmp/pipe && cat /tmp/pipe")
        .await
        .unwrap();
    assert_eq!(result.exit_code, 0);
    assert_eq!(result.stdout.trim(), "hello");
}

#[tokio::test]
async fn mkfifo_with_mode() {
    let mut bash = Bash::new();
    let result = bash
        .exec("mkfifo -m 0600 /tmp/pipe && stat /tmp/pipe")
        .await
        .unwrap();
    assert_eq!(result.exit_code, 0);
}

#[tokio::test]
async fn mkfifo_multiple_pipes() {
    let mut bash = Bash::new();
    let result = bash
        .exec(
            r#"
mkfifo /tmp/p1 /tmp/p2 /tmp/p3
test -p /tmp/p1 && test -p /tmp/p2 && test -p /tmp/p3 && echo all_fifos
"#,
        )
        .await
        .unwrap();
    assert_eq!(result.exit_code, 0);
    assert_eq!(result.stdout.trim(), "all_fifos");
}

#[tokio::test]
async fn mkfifo_already_exists_error() {
    let mut bash = Bash::new();
    let result = bash
        .exec("mkfifo /tmp/pipe && mkfifo /tmp/pipe")
        .await
        .unwrap();
    assert_ne!(result.exit_code, 0);
}

#[tokio::test]
async fn mkfifo_missing_operand() {
    let mut bash = Bash::new();
    let result = bash.exec("mkfifo").await.unwrap();
    assert_ne!(result.exit_code, 0);
    assert!(result.stderr.contains("missing operand"));
}

#[tokio::test]
async fn mkfifo_parent_not_found() {
    let mut bash = Bash::new();
    let result = bash.exec("mkfifo /no/such/dir/pipe").await.unwrap();
    assert_ne!(result.exit_code, 0);
}

#[tokio::test]
async fn bracket_p_detects_fifo() {
    let mut bash = Bash::new();
    let result = bash
        .exec("mkfifo /tmp/pipe && [ -p /tmp/pipe ] && echo yes || echo no")
        .await
        .unwrap();
    assert_eq!(result.stdout.trim(), "yes");
}

#[tokio::test]
async fn fifo_persists_type_after_write() {
    let mut bash = Bash::new();
    let result = bash
        .exec(
            r#"
mkfifo /tmp/pipe
echo data > /tmp/pipe
test -p /tmp/pipe && echo still_fifo || echo not_fifo
"#,
        )
        .await
        .unwrap();
    assert_eq!(result.exit_code, 0);
    assert_eq!(result.stdout.trim(), "still_fifo");
}