Skip to content

Git designed for AI agents.

11.8 KB
Raw Blame
package main

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

	"github.com/stretchr/testify/require"

	"github.com/feder-cr/git-ai/internal/graft/workspace"
)

const (
	testAgentName  = "Agent One"
	testAgentEmail = "[email protected]"
)

func testAuthor() workspace.Signature {
	return workspace.Signature{Name: testAgentName, Email: testAgentEmail}
}

func cloneForTest(t *testing.T, env serverEnv, b *sdkBackend, sparse ...string) (string, *workspace.Workspace) {
	t.Helper()

	dir := filepath.Join(t.TempDir(), "ws")
	ws, err := workspace.Clone(env.ctx, dir, b, workspace.CloneOptions{
		Address: env.addr,
		Storage: env.storage,
		Repo:    env.relPath,
		Branch:  "main",
		Sparse:  sparse,
	})
	require.NoError(t, err)
	return dir, ws
}

func writeLocal(t *testing.T, root, rel, content string) {
	t.Helper()

	full := filepath.Join(root, filepath.FromSlash(rel))
	require.NoError(t, os.MkdirAll(filepath.Dir(full), 0o755))
	require.NoError(t, os.WriteFile(full, []byte(content), 0o644))
}

func readRemoteFile(t *testing.T, env serverEnv, b *sdkBackend, rev, path string) string {
	t.Helper()

	content, err := b.ReadFile(env.ctx, rev, path)
	require.NoError(t, err)
	return string(content)
}

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

	env := startServer(t)
	env.seedMain(t, map[string]string{"a/x.txt": "ax\n", "b/y.txt": "by\n", "top.txt": "top\n"})
	b := env.backend(t)

	dir, ws := cloneForTest(t, env, b, "a")
	require.Equal(t, "ax\n", readLocalFile(t, dir, "a/x.txt"))
	require.NoDirExists(t, filepath.Join(dir, "b"))
	require.NoFileExists(t, filepath.Join(dir, "top.txt"))

	writeLocal(t, dir, "a/x.txt", "changed\n")
	writeLocal(t, dir, "a/new.txt", "new\n")

	res, err := ws.Commit(env.ctx, workspace.CommitRequest{
		Message:    "change a",
		Author:     testAuthor(),
		LandBranch: "main",
	})
	require.NoError(t, err)
	require.True(t, res.Landed)
	require.Equal(t, 2, res.Changes)

	require.Equal(t, "changed\n", readRemoteFile(t, env, b, "main", "a/x.txt"))
	require.Equal(t, "new\n", readRemoteFile(t, env, b, "main", "a/new.txt"))
	require.Equal(t, "by\n", readRemoteFile(t, env, b, "main", "b/y.txt"), "server-side content outside the sparse set is untouched")

	_, err = b.ResolveRevision(env.ctx, res.Branch)
	require.ErrorIs(t, err, workspace.ErrNotFound, "the temporary branch is deleted after landing")

	changes, err := ws.Status()
	require.NoError(t, err)
	require.Empty(t, changes)
	require.Equal(t, ws.Summary().Base, landedHead(t, env, b))

	lines, err := b.Blame(env.ctx, "main", "a/x.txt")
	require.NoError(t, err)
	require.Len(t, lines, 1)
	require.Equal(t, "changed\n", string(lines[0].Content)+"\n")
	require.Equal(t, ws.Summary().Base, lines[0].CommitID)

	commits, err := b.PathHistory(env.ctx, "main", "a/x.txt", 10)
	require.NoError(t, err)
	require.Len(t, commits, 2)
	require.Equal(t, "change a", commits[0].Subject)
	require.Equal(t, testAgentName, commits[0].AuthorName)

	changesets, err := b.Changesets(env.ctx, 0, 0)
	require.NoError(t, err)
	require.NotEmpty(t, changesets)
	for i, c := range changesets {
		require.Equal(t, uint64(i+1), c.Sequence, "sequence numbers are dense")
		require.False(t, c.RecordedAt.IsZero())
	}

	var mainUpdate *workspace.Changeset
	for i := range changesets {
		if changesets[i].Reference == "refs/heads/main" {
			mainUpdate = &changesets[i]
		}
	}
	require.NotNil(t, mainUpdate, "the land is recorded for main")
	require.Equal(t, ws.Summary().Base, mainUpdate.NewOID)

	after, err := b.Changesets(env.ctx, mainUpdate.Sequence-1, 1)
	require.NoError(t, err)
	require.Len(t, after, 1)
	require.Equal(t, mainUpdate.Sequence, after[0].Sequence)
}

// landedHead returns the current commit of main.
func landedHead(t *testing.T, env serverEnv, b *sdkBackend) string {
	t.Helper()

	oid, err := b.ResolveRevision(env.ctx, "main")
	require.NoError(t, err)
	return oid
}

