cleanup: replace dial with newclient (#8602)

Fixes: https://github.com/grpc/grpc-go/issues/7049
RELEASE NOTES: None

diff --git a/clientconn_authority_test.go b/clientconn_authority_test.go
index 6eec582bdd03d568efc9dca700ffa33a77f7ceef..4c454619f72dc084c7135a25818f58da7afc641a 100644 (file)
--- a/clientconn_authority_test.go
+++ b/clientconn_authority_test.go
@@ -109,9 +109,9 @@ func (s) TestClientConnAuthority(t *testing.T) {
 
        for _, test := range tests {
                t.Run(test.name, func(t *testing.T) {
-                       cc, err := Dial(test.target, test.opts...)
+                       cc, err := NewClient(test.target, test.opts...)
                        if err != nil {
-                               t.Fatalf("Dial(%q) failed: %v", test.target, err)
+                               t.Fatalf("NewClient(%q) failed: %v", test.target, err)
                        }
                        defer cc.Close()
                        if cc.authority != test.wantAuthority {
@@ -130,6 +130,6 @@ func (s) TestClientConnAuthority_CredsAndDialOptionMismatch(t *testing.T) {
        opts := []DialOption{WithTransportCredentials(creds), WithAuthority("authority-override")}
        if cc, err := NewClient("Non-Existent.Server:8000", opts...); err == nil {
                cc.Close()
-               t.Fatal("grpc.NewClient() succeeded when expected to fail")
+               t.Fatal("NewClient() succeeded when expected to fail")
        }
 }

diff --git a/clientconn_parsed_target_test.go b/clientconn_parsed_target_test.go
index 499125a7c16a309d206b5c6cd6f9af1af22c6f3b..751343969534da1883fb727e446d37e0e2cbd1de 100644 (file)
--- a/clientconn_parsed_target_test.go
+++ b/clientconn_parsed_target_test.go
@@ -23,6 +23,7 @@ import (
        "errors"
        "fmt"
        "net"
+       "strings"
        "testing"
        "time"
 
@@ -203,6 +204,34 @@ func (s) TestParsedTarget_Failure_WithoutCustomDialer(t *testing.T) {
        }
 }
 
+func (s) TestParsedTarget_Failure_WithoutCustomDialer_WithNewClient(t *testing.T) {
+       targets := []string{
+               "",
+               "unix://a/b/c",
+               "unix://authority",
+               "unix-abstract://authority/a/b/c",
+               "unix-abstract://authority",
+       }
+
+       for _, target := range targets {
+               t.Run(target, func(t *testing.T) {
+                       ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout)
+                       defer cancel()
+                       cc, err := NewClient(target, WithTransportCredentials(insecure.NewCredentials()))
+                       if err != nil {
+                               t.Fatalf("NewClient(%q) failed: %v", target, err)
+                       }
+                       defer cc.Close()
+                       const wantErrSubstr = "failed to exit idle mode"
+                       if _, err := cc.NewStream(ctx, &StreamDesc{}, "/my.service.v1.MyService/UnaryCall"); err == nil {
+                               t.Fatalf("NewStream() succeeded with target = %q, cc.parsedTarget = %+v, expected to fail", target, cc.parsedTarget)
+                       } else if !strings.Contains(err.Error(), wantErrSubstr) {
+                               t.Fatalf("NewStream() with target = %q returned unexpected error: got %v, want substring %q", target, err, wantErrSubstr)
+                       }
+               })
+       }
+}
+
 func (s) TestParsedTarget_WithCustomDialer(t *testing.T) {
        resetInitialResolverState()
        defScheme := resolver.GetDefaultScheme()
@@ -273,11 +302,12 @@ func (s) TestParsedTarget_WithCustomDialer(t *testing.T) {
                                return nil, errors.New("dialer error")
                        }
 
-                       cc, err := Dial(test.target, WithTransportCredentials(insecure.NewCredentials()), WithContextDialer(dialer))
+                       cc, err := NewClient(test.target, WithTransportCredentials(insecure.NewCredentials()), withDefaultScheme(defScheme), WithContextDialer(dialer))
                        if err != nil {
-                               t.Fatalf("Dial(%q) failed: %v", test.target, err)
+                               t.Fatalf("grpc.NewClient(%q) failed: %v", test.target, err)
                        }
                        defer cc.Close()
+                       cc.Connect()
 
                        select {
                        case addr := <-addrCh:

diff --git a/default_dial_option_server_option_test.go b/default_dial_option_server_option_test.go
index a9544d6156c82014c2756fcbb92a50d3f7df32ed..67ea9e80da8c031bef5bed233bc482c7f2106abd 100644 (file)
--- a/default_dial_option_server_option_test.go
+++ b/default_dial_option_server_option_test.go
@@ -29,12 +29,12 @@ import (
 )
 
 func (s) TestAddGlobalDialOptions(t *testing.T) {
-       // Ensure the Dial fails without credentials
-       if _, err := Dial("fake"); err == nil {
-               t.Fatalf("Dialing without a credential did not fail")
+       // Ensure the NewClient fails without credentials
+       if _, err := NewClient("fake"); err == nil {
+               t.Fatalf("NewClient without a credential did not fail")
        } else {
                if !strings.Contains(err.Error(), "no transport security set") {
-                       t.Fatalf("Dialing failed with unexpected error: %v", err)
+                       t.Fatalf("NewClient failed with unexpected error: %v", err)
                }
        }
 
@@ -48,9 +48,9 @@ func (s) TestAddGlobalDialOptions(t *testing.T) {
                }
        }
 
-       // Ensure the Dial passes with the extra dial options
-       if cc, err := Dial("fake"); err != nil {
-               t.Fatalf("Dialing with insecure credential failed: %v", err)
+       // Ensure the NewClient passes with the extra dial options
+       if cc, err := NewClient("fake"); err != nil {
+               t.Fatalf("NewClient with insecure credential failed: %v", err)
        } else {
                cc.Close()
        }
@@ -71,8 +71,8 @@ func (s) TestDisableGlobalOptions(t *testing.T) {
        // due to the global dial options with credentials not being picked up due
        // to global options being disabled.
        noTSecStr := "no transport security set"
-       if _, err := Dial("fake", internal.DisableGlobalDialOptions.(func() DialOption)()); !strings.Contains(fmt.Sprint(err), noTSecStr) {
-               t.Fatalf("Dialing received unexpected error: %v, want error containing \"%v\"", err, noTSecStr)
+       if _, err := NewClient("fake", internal.DisableGlobalDialOptions.(func() DialOption)()); !strings.Contains(fmt.Sprint(err), noTSecStr) {
+               t.Fatalf("NewClient received unexpected error: %v, want error containing %q", err, noTSecStr)
        }
 }
 
@@ -95,11 +95,11 @@ func (s) TestGlobalPerTargetDialOption(t *testing.T) {
        defer internal.ClearGlobalPerTargetDialOptions()
        noTSecStr := "no transport security set"
        if _, err := NewClient("dns:///fake"); !strings.Contains(fmt.Sprint(err), noTSecStr) {
-               t.Fatalf("Dialing received unexpected error: %v, want error containing \"%v\"", err, noTSecStr)
+               t.Fatalf("NewClient received unexpected error: %v, want error containing %q", err, noTSecStr)
        }
        cc, err := NewClient("passthrough:///nice")
        if err != nil {
-               t.Fatalf("Dialing with insecure credentials failed: %v", err)
+               t.Fatalf("NewClient with insecure credentials failed: %v", err)
        }
        cc.Close()
 }
@@ -135,9 +135,9 @@ func (s) TestJoinDialOption(t *testing.T) {
        const maxRecvSize = 998765
        const initialWindowSize = 100
        jdo := newJoinDialOption(WithTransportCredentials(insecure.NewCredentials()), WithReadBufferSize(maxRecvSize), WithInitialWindowSize(initialWindowSize))
-       cc, err := Dial("fake", jdo)
+       cc, err := NewClient("fake", jdo)
        if err != nil {
-               t.Fatalf("Dialing with insecure credentials failed: %v", err)
+               t.Fatalf("NewClient with insecure credentials failed: %v", err)
        }
        defer cc.Close()
        if cc.dopts.copts.ReadBufferSize != maxRecvSize {

diff --git a/resolver_test.go b/resolver_test.go
index 9262f6ce7f9ab7dee76a7e5326a89246feea05e2..1afc5116e2c767a3bac0f11540c9838e80798934 100644 (file)
--- a/resolver_test.go
+++ b/resolver_test.go
@@ -63,9 +63,9 @@ func (s) TestResolverCaseSensitivity(t *testing.T) {
                return nil, fmt.Errorf("not dialing with custom dialer")
        }
 
-       cc, err := Dial(target, WithContextDialer(customDialer), WithTransportCredentials(insecure.NewCredentials()))
+       cc, err := NewClient(target, WithContextDialer(customDialer), WithTransportCredentials(insecure.NewCredentials()))
        if err != nil {
-               t.Fatalf("Unexpected Dial(%q) error: %v", target, err)
+               t.Fatalf("Unexpected NewClient(%q) error: %v", target, err)
        }
        cc.Connect()
        if got, want := <-addrCh, "localhost:1234"; got != want {
@@ -85,9 +85,9 @@ func (s) TestResolverCaseSensitivity(t *testing.T) {
        // This results in "passthrough" being used with the address as the whole
        // target.
        target = "caseTest2:///localhost:1234"
-       cc, err = Dial(target, WithContextDialer(customDialer), WithResolvers(res), WithTransportCredentials(insecure.NewCredentials()))
+       cc, err = NewClient(target, WithContextDialer(customDialer), withDefaultScheme("passthrough"), WithResolvers(res), WithTransportCredentials(insecure.NewCredentials()))
        if err != nil {
-               t.Fatalf("Unexpected Dial(%q) error: %v", target, err)
+               t.Fatalf("Unexpected NewClient(%q) error: %v", target, err)
        }
        cc.Connect()
        if got, want := <-addrCh, target; got != want {
@@ -125,7 +125,7 @@ func (s) TestResolverAddressesToEndpoints(t *testing.T) {
                WithResolvers(r),
                WithDefaultServiceConfig(fmt.Sprintf(`{"loadBalancingConfig": [{"%s":{}}]}`, balancerName)))
        if err != nil {
-               t.Fatalf("grpc.NewClient() failed: %v", err)
+               t.Fatalf("NewClient() failed: %v", err)
        }
        cc.Connect()
        defer cc.Close()
@@ -176,7 +176,7 @@ func (s) TestResolverAddressesToEndpointsUsingNewAddresses(t *testing.T) {
                WithResolvers(r),
                WithDefaultServiceConfig(fmt.Sprintf(`{"loadBalancingConfig": [{"%s":{}}]}`, balancerName)))
        if err != nil {
-               t.Fatalf("grpc.NewClient() failed: %v", err)
+               t.Fatalf("NewClient() failed: %v", err)
        }
        cc.Connect()
        defer cc.Close()