Skip to content

Git designed for AI agents.

9.0 KB
Raw Blame
package sdk_test

import (
	"context"
	"sync"
	"testing"

	"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/proto/go/gitalypb"
	"github.com/feder-cr/git-ai/sdk"
)

// fakeStorageCore implements StorageCoreService with canned responses and
// records the requests it receives.
type fakeStorageCore struct {
	gitalypb.UnimplementedStorageCoreServiceServer

	importResp     *gitalypb.ImportRepositoryResponse
	stateResp      *gitalypb.GetStorageStateResponse
	verifyResp     *gitalypb.VerifyRepositoryResponse
	checkpointResp *gitalypb.CreateCheckpointResponse
	gcResp         *gitalypb.CollectGarbageResponse
	removedResp    *gitalypb.CollectRemovedRepositoriesResponse
	err            error

	mu             sync.Mutex
	importReqs     []*gitalypb.ImportRepositoryRequest
	stateReqs      []*gitalypb.GetStorageStateRequest
	verifyReqs     []*gitalypb.VerifyRepositoryRequest
	checkpointReqs []*gitalypb.CreateCheckpointRequest
	gcReqs         []*gitalypb.CollectGarbageRequest
	removedReqs    []*gitalypb.CollectRemovedRepositoriesRequest
}

func (f *fakeStorageCore) CreateCheckpoint(_ context.Context, req *gitalypb.CreateCheckpointRequest) (*gitalypb.CreateCheckpointResponse, error) {
	f.mu.Lock()
	defer f.mu.Unlock()
	f.checkpointReqs = append(f.checkpointReqs, req)
	if f.err != nil {
		return nil, f.err
	}
	return f.checkpointResp, nil
}

func (f *fakeStorageCore) CollectGarbage(_ context.Context, req *gitalypb.CollectGarbageRequest) (*gitalypb.CollectGarbageResponse, error) {
	f.mu.Lock()
	defer f.mu.Unlock()
	f.gcReqs = append(f.gcReqs, req)
	if f.err != nil {
		return nil, f.err
	}
	return f.gcResp, nil
}

func (f *fakeStorageCore) CollectRemovedRepositories(_ context.Context, req *gitalypb.CollectRemovedRepositoriesRequest) (*gitalypb.CollectRemovedRepositoriesResponse, error) {
	f.mu.Lock()
	defer f.mu.Unlock()
	f.removedReqs = append(f.removedReqs, req)
	if f.err != nil {
		return nil, f.err
	}
	return f.removedResp, nil
}

func (f *fakeStorageCore) ImportRepository(_ context.Context, req *gitalypb.ImportRepositoryRequest) (*gitalypb.ImportRepositoryResponse, error) {
	f.mu.Lock()
	defer f.mu.Unlock()
	f.importReqs = append(f.importReqs, req)
	if f.err != nil {
		return nil, f.err
	}
	return f.importResp, nil
}

func (f *fakeStorageCore) GetStorageState(_ context.Context, req *gitalypb.GetStorageStateRequest) (*gitalypb.GetStorageStateResponse, error) {
	f.mu.Lock()
	defer f.mu.Unlock()
	f.stateReqs = append(f.stateReqs, req)
	if f.err != nil {
		return nil, f.err
	}
	return f.stateResp, nil
}

func (f *fakeStorageCore) VerifyRepository(_ context.Context, req *gitalypb.VerifyRepositoryRequest) (*gitalypb.VerifyRepositoryResponse, error) {
	f.mu.Lock()
	defer f.mu.Unlock()
	f.verifyReqs = append(f.verifyReqs, req)
	if f.err != nil {
		return nil, f.err
	}
	return f.verifyResp, nil
}

// storageRepo starts the fake and returns a handle to a repository on it.
func storageRepo(t *testing.T, fake *fakeStorageCore) *sdk.Repo {
	t.Helper()

	client := dialFake(t, func(srv *grpc.Server) {
		gitalypb.RegisterStorageCoreServiceServer(srv, fake)
	}, sdk.WithStorage("default"))
	return client.Repo("@hashed/ab/cd/repo.git")
}

func TestStorageCheckpoint(t *testing.T) {
	fake := &fakeStorageCore{checkpointResp: &gitalypb.CreateCheckpointResponse{
		CheckpointSequence: 42,
		Created:            true,
		PackBytes:          8192,
		References:         5,
	}}
	repo := storageRepo(t, fake)

	res, err := repo.StorageCheckpoint(t.Context())
	require.NoError(t, err)
	require.Equal(t, &sdk.StorageCheckpoint{Sequence: 42, Created: true, PackBytes: 8192, References: 5}, res)
	require.Len(t, fake.checkpointReqs, 1)
	require.Equal(t, "@hashed/ab/cd/repo.git", fake.checkpointReqs[0].GetRepository().GetRelativePath())
}

func TestStorageGC(t *testing.T) {
	fake := &fakeStorageCore{gcResp: &gitalypb.CollectGarbageResponse{
		Boundary:           7,
		CoveredDeleted:     3,
		CheckpointsDropped: 1,
		OrphansDeleted:     2,
		OrphansObserved:    4,
		OrphansInGrace:     5,
		PacksDeleted:       6,
		BytesReclaimed:     1 << 20,
		DryRun:             true,
	}}
	repo := storageRepo(t, fake)

	res, err := repo.StorageGC(t.Context(), true)
	require.NoError(t, err)
	require.Equal(t, &sdk.StorageGC{
		Boundary:           7,
		CoveredDeleted:     3,
		CheckpointsDropped: 1,
		OrphansDeleted:     2,
		OrphansObserved:    4,
		OrphansInGrace:     5,
		PacksDeleted:       6,
		BytesReclaimed:     1 << 20,
		DryRun:             true,
	}, res)
	require.Len(t, fake.gcReqs, 1)
	require.True(t, fake.gcReqs[0].GetDryRun())
	require.Equal(t, "default", fake.gcReqs[0].GetRepository().GetStorageName())
}

