Skip to content

Git designed for AI agents.

14.7 KB
Raw Blame
package dbreview_test

import (
	"context"
	"errors"
	"fmt"
	"sync"
	"testing"
	"time"

	"github.com/feder-cr/git-ai/internal/graft/corestore"
	"github.com/feder-cr/git-ai/internal/graft/corestore/coretest"
	"github.com/feder-cr/git-ai/internal/graft/corestore/dbreview"
	"github.com/feder-cr/git-ai/internal/graft/review/store"
	"github.com/feder-cr/git-ai/internal/testhelper"
	"github.com/feder-cr/git-ai/proto/go/gitalypb"
	"github.com/stretchr/testify/require"
)

// backend is one review store implementation under test. open returns two
// handles on the same reviews, as two nodes would have.
type backend struct {
	name string
	open func(t *testing.T) (store.ReviewStore, store.ReviewStore)
}

// backends returns the file store and the database store on every dialect.
// The conformance suite runs against all of them.
func backends() []backend {
	out := []backend{
		{
			name: "files",
			open: func(t *testing.T) (store.ReviewStore, store.ReviewStore) {
				dir := t.TempDir()
				return store.Open(dir), store.Open(dir)
			},
		},
	}

	for _, dialect := range coretest.Dialects() {
		out = append(out, backend{
			name: "database-" + string(dialect),
			open: func(t *testing.T) (store.ReviewStore, store.ReviewStore) {
				ctx := testhelper.Context(t)

				// Two cores on one database are two nodes.
				databaseURL := coretest.DatabaseURL(t, dialect)
				first := coretest.Open(t, coretest.Options{Dialect: dialect, DatabaseURL: databaseURL, NodeID: "node-a"})
				second := coretest.Open(t, coretest.Options{Dialect: dialect, DatabaseURL: databaseURL, NodeID: "node-b"})

				repo, _, err := first.Meta.RegisterRepository(ctx,
					corestore.RepoKey{Storage: "default", RelativePath: "repo.git"},
					"sha1", corestore.InitialState{})
				require.NoError(t, err)

				return dbreview.New(ctx, first.Meta, repo.ID), dbreview.New(ctx, second.Meta, repo.ID)
			},
		})
	}

	return out
}

// eachBackend runs fn as a subtest for every backend, with one handle.
func eachBackend(t *testing.T, fn func(t *testing.T, rs store.ReviewStore, other store.ReviewStore)) {
	t.Helper()
	for _, b := range backends() {
		t.Run(b.name, func(t *testing.T) {
			rs, other := b.open(t)
			fn(t, rs, other)
		})
	}
}

func ids(reviews []*gitalypb.Review) []string {
	out := make([]string, 0, len(reviews))
	for _, r := range reviews {
		out = append(out, r.GetId())
	}
	return out
}

func TestCreateGetList(t *testing.T) {
	eachBackend(t, func(t *testing.T, rs store.ReviewStore, _ store.ReviewStore) {
		a, err := rs.Create(&gitalypb.Review{TargetBranch: []byte("main"), Approved: true})
		require.NoError(t, err)
		require.Equal(t, "1", a.GetId())
		require.NotNil(t, a.GetCreatedAt())
		require.NotNil(t, a.GetUpdatedAt())
		require.False(t, a.GetApproved(), "approved is computed, not stored")
		require.Nil(t, a.GetRequirements())

		b, err := rs.Create(&gitalypb.Review{TargetBranch: []byte("dev")})
		require.NoError(t, err)
		require.Equal(t, "2", b.GetId())

		c, err := rs.Create(&gitalypb.Review{TargetBranch: []byte("main"), State: gitalypb.Review_STATE_LANDED})
		require.NoError(t, err)
		require.Equal(t, "3", c.GetId())

		got, err := rs.Get("1")
		require.NoError(t, err)
		require.Equal(t, []byte("main"), got.GetTargetBranch())
		require.False(t, got.GetApproved())

		for _, id := range []string{"99", "0", "", "x", "01"} {
			_, err := rs.Get(id)
			require.ErrorIs(t, err, store.ErrNotFound, "id %q", id)
		}

		all, err := rs.List("", false, 0)
		require.NoError(t, err)
		require.Equal(t, []string{"2", "1"}, ids(all), "landed review excluded, newest first")

		all, err = rs.List("", true, 0)
		require.NoError(t, err)
		require.Equal(t, []string{"3", "2", "1"}, ids(all))

		main, err := rs.List("main", true, 0)
		require.NoError(t, err)
		require.Equal(t, []string{"3", "1"}, ids(main))

		limited, err := rs.List("", true, 1)
		require.NoError(t, err)
		require.Equal(t, []string{"3"}, ids(limited))
	})
}

