Skip to content

Git designed for AI agents.

34.8 KB
Raw Blame
package gitcmd_test

import (
	"bytes"
	"context"
	"fmt"
	"net/http"
	"net/http/httptest"
	"os"
	"path/filepath"
	"strings"
	"testing"

	"github.com/feder-cr/git-ai/internal/featureflag"
	"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/git/trace2"
	"github.com/feder-cr/git-ai/internal/git/trace2hooks"
	"github.com/feder-cr/git-ai/internal/gitaly/config"
	"github.com/feder-cr/git-ai/internal/gitaly/storage"
	"github.com/feder-cr/git-ai/internal/helper/text"
	"github.com/feder-cr/git-ai/internal/log"
	"github.com/feder-cr/git-ai/internal/testhelper"
	"github.com/feder-cr/git-ai/internal/testhelper/testcfg"
	"github.com/feder-cr/git-ai/internal/tracing"
	"github.com/stretchr/testify/require"
	"go.opentelemetry.io/otel"
	"golang.org/x/time/rate"
)

func TestGitCommandProxy(t *testing.T) {
	cfg := testcfg.Build(t)

	requestReceived := false

	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		requestReceived = true
	}))
	defer ts.Close()

	t.Setenv("http_proxy", ts.URL)

	ctx := testhelper.Context(t)

	dir := testhelper.TempDir(t)

	gitCmdFactory, cleanup, err := gitcmd.NewExecCommandFactory(cfg, testhelper.SharedLogger(t))
	require.NoError(t, err)
	defer cleanup()

	cmd, err := gitCmdFactory.NewWithoutRepo(ctx, gitcmd.Command{
		Name: "clone",
		Args: []string{"http://gitlab.com/bogus-repo", dir},
	}, gitcmd.WithDisabledHooks())
	require.NoError(t, err)

	err = cmd.Wait()
	require.NoError(t, err)
	require.True(t, requestReceived)
}

// Global git configuration is only disabled in tests for now. Gitaly should stop using the global
// git configuration in 15.0. See https://gitlab.com/gitlab-org/gitaly/-/issues/3617.
func TestExecCommandFactory_globalGitConfigIgnored(t *testing.T) {
	cfg := testcfg.Build(t)

	gitCmdFactory, cleanup, err := gitcmd.NewExecCommandFactory(cfg, testhelper.SharedLogger(t))
	require.NoError(t, err)
	defer cleanup()

	tmpHome := testhelper.TempDir(t)
	require.NoError(t, os.WriteFile(filepath.Join(tmpHome, ".gitconfig"), []byte(`[ignored]
	value = true
`,
	), os.ModePerm))
	ctx := testhelper.Context(t)

	for _, tc := range []struct {
		desc   string
		filter string
	}{
		{desc: "global", filter: "--global"},
		// The test doesn't override the system config as that would be a global change or would
		// require chrooting. The assertion won't catch problems on systems that do not have system
		// level configuration set.
		{desc: "system", filter: "--system"},
	} {
		t.Run(tc.desc, func(t *testing.T) {
			var stdout strings.Builder
			cmd, err := gitCmdFactory.NewWithoutRepo(ctx, gitcmd.Command{
				Name:  "config",
				Flags: []gitcmd.Option{gitcmd.Flag{Name: "--list"}, gitcmd.Flag{Name: tc.filter}},
			}, gitcmd.WithEnv("HOME="+tmpHome), gitcmd.WithStdout(&stdout))
			require.NoError(t, err)
			require.NoError(t, cmd.Wait())
			require.Empty(t, stdout.String())
		})
	}
}

