Skip to content

Git designed for AI agents.

37.1 KB
Raw Blame
// Package e2e holds Graft's end-to-end tests. They run the standalone server,
// the cache tiers and the SDK together in one process, the way an operator
// deploys them, but without spawning the graft or graft-cache binaries.
//
// The configuration of the standalone server comes from
// examples/graft/config.toml, so the example stays a working configuration.
package e2e

import (
	"context"
	"fmt"
	"net"
	"os"
	"path/filepath"
	"sort"
	"strings"
	"sync"
	"testing"
	"time"

	"github.com/stretchr/testify/require"
	"google.golang.org/grpc"
	"google.golang.org/grpc/codes"
	healthpb "google.golang.org/grpc/health/grpc_health_v1"

	gitalyauth "github.com/feder-cr/git-ai/auth"
	"github.com/feder-cr/git-ai/client"
	"github.com/feder-cr/git-ai/internal/featureflag"
	"github.com/feder-cr/git-ai/internal/git"
	"github.com/feder-cr/git-ai/internal/git/gittest"
	"github.com/feder-cr/git-ai/internal/gitaly/config"
	"github.com/feder-cr/git-ai/internal/gitaly/service/setup"
	"github.com/feder-cr/git-ai/internal/gitlab"
	"github.com/feder-cr/git-ai/internal/graft/cachetier"
	"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/proto/go/gitalypb"
	"github.com/feder-cr/git-ai/sdk"
)

// exampleConfigPath is the example configuration, relative to this package.
const exampleConfigPath = "../../../examples/graft/config.toml"

// exampleTokens are the agent secrets written to the token files that the
// example configuration names.
var exampleTokens = map[string]string{
	"planner": "planner-secret-for-tests",
	"builder": "builder-secret-for-tests",
}

// gitalyStack is a standalone Gitaly server with one repository. The server
// answers access checks from the policy of its configuration, as the graft
// binary does in standalone mode.
type gitalyStack struct {
	ctx      context.Context
	cfg      config.Cfg
	addr     string
	storage  string
	relPath  string
	repoPath string
}

// sharedTestToken is the shared token of the test servers that configure
// agents. The test helpers use it for setup calls, which carry no agent
// identity.
const sharedTestToken = "shared-test-token"

// exampleConfig is the part of examples/graft/config.toml that the tests run.
type exampleConfig struct {
	graft       config.Graft
	sharedToken string
}

// loadExample loads examples/graft/config.toml. The paths in the file are
// rewritten into a temporary directory, the whole file must validate, and the
// agent token files are written there.
func loadExample(t *testing.T) exampleConfig {
	t.Helper()

	root := t.TempDir()
	dirs := map[string]string{
		"/var/lib/graft/run":   filepath.Join(root, "run"),
		"/var/lib/graft/repos": filepath.Join(root, "repos"),
		"/var/lib/graft/bin":   filepath.Join(root, "bin"),
		"/etc/graft/tokens":    filepath.Join(root, "tokens"),
	}
	for _, dir := range dirs {
		require.NoError(t, os.MkdirAll(dir, 0o700))
	}

	data, err := os.ReadFile(exampleConfigPath)
	require.NoError(t, err)
	text := string(data)
	for from, to := range dirs {
		text = strings.ReplaceAll(text, from, to)
	}

	for name, token := range exampleTokens {
		require.NoError(t, os.WriteFile(filepath.Join(dirs["/etc/graft/tokens"], name), []byte(token+"\n"), 0o600))
	}

	cfg, err := config.Load(strings.NewReader(text))
	require.NoError(t, err, "the example configuration must load")

	// Validate the whole file, not only the Graft section. The directories
	// it names exist, and the GitLab settings are not required in standalone
	// mode.
	cfg.Gitlab = config.Gitlab{}
	cfg.GitlabShell = config.GitlabShell{}
	require.NoError(t, cfg.Validate(), "the example configuration must validate")

	return exampleConfig{graft: cfg.Graft, sharedToken: cfg.Auth.Token}
}

// startExample starts the standalone server of the example configuration.
func startExample(t *testing.T) gitalyStack {
	t.Helper()

	ex := loadExample(t)
	return startGitaly(t, ex.graft, ex.sharedToken)
}

// unbatched returns graft with batched landing turned off. The phase-1 and
// phase-2 scenarios check per-request "land" changesets (operation, actor,
// count); with batching on, concurrent lands on main are recorded as one
// "land_batch" changeset whose members carry the actors. Batching itself is
// covered by phase3_test.go.
func unbatched(graft config.Graft) config.Graft {
	graft.Land.Batch.Disabled = true
	return graft
}

// startExampleUnbatched starts the example configuration with batching off,
// see unbatched.
func startExampleUnbatched(t *testing.T) gitalyStack {
	t.Helper()

	ex := loadExample(t)
	return startGitaly(t, unbatched(ex.graft), ex.sharedToken)
}

// startGitaly starts a standalone Gitaly with every service registered and
// creates an empty repository on it. The shared token authorizes the setup
// calls of the test helpers.
func startGitaly(t *testing.T, graft config.Graft, sharedToken string, opts ...testserver.GitalyServerOpt) gitalyStack {
	t.Helper()

	return startGitalyInMode(t, graft, sharedToken, true, opts...)
}

