Method TestPickerRandomHash

balancer/ringhash/picker_test.go:250–311

(t *testing.T)

}

func (s) TestPickerRandomHash(t *testing.T) {
	tests := []struct {
		name                         string
		hash                         uint64
		connectivityStates           []connectivity.State
		wantSC                       balancer.SubConn
		wantErr                      error
		wantSCToConnect              balancer.SubConn
		hasEndpointInConnectingState bool
	}{
		{
			name:               "header not set, picked is Ready",
			connectivityStates: []connectivity.State{connectivity.Ready, connectivity.Idle},
			wantSC:             testSubConns[0],
		},
		{
			name:               "header not set, picked is Idle, another is Ready. Connect and pick Ready",
			connectivityStates: []connectivity.State{connectivity.Idle, connectivity.Ready},
			wantSC:             testSubConns[1],
			wantSCToConnect:    testSubConns[0],
		},
		{
			name:                         "header not set, picked is Idle, there is at least one Connecting",
			connectivityStates:           []connectivity.State{connectivity.Connecting, connectivity.Idle},
			wantErr:                      balancer.ErrNoSubConnAvailable,
			hasEndpointInConnectingState: true,
		},
		{
			name:               "header not set, all Idle or TransientFailure, connect",
			connectivityStates: []connectivity.State{connectivity.TransientFailure, connectivity.Idle},
			wantErr:            balancer.ErrNoSubConnAvailable,
			wantSCToConnect:    testSubConns[1],
		},
	}
	ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout)
	defer cancel()
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			ring, epStates := testRingAndEndpointStates(tt.connectivityStates)
			p := &picker{
				ring:                         ring,
				endpointStates:               epStates,
				requestHashHeader:            "some-header",
				hasEndpointInConnectingState: tt.hasEndpointInConnectingState,
				randUint64:                   func() uint64 { return 0 }, // always return the first endpoint on the ring.
			}
			if got, err := p.Pick(balancer.PickInfo{Ctx: ctx}); err != tt.wantErr {
				t.Errorf("Pick() error = %v, wantErr %v", err, tt.wantErr)
				return
			} else if got.SubConn != tt.wantSC {
				t.Errorf("Pick() got = %v, want picked SubConn: %v", got, tt.wantSC)
			}
			if sc := tt.wantSCToConnect; sc != nil {
				select {
				case <-sc.(*testutils.TestSubConn).ConnectCh:
				case <-time.After(defaultTestShortTimeout):
					t.Errorf("timeout waiting for Connect() from SubConn %v", sc)
				}