engine_test.go

package lockd

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

	"github.com/imharjot/lockd/clock"
)

var epoch = time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC)

func newTestEngine(t *testing.T) (*Engine, *clock.Fake) {
	t.Helper()
	fc := clock.NewFake(epoch)
	e := New(Config{Shards: 4, Clock: fc, Tick: time.Second, WheelSlots: 64, ManualTick: true})
	t.Cleanup(e.Close)
	return e, fc
}

func TestAcquireRelease(t *testing.T) {
	e, _ := newTestEngine(t)
	ctx := context.Background()

	g, err := e.Acquire(ctx, "stone-1", "alice", 30*time.Second)
	if err != nil {
		t.Fatalf("acquire: %v", err)
	}
	if g.Holder != "alice" || g.Token == 0 {
		t.Fatalf("bad grant: %+v", g)
	}
	if err := e.Release("stone-1", "alice", g.Token); err != nil {
		t.Fatalf("release: %v", err)
	}
	// after release another holder can take it
	g2, err := e.Acquire(ctx, "stone-1", "bob", time.Minute)
	if err != nil {
		t.Fatalf("re-acquire: %v", err)
	}
	if g2.Token <= g.Token {
		t.Fatalf("token not monotonic: %d then %d", g.Token, g2.Token)
	}
}

func TestSecondAcquireQueuesUntilRelease(t *testing.T) {
	e, _ := newTestEngine(t)
	ctx := context.Background()

	g, err := e.Acquire(ctx, "stone-1", "alice", time.Minute)
	if err != nil {
		t.Fatal(err)
	}

	got := make(chan Grant, 1)
	go func() {
		bg, err := e.Acquire(ctx, "stone-1", "bob", time.Minute)
		if err == nil {
			got <- bg
		}
	}()

	// bob must not be served while alice holds it
	select {
	case <-got:
		t.Fatal("bob acquired while alice held the key")
	case <-time.After(50 * time.Millisecond):
	}

	if err := e.Release("stone-1", "alice", g.Token); err != nil {
		t.Fatal(err)
	}

	select {
	case bg := <-got:
		if bg.Holder != "bob" {
			t.Fatalf("served wrong holder: %+v", bg)
		}
	case <-time.After(time.Second):
		t.Fatal("bob never served after release")
	}
}

func TestExpiryFreesKey(t *testing.T) {
	e, fc := newTestEngine(t)
	ctx := context.Background()

	g, err := e.Acquire(ctx, "stone-1", "alice", 10*time.Second)
	if err != nil {
		t.Fatal(err)
	}
	_ = g

	// before expiry, bob is blocked
	if tok, held := e.Fence("stone-1"); !held || tok == 0 {
		t.Fatalf("expected held, got held=%v tok=%d", held, tok)
	}

	fc.Advance(10 * time.Second)
	e.Tick()

	if _, held := e.Fence("stone-1"); held {
		t.Fatal("key still held after expiry")
	}

	// bob can now acquire immediately
	bg, err := e.Acquire(ctx, "stone-1", "bob", 10*time.Second)
	if err != nil {
		t.Fatalf("acquire after expiry: %v", err)
	}
	if bg.Holder != "bob" {
		t.Fatalf("wrong holder: %+v", bg)
	}
}

func TestExpiryServesQueue(t *testing.T) {
	e, fc := newTestEngine(t)
	ctx := context.Background()

	if _, err := e.Acquire(ctx, "stone-1", "alice", 10*time.Second); err != nil {
		t.Fatal(err)
	}

	served := make(chan Grant, 1)
	go func() {
		bg, err := e.Acquire(ctx, "stone-1", "bob", 10*time.Second)
		if err == nil {
			served <- bg
		}
	}()
	time.Sleep(30 * time.Millisecond) // let bob queue

	fc.Advance(10 * time.Second)
	e.Tick()

	select {
	case bg := <-served:
		if bg.Holder != "bob" {
			t.Fatalf("wrong holder served: %+v", bg)
		}
	case <-time.After(time.Second):
		t.Fatal("queued waiter not served on expiry")
	}
}

