gwtr 0.6.0

A simple Git worktree manager
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

mod common;

use common::TestHelper;
use std::fs;

#[test]
fn test_add_creates_worktree_at_correct_location() {
    // Setup: Create a test git repository
    let helper = TestHelper::new().expect("Failed to create test helper");

    // Create initial commit (worktree requires at least one commit)
    fs::write(helper.repo_path.join("README.md"), "# Test Repo").unwrap();
    std::process::Command::new("git")
        .args(["add", "."])
        .current_dir(&helper.repo_path)
        .output()
        .unwrap();
    std::process::Command::new("git")
        .args(["commit", "-m", "Initial commit"])
        .current_dir(&helper.repo_path)
        .output()
        .unwrap();

    // Get the repository name for testing
    let repo_dir = helper.repo_path.file_name().unwrap().to_str().unwrap();

    // Run gwtr add to create a worktree
    let output = helper.run_gwtr(&["add", "feature-x"]);

    // Should succeed
    assert!(
        output.status.success(),
        "add command should succeed: stderr: {}",
        String::from_utf8_lossy(&output.stderr)
    );

    // Check that worktree was created at the correct location
    // Should be at ../test-repo_feature-x relative to the repo
    let expected_worktree = helper
        .repo_path
        .parent()
        .unwrap()
        .join(format!("{}_feature-x", repo_dir));

    assert!(
        expected_worktree.exists(),
        "Worktree should be created at {:?}",
        expected_worktree
    );

    // Verify it's a valid git worktree
    assert!(
        expected_worktree.join(".git").exists(),
        "Created directory should be a git worktree"
    );
}

#[test]
fn test_add_creates_worktree_with_new_branch() {
    // Setup
    let helper = TestHelper::new().expect("Failed to create test helper");

    // Create initial commit (worktree requires at least one commit)
    fs::write(helper.repo_path.join("README.md"), "# Test Repo").unwrap();
    std::process::Command::new("git")
        .args(["add", "."])
        .current_dir(&helper.repo_path)
        .output()
        .unwrap();
    std::process::Command::new("git")
        .args(["commit", "-m", "Initial commit"])
        .current_dir(&helper.repo_path)
        .output()
        .unwrap();

    // Run gwtr add
    let output = helper.run_gwtr(&["add", "feature-y"]);

    assert!(
        output.status.success(),
        "add command should succeed: stderr: {}",
        String::from_utf8_lossy(&output.stderr)
    );

    // Get the worktree path
    let repo_dir = helper.repo_path.file_name().unwrap().to_str().unwrap();
    let worktree_path = helper
        .repo_path
        .parent()
        .unwrap()
        .join(format!("{}_feature-y", repo_dir));

    // Check that the worktree is on a new branch
    let branch_output = std::process::Command::new("git")
        .args(["branch", "--show-current"])
        .current_dir(&worktree_path)
        .output()
        .unwrap();

    let branch_name = String::from_utf8_lossy(&branch_output.stdout)
        .trim()
        .to_string();
    assert_eq!(
        branch_name, "feature-y",
        "Worktree should be on branch 'feature-y'"
    );
}

#[test]
fn test_add_fails_if_worktree_already_exists() {
    // Setup
    let helper = TestHelper::new().expect("Failed to create test helper");

    // Create initial commit
    fs::write(helper.repo_path.join("README.md"), "# Test Repo").unwrap();
    std::process::Command::new("git")
        .args(["add", "."])
        .current_dir(&helper.repo_path)
        .output()
        .unwrap();
    std::process::Command::new("git")
        .args(["commit", "-m", "Initial commit"])
        .current_dir(&helper.repo_path)
        .output()
        .unwrap();

    // Create worktree for the first time
    let output = helper.run_gwtr(&["add", "feature-z"]);
    assert!(output.status.success(), "First add should succeed");

    // Try to create the same worktree again
    let output = helper.run_gwtr(&["add", "feature-z"]);

    assert!(
        !output.status.success(),
        "add command should fail when worktree already exists"
    );

    let stderr = String::from_utf8_lossy(&output.stderr);
    assert!(
        stderr.contains("already exists") || stderr.contains("already"),
        "Error message should indicate worktree already exists: {}",
        stderr
    );
}