Skip to content

Git designed for AI agents.

13.5 KB
Raw Blame
package localrepo

import (
	"bytes"
	"context"
	"fmt"
	"os"
	"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/quarantine"
	"github.com/feder-cr/git-ai/internal/gitaly/config"
	"github.com/feder-cr/git-ai/internal/helper/text"
	"github.com/feder-cr/git-ai/internal/testhelper"
	"github.com/feder-cr/git-ai/internal/testhelper/testcfg"
)

func setupTreeWriterRepo(t *testing.T) (context.Context, config.Cfg, *Repo, string) {
	t.Helper()

	ctx := testhelper.Context(t)
	cfg := testcfg.Build(t)
	repoProto, repoPath := gittest.CreateRepository(t, ctx, cfg, gittest.CreateRepositoryConfig{SkipCreationViaService: true})
	return ctx, cfg, NewTestRepo(t, cfg, repoProto), repoPath
}

// requireNoTreeObjectFiles asserts that no temporary tree object file is left in the storage's
// temporary directory.
func requireNoTreeObjectFiles(t *testing.T, repo *Repo) {
	t.Helper()

	tempDir, err := repo.StorageTempDir()
	require.NoError(t, err)
	entries, err := os.ReadDir(tempDir)
	require.NoError(t, err)
	for _, entry := range entries {
		require.NotContains(t, entry.Name(), "tree-object-")
	}
}

func cloneEntries(entries []*TreeEntry) []*TreeEntry {
	cloned := make([]*TreeEntry, 0, len(entries))
	for _, entry := range entries {
		entryCopy := *entry
		cloned = append(cloned, &entryCopy)
	}
	return cloned
}

// TestTreeWriter_matchesWriteEntries checks that the tree writer writes the trees today's writer
// writes, with the same IDs, through one process for every tree, and refuses the trees it refuses,
// with the same error (PLAN9, WP96).
func TestTreeWriter_matchesWriteEntries(t *testing.T) {
	t.Parallel()

	ctx, cfg, repo, repoPath := setupTreeWriterRepo(t)

	blob := gittest.WriteBlob(t, cfg, repoPath, []byte("one\n"))
	otherBlob := gittest.WriteBlob(t, cfg, repoPath, []byte("two\n"))
	subtree := gittest.WriteTree(t, cfg, repoPath, []gittest.TreeEntry{{Path: "x", Mode: "100644", OID: blob}})
	commit := gittest.WriteCommit(t, cfg, repoPath)
	// An object ID that no object of the repository has.
	missing := gittest.DefaultObjectHash.HashData([]byte("missing object"))

	for _, tc := range []struct {
		desc    string
		entries []*TreeEntry
		refused bool
	}{
		{
			desc: "empty",
		},
		{
			desc: "edge names",
			entries: []*TreeEntry{
				{Path: "a", Mode: "100644", Type: Blob, OID: blob},
				{Path: "a.b", Mode: "100644", Type: Blob, OID: otherBlob},
				{Path: "a b", Mode: "100644", Type: Blob, OID: blob},
				{Path: "é té", Mode: "100644", Type: Blob, OID: blob},
				{Path: "-", Mode: "100644", Type: Blob, OID: blob},
			},
		},
		{
			desc: "a directory sorts as its name with a slash",
			entries: []*TreeEntry{
				{Path: "a0", Mode: "100644", Type: Blob, OID: blob},
				{Path: "a", Mode: "040000", Type: Tree, OID: subtree},
				{Path: "a.b", Mode: "100644", Type: Blob, OID: blob},
				{Path: "a-", Mode: "100644", Type: Blob, OID: blob},
			},
		},
		{
			desc: "every mode",
			entries: []*TreeEntry{
				{Path: "regular", Mode: "100644", Type: Blob, OID: blob},
				{Path: "executable", Mode: "100755", Type: Blob, OID: blob},
				{Path: "symlink", Mode: "120000", Type: Blob, OID: otherBlob},
				{Path: "directory", Mode: "040000", Type: Tree, OID: subtree},
				{Path: "submodule", Mode: "160000", Type: Submodule, OID: commit},
			},
		},
		{
			desc: "an object that does not exist is accepted",
			entries: []*TreeEntry{
				{Path: "missing", Mode: "100644", Type: Blob, OID: missing},
				{Path: "missing-submodule", Mode: "160000", Type: Submodule, OID: missing},
			},
		},
		{
			desc: "duplicate names",
			entries: []*TreeEntry{
				{Path: "d", Mode: "100644", Type: Blob, OID: blob},
				{Path: "d", Mode: "100644", Type: Blob, OID: otherBlob},
			},
			refused: true,
		},
		{
			desc: "a file and a directory of the same name",
			entries: []*TreeEntry{
				{Path: "d", Mode: "100644", Type: Blob, OID: blob},
				{Path: "d", Mode: "040000", Type: Tree, OID: subtree},
			},
			refused: true,
		},
		{
			desc:    "invalid mode",
			entries: []*TreeEntry{{Path: "bad", Mode: "100600", Type: Blob, OID: blob}},
			refused: true,
		},
		{
			desc:    "an entry without object ID",
			entries: []*TreeEntry{{Path: "empty", Mode: "100644", Type: Blob}},
			refused: true,
		},
	} {
		t.Run(tc.desc, func(t *testing.T) {
			expectedOID, expectedErr := repo.writeEntries(ctx, cloneEntries(tc.entries))
			require.Equal(t, tc.refused, expectedErr != nil, "today's writer: %v", expectedErr)

			writer, err := repo.NewTreeWriter(ctx)
			require.NoError(t, err)

			oid, err := writer.write(cloneEntries(tc.entries))
			if tc.refused {
				require.Error(t, err)
				require.Equal(t, expectedErr.Error(), err.Error())

				// The process exited and was reaped; the writer refuses every later write.
				require.Nil(t, writer.cmd)
				_, laterErr := writer.write(cloneEntries(tc.entries[:1]))
				require.Equal(t, err, laterErr)
			} else {
				require.NoError(t, err)
				require.Equal(t, expectedOID, oid)

				// The same process writes the next tree.
				process := writer.cmd
				oid, err = writer.write(cloneEntries(tc.entries))
				require.NoError(t, err)
				require.Equal(t, expectedOID, oid)
				require.Same(t, process, writer.cmd)
			}

			require.NoError(t, writer.Close())
			require.Nil(t, writer.cmd)
			require.NoError(t, writer.Close())
			_, err = writer.write(cloneEntries(tc.entries))
			require.Error(t, err)

			requireNoTreeObjectFiles(t, repo)
		})
	}
}

