Skip to content

Git designed for AI agents.

8.1 KB
Raw Blame
package gitcmd_test

import (
	"bytes"
	"context"
	"os"
	"path/filepath"
	"strings"
	"testing"
	"time"

	"github.com/stretchr/testify/require"

	"github.com/feder-cr/git-ai/internal/git"
	"github.com/feder-cr/git-ai/internal/git/gitcmd"
	"github.com/feder-cr/git-ai/internal/git/gittest"
	"github.com/feder-cr/git-ai/internal/graft/identity"
	"github.com/feder-cr/git-ai/internal/testhelper"
	"github.com/feder-cr/git-ai/internal/testhelper/testcfg"
)

// TestAgentWalk_leavesHiddenRefsOut: whatever asks git to walk every reference, as an option, an
// argument or a line on stdin, the walk of an agent's command leaves out the references under
// refs/graft/, and another caller's walk still reaches them. The commit only a proposal reference
// reaches stands for a proposal.
func TestAgentWalk_leavesHiddenRefsOut(t *testing.T) {
	t.Parallel()

	ctx := testhelper.Context(t)
	cfg := testcfg.Build(t)
	repo, repoPath := gittest.CreateRepository(t, ctx, cfg, gittest.CreateRepositoryConfig{SkipCreationViaService: true})
	main := gittest.WriteCommit(t, cfg, repoPath, gittest.WithBranch("main"),
		gittest.WithTreeEntries(gittest.TreeEntry{Mode: "100644", Path: "a", Content: "a\n"}))
	secret := gittest.WriteCommit(t, cfg, repoPath, gittest.WithParents(main),
		gittest.WithReference("refs/graft/proposals/0123456789abcdef/1"), gittest.WithMessage("SECRET proposal"),
		gittest.WithTreeEntries(gittest.TreeEntry{Mode: "100644", Path: "a", Content: "proposed\n"}))
	factory := gittest.NewCommandFactory(t, cfg)
	agent := identity.NewContext(ctx, identity.Identity{Name: "agent-a", Source: identity.SourceAgent})

	run := func(t *testing.T, ctx context.Context, sc gitcmd.Command, stdin string) string {
		t.Helper()
		var stdout, stderr bytes.Buffer
		opts := []gitcmd.CmdOpt{gitcmd.WithStdout(&stdout), gitcmd.WithStderr(&stderr)}
		if stdin != "" {
			opts = append(opts, gitcmd.WithStdin(strings.NewReader(stdin)))
		}
		cmd, err := factory.New(ctx, repo, sc, opts...)
		require.NoError(t, err)
		require.NoError(t, cmd.Wait(), "stderr: %s", stderr.String())
		return stdout.String()
	}

	for _, tc := range []struct {
		desc  string
		sc    gitcmd.Command
		stdin string
		seen  string
	}{
		{desc: "rev-list --all", sc: gitcmd.Command{Name: "rev-list", Flags: []gitcmd.Option{gitcmd.Flag{Name: "--all"}}}, seen: secret.String()},
		{desc: "rev-list --all as an argument", sc: gitcmd.Command{Name: "rev-list", Args: []string{"--all"}}, seen: secret.String()},
		{desc: "rev-list --glob=refs/*", sc: gitcmd.Command{Name: "rev-list", Args: []string{"--glob=refs/*"}}, seen: secret.String()},
		{desc: "rev-list --not --all", sc: gitcmd.Command{Name: "rev-list", Args: []string{secret.String(), "--not", "--all"}}, seen: ""},
		{desc: "rev-list --all on stdin", sc: gitcmd.Command{Name: "rev-list", Flags: []gitcmd.Option{gitcmd.Flag{Name: "--stdin"}}}, stdin: "--all\n", seen: secret.String()},
		{desc: "rev-list --glob= on stdin", sc: gitcmd.Command{Name: "rev-list", Flags: []gitcmd.Option{gitcmd.Flag{Name: "--stdin"}}}, stdin: "--glob=refs/graft/*\n", seen: secret.String()},
		{desc: "log --all", sc: gitcmd.Command{Name: "log", Flags: []gitcmd.Option{gitcmd.Flag{Name: "--format=%H"}, gitcmd.Flag{Name: "--all"}}}, seen: secret.String()},
		{desc: "show --all", sc: gitcmd.Command{Name: "show", Flags: []gitcmd.Option{gitcmd.Flag{Name: "--no-patch"}, gitcmd.Flag{Name: "--format=%H"}, gitcmd.Flag{Name: "--all"}}}, seen: secret.String()},
		{desc: "rev-parse --all", sc: gitcmd.Command{Name: "rev-parse", Flags: []gitcmd.Option{gitcmd.Flag{Name: "--all"}}}, seen: secret.String()},
		{desc: "fast-export --all", sc: gitcmd.Command{Name: "fast-export", Flags: []gitcmd.Option{gitcmd.Flag{Name: "--all"}}}, seen: "SECRET proposal"},
		{desc: "format-patch --all", sc: gitcmd.Command{Name: "format-patch", Flags: []gitcmd.Option{gitcmd.Flag{Name: "--stdout"}, gitcmd.Flag{Name: "--all"}}}, seen: "SECRET proposal"},
		{desc: "bundle create --all", sc: gitcmd.Command{Name: "bundle", Action: "create", Flags: []gitcmd.Option{gitcmd.OutputToStdout, gitcmd.Flag{Name: "--all"}}}, seen: "refs/graft/"},
	} {
		t.Run(tc.desc, func(t *testing.T) {
			agentOut := run(t, agent, tc.sc, tc.stdin)
			otherOut := run(t, ctx, tc.sc, tc.stdin)
			if tc.seen == "" {
				// The proposal is no reference to an agent: it is new to it.
				require.Contains(t, agentOut, secret.String())
				require.Empty(t, otherOut)
				return
			}
			require.NotContains(t, agentOut, tc.seen)
			require.Contains(t, otherOut, tc.seen)
		})
	}

	// Lines that git reads as "--all" or "--glob=...", written so that a filter that compares
	// anything else lets them through (review of b985c82): a carriage return, a NUL.
	for desc, stdin := range map[string]string{
		"--all with a carriage return": "--all\r\n",
		"--all with a NUL":             "--all\x00\n",
		"--all with a NUL and text":    "--all\x00junk\n",
		"--glob with a carriage":       "--glob=refs/*\r\n",
		"--glob after another line":    "main\n--glob=refs/*\r\n",
	} {
		t.Run("stdin "+desc, func(t *testing.T) {
			sc := gitcmd.Command{Name: "rev-list", Flags: []gitcmd.Option{gitcmd.Flag{Name: "--stdin"}}}
			require.NotContains(t, run(t, agent, sc, stdin), secret.String())
			require.Contains(t, run(t, ctx, sc, stdin), secret.String(), "another caller's walk reaches it")
		})
	}

	t.Run("--branches is left alone", func(t *testing.T) {
		out := run(t, agent, gitcmd.Command{Name: "rev-list", Args: []string{"--branches"}}, "")
		require.Contains(t, out, main.String())
	})

	t.Run("--alternate-refs walks the pool's branches and tags only", func(t *testing.T) {
		member, memberPath := gittest.CreateRepository(t, ctx, cfg, gittest.CreateRepositoryConfig{SkipCreationViaService: true})
		_, poolPath := gittest.CreateRepository(t, ctx, cfg, gittest.CreateRepositoryConfig{SkipCreationViaService: true})
		base := gittest.WriteCommit(t, cfg, poolPath, gittest.WithReference(git.ObjectPoolRefNamespace+"/heads/main"))
		mirrored := gittest.WriteCommit(t, cfg, poolPath, gittest.WithParents(base), gittest.WithMessage("mirrored proposal"),
			gittest.WithReference(git.ObjectPoolRefNamespace+"/graft/proposals/0123456789abcdef/1"))
		require.NoError(t, os.WriteFile(filepath.Join(memberPath, "objects", "info", "alternates"), []byte(filepath.Join(poolPath, "objects")+"\n"), 0o644))

		walk := func(ctx context.Context) string {
			var stdout, stderr bytes.Buffer
			cmd, err := factory.New(ctx, member, gitcmd.Command{Name: "rev-list", Args: []string{"--alternate-refs"}},
				gitcmd.WithStdout(&stdout), gitcmd.WithStderr(&stderr))
			require.NoError(t, err)
			require.NoError(t, cmd.Wait(), "stderr: %s", stderr.String())
			return stdout.String()
		}
		agentOut := walk(agent)
		require.Contains(t, agentOut, base.String())
		require.NotContains(t, agentOut, mirrored.String())
		require.Contains(t, walk(ctx), mirrored.String())
	})

	t.Run("revisions written to stdin", func(t *testing.T) {
		var stdout bytes.Buffer
		cmd, err := factory.New(agent, repo, gitcmd.Command{Name: "rev-list", Flags: []gitcmd.Option{gitcmd.Flag{Name: "--stdin"}}},
			gitcmd.WithSetupStdin(), gitcmd.WithStdout(&stdout))
		require.NoError(t, err)
		_, err = cmd.Write([]byte("--glob=refs/*\n"))
		require.NoError(t, err)
		require.NoError(t, cmd.Wait())
		require.Contains(t, stdout.String(), main.String())
		require.NotContains(t, stdout.String(), secret.String())
	})

	t.Run("a writer to a git that stopped reading does not block", func(t *testing.T) {
		var stderr bytes.Buffer
		cmd, err := factory.New(agent, repo, gitcmd.Command{Name: "rev-list", Flags: []gitcmd.Option{gitcmd.Flag{Name: "--stdin"}}},
			gitcmd.WithSetupStdin(), gitcmd.WithStderr(&stderr))
		require.NoError(t, err)

		done := make(chan error, 1)
		go func() {
			line := []byte(strings.Repeat("0", 39) + "1\n")
			var err error
			for i := 0; i < 1<<16 && err == nil; i++ {
				if i == 0 {
					_, err = cmd.Write([]byte("no-such-revision\n"))
					continue
				}
				_, err = cmd.Write(line)
			}
			done <- err
		}()
		select {
		case <-done:
		case <-time.After(30 * time.Second):
			require.FailNow(t, "the writes blocked on a git that exited")
		}
		require.Error(t, cmd.Wait())
		require.Contains(t, stderr.String(), "no-such-revision")
	})
}