func TestExecCommandFactory_gitConfiguration(t *testing.T) {
	t.Parallel()

	ctx := testhelper.Context(t)
	cfg := testcfg.Build(t)

	defaultConfig := func() []string {
		commandFactory, cleanup, err := gitcmd.NewExecCommandFactory(cfg, testhelper.SharedLogger(t))
		require.NoError(t, err)
		defer cleanup()

		globalConfig, err := commandFactory.GlobalConfiguration(ctx)
		require.NoError(t, err)

		var configEntries []string
		for _, config := range globalConfig {
			configEntries = append(configEntries, fmt.Sprintf(
				"%s=%s", strings.ToLower(config.Key), config.Value,
			))
		}

		return configEntries
	}()

	type setupData struct {
		config         []config.GitConfig
		options        []gitcmd.CmdOpt
		expectedConfig []string
	}

	for _, tc := range []struct {
		desc  string
		setup func() setupData
	}{
		{
			desc: "without config",
			setup: func() setupData {
				return setupData{
					expectedConfig: defaultConfig,
				}
			},
		},
		{
			desc: "config with simple entry",
			setup: func() setupData {
				return setupData{
					config: []config.GitConfig{
						{Key: "core.foo", Value: "bar"},
					},
					expectedConfig: append(defaultConfig, "core.foo=bar"),
				}
			},
		},
		{
			desc: "config with empty value",
			setup: func() setupData {
				return setupData{
					config: []config.GitConfig{
						{Key: "core.empty", Value: ""},
					},
					expectedConfig: append(defaultConfig, "core.empty="),
				}
			},
		},
		{
			desc: "config with subsection",
			setup: func() setupData {
				return setupData{
					config: []config.GitConfig{
						{Key: "http.http://example.com.proxy", Value: "http://proxy.example.com"},
					},
					expectedConfig: append(defaultConfig, "http.http://example.com.proxy=http://proxy.example.com"),
				}
			},
		},
		{
			desc: "config with multiple keys",
			setup: func() setupData {
				return setupData{
					config: []config.GitConfig{
						{Key: "core.foo", Value: "initial"},
						{Key: "core.foo", Value: "second"},
					},
					expectedConfig: append(defaultConfig, "core.foo=initial", "core.foo=second"),
				}
			},
		},
		{
			desc: "option",
			setup: func() setupData {
				return setupData{
					options: []gitcmd.CmdOpt{
						gitcmd.WithConfig(gitcmd.ConfigPair{Key: "core.foo", Value: "bar"}),
					},
					expectedConfig: append(defaultConfig, "core.foo=bar"),
				}
			},
		},
		{
			desc: "multiple options",
			setup: func() setupData {
				return setupData{
					options: []gitcmd.CmdOpt{
						gitcmd.WithConfig(
							gitcmd.ConfigPair{Key: "core.foo", Value: "initial"},
							gitcmd.ConfigPair{Key: "core.foo", Value: "second"},
						),
					},
					expectedConfig: append(defaultConfig, "core.foo=initial", "core.foo=second"),
				}
			},
		},
		{
			desc: "config comes after options",
			setup: func() setupData {
				return setupData{
					options: []gitcmd.CmdOpt{
						gitcmd.WithConfig(
							gitcmd.ConfigPair{Key: "from.option", Value: "value"},
						),
					},
					config: []config.GitConfig{
						{Key: "from.config", Value: "value"},
					},
					expectedConfig: append(defaultConfig, "from.option=value", "from.config=value"),
				}
			},
		},
	} {
		t.Run(tc.desc, func(t *testing.T) {
			repo, repoPath := gittest.CreateRepository(t, ctx, cfg, gittest.CreateRepositoryConfig{
				SkipCreationViaService: true,
				ObjectFormat:           "sha256",
			})
			require.NoError(t, os.Remove(filepath.Join(repoPath, "config")))

			setup := tc.setup()

			cfg.Git.Config = setup.config

			commandFactory, cleanup, err := gitcmd.NewExecCommandFactory(cfg, testhelper.SharedLogger(t))
			require.NoError(t, err)
			defer cleanup()

			var stdout bytes.Buffer
			cmd, err := commandFactory.New(ctx, repo, gitcmd.Command{
				Name: "config",
				Flags: []gitcmd.Option{
					gitcmd.Flag{Name: "--list"},
				},
			}, append(setup.options, gitcmd.WithStdout(&stdout))...)
			require.NoError(t, err)
			require.NoError(t, cmd.Wait())

			setup.expectedConfig = append(setup.expectedConfig, fmt.Sprintf("attr.tree=%s", git.ObjectHashSHA1.EmptyTreeOID.String()))

			require.ElementsMatch(t, setup.expectedConfig, strings.Split(text.ChompBytes(stdout.Bytes()), "\n"))
		})
	}
}

func TestExecCommandFactory_addAttrTree(t *testing.T) {
	t.Parallel()

	ctx := testhelper.Context(t)
	cfg := testcfg.Build(t)

	repoSHA1, _ := gittest.CreateRepository(t, ctx, cfg, gittest.CreateRepositoryConfig{
		SkipCreationViaService: true,
		ObjectFormat:           "sha1",
	})

	repoSHA256, _ := gittest.CreateRepository(t, ctx, cfg, gittest.CreateRepositoryConfig{
		SkipCreationViaService: true,
		ObjectFormat:           "sha256",
	})

	cfLogger := testhelper.SharedLogger(t)
	cf, cleanup, err := gitcmd.NewExecCommandFactory(cfg, cfLogger)
	require.NoError(t, err)
	defer cleanup()

	for _, tc := range []struct {
		desc                   string
		cmd                    string
		repo                   storage.Repository
		expectedAttrTreeConfig *gitcmd.ConfigPair
	}{
		{
			desc:                   "git diff without a repo path",
			cmd:                    "diff",
			repo:                   nil,
			expectedAttrTreeConfig: nil,
		},
		{
			desc: "git clone should have attr.tree = empty tree only",
			cmd:  "clone",
			repo: repoSHA256,
			expectedAttrTreeConfig: &gitcmd.ConfigPair{
				Key: "attr.tree", Value: git.ObjectHashSHA256.EmptyTreeOID.String(),
			},
		},
		{
			desc: "git config should have attr.tree = empty tree only",
			cmd:  "config",
			repo: repoSHA1,
			expectedAttrTreeConfig: &gitcmd.ConfigPair{
				Key: "attr.tree", Value: git.ObjectHashSHA1.EmptyTreeOID.String(),
			},
		},
		{
			desc: "git merge should have attr.tree = HEAD",
			cmd:  "merge",
			repo: repoSHA256,
			expectedAttrTreeConfig: &gitcmd.ConfigPair{
				Key: "attr.tree", Value: "HEAD",
			},
		},
		{
			desc: "git diff should have attr.tree = HEAD",
			cmd:  "diff",
			repo: repoSHA1,
			expectedAttrTreeConfig: &gitcmd.ConfigPair{
				Key: "attr.tree", Value: "HEAD",
			},
		},
		{
			desc: "git archive should have attr.tree = HEAD",
			cmd:  "archive",
			repo: repoSHA256,
			expectedAttrTreeConfig: &gitcmd.ConfigPair{
				Key: "attr.tree", Value: "HEAD",
			},
		},
		{
			desc: "git check-attr should have attr.tree = HEAD",
			cmd:  "check-attr",
			repo: repoSHA1,
			expectedAttrTreeConfig: &gitcmd.ConfigPair{
				Key: "attr.tree", Value: "HEAD",
			},
		},
		{
			desc: "git worktree should have attr.tree = HEAD",
			cmd:  "worktree",
			repo: repoSHA256,
			expectedAttrTreeConfig: &gitcmd.ConfigPair{
				Key: "attr.tree", Value: "HEAD",
			},
		},
		{
			desc: "git update-ref should have attr.tree = HEAD",
			cmd:  "update-ref",
			repo: repoSHA1,
			expectedAttrTreeConfig: &gitcmd.ConfigPair{
				Key: "attr.tree", Value: "HEAD",
			},
		},
		{
			desc: "git rev-parse should have attr.tree = HEAD",
			cmd:  "rev-parse",
			repo: repoSHA1,
			expectedAttrTreeConfig: &gitcmd.ConfigPair{
				Key: "attr.tree", Value: "HEAD",
			},
		},
		{
			desc: "git cat-file should have attr.tree = HEAD",
			cmd:  "cat-file",
			repo: repoSHA1,
			expectedAttrTreeConfig: &gitcmd.ConfigPair{
				Key: "attr.tree", Value: "HEAD",
			},
		},
	} {
		t.Run(tc.desc, func(t *testing.T) {
			cmd := gitcmd.Command{Name: tc.cmd}
			actualAttrTreeConfig, err := cf.AttrTreeConfig(ctx, tc.repo, cmd)
			require.NoError(t, err)
			require.Equal(t, tc.expectedAttrTreeConfig, actualAttrTreeConfig)
		})
	}
}

