Skip to content

Git designed for AI agents.

8.6 KB
Raw Blame
package datastore

import (
	"sync"
	"testing"
	"time"

	"github.com/feder-cr/git-ai/internal/testhelper"
	"github.com/feder-cr/git-ai/internal/testhelper/testdb"
	"github.com/stretchr/testify/require"
)

func TestRepositoryReferenceWriteLock(t *testing.T) {
	t.Parallel()

	db := testdb.New(t)
	dbConfig := testdb.GetConfig(t, db.Name)
	logger := testhelper.NewLogger(t)
	ctx := testhelper.Context(t)

	// waitForListener is needed when a test relies on the listener actually
	// receiving a NOTIFY. Without waiting, the test is flaky since we can't
	// guarantee the notification channel is ready to listen before a NOTIFY fires.
	//
	// Call this after creating a new RepoReferenceWriteLockManager.
	// Not all tests need it, but it is provided to avoid unexpected flakiness.
	waitForListener := func(ready <-chan struct{}) {
		t.Helper()
		select {
		case <-ready:
		case <-time.After(5 * time.Second):
			t.Fatal("listener never connected")
		}
	}

	// t.Run subtests use different relative paths so they can run in parallel
	// without conflicting on the same lock_id.
	t.Run("txn acquires lock successfully", func(t *testing.T) {
		t.Parallel()
		mgr := NewRepoReferenceWriteLockManager(ctx, db, dbConfig, logger)
		waitForListener(mgr.handler.ready)

		lock, err := mgr.Lock(ctx, "default", "repo/acquire.git", 1)
		require.NoError(t, err)
		require.NotNil(t, lock.Unlock)
		require.NotNil(t, lock.Renew)

		require.NoError(t, lock.Unlock())
	})

	t.Run("callers with same txn id acquires lock successfully", func(t *testing.T) {
		t.Parallel()
		mgr := NewRepoReferenceWriteLockManager(ctx, db, dbConfig, logger)
		waitForListener(mgr.handler.ready)

		wg := &sync.WaitGroup{}
		callerNum := 3
		unlockCalls := make([]func() error, callerNum)
		wg.Add(callerNum)
		for i := 0; i < callerNum; i++ {
			go func(j int) {
				defer wg.Done()
				lock, err := mgr.Lock(ctx, "default", "acquire-reentrant.git", 1)
				require.NoError(t, err)
				require.NotNil(t, lock.Unlock)
				require.NotNil(t, lock.Renew)
				unlockCalls[j] = lock.Unlock
			}(i)
		}
		wg.Wait()
		for _, unlock := range unlockCalls {
			require.NoError(t, unlock())
		}
	})

	t.Run("first txn release lock and second txn acquires it lock afterward", func(t *testing.T) {
		t.Parallel()
		mgr := NewRepoReferenceWriteLockManager(ctx, db, dbConfig, logger)
		waitForListener(mgr.handler.ready)

		storageName := "default"
		relativePath := "repo/repo/release_and_acquire.git"
		lock1, err1 := mgr.Lock(ctx, storageName, relativePath, 1)
		require.NoError(t, err1)
		require.NotNil(t, lock1.Unlock)
		require.NotNil(t, lock1.Renew)

		go func() {
			// The first caller releases the lock after 1s
			<-time.After(1 * time.Second)
			require.NoError(t, lock1.Unlock())
		}()

		// The second should block here and eventually have the lock after it is released
		lock2, err2 := mgr.Lock(ctx, storageName, relativePath, 2)
		require.NoError(t, err2)
		require.NotNil(t, lock2.Unlock)
		require.NotNil(t, lock2.Renew)
		require.NoError(t, lock2.Unlock())
	})

	t.Run("second txn fails to acquire held lock and receives notification channel", func(t *testing.T) {
		t.Parallel()
		mgr := NewRepoReferenceWriteLockManager(ctx, db, dbConfig, logger)
		waitForListener(mgr.handler.ready)

		res1 := mgr.tryLock(ctx, "default", "repo/contend.git", 1)
		require.NoError(t, res1.Err)
		require.True(t, res1.Acquired)
		require.NotNil(t, res1.Unlock)
		require.NotNil(t, res1.Renew)
		require.Nil(t, res1.NotificationCh)
		require.Nil(t, res1.Deregister)

		res2 := mgr.tryLock(ctx, "default", "repo/contend.git", 2)
		require.NoError(t, res2.Err)
		require.False(t, res2.Acquired)
		require.Nil(t, res2.Unlock)
		require.Nil(t, res2.Renew)
		require.NotNil(t, res2.NotificationCh)
		require.NotNil(t, res2.Deregister)
		defer res2.Deregister()

		require.NoError(t, res1.Unlock())
	})

	t.Run("txn2 notification channel is closed when txn1 releases the lock", func(t *testing.T) {
		t.Parallel()
		mgr := NewRepoReferenceWriteLockManager(ctx, db, dbConfig, logger)
		// This test requires waitForListener to guarantee the listener is ready.
		waitForListener(mgr.handler.ready)
		res1 := mgr.tryLock(ctx, "default", "repo/notify.git", 1)
		require.NoError(t, res1.Err)
		require.True(t, res1.Acquired)

		res2 := mgr.tryLock(ctx, "default", "repo/notify.git", 2)
		require.NoError(t, res2.Err)
		require.False(t, res2.Acquired)
		require.NotNil(t, res2.NotificationCh)
		require.NotNil(t, res2.Deregister)
		defer res2.Deregister()

		require.NoError(t, res1.Unlock())

		// The listener goroutine needs to connect and receive the NOTIFY from the
		// DELETE trigger. Use Eventually to handle the async delivery.
		require.Eventually(t, func() bool {
			select {
			case <-res2.NotificationCh:
				return true
			default:
				return false
			}
		}, 5*time.Second, 50*time.Millisecond, "timed out waiting for lock release notification")
	})

	t.Run("txn2 can steal an expired lock", func(t *testing.T) {
		t.Parallel()
		mgr := NewRepoReferenceWriteLockManager(ctx, db, dbConfig, logger)
		waitForListener(mgr.handler.ready)

		_, err1 := mgr.Lock(ctx, "default", "repo/expire.git", 1)
		require.NoError(t, err1)

		// Simulate expiry by back-dating the lock directly in the DB.
		_, err := db.ExecContext(ctx, `
			UPDATE repository_reference_write_locks
			SET expired_at = NOW() - INTERVAL '1 second'
			WHERE lock_id = 'default|repo/expire.git'`)
		require.NoError(t, err)

		lock2, err2 := mgr.Lock(ctx, "default", "repo/expire.git", 2)
		require.NoError(t, err2)
		require.NoError(t, lock2.Unlock())
	})

	t.Run("renew extends lock and prevents acquisition by another txn", func(t *testing.T) {
		t.Parallel()
		mgr := NewRepoReferenceWriteLockManager(ctx, db, dbConfig, logger)
		waitForListener(mgr.handler.ready)

		res1 := mgr.tryLock(ctx, "default", "repo/renew.git", 1)
		require.NoError(t, res1.Err)
		require.NoError(t, res1.Renew(ctx))
		defer func() {
			require.NoError(t, res1.Unlock())
		}()

		// After renewal the lock is still held; txn2 must not acquire it.
		res2 := mgr.tryLock(ctx, "default", "repo/renew.git", 2)
		require.NoError(t, res2.Err)
		require.False(t, res2.Acquired)
		require.NotNil(t, res2.NotificationCh)
		require.NotNil(t, res2.Deregister)
		defer res2.Deregister()
	})

	t.Run("deregister removes the waiter from the dispatcher", func(t *testing.T) {
		t.Parallel()
		mgr := NewRepoReferenceWriteLockManager(ctx, db, dbConfig, logger)
		waitForListener(mgr.handler.ready)

		res1 := mgr.tryLock(ctx, "default", "repo/deregister.git", 1)
		require.NoError(t, res1.Err)
		require.True(t, res1.Acquired)
		defer func() {
			require.NoError(t, res1.Unlock())
		}()

		res2 := mgr.tryLock(ctx, "default", "repo/deregister.git", 2)
		require.NoError(t, res2.Err)
		require.NotNil(t, res2.Deregister)
		res2.Deregister()

		mgr.handler.mu.Lock()
		waiters := mgr.handler.waiters["default|repo/deregister.git"]
		mgr.handler.mu.Unlock()
		require.Empty(t, waiters)
	})

	t.Run("locks on different repos are independent", func(t *testing.T) {
		t.Parallel()
		mgr := NewRepoReferenceWriteLockManager(ctx, db, dbConfig, logger)
		waitForListener(mgr.handler.ready)

		lock1, err1 := mgr.Lock(ctx, "default", "repo/independent-a.git", 1)
		require.NoError(t, err1)
		defer func() {
			require.NoError(t, lock1.Unlock())
		}()

		// A different repo must be lockable even while the first is held.
		lock2, err2 := mgr.Lock(ctx, "default", "repo/independent-b.git", 2)
		require.NoError(t, err2)
		defer func() {
			require.NoError(t, lock2.Unlock())
		}()
	})

	t.Run("cleanup removes expired locks from the database", func(t *testing.T) {
		t.Parallel()

		_, err := db.ExecContext(ctx, `
			INSERT INTO repository_reference_write_locks (lock_id, holder_txn_id, expired_at)
			VALUES ('default|repo/cleanup-expired.git', 99, NOW() - INTERVAL '1 hour')`)
		require.NoError(t, err)

		cleanUpExpiredRepoRefWriteLocks(ctx, db, logger)

		var count int
		require.NoError(t, db.QueryRowContext(ctx, `
			SELECT COUNT(*) FROM repository_reference_write_locks
			WHERE lock_id = 'default|repo/cleanup-expired.git'`).Scan(&count))
		require.Equal(t, 0, count)
	})

	t.Run("cleanup does not remove locks that have not expired", func(t *testing.T) {
		t.Parallel()
		mgr := NewRepoReferenceWriteLockManager(ctx, db, dbConfig, logger)
		waitForListener(mgr.handler.ready)

		res := mgr.tryLock(ctx, "default", "repo/cleanup-active.git", 1)
		require.NoError(t, res.Err)
		defer func() {
			require.NoError(t, res.Unlock())
		}()

		cleanUpExpiredRepoRefWriteLocks(ctx, db, logger)

		var count int
		require.NoError(t, db.QueryRowContext(ctx, `
			SELECT COUNT(*) FROM repository_reference_write_locks
			WHERE lock_id = 'default|repo/cleanup-active.git'`).Scan(&count))
		require.Equal(t, 1, count)
	})
}