// startGitalyInMode is startGitaly with standalone mode on or off. Off, the agents of
// graft still authenticate, but the request defaults and the policy of standalone
// mode do not apply; the access checks of the pre-receive hook still go to the
// standalone client, which stands in for GitLab here.
func startGitalyInMode(t *testing.T, graft config.Graft, sharedToken string, standalone bool, opts ...testserver.GitalyServerOpt) gitalyStack {
	t.Helper()

	ctx := featureflag.OutgoingCtxWithFeatureFlag(testhelper.Context(t), featureflag.GPGSigning, false)
	cfg := testcfg.Build(t)
	cfg.Auth.Token = sharedToken
	cfg.Graft = graft
	cfg.Graft.Standalone = standalone

	testcfg.BuildGitalySSH(t, cfg)
	testcfg.BuildGitalyHooks(t, cfg)

	addr := testserver.RunGitalyServer(t, cfg, setup.RegisterAll, append([]testserver.GitalyServerOpt{
		testserver.WithGitLabClient(gitlab.NewStandaloneClient(cfg.Graft, testhelper.SharedLogger(t))),
	}, opts...)...)
	cfg.SocketPath = addr

	// Only the setup call carries gitaly-servers metadata. The context of the
	// stack is used for agent calls too, and agents may not send it.
	setupCtx := testhelper.MergeOutgoingMetadata(ctx, testcfg.GitalyServersMetadataFromCfg(t, cfg))
	repoProto, repoPath := gittest.CreateRepository(t, setupCtx, cfg)

	return gitalyStack{
		ctx:      ctx,
		cfg:      cfg,
		addr:     addr,
		storage:  cfg.Storages[0].Name,
		relPath:  repoProto.GetRelativePath(),
		repoPath: repoPath,
	}
}

// repoAs returns a handle to the repository whose requests carry token as a
// plain agent bearer token. An empty token sends no authorization.
func (s gitalyStack) repoAs(t *testing.T, token string) *sdk.Repo {
	t.Helper()

	opts := []sdk.DialOption{sdk.WithStorage(s.storage)}
	if token != "" {
		opts = append(opts, sdk.WithAgentToken(token))
	}
	conn, err := sdk.Dial(s.ctx, s.addr, opts...)
	require.NoError(t, err)
	t.Cleanup(func() { _ = conn.Close() })

	return conn.Repo(s.relPath)
}

// git runs a Git command in the repository and returns its output.
func (s gitalyStack) git(t *testing.T, args ...string) string {
	t.Helper()

	return strings.TrimSpace(string(gittest.Exec(t, s.cfg, append([]string{"-C", s.repoPath}, args...)...)))
}

// writeMain points main at a commit whose tree holds files.
func writeMain(t *testing.T, s gitalyStack, files map[string]string, parents ...string) string {
	t.Helper()

	entries := make([]gittest.TreeEntry, 0, len(files))
	for path, content := range files {
		entries = append(entries, gittest.TreeEntry{Mode: "100644", Path: path, Content: content})
	}

	parentIDs := make([]git.ObjectID, 0, len(parents))
	for _, parent := range parents {
		parentIDs = append(parentIDs, git.ObjectID(parent))
	}

	return gittest.WriteCommit(t, s.cfg, s.repoPath,
		gittest.WithBranch("main"),
		gittest.WithTreeEntries(entries...),
		gittest.WithParents(parentIDs...),
	).String()
}

// commitFile creates a commit on branch that adds path to startRev. The
// author and the acting user of the commit are who.
func commitFile(ctx context.Context, repo *sdk.Repo, who, branch, startRev, path, content string) (string, error) {
	res, err := repo.CommitFiles(ctx, sdk.CommitOptions{
		Branch:   branch,
		StartRev: startRev,
		Message:  "add " + path,
		Author:   sdk.Signature{Name: who, Email: who + "@example.com"},
		// CommitFiles does not fill in the acting user, so the ID is set.
		User:    sdk.User{ID: who, Name: who, Email: who + "@example.com"},
		Actions: []sdk.Action{sdk.Put{Path: path, Content: []byte(content)}},
	})
	if err != nil {
		return "", err
	}

	return res.CommitID, nil
}

// clientDisplayName is the name that landAs sends as the acting user. It is
// deliberately not an agent name, so a test that sees an agent name as the
// actor knows the server took it from the token and not from the request.
const clientDisplayName = "client-supplied display name"

// landAs lands commit on branch, creating the branch if it does not exist.
// The acting user has a display name and an address but no ID, so the server
// fills in the identity of the token. The actor of the land must therefore be
// who, never clientDisplayName.
func landAs(ctx context.Context, repo *sdk.Repo, who, branch, commit string) (*sdk.LandResult, error) {
	return repo.Land(ctx, sdk.LandOptions{
		Branch:       branch,
		Commit:       commit,
		User:         sdk.User{Name: clientDisplayName, Email: who + "@example.com"},
		CreateBranch: true,
	})
}

// allChangesets pages through the changeset log with a small page size.
func allChangesets(ctx context.Context, t *testing.T, repo *sdk.Repo) []*sdk.Changeset {
	t.Helper()

	var all []*sdk.Changeset
	var after uint64
	for {
		page, err := repo.Changesets(ctx, after, 7)
		require.NoError(t, err)
		if len(page) == 0 {
			return all
		}
		all = append(all, page...)
		after = page[len(page)-1].GetSequence()
	}
}