func TestCommandFactory_ExecutionEnvironment(t *testing.T) {
	testhelper.Unsetenv(t, "GITALY_TESTING_GIT_BINARY")

	ctx := testhelper.Context(t)

	assertExecEnv := func(t *testing.T, cfg config.Cfg, expectedExecEnv gitcmd.ExecutionEnvironment) {
		t.Helper()
		gitCmdFactory, cleanup, err := gitcmd.NewExecCommandFactory(cfg, testhelper.SharedLogger(t), gitcmd.WithSkipHooks())
		require.NoError(t, err)
		defer cleanup()

		// We need to compare the execution environments manually because they also have
		// some private variables which we cannot easily check here.
		actualExecEnv := gitCmdFactory.GetExecutionEnvironment(ctx)

		require.Equal(t, expectedExecEnv.EnvironmentVariables, actualExecEnv.EnvironmentVariables)
	}

	t.Run("set using GITALY_TESTING_GIT_BINARY", func(t *testing.T) {
		t.Setenv("GITALY_TESTING_GIT_BINARY", "/path/to/env_git")

		assertExecEnv(t, config.Cfg{}, gitcmd.ExecutionEnvironment{
			BinaryPath: "/path/to/env_git",
			EnvironmentVariables: []string{
				"NO_SET_GIT_TEMPLATE_DIR=YesPlease",
				"LANG=en_US.UTF-8",
				"GIT_TERMINAL_PROMPT=0",
				"GIT_CONFIG_GLOBAL=/dev/null",
				"GIT_CONFIG_SYSTEM=/dev/null",
				"XDG_CONFIG_HOME=/dev/null",
			},
		})
	})

	t.Run("set with the default bundled Git environment", func(t *testing.T) {
		suffix := gitcmd.BundledGitConstructors[0].Suffix

		cfg := testcfg.Build(t)

		gitCmdFactory, cleanup, err := gitcmd.NewExecCommandFactory(
			cfg,
			testhelper.SharedLogger(t),
			gitcmd.WithSkipHooks(),
			gitcmd.WithExecutionEnvironmentConstructors(
				gitcmd.BundledGitEnvironmentConstructor{
					Suffix: suffix,
				},
			),
		)
		require.NoError(t, err)
		defer cleanup()

		// When the command factory has been successfully created then we
		// verify that the symlink that it has created match what we expect.
		gitBinPath := gitCmdFactory.GetExecutionEnvironment(ctx).BinaryPath
		for _, binary := range []string{"git", "git-remote-http", "git-http-backend"} {
			symlinkPath := filepath.Join(filepath.Dir(gitBinPath), binary)

			target, err := os.Readlink(symlinkPath)
			require.NoError(t, err)
			require.Equal(t, filepath.Join(cfg.RuntimeDir, fmt.Sprintf("gitaly-%s%s", binary, suffix)), target)
		}
	})

	t.Run("selects bundled Git environment based on the MVCC reference backend", func(t *testing.T) {
		cfg := testcfg.Build(t)

		gitCmdFactory, cleanup, err := gitcmd.NewExecCommandFactory(cfg, testhelper.SharedLogger(t), gitcmd.WithSkipHooks())
		require.NoError(t, err)
		defer cleanup()

		// selectedSuffix resolves the "git" symlink of the selected execution environment to
		// determine which bundled Git binary was chosen, e.g. "-mvcc" or "-prev".
		selectedSuffix := func(ctx context.Context) string {
			gitBinPath := gitCmdFactory.GetExecutionEnvironment(ctx).BinaryPath
			target, err := os.Readlink(gitBinPath)
			require.NoError(t, err)
			return strings.TrimPrefix(filepath.Base(target), "gitaly-git")
		}

		// With a non-MVCC reference backend, the MVCC binary is not selected.
		ctx := featureflag.ContextWithFeatureFlag(testhelper.Context(t), featureflag.GitMaster, false)
		ctx = gitcmd.ContextWithReferenceBackend(ctx, git.ReferenceBackendReftables)
		require.Equal(t, "-prev", selectedSuffix(ctx))

		// With no reference backend in the context, the MVCC binary is not selected.
		ctx = featureflag.ContextWithFeatureFlag(testhelper.Context(t), featureflag.GitMaster, false)
		require.Equal(t, "-prev", selectedSuffix(ctx))

		// With an MVCC reference backend, the MVCC binary is selected.
		ctx = gitcmd.ContextWithReferenceBackend(testhelper.Context(t), git.ReferenceBackendMVCC)
		require.Equal(t, "-mvcc", selectedSuffix(ctx))
	})

	t.Run("doesn't exist in the system", func(t *testing.T) {
		testhelper.Unsetenv(t, "PATH")

		_, _, err := gitcmd.NewExecCommandFactory(config.Cfg{}, testhelper.SharedLogger(t), gitcmd.WithSkipHooks())
		require.ErrorContains(t, err, "setting up Git execution environment: constructing Git environment: checking bundled Git binary")
	})
}

