Git designed for AI agents.
package gitaly
import (
"bytes"
"context"
"os"
"path/filepath"
"testing"
"time"
"github.com/feder-cr/git-ai/internal/cli/common"
"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/gitaly/storage/mode"
"github.com/feder-cr/git-ai/internal/gitaly/storage/relational"
"github.com/feder-cr/git-ai/internal/gitlab"
"github.com/feder-cr/git-ai/internal/grpc/client"
"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/stretchr/testify/require"
)
func TestPoolSQLStore(t *testing.T) {
t.Parallel()
dbPath := filepath.Join(t.TempDir(), "pools.db")
ctx := context.Background()
db, err := relational.NewSQLitePoolStore(dbPath)
require.NoError(t, err)
defer testhelper.MustClose(t, db)
poolsByDiskPath := map[string]*relational.PoolMetadata{
"pools/pool": {
DiskPath: "pools/pool",
StorageNode: "default",
Members: []string{"group/project1.git", "group/project2.git"},
Upstream: "group/project1.git",
UpdatedAt: time.Now(),
},
}
err = db.StorePoolData(ctx, "default", poolsByDiskPath)
require.NoError(t, err)
pool, err := db.GetPoolByDiskPath(ctx, "pools/pool")
require.NoError(t, err)
require.NotNil(t, pool)
require.Equal(t, "pools/pool", pool.DiskPath)
require.Equal(t, "group/project1.git", pool.Upstream)
require.Len(t, pool.Members, 2)
diskPath, err := db.GetPoolForMember(ctx, "group/project1.git")
require.NoError(t, err)
require.Equal(t, "pools/pool", diskPath)
diskPath, err = db.GetPoolForMember(ctx, "group/project2.git")
require.NoError(t, err)
require.Equal(t, "pools/pool", diskPath)
diskPath, err = db.GetPoolForMember(ctx, "nonexistent/repo.git")
require.NoError(t, err)
require.Empty(t, diskPath)
}
func TestScanStorage(t *testing.T) {
t.Parallel()
newStore := func(t *testing.T) relational.PoolStore {
t.Helper()
store, err := relational.NewSQLitePoolStore(filepath.Join(t.TempDir(), "pools.db"))
require.NoError(t, err)
t.Cleanup(func() { _ = store.Close() })
return store
}
t.Run("scans pools and stores metadata with upstream", func(t *testing.T) {
t.Parallel()
ctx := testhelper.Context(t)
cfg := testcfg.Build(t)
storageName := cfg.Storages[0].Name
storageRoot := cfg.Storages[0].Path
store := newStore(t)
addr := testserver.RunGitalyServer(t, cfg, setup.RegisterAll,
testserver.WithPoolMetadataStore(store),
testserver.WithGitLabClient(gitlab.NewMockClientWithObjectPoolMembers(t,
gitlab.MockAllowed, gitlab.MockPreReceive, gitlab.MockPostReceive,
func(_ context.Context, diskPaths []string, storage string, _ bool) (map[string][]gitlab.ObjectPoolMember, error) {
require.Equal(t, storageName, storage)
result := make(map[string][]gitlab.ObjectPoolMember, len(diskPaths))
for _, diskPath := range diskPaths {
if diskPath == "@pools/aa/bb/pool-a" {
result[diskPath] = []gitlab.ObjectPoolMember{{
RelativePath: "upstream-repo.git",
Public: true,
IsUpstream: true,
}}
} else {
result[diskPath] = []gitlab.ObjectPoolMember{}
}
}
return result, nil
},
)),
testserver.WithDisablePraefect(),
)
// Create pool and link members.
poolDiskPath := "@pools/aa/bb/pool-a.git"
poolPath := filepath.Join(storageRoot, poolDiskPath)
require.NoError(t, os.MkdirAll(filepath.Join(poolPath, "objects"), mode.Directory))
require.NoError(t, os.MkdirAll(filepath.Join(poolPath, "refs"), mode.Directory))
require.NoError(t, os.MkdirAll(filepath.Join(poolPath, "HEAD"), mode.File))
for _, relPath := range []string{"upstream-repo.git", "fork-repo.git"} {
_, repoPath := gittest.CreateRepository(t, ctx, cfg, gittest.CreateRepositoryConfig{
SkipCreationViaService: true,
RelativePath: relPath,
})
require.NoError(t, os.MkdirAll(filepath.Join(repoPath, "objects", "info"), mode.Directory))
require.NoError(t, os.WriteFile(
filepath.Join(repoPath, "objects", "info", "alternates"),
[]byte(filepath.Join(poolPath, "objects")),
mode.File,
))
}
connPool := client.NewPool(client.WithDialOptions(client.UnaryInterceptor(), client.StreamInterceptor()))
defer func() { _ = connPool.Close() }()
conn, err := connPool.Dial(ctx, addr, "")
require.NoError(t, err)
internalClient := gitalypb.NewInternalGitalyClient(conn)
var out bytes.Buffer
scanner := &poolScanner{
logger: testhelper.SharedLogger(t),
out: &out,
internalClient: internalClient,
gitalyStorages: cfg.Storages,
}
require.NoError(t, scanner.scanStorage(ctx, cfg.Storages[0]))
require.Contains(t, out.String(), "found 2 pool members")
require.Contains(t, out.String(), "pool member: upstream-repo.git -> @pools/aa/bb/pool-a.git [isUpstream: true]")
require.Contains(t, out.String(), "pool member: fork-repo.git -> @pools/aa/bb/pool-a.git [isUpstream: false]")
// Verify metadata was stored.
pools, err := common.ListPoolMetadata(ctx, internalClient, storageName)
require.NoError(t, err)
require.ElementsMatch(t, []string{"@pools/aa/bb/pool-a.git"}, pools)
})
t.Run("no pool members produces no store call", func(t *testing.T) {
t.Parallel()
ctx := testhelper.Context(t)
cfg := testcfg.Build(t)
store := newStore(t)
addr := testserver.RunGitalyServer(t, cfg, setup.RegisterAll,
testserver.WithPoolMetadataStore(store),
testserver.WithGitLabClient(gitlab.NewMockClientWithObjectPoolMembers(t,
gitlab.MockAllowed, gitlab.MockPreReceive, gitlab.MockPostReceive,
func(context.Context, []string, string, bool) (map[string][]gitlab.ObjectPoolMember, error) {
t.Fatal("should not be called when no pool members exist")
return nil, nil
},
)),
testserver.WithDisablePraefect(),
)
// Create a repository without alternates.
gittest.CreateRepository(t, ctx, cfg, gittest.CreateRepositoryConfig{
SkipCreationViaService: true,
RelativePath: "repo-without-pool.git",
})
connPool := client.NewPool(client.WithDialOptions(client.UnaryInterceptor(), client.StreamInterceptor()))
defer func() { _ = connPool.Close() }()
conn, err := connPool.Dial(ctx, addr, "")
require.NoError(t, err)
internalClient := gitalypb.NewInternalGitalyClient(conn)
var out bytes.Buffer
scanner := &poolScanner{
logger: testhelper.SharedLogger(t),
out: &out,
internalClient: internalClient,
gitalyStorages: cfg.Storages,
}
require.NoError(t, scanner.scanStorage(ctx, cfg.Storages[0]))
require.Contains(t, out.String(), "found 0 pool members")
require.NotContains(t, out.String(), "pool member:")
})
t.Run("private upstream is not marked", func(t *testing.T) {
t.Parallel()
ctx := testhelper.Context(t)
cfg := testcfg.Build(t)
storageRoot := cfg.Storages[0].Path
store := newStore(t)
addr := testserver.RunGitalyServer(t, cfg, setup.RegisterAll,
testserver.WithPoolMetadataStore(store),
testserver.WithGitLabClient(gitlab.NewMockClientWithObjectPoolMembers(t,
gitlab.MockAllowed, gitlab.MockPreReceive, gitlab.MockPostReceive,
func(_ context.Context, diskPaths []string, _ string, _ bool) (map[string][]gitlab.ObjectPoolMember, error) {
result := make(map[string][]gitlab.ObjectPoolMember, len(diskPaths))
for _, diskPath := range diskPaths {
result[diskPath] = []gitlab.ObjectPoolMember{{
RelativePath: "private-upstream.git",
Public: false,
IsUpstream: true,
}}
}
return result, nil
},
)),
testserver.WithDisablePraefect(),
)
poolDiskPath := "@pools/aa/bb/private-pool.git"
poolPath := filepath.Join(storageRoot, poolDiskPath)
require.NoError(t, os.MkdirAll(filepath.Join(poolPath, "objects"), mode.Directory))
require.NoError(t, os.MkdirAll(filepath.Join(poolPath, "refs"), mode.Directory))
require.NoError(t, os.MkdirAll(filepath.Join(poolPath, "HEAD"), mode.File))
_, repoPath := gittest.CreateRepository(t, ctx, cfg, gittest.CreateRepositoryConfig{
SkipCreationViaService: true,
RelativePath: "private-upstream.git",
})
require.NoError(t, os.MkdirAll(filepath.Join(repoPath, "objects", "info"), mode.Directory))
require.NoError(t, os.WriteFile(
filepath.Join(repoPath, "objects", "info", "alternates"),
[]byte(filepath.Join(poolPath, "objects")),
mode.File,
))
connPool := client.NewPool(client.WithDialOptions(client.UnaryInterceptor(), client.StreamInterceptor()))
defer func() { _ = connPool.Close() }()
conn, err := connPool.Dial(ctx, addr, "")
require.NoError(t, err)
var out bytes.Buffer
scanner := &poolScanner{
logger: testhelper.SharedLogger(t),
out: &out,
internalClient: gitalypb.NewInternalGitalyClient(conn),
gitalyStorages: cfg.Storages,
}
require.NoError(t, scanner.scanStorage(ctx, cfg.Storages[0]))
require.Contains(t, out.String(), "pool member: private-upstream.git -> @pools/aa/bb/private-pool.git [isUpstream: false]")
})
}