// TestTreeWriter_panic checks that a panic during a write, while the tree object file exists and
// the process runs, removes the file, and that Close, as a deferred call runs it on the panic's
// way out, ends the process.
func TestTreeWriter_panic(t *testing.T) {
	t.Parallel()

	ctx, cfg, repo, repoPath := setupTreeWriterRepo(t)
	blob := gittest.WriteBlob(t, cfg, repoPath, []byte("content\n"))

	writer, err := repo.NewTreeWriter(ctx)
	require.NoError(t, err)
	var fileSeen bool
	writer.SetTestHook(func(point string) {
		require.Equal(t, "started", point)
		tempDir, err := repo.StorageTempDir()
		require.NoError(t, err)
		entries, err := os.ReadDir(tempDir)
		require.NoError(t, err)
		for _, entry := range entries {
			fileSeen = fileSeen || strings.HasPrefix(entry.Name(), "tree-object-")
		}
		require.NotNil(t, writer.cmd)
		panic("injected")
	})

	require.PanicsWithValue(t, "injected", func() {
		defer func() { require.NoError(t, writer.Close()) }()
		_, _ = writer.write([]*TreeEntry{{Path: "file", Mode: "100644", Type: Blob, OID: blob}})
	})

	require.True(t, fileSeen, "the hook ran while the tree object file existed")
	require.Nil(t, writer.cmd)
	requireNoTreeObjectFiles(t, repo)
}