func TestExecCommandFactoryHooksPath(t *testing.T) {
	ctx := testhelper.Context(t)

	t.Run("temporary hooks", func(t *testing.T) {
		cfg := testcfg.Build(t)
		cfg.BinDir = testhelper.TempDir(t)

		t.Run("no overrides", func(t *testing.T) {
			gitCmdFactory := gittest.NewCommandFactory(t, cfg)

			hooksPath := gitCmdFactory.HooksPath(ctx)

			// We cannot assert that the hooks path is equal to any specific
			// string, but instead we can assert that it exists and contains the
			// symlinks we expect.
			for _, hook := range []string{"update", "pre-receive", "post-receive", "reference-transaction"} {
				target, err := os.Readlink(filepath.Join(hooksPath, hook))
				require.NoError(t, err)
				require.Equal(t, cfg.BinaryPath("gitaly-hooks"), target)
			}
		})

		t.Run("with skip", func(t *testing.T) {
			gitCmdFactory := gittest.NewCommandFactory(t, cfg, gitcmd.WithSkipHooks())
			require.Equal(t, "/var/empty", gitCmdFactory.HooksPath(ctx))
		})
	})

	t.Run("hooks path", func(t *testing.T) {
		cfg := testcfg.Build(t)
		cfg.BinDir = testhelper.TempDir(t)

		gitCmdFactory := gittest.NewCommandFactory(t, cfg, gitcmd.WithHooksPath("/hooks/path"))

		// The environment variable shouldn't override an explicitly set hooks path.
		require.Equal(t, "/hooks/path", gitCmdFactory.HooksPath(ctx))
	})
}

func TestExecCommandFactory_GitVersion(t *testing.T) {
	ctx := testhelper.Context(t)

	generateVersionScript := func(version string) func(gitcmd.ExecutionEnvironment) string {
		return func(gitcmd.ExecutionEnvironment) string {
			//nolint:gitaly-linters
			return fmt.Sprintf(
				`#!/usr/bin/env bash
				echo '%s'
			`, version)
		}
	}

	for _, tc := range []struct {
		desc            string
		versionString   string
		expectedErr     string
		expectedVersion string
	}{
		{
			desc:            "valid version",
			versionString:   "git version 2.33.1.gl1",
			expectedVersion: "2.33.1.gl1",
		},
		{
			desc:            "valid version with trailing newline",
			versionString:   "git version 2.33.1.gl1\n",
			expectedVersion: "2.33.1.gl1",
		},
	} {
		t.Run(tc.desc, func(t *testing.T) {
			gitCmdFactory := gittest.NewInterceptingCommandFactory(
				t, ctx, testcfg.Build(t), generateVersionScript(tc.versionString),
				gittest.WithRealCommandFactoryOptions(gitcmd.WithSkipHooks()),
				gittest.WithInterceptedVersion(),
			)

			actualVersion, err := gitCmdFactory.GitVersion(ctx)
			if tc.expectedErr == "" {
				require.NoError(t, err)
			} else {
				require.EqualError(t, err, tc.expectedErr)
			}
			require.Equal(t, tc.expectedVersion, actualVersion)
		})
	}

	t.Run("caching", func(t *testing.T) {
		gitCmdFactory := gittest.NewInterceptingCommandFactory(
			t, ctx, testcfg.Build(t), generateVersionScript("git version 1.2.3"),
			gittest.WithRealCommandFactoryOptions(gitcmd.WithSkipHooks()),
			gittest.WithInterceptedVersion(),
		)

		gitPath := gitCmdFactory.GetExecutionEnvironment(ctx).BinaryPath
		stat, err := os.Stat(gitPath)
		require.NoError(t, err)

		version, err := gitCmdFactory.GitVersion(ctx)
		require.NoError(t, err)
		require.Equal(t, "1.2.3", version)

		// We rewrite the file with the same content length and modification time such that
		// its file information doesn't change. As a result, information returned by
		// stat(3P) shouldn't differ and we should continue to see the cached version. This
		// is a known insufficiency, but it is extremely unlikely to ever happen in
		// production when the real Git binary changes.
		require.NoError(t, os.Remove(gitPath))
		testhelper.WriteExecutable(t, gitPath, []byte(generateVersionScript("git version 9.8.7")(gitcmd.ExecutionEnvironment{})))
		require.NoError(t, os.Chtimes(gitPath, stat.ModTime(), stat.ModTime()))

		// Given that we continue to use the cached version we shouldn't see any
		// change here.
		version, err = gitCmdFactory.GitVersion(ctx)
		require.NoError(t, err)
		require.Equal(t, "1.2.3", version)

		// If we really replace the Git binary with something else, then we should
		// see a changed version.
		require.NoError(t, os.Remove(gitPath))
		testhelper.WriteExecutable(t, gitPath, []byte(
			`#!/usr/bin/env bash
			echo 'git version 2.34.1'
		`))

		version, err = gitCmdFactory.GitVersion(ctx)
		require.NoError(t, err)
		require.Equal(t, "2.34.1", version)
	})
}

