Function TestLBClientRemoveClientsCallbackPanic

lbclient_test.go:71–122

TestLBClientRemoveClientsCallbackPanic ensures a panic in the user-supplied RemoveClients callback does not leak the write lock and deadlock later calls.

(t *testing.T)

// TestLBClientRemoveClientsCallbackPanic ensures a panic in the user-supplied
// RemoveClients callback does not leak the write lock and deadlock later calls.
func TestLBClientRemoveClientsCallbackPanic(t *testing.T) {
	t.Parallel()

	lbc := &LBClient{Clients: []BalancingClient{
		&mockBalancingClient{},
		&mockBalancingClient{},
		&mockBalancingClient{},
	}}

	// Trigger the lazy init so cc.cs is populated and the callback runs.
	var req Request
	var resp Response
	if err := lbc.DoDeadline(&req, &resp, time.Now().Add(time.Second)); err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	// Panic part way through so the old code would have already niled an
	// earlier cc.cs slot, leaving a hole that crashes later get() calls.
	calls := 0
	func() {
		defer func() {
			if recover() == nil {
				t.Fatal("expected panic from RemoveClients callback")
			}
		}()
		lbc.RemoveClients(func(BalancingClient) bool {
			calls++
			if calls == 2 {
				panic("boom")
			}
			return false
		})
	}()

	// If the lock leaked, AddClient would block forever.
	done := make(chan struct{})
	go func() {
		lbc.AddClient(&mockBalancingClient{})
		close(done)
	}()
	select {
	case <-done:
	case <-time.After(time.Second):
		t.Fatal("AddClient deadlocked after RemoveClients callback panicked")
	}

	// cc.cs must not be left with nil holes: a request still has to work
	// instead of panicking on a nil client.
	if err := lbc.DoDeadline(&req, &resp, time.Now().Add(time.Second)); err != nil {
		t.Fatalf("unexpected error after panicking RemoveClients: %v", err)
	}
}