// requireDense checks that the changesets have sequences 1, 2, ... without gaps.
func requireDense(t *testing.T, changesets []*sdk.Changeset) {
	t.Helper()

	for i, c := range changesets {
		require.Equal(t, uint64(i+1), c.GetSequence(), "changeset %d", i)
	}
}

// landsOn returns the changesets with operation "land" on ref.
func landsOn(changesets []*sdk.Changeset, ref string) []*sdk.Changeset {
	var lands []*sdk.Changeset
	for _, c := range changesets {
		if c.GetOperation() == "land" && string(c.GetReference()) == ref {
			lands = append(lands, c)
		}
	}
	return lands
}

// startTier starts a cache tier that serves ObjectService from its cache and
// proxies every other RPC to upstream. It returns the tier's address and the
// tier itself, whose Stats report hits and misses.
func startTier(t *testing.T, upstream string, cfg cachetier.Config) (string, *cachetier.Server) {
	t.Helper()
	ctx := testhelper.Context(t)

	logger := testhelper.SharedLogger(t)
	conn, err := cachetier.DialUpstream(ctx, upstream, logger)
	require.NoError(t, err)
	t.Cleanup(func() { _ = conn.Close() })

	cfg.Logger = logger
	if cfg.MaxBytes == 0 {
		cfg.MaxBytes = 64 << 20
	}
	server, err := cachetier.NewServer(conn, cfg)
	require.NoError(t, err)

	listener, err := net.Listen("tcp", "127.0.0.1:0")
	require.NoError(t, err)
	grpcServer := cachetier.NewGRPCServer(server)
	go func() { _ = grpcServer.Serve(listener) }()
	t.Cleanup(grpcServer.Stop)

	return "tcp://" + listener.Addr().String(), server
}

// blobsOf returns the blob object IDs of a recursive tree listing.
func blobsOf(t *testing.T, repo *sdk.Repo, rev string) map[string]string {
	t.Helper()

	entries, err := repo.ListTree(testhelper.Context(t), rev, "", true)
	require.NoError(t, err)

	blobs := map[string]string{}
	for _, e := range entries {
		if e.Type == gitalypb.ObjectType_BLOB {
			blobs[e.OID] = e.Path
		}
	}
	return blobs
}

// workerName returns the agent name of worker i.
func workerName(i int) string {
	return fmt.Sprintf("worker-%02d", i)
}

// TestStandaloneSetup starts Gitaly with [graft] standalone = true, two agents
// and a policy, from the example configuration, and checks that the server
// starts without GitLab configured. Health checks need no token, agent
// tokens are accepted, and unknown tokens are rejected. Covers WP1 and WP2.
func TestStandaloneSetup(t *testing.T) {
	t.Parallel()

	ex := loadExample(t)
	require.True(t, ex.graft.Standalone)
	require.Len(t, ex.graft.Agents, 2)
	require.Len(t, ex.graft.Policy, 3)

	s := startGitaly(t, ex.graft, ex.sharedToken)

	t.Run("health check answers without a token", func(t *testing.T) {
		conn, err := client.DialContext(s.ctx, s.addr)
		require.NoError(t, err)
		t.Cleanup(func() { _ = conn.Close() })

		resp, err := healthpb.NewHealthClient(conn).Check(s.ctx, &healthpb.HealthCheckRequest{})
		require.NoError(t, err)
		require.Equal(t, healthpb.HealthCheckResponse_SERVING, resp.GetStatus())
	})

	writeMain(t, s, map[string]string{"README.md": "hello graft\n"})

	t.Run("agent token is accepted", func(t *testing.T) {
		_, err := s.repoAs(t, exampleTokens["planner"]).ResolveRevision(s.ctx, "main")
		require.NoError(t, err)
	})

	t.Run("missing token is rejected", func(t *testing.T) {
		_, err := s.repoAs(t, "").ResolveRevision(s.ctx, "main")
		require.Equal(t, codes.Unauthenticated, sdk.Code(err), "got %v", err)
	})

	t.Run("unknown token is rejected", func(t *testing.T) {
		_, err := s.repoAs(t, "not-an-agent").ResolveRevision(s.ctx, "main")
		require.Equal(t, codes.Unauthenticated, sdk.Code(err), "got %v", err)
	})
}

// TestAgentIdentitiesAndDefaults checks that every agent token maps to its
// agent name, and that a land without a user ID is recorded for the agent
// whose token made the request. Covers WP2 (identities, request defaults) and
// WP5 (actors in the changeset log).
func TestAgentIdentitiesAndDefaults(t *testing.T) {
	t.Parallel()

	s := startExampleUnbatched(t)
	base := writeMain(t, s, map[string]string{"README.md": "base\n"})

	planner := s.repoAs(t, exampleTokens["planner"])
	builder := s.repoAs(t, exampleTokens["builder"])

	topic, err := commitFile(s.ctx, planner, "planner", "planner/topic", base, "planner.txt", "from planner\n")
	require.NoError(t, err)

	res, err := landAs(s.ctx, planner, "planner", "main", topic)
	require.NoError(t, err)
	require.False(t, res.AlreadyLanded)
	require.Equal(t, topic, res.LandedCommitID, "a fast-forward lands the commit itself")

	feature, err := commitFile(s.ctx, builder, "builder", "builder/feature", base, "builder.txt", "from builder\n")
	require.NoError(t, err)
	_, err = landAs(s.ctx, builder, "builder", "feature/builder", feature)
	require.NoError(t, err, "the builder may create and land on feature branches")

	changesets := allChangesets(s.ctx, t, planner)
	requireDense(t, changesets)

	lands := landsOn(changesets, "refs/heads/main")
	require.Len(t, lands, 1)
	require.Equal(t, "planner", lands[0].GetActor())

	var builderLands []*sdk.Changeset
	for _, c := range changesets {
		if c.GetOperation() == "land" && c.GetActor() == "builder" {
			builderLands = append(builderLands, c)
		}
	}
	require.Len(t, builderLands, 1)
	require.Equal(t, "refs/heads/feature/builder", string(builderLands[0].GetReference()))

	for _, c := range changesets {
		if c.GetOperation() == "commit_files" {
			require.Contains(t, []string{"planner", "builder"}, c.GetActor())
		}
	}
}