func TestExecCommandFactory_config(t *testing.T) {
	t.Parallel()

	ctx := testhelper.Context(t)
	cfg := testcfg.Build(t)

	// Create a repository and remove its gitconfig to bring us into a known state where there
	// is no repo-level configuration that interferes with our test.
	repo, repoDir := gittest.CreateRepository(t, ctx, cfg, gittest.CreateRepositoryConfig{
		SkipCreationViaService: true,
	})
	require.NoError(t, os.Remove(filepath.Join(repoDir, "config")))

	expectedEnv := []string{
		"gc.auto=0",
		"maintenance.auto=0",
		"core.autocrlf=false",
		"core.usereplacerefs=false",
		"core.bigfilethreshold=50m",
		"pack.allowpackreuse=multi",
		"midx.version=1",
	}

	expectedEnv = append(expectedEnv,
		"core.fsync=objects,derived-metadata,reference",
		"core.fsyncmethod=fsync",
		"core.packedrefstimeout=10000",
		"reftable.locktimeout=10000",
		"core.filesreflocktimeout=1000",
	)

	expectedEnv = append(expectedEnv, fmt.Sprintf("attr.tree=%s", git.ObjectHashSHA1.EmptyTreeOID))

	gitCmdFactory := gittest.NewCommandFactory(t, cfg)

	var stdout bytes.Buffer
	cmd, err := gitCmdFactory.New(ctx, repo, gitcmd.Command{
		Name: "config",
		Flags: []gitcmd.Option{
			gitcmd.Flag{Name: "--list"},
		},
	}, gitcmd.WithStdout(&stdout))
	require.NoError(t, err)

	require.NoError(t, cmd.Wait())
	require.Equal(t, expectedEnv, strings.Split(strings.TrimSpace(stdout.String()), "\n"))
}

// TestFsckConfiguration tests the hardcoded configuration of the
// git fsck subcommand generated through the command factory.
func TestFsckConfiguration(t *testing.T) {
	t.Parallel()

	for _, tc := range []struct {
		desc string
		data string
	}{
		{
			desc: "with valid commit",
			data: strings.Join([]string{
				"tree " + gittest.DefaultObjectHash.EmptyTreeOID.String(),
				"author " + gittest.DefaultCommitterSignature,
				"committer " + gittest.DefaultCommitterSignature,
				"",
				"message",
			}, "\n"),
		},
		{
			desc: "with missing space",
			data: strings.Join([]string{
				"tree " + gittest.DefaultObjectHash.EmptyTreeOID.String(),
				"author Scrooge McDuck <[email protected]>1659043074 -0500",
				"committer Scrooge McDuck <[email protected]>1659975573 -0500",
				"",
				"message",
			}, "\n"),
		},
		{
			desc: "with bad timezone",
			data: strings.Join([]string{
				"tree " + gittest.DefaultObjectHash.EmptyTreeOID.String(),
				"author Scrooge McDuck <[email protected]> 1659043074 -0500BAD",
				"committer Scrooge McDuck <[email protected]> 1659975573 -0500BAD",
				"",
				"message",
			}, "\n"),
		},
	} {
		t.Run(tc.desc, func(t *testing.T) {
			ctx := testhelper.Context(t)
			cfg := testcfg.Build(t)
			repoProto, repoPath := gittest.CreateRepository(t, ctx, cfg,
				gittest.CreateRepositoryConfig{SkipCreationViaService: true},
			)

			// Create commit object.
			commitOut := gittest.ExecOpts(t, cfg, gittest.ExecConfig{Stdin: bytes.NewBufferString(tc.data)},
				"-C", repoPath, "hash-object", "-w", "-t", "commit", "--stdin", "--literally",
			)
			_, err := gittest.DefaultObjectHash.FromHex(text.ChompBytes(commitOut))
			require.NoError(t, err)

			gitCmdFactory, cleanup, err := gitcmd.NewExecCommandFactory(cfg, testhelper.SharedLogger(t))
			require.NoError(t, err)
			defer cleanup()

			// Create fsck command with configured ignore rules options.
			cmd, err := gitCmdFactory.New(ctx, repoProto,
				gitcmd.Command{Name: "fsck"},
			)
			require.NoError(t, err)

			// Execute git fsck command.
			err = cmd.Wait()
			require.NoError(t, err)
		})
	}
}

