168 lines
3.2 KiB
Go
168 lines
3.2 KiB
Go
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: "emile@emile.com",
|
|
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")
|
|
}
|
|
}
|