func readLocalFile(t *testing.T, root, rel string) string {
	t.Helper()

	data, err := os.ReadFile(filepath.Join(root, filepath.FromSlash(rel)))
	require.NoError(t, err)
	return string(data)
}

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

	env := startServer(t)
	env.seedMain(t, map[string]string{"a.txt": "one\n", "dir/b.txt": "two\n"})
	b := env.backend(t)

	_, err := b.ResolveRevision(env.ctx, "no-such-branch")
	require.ErrorIs(t, err, workspace.ErrNotFound)

	_, err = b.ReadFile(env.ctx, "main", "missing.txt")
	require.ErrorIs(t, err, workspace.ErrNotFound)

	_, err = b.ListTree(env.ctx, "main", "missing-dir", false)
	require.ErrorIs(t, err, workspace.ErrNotFound)

	entries, err := b.ListTree(env.ctx, "main", "", true)
	require.NoError(t, err)
	paths := map[string]workspace.Entry{}
	for _, e := range entries {
		paths[e.Path] = e
	}
	require.Equal(t, workspace.ObjectBlob, paths["a.txt"].Type)
	require.Equal(t, int64(len("one\n")), paths["a.txt"].Size)
	require.Equal(t, workspace.ObjectBlob, paths["dir/b.txt"].Type)

	objects, err := b.GetObjects(env.ctx, []string{paths["a.txt"].OID, missingOID})
	require.NoError(t, err)
	require.Equal(t, "one\n", string(objects[paths["a.txt"].OID]))
	require.NotContains(t, objects, missingOID, "missing objects are left out")

	_, err = b.CommitFiles(env.ctx, workspace.CommitOptions{
		Branch:   "clash",
		StartRev: "main",
		Message:  "clash",
		Author:   testAuthor(),
		Actions:  []workspace.Action{{Kind: workspace.ActionPut, Path: "a.txt", Content: []byte("dup")}},
	})
	require.ErrorIs(t, err, workspace.ErrAlreadyExists)

	_, err = b.CommitFiles(env.ctx, workspace.CommitOptions{
		Branch:   "unknown-action",
		StartRev: "main",
		Message:  "bad",
		Author:   testAuthor(),
		Actions:  []workspace.Action{{Kind: "rename", Path: "a.txt"}},
	})
	require.ErrorContains(t, err, "unknown action")

	_, err = b.Land(env.ctx, workspace.LandOptions{Branch: "main", Commit: missingOID, Strategy: workspace.StrategyRebase})
	require.Error(t, err)

	head := landedHead(t, env, b)
	_, err = b.Land(env.ctx, workspace.LandOptions{Branch: "main", Commit: head, Strategy: "squash"})
	require.ErrorContains(t, err, "unknown strategy")

	require.NoError(t, b.DeleteBranch(env.ctx, "never-existed"), "deleting a missing branch is not an error")
}

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

	env := startServer(t)
	env.seedMain(t, map[string]string{"a.txt": "base\n"})
	b := env.backend(t)

	dirA, wsA := cloneForTest(t, env, b)
	dirB, wsB := cloneForTest(t, env, b)

	writeLocal(t, dirA, "a.txt", "from A\n")
	_, err := wsA.Commit(env.ctx, workspace.CommitRequest{Message: "A", Author: testAuthor(), LandBranch: "main"})
	require.NoError(t, err)

	writeLocal(t, dirB, "a.txt", "from B\n")
	res, err := wsB.Commit(env.ctx, workspace.CommitRequest{Message: "B", Author: testAuthor()})
	require.NoError(t, err)
	require.False(t, res.Landed)

	_, err = wsB.Land(env.ctx, "", workspace.StrategyFFOnly, testAuthor())
	require.ErrorIs(t, err, workspace.ErrNotFastForward)
	require.NotNil(t, wsB.Summary().Pending)

	_, err = wsB.Land(env.ctx, "", workspace.StrategyRebase, testAuthor())
	require.ErrorIs(t, err, workspace.ErrMergeConflict)
	require.NotNil(t, wsB.Summary().Pending, "a conflicting commit stays pending")
	require.Equal(t, "from A\n", readRemoteFile(t, env, b, "main", "a.txt"))
}

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

	env := startServer(t)
	env.seedMain(t, map[string]string{"a.txt": "base\n"})
	b := env.backend(t)

	dirA, wsA := cloneForTest(t, env, b)
	dirB, wsB := cloneForTest(t, env, b)

	writeLocal(t, dirA, "a.txt", "from A\n")
	_, err := wsA.Commit(env.ctx, workspace.CommitRequest{Message: "A", Author: testAuthor(), LandBranch: "main"})
	require.NoError(t, err)

	writeLocal(t, dirB, "b.txt", "from B\n")
	_, err = wsB.Commit(env.ctx, workspace.CommitRequest{
		Message:    "B",
		Author:     testAuthor(),
		LandBranch: "main",
		Strategy:   workspace.StrategyMerge,
	})
	require.NoError(t, err)

	require.Equal(t, "from A\n", readRemoteFile(t, env, b, "main", "a.txt"))
	require.Equal(t, "from B\n", readRemoteFile(t, env, b, "main", "b.txt"))

	commits, err := b.PathHistory(env.ctx, "main", "b.txt", 10)
	require.NoError(t, err)
	require.NotEmpty(t, commits)
}

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

	const agents = 10

	env := startServer(t)
	env.seedMain(t, map[string]string{"base.txt": "base\n"})
	b := env.backend(t)

	dirs := make([]string, agents)
	workspaces := make([]*workspace.Workspace, agents)
	for i := range agents {
		dirs[i], workspaces[i] = cloneForTest(t, env, b)
	}

	var wg sync.WaitGroup
	errs := make(chan error, agents)
	for i := range agents {
		wg.Add(1)
		go func(i int) {
			defer wg.Done()

			name := fmt.Sprintf("agent-%02d.txt", i)
			if err := os.WriteFile(filepath.Join(dirs[i], name), []byte(name+"\n"), 0o644); err != nil {
				errs <- err
				return
			}
			_, err := workspaces[i].Commit(env.ctx, workspace.CommitRequest{
				Message:    "add " + name,
				Author:     testAuthor(),
				LandBranch: "main",
			})
			errs <- err
		}(i)
	}
	wg.Wait()
	close(errs)

	for err := range errs {
		require.NoError(t, err)
	}

	for i := range agents {
		name := fmt.Sprintf("agent-%02d.txt", i)
		require.Equal(t, name+"\n", readRemoteFile(t, env, b, "main", name))
	}
	require.Equal(t, "base\n", readRemoteFile(t, env, b, "main", "base.txt"))

	changesets, err := b.Changesets(env.ctx, 0, 0)
	require.NoError(t, err)
	// Concurrent lands on one branch are batched, so one changeset may record
	// several changes. Each change is a member of its batch, or else the
	// changeset itself.
	landed := 0
	for _, c := range changesets {
		if c.Reference != "refs/heads/main" {
			continue
		}
		if len(c.Members) > 0 {
			landed += len(c.Members)
		} else {
			landed++
		}
	}
	require.GreaterOrEqual(t, landed, agents, "every agent landed on main")
}

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

	env := startServer(t)
	env.seedMain(t, map[string]string{"a.txt": "one\n"})
	b := env.backend(t)

	dir, ws := cloneForTest(t, env, b)
	writeLocal(t, dir, "a.txt", "two\n")
	_, err := ws.Commit(env.ctx, workspace.CommitRequest{Message: "two", Author: testAuthor(), LandBranch: "main"})
	require.NoError(t, err)

	ctx, cancel := context.WithCancel(env.ctx)
	defer cancel()
	changes, errs := b.WatchChangesets(ctx, 0)

	// The backlog holds the earlier land on main, delivered in sequence order.
	backlog := receiveChangeset(t, changes, "refs/heads/main")
	require.Equal(t, ws.Summary().Base, backlog.NewOID)

	// A later land arrives live.
	writeLocal(t, dir, "a.txt", "three\n")
	_, err = ws.Commit(env.ctx, workspace.CommitRequest{Message: "three", Author: testAuthor(), LandBranch: "main"})
	require.NoError(t, err)

	live := receiveChangeset(t, changes, "refs/heads/main")
	require.Greater(t, live.Sequence, backlog.Sequence)
	require.Equal(t, ws.Summary().Base, live.NewOID)

	cancel()
	for range changes {
	}
	for err := range errs {
		require.NoError(t, err)
	}
}

// receiveChangeset waits for the next changeset of a watch that updates ref. It
// fails the test if a changeset arrives out of sequence order.
func receiveChangeset(t *testing.T, changes <-chan workspace.Changeset, ref string) workspace.Changeset {
	t.Helper()

	var last uint64
	for {
		select {
		case c, ok := <-changes:
			require.True(t, ok, "the watch ended early")
			require.Greater(t, c.Sequence, last, "sequences are delivered in order")
			last = c.Sequence
			if c.Reference == ref {
				return c
			}
		case <-time.After(10 * time.Second):
			require.FailNow(t, "no changeset received", "waiting for %s", ref)
		}
	}
}

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

	env := startServer(t)
	b := env.backend(t)
	b.repo = b.client.Repo("does-not-exist")

	changes, errs := b.WatchChangesets(env.ctx, 0)
	for range changes {
	}
	err, ok := <-errs
	require.True(t, ok, "the failure is reported before the channel closes")
	require.Error(t, err)
}