Git designed for AI agents.
package localrepo
import (
"context"
"fmt"
"os"
"strings"
"testing"
"time"
"github.com/feder-cr/git-ai/internal/featureflag"
"github.com/feder-cr/git-ai/internal/git"
"github.com/feder-cr/git-ai/internal/git/gittest"
"github.com/feder-cr/git-ai/internal/helper"
"github.com/feder-cr/git-ai/internal/structerr"
"github.com/feder-cr/git-ai/internal/testhelper"
"github.com/feder-cr/git-ai/internal/testhelper/testcfg"
"github.com/feder-cr/git-ai/proto/go/gitalypb"
"github.com/stretchr/testify/require"
"google.golang.org/protobuf/types/known/timestamppb"
)
func TestRebase(t *testing.T) {
t.Parallel()
testhelper.NewFeatureSets(featureflag.GPGSigning).Run(t, testRebase)
}
func testRebase(t *testing.T, ctx context.Context) {
cfg := testcfg.Build(t)
defaultCommitter := git.Signature{
Name: gittest.DefaultCommitterName,
Email: gittest.DefaultCommitterMail,
When: gittest.DefaultCommitTime,
}
type setupData struct {
upstream string
branch string
expectedCommitsAhead int
expectedTreeEntries []gittest.TreeEntry
expectedErr error
}
// Write git-log(1) --graph to $REBASE_TEST_GRAPHS
writeGraph := func(t *testing.T, repoPath, title string, data setupData, result git.ObjectID) {}
if graphFilename := os.Getenv("REBASE_TEST_GRAPHS"); graphFilename != "" {
graphFile, err := os.Create(graphFilename)
require.NoError(t, err)
defer graphFile.Close()
t.Logf("Writing git graphs to: %s", graphFilename)
writeGraph = func(t *testing.T, repoPath, title string, data setupData, result git.ObjectID) {
allowFail := gittest.ExecConfig{ExpectedExitCode: 128}
writeOneGraph := func(phase string, refs ...string) {
fmt.Fprintf(graphFile, "\n=== %s [%s] ===\n", title, phase)
args := []string{"-C", repoPath, "log", "--graph", "--oneline", "--format=%(decorate:prefix=,suffix=,tag=)", "--decorate-refs=refs/tags/"}
args = append(args, refs...)
output := gittest.ExecOpts(t, cfg, allowFail, args...)
_, err := graphFile.WriteString(strings.ReplaceAll(string(output), "0-", ""))
require.NoError(t, err)
}
// Add tags for printing the graph.
// Prepend with '0-' to have them sorted first.
// Use ExecOpts so invalid revisions (e.g. "does-not-exist") don't fatal.
gittest.ExecOpts(t, cfg, allowFail, "-C", repoPath, "update-ref", "refs/tags/0-upstream", data.upstream)
gittest.ExecOpts(t, cfg, allowFail, "-C", repoPath, "update-ref", "refs/tags/0-branch", data.branch)
writeOneGraph("BEFORE", "refs/tags/0-upstream", "refs/tags/0-branch")
if data.expectedErr != nil {
return
}
gittest.Exec(t, cfg, "-C", repoPath, "update-ref", "refs/tags/0-result", result.String())
// Build a map from commit message to tag name for existing tags.
commitMessage := func(oid string) string {
return strings.TrimSpace(string(gittest.Exec(t, cfg, "-C", repoPath, "log", "-1", "--format=%s", oid)))
}
msgToTag := map[string]string{}
for _, ref := range gittest.GetReferences(t, cfg, repoPath, gittest.GetReferencesConfig{Patterns: []string{"refs/tags/"}}) {
if strings.HasPrefix(ref.Name.String(), "refs/tags/0-") {
continue
}
msgToTag[commitMessage(ref.Target)] = ref.Name.String()
}
// For each rebased commit, find its original tag by matching
// commit message and create a prime (') version of the tag.
for commit := range strings.FieldsSeq(string(gittest.Exec(t, cfg, "-C", repoPath, "rev-list", data.upstream+".."+result.String()))) {
if tagName, ok := msgToTag[commitMessage(commit)]; ok {
gittest.Exec(t, cfg, "-C", repoPath, "update-ref", tagName+"'", commit)
}
}
writeOneGraph("AFTER", "refs/tags/0-upstream", "refs/tags/0-result", "--decorate-refs-exclude=refs/tags/0-branch")
}
}
testCases := []struct {
desc string
setup func(t *testing.T, repoPath string) setupData
}{
{
desc: "Single commit rebase",
setup: func(t *testing.T, repoPath string) setupData {
// Commit r1 should be picked when rebasing:
//
// BEFORE: AFTER:
// * l2, upstream * r1', result
// | * r1, branch * l2, upstream
// |/ * l1
// * l1
l1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l1: add foo"),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/l1"),
)
l2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l2: add bar"),
gittest.WithParents(l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/l2"),
)
r1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r1: edit foo"),
gittest.WithParents(l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/r1"),
)
return setupData{
upstream: l2.String(),
branch: r1.String(),
expectedCommitsAhead: 1,
expectedTreeEntries: []gittest.TreeEntry{
{
Mode: "100644",
Path: "bar",
Content: "bar",
},
{
Mode: "100644",
Path: "foo",
Content: "foo edited",
},
},
}
},
},
{
desc: "Multiple commits rebase",
setup: func(t *testing.T, repoPath string) setupData {
// Commit r1, r2, r3 should be picked when rebasing:
//
// BEFORE: AFTER:
// * l2, upstream * r3', result
// | * r3, branch * r2'
// | * r2 * r1'
// | * r1 * l2, upstream
// |/ * l1
// * l1
l1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l1: add foo"),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/l1"),
)
l2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l2: add bar"),
gittest.WithParents(l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/l2"),
)
r1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r1: edit foo"),
gittest.WithParents(l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/r1"),
)
r2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r2: edit foo again"),
gittest.WithParents(r1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited\nfoo edited again"},
),
gittest.WithReference("refs/tags/r2"),
)
r3 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r3: add baz"),
gittest.WithParents(r2),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "baz", Mode: "100644", Content: "baz"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited\nfoo edited again"},
),
gittest.WithReference("refs/tags/r3"),
)
return setupData{
upstream: l2.String(),
branch: r3.String(),
expectedCommitsAhead: 3,
expectedTreeEntries: []gittest.TreeEntry{
{
Mode: "100644",
Path: "bar",
Content: "bar",
},
{
Mode: "100644",
Path: "baz",
Content: "baz",
},
{
Mode: "100644",
Path: "foo",
Content: "foo edited\nfoo edited again",
},
},
}
},
},
{
desc: "Branch zero commits behind",
setup: func(t *testing.T, repoPath string) setupData {
// Fast forward to l3 when rebasing l3 to l2:
//
// BEFORE: AFTER:
// * l3, branch * l3', l3, result
// * l2, upstream * l2, upstream
// * l1 * l1
l1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l1: add foo"),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/l1"),
)
l2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l2: add bar"),
gittest.WithParents(l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/l2"),
)
l3 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l3: edit foo"),
gittest.WithParents(l2),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/l3"),
)
return setupData{
upstream: l2.String(),
branch: l3.String(),
expectedCommitsAhead: 1,
expectedTreeEntries: []gittest.TreeEntry{
{
Mode: "100644",
Path: "bar",
Content: "bar",
},
{
Mode: "100644",
Path: "foo",
Content: "foo edited",
},
},
}
},
},
{
desc: "Branch zero commits ahead",
setup: func(t *testing.T, repoPath string) setupData {
// Fast forward to l3 when rebasing l2 to l3:
//
// BEFORE: AFTER:
// * l3, upstream * l3, upstream, result
// * l2, branch * l2
// * l1 * l1
l1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l1: add foo"),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/l1"),
)
l2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l2: add bar"),
gittest.WithParents(l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/l2"),
)
l3 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l3: edit foo"),
gittest.WithParents(l2),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/l3"),
)
return setupData{
upstream: l3.String(),
branch: l2.String(),
expectedCommitsAhead: 0,
expectedTreeEntries: []gittest.TreeEntry{
{
Mode: "100644",
Path: "bar",
Content: "bar",
},
{
Mode: "100644",
Path: "foo",
Content: "foo edited",
},
},
}
},
},
{
desc: "Partially merged branch detected by git-rev-list",
setup: func(t *testing.T, repoPath string) setupData {
// Commit r1 should be filtered out by git-rev-list because it introduces the
// same change as l2. Only commit r2 should be picked:
//
// BEFORE: AFTER:
// * l2, upstream * r2', result
// | * r2, branch * l2, upstream
// | * r1 * l1
// |/
// * l1
l1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l1: add foo"),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/l1"),
)
l2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l2: edit foo"),
gittest.WithParents(l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/l2"),
)
r1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r1: edit foo"),
gittest.WithParents(l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/r1"),
)
r2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r2: edit foo again"),
gittest.WithParents(r1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited\nfoo edited again"},
),
gittest.WithReference("refs/tags/r2"),
)
return setupData{
upstream: l2.String(),
branch: r2.String(),
expectedCommitsAhead: 1,
expectedTreeEntries: []gittest.TreeEntry{
{
Mode: "100644",
Path: "foo",
Content: "foo edited\nfoo edited again",
},
},
}
},
},
{
desc: "Partially merged branch detected by git-merge-tree",
setup: func(t *testing.T, repoPath string) setupData {
// Commit r1 can not be filtered out by git-rev-list because the changes it
// introduces is a subset but not the same as l2, so it should be filtered
// out by git-merge-tree. Only commit r2 should be picked:
//
// BEFORE: AFTER:
// * l2, upstream * r2', result
// | * r2, branch * l2, upstream
// | * r1 * l1
// |/
// * l1
l1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l1: add foo"),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/l1"),
)
l2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l2: add bar and edit foo"),
gittest.WithParents(l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/l2"),
)
r1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r1: edit foo"),
gittest.WithParents(l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/r1"),
)
r2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r2: edit foo again"),
gittest.WithParents(r1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited\nfoo edited again"},
),
gittest.WithReference("refs/tags/r2"),
)
return setupData{
upstream: l2.String(),
branch: r2.String(),
expectedCommitsAhead: 1,
expectedTreeEntries: []gittest.TreeEntry{
{
Mode: "100644",
Path: "bar",
Content: "bar",
},
{
Mode: "100644",
Path: "foo",
Content: "foo edited\nfoo edited again",
},
},
}
},
},
{
desc: "Rebase commit with no parents",
setup: func(t *testing.T, repoPath string) setupData {
// Commit r1 should be picked when rebasing but it has no parents, we need to
// enable --allow-unrelated-histories for git-merge-tree:
//
// BEFORE: AFTER:
// * l2, upstream * r1', result
// | * r2, branch * l2, upstream
// | |\ * l1
// | |/
// |/|
// * | l1
// /
// * r1
l1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l1: add foo"),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/l1"),
)
l2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l2: edit foo"),
gittest.WithParents(l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/l2"),
)
r1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r1: add bar"),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
),
gittest.WithReference("refs/tags/r1"),
)
r2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r2: merge l1"),
gittest.WithParents(r1, l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/r2"),
)
return setupData{
upstream: l2.String(),
branch: r2.String(),
expectedCommitsAhead: 1,
expectedTreeEntries: []gittest.TreeEntry{
{
Mode: "100644",
Path: "bar",
Content: "bar",
},
{
Mode: "100644",
Path: "foo",
Content: "foo edited",
},
},
}
},
},
{
desc: "Rebase commit with no parents and its changes already applied",
setup: func(t *testing.T, repoPath string) setupData {
// Commit r1 should be ignored when rebasing because its changes have already
// been applied:
//
// BEFORE: AFTER:
// * l2, upstream * l2, upstream, result
// | * r2, branch * l1
// | |\
// | |/
// |/|
// * | l1
// /
// * r1
l1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l1: add foo"),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/l1"),
)
l2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l2: add bar and edit foo"),
gittest.WithParents(l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/l2"),
)
r1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r1: add bar"),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
),
gittest.WithReference("refs/tags/r1"),
)
r2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r2: merge l1"),
gittest.WithParents(r1, l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/r2"),
)
return setupData{
upstream: l2.String(),
branch: r2.String(),
expectedCommitsAhead: 0,
expectedTreeEntries: []gittest.TreeEntry{
{
Mode: "100644",
Path: "bar",
Content: "bar",
},
{
Mode: "100644",
Path: "foo",
Content: "foo edited",
},
},
}
},
},
{
desc: "Rebase commit with no parents and points to empty tree",
setup: func(t *testing.T, repoPath string) setupData {
// Commit r1 should be picked because itself is empty:
//
// BEFORE: AFTER:
// * l2, upstream * r1', result
// | * r2, branch * l2, upstream
// | |\ * l1
// | |/
// |/|
// * | l1
// /
// * r1
l1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l1: add foo"),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/l1"),
)
l2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l2: add bar and edit foo"),
gittest.WithParents(l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/l2"),
)
r1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r1: empty"),
gittest.WithReference("refs/tags/r1"),
)
r2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r2: merge l1"),
gittest.WithParents(r1, l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/r2"),
)
return setupData{
upstream: l2.String(),
branch: r2.String(),
expectedCommitsAhead: 1,
expectedTreeEntries: []gittest.TreeEntry{
{
Mode: "100644",
Path: "bar",
Content: "bar",
},
{
Mode: "100644",
Path: "foo",
Content: "foo edited",
},
},
}
},
},
{
desc: "Keep originally empty commit",
setup: func(t *testing.T, repoPath string) setupData {
// Commit r1, r2 should be picked. Commit r2 is an empty commit originally, it
// should not be filtered out:
//
// BEFORE: AFTER:
// * l2, upstream * r2', result
// | * r2, branch * r1'
// | * r1 * l2, upstream
// |/ * l1
// * l1
l1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l1: add foo"),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/l1"),
)
l2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l2: add bar"),
gittest.WithParents(l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/l2"),
)
r1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r1: edit foo"),
gittest.WithParents(l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/r1"),
)
r2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r2: empty commit"),
gittest.WithParents(r1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/r2"),
)
return setupData{
upstream: l2.String(),
branch: r2.String(),
expectedCommitsAhead: 2,
expectedTreeEntries: []gittest.TreeEntry{
{
Mode: "100644",
Path: "bar",
Content: "bar",
},
{
Mode: "100644",
Path: "foo",
Content: "foo edited",
},
},
}
},
},
{
desc: "All changes applied",
setup: func(t *testing.T, repoPath string) setupData {
// Commit r1 should be ignored because all its changes are a subset of l2:
//
// BEFORE: AFTER:
// * l2, upstream * l2, upstream, result
// | * r1, branch * l1
// |/
// * l1
l1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l1: add foo"),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/l1"),
)
l2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l2: add bar and edit foo"),
gittest.WithParents(l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/l2"),
)
r1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r1: edit foo"),
gittest.WithParents(l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/r1"),
)
return setupData{
upstream: l2.String(),
branch: r1.String(),
expectedCommitsAhead: 0,
expectedTreeEntries: []gittest.TreeEntry{
{
Mode: "100644",
Path: "bar",
Content: "bar",
},
{
Mode: "100644",
Path: "foo",
Content: "foo edited",
},
},
}
},
},
{
desc: "With merge commit ignored",
setup: func(t *testing.T, repoPath string) setupData {
// Commit r2 should be ignored because it is a merge commit. Only r1 should be
// picked:
//
// BEFORE: AFTER:
// * l3, upstream * r1', result
// | * r2, branch * l3, upstream
// | |\ * l2
// | |/ * l1
// |/|
// * | l2
// | * r1
// |/
// * l1
l1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l1: add foo"),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/l1"),
)
l2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l2: add bar"),
gittest.WithParents(l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/l2"),
)
l3 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l3: edit bar"),
gittest.WithParents(l2),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar edited"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/l3"),
)
r1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r1: edit foo"),
gittest.WithParents(l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/r1"),
)
r2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r2: merge l2"),
gittest.WithParents(r1, l2),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/r2"),
)
return setupData{
upstream: l3.String(),
branch: r2.String(),
expectedCommitsAhead: 1,
expectedTreeEntries: []gittest.TreeEntry{
{
Mode: "100644",
Path: "bar",
Content: "bar edited",
},
{
Mode: "100644",
Path: "foo",
Content: "foo edited",
},
},
}
},
},
{
desc: "Rebase with criss-cross commit history",
setup: func(t *testing.T, repoPath string) setupData {
// We set up the following history with a criss-cross merge so that the
// merge base becomes ambiguous:
//
// BEFORE: AFTER:
// * l3, upstream * l3, upstream, result
// |\ |\
// | | * r3, branch | * r2
// | |/| | |\
// | |/ | * | r1
// |/| * | | l2
// * | l2 | |/
// | * r2 |/|
// | |\ * | l1
// | |/ |/
// |/| * base
// * | l1
// | * r1
// |/
// * base
base := gittest.WriteCommit(t, cfg, repoPath, gittest.WithMessage("base"), gittest.WithReference("refs/tags/base"))
l1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l1: add left"),
gittest.WithParents(base),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "left", Mode: "100644", Content: "l1"},
),
gittest.WithReference("refs/tags/l1"),
)
r1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r1: add right"),
gittest.WithParents(base),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "right", Mode: "100644", Content: "r1"},
),
gittest.WithReference("refs/tags/r1"),
)
l2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l2: edit left"),
gittest.WithParents(l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "left", Mode: "100644", Content: "l1\nl2"},
),
gittest.WithReference("refs/tags/l2"),
)
r2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r2: merge l1"),
gittest.WithParents(r1, l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "left", Mode: "100644", Content: "l1"},
gittest.TreeEntry{Path: "right", Mode: "100644", Content: "r1"},
),
gittest.WithReference("refs/tags/r2"),
)
// Criss-cross merges.
l3 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l3: merge r2"),
gittest.WithParents(l2, r2),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "left", Mode: "100644", Content: "l1\nl2"},
gittest.TreeEntry{Path: "right", Mode: "100644", Content: "r1"},
),
gittest.WithReference("refs/tags/l3"),
)
r3 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r3: merge l2"),
gittest.WithParents(r2, l2),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "left", Mode: "100644", Content: "l1\nl2"},
gittest.TreeEntry{Path: "right", Mode: "100644", Content: "r1"},
),
gittest.WithReference("refs/tags/r3"),
)
return setupData{
upstream: l3.String(),
branch: r3.String(),
expectedCommitsAhead: 0,
expectedTreeEntries: []gittest.TreeEntry{
{
Mode: "100644",
Path: "left",
Content: "l1\nl2",
},
{
Mode: "100644",
Path: "right",
Content: "r1",
},
},
}
},
},
{
desc: "Rebase with conflict",
setup: func(t *testing.T, repoPath string) setupData {
// Commit l2 and r1 have content conflicts (error, no AFTER):
//
// BEFORE:
// * l2, upstream
// | * r1, branch
// |/
// * l1
blob0 := gittest.WriteBlob(t, cfg, repoPath, []byte("foo"))
l1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l1: add foo"),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", OID: blob0},
),
gittest.WithReference("refs/tags/l1"),
)
blob1 := gittest.WriteBlob(t, cfg, repoPath, []byte("foo edited by upstream"))
l2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l2: edit foo"),
gittest.WithParents(l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", OID: blob1},
),
gittest.WithReference("refs/tags/l2"),
)
blob2 := gittest.WriteBlob(t, cfg, repoPath, []byte("foo edited by branch"))
r1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r1: edit foo"),
gittest.WithParents(l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", OID: blob2},
),
gittest.WithReference("refs/tags/r1"),
)
return setupData{
upstream: l2.String(),
branch: r1.String(),
expectedErr: structerr.NewInternal("rebase using merge-tree: %w", &RebaseConflictError{
Commit: r1.String(),
ConflictError: &MergeTreeConflictError{
ConflictingFileInfo: []ConflictingFileInfo{
{
FileName: "foo",
OID: blob0,
Stage: MergeStageAncestor,
Mode: 0o100644,
},
{
FileName: "foo",
OID: blob1,
Stage: MergeStageOurs,
Mode: 0o100644,
},
{
FileName: "foo",
OID: blob2,
Stage: MergeStageTheirs,
Mode: 0o100644,
},
},
ConflictInfoMessage: []ConflictInfoMessage{
{
Paths: []string{"foo"},
Type: "Auto-merging",
Message: "Auto-merging foo\n",
},
{
Paths: []string{"foo"},
Type: "CONFLICT (contents)",
Message: "CONFLICT (content): Merge conflict in foo\n",
},
},
},
}),
}
},
},
{
desc: "Orphaned branch",
setup: func(t *testing.T, repoPath string) setupData {
// Commit l1 and r1 has no related histories, so we can not rebase r1
// onto l1:
//
// l1
// o upstream
//
// BEFORE:
// * l1, upstream
// * r1, branch
l1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l1: add foo"),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/l1"),
)
r1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l2: add bar"),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
),
gittest.WithReference("refs/tags/r1"),
)
return setupData{
upstream: l1.String(),
branch: r1.String(),
expectedErr: structerr.NewInternal("get merge-base: exit status 1"),
}
},
},
{
desc: "Middle commit becomes empty after rebase",
setup: func(t *testing.T, repoPath string) setupData {
// Commit r2 introduces the same change as l2, so it becomes empty
// after rebase and should be dropped. r1 and r3 should be picked:
//
// BEFORE: AFTER:
// * l2, upstream * r3', result
// | * r3, branch * r1'
// | * r2 * l2, upstream
// | * r1 * l1
// |/
// * l1
l1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l1: add foo"),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/l1"),
)
l2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l2: add bar"),
gittest.WithParents(l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/l2"),
)
r1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r1: edit foo"),
gittest.WithParents(l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/r1"),
)
r2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r2: add bar"),
gittest.WithParents(r1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/r2"),
)
r3 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r3: add baz"),
gittest.WithParents(r2),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
gittest.TreeEntry{Path: "baz", Mode: "100644", Content: "baz"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/r3"),
)
return setupData{
upstream: l2.String(),
branch: r3.String(),
expectedCommitsAhead: 2,
expectedTreeEntries: []gittest.TreeEntry{
{
Mode: "100644",
Path: "bar",
Content: "bar",
},
{
Mode: "100644",
Path: "baz",
Content: "baz",
},
{
Mode: "100644",
Path: "foo",
Content: "foo edited",
},
},
}
},
},
{
desc: "Conflict on second commit",
setup: func(t *testing.T, repoPath string) setupData {
// Commit r1 cherry-picks cleanly but r2 conflicts with l2:
//
// BEFORE:
// * l2, upstream
// | * r2, branch
// | * r1
// |/
// * l1
l1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l1: add foo and bar"),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/l1"),
)
blob1 := gittest.WriteBlob(t, cfg, repoPath, []byte("bar edited by upstream"))
l2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l2: edit bar"),
gittest.WithParents(l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", OID: blob1},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/l2"),
)
r1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r1: edit foo"),
gittest.WithParents(l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/r1"),
)
blob2 := gittest.WriteBlob(t, cfg, repoPath, []byte("bar edited by branch"))
r2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r2: edit bar"),
gittest.WithParents(r1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", OID: blob2},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/r2"),
)
blob0 := gittest.WriteBlob(t, cfg, repoPath, []byte("bar"))
return setupData{
upstream: l2.String(),
branch: r2.String(),
expectedErr: structerr.NewInternal("rebase using merge-tree: %w", &RebaseConflictError{
Commit: r2.String(),
ConflictError: &MergeTreeConflictError{
ConflictingFileInfo: []ConflictingFileInfo{
{
FileName: "bar",
OID: blob0,
Stage: MergeStageAncestor,
Mode: 0o100644,
},
{
FileName: "bar",
OID: blob1,
Stage: MergeStageOurs,
Mode: 0o100644,
},
{
FileName: "bar",
OID: blob2,
Stage: MergeStageTheirs,
Mode: 0o100644,
},
},
ConflictInfoMessage: []ConflictInfoMessage{
{
Paths: []string{"bar"},
Type: "Auto-merging",
Message: "Auto-merging bar\n",
},
{
Paths: []string{"bar"},
Type: "CONFLICT (contents)",
Message: "CONFLICT (content): Merge conflict in bar\n",
},
},
},
}),
}
},
},
{
desc: "Merge commit in the middle with regular commits after",
setup: func(t *testing.T, repoPath string) setupData {
// Merge commit r2 is dropped, r1 and r3 are picked:
//
// BEFORE: AFTER:
// * l3, upstream * r3', result
// | * r3, branch * r1'
// | * r2 * l3, upstream
// | |\ * l2
// | |/ * l1
// |/|
// * | l2
// | * r1
// |/
// * l1
l1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l1: add foo"),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/l1"),
)
l2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l2: add bar"),
gittest.WithParents(l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/l2"),
)
l3 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l3: edit bar"),
gittest.WithParents(l2),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar edited"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/l3"),
)
r1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r1: edit foo"),
gittest.WithParents(l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/r1"),
)
r2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r2: merge l2"),
gittest.WithParents(r1, l2),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/r2"),
)
r3 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r3: add baz"),
gittest.WithParents(r2),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
gittest.TreeEntry{Path: "baz", Mode: "100644", Content: "baz"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/r3"),
)
return setupData{
upstream: l3.String(),
branch: r3.String(),
expectedCommitsAhead: 2,
expectedTreeEntries: []gittest.TreeEntry{
{
Mode: "100644",
Path: "bar",
Content: "bar edited",
},
{
Mode: "100644",
Path: "baz",
Content: "baz",
},
{
Mode: "100644",
Path: "foo",
Content: "foo edited",
},
},
}
},
},
{
desc: "All cherry-pick equivalents filtered by rev-list",
setup: func(t *testing.T, repoPath string) setupData {
// Both r1 and r2 introduce identical patches to l2 and l3 respectively,
// so git-rev-list --cherry-pick filters them all out. Result is upstream:
//
// BEFORE: AFTER:
// * l3, upstream * l3, upstream, result
// * l2 * l2
// | * r2, branch * l1
// | * r1
// |/
// * l1
l1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l1: add foo"),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/l1"),
)
l2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l2: edit foo"),
gittest.WithParents(l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/l2"),
)
l3 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l3: add bar"),
gittest.WithParents(l2),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/l3"),
)
r1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r1: edit foo"),
gittest.WithParents(l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/r1"),
)
r2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r2: add bar"),
gittest.WithParents(r1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/r2"),
)
return setupData{
upstream: l3.String(),
branch: r2.String(),
expectedCommitsAhead: 0,
expectedTreeEntries: []gittest.TreeEntry{
{
Mode: "100644",
Path: "bar",
Content: "bar",
},
{
Mode: "100644",
Path: "foo",
Content: "foo edited",
},
},
}
},
},
{
desc: "Same commit as upstream and branch",
setup: func(t *testing.T, repoPath string) setupData {
// When upstream and branch are the same commit, merge-base equals
// both, so it fast-forwards to branch (no-op):
//
// BEFORE: AFTER:
// * l1, upstream, branch * l1, upstream, result
l1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l1: add foo"),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/l1"),
)
return setupData{
upstream: l1.String(),
branch: l1.String(),
expectedCommitsAhead: 0,
expectedTreeEntries: []gittest.TreeEntry{
{
Mode: "100644",
Path: "foo",
Content: "foo",
},
},
}
},
},
{
desc: "Evil merge loses extra changes",
setup: func(t *testing.T, repoPath string) setupData {
// An "evil merge" is a merge commit that introduces changes
// beyond what either parent contributes. Since rebase drops
// merge commits (--no-merges), the extra changes from the
// evil merge r2 are silently lost. Only r1 is picked:
//
// BEFORE: AFTER:
// * l2, upstream * r1', result
// | * r2, branch * l2, upstream
// | |\ * l1
// | |/ * base
// |/|
// * | l1
// | * r1
// |/
// * base
base := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("base: add foo"),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/base"),
)
l1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l1: add bar"),
gittest.WithParents(base),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/l1"),
)
l2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l2: edit bar"),
gittest.WithParents(l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar edited"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/l2"),
)
r1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r1: edit foo"),
gittest.WithParents(base),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/r1"),
)
r2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r2: evil merge adds baz"),
gittest.WithParents(r1, l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
gittest.TreeEntry{Path: "baz", Mode: "100644", Content: "evil merge sneaked this in"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/r2"),
)
return setupData{
upstream: l2.String(),
branch: r2.String(),
expectedCommitsAhead: 1,
expectedTreeEntries: []gittest.TreeEntry{
{
Mode: "100644",
Path: "bar",
Content: "bar edited",
},
{
Mode: "100644",
Path: "foo",
Content: "foo edited",
},
},
}
},
},
{
desc: "Branch merges in a third branch",
setup: func(t *testing.T, repoPath string) setupData {
// The branch merges in a third branch (side). The merge
// commit r2 is dropped by --no-merges, but s1 appears in
// rev-list as it is reachable from branch but not upstream.
// Both r1 and s1 are picked:
//
// BEFORE: AFTER:
// * l2, upstream * s1', result
// | * r2, branch * r1'
// | |\ * l2, upstream
// | | * s1 * l1
// | |/
// |/|
// | * r1
// |/
// * l1
l1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l1: add foo"),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/l1"),
)
l2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l2: add bar"),
gittest.WithParents(l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/l2"),
)
r1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r1: edit foo"),
gittest.WithParents(l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/r1"),
)
s1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("s1: add baz"),
gittest.WithParents(l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "baz", Mode: "100644", Content: "baz"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/s1"),
)
r2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r2: merge side branch"),
gittest.WithParents(r1, s1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "baz", Mode: "100644", Content: "baz"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/r2"),
)
return setupData{
upstream: l2.String(),
branch: r2.String(),
expectedCommitsAhead: 2,
expectedTreeEntries: []gittest.TreeEntry{
{
Mode: "100644",
Path: "bar",
Content: "bar",
},
{
Mode: "100644",
Path: "baz",
Content: "baz",
},
{
Mode: "100644",
Path: "foo",
Content: "foo edited",
},
},
}
},
},
{
desc: "Commits before and after merging a third branch",
setup: func(t *testing.T, repoPath string) setupData {
// r1 and r2 are on the branch before the merge, s1 is on a
// side branch. m1 merges s1 into the branch, r3 follows.
// The merge m1 is dropped by --no-merges; r1, r2, s1 and r3
// are all picked:
//
// BEFORE: AFTER:
// * l2, upstream * r3', result
// | * r3, branch * s1'
// | * m1 * r2'
// | |\ * r1'
// | | * s1 * l2, upstream
// | * | r2 * l1
// | |/
// | * r1
// |/
// * l1
l1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l1: add foo"),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/l1"),
)
l2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l2: add bar"),
gittest.WithParents(l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/l2"),
)
r1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r1: edit foo"),
gittest.WithParents(l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/r1"),
)
r2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r2: add baz"),
gittest.WithParents(r1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "baz", Mode: "100644", Content: "baz"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/r2"),
)
s1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("s1: add qux"),
gittest.WithParents(r1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
gittest.TreeEntry{Path: "qux", Mode: "100644", Content: "qux"},
),
gittest.WithReference("refs/tags/s1"),
)
m1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("m1: merge side branch"),
gittest.WithParents(r2, s1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "baz", Mode: "100644", Content: "baz"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
gittest.TreeEntry{Path: "qux", Mode: "100644", Content: "qux"},
),
gittest.WithReference("refs/tags/m1"),
)
r3 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r3: add quux"),
gittest.WithParents(m1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "baz", Mode: "100644", Content: "baz"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
gittest.TreeEntry{Path: "quux", Mode: "100644", Content: "quux"},
gittest.TreeEntry{Path: "qux", Mode: "100644", Content: "qux"},
),
gittest.WithReference("refs/tags/r3"),
)
return setupData{
upstream: l2.String(),
branch: r3.String(),
expectedCommitsAhead: 4,
expectedTreeEntries: []gittest.TreeEntry{
{
Mode: "100644",
Path: "bar",
Content: "bar",
},
{
Mode: "100644",
Path: "baz",
Content: "baz",
},
{
Mode: "100644",
Path: "foo",
Content: "foo edited",
},
{
Mode: "100644",
Path: "quux",
Content: "quux",
},
{
Mode: "100644",
Path: "qux",
Content: "qux",
},
},
}
},
},
{
desc: "Branch merges upstream with commits before and after",
setup: func(t *testing.T, repoPath string) setupData {
// r1 is before the merge, m1 merges l2 into the branch,
// r3 follows. l3 advances upstream past the merge point.
// The merge m1 is dropped by --no-merges; r1 and r3 are picked:
//
// BEFORE: AFTER:
// * l3, upstream * r3', result
// | * r3, branch * r1'
// | * m1 * l3, upstream
// | |\ * l2
// | |/ * l1
// |/|
// * | l2
// | * r1
// |/
// * l1
l1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l1: add foo"),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/l1"),
)
l2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l2: add bar"),
gittest.WithParents(l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/l2"),
)
l3 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l3: add quux"),
gittest.WithParents(l2),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
gittest.TreeEntry{Path: "quux", Mode: "100644", Content: "quux"},
),
gittest.WithReference("refs/tags/l3"),
)
r1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r1: edit foo"),
gittest.WithParents(l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/r1"),
)
m1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("m1: merge upstream"),
gittest.WithParents(r1, l2),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/m1"),
)
r3 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r3: add baz"),
gittest.WithParents(m1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
gittest.TreeEntry{Path: "baz", Mode: "100644", Content: "baz"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/r3"),
)
return setupData{
upstream: l3.String(),
branch: r3.String(),
expectedCommitsAhead: 2,
expectedTreeEntries: []gittest.TreeEntry{
{
Mode: "100644",
Path: "bar",
Content: "bar",
},
{
Mode: "100644",
Path: "baz",
Content: "baz",
},
{
Mode: "100644",
Path: "foo",
Content: "foo edited",
},
{
Mode: "100644",
Path: "quux",
Content: "quux",
},
},
}
},
},
{
desc: "Upstream merges branch then branch continues",
setup: func(t *testing.T, repoPath string) setupData {
// Upstream merges r1 via l3, then r2 continues on the branch.
// The merge-base is r1. Only r2 should be picked:
//
// BEFORE: AFTER:
// * l3, upstream * r2', result
// |\ * l3, upstream
// | | * r2, branch |\
// | |/ | * r1
// | * r1 |/
// |/ * l2
// * l2 * l1
// * l1
l1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l1: add foo"),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/l1"),
)
l2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l2: add bar"),
gittest.WithParents(l1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
gittest.WithReference("refs/tags/l2"),
)
r1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r1: edit foo"),
gittest.WithParents(l2),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/r1"),
)
r2 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r2: add baz"),
gittest.WithParents(r1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
gittest.TreeEntry{Path: "baz", Mode: "100644", Content: "baz"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/r2"),
)
l3 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l3: merge branch"),
gittest.WithParents(l2, r1),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "bar", Mode: "100644", Content: "bar"},
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo edited"},
),
gittest.WithReference("refs/tags/l3"),
)
return setupData{
upstream: l3.String(),
branch: r2.String(),
expectedCommitsAhead: 1,
expectedTreeEntries: []gittest.TreeEntry{
{
Mode: "100644",
Path: "bar",
Content: "bar",
},
{
Mode: "100644",
Path: "baz",
Content: "baz",
},
{
Mode: "100644",
Path: "foo",
Content: "foo edited",
},
},
}
},
},
{
desc: "Invalid upstream revision",
setup: func(t *testing.T, repoPath string) setupData {
r1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("r1: add foo"),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
)
return setupData{
upstream: "does-not-exist",
branch: r1.String(),
expectedErr: structerr.NewInvalidArgument("resolving upstream commit: reference not found").WithMetadata("revision", "does-not-exist"),
}
},
},
{
desc: "Invalid branch revision",
setup: func(t *testing.T, repoPath string) setupData {
l1 := gittest.WriteCommit(t, cfg, repoPath,
gittest.WithMessage("l1: add foo"),
gittest.WithTreeEntries(
gittest.TreeEntry{Path: "foo", Mode: "100644", Content: "foo"},
),
)
return setupData{
upstream: l1.String(),
branch: "does-not-exist",
expectedErr: structerr.NewInvalidArgument("resolving branch commit: reference not found").WithMetadata("revision", "does-not-exist"),
}
},
},
}
for _, tc := range testCases {
t.Run(tc.desc, func(t *testing.T) {
repoProto, repoPath := gittest.CreateRepository(t, ctx, cfg, gittest.CreateRepositoryConfig{
SkipCreationViaService: true,
})
repo := NewTestRepo(t, cfg, repoProto)
data := tc.setup(t, repoPath)
rebaseResult, err := repo.Rebase(ctx, data.upstream, data.branch, RebaseWithCommitter(defaultCommitter))
writeGraph(t, repoPath, tc.desc, data, rebaseResult)
if data.expectedErr != nil {
testhelper.RequireGrpcError(t, data.expectedErr, err)
return
}
require.NoError(t, err)
require.NotEmpty(t, rebaseResult)
gittest.RequireTree(t, cfg, repoPath, string(rebaseResult), data.expectedTreeEntries)
upstreamRevision := git.Revision(fmt.Sprintf("%s~%d", rebaseResult.String(), data.expectedCommitsAhead))
upstreamCommit, err := repo.ReadCommit(ctx, upstreamRevision)
require.NoError(t, err)
require.Equal(t, data.upstream, upstreamCommit.GetId())
})
}
}
func TestRebase_reappliedCherryPicks(t *testing.T) {
t.Parallel()
testhelper.NewFeatureSets(featureflag.GPGSigning).Run(t, testRebaseReappliedCherryPicks)
}
func testRebaseReappliedCherryPicks(t *testing.T, ctx context.Context) {
cfg := testcfg.Build(t)
committer := git.Signature{
Name: gittest.DefaultCommitterName,
Email: gittest.DefaultCommitterMail,
When: gittest.DefaultCommitTime,
}
// setup writes the following history, where l2 applies the same patch as r1:
//
// * l3: revert l2 (only with revert)
// * l2: add f
// | * r2: add g, branch
// | * r1: add f
// |/
// * l1: add base
setup := func(t *testing.T, revert bool) (*Repo, string, git.ObjectID, git.ObjectID) {
repoProto, repoPath := gittest.CreateRepository(t, ctx, cfg, gittest.CreateRepositoryConfig{
SkipCreationViaService: true,
})
base := gittest.TreeEntry{Path: "base", Mode: "100644", Content: "base"}
f := gittest.TreeEntry{Path: "f", Mode: "100644", Content: "f"}
g := gittest.TreeEntry{Path: "g", Mode: "100644", Content: "g"}
l1 := gittest.WriteCommit(t, cfg, repoPath, gittest.WithMessage("l1: add base"), gittest.WithTreeEntries(base))
upstream := gittest.WriteCommit(t, cfg, repoPath, gittest.WithMessage("l2: add f"), gittest.WithParents(l1), gittest.WithTreeEntries(base, f))
if revert {
upstream = gittest.WriteCommit(t, cfg, repoPath, gittest.WithMessage("l3: revert l2"), gittest.WithParents(upstream), gittest.WithTreeEntries(base))
}
r1 := gittest.WriteCommit(t, cfg, repoPath, gittest.WithMessage("r1: add f"), gittest.WithParents(l1), gittest.WithTreeEntries(base, f))
r2 := gittest.WriteCommit(t, cfg, repoPath, gittest.WithMessage("r2: add g"), gittest.WithParents(r1), gittest.WithTreeEntries(base, f, g))
return NewTestRepo(t, cfg, repoProto), repoPath, upstream, r2
}
requireCommitsAhead := func(t *testing.T, repoPath string, upstream, result git.ObjectID, expected int) {
t.Helper()
count := strings.TrimSpace(string(gittest.Exec(t, cfg, "-C", repoPath, "rev-list", "--count", upstream.String()+".."+result.String())))
require.Equal(t, fmt.Sprint(expected), count)
require.Equal(t, upstream, gittest.ResolveRevision(t, cfg, repoPath, fmt.Sprintf("%s~%d", result, expected)))
}
t.Run("dropped by default although upstream reverted it", func(t *testing.T) {
repo, repoPath, upstream, branch := setup(t, true)
result, err := repo.Rebase(ctx, upstream.String(), branch.String(), RebaseWithCommitter(committer))
require.NoError(t, err)
requireCommitsAhead(t, repoPath, upstream, result, 1)
gittest.RequireTree(t, cfg, repoPath, result.String(), []gittest.TreeEntry{
{Path: "base", Mode: "100644", Content: "base"},
{Path: "g", Mode: "100644", Content: "g"},
})
})
t.Run("reapplied after upstream reverted it", func(t *testing.T) {
repo, repoPath, upstream, branch := setup(t, true)
result, err := repo.Rebase(ctx, upstream.String(), branch.String(), RebaseWithCommitter(committer), RebaseWithReappliedCherryPicks())
require.NoError(t, err)
requireCommitsAhead(t, repoPath, upstream, result, 2)
gittest.RequireTree(t, cfg, repoPath, result.String(), []gittest.TreeEntry{
{Path: "base", Mode: "100644", Content: "base"},
{Path: "f", Mode: "100644", Content: "f"},
{Path: "g", Mode: "100644", Content: "g"},
})
})
t.Run("reapplied commit that becomes empty is dropped", func(t *testing.T) {
repo, repoPath, upstream, branch := setup(t, false)
result, err := repo.Rebase(ctx, upstream.String(), branch.String(), RebaseWithCommitter(committer), RebaseWithReappliedCherryPicks())
require.NoError(t, err)
requireCommitsAhead(t, repoPath, upstream, result, 1)
gittest.RequireTree(t, cfg, repoPath, result.String(), []gittest.TreeEntry{
{Path: "base", Mode: "100644", Content: "base"},
{Path: "f", Mode: "100644", Content: "f"},
{Path: "g", Mode: "100644", Content: "g"},
})
})
}
func TestRebase_longCommitMessage(t *testing.T) {
t.Parallel()
testhelper.NewFeatureSets(featureflag.GPGSigning).Run(t, testRebaseLongCommitMessage)
}
func testRebaseLongCommitMessage(t *testing.T, ctx context.Context) {
cfg := testcfg.Build(t)
repoProto, repoPath := gittest.CreateRepository(t, ctx, cfg, gittest.CreateRepositoryConfig{
SkipCreationViaService: true,
})
repo := NewTestRepo(t, cfg, repoProto)
committer := git.Signature{
Name: gittest.DefaultCommitterName,
Email: gittest.DefaultCommitterMail,
When: gittest.DefaultCommitTime,
}
// The messages are longer than what ReadCommit returns of a commit body, and contain empty
// lines like the one that ends the headers of a commit object.
longMessage := func(subject string) string {
return subject + "\n\n" + strings.Repeat("body line of the long message\n\n", 400) + "last line\n"
}
require.Greater(t, len(longMessage("")), helper.MaxCommitOrTagMessageSize)
base := gittest.TreeEntry{Path: "base", Mode: "100644", Content: "base"}
b := gittest.TreeEntry{Path: "b", Mode: "100644", Content: "b"}
c := gittest.TreeEntry{Path: "c", Mode: "100644", Content: "c"}
d := gittest.TreeEntry{Path: "d", Mode: "100644", Content: "d"}
l1 := gittest.WriteCommit(t, cfg, repoPath, gittest.WithMessage("l1: add base"), gittest.WithTreeEntries(base))
upstream := gittest.WriteCommit(t, cfg, repoPath, gittest.WithMessage("l2: add b"), gittest.WithParents(l1), gittest.WithTreeEntries(base, b))
r1 := gittest.WriteCommit(t, cfg, repoPath, gittest.WithMessage(longMessage("r1: add c")), gittest.WithParents(l1), gittest.WithTreeEntries(base, c))
r2 := gittest.WriteCommit(t, cfg, repoPath, gittest.WithMessage("r2: add d\n"), gittest.WithParents(r1), gittest.WithTreeEntries(base, c, d))
result, err := repo.Rebase(ctx, upstream.String(), r2.String(), RebaseWithCommitter(committer))
require.NoError(t, err)
message := func(t *testing.T, revision string) string {
t.Helper()
return string(gittest.Exec(t, cfg, "-C", repoPath, "log", "-1", "--format=%B", revision))
}
require.Equal(t, upstream, gittest.ResolveRevision(t, cfg, repoPath, result.String()+"~2"))
require.Equal(t, message(t, r1.String()), message(t, result.String()+"~1"))
require.Equal(t, message(t, r2.String()), message(t, result.String()))
require.Contains(t, message(t, result.String()+"~1"), "body line of the long message\n\nlast line\n")
gittest.RequireTree(t, cfg, repoPath, result.String(), []gittest.TreeEntry{b, base, c, d})
}
func TestParseTimezoneFromCommitAuthor(t *testing.T) {
t.Parallel()
const seconds = 1234567890
testCases := []struct {
desc string
timezone []byte
expectedWhen time.Time
}{
{
desc: "valid timezone with positive offsets",
timezone: []byte("+0800"),
expectedWhen: time.Unix(seconds, 0).In(time.FixedZone("", 8*60*60)),
},
{
desc: "valid timezone with negative offsets",
timezone: []byte("-0100"),
expectedWhen: time.Unix(seconds, 0).In(time.FixedZone("", -60*60)),
},
{
desc: "invalid timezone length",
timezone: []byte("0100"),
expectedWhen: time.Unix(seconds, 0).In(time.UTC),
},
{
desc: "invalid timezone",
timezone: []byte("aaaaa"),
expectedWhen: time.Unix(seconds, 0).In(time.UTC),
},
}
for _, tc := range testCases {
t.Run(tc.desc, func(t *testing.T) {
signature := getSignatureFromCommitAuthor(&gitalypb.CommitAuthor{
Name: []byte(gittest.DefaultCommitterName),
Email: []byte(gittest.DefaultCommitterMail),
Date: ×tamppb.Timestamp{Seconds: seconds},
Timezone: tc.timezone,
})
require.Equal(t, tc.expectedWhen, signature.When)
})
}
}