git-worktree-manager 0.0.31

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
158
159

/// End-to-end workflow tests.
/// Ported from tests/e2e/test_workflows.py (13 tests).
mod common;

use common::TestRepo;

#[test]
fn test_full_workflow_new_list_delete() {
    let repo = TestRepo::new();

    // Create
    assert!(repo.cw_ok(&["new", "e2e-test", "--no-term"]));

    // List shows it
    let list = repo.cw_stdout(&["list"]);
    assert!(list.contains("e2e-test"));

    // Delete
    assert!(repo.cw_ok(&["delete", "e2e-test"]));

    // Gone
    let list = repo.cw_stdout(&["list"]);
    assert!(!list.contains("e2e-test"));
}

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

    let status = repo.cw_stdout(&["status"]);
    assert!(
        status.contains("Worktrees") || status.contains("worktree"),
        "status should show worktree info"
    );
}

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

    let tree = repo.cw_stdout(&["tree"]);
    assert!(tree.contains("tree-test"));
    assert!(tree.contains("base repository"));
}

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

    let list = repo.cw_stdout(&["list"]);
    assert!(list.contains("feat-a"));
    assert!(list.contains("feat-b"));
    assert!(list.contains("feat-c"));

    // Clean up one
    assert!(repo.cw_ok(&["delete", "feat-b"]));
    let list = repo.cw_stdout(&["list"]);
    assert!(!list.contains("feat-b"));
    assert!(list.contains("feat-a"));
    assert!(list.contains("feat-c"));
}

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

    // Worktree removed but branch should still exist
    let list = repo.cw_stdout(&["list"]);
    assert!(!list.contains("keep-branch-test"));
}

#[test]
fn test_workflow_doctor_after_operations() {
    let repo = TestRepo::new();
    assert!(repo.cw_ok(&["new", "doc-test", "--no-term"]));
    let doctor = repo.cw_stdout(&["doctor"]);
    assert!(doctor.contains("Health Check"));
    assert!(doctor.contains("Git version"));
}

#[test]
fn test_workflow_config_show() {
    let repo = TestRepo::new();
    let output = repo.cw_stdout(&["config", "show"]);
    assert!(output.contains("AI Tool:"));
    assert!(output.contains("Config file:"));
}

#[test]
fn test_workflow_config_list_presets() {
    let repo = TestRepo::new();
    let output = repo.cw_stdout(&["config", "list-presets"]);
    assert!(output.contains("claude"));
    assert!(output.contains("no-op"));
}

#[test]
fn test_workflow_export_import_roundtrip() {
    let repo = TestRepo::new();
    let export_path = repo.path().join("export.json");

    assert!(repo.cw_ok(&["export", "--output", export_path.to_str().unwrap()]));
    assert!(export_path.exists());

    // Import preview
    let output = repo.cw(&["import", export_path.to_str().unwrap()]);
    assert!(output.status.success());
    let stdout = String::from_utf8_lossy(&output.stdout);
    assert!(stdout.contains("Preview"));
}

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

    let output = repo.cw(&["sync", "sync-wf"]);
    assert!(output.status.success());
}

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

    let output = repo.cw(&["clean", "--merged", "--dry-run"]);
    assert!(output.status.success());
}

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

    let output = repo.cw_stdout(&["_path", "--list-branches"]);
    assert!(output.contains("main") || output.contains("path-test"));
}

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

    let output = repo.cw(&["backup", "create", "backup-wf"]);
    assert!(output.status.success());

    let list = repo.cw_stdout(&["backup", "list"]);
    assert!(
        list.contains("backup-wf") || list.contains("Backup"),
        "Should list the backup"
    );
}