func TestUpdate(t *testing.T) {
	eachBackend(t, func(t *testing.T, rs store.ReviewStore, _ store.ReviewStore) {
		created, err := rs.Create(&gitalypb.Review{TargetBranch: []byte("main")})
		require.NoError(t, err)

		sentinel := errors.New("refused")
		_, err = rs.Update(created.GetId(), func(*gitalypb.Review) error { return sentinel })
		require.ErrorIs(t, err, sentinel, "the error of fn is returned unchanged")

		got, err := rs.Get(created.GetId())
		require.NoError(t, err)
		require.Equal(t, gitalypb.Review_STATE_OPEN_UNSPECIFIED, got.GetState(), "nothing was written")

		updated, err := rs.Update(created.GetId(), func(r *gitalypb.Review) error {
			r.State = gitalypb.Review_STATE_CLOSED
			return nil
		})
		require.NoError(t, err)
		require.Equal(t, gitalypb.Review_STATE_CLOSED, updated.GetState())

		got, err = rs.Get(created.GetId())
		require.NoError(t, err)
		require.Equal(t, gitalypb.Review_STATE_CLOSED, got.GetState())
		require.False(t, got.GetUpdatedAt().AsTime().Before(created.GetCreatedAt().AsTime()))

		_, err = rs.Update("42", func(*gitalypb.Review) error { return nil })
		require.ErrorIs(t, err, store.ErrNotFound)
	})
}

// withMaxOpen returns rs bounded to limit open reviews.
func withMaxOpen(t *testing.T, rs store.ReviewStore, limit int) store.ReviewStore {
	switch s := rs.(type) {
	case *store.Store:
		return s.WithMaxOpen(limit)
	case *dbreview.Store:
		return s.WithMaxOpen(limit)
	}
	require.FailNow(t, "unknown review store", "%T", rs)
	return nil
}

// TestCreateIsBoundedByTheOpenReviews: concurrent creates on two handles (two
// nodes) never pass the limit of open reviews; reviews that are not open do
// not count and are not refused, and closing one makes room for one.
func TestCreateIsBoundedByTheOpenReviews(t *testing.T) {
	eachBackend(t, func(t *testing.T, rs store.ReviewStore, other store.ReviewStore) {
		const limit, creates = 3, 12
		handles := []store.ReviewStore{withMaxOpen(t, rs, limit), withMaxOpen(t, other, limit)}

		landed, err := handles[0].Create(&gitalypb.Review{TargetBranch: []byte("main"), State: gitalypb.Review_STATE_LANDED})
		require.NoError(t, err, "a review that is not open is not bounded")

		start := make(chan struct{})
		errs := make(chan error, creates)
		for i := 0; i < creates; i++ {
			go func() {
				<-start
				_, err := handles[i%2].Create(&gitalypb.Review{TargetBranch: []byte("main")})
				errs <- err
			}()
		}
		close(start)
		created := 0
		for i := 0; i < creates; i++ {
			err := <-errs
			if err == nil {
				created++
				continue
			}
			require.ErrorIs(t, err, store.ErrTooManyOpenReviews)
		}
		require.Equal(t, limit, created, "exactly the limit is created")

		open, err := rs.List("", false, 0)
		require.NoError(t, err)
		require.Len(t, open, limit)
		all, err := rs.List("", true, 0)
		require.NoError(t, err)
		require.Len(t, all, limit+1, "a refused create writes nothing")
		require.Contains(t, ids(all), landed.GetId())

		_, err = handles[1].Create(&gitalypb.Review{TargetBranch: []byte("main")})
		require.ErrorIs(t, err, store.ErrTooManyOpenReviews)
		_, err = rs.Update(open[0].GetId(), func(r *gitalypb.Review) error {
			r.State = gitalypb.Review_STATE_CLOSED
			return nil
		})
		require.NoError(t, err)
		_, err = handles[1].Create(&gitalypb.Review{TargetBranch: []byte("main")})
		require.NoError(t, err, "closing a review makes room")
	})
}

func TestCreateTimestampsAreNow(t *testing.T) {
	eachBackend(t, func(t *testing.T, rs store.ReviewStore, _ store.ReviewStore) {
		before := time.Now().Add(-time.Second)
		r, err := rs.Create(&gitalypb.Review{TargetBranch: []byte("main")})
		require.NoError(t, err)
		require.True(t, r.GetCreatedAt().AsTime().After(before))
		require.True(t, r.GetCreatedAt().AsTime().Equal(r.GetUpdatedAt().AsTime()))
	})
}

