Skip to content

Git designed for AI agents.

12.9 KB
Raw Blame
package eager

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

	"github.com/feder-cr/git-ai/internal/git"
	"github.com/feder-cr/git-ai/internal/gitaly/storage"
	"github.com/feder-cr/git-ai/internal/graft/changelog"
	"github.com/feder-cr/git-ai/internal/testhelper"
	"github.com/feder-cr/git-ai/proto/go/gitalypb"
	"github.com/stretchr/testify/require"
)

const (
	zeroOID = "0000000000000000000000000000000000000000"
	oidA    = "1111111111111111111111111111111111111111"
	oidB    = "2222222222222222222222222222222222222222"
	oidC    = "3333333333333333333333333333333333333333"
)

var testRepo = &gitalypb.Repository{StorageName: "default", RelativePath: "repo.git"}

// fakeEnqueuer records the commits it is asked to enqueue.
type fakeEnqueuer struct {
	mu      sync.Mutex
	calls   [][]git.ObjectID
	explode bool
}

func (f *fakeEnqueuer) Enqueue(_ storage.Repository, commits []git.ObjectID) {
	f.mu.Lock()
	defer f.mu.Unlock()

	if f.explode {
		panic("boom")
	}

	f.calls = append(f.calls, append([]git.ObjectID(nil), commits...))
}

func (f *fakeEnqueuer) recorded() [][]git.ObjectID {
	f.mu.Lock()
	defer f.mu.Unlock()

	return append([][]git.ObjectID(nil), f.calls...)
}

// fakeLister answers the listing of the new commits from a table keyed by the
// old and new value of an update, and records the listings.
type fakeLister struct {
	mu      sync.Mutex
	answers map[[2]string][]git.ObjectID
	errs    map[[2]string]error
	calls   [][2]string
}

func (l *fakeLister) list(_ context.Context, _ storage.Repository, oldOID, newOID string) ([]git.ObjectID, error) {
	l.mu.Lock()
	defer l.mu.Unlock()

	key := [2]string{oldOID, newOID}
	l.calls = append(l.calls, key)

	if err := l.errs[key]; err != nil {
		return nil, err
	}

	return l.answers[key], nil
}

func (l *fakeLister) listed() [][2]string {
	l.mu.Lock()
	defer l.mu.Unlock()

	return append([][2]string(nil), l.calls...)
}

// fakeWriter counts the commit-graph writes per repository.
type fakeWriter struct {
	mu     sync.Mutex
	counts int
}

func (w *fakeWriter) write(_ context.Context, _ storage.Repository) error {
	w.mu.Lock()
	defer w.mu.Unlock()

	w.counts++
	return nil
}

func (w *fakeWriter) count() int {
	w.mu.Lock()
	defer w.mu.Unlock()

	return w.counts
}

func TestObserveCommitted_EnqueuesNewCommitsOfEveryTarget(t *testing.T) {
	ctx := testhelper.Context(t)
	enqueuer := &fakeEnqueuer{}
	writer := &fakeWriter{}
	lister := &fakeLister{answers: map[[2]string][]git.ObjectID{
		{zeroOID, oidB}: {oidB, oidA},
		{oidA, oidC}:    {oidC, oidB, oidA},
	}}

	observer := NewObserver(ctx, testhelper.NewLogger(t),
		Options{Eager: true, CommitGraph: true, Debounce: 10 * time.Millisecond},
		Deps{Enqueuer: enqueuer, ListNewCommits: lister.list, WriteCommitGraph: writer.write})
	defer observer.Close()

	observer.ObserveCommitted(ctx, testRepo, []changelog.Update{
		{Reference: "refs/heads/main", OldOID: zeroOID, NewOID: oidB},
		{Reference: "refs/heads/feature", OldOID: oidA, NewOID: oidC},
		{Reference: "refs/heads/gone", OldOID: oidA, NewOID: zeroOID},
		{Reference: "refs/heads/main", OldOID: zeroOID, NewOID: oidB},
	})

	require.Eventually(t, func() bool { return len(enqueuer.recorded()) == 1 }, time.Second, time.Millisecond)
	require.Equal(t, [][]git.ObjectID{{oidB, oidA, oidC}}, enqueuer.recorded(),
		"every new commit is enqueued once, not only the tips")
	require.Equal(t, [][2]string{{zeroOID, oidB}, {oidA, oidC}}, lister.listed(),
		"deletions and repeated updates are not listed")
	require.Eventually(t, func() bool { return writer.count() == 1 }, time.Second, time.Millisecond)
}

