Skip to content

Git designed for AI agents.

6.9 KB
Raw Blame
package verify

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

	"github.com/stretchr/testify/require"

	"github.com/feder-cr/git-ai/internal/featureflag"
	"github.com/feder-cr/git-ai/internal/git/gittest"
	"github.com/feder-cr/git-ai/internal/gitaly/service/setup"
	"github.com/feder-cr/git-ai/internal/gitlab"
	"github.com/feder-cr/git-ai/internal/testhelper"
	"github.com/feder-cr/git-ai/internal/testhelper/testcfg"
	"github.com/feder-cr/git-ai/internal/testhelper/testserver"
	"github.com/feder-cr/git-ai/sdk"
)

// verifyToken is the shared token of the integration server.
const verifyToken = "graft-verify-test-token"

// realEnv is a standalone server with one empty repository and a verifier
// configuration that points at it.
type realEnv struct {
	t      *testing.T
	ctx    context.Context
	repo   *sdk.Repo
	cfg    Config
	runs   string
	gate   string
	client *sdk.Client
}

// startRealServer starts a standalone Gitaly, creates a repository and returns
// the environment. The verifier configuration uses the shared token.
func startRealServer(t *testing.T) *realEnv {
	t.Helper()

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

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

	addr := testserver.RunGitalyServer(t, cfg, setup.RegisterAll,
		testserver.WithGitLabClient(gitlab.NewStandaloneClient(cfg.Graft, testhelper.SharedLogger(t))),
	)
	cfg.SocketPath = addr

	ctx = testhelper.MergeOutgoingMetadata(ctx, testcfg.GitalyServersMetadataFromCfg(t, cfg))
	repoProto, _ := gittest.CreateRepository(t, ctx, cfg)

	storage := cfg.Storages[0].Name
	client, err := sdk.Dial(ctx, addr, sdk.WithStorage(storage), sdk.WithToken(verifyToken))
	require.NoError(t, err)
	t.Cleanup(func() { _ = client.Close() })

	dir := t.TempDir()
	script := filepath.Join(dir, "test.sh")
	require.NoError(t, os.WriteFile(script, []byte(testScript), 0o700))

	env := &realEnv{
		t:      t,
		ctx:    ctx,
		repo:   client.Repo(repoProto.GetRelativePath()),
		runs:   filepath.Join(dir, "runs.log"),
		gate:   filepath.Join(dir, "gate"),
		client: client,
	}
	require.NoError(t, os.WriteFile(env.gate, nil, 0o600))

	env.cfg = Config{
		Address:     addr,
		Token:       verifyToken,
		Storage:     storage,
		Repository:  repoProto.GetRelativePath(),
		Branch:      "main",
		WorkDir:     filepath.Join(dir, "work"),
		StateFile:   filepath.Join(dir, "state.json"),
		BatchWindow: Duration(20 * time.Millisecond),
		Test: TestConfig{
			Command: []string{"sh", script},
			Env:     []string{"RUNS=" + env.runs, "GATE=" + env.gate},
			Timeout: Duration(time.Minute),
		},
	}
	require.NoError(t, env.cfg.Finalize())
	return env
}

// land commits path on main, on top of the current tip, and returns the new
// tip. The first commit creates the branch.
func (env *realEnv) land(path, content string) string {
	env.t.Helper()

	startRev := "main"
	if _, err := env.repo.ResolveRevision(env.ctx, "refs/heads/main"); err != nil {
		startRev = ""
	}
	res, err := env.repo.CommitFiles(env.ctx, sdk.CommitOptions{
		Branch:   "main",
		StartRev: startRev,
		Message:  "add " + path,
		Author:   sdk.Signature{Name: "dev", Email: "[email protected]"},
		User:     sdk.User{ID: "dev", Username: "dev", Name: "dev", Email: "[email protected]"},
		Actions:  []sdk.Action{sdk.Put{Path: path, Content: []byte(content)}},
	})
	require.NoError(env.t, err)
	return res.CommitID
}

