diff --git a/balancer/rls/balancer_test.go b/balancer/rls/balancer_test.go index 8c77e3428950..6d13ccca68ba 100644 --- a/balancer/rls/balancer_test.go +++ b/balancer/rls/balancer_test.go @@ -333,11 +333,12 @@ func (s) TestConfigUpdate_ChildPolicyConfigs(t *testing.T) { // Register a manual resolver and push the RLS service config through it. r := startManualResolverWithConfig(t, rlsConfig) - cc, err := grpc.Dial(r.Scheme()+":///", grpc.WithResolvers(r), grpc.WithTransportCredentials(insecure.NewCredentials())) + cc, err := grpc.NewClient(r.Scheme()+":///", grpc.WithResolvers(r), grpc.WithTransportCredentials(insecure.NewCredentials())) if err != nil { - t.Fatalf("grpc.Dial() failed: %v", err) + t.Fatalf("grpc.NewClient() failed: %v", err) } defer cc.Close() + cc.Connect() // At this point, the RLS LB policy should have received its config, and // should have created a child policy for the default target. @@ -448,11 +449,12 @@ func (s) TestConfigUpdate_ChildPolicyChange(t *testing.T) { // Register a manual resolver and push the RLS service config through it. r := startManualResolverWithConfig(t, rlsConfig) - cc, err := grpc.Dial(r.Scheme()+":///", grpc.WithResolvers(r), grpc.WithTransportCredentials(insecure.NewCredentials())) + cc, err := grpc.NewClient(r.Scheme()+":///", grpc.WithResolvers(r), grpc.WithTransportCredentials(insecure.NewCredentials())) if err != nil { - t.Fatalf("grpc.Dial() failed: %v", err) + t.Fatalf("grpc.NewClient() failed: %v", err) } defer cc.Close() + cc.Connect() // At this point, the RLS LB policy should have received its config, and // should have created a child policy for the default target. @@ -603,11 +605,12 @@ func (s) TestConfigUpdate_DataCacheSizeDecrease(t *testing.T) { // Register a manual resolver and push the RLS service config through it. r := startManualResolverWithConfig(t, rlsConfig) - cc, err := grpc.Dial(r.Scheme()+":///", grpc.WithResolvers(r), grpc.WithTransportCredentials(insecure.NewCredentials())) + cc, err := grpc.NewClient(r.Scheme()+":///", grpc.WithResolvers(r), grpc.WithTransportCredentials(insecure.NewCredentials())) if err != nil { - t.Fatalf("grpc.Dial() failed: %v", err) + t.Fatalf("grpc.NewClient() failed: %v", err) } defer cc.Close() + cc.Connect() <-clientConnUpdateDone @@ -769,11 +772,12 @@ func (s) TestPickerUpdateOnDataCacheSizeDecrease(t *testing.T) { sc := internal.ParseServiceConfig.(func(string) *serviceconfig.ParseResult)(scJSON) r.InitialState(resolver.State{ServiceConfig: sc}) - cc, err := grpc.Dial(r.Scheme()+":///", grpc.WithResolvers(r), grpc.WithTransportCredentials(insecure.NewCredentials())) + cc, err := grpc.NewClient(r.Scheme()+":///", grpc.WithResolvers(r), grpc.WithTransportCredentials(insecure.NewCredentials())) if err != nil { - t.Fatalf("create grpc.Dial() failed: %v", err) + t.Fatalf("create grpc.NewClient() failed: %v", err) } defer cc.Close() + cc.Connect() <-clientConnUpdateDone @@ -1151,11 +1155,12 @@ func (s) TestUpdateStatePauses(t *testing.T) { sc := internal.ParseServiceConfig.(func(string) *serviceconfig.ParseResult)(scJSON) r.InitialState(resolver.State{ServiceConfig: sc}) - cc, err := grpc.Dial(r.Scheme()+":///", grpc.WithResolvers(r), grpc.WithTransportCredentials(insecure.NewCredentials())) + cc, err := grpc.NewClient(r.Scheme()+":///", grpc.WithResolvers(r), grpc.WithTransportCredentials(insecure.NewCredentials())) if err != nil { - t.Fatalf("grpc.Dial() failed: %v", err) + t.Fatalf("grpc.NewClient() failed: %v", err) } defer cc.Close() + cc.Connect() // Wait for the clientconn update to be processed by the RLS LB policy. ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout) diff --git a/internal/idle/idle_e2e_test.go b/internal/idle/idle_e2e_test.go index 26f4f4c7017b..b9e06fb609b6 100644 --- a/internal/idle/idle_e2e_test.go +++ b/internal/idle/idle_e2e_test.go @@ -131,11 +131,12 @@ func (s) TestChannelIdleness_Disabled_NoActivity(t *testing.T) { grpc.WithIdleTimeout(0), // Disable idleness. grpc.WithDefaultServiceConfig(`{"loadBalancingConfig": [{"round_robin":{}}]}`), } - cc, err := grpc.Dial(r.Scheme()+":///test.server", dopts...) + cc, err := grpc.NewClient(r.Scheme()+":///test.server", dopts...) if err != nil { - t.Fatalf("grpc.Dial() failed: %v", err) + t.Fatalf("grpc.NewClient() failed: %v", err) } defer cc.Close() + cc.Connect() // Start a test backend and push an address update via the resolver. backend := stubserver.StartTestService(t, nil) @@ -177,12 +178,13 @@ func (s) TestChannelIdleness_Enabled_NoActivity(t *testing.T) { grpc.WithIdleTimeout(defaultTestShortIdleTimeout), grpc.WithDefaultServiceConfig(`{"loadBalancingConfig": [{"round_robin":{}}]}`), } - cc, err := grpc.Dial(r.Scheme()+":///test.server", dopts...) + cc, err := grpc.NewClient(r.Scheme()+":///test.server", dopts...) if err != nil { - t.Fatalf("grpc.Dial() failed: %v", err) + t.Fatalf("grpc.NewClient() failed: %v", err) } defer cc.Close() + cc.Connect() // Start a test backend and push an address update via the resolver. lis := testutils.NewListenerWrapper(t, nil) backend := stubserver.StartTestService(t, &stubserver.StubServer{Listener: lis}) @@ -265,12 +267,12 @@ func (s) TestChannelIdleness_Enabled_OngoingCall(t *testing.T) { grpc.WithIdleTimeout(defaultTestShortIdleTimeout), grpc.WithDefaultServiceConfig(`{"loadBalancingConfig": [{"round_robin":{}}]}`), } - cc, err := grpc.Dial(r.Scheme()+":///test.server", dopts...) + cc, err := grpc.NewClient(r.Scheme()+":///test.server", dopts...) if err != nil { - t.Fatalf("grpc.Dial() failed: %v", err) + t.Fatalf("grpc.NewClient() failed: %v", err) } defer cc.Close() - + cc.Connect() // Start a test backend that keeps the RPC call active by blocking // on a channel that is closed by the test later on. blockCh := make(chan struct{}) @@ -354,12 +356,12 @@ func (s) TestChannelIdleness_Enabled_ActiveSinceLastCheck(t *testing.T) { grpc.WithIdleTimeout(defaultTestShortIdleTimeout), grpc.WithDefaultServiceConfig(`{"loadBalancingConfig": [{"round_robin":{}}]}`), } - cc, err := grpc.Dial(r.Scheme()+":///test.server", dopts...) + cc, err := grpc.NewClient(r.Scheme()+":///test.server", dopts...) if err != nil { - t.Fatalf("grpc.Dial() failed: %v", err) + t.Fatalf("grpc.NewClient() failed: %v", err) } defer cc.Close() - + cc.Connect() // Start a test backend and push an address update via the resolver. backend := stubserver.StartTestService(t, nil) defer backend.Stop() @@ -423,12 +425,12 @@ func (s) TestChannelIdleness_Enabled_ExitIdleOnRPC(t *testing.T) { grpc.WithIdleTimeout(defaultTestShortIdleTimeout), grpc.WithDefaultServiceConfig(`{"loadBalancingConfig": [{"round_robin":{}}]}`), } - cc, err := grpc.Dial(r.Scheme()+":///test.server", dopts...) + cc, err := grpc.NewClient(r.Scheme()+":///test.server", dopts...) if err != nil { - t.Fatalf("grpc.Dial() failed: %v", err) + t.Fatalf("grpc.NewClient() failed: %v", err) } defer cc.Close() - + cc.Connect() // Verify that the ClientConn moves to READY. ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout) defer cancel() diff --git a/orca/producer_test.go b/orca/producer_test.go index 9df18bf574c9..adf030cc145b 100644 --- a/orca/producer_test.go +++ b/orca/producer_test.go @@ -153,12 +153,17 @@ func (s) TestProducer(t *testing.T) { li := &listenerInfo{scChan: make(chan balancer.SubConn, 1), listener: oobLis, opts: lisOpts} addr := setListenerInfo(resolver.Address{Addr: lis.Addr().String()}, li) r.InitialState(resolver.State{Addresses: []resolver.Address{addr}}) - cc, err := grpc.Dial("whatever:///whatever", grpc.WithDefaultServiceConfig(`{"loadBalancingConfig": [{"customLB":{}}]}`), grpc.WithResolvers(r), grpc.WithTransportCredentials(insecure.NewCredentials())) + dopts := []grpc.DialOption{ + grpc.WithDefaultServiceConfig(`{"loadBalancingConfig": [{"customLB":{}}]}`), + grpc.WithResolvers(r), + grpc.WithTransportCredentials(insecure.NewCredentials()), + } + cc, err := grpc.NewClient("whatever:///whatever", dopts...) if err != nil { - t.Fatalf("grpc.Dial failed: %v", err) + t.Fatalf("grpc.NewClient() failed: %v", err) } defer cc.Close() - + cc.Connect() // Set a few metrics and wait for them on the client side. smr.SetCPUUtilization(10) smr.SetMemoryUtilization(0.1) @@ -319,10 +324,16 @@ func (s) TestProducerBackoff(t *testing.T) { lisOpts := orca.OOBListenerOptions{ReportInterval: reportInterval} li := &listenerInfo{scChan: make(chan balancer.SubConn, 1), listener: oobLis, opts: lisOpts} r.InitialState(resolver.State{Addresses: []resolver.Address{setListenerInfo(resolver.Address{Addr: lis.Addr().String()}, li)}}) - cc, err := grpc.Dial("whatever:///whatever", grpc.WithDefaultServiceConfig(`{"loadBalancingConfig": [{"customLB":{}}]}`), grpc.WithResolvers(r), grpc.WithTransportCredentials(insecure.NewCredentials())) + dopts := []grpc.DialOption{ + grpc.WithDefaultServiceConfig(`{"loadBalancingConfig": [{"customLB":{}}]}`), + grpc.WithResolvers(r), + grpc.WithTransportCredentials(insecure.NewCredentials()), + } + cc, err := grpc.NewClient("whatever:///whatever", dopts...) if err != nil { - t.Fatalf("grpc.Dial failed: %v", err) + t.Fatalf("grpc.NewClient failed: %v", err) } + cc.Connect() defer cc.Close() // Define a load report to send and expect the client to see. @@ -431,10 +442,11 @@ func (s) TestProducerMultipleListeners(t *testing.T) { lisOpts1 := orca.OOBListenerOptions{ReportInterval: reportInterval1} li := &listenerInfo{scChan: make(chan balancer.SubConn, 1), listener: oobLis1, opts: lisOpts1} r.InitialState(resolver.State{Addresses: []resolver.Address{setListenerInfo(resolver.Address{Addr: lis.Addr().String()}, li)}}) - cc, err := grpc.Dial("whatever:///whatever", grpc.WithDefaultServiceConfig(`{"loadBalancingConfig": [{"customLB":{}}]}`), grpc.WithResolvers(r), grpc.WithTransportCredentials(insecure.NewCredentials())) + cc, err := grpc.NewClient("whatever:///whatever", grpc.WithDefaultServiceConfig(`{"loadBalancingConfig": [{"customLB":{}}]}`), grpc.WithResolvers(r), grpc.WithTransportCredentials(insecure.NewCredentials())) if err != nil { - t.Fatalf("grpc.Dial failed: %v", err) + t.Fatalf("grpc.NewClient() failed: %v", err) } + cc.Connect() defer cc.Close() // Ensure the OOB listener is stopped before the client is closed to avoid diff --git a/resolver/manual/manual_test.go b/resolver/manual/manual_test.go index 3c118134b870..2d089268b778 100644 --- a/resolver/manual/manual_test.go +++ b/resolver/manual/manual_test.go @@ -59,12 +59,14 @@ func TestResolver(t *testing.T) { }) t.Run("happy_path", func(t *testing.T) { - _, err := grpc.Dial("whatever://localhost", + cc, err := grpc.NewClient("whatever://localhost", grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithResolvers(r)) if err != nil { - t.Errorf("dial setup error: %v", err) + t.Errorf("grpc.NewClient() failed: %v", err) } + defer cc.Close() + cc.Connect() r.UpdateState(resolver.State{Addresses: []resolver.Address{ {Addr: "ok"}, }}) diff --git a/test/authority_test.go b/test/authority_test.go index cf9da155a770..3749b59b9644 100644 --- a/test/authority_test.go +++ b/test/authority_test.go @@ -165,7 +165,7 @@ func (s) TestUnixCustomDialer(t *testing.T) { } } -// TestColonPortAuthority does an end to end test with the target for grpc.Dial +// TestColonPortAuthority does an end to end test with the target for grpc.NewClient // being ":[port]". Ensures authority is "localhost:[port]". func (s) TestColonPortAuthority(t *testing.T) { expectedAuthority := "" @@ -189,16 +189,11 @@ func (s) TestColonPortAuthority(t *testing.T) { authorityMu.Lock() expectedAuthority = "localhost:" + port authorityMu.Unlock() - // ss.Start dials, but not the ":[port]" target that is being tested here. - // Dial again, with ":[port]" as the target. - // - // Append "localhost" before calling net.Dial, in case net.Dial on certain - // platforms doesn't work well for address without the IP. - cc, err := grpc.Dial(":"+port, grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithContextDialer(func(ctx context.Context, addr string) (net.Conn, error) { - return (&net.Dialer{}).DialContext(ctx, "tcp", "localhost"+addr) - })) + // ss.Start dials the server, but we explicitly test with ":[port]" + // as the target. + cc, err := grpc.NewClient(":"+port, grpc.WithTransportCredentials(insecure.NewCredentials())) if err != nil { - t.Fatalf("grpc.Dial(%q) = %v", ss.Target, err) + t.Fatalf("grpc.NewClient(%q) = %v", ss.Target, err) } defer cc.Close() ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout) diff --git a/test/roundrobin_test.go b/test/roundrobin_test.go index 2241fab7e6c8..815e244946fe 100644 --- a/test/roundrobin_test.go +++ b/test/roundrobin_test.go @@ -266,16 +266,15 @@ func (s) TestRoundRobin_UpdateAddressAttributes(t *testing.T) { grpc.WithResolvers(r), grpc.WithDefaultServiceConfig(rrServiceConfig), } - cc, err := grpc.Dial(r.Scheme()+":///test.server", dopts...) + // Set an initial resolver update with no address attributes. + addr := resolver.Address{Addr: backend.Address} + r.InitialState(resolver.State{Addresses: []resolver.Address{addr}}) + cc, err := grpc.NewClient(r.Scheme()+":///test.server", dopts...) if err != nil { - t.Fatalf("grpc.Dial() failed: %v", err) + t.Fatalf("grpc.NewClient() failed: %v", err) } t.Cleanup(func() { cc.Close() }) - // Send a resolver update with no address attributes. - addr := resolver.Address{Addr: backend.Address} - r.UpdateState(resolver.State{Addresses: []resolver.Address{addr}}) - // Make an RPC and ensure it does not contain the metadata we are looking for. client := testgrpc.NewTestServiceClient(cc) ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout)