Method TestRingHash_RequestHashKeyRandom

balancer/ringhash/ringhash_e2e_test.go:2748–2807

Tests that when a request hash key is set in the balancer configuration via service config, and the header is not set in the outgoing request, then it is sent to a random backend.

(t *testing.T)

// service config, and the header is not set in the outgoing request, then it
// is sent to a random backend.
func (s) TestRingHash_RequestHashKeyRandom(t *testing.T) {
	testutils.SetEnvConfig(t, &envconfig.RingHashSetRequestHashKey, true)

	backends := backendAddrs(startTestServiceBackends(t, 4))

	// Create a clientConn with a manual resolver (which is used to push the
	// address of the test backend), and a default service config pointing to
	// the use of the ring_hash_experimental LB policy with an explicit hash
	// header.
	ringHashServiceConfig := highRingSizeServiceConfig(t)
	r := manual.NewBuilderWithScheme("whatever")
	dopts := []grpc.DialOption{
		grpc.WithTransportCredentials(insecure.NewCredentials()),
		grpc.WithResolvers(r),
		grpc.WithDefaultServiceConfig(ringHashServiceConfig),
		grpc.WithConnectParams(fastConnectParams),
	}
	cc, err := grpc.NewClient(r.Scheme()+":///test.server", dopts...)
	if err != nil {
		t.Fatalf("Failed to dial local test server: %v", err)
	}
	defer cc.Close()
	var endpoints []resolver.Endpoint
	for _, backend := range backends {
		endpoints = append(endpoints, resolver.Endpoint{
			Addresses: []resolver.Address{{Addr: backend}},
		})
	}
	r.UpdateState(resolver.State{
		Endpoints: endpoints,
	})
	client := testgrpc.NewTestServiceClient(cc)

	ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout)
	defer cancel()

	// Due to the way that ring hash lazily establishes connections when using a
	// random hash, request distribution is skewed towards the order in which we
	// connected. The test send RPCs until we are connected to all backends, so
	// we can later assert that the distribution is uniform.
	seen := make(map[string]bool)
	for len(seen) != 4 {
		var remote peer.Peer
		if _, err := client.EmptyCall(ctx, &testpb.Empty{}, grpc.Peer(&remote)); err != nil {
			t.Fatalf("rpc EmptyCall() failed: %v", err)
		}
		seen[remote.String()] = true
	}

	// Make sure that requests with the old hash are sent to random backends.
	const want = 1.0 / 4
	numRPCs := computeIdealNumberOfRPCs(t, want, errorTolerance)
	gotPerBackend := checkRPCSendOK(ctx, t, client, numRPCs)
	for _, backend := range backends {
		got := float64(gotPerBackend[backend]) / float64(numRPCs)
		if !cmp.Equal(got, want, cmpopts.EquateApprox(0, errorTolerance)) {
			t.Errorf("Fraction of RPCs to backend %s: got %v, want %v (margin: +-%v)", backend, got, want, errorTolerance)
		}