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.gonew file mode 100644index 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.goindex 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 thediff --git a/internal/graft/rebase/zz_plan_spec_test.go b/internal/graft/rebase/zz_plan_spec_test.gonew file mode 100644index 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)+}