// TestDaemonChainedToCache starts a graft-cache daemon tier whose upstream is
// a graft-cache cache tier whose upstream is Gitaly. A second daemon behind
// the same cache tier must be served from the cache tier, not from Gitaly.
// Covers WP7.
func TestDaemonChainedToCache(t *testing.T) {
	t.Parallel()

	s := startExample(t)
	base := writeMain(t, s, map[string]string{"README.md": "chained\n", "docs-a.txt": "a\n"})
	reader := s.repoAs(t, exampleTokens["planner"])

	cacheAddr, cacheTier := startTier(t, s.addr, cachetier.Config{
		Tier:    cachetier.TierCache,
		DiskDir: t.TempDir(),
	})
	daemonAddr, daemon := startTier(t, cacheAddr, cachetier.Config{Tier: cachetier.TierDaemon})

	blobs := blobsOf(t, reader, base)
	oids := make([]string, 0, len(blobs))
	for oid := range blobs {
		oids = append(oids, oid)
	}

	direct, err := reader.GetObjects(s.ctx, oids)
	require.NoError(t, err)

	first, err := daemonHandle(t, s, daemonAddr, exampleTokens["planner"]).GetObjects(s.ctx, oids)
	require.NoError(t, err)
	requireSameObjects(t, direct, first)
	require.NotZero(t, daemon.Stats().ObjectMisses)
	require.NotZero(t, cacheTier.Stats().MemoryEntries, "the cache tier must hold what the daemon fetched")

	// A fresh daemon has an empty memory cache. Its misses are served by the
	// cache tier, so the cache tier must report hits.
	freshAddr, fresh := startTier(t, cacheAddr, cachetier.Config{Tier: cachetier.TierDaemon})
	cacheHitsBefore := cacheTier.Stats().ObjectHits

	second, err := daemonHandle(t, s, freshAddr, exampleTokens["planner"]).GetObjects(s.ctx, oids)
	require.NoError(t, err)
	requireSameObjects(t, direct, second)
	require.Greater(t, cacheTier.Stats().ObjectHits, cacheHitsBefore, "the cache tier must serve the fresh daemon")
	require.Zero(t, fresh.Stats().ObjectHits, "the fresh daemon starts empty")
}

// daemonHandle returns a repository handle through a cache tier address. An
// empty token sends no authorization.
func daemonHandle(t *testing.T, s gitalyStack, addr, token string) *sdk.Repo {
	t.Helper()

	opts := []sdk.DialOption{sdk.WithStorage(s.storage)}
	if token != "" {
		opts = append(opts, sdk.WithAgentToken(token))
	}
	conn, err := sdk.Dial(s.ctx, addr, opts...)
	require.NoError(t, err)
	t.Cleanup(func() { _ = conn.Close() })

	return conn.Repo(s.relPath)
}

// requireSameObjects checks that two reads returned identical objects.
func requireSameObjects(t *testing.T, want, got []sdk.Object) {
	t.Helper()

	require.Len(t, got, len(want))
	byOID := map[string]sdk.Object{}
	for _, o := range want {
		byOID[o.OID] = o
	}
	for _, o := range got {
		require.Equal(t, byOID[o.OID].Type, o.Type, o.OID)
		require.Equal(t, byOID[o.OID].Data, o.Data, o.OID)
		require.Equal(t, byOID[o.OID].Missing, o.Missing, o.OID)
	}
}

