test: nil target and validation tests for lb policy

Author: elijah-rou

pkg/activator/net/lb_policy_test.go

@@ -260,6 +260,269 @@ func TestRoundRobin(t *testing.T) {
 	})
 }
 
+func TestLeastConnectionsPolicy(t *testing.T) {
+	t.Run("empty trackers", func(t *testing.T) {
+		cb, pt := leastConnectionsPolicy(context.Background(), []*podTracker{})
+		defer cb()
+		if pt != nil {
+			t.Fatal("Expected nil tracker for empty input")
+		}
+	})
+
+	t.Run("single tracker", func(t *testing.T) {
+		podTrackers := makeTrackers(1, 1)
+		cb, pt := leastConnectionsPolicy(context.Background(), podTrackers)
+		defer cb()
+		if pt == nil {
+			t.Fatal("Expected non-nil tracker")
+		}
+		if got, want := pt.dest, podTrackers[0].dest; got != want {
+			t.Errorf("pt.dest = %s, want: %s", got, want)
+		}
+	})
+
+	t.Run("multiple trackers with different loads", func(t *testing.T) {
+		podTrackers := makeTrackers(3, 2)
+		// Simulate different loads
+		podTrackers[0].weight.Store(5)
+		podTrackers[1].weight.Store(2)
+		podTrackers[2].weight.Store(8)
+
+		cb, pt := leastConnectionsPolicy(context.Background(), podTrackers)
+		defer cb()
+		if pt == nil {
+			t.Fatal("Expected non-nil tracker")
+		}
+		// Should pick the one with lowest weight (index 1)
+		if got, want := pt.dest, podTrackers[1].dest; got != want {
+			t.Errorf("pt.dest = %s, want: %s (should pick lowest load)", got, want)
+		}
+	})
+
+	t.Run("nil trackers in list", func(t *testing.T) {
+		podTrackers := []*podTracker{
+			nil,
+			{
+				dest: "tracker-1",
+				b: queue.NewBreaker(queue.BreakerParams{
+					QueueDepth:      1,
+					MaxConcurrency:  1,
+					InitialCapacity: 1,
+				}),
+			},
+			nil,
+		}
+		cb, pt := leastConnectionsPolicy(context.Background(), podTrackers)
+		defer cb()
+		if pt == nil {
+			t.Fatal("Expected non-nil tracker")
+		}
+		if got, want := pt.dest, "tracker-1"; got != want {
+			t.Errorf("pt.dest = %s, want: %s", got, want)
+		}
+	})
+
+	t.Run("all nil trackers", func(t *testing.T) {
+		podTrackers := []*podTracker{nil, nil, nil}
+		cb, pt := leastConnectionsPolicy(context.Background(), podTrackers)
+		defer cb()
+		if pt != nil {
+			t.Fatal("Expected nil tracker when all trackers are nil")
+		}
+	})
+
+	t.Run("negative weight handling", func(t *testing.T) {
+		podTrackers := makeTrackers(2, 1)
+		podTrackers[0].weight.Store(-5)
+		podTrackers[1].weight.Store(3)
+
+		cb, pt := leastConnectionsPolicy(context.Background(), podTrackers)
+		defer cb()
+		if pt == nil {
+			t.Fatal("Expected non-nil tracker")
+		}
+		// Negative weight should be treated as 0, so should pick first tracker
+		if got, want := pt.dest, podTrackers[0].dest; got != want {
+			t.Errorf("pt.dest = %s, want: %s (negative weight should be treated as 0)", got, want)
+		}
+	})
+}
+
+func TestRandomLBPolicyWithNilTrackers(t *testing.T) {
+	t.Run("empty trackers", func(t *testing.T) {
+		cb, pt := randomLBPolicy(context.Background(), []*podTracker{})
+		defer cb()
+		if pt != nil {
+			t.Fatal("Expected nil tracker for empty input")
+		}
+	})
+
+	t.Run("all nil trackers", func(t *testing.T) {
+		podTrackers := []*podTracker{nil, nil, nil}
+		cb, pt := randomLBPolicy(context.Background(), podTrackers)
+		defer cb()
+		if pt != nil {
+			t.Fatal("Expected nil tracker when all trackers are nil")
+		}
+	})
+
+	t.Run("mixed nil and valid trackers", func(t *testing.T) {
+		podTrackers := makeTrackers(3, 0)
+		// Set middle one to nil
+		podTrackers[1] = nil
+		
+		// Run multiple times to ensure we don't get nil
+		for i := 0; i < 10; i++ {
+			cb, pt := randomLBPolicy(context.Background(), podTrackers)
+			defer cb()
+			if pt == nil {
+				t.Fatal("Should not return nil when valid trackers exist")
+			}
+			if pt.dest != podTrackers[0].dest && pt.dest != podTrackers[2].dest {
+				t.Fatal("Should return one of the valid trackers")
+			}
+		}
+	})
+}
+
+func TestRandomChoice2PolicyWithNilTrackers(t *testing.T) {
+	t.Run("single nil tracker", func(t *testing.T) {
+		podTrackers := []*podTracker{nil}
+		cb, pt := randomChoice2Policy(context.Background(), podTrackers)
+		defer cb()
+		if pt != nil {
+			t.Fatal("Expected nil tracker when single tracker is nil")
+		}
+	})
+
+	t.Run("all nil trackers", func(t *testing.T) {
+		podTrackers := []*podTracker{nil, nil, nil}
+		cb, pt := randomChoice2Policy(context.Background(), podTrackers)
+		defer cb()
+		if pt != nil {
+			t.Fatal("Expected nil tracker when all trackers are nil")
+		}
+	})
+
+	t.Run("mixed nil and valid trackers", func(t *testing.T) {
+		podTrackers := makeTrackers(4, 0)
+		// Set some to nil
+		podTrackers[1] = nil
+		podTrackers[3] = nil
+		
+		// Run multiple times to check behavior
+		foundNonNil := false
+		for i := 0; i < 20; i++ {
+			cb, pt := randomChoice2Policy(context.Background(), podTrackers)
+			defer cb()
+			if pt != nil {
+				foundNonNil = true
+				if pt.dest != podTrackers[0].dest && pt.dest != podTrackers[2].dest {
+					t.Fatal("Should return one of the valid trackers")
+				}
+			}
+		}
+		if !foundNonNil {
+			t.Fatal("Should find at least one non-nil tracker in multiple attempts")
+		}
+	})
+
+	t.Run("mostly nil trackers", func(t *testing.T) {
+		// Create a large array with mostly nils
+		podTrackers := make([]*podTracker, 10)
+		// Create a proper tracker with initialized fields
+		validTracker := &podTracker{
+			dest: "valid-tracker",
+		}
+		// Initialize the weight field properly
+		validTracker.weight.Store(0)
+		podTrackers[0] = validTracker
+		
+		// Run multiple times - should eventually find the valid tracker
+		foundValid := false
+		for i := 0; i < 100; i++ {
+			cb, pt := randomChoice2Policy(context.Background(), podTrackers)
+			if cb != nil {
+				defer cb()
+			}
+			if pt != nil && pt.dest == "valid-tracker" {
+				foundValid = true
+				break
+			}
+		}
+		if !foundValid {
+			t.Fatal("Should eventually find the valid tracker")
+		}
+	})
+}
+
+func TestFirstAvailableWithNilTrackers(t *testing.T) {
+	t.Run("nil trackers in list", func(t *testing.T) {
+		podTrackers := []*podTracker{
+			nil,
+			{
+				dest: "tracker-1",
+				b: queue.NewBreaker(queue.BreakerParams{
+					QueueDepth:      1,
+					MaxConcurrency:  1,
+					InitialCapacity: 1,
+				}),
+			},
+			nil,
+		}
+		cb, pt := firstAvailableLBPolicy(context.Background(), podTrackers)
+		defer cb()
+		if pt == nil {
+			t.Fatal("Expected non-nil tracker")
+		}
+		if got, want := pt.dest, "tracker-1"; got != want {
+			t.Errorf("pt.dest = %s, want: %s", got, want)
+		}
+	})
+
+	t.Run("all nil trackers", func(t *testing.T) {
+		podTrackers := []*podTracker{nil, nil, nil}
+		cb, pt := firstAvailableLBPolicy(context.Background(), podTrackers)
+		defer cb()
+		if pt != nil {
+			t.Fatal("Expected nil tracker when all trackers are nil")
+		}
+	})
+}
+
+func TestRoundRobinWithNilTrackers(t *testing.T) {
+	t.Run("nil trackers in list", func(t *testing.T) {
+		rrp := newRoundRobinPolicy()
+		podTrackers := makeTrackers(3, 1)
+		// Set middle tracker to nil
+		podTrackers[1] = nil
+		
+		cb, pt := rrp(context.Background(), podTrackers)
+		t.Cleanup(cb)
+		if got, want := pt, podTrackers[0]; got != want {
+			t.Fatalf("Tracker = %v, want: %v", got, want)
+		}
+		
+		// Should skip nil tracker and go to next valid one
+		cb, pt = rrp(context.Background(), podTrackers)
+		t.Cleanup(cb)
+		if got, want := pt, podTrackers[2]; got != want {
+			t.Fatalf("Tracker = %v, want: %v (should skip nil tracker)", got, want)
+		}
+	})
+
+	t.Run("all nil trackers", func(t *testing.T) {
+		rrp := newRoundRobinPolicy()
+		podTrackers := []*podTracker{nil, nil, nil}
+		
+		cb, pt := rrp(context.Background(), podTrackers)
+		defer cb()
+		if pt != nil {
+			t.Fatal("Expected nil tracker when all trackers are nil")
+		}
+	})
+}
+
 func BenchmarkPolicy(b *testing.B) {
 	for _, test := range []struct {
 		name   string
@@ -276,6 +539,9 @@ func BenchmarkPolicy(b *testing.B) {
 	}, {
 		name:   "round-robin",
 		policy: newRoundRobinPolicy(),
+	}, {
+		name:   "least-connections",
+		policy: leastConnectionsPolicy,
 	}} {
 		for _, n := range []int{1, 2, 3, 10, 100} {
 			b.Run(fmt.Sprintf("%s-%d-trackers-sequential", test.name, n), func(b *testing.B) {