compact test version

Signed-off-by: Swati Gupta <[email protected]>

Author: guptaNswati

pkg/workqueue/workqueue_test.go

@@ -22,66 +22,75 @@ import (
 	"testing"
 	"time"
 
+	"github.com/stretchr/testify/require"
 	"k8s.io/apimachinery/pkg/runtime"
 )
 
 func TestEnqueue(t *testing.T) {
 	// Create a WorkQueue using the default rate limiter.
 	defaultRateLimiter := DefaultControllerRateLimiter()
 	wq := New(defaultRateLimiter)
-	if wq == nil || wq.queue == nil {
-		t.Fatal("Failed to create valid WorkQueue")
+	require.NotNil(t, wq)
+	require.NotNil(t, wq.queue)
+
+	tests := []struct {
+		name   string
+		obj    any
+		called *int32
+	}{
+		{
+			name:   "EnqueueRaw",
+			obj:    "AnyObject",
+			called: new(int32),
+		},
+		{
+			name:   "EnqueueValid",
+			obj:    &runtime.Unknown{},
+			called: new(int32),
+		},
+		{
+			name: "EnqueueInvalid",
+			obj:  "NotRuntimeObject",
+		},
+		{
+			name: "NilCallback",
+			obj:  &runtime.Unknown{},
+		},
 	}
 
 	// Create a context with timeout for processing.
 	// use DefaultTypedControllerRateLimiter Base delay: 5ms
 	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Millisecond)
 	defer cancel()
 
-	// Test EnqueueRaw
-	t.Run("EnqueueRaw", func(t *testing.T) {
-		var called int32
-		callback := func(ctx context.Context, obj any) error {
-			atomic.StoreInt32(&called, 1)
-			return nil
-		}
-		wq.EnqueueRaw("AnyObject", callback)
-		wq.processNextWorkItem(ctx)
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var callback func(context.Context, any) error
+			switch tt.name {
+			case "EnqueueRaw":
+				callback = func(ctx context.Context, obj any) error {
+					atomic.StoreInt32(tt.called, 1)
+					return nil
+				}
+			case "EnqueueValid":
+				callback = func(ctx context.Context, obj any) error {
+					if _, ok := obj.(runtime.Object); !ok {
+						t.Errorf("Expected runtime.Object, got %T", obj)
+					}
+					atomic.StoreInt32(tt.called, 1)
+					return nil
+				}
+			default:
+				callback = nil
 
-		if atomic.LoadInt32(&called) != 1 {
-			t.Error("EnqueueRaw callback was not invoked")
-		}
-	})
-	// Test Enqueue with valid and invalid runtime.Object and  nill callback
-	// TODO: Implement a proper claim spec that needs to be processed
-	t.Run("EnqueueValid", func(t *testing.T) {
-		var called int32
-		callback := func(ctx context.Context, obj any) error {
-			_, ok := obj.(runtime.Object)
-			if !ok {
-				t.Errorf("Expected runtime.Object, got %T", obj)
+				wq.Enqueue(tt.obj, callback)
+				if tt.name != "EnqueueInvalid" {
+					wq.processNextWorkItem(ctx)
+				}
+				if tt.called != nil && atomic.LoadInt32(tt.called) != 1 {
+					t.Error("Callback was not invoked")
+				}
 			}
-			atomic.StoreInt32(&called, 1)
-			return nil
-		}
-		validObj := &runtime.Unknown{}
-		wq.Enqueue(validObj, callback)
-		wq.processNextWorkItem(ctx)
-
-		if atomic.LoadInt32(&called) != 1 {
-			t.Error("Enqueue callback was not invoked")
-		}
-	})
-
-	t.Run("EnqueueInvalid", func(t *testing.T) {
-		callback := func(ctx context.Context, obj any) error { return nil }
-		wq.Enqueue("NotRuntimeObject", callback)
-	})
-
-	t.Run("NilCallback", func(t *testing.T) {
-		validObj := &runtime.Unknown{}
-		wq.Enqueue(validObj, nil)
-		wq.processNextWorkItem(ctx)
-	})
-
+		})
+	}
 }