// TestTwentyConcurrentLands creates a repository, then lets 20 agents land
// disjoint changes created from the same base commit onto main concurrently
// using UserLand (rebase strategy). Every land must succeed, the final tree
// must contain all 20 files, and history must be linear. Covers WP3, WP5 and
// WP8 (SDK Land).
func TestTwentyConcurrentLands(t *testing.T) {
	t.Parallel()

	const workers = 20
	graft, tokens := workerGraft(workers)
	s := startGitaly(t, unbatched(graft), sharedTestToken)
	base := writeMain(t, s, map[string]string{"README.md": "concurrent\n"})

	// Each worker has its own connection, so its token is its identity.
	repos := make([]*sdk.Repo, workers)
	for i := range repos {
		repos[i] = s.repoAs(t, tokens[workerName(i)])
	}

	// Commits are created before any land, so that every change starts from
	// the same base and the lands race for main.
	commits := make([]string, workers)
	for i := range repos {
		commit, err := commitFile(s.ctx, repos[i], workerName(i), "work/"+workerName(i), base,
			fmt.Sprintf("workers/%s.txt", workerName(i)), fmt.Sprintf("written by %s\n", workerName(i)))
		require.NoError(t, err)
		commits[i] = commit
	}

	start := make(chan struct{})
	var wg sync.WaitGroup
	results := make([]*sdk.LandResult, workers)
	errs := make([]error, workers)
	for i := range repos {
		wg.Add(1)
		go func(i int) {
			defer wg.Done()
			<-start
			results[i], errs[i] = landAs(s.ctx, repos[i], workerName(i), "main", commits[i])
		}(i)
	}
	close(start)
	wg.Wait()

	for i := range errs {
		require.NoError(t, errs[i], "land of %s", workerName(i))
		require.NotEmpty(t, results[i].LandedCommitID)
		require.False(t, results[i].AlreadyLanded, "land of %s", workerName(i))
	}

	tree := s.git(t, "ls-tree", "-r", "--name-only", "main")
	for i := 0; i < workers; i++ {
		require.Contains(t, tree, fmt.Sprintf("workers/%s.txt", workerName(i)))
	}
	require.Contains(t, tree, "README.md")

	require.Empty(t, s.git(t, "rev-list", "--merges", "main"), "history must be linear")
	require.Equal(t, fmt.Sprint(workers+1), s.git(t, "rev-list", "--count", "main"))

	lands := landsOn(allChangesets(s.ctx, t, repos[0]), "refs/heads/main")
	require.Len(t, lands, workers)
	actors := make([]string, 0, len(lands))
	for _, c := range lands {
		actors = append(actors, c.GetActor())
	}
	expected := make([]string, 0, workers)
	for i := 0; i < workers; i++ {
		expected = append(expected, workerName(i))
	}
	sort.Strings(actors)
	require.Equal(t, expected, actors, "each worker must be the actor of exactly one land, taken from its token")
}

// workerGraft returns a standalone configuration with n worker agents. The
// workers may update main; nobody else may. Every other branch is open.
func workerGraft(n int) (config.Graft, map[string]string) {
	tokens := map[string]string{}
	var agents []config.GraftAgent
	for i := 0; i < n; i++ {
		name := workerName(i)
		token := name + "-secret-for-tests"
		tokens[name] = token
		agents = append(agents, config.GraftAgent{Name: name, Token: token})
	}

	return config.Graft{
		Standalone: true,
		Agents:     agents,
		Policy: []config.GraftPolicyRule{
			{Actor: "worker-*", Refs: []string{"refs/heads/main"}, Allow: true},
			{Refs: []string{"refs/heads/main"}, Allow: false},
			{Refs: []string{"refs/heads/**"}, Allow: true},
		},
	}, tokens
}

// TestReadThroughDaemonHasHits reads a tree and its objects through the daemon
// and asserts the cache reports hits on repeated reads. Covers WP4 and WP7.
func TestReadThroughDaemonHasHits(t *testing.T) {
	t.Parallel()

	s := startExample(t)
	writeMain(t, s, map[string]string{
		"README.md": "read through the daemon\n",
		"main.go":   "package main\n",
		"lib.go":    "package lib\n",
	})

	daemonAddr, daemon := startTier(t, s.addr, cachetier.Config{Tier: cachetier.TierDaemon})
	repo := daemonHandle(t, s, daemonAddr, exampleTokens["planner"])

	blobs := blobsOf(t, repo, "main")
	require.Len(t, blobs, 3)
	oids := make([]string, 0, len(blobs))
	for oid := range blobs {
		oids = append(oids, oid)
	}

	first, err := repo.GetObjects(s.ctx, oids)
	require.NoError(t, err)
	hitsBefore := daemon.Stats().ObjectHits

	second, err := repo.GetObjects(s.ctx, oids)
	require.NoError(t, err)
	require.Greater(t, daemon.Stats().ObjectHits, hitsBefore, "the second read must hit the cache")
	requireSameObjects(t, first, second)
}

// TestBlameAndHistory checks that Blame and PathHistory through the SDK match
// `git blame --porcelain` and `git log --first-parent -- path` on the same
// repository. Covers WP6 and WP8.
func TestBlameAndHistory(t *testing.T) {
	t.Parallel()

	s := startExample(t)
	repo := s.repoAs(t, exampleTokens["planner"])

	// The README changes in the first, second and third commits. The fourth
	// commit does not touch it.
	c1 := writeCommitWith(t, s, "", map[string]string{"README.md": "one\ntwo\n"})
	c2 := writeCommitWith(t, s, c1, map[string]string{"README.md": "one\ntwo\nthree\n"})
	c3 := writeCommitWith(t, s, c2, map[string]string{"README.md": "ONE\ntwo\nthree\n"})
	writeCommitWith(t, s, c3, map[string]string{"README.md": "ONE\ntwo\nthree\n", "other.txt": "x\n"})

	t.Run("blame matches git", func(t *testing.T) {
		got, err := repo.Blame(s.ctx, "main", "README.md")
		require.NoError(t, err)

		want := gitBlameCommits(t, s, "main", "README.md")
		require.Len(t, got.Lines, len(want))
		for i, line := range got.Lines {
			require.Equal(t, want[i], line.CommitID, "line %d", i+1)
		}
		require.Equal(t, []string{c3, c1, c2}, commitsOf(got.Lines))
	})

	t.Run("path history matches git", func(t *testing.T) {
		got, err := repo.PathHistory(s.ctx, "main", "README.md", 100)
		require.NoError(t, err)

		ids := make([]string, 0, len(got))
		for _, c := range got {
			ids = append(ids, c.GetId())
		}
		want := strings.Fields(s.git(t, "log", "--first-parent", "--format=%H", "main", "--", "README.md"))
		require.Equal(t, want, ids)
		require.Equal(t, []string{c3, c2, c1}, ids)
	})
}