// TestTreeEntry_WriteWith checks that WriteWith writes the trees Write writes.
func TestTreeEntry_WriteWith(t *testing.T) {
	t.Parallel()

	ctx, cfg, repo, repoPath := setupTreeWriterRepo(t)
	blob := gittest.WriteBlob(t, cfg, repoPath, []byte("content\n"))

	build := func() *TreeEntry {
		root := &TreeEntry{Mode: "040000", Type: Tree}
		for _, path := range []string{"a/b/c", "a/b.c", "a.b/c", "d", "a/é/f"} {
			require.NoError(t, root.Add(path, TreeEntry{Path: path[strings.LastIndex(path, "/")+1:], Mode: "100644", Type: Blob, OID: blob}))
		}
		return root
	}

	expected := build()
	require.NoError(t, expected.Write(ctx, repo))

	actual := build()
	writer, err := repo.NewTreeWriter(ctx)
	require.NoError(t, err)
	require.NoError(t, actual.WriteWith(writer))
	require.NoError(t, writer.Close())

	require.Equal(t, expected, actual)
	requireNoTreeObjectFiles(t, repo)
}

// TestReadTreeLazily_matchesReadTree checks that the lazy tree, once walked, is the tree ReadTree
// reads whole, and that it refuses what ReadTree refuses.
func TestReadTreeLazily_matchesReadTree(t *testing.T) {
	t.Parallel()

	ctx, cfg, repo, repoPath := setupTreeWriterRepo(t)

	blob := gittest.WriteBlob(t, cfg, repoPath, []byte("content\n"))
	commit := gittest.WriteCommit(t, cfg, repoPath)
	inner := gittest.WriteTree(t, cfg, repoPath, []gittest.TreeEntry{
		{Path: "file", Mode: "100644", OID: blob},
		{Path: "é", Mode: "100755", OID: blob},
	})
	middle := gittest.WriteTree(t, cfg, repoPath, []gittest.TreeEntry{
		{Path: "inner", Mode: "040000", OID: inner},
		{Path: "link", Mode: "120000", OID: blob},
	})
	root := gittest.WriteTree(t, cfg, repoPath, []gittest.TreeEntry{
		{Path: "a", Mode: "040000", OID: middle},
		{Path: "a.b", Mode: "100644", OID: blob},
		{Path: "a b", Mode: "040000", OID: inner},
		{Path: "submodule", Mode: "160000", OID: commit},
	})

	expected, err := repo.ReadTree(ctx, root.Revision(), WithRecursive())
	require.NoError(t, err)

	reader, cancel, err := repo.RequestObjectReader(ctx)
	require.NoError(t, err)
	defer cancel()

	lazy, err := repo.ReadTreeLazily(ctx, reader, root)
	require.NoError(t, err)
	// Only the root is read.
	for _, entry := range lazy.Entries {
		require.Nil(t, entry.Entries)
	}

	require.NoError(t, lazy.Walk(func(string, *TreeEntry) error { return nil }))
	require.Equal(t, expected, lazy)

	_, err = repo.ReadTreeLazily(ctx, reader, blob)
	require.Equal(t, ErrNotTreeish, err)

	missing := gittest.DefaultObjectHash.HashData([]byte("missing tree"))
	_, err = repo.ReadTreeLazily(ctx, reader, missing)
	require.ErrorContains(t, err, "check object type: object not found")
}