func TestObserveCommitted_ListingErrorSkipsOnlyThatUpdate(t *testing.T) {
	ctx := testhelper.Context(t)
	enqueuer := &fakeEnqueuer{}
	lister := &fakeLister{
		answers: map[[2]string][]git.ObjectID{{zeroOID, oidC}: {oidC}},
		errs:    map[[2]string]error{{oidA, oidB}: errors.New("bad object")},
	}

	observer := NewObserver(ctx, testhelper.NewLogger(t), Options{Eager: true},
		Deps{Enqueuer: enqueuer, ListNewCommits: lister.list})
	defer observer.Close()

	observer.ObserveCommitted(ctx, testRepo, []changelog.Update{
		{Reference: "refs/heads/broken", OldOID: oidA, NewOID: oidB},
		{Reference: "refs/heads/new", OldOID: zeroOID, NewOID: oidC},
	})

	require.Eventually(t, func() bool { return len(enqueuer.recorded()) == 1 }, time.Second, time.Millisecond)
	require.Equal(t, [][]git.ObjectID{{oidC}}, enqueuer.recorded())
}

func TestObserveCommitted_DeletionsOnlyScheduleCommitGraph(t *testing.T) {
	ctx := testhelper.Context(t)
	enqueuer := &fakeEnqueuer{}
	writer := &fakeWriter{}
	lister := &fakeLister{}

	observer := NewObserver(ctx, testhelper.NewLogger(t),
		Options{Eager: true, CommitGraph: true, Debounce: 5 * time.Millisecond},
		Deps{Enqueuer: enqueuer, ListNewCommits: lister.list, WriteCommitGraph: writer.write})
	defer observer.Close()

	observer.ObserveCommitted(ctx, testRepo, []changelog.Update{
		{Reference: "refs/heads/main", OldOID: oidA, NewOID: zeroOID},
	})

	require.Eventually(t, func() bool { return writer.count() == 1 }, time.Second, time.Millisecond)
	require.Empty(t, lister.listed())
	require.Empty(t, enqueuer.recorded())
}

func TestObserveCommitted_NoUpdatesDoesNothing(t *testing.T) {
	ctx := testhelper.Context(t)
	enqueuer := &fakeEnqueuer{}
	writer := &fakeWriter{}
	lister := &fakeLister{}

	observer := NewObserver(ctx, testhelper.NewLogger(t),
		Options{Eager: true, CommitGraph: true, Debounce: 5 * time.Millisecond},
		Deps{Enqueuer: enqueuer, ListNewCommits: lister.list, WriteCommitGraph: writer.write})
	defer observer.Close()

	observer.ObserveCommitted(ctx, testRepo, nil)

	time.Sleep(30 * time.Millisecond)
	require.Empty(t, lister.listed())
	require.Empty(t, enqueuer.recorded())
	require.Zero(t, writer.count())
}