// writeCommitWith writes a commit on top of parent (none if empty) that holds
// exactly files, and points main at it.
func writeCommitWith(t *testing.T, s gitalyStack, parent string, files map[string]string) string {
	t.Helper()

	var parents []string
	if parent != "" {
		parents = append(parents, parent)
	}
	return writeMain(t, s, files, parents...)
}

// gitBlameCommits returns the commit that last changed each line of path at
// rev, as reported by `git blame --porcelain`.
func gitBlameCommits(t *testing.T, s gitalyStack, rev, path string) []string {
	t.Helper()

	out := s.git(t, "blame", "--porcelain", rev, "--", path)
	var commits []string
	for _, line := range strings.Split(out, "\n") {
		if strings.HasPrefix(line, "\t") {
			continue
		}
		fields := strings.Fields(line)
		if len(fields) < 3 || len(fields[0]) != 40 {
			continue
		}
		var final int
		_, err := fmt.Sscan(fields[2], &final)
		require.NoError(t, err)
		for len(commits) < final {
			commits = append(commits, "")
		}
		commits[final-1] = fields[0]
	}
	return commits
}

// commitsOf returns the commit of every line in order.
func commitsOf(lines []sdk.BlameLine) []string {
	commits := make([]string, 0, len(lines))
	for _, line := range lines {
		commits = append(commits, line.CommitID)
	}
	return commits
}

// TestChangesetLogHasAllLands checks that ListChangesets after a series of
// lands returns every land with its operation ("land"), actor and a dense
// sequence starting at 1. Covers WP5 and WP8 (Changesets).
func TestChangesetLogHasAllLands(t *testing.T) {
	t.Parallel()

	const lands = 9
	s := startExampleUnbatched(t)
	base := writeMain(t, s, map[string]string{"README.md": "log\n"})
	planner := s.repoAs(t, exampleTokens["planner"])

	tip := base
	for i := 0; i < lands; i++ {
		name := fmt.Sprintf("log/%02d.txt", i)
		commit, err := commitFile(s.ctx, planner, "planner", fmt.Sprintf("log/%02d", i), tip, name, "entry\n")
		require.NoError(t, err)
		res, err := landAs(s.ctx, planner, "planner", "main", commit)
		require.NoError(t, err)
		tip = res.LandedCommitID
	}

	changesets := allChangesets(s.ctx, t, planner)
	requireDense(t, changesets)

	mainLands := landsOn(changesets, "refs/heads/main")
	require.Len(t, mainLands, lands)
	for _, c := range mainLands {
		require.Equal(t, "planner", c.GetActor())
		require.NotEmpty(t, c.GetRecordedAt())
	}

	// A page size of seven must return the same log as one large page.
	page, err := planner.Changesets(s.ctx, 0, 1000)
	require.NoError(t, err)
	require.Equal(t, len(changesets), len(page))
}

// TestWatchReceivesLiveUpdate starts WatchChangesets from the current end of
// the log, performs one land, and expects exactly that changeset on the
// channel. Cancelling the context must end the watch without an error. Covers
// WP5 and WP8 (WatchChangesets).
func TestWatchReceivesLiveUpdate(t *testing.T) {
	t.Parallel()

	s := startExampleUnbatched(t)
	base := writeMain(t, s, map[string]string{"README.md": "watch\n"})
	planner := s.repoAs(t, exampleTokens["planner"])

	commit, err := commitFile(s.ctx, planner, "planner", "watch/topic", base, "watched.txt", "live\n")
	require.NoError(t, err)

	existing := allChangesets(s.ctx, t, planner)
	cursor := existing[len(existing)-1].GetSequence()

	watchCtx, cancel := context.WithCancel(s.ctx)
	defer cancel()
	changes, errs := planner.WatchChangesets(watchCtx, cursor)

	_, err = landAs(s.ctx, planner, "planner", "main", commit)
	require.NoError(t, err)

	var got *sdk.Changeset
	select {
	case got = <-changes:
	case <-time.After(10 * time.Second):
		require.FailNow(t, "no live changeset arrived")
	}
	require.Equal(t, cursor+1, got.GetSequence())
	require.Equal(t, "land", got.GetOperation())
	require.Equal(t, "refs/heads/main", string(got.GetReference()))
	require.Equal(t, "planner", got.GetActor())

	select {
	case extra := <-changes:
		require.FailNow(t, "unexpected changeset", "got %v", extra)
	case <-time.After(300 * time.Millisecond):
	}

	cancel()
	requireWatchEnded(t, changes, errs)
}

// requireWatchEnded checks that both watch channels close after cancellation
// and that no error is reported.
func requireWatchEnded(t *testing.T, changes <-chan *sdk.Changeset, errs <-chan error) {
	t.Helper()

	timeout := time.After(10 * time.Second)
	for changes != nil || errs != nil {
		select {
		case _, ok := <-changes:
			if ok {
				require.FailNow(t, "changeset received after cancellation")
			}
			changes = nil
		case err, ok := <-errs:
			if ok {
				require.NoError(t, err)
			}
			errs = nil
		case <-timeout:
			require.FailNow(t, "watch did not end after cancellation")
		}
	}
}