// TestReadTreeLazily_canonicalModes checks that the lazy tree reads legacy modes, which git no
// longer writes but still reads, as ls-tree prints them: canonical, as git's canon_mode makes
// them. Written back, they are then modes the tree writer accepts.
func TestReadTreeLazily_canonicalModes(t *testing.T) {
	t.Parallel()

	ctx, cfg, repo, repoPath := setupTreeWriterRepo(t)

	blob := gittest.WriteBlob(t, cfg, repoPath, []byte("content\n"))
	subtree := gittest.WriteTree(t, cfg, repoPath, []gittest.TreeEntry{{Path: "f", Mode: "100644", OID: blob}})
	raw := func(oid git.ObjectID) []byte {
		b, err := oid.Bytes()
		require.NoError(t, err)
		return b
	}
	var content bytes.Buffer
	for _, entry := range []struct {
		mode, name string
		oid        git.ObjectID
	}{
		// In git's order: a directory sorts as its name with a slash.
		{"100600", "a", blob},
		{"100664", "b", blob},
		{"100775", "c", blob},
		{"120777", "d", blob},
		{"40755", "e", subtree},
		{"644", "f", blob},
	} {
		fmt.Fprintf(&content, "%s %s\x00", entry.mode, entry.name)
		content.Write(raw(entry.oid))
	}
	root := git.ObjectID(text.ChompBytes(gittest.ExecOpts(t, cfg, gittest.ExecConfig{Stdin: &content},
		"-C", repoPath, "hash-object", "-t", "tree", "-w", "--literally", "--stdin")))

	expected, err := repo.ReadTree(ctx, root.Revision(), WithRecursive())
	require.NoError(t, err)

	reader, cancel, err := repo.RequestObjectReader(ctx)
	require.NoError(t, err)
	defer cancel()
	lazy, err := repo.ReadTreeLazily(ctx, reader, root)
	require.NoError(t, err)
	require.NoError(t, lazy.Walk(func(string, *TreeEntry) error { return nil }))
	require.Equal(t, expected, lazy)

	typeNames := map[ObjectType]string{Blob: "blob", Tree: "tree", Submodule: "commit"}
	var modes []string
	for _, entry := range lazy.Entries {
		modes = append(modes, entry.Mode+" "+typeNames[entry.Type]+" "+entry.Path)
	}
	require.Equal(t, []string{
		"100644 blob a", "100644 blob b", "100755 blob c", "120000 blob d", "040000 tree e", "160000 commit f",
	}, modes)

	// Written back, the tree holds the canonical modes, which the tree writer accepts.
	lazy.OID = ""
	writer, err := repo.NewTreeWriter(ctx)
	require.NoError(t, err)
	require.NoError(t, lazy.WriteWith(writer))
	require.NoError(t, writer.Close())
	require.NotEqual(t, root, lazy.OID)
}

// TestTreeWriter_quarantine checks that the request's reader and tree writer run on the
// quarantined repository: they write into the quarantine and read what only it holds.
func TestTreeWriter_quarantine(t *testing.T) {
	t.Parallel()

	ctx := testhelper.Context(t)
	cfg := testcfg.Build(t)
	repoProto, _ := gittest.CreateRepository(t, ctx, cfg, gittest.CreateRepositoryConfig{SkipCreationViaService: true})
	repo := NewTestRepo(t, cfg, repoProto)

	quarantineDir, cleanup, err := quarantine.New(ctx, repoProto, testhelper.NewLogger(t), config.NewLocator(cfg))
	require.NoError(t, err)
	t.Cleanup(cleanup)
	quarantineRepo := NewTestRepo(t, cfg, quarantineDir.QuarantinedRepo())

	blob, err := quarantineRepo.WriteBlob(ctx, strings.NewReader("quarantined\n"), WriteBlobConfig{})
	require.NoError(t, err)

	tree := &TreeEntry{Mode: "040000", Type: Tree}
	require.NoError(t, tree.Add("dir/file", TreeEntry{Path: "file", Mode: "100644", Type: Blob, OID: blob}))
	writer, err := quarantineRepo.NewTreeWriter(ctx)
	require.NoError(t, err)
	require.NoError(t, tree.WriteWith(writer))
	require.NoError(t, writer.Close())

	// The trees are in the quarantine only.
	for _, oid := range []git.ObjectID{tree.OID, tree.Entries[0].OID} {
		_, err := quarantineRepo.ReadObject(ctx, oid)
		require.NoError(t, err)
		_, err = repo.ReadObject(ctx, oid)
		require.Equal(t, InvalidObjectError(oid.String()), err)
	}

	reader, cancel, err := quarantineRepo.RequestObjectReader(ctx)
	require.NoError(t, err)
	defer cancel()

	resolved, err := quarantineRepo.ResolveRevisionWithReader(ctx, reader, tree.OID.Revision()+"^{tree}")
	require.NoError(t, err)
	require.Equal(t, tree.OID, resolved)

	lazy, err := quarantineRepo.ReadTreeLazily(ctx, reader, tree.OID)
	require.NoError(t, err)
	entry, err := lazy.Get("dir/file")
	require.NoError(t, err)
	require.Equal(t, blob, entry.OID)

	mainReader, cancelMain, err := repo.RequestObjectReader(ctx)
	require.NoError(t, err)
	defer cancelMain()

	_, err = repo.ResolveRevisionWithReader(ctx, mainReader, tree.OID.Revision()+"^{tree}")
	require.Equal(t, git.ErrReferenceNotFound, err)
}