type dummyHook struct {
	name    string
	handler func(context.Context, *trace2.Trace) error
}

func (h *dummyHook) Name() string {
	return h.name
}

func (h *dummyHook) Handle(ctx context.Context, trace *trace2.Trace) error {
	return h.handler(ctx, trace)
}

func TestWithTrace2Hooks(t *testing.T) {
	t.Parallel()

	extractEventNames := func(trace *trace2.Trace) []string {
		var names []string
		trace.Walk(testhelper.Context(t), func(ctx context.Context, trace *trace2.Trace) context.Context {
			names = append(names, trace.Name)
			return nil
		})
		return names
	}

	// Trace2 outputs differently between platforms. It may include irrelevant events. In some
	// rare cases, it can also re-order the events, leading to flaky tests. So, we assert the
	// presences of essential events of the tested Git command.
	essentialEvents := []string{
		"pack-objects:enumerate-objects",
		"pack-objects:prepare-pack",
		"pack-objects:write-pack-file",
		"data:pack-objects:write_pack_file/wrote",
	}

	for _, tc := range []struct {
		desc           string
		setup          func(t *testing.T) []trace2.Hook
		expectedFields map[string]any
		withFields     bool
	}{
		{
			desc: "trace2 hook runs successfully",
			setup: func(t *testing.T) []trace2.Hook {
				return []trace2.Hook{
					&dummyHook{
						name: "dummy",
						handler: func(ctx context.Context, trace *trace2.Trace) error {
							require.Subset(t, extractEventNames(trace), essentialEvents)
							return nil
						},
					},
				}
			},
			withFields: true,
			expectedFields: map[string]any{
				"trace2.activated": "true",
				"trace2.hooks":     "dummy",
			},
		},
		{
			desc: "multiple trace2 hooks run successfully",
			setup: func(t *testing.T) []trace2.Hook {
				return []trace2.Hook{
					&dummyHook{
						name: "dummy",
						handler: func(ctx context.Context, trace *trace2.Trace) error {
							require.Subset(t, extractEventNames(trace), essentialEvents)
							return nil
						},
					},
					&dummyHook{
						name: "dummy2",
						handler: func(ctx context.Context, trace *trace2.Trace) error {
							require.Subset(t, extractEventNames(trace), essentialEvents)
							return nil
						},
					},
				}
			},
			withFields: true,
			expectedFields: map[string]any{
				"trace2.activated": "true",
				"trace2.hooks":     "dummy,dummy2",
			},
		},
		{
			desc: "no hooks provided",
			setup: func(t *testing.T) []trace2.Hook {
				return []trace2.Hook{}
			},
			withFields: true,
			expectedFields: map[string]any{
				"trace2.activated": nil,
				"trace2.hooks":     nil,
			},
		},
		{
			desc: "trace2 hook returns error",
			setup: func(t *testing.T) []trace2.Hook {
				return []trace2.Hook{
					&dummyHook{
						name: "dummy",
						handler: func(ctx context.Context, trace *trace2.Trace) error {
							return fmt.Errorf("something goes wrong")
						},
					},
					&dummyHook{
						name: "dummy2",
						handler: func(ctx context.Context, trace *trace2.Trace) error {
							require.Fail(t, "should not trigger hook after prior one fails")
							return nil
						},
					},
				}
			},
			withFields: true,
			expectedFields: map[string]any{
				"trace2.activated": "true",
				"trace2.hooks":     "dummy,dummy2",
				"trace2.error":     `trace2: executing "dummy" handler: something goes wrong`,
			},
		},
		{
			desc: "context does not initialize custom fields",
			setup: func(t *testing.T) []trace2.Hook {
				return []trace2.Hook{
					&dummyHook{
						name: "dummy",
						handler: func(ctx context.Context, trace *trace2.Trace) error {
							require.Subset(t, extractEventNames(trace), essentialEvents)
							return nil
						},
					},
				}
			},
			withFields: false,
		},
	} {
		t.Run(tc.desc, func(t *testing.T) {
			hooks := tc.setup(t)
			ctx := testhelper.Context(t)
			if tc.withFields {
				ctx = log.InitContextCustomFields(ctx)
			}

			performPackObjectGit(t, ctx, gitcmd.WithTrace2Hooks(hooks))

			if tc.withFields {
				customFields := log.CustomFieldsFromContext(ctx)
				require.NotNil(t, customFields)

				logrusFields := customFields.Fields()
				for key, value := range tc.expectedFields {
					require.Equal(t, value, logrusFields[key])
				}
			} else {
				require.Nil(t, log.CustomFieldsFromContext(ctx))
			}
		})
	}
}

