Git designed for AI agents.
package main
import (
"crypto/sha256"
"encoding/json"
"path/filepath"
"strings"
"testing"
"github.com/stretchr/testify/require"
"github.com/feder-cr/git-ai/internal/git/gittest"
"github.com/feder-cr/git-ai/internal/gitaly/service/setup"
"github.com/feder-cr/git-ai/internal/graft/corestore"
"github.com/feder-cr/git-ai/internal/graft/corestore/coretest"
"github.com/feder-cr/git-ai/internal/testhelper"
"github.com/feder-cr/git-ai/internal/testhelper/testcfg"
"github.com/feder-cr/git-ai/internal/testhelper/testserver"
"github.com/feder-cr/git-ai/sdk"
)
// TestCLIStorageAgainstServer drives graft storage against a real server whose
// storage core runs in shadow mode. It runs serially because the CLI tests
// share the package-level backend factory.
func TestCLIStorageAgainstServer(t *testing.T) {
ctx := testhelper.Context(t)
cfg := testcfg.Build(t)
cfg.Graft.Standalone = true
core := coretest.Open(t, coretest.Options{Mode: corestore.ModeShadow})
addr := testserver.RunGitalyServer(t, cfg, setup.RegisterAll, testserver.WithGraftStorage(core))
repo, repoPath := gittest.CreateRepository(t, ctx, cfg, gittest.CreateRepositoryConfig{SkipCreationViaService: true})
main := gittest.WriteCommit(t, cfg, repoPath, gittest.WithBranch("main"))
target := []string{"-address", addr, "-storage", repo.GetStorageName(), "-repo", repo.GetRelativePath()}
cli := func(args ...string) (int, string, string) {
return runCLI(t, append(append([]string{"storage"}, args...), target...)...)
}
code, stdout, stderr := cli("state")
require.Equal(t, exitOK, code, stderr)
require.Contains(t, stdout, "mode\tshadow\n")
require.Contains(t, stdout, "tracked\tfalse\n")
require.Contains(t, stdout, "node_id\tnode-a\n")
code, _, stderr = cli("verify")
require.Equal(t, exitError, code)
require.Contains(t, stderr, "not imported")
code, stdout, stderr = cli("import", "--json")
require.Equal(t, exitOK, code, stderr)
var imported sdk.StorageImport
require.NoError(t, json.Unmarshal([]byte(stdout), &imported))
require.EqualValues(t, 1, imported.Sequence)
require.EqualValues(t, 2, imported.References)
require.Positive(t, imported.PackBytes)
// Importing a tracked repository again brings only the history written
// since the import (none here) and leaves the references alone
// (doc/graft/PLAN6.md, LOCK AND HISTORY RULE): it succeeds and is idempotent.
code, stdout, stderr = cli("import", "--json")
require.Equal(t, exitOK, code, stderr)
var again sdk.StorageImport
require.NoError(t, json.Unmarshal([]byte(stdout), &again))
require.EqualValues(t, 1, again.Sequence, "the current head")
require.Zero(t, again.References, "no reference is imported again")
require.Zero(t, again.ChangelogEntries)
require.Zero(t, again.Reviews)
// The text output of a history import says what it did: it is not an
// import changeset without references.
code, stdout, stderr = cli("import")
require.Equal(t, exitOK, code, stderr)
require.Equal(t, "already imported at changeset 1: imported 0 changelog entries and 0 reviews written since\n", stdout)
code, stdout, stderr = cli("state", "--json")
require.Equal(t, exitOK, code, stderr)
require.Equal(t, 1, strings.Count(stdout, "\n"), "one object, one line")
var state sdk.StorageState
require.NoError(t, json.Unmarshal([]byte(stdout), &state))
require.Equal(t, "shadow", state.Mode)
require.True(t, state.Tracked)
require.EqualValues(t, 1, state.HeadSequence)
code, stdout, stderr = cli("verify", "--connectivity")
require.Equal(t, exitOK, code, stderr)
require.Equal(t, "head sequence 1\nconnectivity ok\nconsistent\n", stdout)
// A local change the database never saw is reported, and fails the command.
gittest.Exec(t, cfg, "-C", repoPath, "update-ref", "refs/heads/rogue", main.String())
code, stdout, stderr = cli("verify")
require.Equal(t, exitError, code)
require.Equal(t, "head sequence 1\ndivergence\trefs/heads/rogue\tlocal="+main.String()+"\tdatabase=absent\n", stdout)
require.Contains(t, stderr, "1 reference(s) diverge")
code, stdout, _ = cli("verify", "--json")
require.Equal(t, exitError, code)
var verify sdk.StorageVerify
require.NoError(t, json.Unmarshal([]byte(stdout), &verify))
require.Equal(t, []sdk.StorageDivergence{{Reference: "refs/heads/rogue", LocalTarget: main.String()}}, verify.Divergences)
}
// TestCLIStorageMaintenanceAgainstServer drives graft storage checkpoint and gc
// against a real server whose storage core runs in authoritative mode. It runs
// serially because the CLI tests share the package-level backend factory.
func TestCLIStorageMaintenanceAgainstServer(t *testing.T) {
ctx := testhelper.Context(t)
cfg := testcfg.Build(t)
cfg.Graft.Standalone = true
core := coretest.Open(t, coretest.Options{Mode: corestore.ModeAuthoritative})
addr := testserver.RunGitalyServer(t, cfg, setup.RegisterAll, testserver.WithGraftStorage(core))
repo, repoPath := gittest.CreateRepository(t, ctx, cfg, gittest.CreateRepositoryConfig{SkipCreationViaService: true})
gittest.WriteCommit(t, cfg, repoPath, gittest.WithBranch("main"))
server := []string{"-address", addr, "-storage", repo.GetStorageName()}
target := append(append([]string{}, server...), "-repo", repo.GetRelativePath())
cli := func(args ...string) (int, string, string) {
return runCLI(t, append(append([]string{"storage"}, args...), target...)...)
}
code, _, stderr := cli("import")
require.Equal(t, exitOK, code, stderr)
code, stdout, stderr := cli("checkpoint")
require.Equal(t, exitOK, code, stderr)
require.Regexp(t, `^checkpoint created at changeset 1: 2 references, pack [1-9][0-9]* bytes\n$`, stdout)
code, stdout, stderr = cli("checkpoint", "--json")
require.Equal(t, exitOK, code, stderr)
var checkpoint sdk.StorageCheckpoint
require.NoError(t, json.Unmarshal([]byte(stdout), &checkpoint))
require.False(t, checkpoint.Created, "a checkpoint at the head exists")
require.EqualValues(t, 1, checkpoint.Sequence)
code, stdout, stderr = cli("gc", "--dry-run", "--json")
require.Equal(t, exitOK, code, stderr)
var gc sdk.StorageGC
require.NoError(t, json.Unmarshal([]byte(stdout), &gc))
require.True(t, gc.DryRun)
code, stdout, stderr = cli("gc")
require.Equal(t, exitOK, code, stderr)
require.Contains(t, stdout, "deleted 0 objects (0 bytes)")
code, stdout, stderr = runCLI(t, append([]string{"storage", "gc", "--removed"}, server...)...)
require.Equal(t, exitOK, code, stderr)
require.Equal(t, "deleted 0 objects (0 bytes) of 0 removed repositories of storage "+repo.GetStorageName()+"\n", stdout)
// Objects of a repository ID the database has not allocated (a database
// restored from an older backup) are reported, never touched.
record, err := core.Meta.GetRepository(ctx, corestore.KeyOf(repo))
require.NoError(t, err)
ahead := corestore.NewPackKey(record.ID+2, sha256.Sum256([]byte("ahead")))
require.NoError(t, core.Blobs.Put(ctx, ahead, strings.NewReader("ahead")))
code, stdout, stderr = runCLI(t, append([]string{"storage", "gc", "--removed"}, server...)...)
require.Equal(t, exitOK, code, stderr)
require.Equal(t, "deleted 0 objects (0 bytes) of 0 removed repositories of storage "+repo.GetStorageName()+"\n"+
"warning: 1 repository IDs above the database's allocator have objects in the bucket (a database restored from an older backup?); they are left alone\n", stdout)
exists, err := core.Blobs.Exists(ctx, ahead)
require.NoError(t, err)
require.True(t, exists)
}
// TestCLIStorageCoreOff checks that a server without a storage core reports
// mode off and refuses an import.
func TestCLIStorageCoreOff(t *testing.T) {
env := startServer(t)
target := []string{"-address", env.addr, "-storage", env.storage, "-repo", env.relPath}
code, stdout, stderr := runCLI(t, append([]string{"storage", "state"}, target...)...)
require.Equal(t, exitOK, code, stderr)
require.Contains(t, stdout, "mode\toff\n")
code, _, stderr = runCLI(t, append([]string{"storage", "import"}, target...)...)
require.Equal(t, exitError, code)
require.Contains(t, stderr, "storage core is off")
}
// TestCLIStorageUsageErrorsDoNotContactServer checks the arguments of the
// storage commands before any server call. The workspace does not exist, so a
// server call would fail with a different error.
func TestCLIStorageUsageErrorsDoNotContactServer(t *testing.T) {
dir := filepath.Join(t.TempDir(), "missing")
cases := map[string][]string{
"no subcommand": {"storage", "-C", dir},
"unknown subcommand": {"storage", "repair", "-C", dir},
"import with arg": {"storage", "import", "-C", dir, "extra"},
"state with arg": {"storage", "state", "-C", dir, "extra"},
"verify with arg": {"storage", "verify", "-C", dir, "extra"},
"checkpoint with arg": {"storage", "checkpoint", "-C", dir, "extra"},
"gc with arg": {"storage", "gc", "-C", dir, "extra"},
"gc removed and repo": {"storage", "gc", "--removed", "-C", dir, "-repo", "a.git"},
"gc removed without server": {"storage", "gc", "--removed", "-C", dir},
"import dry run": {"storage", "import", "--dry-run", "-C", dir},
"checkpoint dry run": {"storage", "checkpoint", "--dry-run", "-C", dir},
"state connectivity": {"storage", "state", "--connectivity", "-C", dir},
"verify removed": {"storage", "verify", "--removed", "-C", dir},
"checkpoint removed": {"storage", "checkpoint", "--removed", "-C", dir},
}
for name, args := range cases {
code, _, stderr := runCLI(t, args...)
require.Equal(t, exitUsage, code, "%s: %s", name, stderr)
}
// Without a workspace and without -address the target cannot be found, so
// the command fails before any server call, with an error that is not a usage error.
code, _, stderr := runCLI(t, "storage", "verify", "-C", dir, "-repo", "a.git", "--connectivity")
require.NotEqual(t, exitUsage, code, stderr)
require.NotEqual(t, 0, code, stderr)
}
// TestCLIStorageHelp checks that graft help lists the storage command and that
// its help and its usage errors show the synopsis of the subcommands.
func TestCLIStorageHelp(t *testing.T) {
code, stdout, _ := runCLI(t, "help")
require.Equal(t, exitOK, code)
require.Contains(t, stdout, " storage SUBCOMMAND ")
code, _, stderr := runCLI(t, "storage", "-h")
require.Equal(t, exitOK, code, stderr)
require.Contains(t, stderr, storageSynopsis)
require.Contains(t, stderr, "-connectivity")
code, _, stderr = runCLI(t, "storage", "-C", filepath.Join(t.TempDir(), "missing"))
require.Equal(t, exitUsage, code, stderr)
require.Contains(t, stderr, storageSynopsis)
}
// TestStorageVerifyJSONKeepsNonUTF8Names checks that a reference name that is
// not valid UTF-8 (which the database accepts) is reproduced exactly in the
// JSON output of verify, next to its lossy JSON string.
func TestStorageVerifyJSONKeepsNonUTF8Names(t *testing.T) {
res := &sdk.StorageVerify{
HeadSequence: 3,
Divergences: []sdk.StorageDivergence{
{Reference: "refs/heads/\xff", LocalTarget: "1111111111111111111111111111111111111111"},
{Reference: "refs/heads/main", DatabaseTarget: "2222222222222222222222222222222222222222"},
},
}
var out strings.Builder
require.NoError(t, writeStorageJSON(&out, storageVerifyView(res)))
var decoded struct {
HeadSequence uint64 `json:"head_sequence"`
Divergences []struct {
Reference string `json:"reference"`
ReferenceBytes []byte `json:"reference_bytes"`
LocalTarget string `json:"local_target"`
DatabaseTarget string `json:"database_target"`
} `json:"divergences"`
}
require.NoError(t, json.Unmarshal([]byte(out.String()), &decoded))
require.EqualValues(t, 3, decoded.HeadSequence)
require.Len(t, decoded.Divergences, 2)
require.Equal(t, []byte("refs/heads/\xff"), decoded.Divergences[0].ReferenceBytes)
require.Equal(t, "refs/heads/�", decoded.Divergences[0].Reference)
require.Equal(t, "1111111111111111111111111111111111111111", decoded.Divergences[0].LocalTarget)
require.Nil(t, decoded.Divergences[1].ReferenceBytes)
require.NotContains(t, out.String(), `"reference_bytes":null`)
require.Equal(t, "refs/heads/main", decoded.Divergences[1].Reference)
// The SDK result decodes the same output unchanged otherwise.
var verify sdk.StorageVerify
require.NoError(t, json.Unmarshal([]byte(out.String()), &verify))
require.Equal(t, "2222222222222222222222222222222222222222", verify.Divergences[1].DatabaseTarget)
}
func TestStorageTargetText(t *testing.T) {
require.Equal(t, "absent", storageTargetText(""))
require.Equal(t, "ref:refs/heads/main", storageTargetText("ref:refs/heads/main"))
require.Equal(t, "1111111111111111111111111111111111111111", storageTargetText("1111111111111111111111111111111111111111"))
}