diff --git a/test/creds_test.go b/test/creds_test.go index ff3818e0ad54..7d45d5e07ab5 100644 --- a/test/creds_test.go +++ b/test/creds_test.go @@ -32,6 +32,7 @@ import ( "google.golang.org/grpc/connectivity" "google.golang.org/grpc/credentials" "google.golang.org/grpc/credentials/insecure" + "google.golang.org/grpc/internal/stubserver" "google.golang.org/grpc/internal/testutils" "google.golang.org/grpc/metadata" "google.golang.org/grpc/resolver" @@ -431,10 +432,15 @@ func (s) TestCredsHandshakeAuthority(t *testing.T) { t.Fatal(err) } cred := &authorityCheckCreds{} - s := grpc.NewServer() - go s.Serve(lis) - defer s.Stop() - + stub := &stubserver.StubServer{ + Listener: lis, + EmptyCallF: func(_ context.Context, _ *testpb.Empty) (*testpb.Empty, error) { + return &testpb.Empty{}, nil + }, + S: grpc.NewServer(), + } + stubserver.StartTestService(t, stub) + defer stub.S.Stop() r := manual.NewBuilderWithScheme("whatever") cc, err := grpc.Dial(r.Scheme()+":///"+testAuthority, grpc.WithTransportCredentials(cred), grpc.WithResolvers(r)) @@ -463,10 +469,16 @@ func (s) TestCredsHandshakeServerNameAuthority(t *testing.T) { t.Fatal(err) } cred := &authorityCheckCreds{} - s := grpc.NewServer() - go s.Serve(lis) - defer s.Stop() + stub := &stubserver.StubServer{ + Listener: lis, + EmptyCallF: func(_ context.Context, _ *testpb.Empty) (*testpb.Empty, error) { + return &testpb.Empty{}, nil + }, + S: grpc.NewServer(), + } + stubserver.StartTestService(t, stub) + defer stub.S.Stop() r := manual.NewBuilderWithScheme("whatever") cc, err := grpc.Dial(r.Scheme()+":///"+testAuthority, grpc.WithTransportCredentials(cred), grpc.WithResolvers(r)) diff --git a/test/goaway_test.go b/test/goaway_test.go index 65d2cc02d05a..f8fab36e445a 100644 --- a/test/goaway_test.go +++ b/test/goaway_test.go @@ -57,21 +57,20 @@ func (s) TestGracefulClientOnGoAway(t *testing.T) { const maxConnAge = 100 * time.Millisecond const testTime = maxConnAge * 10 + lis, err := net.Listen("tcp", "localhost:0") + if err != nil { + t.Fatalf("Failed to create listener: %v", err) + } + ss := &stubserver.StubServer{ + Listener: lis, EmptyCallF: func(context.Context, *testpb.Empty) (*testpb.Empty, error) { return &testpb.Empty{}, nil }, + S: grpc.NewServer(grpc.KeepaliveParams(keepalive.ServerParameters{MaxConnectionAge: maxConnAge})), } - - s := grpc.NewServer(grpc.KeepaliveParams(keepalive.ServerParameters{MaxConnectionAge: maxConnAge})) - defer s.Stop() - testgrpc.RegisterTestServiceServer(s, ss) - - lis, err := net.Listen("tcp", "localhost:0") - if err != nil { - t.Fatalf("Failed to create listener: %v", err) - } - go s.Serve(lis) + defer ss.S.Stop() + stubserver.StartTestService(t, ss) cc, err := grpc.NewClient(lis.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials())) if err != nil { @@ -551,13 +550,15 @@ func (s) TestGoAwayThenClose(t *testing.T) { if err != nil { t.Fatalf("Error while listening. Err: %v", err) } - s1 := grpc.NewServer() - defer s1.Stop() - ts := &funcServer{ - unaryCall: func(context.Context, *testpb.SimpleRequest) (*testpb.SimpleResponse, error) { + //s1 := grpc.NewServer() + //defer s1.Stop() + //ts := &funcServer{ + ss1 := &stubserver.StubServer{ + Listener: lis1, + UnaryCallF: func(context.Context, *testpb.SimpleRequest) (*testpb.SimpleResponse, error) { return &testpb.SimpleResponse{}, nil }, - fullDuplexCall: func(stream testgrpc.TestService_FullDuplexCallServer) error { + FullDuplexCallF: func(stream testgrpc.TestService_FullDuplexCallServer) error { if err := stream.Send(&testpb.StreamingOutputCallResponse{}); err != nil { t.Errorf("unexpected error from send: %v", err) return err @@ -569,18 +570,42 @@ func (s) TestGoAwayThenClose(t *testing.T) { } return err }, + S: grpc.NewServer(), } - testgrpc.RegisterTestServiceServer(s1, ts) - go s1.Serve(lis1) + stubserver.StartTestService(t, ss1) + defer ss1.S.Stop() + //testgrpc.RegisterTestServiceServer(s1, ts) + //go s1.Serve(lis1) conn2Established := grpcsync.NewEvent() lis2, err := listenWithNotifyingListener("tcp", "localhost:0", conn2Established) if err != nil { t.Fatalf("Error while listening. Err: %v", err) } - s2 := grpc.NewServer() + /*s2 := grpc.NewServer() defer s2.Stop() - testgrpc.RegisterTestServiceServer(s2, ts) + testgrpc.RegisterTestServiceServer(s2, ts)*/ + ss2 := &stubserver.StubServer{ + Listener: lis2, + UnaryCallF: func(context.Context, *testpb.SimpleRequest) (*testpb.SimpleResponse, error) { + return &testpb.SimpleResponse{}, nil + }, + FullDuplexCallF: func(stream testgrpc.TestService_FullDuplexCallServer) error { + if err := stream.Send(&testpb.StreamingOutputCallResponse{}); err != nil { + t.Errorf("unexpected error from send: %v", err) + return err + } + // Wait forever. + _, err := stream.Recv() + if err == nil { + t.Error("expected to never receive any message") + } + return err + }, + S: grpc.NewServer(), + } + stubserver.StartTestService(t, ss2) + defer ss2.S.Stop() r := manual.NewBuilderWithScheme("whatever") r.InitialState(resolver.State{Addresses: []resolver.Address{ @@ -613,10 +638,8 @@ func (s) TestGoAwayThenClose(t *testing.T) { t.Fatalf("unexpected error from first recv: %v", err) } - go s2.Serve(lis2) - t.Log("Gracefully stopping server 1.") - go s1.GracefulStop() + go ss1.S.GracefulStop() t.Log("Waiting for the ClientConn to enter IDLE state.") testutils.AwaitState(ctx, t, cc, connectivity.Idle) @@ -637,7 +660,7 @@ func (s) TestGoAwayThenClose(t *testing.T) { lis2.Close() t.Log("Hard closing connection 1.") - s1.Stop() + ss1.S.Stop() t.Log("Waiting for the first stream to error.") if _, err = stream.Recv(); err == nil { diff --git a/test/insecure_creds_test.go b/test/insecure_creds_test.go index 9f6c8b594708..3052c8fdad2a 100644 --- a/test/insecure_creds_test.go +++ b/test/insecure_creds_test.go @@ -83,7 +83,13 @@ func (s) TestInsecureCreds(t *testing.T) { for _, test := range tests { t.Run(test.desc, func(t *testing.T) { + lis, err := net.Listen("tcp", "localhost:0") + if err != nil { + t.Fatalf("net.Listen(tcp, localhost:0) failed: %v", err) + } + ss := &stubserver.StubServer{ + Listener: lis, EmptyCallF: func(ctx context.Context, _ *testpb.Empty) (*testpb.Empty, error) { if !test.serverInsecureCreds { return &testpb.Empty{}, nil @@ -104,22 +110,14 @@ func (s) TestInsecureCreds(t *testing.T) { return &testpb.Empty{}, nil }, } - - sOpts := []grpc.ServerOption{} if test.serverInsecureCreds { - sOpts = append(sOpts, grpc.Creds(insecure.NewCredentials())) - } - s := grpc.NewServer(sOpts...) - defer s.Stop() - - testgrpc.RegisterTestServiceServer(s, ss) - - lis, err := net.Listen("tcp", "localhost:0") - if err != nil { - t.Fatalf("net.Listen(tcp, localhost:0) failed: %v", err) + ss.S = grpc.NewServer(grpc.Creds(insecure.NewCredentials())) + } else { + ss.S = grpc.NewServer() } + defer ss.S.Stop() - go s.Serve(lis) + stubserver.StartTestService(t, ss) addr := lis.Addr().String() opts := []grpc.DialOption{grpc.WithTransportCredentials(insecure.NewCredentials())} @@ -143,21 +141,21 @@ func (s) TestInsecureCreds(t *testing.T) { } func (s) TestInsecureCreds_WithPerRPCCredentials_AsCallOption(t *testing.T) { + lis, err := net.Listen("tcp", "localhost:0") + if err != nil { + t.Fatalf("net.Listen(tcp, localhost:0) failed: %v", err) + } + ss := &stubserver.StubServer{ + Listener: lis, EmptyCallF: func(context.Context, *testpb.Empty) (*testpb.Empty, error) { return &testpb.Empty{}, nil }, + S: grpc.NewServer(grpc.Creds(insecure.NewCredentials())), } - s := grpc.NewServer(grpc.Creds(insecure.NewCredentials())) - defer s.Stop() - testgrpc.RegisterTestServiceServer(s, ss) - - lis, err := net.Listen("tcp", "localhost:0") - if err != nil { - t.Fatalf("net.Listen(tcp, localhost:0) failed: %v", err) - } - go s.Serve(lis) + defer ss.S.Stop() + stubserver.StartTestService(t, ss) addr := lis.Addr().String() ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout) @@ -179,21 +177,19 @@ func (s) TestInsecureCreds_WithPerRPCCredentials_AsCallOption(t *testing.T) { } func (s) TestInsecureCreds_WithPerRPCCredentials_AsDialOption(t *testing.T) { + lis, err := net.Listen("tcp", "localhost:0") + if err != nil { + t.Fatalf("net.Listen(tcp, localhost:0) failed: %v", err) + } ss := &stubserver.StubServer{ EmptyCallF: func(_ context.Context, _ *testpb.Empty) (*testpb.Empty, error) { return &testpb.Empty{}, nil }, + S: grpc.NewServer(grpc.Creds(insecure.NewCredentials())), } - s := grpc.NewServer(grpc.Creds(insecure.NewCredentials())) - defer s.Stop() - testgrpc.RegisterTestServiceServer(s, ss) - - lis, err := net.Listen("tcp", "localhost:0") - if err != nil { - t.Fatalf("net.Listen(tcp, localhost:0) failed: %v", err) - } - go s.Serve(lis) + defer ss.S.Stop() + stubserver.StartTestService(t, ss) addr := lis.Addr().String() dopts := []grpc.DialOption{ diff --git a/test/local_creds_test.go b/test/local_creds_test.go index 241f6306e2b4..2e2dc0ba317d 100644 --- a/test/local_creds_test.go +++ b/test/local_creds_test.go @@ -40,8 +40,14 @@ import ( testpb "google.golang.org/grpc/interop/grpc_testing" ) -func testLocalCredsE2ESucceed(network, address string) error { +func testLocalCredsE2ESucceed(t *testing.T, network, address string) error { + + lis, err := net.Listen(network, address) + if err != nil { + return fmt.Errorf("Failed to create listener: %v", err) + } ss := &stubserver.StubServer{ + Listener: lis, EmptyCallF: func(ctx context.Context, _ *testpb.Empty) (*testpb.Empty, error) { pr, ok := peer.FromContext(ctx) if !ok { @@ -69,20 +75,12 @@ func testLocalCredsE2ESucceed(network, address string) error { } return &testpb.Empty{}, nil }, + S: grpc.NewServer(grpc.Creds(local.NewCredentials())), } - sopts := []grpc.ServerOption{grpc.Creds(local.NewCredentials())} - s := grpc.NewServer(sopts...) - defer s.Stop() + defer ss.S.Stop() - testgrpc.RegisterTestServiceServer(s, ss) - - lis, err := net.Listen(network, address) - if err != nil { - return fmt.Errorf("Failed to create listener: %v", err) - } - - go s.Serve(lis) + stubserver.StartTestService(t, ss) var cc *grpc.ClientConn lisAddr := lis.Addr().String() @@ -114,14 +112,14 @@ func testLocalCredsE2ESucceed(network, address string) error { } func (s) TestLocalCredsLocalhost(t *testing.T) { - if err := testLocalCredsE2ESucceed("tcp", "localhost:0"); err != nil { + if err := testLocalCredsE2ESucceed(t, "tcp", "localhost:0"); err != nil { t.Fatalf("Failed e2e test for localhost: %v", err) } } func (s) TestLocalCredsUDS(t *testing.T) { addr := fmt.Sprintf("/tmp/grpc_fullstck_test%d", time.Now().UnixNano()) - if err := testLocalCredsE2ESucceed("unix", addr); err != nil { + if err := testLocalCredsE2ESucceed(t, "unix", addr); err != nil { t.Fatalf("Failed e2e test for UDS: %v", err) } } @@ -162,18 +160,15 @@ func spoofDialer(addr net.Addr) func(target string, t time.Duration) (net.Conn, } } -func testLocalCredsE2EFail(dopts []grpc.DialOption) error { +func testLocalCredsE2EFail(t *testing.T, dopts []grpc.DialOption) error { ss := &stubserver.StubServer{ EmptyCallF: func(context.Context, *testpb.Empty) (*testpb.Empty, error) { return &testpb.Empty{}, nil }, + S: grpc.NewServer(grpc.Creds(local.NewCredentials())), } - - sopts := []grpc.ServerOption{grpc.Creds(local.NewCredentials())} - s := grpc.NewServer(sopts...) - defer s.Stop() - - testgrpc.RegisterTestServiceServer(s, ss) + defer ss.S.Stop() + stubserver.StartTestService(t, ss) lis, err := net.Listen("tcp", "localhost:0") if err != nil { @@ -190,7 +185,7 @@ func testLocalCredsE2EFail(dopts []grpc.DialOption) error { Zone: "", } - go s.Serve(spoofListener(lis, fakeClientAddr)) + go ss.S.Serve(spoofListener(lis, fakeClientAddr)) cc, err := grpc.NewClient(lis.Addr().String(), append(dopts, grpc.WithDialer(spoofDialer(fakeServerAddr)))...) if err != nil { @@ -214,7 +209,7 @@ func (s) TestLocalCredsClientFail(t *testing.T) { // Use local creds at client-side which should lead to client-side failure. opts := []grpc.DialOption{grpc.WithTransportCredentials(local.NewCredentials())} want := status.Error(codes.Unavailable, "transport: authentication handshake failed: local credentials rejected connection to non-local address") - if err := testLocalCredsE2EFail(opts); !isExpected(err, want) { + if err := testLocalCredsE2EFail(t, opts); !isExpected(err, want) { t.Fatalf("testLocalCredsE2EFail() = %v; want %v", err, want) } } @@ -222,7 +217,7 @@ func (s) TestLocalCredsClientFail(t *testing.T) { func (s) TestLocalCredsServerFail(t *testing.T) { // Use insecure at client-side which should lead to server-side failure. opts := []grpc.DialOption{grpc.WithTransportCredentials(insecure.NewCredentials())} - if err := testLocalCredsE2EFail(opts); status.Code(err) != codes.Unavailable { + if err := testLocalCredsE2EFail(t, opts); status.Code(err) != codes.Unavailable { t.Fatalf("testLocalCredsE2EFail() = %v; want %v", err, codes.Unavailable) } }