// TestPolicyDeniesProtectedBranch lets a non-privileged agent try to land on
// main, which the policy protects, and expects a PermissionDenied error with
// a detailed UserLandError (access_check) naming the acting user. The same
// agent must still be able to land on a feature branch. Covers WP1 and WP3.
func TestPolicyDeniesProtectedBranch(t *testing.T) {
	t.Parallel()

	s := startExample(t)
	base := writeMain(t, s, map[string]string{"README.md": "policy\n"})
	planner := s.repoAs(t, exampleTokens["planner"])
	builder := s.repoAs(t, exampleTokens["builder"])

	// The planner may update main.
	plannerCommit, err := commitFile(s.ctx, planner, "planner", "planner/policy", base, "planner.txt", "ok\n")
	require.NoError(t, err)
	planned, err := landAs(s.ctx, planner, "planner", "main", plannerCommit)
	require.NoError(t, err)
	mainBefore := s.git(t, "rev-parse", "refs/heads/main")
	require.Equal(t, planned.LandedCommitID, mainBefore)

	builderCommit, err := commitFile(s.ctx, builder, "builder", "builder/policy", base, "builder.txt", "denied\n")
	require.NoError(t, err)

	_, err = landAs(s.ctx, builder, "builder", "main", builderCommit)
	require.Equal(t, codes.PermissionDenied, sdk.Code(err), "got %v", err)

	landErr, ok := sdk.LandError(err)
	require.True(t, ok, "the denial must carry a UserLandError: %v", err)
	require.NotNil(t, landErr.GetAccessCheck(), "the denial must be an access check")
	require.Equal(t, "builder", landErr.GetAccessCheck().GetUserId(), "the identity of the token is the acting user")
	require.Contains(t, landErr.GetAccessCheck().GetErrorMessage(), "refs/heads/main")

	require.Equal(t, mainBefore, s.git(t, "rev-parse", "refs/heads/main"), "a denied land must leave main unchanged")

	// The builder may still land on a feature branch.
	res, err := landAs(s.ctx, builder, "builder", "feature/builder-policy", builderCommit)
	require.NoError(t, err)
	require.True(t, res.BranchCreated)

	for _, c := range landsOn(allChangesets(s.ctx, t, planner), "refs/heads/main") {
		require.NotEqual(t, "builder", c.GetActor(), "the denied land must not be recorded")
	}
}

// TestPolicyUsesTokenIdentity pins the behaviour that the policy and the
// changeset actor come from the identity of the token. The builder's token
// names planner as the acting user, and the land on main must still be denied
// to builder: in standalone mode the pre-receive access check decides on the
// agent that authenticated the request, not on the client-sent gl_id.
func TestPolicyUsesTokenIdentity(t *testing.T) {
	t.Parallel()

	s := startExample(t)
	base := writeMain(t, s, map[string]string{"README.md": "impersonation\n"})
	planner := s.repoAs(t, exampleTokens["planner"])
	builder := s.repoAs(t, exampleTokens["builder"])

	plannerCommit, err := commitFile(s.ctx, planner, "planner", "planner/impersonation", base, "planner.txt", "ok\n")
	require.NoError(t, err)
	_, err = landAs(s.ctx, planner, "planner", "main", plannerCommit)
	require.NoError(t, err)
	mainBefore := s.git(t, "rev-parse", "refs/heads/main")

	builderCommit, err := commitFile(s.ctx, builder, "builder", "builder/impersonation", base, "builder.txt", "denied\n")
	require.NoError(t, err)

	_, err = builder.Land(s.ctx, sdk.LandOptions{
		Branch: "main",
		Commit: builderCommit,
		User:   sdk.User{ID: "planner", Name: "planner", Email: "[email protected]"},
	})
	require.Equal(t, codes.PermissionDenied, sdk.Code(err), "got %v", err)
	require.Equal(t, mainBefore, s.git(t, "rev-parse", "refs/heads/main"), "a denied land must leave main unchanged")
}

// TestChangesetActorUsesTokenIdentity checks that the changeset log records the
// identity of the token as the actor, even when the client sends another
// agent's name as its acting user. The builder's token commits and lands on a
// feature branch with User.ID set to planner. Every commit_files and land
// changeset must name builder as the actor. The feature branch is open to the
// builder, so the policy does not decide here; the policy side is pinned by
// TestPolicyUsesTokenIdentity. Covers WP5.
func TestChangesetActorUsesTokenIdentity(t *testing.T) {
	t.Parallel()

	s := startExample(t)
	base := writeMain(t, s, map[string]string{"README.md": "actor\n"})
	builder := s.repoAs(t, exampleTokens["builder"])
	impersonated := sdk.User{ID: "planner", Name: "planner", Email: "[email protected]"}

	commit, err := builder.CommitFiles(s.ctx, sdk.CommitOptions{
		Branch:   "builder/actor",
		StartRev: base,
		Message:  "add builder-actor.txt",
		Author:   sdk.Signature{Name: "builder", Email: "[email protected]"},
		User:     impersonated,
		Actions:  []sdk.Action{sdk.Put{Path: "builder-actor.txt", Content: []byte("actor\n")}},
	})
	require.NoError(t, err)

	res, err := builder.Land(s.ctx, sdk.LandOptions{
		Branch:       "feature/builder-actor",
		Commit:       commit.CommitID,
		User:         impersonated,
		CreateBranch: true,
	})
	require.NoError(t, err)
	require.True(t, res.BranchCreated)

	changesets := allChangesets(s.ctx, t, builder)
	requireDense(t, changesets)

	var writes int
	for _, c := range changesets {
		if c.GetOperation() == "commit_files" || c.GetOperation() == "land" {
			writes++
			require.Equal(t, "builder", c.GetActor(), "operation %s on %s", c.GetOperation(), c.GetReference())
		}
	}
	require.Equal(t, 2, writes, "one commit and one land must be recorded")
	require.Len(t, landsOn(changesets, "refs/heads/feature/builder-actor"), 1)
}