func TestObserveCommitted_DisabledTriggers(t *testing.T) {
	ctx := testhelper.Context(t)
	updates := []changelog.Update{{Reference: "refs/heads/main", OldOID: oidA, NewOID: oidB}}

	t.Run("eager off", func(t *testing.T) {
		enqueuer := &fakeEnqueuer{}
		lister := &fakeLister{}

		observer := NewObserver(ctx, testhelper.NewLogger(t), Options{Eager: false},
			Deps{Enqueuer: enqueuer, ListNewCommits: lister.list})
		defer observer.Close()

		observer.ObserveCommitted(ctx, testRepo, updates)
		require.Empty(t, lister.listed())
		require.Empty(t, enqueuer.recorded())
	})

	t.Run("no enqueuer", func(t *testing.T) {
		writer := &fakeWriter{}
		lister := &fakeLister{}

		observer := NewObserver(ctx, testhelper.NewLogger(t),
			Options{Eager: true, CommitGraph: true, Debounce: 5 * time.Millisecond},
			Deps{ListNewCommits: lister.list, WriteCommitGraph: writer.write})
		defer observer.Close()

		observer.ObserveCommitted(ctx, testRepo, updates)
		require.Eventually(t, func() bool { return writer.count() == 1 }, time.Second, time.Millisecond)
		require.Empty(t, lister.listed())
	})

	t.Run("commit-graph off", func(t *testing.T) {
		enqueuer := &fakeEnqueuer{}
		lister := &fakeLister{answers: map[[2]string][]git.ObjectID{{oidA, oidB}: {oidB}}}
		writer := &fakeWriter{}

		observer := NewObserver(ctx, testhelper.NewLogger(t),
			Options{Eager: true, CommitGraph: false, Debounce: 5 * time.Millisecond},
			Deps{Enqueuer: enqueuer, ListNewCommits: lister.list, WriteCommitGraph: writer.write})
		defer observer.Close()

		observer.ObserveCommitted(ctx, testRepo, updates)
		require.Eventually(t, func() bool { return len(enqueuer.recorded()) == 1 }, time.Second, time.Millisecond)

		time.Sleep(30 * time.Millisecond)
		require.Zero(t, writer.count())
	})
}

func TestObserveCommitted_PanicIsRecovered(t *testing.T) {
	ctx := testhelper.Context(t)
	lister := &fakeLister{answers: map[[2]string][]git.ObjectID{{oidA, oidB}: {oidB}}}

	observer := NewObserver(ctx, testhelper.NewLogger(t), Options{Eager: true},
		Deps{Enqueuer: &fakeEnqueuer{explode: true}, ListNewCommits: lister.list})

	require.NotPanics(t, func() {
		observer.ObserveCommitted(ctx, testRepo, []changelog.Update{{Reference: "refs/heads/main", OldOID: oidA, NewOID: oidB}})
	})

	// Close waits for the listing, so a leaked panic would take the test down.
	observer.Close()
}

func TestObserveCommitted_ClosedObserverDoesNothing(t *testing.T) {
	ctx := testhelper.Context(t)
	enqueuer := &fakeEnqueuer{}
	writer := &fakeWriter{}
	lister := &fakeLister{}

	observer := NewObserver(ctx, testhelper.NewLogger(t),
		Options{Eager: true, CommitGraph: true, Debounce: 5 * time.Millisecond},
		Deps{Enqueuer: enqueuer, ListNewCommits: lister.list, WriteCommitGraph: writer.write})
	observer.Close()
	observer.Close()

	observer.ObserveCommitted(ctx, testRepo, []changelog.Update{{Reference: "refs/heads/main", OldOID: oidA, NewOID: oidB}})

	time.Sleep(20 * time.Millisecond)
	require.Empty(t, lister.listed())
	require.Empty(t, enqueuer.recorded())
	require.Zero(t, writer.count())
}

func TestObserveCommitted_NilObserver(t *testing.T) {
	ctx := testhelper.Context(t)

	var observer *Observer
	require.NotPanics(t, func() {
		observer.ObserveCommitted(ctx, testRepo, []changelog.Update{{Reference: "refs/heads/main", OldOID: oidA, NewOID: oidB}})
		observer.Close()
	})
}

