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
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319

//! Git Advanced Operations Tests (Phase 3)
//!
//! Tests for git branch, checkout, diff, and reset commands.

#![cfg(feature = "git")]

use bashkit::{Bash, GitConfig};

/// Helper to create a bash instance with git configured
fn create_git_bash() -> Bash {
    Bash::builder()
        .git(
            GitConfig::new()
                .author("Test User", "test@example.com")
                .allow_all_remotes(),
        )
        .build()
}

/// Helper to set up a repo with an initial commit
async fn setup_repo_with_commit(bash: &mut Bash) {
    bash.exec("git init /repo").await.unwrap();
    bash.exec("echo 'hello' > /repo/README.md").await.unwrap();
    bash.exec("cd /repo && git add README.md").await.unwrap();
    bash.exec("cd /repo && git commit -m 'Initial commit'")
        .await
        .unwrap();
}

mod branch_operations {
    use super::*;

    #[tokio::test]
    async fn test_branch_list_default() {
        let mut bash = create_git_bash();
        setup_repo_with_commit(&mut bash).await;

        let result = bash.exec("cd /repo && git branch").await.unwrap();
        assert_eq!(result.exit_code, 0);
        assert!(result.stdout.contains("* master"));
    }

    #[tokio::test]
    async fn test_branch_create() {
        let mut bash = create_git_bash();
        setup_repo_with_commit(&mut bash).await;

        let result = bash.exec("cd /repo && git branch feature").await.unwrap();
        assert_eq!(result.exit_code, 0);

        let result = bash.exec("cd /repo && git branch").await.unwrap();
        assert!(result.stdout.contains("* master"));
        assert!(result.stdout.contains("feature"));
    }

    #[tokio::test]
    async fn test_branch_create_duplicate() {
        let mut bash = create_git_bash();
        setup_repo_with_commit(&mut bash).await;

        bash.exec("cd /repo && git branch feature").await.unwrap();
        let result = bash.exec("cd /repo && git branch feature").await.unwrap();
        assert_ne!(result.exit_code, 0);
        assert!(result.stderr.contains("already exists"));
    }

    #[tokio::test]
    async fn test_branch_delete() {
        let mut bash = create_git_bash();
        setup_repo_with_commit(&mut bash).await;

        bash.exec("cd /repo && git branch feature").await.unwrap();
        let result = bash
            .exec("cd /repo && git branch -d feature")
            .await
            .unwrap();
        assert_eq!(result.exit_code, 0);
        assert!(result.stdout.contains("Deleted branch feature"));

        let result = bash.exec("cd /repo && git branch").await.unwrap();
        assert!(!result.stdout.contains("feature"));
    }

    #[tokio::test]
    async fn test_branch_delete_current() {
        let mut bash = create_git_bash();
        setup_repo_with_commit(&mut bash).await;

        let result = bash.exec("cd /repo && git branch -d master").await.unwrap();
        assert_ne!(result.exit_code, 0);
        assert!(result.stderr.contains("cannot delete branch"));
    }

    #[tokio::test]
    async fn test_branch_delete_nonexistent() {
        let mut bash = create_git_bash();
        setup_repo_with_commit(&mut bash).await;

        let result = bash
            .exec("cd /repo && git branch -d nonexistent")
            .await
            .unwrap();
        assert_ne!(result.exit_code, 0);
        assert!(result.stderr.contains("not found"));
    }

    #[tokio::test]
    async fn test_branch_no_commits() {
        let mut bash = create_git_bash();
        bash.exec("git init /repo").await.unwrap();

        // Creating branch without commits should fail
        let result = bash.exec("cd /repo && git branch feature").await.unwrap();
        assert_ne!(result.exit_code, 0);
        assert!(result.stderr.contains("not a valid object name"));
    }
}

mod checkout_operations {
    use super::*;

    #[tokio::test]
    async fn test_checkout_branch() {
        let mut bash = create_git_bash();
        setup_repo_with_commit(&mut bash).await;

        bash.exec("cd /repo && git branch feature").await.unwrap();
        let result = bash.exec("cd /repo && git checkout feature").await.unwrap();
        assert_eq!(result.exit_code, 0);
        assert!(result.stdout.contains("Switched to branch 'feature'"));

        // Verify current branch
        let result = bash.exec("cd /repo && git branch").await.unwrap();
        assert!(result.stdout.contains("* feature"));
    }

    #[tokio::test]
    async fn test_checkout_create_branch() {
        let mut bash = create_git_bash();
        setup_repo_with_commit(&mut bash).await;

        let result = bash
            .exec("cd /repo && git checkout -b newbranch")
            .await
            .unwrap();
        assert_eq!(result.exit_code, 0);
        assert!(result.stdout.contains("Switched to branch 'newbranch'"));

        let result = bash.exec("cd /repo && git branch").await.unwrap();
        assert!(result.stdout.contains("* newbranch"));
    }

    #[tokio::test]
    async fn test_checkout_nonexistent() {
        let mut bash = create_git_bash();
        setup_repo_with_commit(&mut bash).await;

        let result = bash
            .exec("cd /repo && git checkout nonexistent")
            .await
            .unwrap();
        assert_ne!(result.exit_code, 0);
        assert!(result.stderr.contains("did not match"));
    }