func TestTrace2TracingExporter(t *testing.T) {
	for _, tc := range []struct {
		desc          string
		tracerOptions []testhelper.StubTracingReporterOption
		setup         func(*testing.T, context.Context) context.Context
		assert        func(*testing.T, []string, map[string]any)
	}{
		{
			desc: "there is no active span",
			setup: func(t *testing.T, ctx context.Context) context.Context {
				return ctx
			},
			assert: func(t *testing.T, spans []string, statFields map[string]any) {
				require.NotContains(t, statFields, "trace2.activated")
				require.NotContains(t, statFields, "trace2.hooks")
				for _, span := range spans {
					require.NotEqual(t, "trace2.parse", span)
				}
			},
		},
		{
			desc: "active span is sampled",
			setup: func(t *testing.T, ctx context.Context) context.Context {
				tr := otel.GetTracerProvider().Tracer(t.Name())
				spanCtx, span := tr.Start(ctx, "root")
				span.End()
				return spanCtx
			},
			assert: func(t *testing.T, spans []string, statFields map[string]any) {
				require.Equal(t, statFields["trace2.activated"], "true")
				require.Equal(t, statFields["trace2.hooks"], "tracing_exporter")
				require.Subset(t, spans, []string{
					"git-rev-list",
					"git",
					"git:version",
					"git:start",
					"trace2.parse",
				})
			},
		},
		{
			desc:          "active span is not sampled",
			tracerOptions: []testhelper.StubTracingReporterOption{testhelper.NeverSampled()},
			setup: func(t *testing.T, ctx context.Context) context.Context {
				tr := otel.GetTracerProvider().Tracer(t.Name())
				spanCtx, span := tr.Start(ctx, "root")
				span.End()
				return spanCtx
			},
			assert: func(t *testing.T, spans []string, statFields map[string]any) {
				require.NotContains(t, statFields, "trace2.activated")
				require.NotContains(t, statFields, "trace2.hooks")
				for _, span := range spans {
					require.NotEqual(t, "trace2.parse", span)
				}
			},
		},
	} {
		t.Run(tc.desc, func(t *testing.T) {
			reporter := testhelper.NewStubTracingReporter(t, tc.tracerOptions...)
			defer func() { _ = reporter.Close() }()

			ctx := tc.setup(t, log.InitContextCustomFields(testhelper.Context(t)))
			performRevList(t, ctx)

			customFields := log.CustomFieldsFromContext(ctx)
			require.NotNil(t, customFields)
			statFields := customFields.Fields()

			var spans []string
			for _, span := range reporter.GetSpans() {
				spans = append(spans, span.Name)
			}

			tc.assert(t, spans, statFields)
		})
	}
}

func TestTrace2PackObjectsMetrics(t *testing.T) {
	t.Parallel()

	for _, tc := range []struct {
		desc              string
		performGitCommand func(t *testing.T, ctx context.Context, opts ...gitcmd.ExecCommandFactoryOption)
		assert            func(*testing.T, context.Context, log.Fields)
	}{
		{
			desc:              "git-pack-objects",
			performGitCommand: performPackObjectGit,
			assert: func(t *testing.T, ctx context.Context, statFields log.Fields) {
				require.Equal(t, "true", statFields["trace2.activated"])
				require.Equal(t, "pack_objects_metrics", statFields["trace2.hooks"])
				require.Contains(t, statFields, "pack_objects.enumerate_objects_ms")
				require.Contains(t, statFields, "pack_objects.prepare_pack_ms")
				require.Contains(t, statFields, "pack_objects.write_pack_file_ms")
				require.Equal(t, 1, statFields["pack_objects.written_object_count"])
			},
		},
		{
			desc: "other git command",
			performGitCommand: func(t *testing.T, ctx context.Context, opts ...gitcmd.ExecCommandFactoryOption) {
				cfg := testcfg.Build(t)
				repoProto, _ := gittest.CreateRepository(t, ctx, cfg,
					gittest.CreateRepositoryConfig{SkipCreationViaService: true},
				)
				gitCmdFactory, cleanup, err := gitcmd.NewExecCommandFactory(cfg, testhelper.SharedLogger(t), opts...)
				require.NoError(t, err)
				defer cleanup()

				cmd, err := gitCmdFactory.New(ctx, repoProto, gitcmd.Command{
					Name: "rev-list",
					Flags: []gitcmd.Option{
						gitcmd.Flag{Name: "--all"},
						gitcmd.Flag{Name: "--max-count=1"},
					},
				})
				require.NoError(t, err)

				err = cmd.Wait()
				require.NoError(t, err)
			},
			assert: func(t *testing.T, ctx context.Context, statFields log.Fields) {
				require.NotContains(t, statFields, "trace2.activated")
				require.NotContains(t, statFields, "trace2.hooks")
			},
		},
	} {
		t.Run(tc.desc, func(t *testing.T) {
			t.Parallel()

			ctx := log.InitContextCustomFields(testhelper.Context(t))
			tc.performGitCommand(t, ctx)

			customFields := log.CustomFieldsFromContext(ctx)
			require.NotNil(t, customFields)

			logrusFields := customFields.Fields()
			tc.assert(t, ctx, logrusFields)
		})
	}
}