// TestReviewsArePerRepository checks that two repositories of one database
// have their own review IDs and do not see each other's reviews.
func TestReviewsArePerRepository(t *testing.T) {
	for _, dialect := range coretest.Dialects() {
		t.Run(string(dialect), func(t *testing.T) {
			ctx := testhelper.Context(t)
			core := coretest.Open(t, coretest.Options{Dialect: dialect})

			register := func(path string) store.ReviewStore {
				repo, _, err := core.Meta.RegisterRepository(ctx,
					corestore.RepoKey{Storage: "default", RelativePath: path}, "sha1", corestore.InitialState{})
				require.NoError(t, err)
				return dbreview.New(ctx, core.Meta, repo.ID)
			}
			a, b := register("a.git"), register("b.git")

			ra, err := a.Create(&gitalypb.Review{TargetBranch: []byte("main"), Title: []byte("a")})
			require.NoError(t, err)
			rb, err := b.Create(&gitalypb.Review{TargetBranch: []byte("main"), Title: []byte("b")})
			require.NoError(t, err)
			require.Equal(t, "1", ra.GetId())
			require.Equal(t, "1", rb.GetId())

			got, err := b.Get("1")
			require.NoError(t, err)
			require.Equal(t, []byte("b"), got.GetTitle())

			_, err = a.Create(&gitalypb.Review{TargetBranch: []byte("main")})
			require.NoError(t, err)

			listed, err := b.List("", true, 0)
			require.NoError(t, err)
			require.Equal(t, []string{"1"}, ids(listed))
		})
	}
}

// conflictingMeta is a MetaStore whose reviews always changed concurrently.
type conflictingMeta struct {
	corestore.MetaStore
	gets, updates int
	updateErr     error
	// requireRoots are the requireRoots arguments of the writes, in order.
	requireRoots []bool
	// maxOpen are the open-review limits of the inserts, in order.
	maxOpen []int
}

func (m *conflictingMeta) GetReview(context.Context, int64, string) (*gitalypb.Review, int64, error) {
	m.gets++
	return &gitalypb.Review{Id: "1", TargetBranch: []byte("main")}, int64(m.gets), nil
}

func (m *conflictingMeta) UpdateReview(_ context.Context, _ int64, _ string, _ int64, _ *gitalypb.Review, requireRoots bool) error {
	m.updates++
	m.requireRoots = append(m.requireRoots, requireRoots)
	return m.updateErr
}

func (m *conflictingMeta) InsertReview(_ context.Context, _ int64, build func(string) (*gitalypb.Review, error), opts corestore.ReviewInsert) (*gitalypb.Review, error) {
	m.requireRoots = append(m.requireRoots, opts.RequireRoots)
	m.maxOpen = append(m.maxOpen, opts.MaxOpen)
	return build("1")
}

// TestRequiredRootsReachTheDatabase: the writes of WithRequiredRoots require
// the review's roots, those of New's store do not. A missing root is returned
// at once: retrying the same write without writing the reference again could
// not succeed.
func TestRequiredRootsReachTheDatabase(t *testing.T) {
	ctx := testhelper.Context(t)
	meta := &conflictingMeta{}
	plain := dbreview.New(ctx, meta, 1)

	_, err := plain.Create(&gitalypb.Review{})
	require.NoError(t, err)
	_, err = plain.Update("1", func(*gitalypb.Review) error { return nil })
	require.NoError(t, err)

	required := plain.(*dbreview.Store).WithRequiredRoots()
	_, err = required.Create(&gitalypb.Review{})
	require.NoError(t, err)
	_, err = required.Update("1", func(*gitalypb.Review) error { return nil })
	require.NoError(t, err)
	require.Equal(t, []bool{false, false, true, true}, meta.requireRoots)

	meta.updateErr = corestore.ErrReviewRootsMissing
	meta.updates = 0
	_, err = required.Update("1", func(*gitalypb.Review) error { return nil })
	require.ErrorIs(t, err, corestore.ErrReviewRootsMissing)
	require.Equal(t, 1, meta.updates)
}