func TestStorageGCRemoved(t *testing.T) {
	fake := &fakeStorageCore{removedResp: &gitalypb.CollectRemovedRepositoriesResponse{
		Repositories:        2,
		PacksDeleted:        9,
		BytesReclaimed:      4096,
		LeaksFound:          3,
		LeaksTombstoned:     2,
		IdsAheadOfAllocator: 1,
	}}
	client := dialFake(t, func(srv *grpc.Server) {
		gitalypb.RegisterStorageCoreServiceServer(srv, fake)
	}, sdk.WithStorage("default"))

	res, err := client.StorageGCRemoved(t.Context(), "", false)
	require.NoError(t, err)
	require.Equal(t, &sdk.StorageGCRemoved{
		Repositories: 2, PacksDeleted: 9, BytesReclaimed: 4096,
		LeaksFound: 3, LeaksTombstoned: 2, IDsAheadOfAllocator: 1,
	}, res)

	_, err = client.StorageGCRemoved(t.Context(), "other", true)
	require.NoError(t, err)

	require.Len(t, fake.removedReqs, 2)
	require.Equal(t, "default", fake.removedReqs[0].GetStorageName(), "the client's storage by default")
	require.False(t, fake.removedReqs[0].GetDryRun())
	require.Equal(t, "other", fake.removedReqs[1].GetStorageName())
	require.True(t, fake.removedReqs[1].GetDryRun())
}

func TestStorageMaintenanceErrorsAreReturned(t *testing.T) {
	fake := &fakeStorageCore{err: status.Error(codes.FailedPrecondition, "the storage core is off")}
	repo := storageRepo(t, fake)

	_, err := repo.StorageCheckpoint(t.Context())
	require.Equal(t, codes.FailedPrecondition, status.Code(err))
	_, err = repo.StorageGC(t.Context(), false)
	require.Equal(t, codes.FailedPrecondition, status.Code(err))
}

func TestStorageImport(t *testing.T) {
	fake := &fakeStorageCore{importResp: &gitalypb.ImportRepositoryResponse{
		Sequence:         1,
		References:       3,
		PackBytes:        4096,
		ChangelogEntries: 7,
		Reviews:          2,
	}}
	repo := storageRepo(t, fake)

	res, err := repo.StorageImport(t.Context())
	require.NoError(t, err)
	require.Equal(t, &sdk.StorageImport{
		Sequence:         1,
		References:       3,
		PackBytes:        4096,
		ChangelogEntries: 7,
		Reviews:          2,
	}, res)

	require.Len(t, fake.importReqs, 1)
	got := fake.importReqs[0].GetRepository()
	require.Equal(t, "default", got.GetStorageName())
	require.Equal(t, "@hashed/ab/cd/repo.git", got.GetRelativePath())
}

func TestStorageImportErrorIsReturned(t *testing.T) {
	fake := &fakeStorageCore{err: status.Error(codes.AlreadyExists, "already tracked")}
	repo := storageRepo(t, fake)

	_, err := repo.StorageImport(t.Context())
	require.Equal(t, codes.AlreadyExists, status.Code(err))
}

func TestStorageState(t *testing.T) {
	fake := &fakeStorageCore{stateResp: &gitalypb.GetStorageStateResponse{
		Mode:            "authoritative",
		Tracked:         true,
		RepositoryId:    12,
		HeadSequence:    40,
		AppliedSequence: 39,
		NodeId:          "node-b",
	}}
	repo := storageRepo(t, fake)

	state, err := repo.StorageState(t.Context())
	require.NoError(t, err)
	require.Equal(t, &sdk.StorageState{
		Mode:            "authoritative",
		Tracked:         true,
		RepositoryID:    12,
		HeadSequence:    40,
		AppliedSequence: 39,
		NodeID:          "node-b",
	}, state)
	require.Len(t, fake.stateReqs, 1)
}

func TestStorageVerify(t *testing.T) {
	fake := &fakeStorageCore{verifyResp: &gitalypb.VerifyRepositoryResponse{
		HeadSequence: 5,
		Divergences: []*gitalypb.VerifyRepositoryResponse_ReferenceDivergence{{
			Reference:      []byte("refs/heads/main"),
			LocalTarget:    "1111111111111111111111111111111111111111",
			DatabaseTarget: "2222222222222222222222222222222222222222",
		}},
		ConnectivityOk:    false,
		ConnectivityError: "broken link",
	}}
	repo := storageRepo(t, fake)

	res, err := repo.StorageVerify(t.Context(), true)
	require.NoError(t, err)
	require.EqualValues(t, 5, res.HeadSequence)
	require.Equal(t, []sdk.StorageDivergence{{
		Reference:      "refs/heads/main",
		LocalTarget:    "1111111111111111111111111111111111111111",
		DatabaseTarget: "2222222222222222222222222222222222222222",
	}}, res.Divergences)
	require.False(t, res.ConnectivityOK)
	require.Equal(t, "broken link", res.ConnectivityError)

	require.Len(t, fake.verifyReqs, 1)
	require.True(t, fake.verifyReqs[0].GetCheckConnectivity())
}

func TestStorageVerifyWithoutConnectivityOrDivergence(t *testing.T) {
	fake := &fakeStorageCore{verifyResp: &gitalypb.VerifyRepositoryResponse{HeadSequence: 1}}
	repo := storageRepo(t, fake)

	res, err := repo.StorageVerify(t.Context(), false)
	require.NoError(t, err)
	require.Empty(t, res.Divergences)
	require.False(t, fake.verifyReqs[0].GetCheckConnectivity())
}