// TestWritesThroughTiers runs writes through a chain of cache tiers: a daemon
// in front of a cache tier in front of Gitaly. A commit and a land by the
// planner must succeed and move main, and a land on main by the builder must
// be denied with the access-check detail. The changeset log must record only
// the planner's land. Covers WP7 (pass-through of writes) and WP10.
func TestWritesThroughTiers(t *testing.T) {
	t.Parallel()

	s := startExampleUnbatched(t)
	base := writeMain(t, s, map[string]string{"README.md": "writes\n"})

	cacheAddr, _ := startTier(t, s.addr, cachetier.Config{Tier: cachetier.TierCache, DiskDir: t.TempDir()})
	daemonAddr, _ := startTier(t, cacheAddr, cachetier.Config{Tier: cachetier.TierDaemon})
	planner := daemonHandle(t, s, daemonAddr, exampleTokens["planner"])
	builder := daemonHandle(t, s, daemonAddr, exampleTokens["builder"])

	plannerCommit, err := commitFile(s.ctx, planner, "planner", "planner/tiers", base, "tiers.txt", "through the tiers\n")
	require.NoError(t, err)
	landed, err := landAs(s.ctx, planner, "planner", "main", plannerCommit)
	require.NoError(t, err)
	require.Equal(t, landed.LandedCommitID, s.git(t, "rev-parse", "refs/heads/main"))
	require.Contains(t, s.git(t, "ls-tree", "--name-only", "main"), "tiers.txt")

	builderCommit, err := commitFile(s.ctx, builder, "builder", "builder/tiers", base, "builder-tiers.txt", "denied\n")
	require.NoError(t, err)
	mainBefore := s.git(t, "rev-parse", "refs/heads/main")

	_, err = landAs(s.ctx, builder, "builder", "main", builderCommit)
	require.Equal(t, codes.PermissionDenied, sdk.Code(err), "got %v", err)
	landErr, ok := sdk.LandError(err)
	require.True(t, ok, "the denial must carry a UserLandError: %v", err)
	require.Equal(t, "builder", landErr.GetAccessCheck().GetUserId())
	require.Equal(t, mainBefore, s.git(t, "rev-parse", "refs/heads/main"), "a denied land must leave main unchanged")

	res, err := landAs(s.ctx, builder, "builder", "feature/builder-tiers", builderCommit)
	require.NoError(t, err)
	require.True(t, res.BranchCreated)

	lands := landsOn(allChangesets(s.ctx, t, planner), "refs/heads/main")
	require.Len(t, lands, 1)
	require.Equal(t, "planner", lands[0].GetActor())
}

// TestTierTokenWidensAccess checks the trust boundary of a cache tier that was
// started with a token. A client that sends no authorization is served with
// the tier's token and reads an object that it could not read from Gitaly
// without credentials. A tier without a token refuses the same client. Covers
// WP7 and the trust boundary documented in doc/graft/ARCHITECTURE.md.
func TestTierTokenWidensAccess(t *testing.T) {
	t.Parallel()

	ex := loadExample(t)
	s := startGitaly(t, ex.graft, ex.sharedToken)
	writeMain(t, s, map[string]string{"README.md": "widened\n"})
	blob := s.git(t, "rev-parse", "main:README.md")

	withToken, _ := startTier(t, s.addr, cachetier.Config{Tier: cachetier.TierDaemon, Token: ex.sharedToken})
	withoutToken, _ := startTier(t, s.addr, cachetier.Config{Tier: cachetier.TierDaemon})

	objects, err := daemonHandle(t, s, withToken, "").GetObjects(s.ctx, []string{blob})
	require.NoError(t, err, "the tier's token must serve a client that sends none")
	require.Len(t, objects, 1)
	require.False(t, objects[0].Missing)

	_, err = daemonHandle(t, s, withoutToken, "").GetObjects(s.ctx, []string{blob})
	require.Equal(t, codes.Unauthenticated, sdk.Code(err), "got %v", err)
}

// dialAgent returns a raw gRPC connection whose requests carry a v2 token
// signed with an agent token, for RPCs that the SDK does not wrap.
func (s gitalyStack) dialAgent(t *testing.T, token string) *grpc.ClientConn {
	t.Helper()

	conn, err := client.DialContext(s.ctx, s.addr, client.WithGrpcOptions([]grpc.DialOption{
		grpc.WithPerRPCCredentials(gitalyauth.RPCCredentialsV2(token)),
	}))
	require.NoError(t, err)
	t.Cleanup(func() { _ = conn.Close() })

	return conn
}