// TestMaxOpenReachesTheDatabase: the open-review limit of WithMaxOpen goes to
// the insert, also through WithRequiredRoots, and the database's refusal is
// the store's ErrTooManyOpenReviews.
func TestMaxOpenReachesTheDatabase(t *testing.T) {
	ctx := testhelper.Context(t)
	meta := &conflictingMeta{}
	plain := dbreview.New(ctx, meta, 1).(*dbreview.Store)

	_, err := plain.Create(&gitalypb.Review{})
	require.NoError(t, err)
	_, err = plain.WithMaxOpen(5).Create(&gitalypb.Review{})
	require.NoError(t, err)
	_, err = plain.WithMaxOpen(7).WithRequiredRoots().Create(&gitalypb.Review{})
	require.NoError(t, err)
	require.Equal(t, []int{0, 5, 7}, meta.maxOpen)
	require.Equal(t, []bool{false, false, true}, meta.requireRoots)

	refusing := &refusingMeta{}
	_, err = dbreview.New(ctx, refusing, 1).(*dbreview.Store).WithMaxOpen(1).Create(&gitalypb.Review{})
	require.ErrorIs(t, err, store.ErrTooManyOpenReviews)
	require.ErrorContains(t, err, "the limit is 1")
}

// refusingMeta refuses every insert as beyond the open-review limit.
type refusingMeta struct {
	corestore.MetaStore
}

func (refusingMeta) InsertReview(_ context.Context, _ int64, _ func(string) (*gitalypb.Review, error), opts corestore.ReviewInsert) (*gitalypb.Review, error) {
	return nil, fmt.Errorf("%w: the repository has %d open reviews, the limit is %d", corestore.ErrTooManyOpenReviews, opts.MaxOpen, opts.MaxOpen)
}

func TestUpdateGivesUpAfterTenConflicts(t *testing.T) {
	ctx := testhelper.Context(t)
	meta := &conflictingMeta{updateErr: corestore.ErrReviewVersionConflict}

	calls := 0
	_, err := dbreview.New(ctx, meta, 1).Update("1", func(*gitalypb.Review) error {
		calls++
		return nil
	})
	require.ErrorIs(t, err, corestore.ErrReviewVersionConflict)
	require.Equal(t, 10, calls, "fn runs once per attempt")
	require.Equal(t, 10, meta.gets, "every attempt reads the review again")
	require.Equal(t, 10, meta.updates)
}

func TestUpdateReturnsOtherErrorsAtOnce(t *testing.T) {
	ctx := testhelper.Context(t)
	broken := errors.New("database is down")
	meta := &conflictingMeta{updateErr: broken}

	_, err := dbreview.New(ctx, meta, 1).Update("1", func(*gitalypb.Review) error { return nil })
	require.ErrorIs(t, err, broken)
	require.Equal(t, 1, meta.updates)
}

func TestUpdateStopsWhenContextIsCancelled(t *testing.T) {
	ctx, cancel := context.WithCancel(testhelper.Context(t))
	meta := &conflictingMeta{updateErr: corestore.ErrReviewVersionConflict}

	_, err := dbreview.New(ctx, meta, 1).Update("1", func(*gitalypb.Review) error {
		cancel()
		return nil
	})
	require.ErrorIs(t, err, context.Canceled)
	require.Equal(t, 1, meta.updates)
}

// TestConcurrentUpdatesLoseNothing runs updates through two handles at once.
// Every update appends one byte to the target branch, so the final length
// counts every update that was applied.
func TestConcurrentUpdatesLoseNothing(t *testing.T) {
	for _, b := range backends() {
		t.Run(b.name, func(t *testing.T) {
			first, second := b.open(t)

			created, err := first.Create(&gitalypb.Review{TargetBranch: []byte("main")})
			require.NoError(t, err)

			const writers, updatesPerWriter = 2, 20
			var (
				wg   sync.WaitGroup
				mu   sync.Mutex
				errs []error
			)
			for _, rs := range []store.ReviewStore{first, second} {
				wg.Add(1)
				go func(rs store.ReviewStore) {
					defer wg.Done()
					for i := 0; i < updatesPerWriter; i++ {
						_, err := rs.Update(created.GetId(), func(r *gitalypb.Review) error {
							r.TargetBranch = append(r.TargetBranch, 'x')
							return nil
						})
						if err != nil {
							mu.Lock()
							errs = append(errs, err)
							mu.Unlock()
						}
					}
				}(rs)
			}
			wg.Wait()
			require.Empty(t, errs)

			got, err := first.Get(created.GetId())
			require.NoError(t, err)
			require.Len(t, got.GetTargetBranch(), len("main")+writers*updatesPerWriter)
		})
	}
}