Skip to content

Git designed for AI agents.

test: spec tests of the land plan and the batch pack, fsck after chaos

Federico Elia4fdff0515ae4
diff --git a/internal/gitaly/service/operations/zz_pack_spec_test.go b/internal/gitaly/service/operations/zz_pack_spec_test.go
new file mode 100644
index 0000000..a93502c
--- /dev/null
+++ b/internal/gitaly/service/operations/zz_pack_spec_test.go
@@ -0,0 +1,193 @@
+package operations
+
+import (
+ "os"
+ "path/filepath"
+ "strings"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+
+ "github.com/feder-cr/git-ai/internal/git"
+ "github.com/feder-cr/git-ai/internal/git/gittest"
+ "github.com/feder-cr/git-ai/internal/git/localrepo"
+ "github.com/feder-cr/git-ai/internal/testhelper"
+ "github.com/feder-cr/git-ai/internal/testhelper/testcfg"
+)
+
+// Rule: every loose object of the quarantine is packed into one pack, and the loose files are removed.
+func TestSpecPackPacksAllLooseObjects(t *testing.T) {
+ t.Parallel()
+
+ ctx := testhelper.Context(t)
+ cfg := testcfg.Build(t)
+ repoProto, repoPath := gittest.CreateRepository(t, ctx, cfg, gittest.CreateRepositoryConfig{SkipCreationViaService: true})
+ _, repo, objectDir := newQuarantine(t, ctx, cfg, repoProto, repoPath)
+
+ contents := []string{"alpha", "beta", "gamma", "delta", "epsilon"}
+ var ids []git.ObjectID
+ for _, c := range contents {
+ id, err := repo.WriteBlob(ctx, strings.NewReader(c), localrepo.WriteBlobConfig{})
+ require.NoError(t, err)
+ ids = append(ids, id)
+ }
+
+ n, err := packAttemptObjects(ctx, repo, objectDir)
+ require.NoError(t, err)
+ require.Equal(t, 5, n)
+ require.Empty(t, looseObjects(t, objectDir))
+ require.Len(t, packIndexes(t, objectDir), 1)
+
+ for i, id := range ids {
+ data, err := repo.ReadObject(ctx, id)
+ require.NoError(t, err)
+ require.Equal(t, contents[i], string(data))
+ }
+}
+
+// Rule: a quarantine holding no loose object gives 0, and nothing is packed.
+func TestSpecPackEmptyQuarantineIsNoOp(t *testing.T) {
+ t.Parallel()
+
+ ctx := testhelper.Context(t)
+ cfg := testcfg.Build(t)
+ repoProto, repoPath := gittest.CreateRepository(t, ctx, cfg, gittest.CreateRepositoryConfig{SkipCreationViaService: true})
+ _, repo, objectDir := newQuarantine(t, ctx, cfg, repoProto, repoPath)
+
+ n, err := packAttemptObjects(ctx, repo, objectDir)
+ require.NoError(t, err)
+ require.Equal(t, 0, n)
+ require.Empty(t, packIndexes(t, objectDir))
+}
+
+// Rule: once the loose objects are packed, a second call finds nothing to pack and keeps one index.
+func TestSpecPackSecondCallIsNoOp(t *testing.T) {
+ t.Parallel()
+
+ ctx := testhelper.Context(t)
+ cfg := testcfg.Build(t)
+ repoProto, repoPath := gittest.CreateRepository(t, ctx, cfg, gittest.CreateRepositoryConfig{SkipCreationViaService: true})
+ _, repo, objectDir := newQuarantine(t, ctx, cfg, repoProto, repoPath)
+
+ for _, c := range []string{"first", "second"} {
+ _, err := repo.WriteBlob(ctx, strings.NewReader(c), localrepo.WriteBlobConfig{})
+ require.NoError(t, err)
+ }
+
+ n, err := packAttemptObjects(ctx, repo, objectDir)
+ require.NoError(t, err)
+ require.Equal(t, 2, n)
+
+ n, err = packAttemptObjects(ctx, repo, objectDir)
+ require.NoError(t, err)
+ require.Equal(t, 0, n)
+ require.Len(t, packIndexes(t, objectDir), 1)
+}
+
+// Rule: a file in a fan-out directory that is not an object ID is left in place, and its fan-out directory is kept.
+func TestSpecPackKeepsStrayFileAndFanoutDir(t *testing.T) {
+ t.Parallel()
+
+ ctx := testhelper.Context(t)
+ cfg := testcfg.Build(t)
+ repoProto, repoPath := gittest.CreateRepository(t, ctx, cfg, gittest.CreateRepositoryConfig{SkipCreationViaService: true})
+ _, repo, objectDir := newQuarantine(t, ctx, cfg, repoProto, repoPath)
+
+ id, err := repo.WriteBlob(ctx, strings.NewReader("stray case"), localrepo.WriteBlobConfig{})
+ require.NoError(t, err)
+
+ fan := string(id)[:2]
+ stray := filepath.Join(objectDir, fan, "tmp_obj_x")
+ require.NoError(t, os.WriteFile(stray, []byte("not an object"), 0o600))
+
+ n, err := packAttemptObjects(ctx, repo, objectDir)
+ require.NoError(t, err)
+ require.Equal(t, 1, n)
+
+ require.FileExists(t, stray)
+ require.DirExists(t, filepath.Join(objectDir, fan))
+ require.NotContains(t, looseObjects(t, objectDir), string(id))
+}
+
+// Rule: when only objects were present, no fan-out directory is left in the object directory after packing.
+func TestSpecPackRemovesEmptyFanoutDirs(t *testing.T) {
+ t.Parallel()
+
+ ctx := testhelper.Context(t)
+ cfg := testcfg.Build(t)
+ repoProto, repoPath := gittest.CreateRepository(t, ctx, cfg, gittest.CreateRepositoryConfig{SkipCreationViaService: true})
+ _, repo, objectDir := newQuarantine(t, ctx, cfg, repoProto, repoPath)
+
+ for _, c := range []string{"one", "two", "three"} {
+ _, err := repo.WriteBlob(ctx, strings.NewReader(c), localrepo.WriteBlobConfig{})
+ require.NoError(t, err)
+ }
+
+ _, err := packAttemptObjects(ctx, repo, objectDir)
+ require.NoError(t, err)
+
+ entries, err := os.ReadDir(objectDir)
+ require.NoError(t, err)
+ for _, e := range entries {
+ require.False(t, isFanoutName(e.Name()), "fan-out directory %q left behind", e.Name())
+ }
+}
+
+// Rule: when git pack-objects fails, an error is returned and the loose files are left untouched.
+func TestSpecPackFailureKeepsLooseObjects(t *testing.T) {
+ t.Parallel()
+
+ ctx := testhelper.Context(t)
+ cfg := testcfg.Build(t)
+ repoProto, repoPath := gittest.CreateRepository(t, ctx, cfg, gittest.CreateRepositoryConfig{SkipCreationViaService: true})
+ _, repo, objectDir := newQuarantine(t, ctx, cfg, repoProto, repoPath)
+
+ id, err := repo.WriteBlob(ctx, strings.NewReader("kept on failure"), localrepo.WriteBlobConfig{})
+ require.NoError(t, err)
+
+ packDir := filepath.Join(objectDir, "pack")
+ require.NoError(t, os.MkdirAll(packDir, 0o700))
+ require.NoError(t, os.Chmod(packDir, 0o500))
+ t.Cleanup(func() {
+ require.NoError(t, os.Chmod(packDir, 0o700))
+ })
+
+ _, err = packAttemptObjects(ctx, repo, objectDir)
+ require.Error(t, err)
+ require.Contains(t, looseObjects(t, objectDir), string(id))
+}
+
+// Rule: packed object IDs use the repository object format (64 hex characters for SHA-256, 40 for SHA-1),
+// and the pack index lists each of them.
+func TestSpecPackUsesObjectFormatIDs(t *testing.T) {
+ t.Parallel()
+
+ ctx := testhelper.Context(t)
+ cfg := testcfg.Build(t)
+ repoProto, repoPath := gittest.CreateRepository(t, ctx, cfg, gittest.CreateRepositoryConfig{SkipCreationViaService: true})
+ _, repo, objectDir := newQuarantine(t, ctx, cfg, repoProto, repoPath)
+
+ wantLen := 40
+ if gittest.ObjectHashIsSHA256() {
+ wantLen = 64
+ }
+
+ var ids []git.ObjectID
+ for _, c := range []string{"sha check one", "sha check two"} {
+ id, err := repo.WriteBlob(ctx, strings.NewReader(c), localrepo.WriteBlobConfig{})
+ require.NoError(t, err)
+ require.Len(t, string(id), wantLen)
+ ids = append(ids, id)
+ }
+
+ n, err := packAttemptObjects(ctx, repo, objectDir)
+ require.NoError(t, err)
+ require.Equal(t, 2, n)
+
+ idxs := packIndexes(t, objectDir)
+ require.Len(t, idxs, 1)
+ out := gittest.Exec(t, cfg, "-C", repoPath, "verify-pack", "-v", idxs[0])
+ for _, id := range ids {
+ require.Contains(t, string(out), string(id))
+ }
+}
diff --git a/internal/graft/e2e/chaos_test.go b/internal/graft/e2e/chaos_test.go
index 07bde10..d5494a8 100644
--- a/internal/graft/e2e/chaos_test.go
+++ b/internal/graft/e2e/chaos_test.go
@@ -633,6 +633,10 @@ func TestChaosLanding(t *testing.T) {
view := chaosViewOf(t, s, s.repoAs(t, tokens[workerName(0)]), base)
require.Empty(t, checkChaosInvariants(reqs, results, view), "the chaos invariants hold")
+
+ // Every object that a reference reaches is in the repository: the batches published their
+ // objects as packs before moving the branches (doc/graft/PLAN8.md, invariant D).
+ s.git(t, "fsck", "--connectivity-only", "--no-dangling")
}
// TestChaosPlanIsSeeded checks that the plan of the scenario depends on the
diff --git a/internal/graft/rebase/zz_plan_spec_test.go b/internal/graft/rebase/zz_plan_spec_test.go
new file mode 100644
index 0000000..bbd2110
--- /dev/null
+++ b/internal/graft/rebase/zz_plan_spec_test.go
@@ -0,0 +1,201 @@
+package rebase
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/require"
+
+ "github.com/feder-cr/git-ai/internal/git"
+ "github.com/feder-cr/git-ai/internal/graft/ancestry"
+)
+
+// Rule 1: an empty range (nil or empty) means the commit is already landed.
+func TestSpecEmptyRangeIsAlreadyLanded(t *testing.T) {
+ t.Parallel()
+
+ tip, commit := git.ObjectID("tip"), git.ObjectID("commit")
+
+ plan, err := PlanLanding(tip, commit, nil)
+ require.NoError(t, err)
+ require.Equal(t, LandAlreadyLanded, plan.Kind())
+
+ plan, err = PlanLanding(tip, commit, []ancestry.RangeCommit{})
+ require.NoError(t, err)
+ require.Equal(t, LandAlreadyLanded, plan.Kind())
+}
+
+// Rule 2: tip is a parent of a range commit, so the plan is a fast-forward.
+func TestSpecTipAsParentIsFastForward(t *testing.T) {
+ t.Parallel()
+
+ tip, commit := git.ObjectID("tip"), git.ObjectID("commit")
+ rng := []ancestry.RangeCommit{
+ {ID: commit, Parents: []git.ObjectID{"tip"}},
+ }
+
+ plan, err := PlanLanding(tip, commit, rng)
+ require.NoError(t, err)
+ require.Equal(t, LandFastForward, plan.Kind())
+}
+
+// Rule 2: a fast-forward stays a fast-forward even when a range commit is a merge.
+func TestSpecMergeWithTipParentIsFastForward(t *testing.T) {
+ t.Parallel()
+
+ tip, commit := git.ObjectID("tip"), git.ObjectID("commit")
+ rng := []ancestry.RangeCommit{
+ {ID: commit, Parents: []git.ObjectID{"c1", "c2"}},
+ {ID: "c1", Parents: []git.ObjectID{"tip"}},
+ {ID: "c2", Parents: []git.ObjectID{"tip"}},
+ }
+
+ plan, err := PlanLanding(tip, commit, rng)
+ require.NoError(t, err)
+ require.Equal(t, LandFastForward, plan.Kind())
+}
+
+// Rule 3: when tip is not a parent of any range commit, the plan is diverged.
+func TestSpecUnmergedRangeIsDiverged(t *testing.T) {
+ t.Parallel()
+
+ tip, commit := git.ObjectID("tip"), git.ObjectID("commit")
+ rng := []ancestry.RangeCommit{
+ {ID: commit, Parents: []git.ObjectID{"c1"}},
+ {ID: "c1", Parents: []git.ObjectID{"base"}},
+ }
+
+ plan, err := PlanLanding(tip, commit, rng)
+ require.NoError(t, err)
+ require.Equal(t, LandDiverged, plan.Kind())
+}
+
+// Rule 4: a merge in a diverged range makes Replay fail with ErrMergesInRange,
+// including when the range also has a root (the merge check runs first).
+func TestSpecMergeInDivergedRangeFails(t *testing.T) {
+ t.Parallel()
+
+ tip, commit := git.ObjectID("tip"), git.ObjectID("commit")
+
+ mergeOnly := []ancestry.RangeCommit{
+ {ID: commit, Parents: []git.ObjectID{"c1", "c2"}},
+ {ID: "c1", Parents: []git.ObjectID{"base"}},
+ {ID: "c2", Parents: []git.ObjectID{"base"}},
+ }
+ plan, err := PlanLanding(tip, commit, mergeOnly)
+ require.NoError(t, err)
+ require.Equal(t, LandDiverged, plan.Kind())
+ _, err = plan.Replay()
+ require.ErrorIs(t, err, ErrMergesInRange)
+
+ mergeAndRoot := []ancestry.RangeCommit{
+ {ID: commit, Parents: []git.ObjectID{"c1", "c2"}},
+ {ID: "c1", Parents: []git.ObjectID{"base"}},
+ {ID: "c2"},
+ }
+ plan, err = PlanLanding(tip, commit, mergeAndRoot)
+ require.NoError(t, err)
+ _, err = plan.Replay()
+ require.ErrorIs(t, err, ErrMergesInRange)
+}
+
+// Rule 5: a diverged, merge-free range whose bottom commit is a root makes Replay fail with ErrUnrelated.
+func TestSpecRootInDivergedRangeIsUnrelated(t *testing.T) {
+ t.Parallel()
+
+ tip, commit := git.ObjectID("tip"), git.ObjectID("commit")
+ rng := []ancestry.RangeCommit{
+ {ID: commit, Parents: []git.ObjectID{"c1"}},
+ {ID: "c1"},
+ }
+
+ plan, err := PlanLanding(tip, commit, rng)
+ require.NoError(t, err)
+ require.Equal(t, LandDiverged, plan.Kind())
+ _, err = plan.Replay()
+ require.ErrorIs(t, err, ErrUnrelated)
+}
+
+// Rule 6: Replay returns the chain oldest first, and the order of rng does not change the result.
+func TestSpecReplayOrderIndependentOldestFirst(t *testing.T) {
+ t.Parallel()
+
+ tip, commit := git.ObjectID("tip"), git.ObjectID("commit")
+ want := []git.ObjectID{"c1", "c2", "commit"}
+
+ inOrder := []ancestry.RangeCommit{
+ {ID: commit, Parents: []git.ObjectID{"c2"}},
+ {ID: "c2", Parents: []git.ObjectID{"c1"}},
+ {ID: "c1", Parents: []git.ObjectID{"base"}},
+ }
+ shuffled := []ancestry.RangeCommit{
+ {ID: "c1", Parents: []git.ObjectID{"base"}},
+ {ID: commit, Parents: []git.ObjectID{"c2"}},
+ {ID: "c2", Parents: []git.ObjectID{"c1"}},
+ }
+
+ for _, rng := range [][]ancestry.RangeCommit{inOrder, shuffled} {
+ plan, err := PlanLanding(tip, commit, rng)
+ require.NoError(t, err)
+ todo, err := plan.Replay()
+ require.NoError(t, err)
+ require.Equal(t, want, todo)
+ }
+}
+
+// Rule 7: Replay on a plan that is not diverged (already landed or fast-forward) returns an error.
+func TestSpecReplayRejectsNonDivergedPlan(t *testing.T) {
+ t.Parallel()
+
+ tip, commit := git.ObjectID("tip"), git.ObjectID("commit")
+
+ landed, err := PlanLanding(tip, commit, nil)
+ require.NoError(t, err)
+ _, err = landed.Replay()
+ require.Error(t, err)
+
+ fastForward := []ancestry.RangeCommit{
+ {ID: commit, Parents: []git.ObjectID{"tip"}},
+ }
+ ff, err := PlanLanding(tip, commit, fastForward)
+ require.NoError(t, err)
+ require.Equal(t, LandFastForward, ff.Kind())
+ _, err = ff.Replay()
+ require.Error(t, err)
+}
+
+// Rule 8: PlanLanding fails when a non-empty range does not contain commit, or lists an ID twice.
+func TestSpecPlanLandingRejectsBadRange(t *testing.T) {
+ t.Parallel()
+
+ tip, commit := git.ObjectID("tip"), git.ObjectID("commit")
+
+ missingCommit := []ancestry.RangeCommit{
+ {ID: "c1", Parents: []git.ObjectID{"base"}},
+ }
+ _, err := PlanLanding(tip, commit, missingCommit)
+ require.Error(t, err)
+
+ duplicated := []ancestry.RangeCommit{
+ {ID: commit, Parents: []git.ObjectID{"base"}},
+ {ID: commit, Parents: []git.ObjectID{"base"}},
+ }
+ _, err = PlanLanding(tip, commit, duplicated)
+ require.Error(t, err)
+}
+
+// Rule 9: a single-commit diverged range replays to exactly that commit.
+func TestSpecSingleCommitReplaysItself(t *testing.T) {
+ t.Parallel()
+
+ tip, commit := git.ObjectID("tip"), git.ObjectID("commit")
+ rng := []ancestry.RangeCommit{
+ {ID: commit, Parents: []git.ObjectID{"base"}},
+ }
+
+ plan, err := PlanLanding(tip, commit, rng)
+ require.NoError(t, err)
+ require.Equal(t, LandDiverged, plan.Kind())
+ todo, err := plan.Replay()
+ require.NoError(t, err)
+ require.Equal(t, []git.ObjectID{commit}, todo)
+}