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
|
package git
import (
"testing"
"time"
)
func createBranch(repo *Repository, branch string) error {
head, err := repo.Head()
if err != nil {
return err
}
commit, err := repo.LookupCommit(head.Target())
if err != nil {
return err
}
_, err = repo.CreateBranch(branch, commit, false)
if err != nil {
return err
}
return nil
}
func signature() *Signature {
return &Signature{
Name: "Emile",
Email: "[email protected]",
When: time.Now(),
}
}
func commitSomething(repo *Repository, something string) (*Oid, error) {
head, err := repo.Head()
if err != nil {
return nil, err
}
headCommit, err := repo.LookupCommit(head.Target())
if err != nil {
return nil, err
}
index, err := NewIndex()
if err != nil {
return nil, err
}
defer index.Free()
blobOID, err := repo.CreateBlobFromBuffer([]byte("fou"))
if err != nil {
return nil, err
}
entry := &IndexEntry{
Mode: FilemodeBlob,
Id: blobOID,
Path: something,
}
if err := index.Add(entry); err != nil {
return nil, err
}
newTreeOID, err := index.WriteTreeTo(repo)
if err != nil {
return nil, err
}
newTree, err := repo.LookupTree(newTreeOID)
if err != nil {
return nil, err
}
if err != nil {
return nil, err
}
commit, err := repo.CreateCommit("HEAD", signature(), signature(), "Test rebase onto, Baby! "+something, newTree, headCommit)
if err != nil {
return nil, err
}
opts := &CheckoutOpts{
Strategy: CheckoutRemoveUntracked | CheckoutForce,
}
err = repo.CheckoutIndex(index, opts)
if err != nil {
return nil, err
}
return commit, nil
}
func entryExists(repo *Repository, file string) bool {
head, err := repo.Head()
if err != nil {
return false
}
headCommit, err := repo.LookupCommit(head.Target())
if err != nil {
return false
}
headTree, err := headCommit.Tree()
if err != nil {
return false
}
_, err = headTree.EntryByPath(file)
return err == nil
}
func TestRebaseOnto(t *testing.T) {
repo := createTestRepo(t)
defer cleanupTestRepo(t, repo)
fileInMaster := "something"
fileInEmile := "something else"
// Seed master
seedTestRepo(t, repo)
// Create a new branch from master
err := createBranch(repo, "emile")
checkFatal(t, err)
// Create a commit in master
_, err = commitSomething(repo, fileInMaster)
checkFatal(t, err)
// Switch to this emile
err = repo.SetHead("refs/heads/emile")
checkFatal(t, err)
// Check master commit is not in emile branch
if entryExists(repo, fileInMaster) {
t.Fatal("something entry should not exist in emile branch")
}
// Create a commit in emile
_, err = commitSomething(repo, fileInEmile)
checkFatal(t, err)
// Rebase onto master
master, err := repo.LookupBranch("master", BranchLocal)
branch, err := repo.AnnotatedCommitFromRef(master.Reference)
checkFatal(t, err)
rebase, err := repo.RebaseInit(nil, nil, branch, nil)
checkFatal(t, err)
defer rebase.Free()
operation, err := rebase.Next()
checkFatal(t, err)
commit, err := repo.LookupCommit(operation.ID)
checkFatal(t, err)
err = rebase.Commit(operation.ID, signature(), signature(), commit.Message())
checkFatal(t, err)
rebase.Finish()
// Check master commit is now also in emile branch
if !entryExists(repo, fileInMaster) {
t.Fatal("something entry should now exist in emile branch")
}
}
|
