Method TestPicker

balancer/lazy/lazy_ext_test.go:139–188

TestPicker creates a lazy balancer under a stub balancer which block all calls to ExitIdle. This ensures the only way to trigger lazy to exit idle is through the picker. The test makes an RPC and ensures it succeeds.

(t *testing.T)

// calls to ExitIdle. This ensures the only way to trigger lazy to exit idle is
// through the picker. The test makes an RPC and ensures it succeeds.
func (s) TestPicker(t *testing.T) {
	backend := stubserver.StartTestService(t, nil)
	defer backend.Stop()
	ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout)
	defer cancel()

	bf := stub.BalancerFuncs{
		Init: func(bd *stub.BalancerData) {
			bd.ChildBalancer = lazy.NewBalancer(bd.ClientConn, bd.BuildOptions, balancer.Get(pickfirst.Name).Build)
		},
		ExitIdle: func(*stub.BalancerData) {
			t.Log("Ignoring call to ExitIdle, calling the picker should make the lazy balancer exit IDLE state.")
		},
		UpdateClientConnState: func(bd *stub.BalancerData, ccs balancer.ClientConnState) error {
			return bd.ChildBalancer.UpdateClientConnState(ccs)
		},
		Close: func(bd *stub.BalancerData) {
			bd.ChildBalancer.Close()
		},
	}

	name := strings.ReplaceAll(strings.ToLower(t.Name()), "/", "")
	stub.Register(name, bf)
	json := fmt.Sprintf(`{"loadBalancingConfig": [{%q: {}}]}`, name)

	opts := []grpc.DialOption{
		grpc.WithTransportCredentials(insecure.NewCredentials()),
		grpc.WithDefaultServiceConfig(json),
	}
	cc, err := grpc.NewClient(backend.Address, opts...)
	if err != nil {
		t.Fatalf("grpc.NewClient(_) failed: %v", err)
	}
	defer cc.Close()

	// The channel should remain in IDLE as the ExitIdle calls are not
	// propagated to the lazy balancer from the stub balancer.
	cc.Connect()
	shortCtx, shortCancel := context.WithTimeout(ctx, defaultTestShortTimeout)
	defer shortCancel()
	testutils.AwaitNoStateChange(shortCtx, t, cc, connectivity.Idle)

	// The picker from the lazy balancer should be send to the channel when the
	// first resolver update is received by lazy. Making an RPC should trigger
	// child creation.
	client := testgrpc.NewTestServiceClient(cc)
	if _, err := client.EmptyCall(ctx, &testpb.Empty{}); err != nil {
		t.Errorf("client.EmptyCall() returned unexpected error: %v", err)
	}
}

// Tests the scenario when a resolver produces a good state followed by a
// resolver error. The test verifies that the child balancer receives the good