git-worktree-manager 0.0.39

CLI tool integrating git worktree with AI coding assistants
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

//! Integration tests for multi-target `gw delete`.
//!
//! Uses the `TestRepo` harness from `tests/common/`.

mod common;
use common::TestRepo;

/// Match the exact feature-worktree row prefix in `gw list` output
/// (symbol + one space + branch + trailing space), which avoids
/// false-positives against `main` or any default-branch prefix.
fn worktree_row(branch: &str) -> String {
    format!("\u{25cb} {branch} ")
}

#[test]
fn test_delete_multiple_positional_all_succeed() {
    let repo = TestRepo::new();
    assert!(repo.cw_ok(&["new", "a", "--no-term"]));
    assert!(repo.cw_ok(&["new", "b", "--no-term"]));
    assert!(repo.cw_ok(&["new", "c", "--no-term"]));

    let out = repo.cw(&["delete", "a", "b", "c"]);
    assert!(
        out.status.success(),
        "stderr: {}",
        String::from_utf8_lossy(&out.stderr)
    );

    let list = repo.cw_stdout(&["list"]);
    assert!(
        !list.contains(&worktree_row("a")),
        "list still mentions a: {list}"
    );
    assert!(
        !list.contains(&worktree_row("b")),
        "list still mentions b: {list}"
    );
    assert!(
        !list.contains(&worktree_row("c")),
        "list still mentions c: {list}"
    );
}

#[test]
fn test_delete_multiple_mixed_valid_and_missing() {
    let repo = TestRepo::new();
    assert!(repo.cw_ok(&["new", "real", "--no-term"]));

    let out = repo.cw(&["delete", "real", "does-not-exist"]);
    // exit code 2: at least one target was not deleted
    assert_eq!(
        out.status.code(),
        Some(2),
        "stdout: {} stderr: {}",
        String::from_utf8_lossy(&out.stdout),
        String::from_utf8_lossy(&out.stderr)
    );

    let list = repo.cw_stdout(&["list"]);
    assert!(
        !list.contains(&worktree_row("real")),
        "list still mentions real: {list}"
    );
}

#[test]
fn test_delete_dry_run_does_not_delete() {
    let repo = TestRepo::new();
    assert!(repo.cw_ok(&["new", "p", "--no-term"]));
    assert!(repo.cw_ok(&["new", "q", "--no-term"]));

    let out = repo.cw(&["delete", "p", "q", "--dry-run"]);
    assert!(out.status.success());
    let stdout = String::from_utf8_lossy(&out.stdout);
    assert!(
        stdout.contains("dry-run; nothing deleted"),
        "stdout: {stdout}"
    );

    let list = repo.cw_stdout(&["list"]);
    assert!(
        list.contains(&worktree_row("p")),
        "p should still be listed: {list}"
    );
    assert!(
        list.contains(&worktree_row("q")),
        "q should still be listed: {list}"
    );
}

#[test]
fn test_delete_keep_branch_applies_to_all_targets() {
    let repo = TestRepo::new();
    assert!(repo.cw_ok(&["new", "k1", "--no-term"]));
    assert!(repo.cw_ok(&["new", "k2", "--no-term"]));

    let out = repo.cw(&["delete", "k1", "k2", "--keep-branch"]);
    assert!(
        out.status.success(),
        "stderr: {}",
        String::from_utf8_lossy(&out.stderr)
    );

    let branches = repo.git_stdout(&["branch", "--list"]);
    assert!(branches.contains("k1"), "branches: {branches}");
    assert!(branches.contains("k2"), "branches: {branches}");

    // worktrees themselves should be gone
    let list = repo.cw_stdout(&["list"]);
    assert!(
        !list.contains(&worktree_row("k1")),
        "list still mentions k1: {list}"
    );
    assert!(
        !list.contains(&worktree_row("k2")),
        "list still mentions k2: {list}"
    );
}

#[test]
fn test_delete_interactive_conflicts_with_positional_at_runtime() {
    let repo = TestRepo::new();
    let out = repo.cw(&["delete", "-i", "some-target"]);
    assert!(
        !out.status.success(),
        "stdout: {} stderr: {}",
        String::from_utf8_lossy(&out.stdout),
        String::from_utf8_lossy(&out.stderr)
    );
    let err = String::from_utf8_lossy(&out.stderr);
    assert!(
        err.contains("cannot") || err.contains("conflict"),
        "expected conflict error, got: {err}"
    );
}

#[test]
fn test_delete_no_args_still_uses_legacy_path() {
    // Running `gw delete` from *inside* a worktree should still delete the
    // current worktree. This exercises the legacy path.
    let repo = TestRepo::new();
    let wt_path = repo.create_worktree("inside-me");

    // Run `gw delete` with cwd = the worktree path, using cw_at
    let out = TestRepo::cw_at(&wt_path, &["delete"]);
    assert!(
        out.status.success(),
        "stderr: {}",
        String::from_utf8_lossy(&out.stderr)
    );

    let list = repo.cw_stdout(&["list"]);
    assert!(
        !list.contains(&worktree_row("inside-me")),
        "list still mentions inside-me: {list}"
    );
}