// This test modifies global tracing tracer. Thus, it cannot run in parallel.
func TestDefaultTrace2HooksFor(t *testing.T) {
	for _, tc := range []struct {
		desc          string
		subCmd        string
		setup         func(t *testing.T) (context.Context, []trace2.Hook)
		tracerOptions []testhelper.StubTracingReporterOption
	}{
		{
			desc:   "there is no active span",
			subCmd: "status",
			setup: func(t *testing.T) (context.Context, []trace2.Hook) {
				ctx := testhelper.Context(t)
				return ctx, []trace2.Hook{}
			},
		},
		{
			desc:   "active span is sampled",
			subCmd: "status",
			setup: func(t *testing.T) (context.Context, []trace2.Hook) {
				span, ctx := tracing.StartSpan(testhelper.Context(t), "root", nil)
				defer span.End()
				return ctx, []trace2.Hook{
					trace2hooks.NewTracingExporter(),
				}
			},
		},
		{
			desc:   "active span is not sampled",
			subCmd: "status",
			setup: func(t *testing.T) (context.Context, []trace2.Hook) {
				span, ctx := tracing.StartSpan(testhelper.Context(t), "root", nil)
				defer span.End()
				return ctx, []trace2.Hook{}
			},
			tracerOptions: []testhelper.StubTracingReporterOption{testhelper.NeverSampled()},
		},
		{
			desc:   "subcmd is pack-objects but span is not sampled",
			subCmd: "pack-objects",
			setup: func(t *testing.T) (context.Context, []trace2.Hook) {
				return testhelper.Context(t), []trace2.Hook{
					trace2hooks.NewPackObjectsMetrics(),
				}
			},
		},
		{
			desc:   "subcmd is pack-objects and active span is sampled",
			subCmd: "pack-objects",
			setup: func(t *testing.T) (context.Context, []trace2.Hook) {
				span, ctx := tracing.StartSpan(testhelper.Context(t), "root", nil)
				defer span.End()
				hooks := []trace2.Hook{
					trace2hooks.NewTracingExporter(),
					trace2hooks.NewPackObjectsMetrics(),
				}

				return ctx, hooks
			},
		},
		{
			desc:   "subcmd is pack-objects, active span is sampled and feature flag LogGitTraces enabled",
			subCmd: "pack-objects",
			setup: func(t *testing.T) (context.Context, []trace2.Hook) {
				ctx := testhelper.Context(t)
				ctx = featureflag.ContextWithFeatureFlag(ctx, featureflag.LogGitTraces, true)
				span, ctx := tracing.StartSpan(ctx, "root", nil)
				defer span.End()
				hooks := []trace2.Hook{
					trace2hooks.NewTracingExporter(),
					trace2hooks.NewPackObjectsMetrics(),
					trace2hooks.NewLogExporter(rate.NewLimiter(1, 1), testhelper.SharedLogger(t)),
				}

				return ctx, hooks
			},
		},
	} {
		t.Run(tc.desc, func(t *testing.T) {
			reporter := testhelper.NewStubTracingReporter(t, tc.tracerOptions...)
			defer func() { _ = reporter.Close() }()

			ctx, expectedHooks := tc.setup(t)
			hooks := gitcmd.DefaultTrace2HooksFor(ctx, tc.subCmd, testhelper.SharedLogger(t), rate.NewLimiter(1, 1))

			require.Equal(t, hookNames(expectedHooks), hookNames(hooks))
		})
	}
}

func performPackObjectGit(t *testing.T, ctx context.Context, opts ...gitcmd.ExecCommandFactoryOption) {
	cfg := testcfg.Build(t)
	repoProto, repoPath := gittest.CreateRepository(t, ctx, cfg,
		gittest.CreateRepositoryConfig{SkipCreationViaService: true},
	)

	var input bytes.Buffer
	for i := 0; i <= 10; i++ {
		input.WriteString(gittest.WriteCommit(t, cfg, repoPath).String())
		input.WriteString("\n")
	}

	gitCmdFactory, cleanup, err := gitcmd.NewExecCommandFactory(cfg, testhelper.SharedLogger(t), opts...)
	require.NoError(t, err)
	defer cleanup()

	cmd, err := gitCmdFactory.New(ctx, repoProto, gitcmd.Command{
		Name: "pack-objects",
		Flags: []gitcmd.Option{
			gitcmd.Flag{Name: "--compression=0"},
			gitcmd.Flag{Name: "--stdout"},
			gitcmd.Flag{Name: "-q"},
		},
	}, gitcmd.WithStdin(&input))
	require.NoError(t, err)

	err = cmd.Wait()
	require.NoError(t, err)
}

func performRevList(t *testing.T, ctx context.Context, opts ...gitcmd.ExecCommandFactoryOption) {
	cfg := testcfg.Build(t)
	repoProto, _ := gittest.CreateRepository(t, ctx, cfg,
		gittest.CreateRepositoryConfig{SkipCreationViaService: true},
	)
	gitCmdFactory, cleanup, err := gitcmd.NewExecCommandFactory(cfg, testhelper.SharedLogger(t), opts...)
	require.NoError(t, err)
	defer cleanup()

	cmd, err := gitCmdFactory.New(ctx, repoProto, gitcmd.Command{
		Name: "rev-list",
		Flags: []gitcmd.Option{
			gitcmd.Flag{Name: "--max-count=10"},
			gitcmd.Flag{Name: "--all"},
		},
	})
	require.NoError(t, err)

	err = cmd.Wait()
	require.NoError(t, err)
}

func hookNames(hooks []trace2.Hook) []string {
	var names []string
	for _, hook := range hooks {
		names = append(names, hook.Name())
	}
	return names
}