    #[tokio::test]
    async fn test_checkout_no_args() {
        let mut bash = create_git_bash();
        setup_repo_with_commit(&mut bash).await;

        let result = bash.exec("cd /repo && git checkout").await.unwrap();
        assert_ne!(result.exit_code, 0);
        assert!(result.stderr.contains("must specify"));
    }

    #[tokio::test]
    async fn test_checkout_commit_hash() {
        let mut bash = create_git_bash();
        setup_repo_with_commit(&mut bash).await;

        // Get the commit hash
        let log_result = bash.exec("cd /repo && git log -1").await.unwrap();
        // Extract hash from "commit <hash>" line
        let hash = log_result
            .stdout
            .lines()
            .find(|l| l.starts_with("commit"))
            .map(|l| l.strip_prefix("commit ").unwrap_or(l).trim())
            .unwrap_or("abcd1234");

        // Checkout by hash (detached HEAD)
        let result = bash
            .exec(&format!("cd /repo && git checkout {}", hash))
            .await
            .unwrap();
        assert_eq!(result.exit_code, 0);
        assert!(result.stdout.contains("detached HEAD"));
    }
}

mod diff_operations {
    use super::*;

    #[tokio::test]
    async fn test_diff_basic() {
        let mut bash = create_git_bash();
        setup_repo_with_commit(&mut bash).await;

        let result = bash.exec("cd /repo && git diff").await.unwrap();
        assert_eq!(result.exit_code, 0);
        // Simplified diff in virtual mode
        assert!(result.stdout.contains("Diff output"));
    }

    #[tokio::test]
    async fn test_diff_not_a_repo() {
        let mut bash = create_git_bash();

        let result = bash.exec("cd / && git diff").await.unwrap();
        assert_ne!(result.exit_code, 0);
        assert!(result.stderr.contains("not a git repository"));
    }
}

mod reset_operations {
    use super::*;

    #[tokio::test]
    async fn test_reset_soft() {
        let mut bash = create_git_bash();
        setup_repo_with_commit(&mut bash).await;

        // Stage a file
        bash.exec("echo 'new' > /repo/new.txt").await.unwrap();
        bash.exec("cd /repo && git add new.txt").await.unwrap();

        // Reset soft
        let result = bash.exec("cd /repo && git reset --soft").await.unwrap();
        assert_eq!(result.exit_code, 0);
    }

    #[tokio::test]
    async fn test_reset_mixed() {
        let mut bash = create_git_bash();
        setup_repo_with_commit(&mut bash).await;

        // Stage a file
        bash.exec("echo 'new' > /repo/new.txt").await.unwrap();
        bash.exec("cd /repo && git add new.txt").await.unwrap();

        // Reset mixed (default)
        let result = bash.exec("cd /repo && git reset --mixed").await.unwrap();
        assert_eq!(result.exit_code, 0);
        assert!(result.stdout.contains("Unstaged changes"));
    }

    #[tokio::test]
    async fn test_reset_hard() {
        let mut bash = create_git_bash();
        setup_repo_with_commit(&mut bash).await;

        // Stage a file
        bash.exec("echo 'new' > /repo/new.txt").await.unwrap();
        bash.exec("cd /repo && git add new.txt").await.unwrap();

        // Reset hard
        let result = bash.exec("cd /repo && git reset --hard").await.unwrap();
        assert_eq!(result.exit_code, 0);
        assert!(result.stdout.contains("HEAD is now at"));
    }

    #[tokio::test]
    async fn test_reset_invalid_mode() {
        let mut bash = create_git_bash();
        setup_repo_with_commit(&mut bash).await;

        let result = bash.exec("cd /repo && git reset --invalid").await.unwrap();
        assert_ne!(result.exit_code, 0);
        assert!(result.stderr.contains("unknown switch"));
    }

    #[tokio::test]
    async fn test_reset_clears_staging() {
        let mut bash = create_git_bash();
        setup_repo_with_commit(&mut bash).await;

        // Stage a file
        bash.exec("echo 'new' > /repo/new.txt").await.unwrap();
        bash.exec("cd /repo && git add new.txt").await.unwrap();

        // Verify staged
        let result = bash.exec("cd /repo && git status").await.unwrap();
        assert!(result.stdout.contains("new.txt"));
        assert!(result.stdout.contains("Changes to be committed"));

        // Reset
        bash.exec("cd /repo && git reset --mixed").await.unwrap();

        // Verify unstaged (should be untracked now)
        let result = bash.exec("cd /repo && git status").await.unwrap();
        assert!(result.stdout.contains("Untracked files"));
    }
}

mod help_messages {
    use super::*;

    #[tokio::test]
    async fn test_git_help_shows_all_commands() {
        let mut bash = create_git_bash();

        let result = bash.exec("git").await.unwrap();
        // All Phase 3 commands should be in help
        assert!(result.stderr.contains("branch"));
        assert!(result.stderr.contains("checkout"));
        assert!(result.stderr.contains("diff"));
        assert!(result.stderr.contains("reset"));
    }
}