use ginkgo

Signed-off-by: Ettore Di Giacinto <mudler@localai.io>

Author: mudler

core/http/endpoints/localai/nodes_test.go

@@ -3,49 +3,32 @@ package localai
 import (
 	"crypto/sha256"
 	"crypto/subtle"
-	"testing"
-)
 
-// TestTokenValidation verifies the token hashing and comparison logic
-// used in RegisterNodeEndpoint.
-func TestTokenValidation(t *testing.T) {
-	tests := []struct {
-		name          string
-		expectedToken string
-		providedToken string
-		wantMatch     bool
-	}{
-		{"matching tokens", "my-secret-token", "my-secret-token", true},
-		{"mismatched tokens", "my-secret-token", "wrong-token", false},
-		{"empty expected (no auth)", "", "any-token", true},
-		{"empty provided when expected set", "my-secret-token", "", false},
-	}
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
 
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			// Simulate the logic from RegisterNodeEndpoint
-			if tt.expectedToken == "" {
-				// No auth required — always matches
-				if !tt.wantMatch {
-					t.Error("expected no-auth to always pass")
-				}
-				return
-			}
+var _ = DescribeTable("token validation",
+	func(expectedToken, providedToken string, wantMatch bool) {
+		if expectedToken == "" {
+			// No auth required — always matches
+			Expect(wantMatch).To(BeTrue(), "no-auth should always pass")
+			return
+		}
 
-			if tt.providedToken == "" {
-				if tt.wantMatch {
-					t.Error("expected empty token to be rejected")
-				}
-				return
-			}
+		if providedToken == "" {
+			Expect(wantMatch).To(BeFalse(), "empty token should be rejected")
+			return
+		}
 
-			expectedHash := sha256.Sum256([]byte(tt.expectedToken))
-			providedHash := sha256.Sum256([]byte(tt.providedToken))
-			match := subtle.ConstantTimeCompare(expectedHash[:], providedHash[:]) == 1
+		expectedHash := sha256.Sum256([]byte(expectedToken))
+		providedHash := sha256.Sum256([]byte(providedToken))
+		match := subtle.ConstantTimeCompare(expectedHash[:], providedHash[:]) == 1
 
-			if match != tt.wantMatch {
-				t.Errorf("got match=%v, want %v", match, tt.wantMatch)
-			}
-		})
-	}
-}
+		Expect(match).To(Equal(wantMatch))
+	},
+	Entry("matching tokens", "my-secret-token", "my-secret-token", true),
+	Entry("mismatched tokens", "my-secret-token", "wrong-token", false),
+	Entry("empty expected (no auth)", "", "any-token", true),
+	Entry("empty provided when expected set", "my-secret-token", "", false),
+)

core/services/advisorylock/advisorylock_suite_test.go

@@ -0,0 +1,13 @@
+package advisorylock
+
+import (
+	"testing"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+func TestAdvisoryLock(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "AdvisoryLock test suite")
+}

core/services/advisorylock/advisorylock_test.go