func TestFifoOrdering(t *testing.T) {
	e, _ := newTestEngine(t)
	ctx := context.Background()

	g, err := e.Acquire(ctx, "stone-1", "holder0", time.Minute)
	if err != nil {
		t.Fatal(err)
	}

	const n = 5
	order := make(chan string, n)
	var ready sync.WaitGroup
	ready.Add(n)
	for i := 0; i < n; i++ {
		name := string(rune('A' + i))
		go func() {
			ready.Done()
			bg, err := e.Acquire(ctx, "stone-1", name, 10*time.Millisecond)
			if err != nil {
				return
			}
			order <- bg.Holder
			// release quickly so the next in line proceeds
			_ = e.Release("stone-1", name, bg.Token)
		}()
		// stagger so the queue order is deterministic
		time.Sleep(20 * time.Millisecond)
	}
	ready.Wait()

	if err := e.Release("stone-1", "holder0", g.Token); err != nil {
		t.Fatal(err)
	}

	got := make([]string, 0, n)
	for i := 0; i < n; i++ {
		select {
		case h := <-order:
			got = append(got, h)
		case <-time.After(2 * time.Second):
			t.Fatalf("only %d served: %v", len(got), got)
		}
	}
	want := []string{"A", "B", "C", "D", "E"}
	for i := range want {
		if got[i] != want[i] {
			t.Fatalf("fifo order = %v, want %v", got, want)
		}
	}
}

func TestContextCancelFreesQueueSlot(t *testing.T) {
	e, _ := newTestEngine(t)
	ctx := context.Background()

	g, err := e.Acquire(ctx, "stone-1", "alice", time.Minute)
	if err != nil {
		t.Fatal(err)
	}

	// bob queues with a cancellable context
	cctx, cancel := context.WithCancel(context.Background())
	bobErr := make(chan error, 1)
	go func() {
		_, err := e.Acquire(cctx, "stone-1", "bob", time.Minute)
		bobErr <- err
	}()
	time.Sleep(30 * time.Millisecond)

	// carol queues behind bob
	carol := make(chan Grant, 1)
	go func() {
		cg, err := e.Acquire(ctx, "stone-1", "carol", time.Minute)
		if err == nil {
			carol <- cg
		}
	}()
	time.Sleep(30 * time.Millisecond)

	// cancel bob: he should error out, carol should still be served next
	cancel()
	select {
	case err := <-bobErr:
		if !errors.Is(err, context.Canceled) {
			t.Fatalf("bob err = %v, want canceled", err)
		}
	case <-time.After(time.Second):
		t.Fatal("bob not released on cancel")
	}

	if err := e.Release("stone-1", "alice", g.Token); err != nil {
		t.Fatal(err)
	}

	select {
	case cg := <-carol:
		if cg.Holder != "carol" {
			t.Fatalf("wrong holder served: %+v", cg)
		}
	case <-time.After(time.Second):
		t.Fatal("carol not served after bob cancelled and alice released")
	}
}

func TestRenewExtendsAndFencing(t *testing.T) {
	e, fc := newTestEngine(t)
	ctx := context.Background()

	g, err := e.Acquire(ctx, "stone-1", "alice", 10*time.Second)
	if err != nil {
		t.Fatal(err)
	}

	fc.Advance(8 * time.Second)
	ng, err := e.Renew("stone-1", "alice", g.Token, 10*time.Second)
	if err != nil {
		t.Fatalf("renew: %v", err)
	}
	if !ng.ExpiresAt.After(g.ExpiresAt) {
		t.Fatalf("renew did not extend: %v vs %v", ng.ExpiresAt, g.ExpiresAt)
	}

	// wrong holder cannot renew
	if _, err := e.Renew("stone-1", "mallory", g.Token, time.Minute); !errors.Is(err, ErrWrongHolder) {
		t.Fatalf("renew wrong holder err = %v", err)
	}
}

func TestReleaseWrongTokenRejected(t *testing.T) {
	e, _ := newTestEngine(t)
	ctx := context.Background()
	g, err := e.Acquire(ctx, "stone-1", "alice", time.Minute)
	if err != nil {
		t.Fatal(err)
	}
	// stale token (one less) from a hypothetical earlier grant
	if g.Token > 1 {
		if err := e.Release("stone-1", "alice", g.Token-1); err == nil {
			t.Fatal("stale token release accepted")
		}
	}
	if err := e.Release("stone-1", "alice", g.Token); err != nil {
		t.Fatalf("valid release: %v", err)
	}
}

func TestFenceUnknownKey(t *testing.T) {
	e, _ := newTestEngine(t)
	if _, held := e.Fence("never-touched"); held {
		t.Fatal("unknown key reported held")
	}
}

func TestBadTTL(t *testing.T) {
	e, _ := newTestEngine(t)
	if _, err := e.Acquire(context.Background(), "k", "a", 0); !errors.Is(err, ErrBadTTL) {
		t.Fatalf("err = %v, want ErrBadTTL", err)
	}
}