clusterresolver: switch a couple of tests to e2e style (#6394)

Author: easwars

xds/internal/balancer/clusterresolver/clusterresolver_test.go

@@ -19,26 +19,10 @@
 package clusterresolver
 
 import (
-	"context"
-	"fmt"
 	"testing"
 	"time"
 
-	"github.com/google/go-cmp/cmp"
-	"github.com/google/go-cmp/cmp/cmpopts"
-	"google.golang.org/grpc/balancer"
-	"google.golang.org/grpc/connectivity"
 	"google.golang.org/grpc/internal/grpctest"
-	iserviceconfig "google.golang.org/grpc/internal/serviceconfig"
-	"google.golang.org/grpc/internal/testutils"
-	"google.golang.org/grpc/resolver"
-	xdsinternal "google.golang.org/grpc/xds/internal"
-	"google.golang.org/grpc/xds/internal/balancer/clusterimpl"
-	"google.golang.org/grpc/xds/internal/balancer/outlierdetection"
-	"google.golang.org/grpc/xds/internal/balancer/priority"
-	"google.golang.org/grpc/xds/internal/testutils/fakeclient"
-	"google.golang.org/grpc/xds/internal/xdsclient"
-	"google.golang.org/grpc/xds/internal/xdsclient/xdsresource"
 )
 
 const (
@@ -47,295 +31,13 @@ const (
 	testEDSService          = "test-eds-service-name"
 	testClusterName         = "test-cluster-name"
 	testClusterName2        = "google_cfe_some-name"
+	testBalancerNameFooBar  = "foo.bar"
 )
 
-var (
-	// A non-empty endpoints update which is expected to be accepted by the EDS
-	// LB policy.
-	defaultEndpointsUpdate = xdsresource.EndpointsUpdate{
-		Localities: []xdsresource.Locality{
-			{
-				Endpoints: []xdsresource.Endpoint{{Address: "endpoint1"}},
-				ID:        xdsinternal.LocalityID{Zone: "zone"},
-				Priority:  1,
-				Weight:    100,
-			},
-		},
-	}
-)
-
-func init() {
-	balancer.Register(bb{})
-}
-
 type s struct {
 	grpctest.Tester
-
-	cleanup func()
-}
-
-func (ss s) Teardown(t *testing.T) {
-	xdsclient.ClearAllCountersForTesting()
-	ss.Tester.Teardown(t)
-	if ss.cleanup != nil {
-		ss.cleanup()
-	}
 }
 
 func Test(t *testing.T) {
 	grpctest.RunSubTests(t, s{})
 }
-
-const testBalancerNameFooBar = "foo.bar"
-
-func newNoopTestClientConn() *noopTestClientConn {
-	return &noopTestClientConn{}
-}
-
-// noopTestClientConn is used in EDS balancer config update tests that only
-// cover the config update handling, but not SubConn/load-balancing.
-type noopTestClientConn struct {
-	balancer.ClientConn
-}
-
-func (t *noopTestClientConn) NewSubConn([]resolver.Address, balancer.NewSubConnOptions) (balancer.SubConn, error) {
-	return nil, nil
-}
-
-func (noopTestClientConn) Target() string { return testEDSService }
-
-type scStateChange struct {
-	sc    balancer.SubConn
-	state balancer.SubConnState
-}
-
-type fakeChildBalancer struct {
-	cc              balancer.ClientConn
-	subConnState    *testutils.Channel
-	clientConnState *testutils.Channel
-	resolverError   *testutils.Channel
-}
-
-func (f *fakeChildBalancer) UpdateClientConnState(state balancer.ClientConnState) error {
-	f.clientConnState.Send(state)
-	return nil
-}
-
-func (f *fakeChildBalancer) ResolverError(err error) {
-	f.resolverError.Send(err)
-}
-
-func (f *fakeChildBalancer) UpdateSubConnState(sc balancer.SubConn, state balancer.SubConnState) {
-	f.subConnState.Send(&scStateChange{sc: sc, state: state})
-}
-
-func (f *fakeChildBalancer) Close() {}
-
-func (f *fakeChildBalancer) ExitIdle() {}
-
-func (f *fakeChildBalancer) waitForClientConnStateChangeVerifyBalancerConfig(ctx context.Context, wantCCS balancer.ClientConnState) error {
-	ccs, err := f.clientConnState.Receive(ctx)
-	if err != nil {
-		return err
-	}
-	gotCCS := ccs.(balancer.ClientConnState)
-	if diff := cmp.Diff(gotCCS, wantCCS, cmpopts.IgnoreFields(balancer.ClientConnState{}, "ResolverState")); diff != "" {
-		return fmt.Errorf("received unexpected ClientConnState, diff (-got +want): %v", diff)
-	}
-	return nil
-}
-
-func (f *fakeChildBalancer) waitForSubConnStateChange(ctx context.Context, wantState *scStateChange) error {
-	val, err := f.subConnState.Receive(ctx)
-	if err != nil {
-		return err
-	}
-	gotState := val.(*scStateChange)
-	if !cmp.Equal(gotState, wantState, cmp.AllowUnexported(scStateChange{})) {
-		return fmt.Errorf("got subconnStateChange %v, want %v", gotState, wantState)
-	}
-	return nil
-}
-
-func newFakeChildBalancer(cc balancer.ClientConn) balancer.Balancer {
-	return &fakeChildBalancer{
-		cc:              cc,
-		subConnState:    testutils.NewChannelWithSize(10),
-		clientConnState: testutils.NewChannelWithSize(10),
-		resolverError:   testutils.NewChannelWithSize(10),
-	}
-}
-
-type fakeSubConn struct{}
-
-func (*fakeSubConn) UpdateAddresses([]resolver.Address) { panic("implement me") }
-func (*fakeSubConn) Connect()                           { panic("implement me") }
-func (*fakeSubConn) GetOrBuildProducer(balancer.ProducerBuilder) (balancer.Producer, func()) {
-	panic("implement me")
-}
-
-// waitForNewChildLB makes sure that a new child LB is created by the top-level
-// clusterResolverBalancer.
-func waitForNewChildLB(ctx context.Context, ch *testutils.Channel) (*fakeChildBalancer, error) {
-	val, err := ch.Receive(ctx)
-	if err != nil {
-		return nil, fmt.Errorf("error when waiting for a new edsLB: %v", err)
-	}
-	return val.(*fakeChildBalancer), nil
-}
-
-// setup overrides the functions which are used to create the xdsClient and the
-// edsLB, creates fake version of them and makes them available on the provided
-// channels. The returned cancel function should be called by the test for
-// cleanup.
-func setup(childLBCh *testutils.Channel) (*fakeclient.Client, func()) {
-	xdsC := fakeclient.NewClientWithName(testBalancerNameFooBar)
-
-	origNewChildBalancer := newChildBalancer
-	newChildBalancer = func(_ balancer.Builder, cc balancer.ClientConn, _ balancer.BuildOptions) balancer.Balancer {
-		childLB := newFakeChildBalancer(cc)
-		defer func() { childLBCh.Send(childLB) }()
-		return childLB
-	}
-	return xdsC, func() { newChildBalancer = origNewChildBalancer }
-}
-
-// TestSubConnStateChange verifies if the top-level clusterResolverBalancer passes on
-// the subConnState to appropriate child balancer.
-func (s) TestSubConnStateChange(t *testing.T) {
-	edsLBCh := testutils.NewChannel()
-	xdsC, cleanup := setup(edsLBCh)
-	defer cleanup()
-
-	builder := balancer.Get(Name)
-	edsB := builder.Build(newNoopTestClientConn(), balancer.BuildOptions{})
-	if edsB == nil {
-		t.Fatalf("builder.Build(%s) failed and returned nil", Name)
-	}
-	defer edsB.Close()
-
-	if err := edsB.UpdateClientConnState(balancer.ClientConnState{
-		ResolverState:  xdsclient.SetClient(resolver.State{}, xdsC),
-		BalancerConfig: newLBConfigWithOneEDS(testEDSService),
-	}); err != nil {
-		t.Fatalf("edsB.UpdateClientConnState() failed: %v", err)
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout)
-	defer cancel()
-	if _, err := xdsC.WaitForWatchEDS(ctx); err != nil {
-		t.Fatalf("xdsClient.WatchEndpoints failed with error: %v", err)
-	}
-	xdsC.InvokeWatchEDSCallback("", defaultEndpointsUpdate, nil)
-	edsLB, err := waitForNewChildLB(ctx, edsLBCh)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	fsc := &fakeSubConn{}
-	state := balancer.SubConnState{ConnectivityState: connectivity.Ready}
-	edsB.UpdateSubConnState(fsc, state)
-	if err := edsLB.waitForSubConnStateChange(ctx, &scStateChange{sc: fsc, state: state}); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func newLBConfigWithOneEDS(edsServiceName string) *LBConfig {
-	return &LBConfig{
-		DiscoveryMechanisms: []DiscoveryMechanism{{
-			Cluster:        testClusterName,
-			Type:           DiscoveryMechanismTypeEDS,
-			EDSServiceName: edsServiceName,
-		}},
-		xdsLBPolicy: iserviceconfig.BalancerConfig{
-			Name:   "ROUND_ROBIN",
-			Config: nil,
-		},
-	}
-}
-
-func newLBConfigWithOneEDSAndOutlierDetection(edsServiceName string, odCfg outlierdetection.LBConfig) *LBConfig {
-	lbCfg := newLBConfigWithOneEDS(edsServiceName)
-	lbCfg.DiscoveryMechanisms[0].outlierDetection = odCfg
-	return lbCfg
-}
-
-// TestOutlierDetection tests the Balancer Config sent down to the child
-// priority balancer when Outlier Detection is turned on. The Priority
-// Configuration sent downward should have a top level Outlier Detection Policy
-// for each priority.
-func (s) TestOutlierDetection(t *testing.T) {
-	edsLBCh := testutils.NewChannel()
-	xdsC, cleanup := setup(edsLBCh)
-	defer cleanup()
-	builder := balancer.Get(Name)
-	edsB := builder.Build(newNoopTestClientConn(), balancer.BuildOptions{})
-	if edsB == nil {
-		t.Fatalf("builder.Build(%s) failed and returned nil", Name)
-	}
-	defer edsB.Close()
-
-	ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout)
-	defer cancel()
-
-	// Update Cluster Resolver with Client Conn State with Outlier Detection
-	// configuration present. This is what will be passed down to this balancer,
-	// as CDS Balancer gets the Cluster Update and converts the Outlier
-	// Detection data to an Outlier Detection configuration and sends it to this
-	// level.
-	if err := edsB.UpdateClientConnState(balancer.ClientConnState{
-		ResolverState:  xdsclient.SetClient(resolver.State{}, xdsC),
-		BalancerConfig: newLBConfigWithOneEDSAndOutlierDetection(testEDSService, noopODCfg),
-	}); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := xdsC.WaitForWatchEDS(ctx); err != nil {
-		t.Fatalf("xdsClient.WatchEndpoints failed with error: %v", err)
-	}
-
-	// Invoke EDS Callback - causes child balancer to be built and then
-	// UpdateClientConnState called on it with Outlier Detection as a direct
-	// child.
-	xdsC.InvokeWatchEDSCallback("", defaultEndpointsUpdate, nil)
-	edsLB, err := waitForNewChildLB(ctx, edsLBCh)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// The priority configuration generated should have Outlier Detection as a
-	// direct child due to Outlier Detection being turned on.
-	pCfgWant := &priority.LBConfig{
-		Children: map[string]*priority.Child{
-			"priority-0-0": {
-				Config: &iserviceconfig.BalancerConfig{
-					Name: outlierdetection.Name,
-					Config: &outlierdetection.LBConfig{
-						Interval:           iserviceconfig.Duration(10 * time.Second), // default interval
-						BaseEjectionTime:   iserviceconfig.Duration(30 * time.Second),
-						MaxEjectionTime:    iserviceconfig.Duration(300 * time.Second),
-						MaxEjectionPercent: 10,
-						ChildPolicy: &iserviceconfig.BalancerConfig{
-							Name: clusterimpl.Name,
-							Config: &clusterimpl.LBConfig{
-								Cluster:        testClusterName,
-								EDSServiceName: "test-eds-service-name",
-								ChildPolicy: &iserviceconfig.BalancerConfig{
-									Name:   "ROUND_ROBIN",
-									Config: nil,
-								},
-							},
-						},
-					},
-				},
-				IgnoreReresolutionRequests: true,
-			},
-		},
-		Priorities: []string{"priority-0-0"},
-	}
-
-	if err := edsLB.waitForClientConnStateChangeVerifyBalancerConfig(ctx, balancer.ClientConnState{
-		BalancerConfig: pCfgWant,
-	}); err != nil {
-		t.Fatalf("EDS impl got unexpected update: %v", err)
-	}
-}