Git designed for AI agents.
package sdk_test
import (
"bytes"
"context"
"fmt"
"strings"
"sync"
"testing"
"time"
"github.com/stretchr/testify/require"
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
"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/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"
)
// zeroOID is the all-zero SHA-1 object ID, used by Git for "no object".
const zeroOID = "0000000000000000000000000000000000000000"
// missingOID is a well-formed object ID that does not exist in test repositories.
const missingOID = "0123456789abcdef0123456789abcdef01234567"
// integrationEnv is a real Gitaly server with every service registered, one
// repository on it, and an SDK client connected to it.
type integrationEnv struct {
ctx context.Context
cfg config.Cfg
addr string
relPath string
client *sdk.Client
repo *sdk.Repo
repoPath string
}
// startIntegration starts Gitaly with all services and creates an empty
// repository on it. modify may adjust the configuration before the server
// starts. The client connects with the configured storage and opts.
func startIntegration(t *testing.T, modify func(cfg *config.Cfg), opts ...sdk.DialOption) integrationEnv {
t.Helper()
// The test context marks feature flags as explicit, so every flag a server
// checks must be set. GPGSigning is checked by UserCommitFiles.
ctx := featureflag.OutgoingCtxWithFeatureFlag(testhelper.Context(t), featureflag.GPGSigning, false)
cfg := testcfg.Build(t)
if modify != nil {
modify(&cfg)
}
testcfg.BuildGitalySSH(t, cfg)
testcfg.BuildGitalyHooks(t, cfg)
addr := testserver.RunGitalyServer(t, cfg, setup.RegisterAll)
cfg.SocketPath = addr
// Only the setup call carries gitaly-servers metadata. The client calls
// may authenticate as agents, which may not send it.
setupCtx := testhelper.MergeOutgoingMetadata(ctx, testcfg.GitalyServersMetadataFromCfg(t, cfg))
repoProto, repoPath := gittest.CreateRepository(t, setupCtx, cfg)
opts = append([]sdk.DialOption{sdk.WithStorage(cfg.Storages[0].Name)}, opts...)
client, err := sdk.Dial(ctx, addr, opts...)
require.NoError(t, err)
t.Cleanup(func() { _ = client.Close() })
return integrationEnv{
ctx: ctx,
cfg: cfg,
addr: addr,
relPath: repoProto.GetRelativePath(),
client: client,
repo: client.Repo(repoProto.GetRelativePath()),
repoPath: repoPath,
}
}
// dial connects a new client to the same server with opts and returns a handle
// to the test repository through it.
func (e integrationEnv) dial(t *testing.T, opts ...sdk.DialOption) *sdk.Repo {
t.Helper()
client, err := sdk.Dial(e.ctx, e.addr, append([]sdk.DialOption{sdk.WithStorage(e.cfg.Storages[0].Name)}, opts...)...)
require.NoError(t, err)
t.Cleanup(func() { _ = client.Close() })
return client.Repo(e.relPath)
}
// writeCommit writes a commit whose tree holds exactly files, with the given
// parents. If branch is not empty, the branch is pointed at the commit.
func (e integrationEnv) writeCommit(t *testing.T, branch string, files map[string]string, parents ...git.ObjectID) git.ObjectID {
t.Helper()
opts := []gittest.WriteCommitOption{
gittest.WithTree(e.writeTree(t, files)),
gittest.WithParents(parents...),
}
if branch != "" {
opts = append(opts, gittest.WithBranch(branch))
}
return gittest.WriteCommit(t, e.cfg, e.repoPath, opts...)
}
// writeTree writes the nested tree that holds exactly files, keyed by their
// slash-separated paths.
func (e integrationEnv) writeTree(t *testing.T, files map[string]string) git.ObjectID {
t.Helper()
blobs := map[string]string{}
dirs := map[string]map[string]string{}
for path, content := range files {
name, rest, nested := strings.Cut(path, "/")
if !nested {
blobs[name] = content
continue
}
if dirs[name] == nil {
dirs[name] = map[string]string{}
}
dirs[name][rest] = content
}
entries := make([]gittest.TreeEntry, 0, len(blobs)+len(dirs))
for name, content := range blobs {
entries = append(entries, gittest.TreeEntry{Mode: "100644", Path: name, Content: content})
}
for name, sub := range dirs {
entries = append(entries, gittest.TreeEntry{Mode: "040000", Path: name, OID: e.writeTree(t, sub)})
}
return gittest.WriteTree(t, e.cfg, e.repoPath, entries)
}
// git runs a Git command in the test repository and returns its trimmed output.
func (e integrationEnv) git(t *testing.T, args ...string) string {
t.Helper()
return strings.TrimSpace(string(gittest.Exec(t, e.cfg, append([]string{"-C", e.repoPath}, args...)...)))
}
// mustResolve resolves rev with the SDK and fails the test on error.
func (e integrationEnv) mustResolve(t *testing.T, rev string) string {
t.Helper()
id, err := e.repo.ResolveRevision(e.ctx, rev)
require.NoError(t, err)
return id
}
// readString reads the file at path in rev and returns its contents.
func (e integrationEnv) readString(t *testing.T, rev, path string) string {
t.Helper()
data, err := e.repo.ReadFile(e.ctx, rev, path)
require.NoError(t, err)
return string(data)
}
func TestIntegration_ResolveRevision(t *testing.T) {
t.Parallel()
env := startIntegration(t, nil)
base := env.writeCommit(t, "main", map[string]string{"a.txt": "a"})
for _, tc := range []struct {
desc string
rev string
want string
}{
{desc: "branch", rev: "main", want: base.String()},
{desc: "fully qualified branch", rev: "refs/heads/main", want: base.String()},
{desc: "full object ID", rev: base.String(), want: base.String()},
{desc: "parent expression", rev: "main^{commit}", want: base.String()},
} {
t.Run(tc.desc, func(t *testing.T) {
got, err := env.repo.ResolveRevision(env.ctx, tc.rev)
require.NoError(t, err)
require.Equal(t, tc.want, got)
})
}
t.Run("unknown revision", func(t *testing.T) {
_, err := env.repo.ResolveRevision(env.ctx, "no-such-branch")
require.Error(t, err)
require.True(t, sdk.IsNotFound(err), "got %v", err)
})
t.Run("missing object", func(t *testing.T) {
_, err := env.repo.ResolveRevision(env.ctx, missingOID)
require.Error(t, err)
})
t.Run("empty revision", func(t *testing.T) {
_, err := env.repo.ResolveRevision(env.ctx, "")
require.Equal(t, codes.InvalidArgument, sdk.Code(err))
})
}
func TestIntegration_ClientAndRepoHandles(t *testing.T) {
t.Parallel()
env := startIntegration(t, nil)
require.Equal(t, env.cfg.Storages[0].Name, env.client.Storage())
require.Equal(t, env.relPath, env.repo.RelativePath())
require.Equal(t, env.relPath, env.client.Repo(env.relPath).RelativePath())
}
func TestIntegration_ReadFile(t *testing.T) {
t.Parallel()
env := startIntegration(t, nil)
large := bytes.Repeat([]byte("0123456789abcdef"), 1<<16) // 1 MiB spans several messages
env.writeCommit(t, "main", map[string]string{
"README.md": "# graft\n",
"dir/a.txt": "nested",
"empty.txt": "",
"big.bin": string(large),
"dir/sub/ok": "deep",
})
require.Equal(t, "# graft\n", env.readString(t, "main", "README.md"))
require.Equal(t, "nested", env.readString(t, "main", "dir/a.txt"))
require.Equal(t, "deep", env.readString(t, "main", "dir/sub/ok"))
require.Equal(t, "", env.readString(t, "main", "empty.txt"))
require.Equal(t, large, mustReadFile(t, env, "main", "big.bin"))
t.Run("full object ID as revision", func(t *testing.T) {
commitID := env.mustResolve(t, "main")
require.Equal(t, "nested", env.readString(t, commitID, "dir/a.txt"))
})
t.Run("missing path", func(t *testing.T) {
_, err := env.repo.ReadFile(env.ctx, "main", "does/not/exist")
require.True(t, sdk.IsNotFound(err), "got %v", err)
})
t.Run("directory is not a file", func(t *testing.T) {
_, err := env.repo.ReadFile(env.ctx, "main", "dir")
require.Equal(t, codes.FailedPrecondition, sdk.Code(err), "got %v", err)
})
t.Run("unknown revision", func(t *testing.T) {
_, err := env.repo.ReadFile(env.ctx, "no-such-branch", "README.md")
require.Error(t, err)
})
t.Run("validation", func(t *testing.T) {
_, err := env.repo.ReadFile(env.ctx, "", "README.md")
require.Equal(t, codes.InvalidArgument, sdk.Code(err))
_, err = env.repo.ReadFile(env.ctx, "main", "")
require.Equal(t, codes.InvalidArgument, sdk.Code(err))
})
}
func mustReadFile(t *testing.T, env integrationEnv, rev, path string) []byte {
t.Helper()
data, err := env.repo.ReadFile(env.ctx, rev, path)
require.NoError(t, err)
return data
}
func TestIntegration_ListTree(t *testing.T) {
t.Parallel()
env := startIntegration(t, nil)
env.writeCommit(t, "main", map[string]string{
"README": "readme",
"dir/a.txt": "aaa",
"dir/sub/b.t": "bb",
})
type entry struct {
path string
typ sdk.ObjectType
size int64
}
flatten := func(entries []sdk.TreeEntry) []entry {
out := make([]entry, 0, len(entries))
for _, e := range entries {
out = append(out, entry{path: e.Path, typ: e.Type, size: e.Size})
}
return out
}
t.Run("root, not recursive", func(t *testing.T) {
entries, err := env.repo.ListTree(env.ctx, "main", "", false)
require.NoError(t, err)
require.Equal(t, []entry{
{path: "README", typ: sdk.ObjectBlob, size: 6},
{path: "dir", typ: sdk.ObjectTree, size: 0},
}, flatten(entries))
require.False(t, entries[0].IsDir())
require.True(t, entries[1].IsDir())
require.NotEmpty(t, entries[0].OID)
require.Equal(t, int32(0100644), entries[0].Mode)
})
t.Run("root, recursive", func(t *testing.T) {
entries, err := env.repo.ListTree(env.ctx, "main", "", true)
require.NoError(t, err)
require.Equal(t, []entry{
{path: "README", typ: sdk.ObjectBlob, size: 6},
{path: "dir", typ: sdk.ObjectTree},
{path: "dir/a.txt", typ: sdk.ObjectBlob, size: 3},
{path: "dir/sub", typ: sdk.ObjectTree},
{path: "dir/sub/b.t", typ: sdk.ObjectBlob, size: 2},
}, flatten(entries))
})
t.Run("subdirectory paths are relative to it", func(t *testing.T) {
entries, err := env.repo.ListTree(env.ctx, "main", "dir", false)
require.NoError(t, err)
require.Equal(t, []entry{
{path: "a.txt", typ: sdk.ObjectBlob, size: 3},
{path: "sub", typ: sdk.ObjectTree},
}, flatten(entries))
entries, err = env.repo.ListTree(env.ctx, "main", "dir", true)
require.NoError(t, err)
require.Equal(t, []string{"a.txt", "sub", "sub/b.t"}, paths(entries))
})
t.Run("missing path", func(t *testing.T) {
_, err := env.repo.ListTree(env.ctx, "main", "nope", false)
require.True(t, sdk.IsNotFound(err), "got %v", err)
})
t.Run("validation", func(t *testing.T) {
_, err := env.repo.ListTree(env.ctx, "", "", false)
require.Equal(t, codes.InvalidArgument, sdk.Code(err))
})
}
func TestIntegration_GetObjects(t *testing.T) {
t.Parallel()
env := startIntegration(t, nil)
content := []byte("hello, graft\n")
blob := gittest.WriteBlob(t, env.cfg, env.repoPath, content)
commit := env.writeCommit(t, "main", map[string]string{"greeting.txt": string(content)})
tree := env.git(t, "rev-parse", "main^{tree}")
objects, err := env.repo.GetObjects(env.ctx, []string{
blob.String(), tree, commit.String(), missingOID, blob.String(),
})
require.NoError(t, err)
require.Len(t, objects, 4, "duplicates are returned once")
require.Equal(t, blob.String(), objects[0].OID)
require.Equal(t, sdk.ObjectBlob, objects[0].Type)
require.Equal(t, int64(len(content)), objects[0].Size)
require.Equal(t, content, objects[0].Data)
require.False(t, objects[0].Missing)
require.Equal(t, tree, objects[1].OID)
require.Equal(t, sdk.ObjectTree, objects[1].Type)
require.Equal(t, int64(len(objects[1].Data)), objects[1].Size)
require.Contains(t, string(objects[1].Data), "greeting.txt")
require.Equal(t, commit.String(), objects[2].OID)
require.Equal(t, sdk.ObjectCommit, objects[2].Type)
require.True(t, bytes.HasPrefix(objects[2].Data, []byte("tree "+tree+"\n")))
require.Equal(t, missingOID, objects[3].OID)
require.True(t, objects[3].Missing)
require.Empty(t, objects[3].Data)
require.Zero(t, objects[3].Type)
}
func TestIntegration_GetObjects_Empty(t *testing.T) {
t.Parallel()
env := startIntegration(t, nil)
objects, err := env.repo.GetObjects(env.ctx, nil)
require.NoError(t, err)
require.Empty(t, objects)
}
func TestIntegration_GetObjects_Validation(t *testing.T) {
t.Parallel()
env := startIntegration(t, func(cfg *config.Cfg) {
cfg.Graft.ObjectService.MaxObjects = 2
})
blob := gittest.WriteBlob(t, env.cfg, env.repoPath, []byte("x"))
t.Run("empty object ID", func(t *testing.T) {
_, err := env.repo.GetObjects(env.ctx, []string{blob.String(), ""})
require.Equal(t, codes.InvalidArgument, sdk.Code(err))
})
t.Run("malformed object ID", func(t *testing.T) {
_, err := env.repo.GetObjects(env.ctx, []string{"not-an-object-id"})
require.Equal(t, codes.InvalidArgument, sdk.Code(err), "got %v", err)
})
t.Run("at the limit", func(t *testing.T) {
objects, err := env.repo.GetObjects(env.ctx, []string{blob.String(), missingOID})
require.NoError(t, err)
require.Len(t, objects, 2)
})
t.Run("above the server limit is split into requests within it", func(t *testing.T) {
objects, err := env.repo.GetObjects(env.ctx, []string{blob.String(), missingOID, zeroOID})
require.NoError(t, err)
require.Len(t, objects, 3)
require.Equal(t, []byte("x"), objects[0].Data)
require.True(t, objects[1].Missing)
require.True(t, objects[2].Missing)
})
t.Run("malformed object ID above the server limit", func(t *testing.T) {
_, err := env.repo.GetObjects(env.ctx, []string{blob.String(), missingOID, "not-an-object-id"})
require.Equal(t, codes.InvalidArgument, sdk.Code(err), "got %v", err)
require.ErrorContains(t, err, "invalid object ID")
})
}
func TestIntegration_GetObjects_ChunksLargeObjects(t *testing.T) {
t.Parallel()
env := startIntegration(t, func(cfg *config.Cfg) {
cfg.Graft.ObjectService.ChunkSize = 16
})
large := bytes.Repeat([]byte("abcdefghij"), 500)
small := []byte("tiny")
large1 := gittest.WriteBlob(t, env.cfg, env.repoPath, large)
small1 := gittest.WriteBlob(t, env.cfg, env.repoPath, small)
objects, err := env.repo.GetObjects(env.ctx, []string{large1.String(), small1.String()})
require.NoError(t, err)
require.Len(t, objects, 2)
require.Equal(t, large, objects[0].Data)
require.Equal(t, int64(len(large)), objects[0].Size)
require.Equal(t, small, objects[1].Data)
}
func TestIntegration_GetObjects_Batches(t *testing.T) {
t.Parallel()
// More than one batch of the SDK, and more objects than fit in one
// request by default, so the requests are split.
env := startIntegration(t, nil)
const count = 520
oids := make([]string, 0, count)
for i := 0; i < count; i++ {
oids = append(oids, gittest.WriteBlob(t, env.cfg, env.repoPath, []byte(fmt.Sprintf("object %d\n", i))).String())
}
objects, err := env.repo.GetObjects(env.ctx, oids)
require.NoError(t, err)
require.Len(t, objects, count)
for i, obj := range objects {
require.Equal(t, oids[i], obj.OID, "objects keep request order")
require.Equal(t, sdk.ObjectBlob, obj.Type)
require.Equal(t, fmt.Sprintf("object %d\n", i), string(obj.Data))
}
}
// flakyObjects drops the first failures GetObjects streams after
// afterMessages messages, the way a broken connection would.
type flakyObjects struct {
mu sync.Mutex
failures int
afterMessages int
streams int
}
func (f *flakyObjects) intercept(
ctx context.Context,
desc *grpc.StreamDesc,
cc *grpc.ClientConn,
method string,
streamer grpc.Streamer,
opts ...grpc.CallOption,
) (grpc.ClientStream, error) {
stream, err := streamer(ctx, desc, cc, method, opts...)
if err != nil || method != "/gitaly.ObjectService/GetObjects" {
return stream, err
}
f.mu.Lock()
defer f.mu.Unlock()
f.streams++
if f.failures == 0 {
return stream, nil
}
f.failures--
return &droppingStream{ClientStream: stream, remaining: f.afterMessages}, nil
}
type droppingStream struct {
grpc.ClientStream
remaining int
}
func (s *droppingStream) RecvMsg(m any) error {
if s.remaining == 0 {
return status.Error(codes.Unavailable, "connection dropped")
}
s.remaining--
return s.ClientStream.RecvMsg(m)
}
func TestIntegration_GetObjects_ResumesAfterDroppedStreams(t *testing.T) {
t.Parallel()
flaky := &flakyObjects{failures: 2, afterMessages: 3}
env := startIntegration(t, func(cfg *config.Cfg) {
cfg.Graft.ObjectService.ChunkSize = 16
}, sdk.WithGRPCOptions(grpc.WithStreamInterceptor(flaky.intercept)))
first := bytes.Repeat([]byte("0123456789"), 20) // 200 bytes, 13 chunks
second := bytes.Repeat([]byte("xyz"), 30)
blob1 := gittest.WriteBlob(t, env.cfg, env.repoPath, first)
blob2 := gittest.WriteBlob(t, env.cfg, env.repoPath, second)
objects, err := env.repo.GetObjects(env.ctx, []string{blob1.String(), blob2.String()})
require.NoError(t, err)
require.Len(t, objects, 2)
require.Equal(t, first, objects[0].Data)
require.Equal(t, second, objects[1].Data)
flaky.mu.Lock()
defer flaky.mu.Unlock()
require.Equal(t, 0, flaky.failures)
require.Equal(t, 3, flaky.streams, "two dropped streams were resumed")
}
func TestIntegration_GetObjects_GivesUpWithoutProgress(t *testing.T) {
t.Parallel()
flaky := &flakyObjects{failures: 1000, afterMessages: 0}
env := startIntegration(t, nil, sdk.WithGRPCOptions(grpc.WithStreamInterceptor(flaky.intercept)))
blob := gittest.WriteBlob(t, env.cfg, env.repoPath, []byte("never arrives"))
_, err := env.repo.GetObjects(env.ctx, []string{blob.String()})
require.Equal(t, codes.Unavailable, sdk.Code(err), "got %v", err)
}
func TestIntegration_CommitFiles(t *testing.T) {
t.Parallel()
env := startIntegration(t, nil)
base := env.writeCommit(t, "main", map[string]string{"keep.txt": "keep"})
user := sdk.User{ID: "user-1", Name: "Ada", Email: "[email protected]", Username: "ada"}
large := strings.Repeat("0123456789abcdef", 8192) // 128 KiB spans several content messages
t.Run("creates a branch with new files", func(t *testing.T) {
result, err := env.repo.CommitFiles(env.ctx, sdk.CommitOptions{
Branch: "feature",
StartRev: "main",
Message: "add files",
Author: sdk.Signature{Name: "Grace", Email: "[email protected]"},
User: user,
Timestamp: time.Unix(1700000000, 0),
Actions: []sdk.Action{
sdk.Put{Path: "dir/new.txt", Content: []byte("new")},
sdk.Put{Path: "big.bin", Content: []byte(large)},
sdk.Put{Path: "tool.sh", Content: []byte("#!/bin/sh\n"), Executable: true},
sdk.Put{Path: "empty.txt"},
},
})
require.NoError(t, err)
require.True(t, result.BranchCreated)
require.Equal(t, env.mustResolve(t, "feature"), result.CommitID)
require.Equal(t, base.String(), env.git(t, "rev-parse", "feature^"))
require.Equal(t, "new", env.readString(t, "feature", "dir/new.txt"))
require.Equal(t, large, string(mustReadFile(t, env, "feature", "big.bin")))
require.Equal(t, "keep", env.readString(t, "feature", "keep.txt"))
require.Equal(t, "", env.readString(t, "feature", "empty.txt"))
require.Contains(t, env.git(t, "ls-tree", "feature", "tool.sh"), "100755")
require.Equal(t, "Grace <[email protected]> 1700000000", env.git(t, "log", "-1", "--format=%an <%ae> %at", "feature"))
})
t.Run("updates an existing branch", func(t *testing.T) {
before := env.mustResolve(t, "feature")
result, err := env.repo.CommitFiles(env.ctx, sdk.CommitOptions{
Branch: "refs/heads/feature",
StartRev: "feature",
ExpectedOldOID: before,
Message: "reshape",
Author: sdk.Signature{Name: "Grace", Email: "[email protected]"},
User: user,
Actions: []sdk.Action{
sdk.Delete{Path: "keep.txt"},
sdk.Move{From: "dir/new.txt", To: "dir/moved.txt"},
sdk.Chmod{Path: "big.bin", Executable: true},
sdk.Put{Path: "big.bin", Content: []byte("small"), Overwrite: true},
},
})
require.NoError(t, err)
require.False(t, result.BranchCreated)
require.Equal(t, before, env.git(t, "rev-parse", "feature^"))
require.Equal(t, env.mustResolve(t, "feature"), result.CommitID)
_, err = env.repo.ReadFile(env.ctx, "feature", "keep.txt")
require.True(t, sdk.IsNotFound(err), "deleted file is gone, got %v", err)
require.Equal(t, "new", env.readString(t, "feature", "dir/moved.txt"))
require.Equal(t, "small", env.readString(t, "feature", "big.bin"))
require.Contains(t, env.git(t, "ls-tree", "feature", "big.bin"), "100755")
})
t.Run("creating an existing file fails", func(t *testing.T) {
_, err := env.repo.CommitFiles(env.ctx, sdk.CommitOptions{
Branch: "feature",
StartRev: "feature",
Message: "conflict",
User: user,
Actions: []sdk.Action{sdk.Put{Path: "dir/moved.txt", Content: []byte("again")}},
})
require.Equal(t, codes.AlreadyExists, sdk.Code(err), "got %v", err)
})
t.Run("unknown start revision", func(t *testing.T) {
_, err := env.repo.CommitFiles(env.ctx, sdk.CommitOptions{
Branch: "other",
StartRev: "no-such-branch",
Message: "msg",
User: user,
Actions: []sdk.Action{sdk.Put{Path: "x", Content: []byte("x")}},
})
require.True(t, sdk.IsNotFound(err), "got %v", err)
})
t.Run("stale expected old object ID is rejected", func(t *testing.T) {
featureBefore := env.mustResolve(t, "feature")
_, err := env.repo.CommitFiles(env.ctx, sdk.CommitOptions{
Branch: "feature",
StartRev: "feature",
ExpectedOldOID: base.String(),
Message: "stale",
User: user,
Actions: []sdk.Action{sdk.Put{Path: "stale.txt", Content: []byte("x")}},
})
require.Error(t, err)
require.Equal(t, featureBefore, env.mustResolve(t, "feature"), "branch is unchanged")
})
t.Run("expected old object ID zero requires a new branch", func(t *testing.T) {
_, err := env.repo.CommitFiles(env.ctx, sdk.CommitOptions{
Branch: "feature",
StartRev: "main",
ExpectedOldOID: zeroOID,
Message: "create",
User: user,
Actions: []sdk.Action{sdk.Put{Path: "z.txt", Content: []byte("z")}},
})
require.Error(t, err, "feature exists, so the zero OID must not match")
})
}
func TestIntegration_Land(t *testing.T) {
t.Parallel()
user := sdk.User{ID: "user-1", Name: "Ada", Email: "[email protected]"}
t.Run("fast-forward", func(t *testing.T) {
t.Parallel()
env := startIntegration(t, nil)
base := env.writeCommit(t, "main", map[string]string{"base.txt": "base"})
change := env.writeCommit(t, "", map[string]string{"base.txt": "base", "new.txt": "new"}, base)
result, err := env.repo.Land(env.ctx, sdk.LandOptions{Branch: "main", Commit: change.String(), User: user})
require.NoError(t, err)
require.Equal(t, change.String(), result.LandedCommitID)
require.Equal(t, base.String(), result.OldTip)
require.False(t, result.Rewritten)
require.False(t, result.AlreadyLanded)
require.False(t, result.BranchCreated)
require.Equal(t, int32(1), result.Attempts)
require.Equal(t, change.String(), env.mustResolve(t, "main"))
require.Equal(t, "new", env.readString(t, "main", "new.txt"))
})
t.Run("already landed leaves the branch alone", func(t *testing.T) {
t.Parallel()
env := startIntegration(t, nil)
base := env.writeCommit(t, "main", map[string]string{"base.txt": "base"})
tip := env.writeCommit(t, "main", map[string]string{"base.txt": "base", "x": "x"}, base)
result, err := env.repo.Land(env.ctx, sdk.LandOptions{Branch: "main", Commit: base.String(), User: user})
require.NoError(t, err)
require.True(t, result.AlreadyLanded)
require.False(t, result.Rewritten)
require.Equal(t, tip.String(), result.LandedCommitID)
require.Equal(t, tip.String(), env.mustResolve(t, "main"))
})
t.Run("rebases onto a diverged tip", func(t *testing.T) {
t.Parallel()
env := startIntegration(t, nil)
base := env.writeCommit(t, "main", map[string]string{"base.txt": "base"})
tip := env.writeCommit(t, "main", map[string]string{"base.txt": "base", "tip.txt": "tip"}, base)
change := env.writeCommit(t, "", map[string]string{"base.txt": "base", "change.txt": "change"}, base)
result, err := env.repo.Land(env.ctx, sdk.LandOptions{Branch: "main", Commit: change.String(), User: user})
require.NoError(t, err)
require.True(t, result.Rewritten)
require.False(t, result.AlreadyLanded)
require.Equal(t, tip.String(), result.OldTip)
require.NotEqual(t, change.String(), result.LandedCommitID)
require.Equal(t, result.LandedCommitID, env.mustResolve(t, "main"))
require.Equal(t, tip.String(), env.git(t, "rev-parse", "main^"), "history is linear on top of the tip")
require.Empty(t, env.git(t, "rev-list", "--merges", "main"))
require.Equal(t, "tip", env.readString(t, "main", "tip.txt"))
require.Equal(t, "change", env.readString(t, "main", "change.txt"))
})
t.Run("merge strategy creates a merge commit", func(t *testing.T) {
t.Parallel()
env := startIntegration(t, nil)
base := env.writeCommit(t, "main", map[string]string{"base.txt": "base"})
tip := env.writeCommit(t, "main", map[string]string{"base.txt": "base", "tip.txt": "tip"}, base)
change := env.writeCommit(t, "", map[string]string{"base.txt": "base", "change.txt": "change"}, base)
result, err := env.repo.Land(env.ctx, sdk.LandOptions{
Branch: "main",
Commit: change.String(),
User: user,
Strategy: sdk.LandMerge,
MergeMessage: "merge the change",
})
require.NoError(t, err)
require.True(t, result.Rewritten)
require.Equal(t, result.LandedCommitID, env.mustResolve(t, "main"))
require.Equal(t, tip.String(), env.git(t, "rev-parse", "main^1"))
require.Equal(t, change.String(), env.git(t, "rev-parse", "main^2"))
require.Equal(t, "merge the change", env.git(t, "log", "-1", "--format=%s", "main"))
})
t.Run("fast-forward only fails when not a fast-forward", func(t *testing.T) {
t.Parallel()
env := startIntegration(t, nil)
base := env.writeCommit(t, "main", map[string]string{"base.txt": "base"})
tip := env.writeCommit(t, "main", map[string]string{"base.txt": "base", "tip.txt": "tip"}, base)
change := env.writeCommit(t, "", map[string]string{"base.txt": "base", "change.txt": "change"}, base)
_, err := env.repo.Land(env.ctx, sdk.LandOptions{
Branch: "main",
Commit: change.String(),
User: user,
Strategy: sdk.LandFastForwardOnly,
})
require.True(t, sdk.IsNotAncestor(err), "got %v", err)
require.Equal(t, codes.FailedPrecondition, sdk.Code(err))
require.Equal(t, tip.String(), env.mustResolve(t, "main"), "branch is unchanged")
})
t.Run("conflicting change is reported", func(t *testing.T) {
t.Parallel()
env := startIntegration(t, nil)
base := env.writeCommit(t, "main", map[string]string{"f.txt": "base\n"})
tip := env.writeCommit(t, "main", map[string]string{"f.txt": "tip\n"}, base)
change := env.writeCommit(t, "", map[string]string{"f.txt": "change\n"}, base)
_, err := env.repo.Land(env.ctx, sdk.LandOptions{Branch: "main", Commit: change.String(), User: user})
require.True(t, sdk.IsMergeConflict(err), "got %v", err)
require.Equal(t, codes.FailedPrecondition, sdk.Code(err))
require.Equal(t, tip.String(), env.mustResolve(t, "main"), "branch is unchanged")
_, ok := sdk.LandConflict(err)
require.False(t, ok, "no package without ResolveConflicts")
})
t.Run("the conflict package and the re-land", func(t *testing.T) {
t.Parallel()
env := startIntegration(t, nil) // no resolver: the agent resolves
base := env.writeCommit(t, "main", map[string]string{"f.txt": "1\nbase\n3\n", "g.txt": "g\n"})
tip := env.writeCommit(t, "main", map[string]string{"f.txt": "1\ntip\n3\n", "g.txt": "g\n"}, base)
change := env.writeCommit(t, "", map[string]string{"f.txt": "1\nchange\n3\n", "g.txt": "g\n", "h.txt": "h\n"}, base)
_, err := env.repo.Land(env.ctx, sdk.LandOptions{Branch: "main", Commit: change.String(), User: user, ResolveConflicts: true})
require.True(t, sdk.IsMergeConflict(err), "got %v", err)
pkg, ok := sdk.LandConflict(err)
require.True(t, ok, "the merge conflict carries the package")
require.Equal(t, tip.String(), pkg.GetTip())
require.Equal(t, change.String(), pkg.GetCommit())
require.Equal(t, base.String(), pkg.GetMergeBase())
require.Len(t, pkg.GetFiles(), 1)
f := pkg.GetFiles()[0]
require.Equal(t, "f.txt", string(f.GetPath()))
require.Len(t, f.GetHunks(), 1)
require.Equal(t, uint32(2), f.GetHunks()[0].GetOurs().GetStart())
sides, err := env.repo.ConflictSides(env.ctx, pkg)
require.NoError(t, err)
require.Equal(t, sdk.ConflictSides{Base: []byte("1\nbase\n3\n"), Ours: []byte("1\ntip\n3\n"), Theirs: []byte("1\nchange\n3\n")}, sides["f.txt"])
resolution := sdk.ResolutionFor(pkg)
resolution.Files = []sdk.ResolvedFile{{Path: "f.txt", Mode: "100644", Content: []byte("1\ntip and change\n3\n")}}
result, err := env.repo.Land(env.ctx, sdk.LandOptions{Branch: "main", Commit: change.String(), User: user, Resolution: resolution})
require.NoError(t, err)
require.True(t, result.Rewritten)
require.Equal(t, "agent", result.Resolver)
require.Equal(t, []string{"f.txt"}, result.ResolvedPaths)
require.Equal(t, "1\ntip and change\n3\n", env.readString(t, "main", "f.txt"))
require.Equal(t, "h\n", env.readString(t, "main", "h.txt"))
body := env.git(t, "log", "-1", "--format=%B", "main")
require.Contains(t, body, "Graft-Resolved-By: agent\n")
require.NotContains(t, body, "Graft-Checked-By:")
})
t.Run("a side the repository does not keep", func(t *testing.T) {
t.Parallel()
// The tip renames a.txt to c.txt and changes its last line; the change changes its first
// line and adds a c.txt of its own. The tip's side of the add/add conflict on c.txt is the
// content merge of the rename, which no tree holds.
env := startIntegration(t, nil)
base := env.writeCommit(t, "main", map[string]string{"a.txt": "1\n2\n3\n4\n5\n6\n7\n8\n"})
env.writeCommit(t, "main", map[string]string{"c.txt": "1\n2\n3\n4\n5\n6\n7\neight\n"}, base)
change := env.writeCommit(t, "", map[string]string{"a.txt": "one\n2\n3\n4\n5\n6\n7\n8\n", "c.txt": "theirs\n"}, base)
_, err := env.repo.Land(env.ctx, sdk.LandOptions{Branch: "main", Commit: change.String(), User: user, ResolveConflicts: true})
pkg, ok := sdk.LandConflict(err)
require.True(t, ok, "got %v", err)
sides, err := env.repo.ConflictSides(env.ctx, pkg)
require.NoError(t, err, "an unavailable side fails no other side")
c := sides["c.txt"]
require.Nil(t, c.Ours)
require.Contains(t, c.Unreadable["ours"], "the merge wrote this blob")
require.Equal(t, []byte("theirs\n"), c.Theirs)
})
t.Run("create branch", func(t *testing.T) {
t.Parallel()
env := startIntegration(t, nil)
base := env.writeCommit(t, "main", map[string]string{"base.txt": "base"})
change := env.writeCommit(t, "", map[string]string{"base.txt": "base", "n.txt": "n"}, base)
_, err := env.repo.Land(env.ctx, sdk.LandOptions{Branch: "topic", Commit: change.String(), User: user})
require.True(t, sdk.IsNotFound(err), "missing branch without create_branch, got %v", err)
result, err := env.repo.Land(env.ctx, sdk.LandOptions{
Branch: "topic",
Commit: change.String(),
User: user,
CreateBranch: true,
})
require.NoError(t, err)
require.True(t, result.BranchCreated)
require.Empty(t, result.OldTip)
require.Equal(t, change.String(), result.LandedCommitID)
require.Equal(t, change.String(), env.mustResolve(t, "topic"))
})
t.Run("merge commits cannot be rebased", func(t *testing.T) {
t.Parallel()
env := startIntegration(t, nil)
base := env.writeCommit(t, "main", map[string]string{"base.txt": "base"})
env.writeCommit(t, "main", map[string]string{"base.txt": "base", "tip.txt": "tip"}, base)
left := env.writeCommit(t, "", map[string]string{"base.txt": "base", "left.txt": "l"}, base)
right := env.writeCommit(t, "", map[string]string{"base.txt": "base", "right.txt": "r"}, base)
merge := env.writeCommit(t, "", map[string]string{"base.txt": "base", "left.txt": "l", "right.txt": "r"}, left, right)
_, err := env.repo.Land(env.ctx, sdk.LandOptions{Branch: "main", Commit: merge.String(), User: user})
require.Equal(t, codes.InvalidArgument, sdk.Code(err), "got %v", err)
_, err = env.repo.Land(env.ctx, sdk.LandOptions{
Branch: "main",
Commit: merge.String(),
User: user,
Strategy: sdk.LandMerge,
})
require.NoError(t, err, "merge strategy accepts a merge commit")
})
t.Run("unknown commit", func(t *testing.T) {
t.Parallel()
env := startIntegration(t, nil)
env.writeCommit(t, "main", map[string]string{"base.txt": "base"})
_, err := env.repo.Land(env.ctx, sdk.LandOptions{Branch: "main", Commit: missingOID, User: user})
require.Equal(t, codes.InvalidArgument, sdk.Code(err), "got %v", err)
})
t.Run("validation", func(t *testing.T) {
t.Parallel()
env := startIntegration(t, nil)
_, err := env.repo.Land(env.ctx, sdk.LandOptions{Commit: missingOID, User: user})
require.Equal(t, codes.InvalidArgument, sdk.Code(err))
_, err = env.repo.Land(env.ctx, sdk.LandOptions{Branch: "main", User: user})
require.Equal(t, codes.InvalidArgument, sdk.Code(err))
_, err = env.repo.Land(env.ctx, sdk.LandOptions{Branch: "main", Commit: missingOID, MaxAttempts: -1, User: user})
require.Equal(t, codes.InvalidArgument, sdk.Code(err))
})
t.Run("concurrent disjoint changes all land linearly", func(t *testing.T) {
t.Parallel()
env := startIntegration(t, nil)
base := env.writeCommit(t, "main", map[string]string{"base.txt": "base"})
const writers = 12
changes := make([]git.ObjectID, 0, writers)
for i := 0; i < writers; i++ {
changes = append(changes, env.writeCommit(t, "",
map[string]string{"base.txt": "base", fmt.Sprintf("writer-%02d.txt", i): "data"}, base))
}
var (
wg sync.WaitGroup
mu sync.Mutex
results []*sdk.LandResult
errs []error
)
for i := range changes {
wg.Add(1)
go func(commit git.ObjectID) {
defer wg.Done()
result, err := env.repo.Land(env.ctx, sdk.LandOptions{
Branch: "main",
Commit: commit.String(),
User: sdk.User{
ID: fmt.Sprintf("user-%s", commit.String()[:8]),
Name: "Writer",
Email: "[email protected]",
},
})
mu.Lock()
defer mu.Unlock()
if err != nil {
errs = append(errs, err)
return
}
results = append(results, result)
}(changes[i])
}
wg.Wait()
require.Empty(t, errs)
require.Len(t, results, writers)
history := strings.Fields(env.git(t, "rev-list", "main"))
for _, result := range results {
require.NotEmpty(t, result.LandedCommitID)
require.GreaterOrEqual(t, result.Attempts, int32(1))
require.Contains(t, history, result.LandedCommitID, "every landed commit is on the branch")
}
tree := env.git(t, "ls-tree", "--name-only", "main")
for i := 0; i < writers; i++ {
require.Contains(t, tree, fmt.Sprintf("writer-%02d.txt", i))
}
require.Equal(t, writers+1, len(strings.Fields(env.git(t, "rev-list", "main"))))
require.Empty(t, env.git(t, "rev-list", "--merges", "main"))
})
}
func TestIntegration_Changesets(t *testing.T) {
t.Parallel()
env := startIntegration(t, nil)
changesets, err := env.repo.Changesets(env.ctx, 0, 0)
require.NoError(t, err)
require.Empty(t, changesets)
env.writeCommit(t, "main", map[string]string{"base.txt": "base"})
user := sdk.User{ID: "user-1", Name: "Ada", Email: "[email protected]"}
feature, err := env.repo.CommitFiles(env.ctx, sdk.CommitOptions{
Branch: "feature",
StartRev: "main",
Message: "feature",
User: user,
Actions: []sdk.Action{sdk.Put{Path: "f.txt", Content: []byte("f")}},
})
require.NoError(t, err)
landed, err := env.repo.Land(env.ctx, sdk.LandOptions{Branch: "main", Commit: feature.CommitID, User: user})
require.NoError(t, err)
changesets, err = env.repo.Changesets(env.ctx, 0, 0)
require.NoError(t, err)
require.Len(t, changesets, 2)
require.Equal(t, uint64(1), changesets[0].GetSequence())
require.Equal(t, uint64(2), changesets[1].GetSequence())
require.Equal(t, "refs/heads/feature", string(changesets[0].GetReference()))
require.Equal(t, zeroOID, changesets[0].GetOldOid(), "the branch was created")
require.Equal(t, feature.CommitID, changesets[0].GetNewOid())
require.Equal(t, "land", changesets[1].GetOperation())
require.Equal(t, "refs/heads/main", string(changesets[1].GetReference()))
require.Equal(t, landed.LandedCommitID, changesets[1].GetNewOid())
require.Equal(t, landed.Rewritten, changesets[1].GetRewritten())
after, err := env.repo.Changesets(env.ctx, 1, 0)
require.NoError(t, err)
require.Len(t, after, 1)
require.Equal(t, uint64(2), after[0].GetSequence())
limited, err := env.repo.Changesets(env.ctx, 0, 1)
require.NoError(t, err)
require.Len(t, limited, 1)
require.Equal(t, uint64(1), limited[0].GetSequence())
}
// nextChangeset receives the next changeset from a watch or fails the test.
func nextChangeset(t *testing.T, changes <-chan *sdk.Changeset, errs <-chan error) *sdk.Changeset {
t.Helper()
select {
case changeset, ok := <-changes:
require.True(t, ok, "watch ended unexpectedly")
return changeset
case err := <-errs:
t.Fatalf("watch failed: %v", err)
case <-time.After(10 * time.Second):
t.Fatal("timed out waiting for a changeset")
}
return nil
}
func TestIntegration_WatchChangesets(t *testing.T) {
t.Parallel()
env := startIntegration(t, nil)
env.writeCommit(t, "main", map[string]string{"base.txt": "base"})
user := sdk.User{ID: "user-1", Name: "Ada", Email: "[email protected]"}
land := func(name string) *sdk.LandResult {
commit, err := env.repo.CommitFiles(env.ctx, sdk.CommitOptions{
Branch: name,
StartRev: "main",
Message: name,
User: user,
Actions: []sdk.Action{sdk.Put{Path: name + ".txt", Content: []byte(name)}},
})
require.NoError(t, err)
result, err := env.repo.Land(env.ctx, sdk.LandOptions{Branch: "main", Commit: commit.CommitID, User: user})
require.NoError(t, err)
return result
}
land("one")
land("two")
ctx, cancel := context.WithCancel(env.ctx)
defer cancel()
changes, errs := env.repo.WatchChangesets(ctx, 0)
// The backlog comes first, in order: two branch creations and two lands.
for want := uint64(1); want <= 4; want++ {
require.Equal(t, want, nextChangeset(t, changes, errs).GetSequence())
}
// Then changes recorded while the watch is open.
land("three")
require.Equal(t, uint64(5), nextChangeset(t, changes, errs).GetSequence())
last := nextChangeset(t, changes, errs)
require.Equal(t, uint64(6), last.GetSequence())
require.Equal(t, "land", last.GetOperation())
cancel()
requireClosed(t, changes, errs)
}
func TestIntegration_WatchChangesets_StartsAfterCursor(t *testing.T) {
t.Parallel()
env := startIntegration(t, nil)
env.writeCommit(t, "main", map[string]string{"base.txt": "base"})
user := sdk.User{ID: "user-1", Name: "Ada", Email: "[email protected]"}
for _, name := range []string{"a", "b"} {
commit, err := env.repo.CommitFiles(env.ctx, sdk.CommitOptions{
Branch: name,
StartRev: "main",
Message: name,
User: user,
Actions: []sdk.Action{sdk.Put{Path: name, Content: []byte(name)}},
})
require.NoError(t, err)
_, err = env.repo.Land(env.ctx, sdk.LandOptions{Branch: "main", Commit: commit.CommitID, User: user})
require.NoError(t, err)
}
ctx, cancel := context.WithCancel(env.ctx)
defer cancel()
changes, errs := env.repo.WatchChangesets(ctx, 1)
require.Equal(t, uint64(2), nextChangeset(t, changes, errs).GetSequence())
cancel()
requireClosed(t, changes, errs)
}
func TestIntegration_WatchChangesets_UnknownRepository(t *testing.T) {
t.Parallel()
env := startIntegration(t, nil)
ctx, cancel := context.WithCancel(env.ctx)
defer cancel()
missing := env.client.Repo("@hashed/does/not/exist.git")
changes, errs := missing.WatchChangesets(ctx, 0)
select {
case err := <-errs:
require.NotNil(t, err)
require.NotEqual(t, codes.OK, sdk.Code(err))
case <-time.After(10 * time.Second):
t.Fatal("timed out waiting for the watch to fail")
}
requireClosed(t, changes, errs)
}
// requireClosed waits until both channels of a watch are closed.
func requireClosed(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 {
changes = nil
}
case _, ok := <-errs:
if !ok {
errs = nil
}
case <-timeout:
t.Fatal("watch did not close after cancellation")
}
}
}
func TestIntegration_Blame(t *testing.T) {
t.Parallel()
env := startIntegration(t, nil)
first := env.writeCommit(t, "main", map[string]string{"f.txt": "one\ntwo\n", "dir/x": "x"})
second := env.writeCommit(t, "main", map[string]string{"f.txt": "one\nTWO\nthree\n", "dir/x": "x"}, first)
t.Run("attributes lines to the commits that changed them", func(t *testing.T) {
blame, err := env.repo.Blame(env.ctx, "main", "f.txt")
require.NoError(t, err)
require.Equal(t, second.String(), blame.CommitID)
require.Len(t, blame.Lines, 3)
require.Equal(t, sdk.BlameLine{
LineNumber: 1, CommitID: first.String(), OriginalLineNumber: 1, Content: []byte("one"),
}, blame.Lines[0])
require.Equal(t, sdk.BlameLine{
LineNumber: 2, CommitID: second.String(), OriginalLineNumber: 2, Content: []byte("TWO"),
}, blame.Lines[1])
require.Equal(t, sdk.BlameLine{
LineNumber: 3, CommitID: second.String(), OriginalLineNumber: 3, Content: []byte("three"),
}, blame.Lines[2])
})
t.Run("older revision", func(t *testing.T) {
blame, err := env.repo.Blame(env.ctx, first.String(), "f.txt")
require.NoError(t, err)
require.Equal(t, first.String(), blame.CommitID)
require.Len(t, blame.Lines, 2)
for _, line := range blame.Lines {
require.Equal(t, first.String(), line.CommitID)
}
})
t.Run("missing path", func(t *testing.T) {
_, err := env.repo.Blame(env.ctx, "main", "nope.txt")
require.True(t, sdk.IsNotFound(err), "got %v", err)
})
t.Run("directory is not a file", func(t *testing.T) {
_, err := env.repo.Blame(env.ctx, "main", "dir")
require.Equal(t, codes.InvalidArgument, sdk.Code(err), "got %v", err)
})
t.Run("unknown revision", func(t *testing.T) {
_, err := env.repo.Blame(env.ctx, "no-such-branch", "f.txt")
require.True(t, sdk.IsNotFound(err), "got %v", err)
})
t.Run("validation", func(t *testing.T) {
_, err := env.repo.Blame(env.ctx, "", "f.txt")
require.Equal(t, codes.InvalidArgument, sdk.Code(err))
_, err = env.repo.Blame(env.ctx, "main", "")
require.Equal(t, codes.InvalidArgument, sdk.Code(err))
})
}
func TestIntegration_PathHistory(t *testing.T) {
t.Parallel()
env := startIntegration(t, nil)
c1 := env.writeCommit(t, "main", map[string]string{"a": "1", "b": "0"})
c2 := env.writeCommit(t, "main", map[string]string{"a": "2", "b": "0"}, c1)
c3 := env.writeCommit(t, "main", map[string]string{"a": "2", "b": "9"}, c2)
c4 := env.writeCommit(t, "main", map[string]string{"a": "3", "b": "9"}, c3)
commitIDs := func(commits []*sdk.Commit) []string {
out := make([]string, 0, len(commits))
for _, c := range commits {
out = append(out, c.GetId())
}
return out
}
t.Run("only commits that changed the path, newest first", func(t *testing.T) {
commits, err := env.repo.PathHistory(env.ctx, "main", "a", 0)
require.NoError(t, err)
require.Equal(t, []string{c4.String(), c2.String(), c1.String()}, commitIDs(commits))
})
t.Run("limit", func(t *testing.T) {
commits, err := env.repo.PathHistory(env.ctx, "main", "a", 2)
require.NoError(t, err)
require.Equal(t, []string{c4.String(), c2.String()}, commitIDs(commits))
})
t.Run("starts at the given revision", func(t *testing.T) {
commits, err := env.repo.PathHistory(env.ctx, c3.String(), "a", 0)
require.NoError(t, err)
require.Equal(t, []string{c2.String(), c1.String()}, commitIDs(commits))
})
t.Run("unknown revision", func(t *testing.T) {
_, err := env.repo.PathHistory(env.ctx, "no-such-branch", "a", 0)
require.Error(t, err)
})
t.Run("validation", func(t *testing.T) {
_, err := env.repo.PathHistory(env.ctx, "", "a", 0)
require.Equal(t, codes.InvalidArgument, sdk.Code(err))
_, err = env.repo.PathHistory(env.ctx, "main", "", 0)
require.Equal(t, codes.InvalidArgument, sdk.Code(err))
})
}
func TestIntegration_Authentication(t *testing.T) {
t.Parallel()
env := startIntegration(t, func(cfg *config.Cfg) {
cfg.Auth.Token = "shared-secret"
cfg.Graft.Agents = []config.GraftAgent{{Name: "agent-1", Token: "agent-secret"}}
})
base := env.writeCommit(t, "main", map[string]string{"base.txt": "base"})
want := base.String()
t.Run("shared token as v2 HMAC", func(t *testing.T) {
repo := env.dial(t, sdk.WithToken("shared-secret"))
got, err := repo.ResolveRevision(env.ctx, "main")
require.NoError(t, err)
require.Equal(t, want, got)
})
t.Run("agent token as bearer", func(t *testing.T) {
repo := env.dial(t, sdk.WithAgentToken("agent-secret"))
got, err := repo.ResolveRevision(env.ctx, "main")
require.NoError(t, err)
require.Equal(t, want, got)
})
t.Run("agent token as v2 HMAC", func(t *testing.T) {
repo := env.dial(t, sdk.WithToken("agent-secret"))
got, err := repo.ResolveRevision(env.ctx, "main")
require.NoError(t, err)
require.Equal(t, want, got)
})
t.Run("shared token is not accepted as a plain bearer", func(t *testing.T) {
repo := env.dial(t, sdk.WithAgentToken("shared-secret"))
_, err := repo.ResolveRevision(env.ctx, "main")
require.Equal(t, codes.Unauthenticated, sdk.Code(err), "got %v", err)
})
t.Run("wrong token", func(t *testing.T) {
repo := env.dial(t, sdk.WithToken("wrong"))
_, err := repo.ResolveRevision(env.ctx, "main")
require.Equal(t, codes.Unauthenticated, sdk.Code(err), "got %v", err)
})
t.Run("wrong agent token", func(t *testing.T) {
repo := env.dial(t, sdk.WithAgentToken("wrong"))
_, err := repo.ResolveRevision(env.ctx, "main")
require.Equal(t, codes.Unauthenticated, sdk.Code(err), "got %v", err)
})
t.Run("no token", func(t *testing.T) {
repo := env.dial(t)
_, err := repo.ResolveRevision(env.ctx, "main")
require.Equal(t, codes.Unauthenticated, sdk.Code(err), "got %v", err)
})
}