@@ -4,9 +4,11 @@ import (
 	"context"
 	"sync"
 	"sync/atomic"
-	"testing"
 	"time"
 
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+
 	"github.com/mudler/LocalAI/core/services/messaging"
 
 	"github.com/testcontainers/testcontainers-go"
@@ -17,11 +19,8 @@ import (
 	"gorm.io/gorm/logger"
 )
 
-func setupTestDB(t *testing.T) *gorm.DB {
-	t.Helper()
-	t.Skip("requires docker")
-
-	ctx := t.Context()
+func setupTestDB() *gorm.DB {
+	ctx := context.Background()
 
 	pgC, err := tcpostgres.Run(ctx, "postgres:16",
 		tcpostgres.WithDatabase("testdb"),
@@ -30,132 +29,109 @@ func setupTestDB(t *testing.T) *gorm.DB {
 		testcontainers.WithWaitStrategyAndDeadline(60*time.Second,
 			wait.ForLog("database system is ready to accept connections").WithOccurrence(2)),
 	)
-	if err != nil {
-		t.Fatalf("start postgres container: %v", err)
-	}
-	t.Cleanup(func() { pgC.Terminate(context.Background()) })
+	Expect(err).ToNot(HaveOccurred())
+	DeferCleanup(func() { pgC.Terminate(context.Background()) })
 
 	connStr, err := pgC.ConnectionString(ctx, "sslmode=disable")
-	if err != nil {
-		t.Fatalf("connection string: %v", err)
-	}
+	Expect(err).ToNot(HaveOccurred())
 
 	db, err := gorm.Open(postgres.Open(connStr), &gorm.Config{
 		Logger: logger.Default.LogMode(logger.Silent),
 	})
-	if err != nil {
-		t.Fatalf("open gorm: %v", err)
-	}
+	Expect(err).ToNot(HaveOccurred())
 	return db
 }
 
-func TestWithLock_PreventsConcurrentExecution(t *testing.T) {
-	db := setupTestDB(t)
-
-	const lockKey int64 = 999
-
-	var (
-		mu          sync.Mutex
-		maxRunning  int32
-		running     int32
-		concurrency int32
-	)
-
-	var wg sync.WaitGroup
-	wg.Add(2)
-
-	for i := 0; i < 2; i++ {
-		go func() {
-			defer wg.Done()
-			err := WithLock(db, lockKey, func() error {
-				cur := atomic.AddInt32(&running, 1)
-				mu.Lock()
-				if cur > maxRunning {
-					maxRunning = cur
-				}
-				if cur > 1 {
-					atomic.AddInt32(&concurrency, 1)
-				}
-				mu.Unlock()
-
-				// Hold the lock briefly so the other goroutine has a chance to contend.
-				time.Sleep(50 * time.Millisecond)
-
-				atomic.AddInt32(&running, -1)
-				return nil
-			})
-			if err != nil {
-				t.Errorf("WithLock returned error: %v", err)
+var _ = Describe("AdvisoryLock", func() {
+	Context("PostgreSQL advisory locks", func() {
+		var db *gorm.DB
+
+		BeforeEach(func() {
+			db = setupTestDB()
+		})
+
+		It("prevents concurrent execution with WithLock", func() {
+			const lockKey int64 = 999
+
+			var (
+				mu          sync.Mutex
+				maxRunning  int32
+				running     int32
+				concurrency int32
+			)
+
+			var wg sync.WaitGroup
+			wg.Add(2)
+
+			for i := 0; i < 2; i++ {
+				go func() {
+					defer GinkgoRecover()
+					defer wg.Done()
+					err := WithLock(db, lockKey, func() error {
+						cur := atomic.AddInt32(&running, 1)
+						mu.Lock()
+						if cur > maxRunning {
+							maxRunning = cur
+						}
+						if cur > 1 {
+							atomic.AddInt32(&concurrency, 1)
+						}
+						mu.Unlock()
+
+						time.Sleep(50 * time.Millisecond)
+
+						atomic.AddInt32(&running, -1)
+						return nil
+					})
+					Expect(err).ToNot(HaveOccurred())
+				}()
 			}
-		}()
-	}
-
-	wg.Wait()
-
-	if maxRunning > 1 {
-		t.Errorf("expected max 1 goroutine inside lock at a time, observed %d", maxRunning)
-	}
-	if concurrency > 0 {
-		t.Errorf("detected concurrent execution inside advisory lock")
-	}
-}
-
-func TestTryLock_AcquiresAndUnlocks(t *testing.T) {
-	db := setupTestDB(t)
 
-	const lockKey int64 = 888
+			wg.Wait()
 
-	// NOTE: TryLock and Unlock may use different pool connections,
-	// so this test documents the API contract but may sometimes pass
-	// even when the implementation has a connection-affinity bug.
-	acquired := TryLock(db, lockKey)
-	if !acquired {
-		t.Fatal("expected TryLock to acquire the lock")
-	}
+			Expect(maxRunning).To(BeNumerically("<=", 1), "expected max 1 goroutine inside lock at a time")
+			Expect(concurrency).To(BeZero(), "detected concurrent execution inside advisory lock")
+		})
 
-	Unlock(db, lockKey)
+		It("acquires and unlocks with TryLock", func() {
+			const lockKey int64 = 888
 
-	reacquired := TryLock(db, lockKey)
-	if !reacquired {
-		t.Error("expected TryLock to re-acquire the lock after Unlock")
-	}
+			acquired := TryLock(db, lockKey)
+			Expect(acquired).To(BeTrue(), "expected TryLock to acquire the lock")
 
-	// Clean up
-	Unlock(db, lockKey)
-}
+			Unlock(db, lockKey)
 
-func TestKeyFromUUID_Deterministic(t *testing.T) {
-	a := [16]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}
-	b := [16]byte{16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1}
+			reacquired := TryLock(db, lockKey)
+			Expect(reacquired).To(BeTrue(), "expected TryLock to re-acquire the lock after Unlock")
 
-	keyA1 := KeyFromUUID(a)
-	keyA2 := KeyFromUUID(a)
-	keyB := KeyFromUUID(b)
+			Unlock(db, lockKey)
+		})
+	})
 
-	if keyA1 != keyA2 {
-		t.Errorf("KeyFromUUID not deterministic: got %d and %d for same input", keyA1, keyA2)
-	}
-	if keyA1 == keyB {
-		t.Errorf("KeyFromUUID returned same key %d for different inputs", keyA1)
-	}
-}
+	Context("pure logic", func() {
+		It("KeyFromUUID is deterministic", func() {
+			a := [16]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}
+			b := [16]byte{16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1}
+
+			keyA1 := KeyFromUUID(a)
+			keyA2 := KeyFromUUID(a)
+			keyB := KeyFromUUID(b)
+
+			Expect(keyA1).To(Equal(keyA2), "KeyFromUUID not deterministic")
+			Expect(keyA1).ToNot(Equal(keyB), "KeyFromUUID returned same key for different inputs")
+		})
+
+		It("all advisory lock keys are unique", func() {
+			keys := map[int64]string{
+				messaging.AdvisoryLockCronScheduler:    "messaging.AdvisoryLockCronScheduler",
+				messaging.AdvisoryLockStaleNodeCleanup: "messaging.AdvisoryLockStaleNodeCleanup",
+				messaging.AdvisoryLockGalleryDedup:     "messaging.AdvisoryLockGalleryDedup",
+				messaging.AdvisoryLockAgentScheduler:   "messaging.AdvisoryLockAgentScheduler",
+				messaging.AdvisoryLockHealthCheck:      "messaging.AdvisoryLockHealthCheck",
+				messaging.AdvisoryLockSchemaMigrate:    "messaging.AdvisoryLockSchemaMigrate",
+			}
 
-func TestAllLockKeysUnique(t *testing.T) {
-	// Collect all advisory lock keys from both the advisorylock package
-	// and the messaging package. They share the same PostgreSQL lock
-	// namespace so every key must be unique.
-	keys := map[int64]string{
-		messaging.AdvisoryLockCronScheduler:    "messaging.AdvisoryLockCronScheduler",
-		messaging.AdvisoryLockStaleNodeCleanup: "messaging.AdvisoryLockStaleNodeCleanup",
-		messaging.AdvisoryLockGalleryDedup:     "messaging.AdvisoryLockGalleryDedup",
-		messaging.AdvisoryLockAgentScheduler:   "messaging.AdvisoryLockAgentScheduler",
-		messaging.AdvisoryLockHealthCheck:      "messaging.AdvisoryLockHealthCheck",
-		messaging.AdvisoryLockSchemaMigrate:    "messaging.AdvisoryLockSchemaMigrate",
-	}
-
-	// If any keys collide, the map will have fewer entries than expected.
-	expectedCount := 6
-	if len(keys) != expectedCount {
-		t.Errorf("expected %d unique advisory lock keys, got %d — some keys have the same value", expectedCount, len(keys))
-	}
-}
+			Expect(keys).To(HaveLen(6), "some advisory lock keys have the same value")
+		})
+	})
+})

core/services/agents/agents_suite_test.go

@@ -0,0 +1,13 @@
+package agents
+
+import (
+	"testing"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+func TestAgents(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Agents test suite")
+}