git-repos 0.1.0

Git Repos
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

#!/usr/bin/env python3

import re

import git
import pytest
from helpers import (
    EmptyDir,
    TempGitFileRemote,
    TempGitRepositoryWorktree,
    funcname,
    grm,
    shell,
)


def test_worktree_fetch():
    with TempGitRepositoryWorktree.get(funcname()) as (base_dir, root_commit):
        with TempGitFileRemote() as (remote_path, _remote_sha):
            shell(
                f"""
                cd {base_dir}
                git --git-dir .git-main-working-tree remote add upstream file://{remote_path}
                git --git-dir .git-main-working-tree push --force upstream master:master
            """
            )

            cmd = grm(["wt", "fetch"], cwd=base_dir)
            assert cmd.returncode == 0

            repo = git.Repo(f"{base_dir}/.git-main-working-tree")
            assert repo.commit("master").hexsha == repo.commit("origin/master").hexsha
            assert repo.commit("master").hexsha == repo.commit("upstream/master").hexsha

            with EmptyDir() as tmp:
                shell(
                    f"""
                    cd {tmp}
                    git clone {remote_path} tmp
                    cd tmp
                    echo change > mychange-remote
                    git add mychange-remote
                    git commit -m "change-remote"
                    git push origin HEAD:master
                """
                )
                remote_commit = git.Repo(f"{tmp}/tmp").commit("master").hexsha

            assert repo.commit("master").hexsha == repo.commit("origin/master").hexsha
            assert repo.commit("master").hexsha == repo.commit("upstream/master").hexsha

            cmd = grm(["wt", "fetch"], cwd=base_dir)
            assert cmd.returncode == 0

            assert repo.commit("master").hexsha == repo.commit("origin/master").hexsha
            assert repo.commit("master").hexsha == root_commit
            assert repo.commit("upstream/master").hexsha == remote_commit


@pytest.mark.parametrize("rebase", [True, False])
@pytest.mark.parametrize("ffable", [True, False])
@pytest.mark.parametrize("has_changes", [True, False])
@pytest.mark.parametrize("stash", [True, False])
def test_worktree_pull(rebase, ffable, has_changes, stash):
    with TempGitRepositoryWorktree.get(funcname()) as (base_dir, root_commit):
        with TempGitFileRemote() as (remote_path, _remote_sha):
            shell(
                f"""
                cd {base_dir}
                git --git-dir .git-main-working-tree remote add upstream file://{remote_path}
                git --git-dir .git-main-working-tree push --force upstream master:master
            """
            )

            repo = git.Repo(f"{base_dir}/.git-main-working-tree")
            assert repo.commit("origin/master").hexsha == repo.commit("master").hexsha
            assert repo.commit("upstream/master").hexsha == repo.commit("master").hexsha

            with EmptyDir() as tmp:
                shell(
                    f"""
                    cd {tmp}
                    git clone {remote_path} tmp
                    cd tmp
                    git checkout origin/master
                    echo change > mychange-remote
                    git add mychange-remote
                    git commit -m "change-remote"
                    git push origin HEAD:master
                """
                )
                remote_commit = git.Repo(f"{tmp}/tmp").commit("HEAD").hexsha

                grm(["wt", "add", "master", "--track", "upstream/master"], cwd=base_dir)

                repo = git.Repo(f"{base_dir}/master")
                if not ffable:
                    shell(
                        f"""
                        cd {base_dir}/master
                        echo change > mychange
                        git add mychange
                        git commit -m "local-commit-in-master"
                    """
                    )

                if has_changes:
                    shell(
                        f"""
                        cd {base_dir}/master
                        echo change >> root-commit-in-worktree-1
                        echo uncommitedchange > uncommitedchange
                    """
                    )

                args = ["wt", "pull"]
                if rebase:
                    args += ["--rebase"]
                if stash:
                    args += ["--stash"]
                cmd = grm(args, cwd=base_dir)
                if has_changes and not stash:
                    assert cmd.returncode != 0
                    assert re.match(r".*master.*contains changes.*", cmd.stderr)
                else:
                    assert repo.commit("upstream/master").hexsha == remote_commit
                    assert repo.commit("origin/master").hexsha == root_commit
                    assert (
                        repo.commit("master").hexsha
                        != repo.commit("origin/master").hexsha
                    )
                    if has_changes:
                        assert ["uncommitedchange"] == repo.untracked_files
                        assert repo.is_dirty()
                    else:
                        assert not repo.is_dirty()

                    if not rebase:
                        if ffable:
                            assert cmd.returncode == 0
                            assert (
                                repo.commit("master").hexsha
                                != repo.commit("origin/master").hexsha
                            )
                            assert (
                                repo.commit("master").hexsha
                                == repo.commit("upstream/master").hexsha
                            )
                            assert (
                                repo.commit("upstream/master").hexsha == remote_commit
                            )
                        else:
                            assert cmd.returncode != 0
                            assert "cannot be fast forwarded" in cmd.stderr
                            assert (
                                repo.commit("master").hexsha
                                != repo.commit("origin/master").hexsha
                            )
                            assert repo.commit("master").hexsha != remote_commit
                            assert (
                                repo.commit("upstream/master").hexsha == remote_commit
                            )
                    else:
                        assert cmd.returncode == 0
                        if ffable:
                            assert (
                                repo.commit("master").hexsha
                                != repo.commit("origin/master").hexsha
                            )
                            assert (
                                repo.commit("master").hexsha
                                == repo.commit("upstream/master").hexsha
                            )
                            assert (
                                repo.commit("upstream/master").hexsha == remote_commit
                            )
                        else:
                            assert (
                                repo.commit("master").message.strip()
                                == "local-commit-in-master"
                            )
                            assert repo.commit("master~1").hexsha == remote_commit