waitinline_test.go

package waitinline

import (
	"context"
	"sync"
	"testing"
	"time"
)

func TestBasicLockUnlock(t *testing.T) {
	lock := New(10)
	defer lock.Close()

	ctx := context.Background()
	h, err := lock.Lock(ctx)
	if err != nil {
		t.Fatalf("unexpected error acquiring lock: %v", err)
	}

	if err := h.Unlock(); err != nil {
		t.Fatalf("unexpected error unlocking: %v", err)
	}
}

func TestFairness(t *testing.T) {
	lock := New(10)
	defer lock.Close()
	wg := sync.WaitGroup{}
	order := []int{}
	for i := range 10 {
		wg.Add(1)
		go func(index int) {
			defer wg.Done()
			ticket, err := lock.Lock(context.Background())
			if err != nil {
				t.Errorf("lock failed: %v", err)
			}
			t.Logf("Ticket: %v", ticket)
			defer ticket.Unlock()
			order = append(order, index)
		}(i)
		time.Sleep(time.Millisecond * 100)
	}

	wg.Wait()
	for i := 1; i < len(order); i++ {
		if order[i-1] > order[i] {
			t.Fatalf("lock acquisition not in FIFO order: %v", order)
		}
	}
}

func TestContextCancellation(t *testing.T) {
	lock := New(1)
	defer lock.Close()

	ctx := context.Background()
	h1, err := lock.Lock(ctx)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	ctx2, cancel := context.WithTimeout(context.Background(), 10*time.Millisecond)
	defer cancel()

	_, err = lock.Lock(ctx2)
	if err != ErrContextCancelled {
		t.Fatalf("expected context cancelled error, got: %v", err)
	}

	if err := h1.Unlock(); err != nil {
		t.Fatalf("unexpected unlock error: %v", err)
	}
}

func TestClosePreventsLocking(t *testing.T) {
	lock := New(1)
	lock.Close()

	ctx := context.Background()
	_, err := lock.Lock(ctx)
	if err != ErrQueueClosed {
		t.Fatalf("expected ErrQueueClosed, got: %v", err)
	}
}

func TestUnlockAfterClose(t *testing.T) {
	lock := New(1)
	ctx := context.Background()
	h, err := lock.Lock(ctx)
	if err != nil {
		t.Fatalf("unexpected error acquiring lock: %v", err)
	}

	lock.Close()
	err = h.Unlock()
	if err != ErrQueueClosed {
		t.Fatalf("expected ErrQueueClosed on unlock after close, got: %v", err)
	}
}