// TestObserveCommitted_ListingsAreBounded commits many transactions at once
// while every listing blocks. Only ListWorkers listings may run at a time, the
// queue holds ListQueueSize transactions and the rest are dropped and counted,
// without ObserveCommitted ever blocking.
func TestObserveCommitted_ListingsAreBounded(t *testing.T) {
	ctx := testhelper.Context(t)
	enqueuer := &fakeEnqueuer{}

	const (
		workers      = 2
		queueSize    = 5
		transactions = 300
	)

	var running, maxRunning, listed atomic.Int32
	release := make(chan struct{})
	lister := func(ctx context.Context, _ storage.Repository, _, newOID string) ([]git.ObjectID, error) {
		now := running.Add(1)
		defer running.Add(-1)
		for {
			highest := maxRunning.Load()
			if now <= highest || maxRunning.CompareAndSwap(highest, now) {
				break
			}
		}

		select {
		case <-release:
		case <-ctx.Done():
			return nil, ctx.Err()
		}

		listed.Add(1)
		return []git.ObjectID{git.ObjectID(newOID)}, nil
	}

	observer := NewObserver(ctx, testhelper.NewLogger(t),
		Options{Eager: true, ListWorkers: workers, ListQueueSize: queueSize},
		Deps{Enqueuer: enqueuer, ListNewCommits: lister})
	defer observer.Close()

	for i := 0; i < transactions; i++ {
		observer.ObserveCommitted(ctx, testRepo, []changelog.Update{
			// The new OID is never zero, which would be a deletion that lists nothing.
			{Reference: fmt.Sprintf("refs/heads/b%d", i), OldOID: zeroOID, NewOID: fmt.Sprintf("%040d", i+1)},
		})
	}

	require.Eventually(t, func() bool { return running.Load() == workers }, 5*time.Second, time.Millisecond)
	time.Sleep(20 * time.Millisecond)
	require.Equal(t, int32(workers), maxRunning.Load(), "listings beyond the workers do not start")

	dropped := observer.droppedListings.Load()
	require.GreaterOrEqual(t, dropped, int64(transactions-workers-queueSize))
	require.LessOrEqual(t, dropped, int64(transactions-queueSize))

	testhelper.RequirePromMetrics(t, observer, fmt.Sprintf(`# HELP graft_eager_dropped_listings_total Number of committed reference transactions whose new commits were not listed for the eager derived-data warmers because the listing queue was full.
# TYPE graft_eager_dropped_listings_total counter
graft_eager_dropped_listings_total %d
`, dropped))

	close(release)

	accepted := transactions - int(dropped)
	require.Eventually(t, func() bool { return len(enqueuer.recorded()) == accepted }, 5*time.Second, time.Millisecond,
		"every accepted transaction is listed and enqueued")
	require.LessOrEqual(t, maxRunning.Load(), int32(workers))
	require.Equal(t, int32(accepted), listed.Load())
}

func TestObserveCommitted_CloseStopsBlockedListings(t *testing.T) {
	ctx := testhelper.Context(t)

	started := make(chan struct{}, 1)
	lister := func(ctx context.Context, _ storage.Repository, _, _ string) ([]git.ObjectID, error) {
		started <- struct{}{}
		<-ctx.Done()
		return nil, ctx.Err()
	}

	observer := NewObserver(ctx, testhelper.NewLogger(t),
		Options{Eager: true, ListWorkers: 1, ListQueueSize: 4},
		Deps{Enqueuer: &fakeEnqueuer{}, ListNewCommits: lister})

	for i := 0; i < 3; i++ {
		observer.ObserveCommitted(ctx, testRepo, []changelog.Update{
			{Reference: "refs/heads/main", OldOID: oidA, NewOID: oidB},
		})
	}
	<-started

	// Close cancels the running listing, drops the queued ones and returns.
	observer.Close()
	require.Len(t, started, 0, "no queued listing starts after Close")
}

func TestUpdatedTargets(t *testing.T) {
	require.Nil(t, updatedTargets(nil))
	require.Equal(t, []updateTarget{
		{reference: "refs/heads/a", oldOID: zeroOID, newOID: oidA},
		{reference: "refs/heads/b", oldOID: oidA, newOID: oidB},
		{reference: "refs/tags/v1", oldOID: zeroOID, newOID: oidA},
	}, updatedTargets([]changelog.Update{
		{Reference: "refs/heads/a", OldOID: zeroOID, NewOID: oidA},
		{Reference: "refs/heads/gone", OldOID: oidC, NewOID: zeroOID},
		{Reference: "refs/heads/a", OldOID: zeroOID, NewOID: oidA},
		{Reference: "refs/heads/b", OldOID: oidA, NewOID: oidB},
		{Reference: "refs/tags/v1", OldOID: zeroOID, NewOID: oidA},
	}))
}