// green returns the green ref of the repository as the server sees it.
func (env *realEnv) green() string {
	env.t.Helper()

	oid, err := env.repo.ResolveRevision(env.ctx, "refs/graft/green/main")
	if sdk.IsNotFound(err) {
		return ""
	}
	require.NoError(env.t, err)
	return oid
}

// verifier opens a verifier over the real server.
func (env *realEnv) verifier() (*Verifier, func()) {
	env.t.Helper()

	v, closer, err := Open(env.ctx, env.cfg, discardLogger())
	require.NoError(env.t, err)
	return v, func() { _ = closer.Close() }
}

// runCount returns how many times the test command ran.
func (env *realEnv) runCount() int {
	data, err := os.ReadFile(env.runs)
	if os.IsNotExist(err) {
		return 0
	}
	require.NoError(env.t, err)
	n := 0
	for _, b := range data {
		if b == '\n' {
			n++
		}
	}
	return n
}

func TestRealServerRunOnceMovesGreenRef(t *testing.T) {
	env := startRealServer(t)
	v, closeVerifier := env.verifier()
	defer closeVerifier()

	tip := env.land("a.txt", "one")
	out, ran, err := v.RunOnce(env.ctx)
	require.NoError(t, err)
	require.True(t, ran)
	require.True(t, out.Passed, out.Output)
	require.True(t, out.GreenMoved)
	require.Equal(t, tip, out.Tip)
	require.Equal(t, tip, env.green())

	broken := env.land("broken", "x")
	out, ran, err = v.RunOnce(env.ctx)
	require.NoError(t, err)
	require.True(t, ran)
	require.False(t, out.Passed)
	require.Equal(t, broken, out.Tip)
	require.Equal(t, tip, env.green(), "a failing tip must not move the green ref")
	require.Equal(t, 2, env.runCount())
}

func TestRealServerRunFollowsWatchAndIgnoresGreenUpdates(t *testing.T) {
	env := startRealServer(t)
	v, closeVerifier := env.verifier()
	defer closeVerifier()

	ctx, cancel := context.WithCancel(env.ctx)
	defer cancel()
	done := make(chan error, 1)
	go func() { done <- v.Run(ctx) }()

	first := env.land("a.txt", "one")
	require.Eventually(t, func() bool { return env.green() == first }, 30*time.Second, 10*time.Millisecond)

	second := env.land("b.txt", "two")
	require.Eventually(t, func() bool { return env.green() == second }, 30*time.Second, 10*time.Millisecond)

	// The green moves are changesets of the log too. They must not start
	// further runs: exactly one run per landed tip.
	time.Sleep(200 * time.Millisecond)
	require.Equal(t, 2, env.runCount())

	cancel()
	select {
	case err := <-done:
		require.NoError(t, err)
	case <-time.After(30 * time.Second):
		t.Fatal("Run did not return after cancel")
	}
}

func TestRealServerOpenRejectsWrongToken(t *testing.T) {
	env := startRealServer(t)
	env.cfg.Token = "wrong-token"

	_, closer, err := Open(env.ctx, env.cfg, discardLogger())
	if closer != nil {
		_ = closer.Close()
	}
	require.Error(t, err)
}

func TestRealServerRefUpdaterCompareAndSwap(t *testing.T) {
	env := startRealServer(t)
	tip := env.land("a.txt", "one")
	other := env.land("b.txt", "two")

	greens, err := dialRefUpdater(env.ctx, env.cfg.Address, env.cfg.Token, env.repo, env.cfg.Storage)
	require.NoError(t, err)
	defer func() { _ = greens.Close() }()

	current, err := greens.Current(env.ctx, env.cfg.GreenRef)
	require.NoError(t, err)
	require.Empty(t, current, "the green ref does not exist yet")

	require.NoError(t, greens.Move(env.ctx, env.cfg.GreenRef, "", tip))
	require.Equal(t, tip, env.green())

	// A move from a stale old value is refused and changes nothing.
	require.Error(t, greens.Move(env.ctx, env.cfg.GreenRef, zeroOIDLike(tip), other))
	require.Equal(t, tip, env.green())

	require.NoError(t, greens.Move(env.ctx, env.cfg.GreenRef, tip, other))
	require.Equal(t, other, env.green())
}