vendor/google.golang.org/grpc/reflection/serverreflection_test.go

   1 /*
   2  *
   3  * Copyright 2016 gRPC authors.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  */
  18
  19 //go:generate protoc -I grpc_testing --go_out=plugins=grpc:grpc_testing/ grpc_testing/proto2.proto grpc_testing/proto2_ext.proto grpc_testing/proto2_ext2.proto grpc_testing/test.proto
  20
  21 // Note: grpc_testingv3/testv3.pb.go is not re-generated because it was
  22 // intentionally generated by an older version of protoc-gen-go.
  23
  24 package reflection
  25
  26 import (
  27         "fmt"
  28         "net"
  29         "reflect"
  30         "sort"
  31         "testing"
  32
  33         "github.com/golang/protobuf/proto"
  34         dpb "github.com/golang/protobuf/protoc-gen-go/descriptor"
  35         "golang.org/x/net/context"
  36         "google.golang.org/grpc"
  37         rpb "google.golang.org/grpc/reflection/grpc_reflection_v1alpha"
  38         pb "google.golang.org/grpc/reflection/grpc_testing"
  39         pbv3 "google.golang.org/grpc/reflection/grpc_testingv3"
  40 )
  41
  42 var (
  43         s = &serverReflectionServer{}
  44         // fileDescriptor of each test proto file.
  45         fdTest       *dpb.FileDescriptorProto
  46         fdTestv3     *dpb.FileDescriptorProto
  47         fdProto2     *dpb.FileDescriptorProto
  48         fdProto2Ext  *dpb.FileDescriptorProto
  49         fdProto2Ext2 *dpb.FileDescriptorProto
  50         // fileDescriptor marshalled.
  51         fdTestByte       []byte
  52         fdTestv3Byte     []byte
  53         fdProto2Byte     []byte
  54         fdProto2ExtByte  []byte
  55         fdProto2Ext2Byte []byte
  56 )
  57
  58 func loadFileDesc(filename string) (*dpb.FileDescriptorProto, []byte) {
  59         enc := proto.FileDescriptor(filename)
  60         if enc == nil {
  61                 panic(fmt.Sprintf("failed to find fd for file: %v", filename))
  62         }
  63         fd, err := s.decodeFileDesc(enc)
  64         if err != nil {
  65                 panic(fmt.Sprintf("failed to decode enc: %v", err))
  66         }
  67         b, err := proto.Marshal(fd)
  68         if err != nil {
  69                 panic(fmt.Sprintf("failed to marshal fd: %v", err))
  70         }
  71         return fd, b
  72 }
  73
  74 func init() {
  75         fdTest, fdTestByte = loadFileDesc("test.proto")
  76         fdTestv3, fdTestv3Byte = loadFileDesc("testv3.proto")
  77         fdProto2, fdProto2Byte = loadFileDesc("proto2.proto")
  78         fdProto2Ext, fdProto2ExtByte = loadFileDesc("proto2_ext.proto")
  79         fdProto2Ext2, fdProto2Ext2Byte = loadFileDesc("proto2_ext2.proto")
  80 }
  81
  82 func TestFileDescForType(t *testing.T) {
  83         for _, test := range []struct {
  84                 st     reflect.Type
  85                 wantFd *dpb.FileDescriptorProto
  86         }{
  87                 {reflect.TypeOf(pb.SearchResponse_Result{}), fdTest},
  88                 {reflect.TypeOf(pb.ToBeExtended{}), fdProto2},
  89         } {
  90                 fd, err := s.fileDescForType(test.st)
  91                 if err != nil || !proto.Equal(fd, test.wantFd) {
  92                         t.Errorf("fileDescForType(%q) = %q, %v, want %q, <nil>", test.st, fd, err, test.wantFd)
  93                 }
  94         }
  95 }
  96
  97 func TestTypeForName(t *testing.T) {
  98         for _, test := range []struct {
  99                 name string
 100                 want reflect.Type
 101         }{
 102                 {"grpc.testing.SearchResponse", reflect.TypeOf(pb.SearchResponse{})},
 103         } {
 104                 r, err := s.typeForName(test.name)
 105                 if err != nil || r != test.want {
 106                         t.Errorf("typeForName(%q) = %q, %v, want %q, <nil>", test.name, r, err, test.want)
 107                 }
 108         }
 109 }
 110
 111 func TestTypeForNameNotFound(t *testing.T) {
 112         for _, test := range []string{
 113                 "grpc.testing.not_exiting",
 114         } {
 115                 _, err := s.typeForName(test)
 116                 if err == nil {
 117                         t.Errorf("typeForName(%q) = _, %v, want _, <non-nil>", test, err)
 118                 }
 119         }
 120 }
 121
 122 func TestFileDescContainingExtension(t *testing.T) {
 123         for _, test := range []struct {
 124                 st     reflect.Type
 125                 extNum int32
 126                 want   *dpb.FileDescriptorProto
 127         }{
 128                 {reflect.TypeOf(pb.ToBeExtended{}), 13, fdProto2Ext},
 129                 {reflect.TypeOf(pb.ToBeExtended{}), 17, fdProto2Ext},
 130                 {reflect.TypeOf(pb.ToBeExtended{}), 19, fdProto2Ext},
 131                 {reflect.TypeOf(pb.ToBeExtended{}), 23, fdProto2Ext2},
 132                 {reflect.TypeOf(pb.ToBeExtended{}), 29, fdProto2Ext2},
 133         } {
 134                 fd, err := s.fileDescContainingExtension(test.st, test.extNum)
 135                 if err != nil || !proto.Equal(fd, test.want) {
 136                         t.Errorf("fileDescContainingExtension(%q) = %q, %v, want %q, <nil>", test.st, fd, err, test.want)
 137                 }
 138         }
 139 }
 140
 141 // intArray is used to sort []int32
 142 type intArray []int32
 143
 144 func (s intArray) Len() int           { return len(s) }
 145 func (s intArray) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
 146 func (s intArray) Less(i, j int) bool { return s[i] < s[j] }
 147
 148 func TestAllExtensionNumbersForType(t *testing.T) {
 149         for _, test := range []struct {
 150                 st   reflect.Type
 151                 want []int32
 152         }{
 153                 {reflect.TypeOf(pb.ToBeExtended{}), []int32{13, 17, 19, 23, 29}},
 154         } {
 155                 r, err := s.allExtensionNumbersForType(test.st)
 156                 sort.Sort(intArray(r))
 157                 if err != nil || !reflect.DeepEqual(r, test.want) {
 158                         t.Errorf("allExtensionNumbersForType(%q) = %v, %v, want %v, <nil>", test.st, r, err, test.want)
 159                 }
 160         }
 161 }
 162
 163 // Do end2end tests.
 164
 165 type server struct{}
 166
 167 func (s *server) Search(ctx context.Context, in *pb.SearchRequest) (*pb.SearchResponse, error) {
 168         return &pb.SearchResponse{}, nil
 169 }
 170
 171 func (s *server) StreamingSearch(stream pb.SearchService_StreamingSearchServer) error {
 172         return nil
 173 }
 174
 175 type serverV3 struct{}
 176
 177 func (s *serverV3) Search(ctx context.Context, in *pbv3.SearchRequestV3) (*pbv3.SearchResponseV3, error) {
 178         return &pbv3.SearchResponseV3{}, nil
 179 }
 180
 181 func (s *serverV3) StreamingSearch(stream pbv3.SearchServiceV3_StreamingSearchServer) error {
 182         return nil
 183 }
 184
 185 func TestReflectionEnd2end(t *testing.T) {
 186         // Start server.
 187         lis, err := net.Listen("tcp", "localhost:0")
 188         if err != nil {
 189                 t.Fatalf("failed to listen: %v", err)
 190         }
 191         s := grpc.NewServer()
 192         pb.RegisterSearchServiceServer(s, &server{})
 193         pbv3.RegisterSearchServiceV3Server(s, &serverV3{})
 194         // Register reflection service on s.
 195         Register(s)
 196         go s.Serve(lis)
 197
 198         // Create client.
 199         conn, err := grpc.Dial(lis.Addr().String(), grpc.WithInsecure())
 200         if err != nil {
 201                 t.Fatalf("cannot connect to server: %v", err)
 202         }
 203         defer conn.Close()
 204
 205         c := rpb.NewServerReflectionClient(conn)
 206         stream, err := c.ServerReflectionInfo(context.Background(), grpc.FailFast(false))
 207         if err != nil {
 208                 t.Fatalf("cannot get ServerReflectionInfo: %v", err)
 209         }
 210
 211         testFileByFilename(t, stream)
 212         testFileByFilenameError(t, stream)
 213         testFileContainingSymbol(t, stream)
 214         testFileContainingSymbolError(t, stream)
 215         testFileContainingExtension(t, stream)
 216         testFileContainingExtensionError(t, stream)
 217         testAllExtensionNumbersOfType(t, stream)
 218         testAllExtensionNumbersOfTypeError(t, stream)
 219         testListServices(t, stream)
 220
 221         s.Stop()
 222 }
 223
 224 func testFileByFilename(t *testing.T, stream rpb.ServerReflection_ServerReflectionInfoClient) {
 225         for _, test := range []struct {
 226                 filename string
 227                 want     []byte
 228         }{
 229                 {"test.proto", fdTestByte},
 230                 {"proto2.proto", fdProto2Byte},
 231                 {"proto2_ext.proto", fdProto2ExtByte},
 232         } {
 233                 if err := stream.Send(&rpb.ServerReflectionRequest{
 234                         MessageRequest: &rpb.ServerReflectionRequest_FileByFilename{
 235                                 FileByFilename: test.filename,
 236                         },
 237                 }); err != nil {
 238                         t.Fatalf("failed to send request: %v", err)
 239                 }
 240                 r, err := stream.Recv()
 241                 if err != nil {
 242                         // io.EOF is not ok.
 243                         t.Fatalf("failed to recv response: %v", err)
 244                 }
 245
 246                 switch r.MessageResponse.(type) {
 247                 case *rpb.ServerReflectionResponse_FileDescriptorResponse:
 248                         if !reflect.DeepEqual(r.GetFileDescriptorResponse().FileDescriptorProto[0], test.want) {
 249                                 t.Errorf("FileByFilename(%v)\nreceived: %q,\nwant: %q", test.filename, r.GetFileDescriptorResponse().FileDescriptorProto[0], test.want)
 250                         }
 251                 default:
 252                         t.Errorf("FileByFilename(%v) = %v, want type <ServerReflectionResponse_FileDescriptorResponse>", test.filename, r.MessageResponse)
 253                 }
 254         }
 255 }
 256
 257 func testFileByFilenameError(t *testing.T, stream rpb.ServerReflection_ServerReflectionInfoClient) {
 258         for _, test := range []string{
 259                 "test.poto",
 260                 "proo2.proto",
 261                 "proto2_et.proto",
 262         } {
 263                 if err := stream.Send(&rpb.ServerReflectionRequest{
 264                         MessageRequest: &rpb.ServerReflectionRequest_FileByFilename{
 265                                 FileByFilename: test,
 266                         },
 267                 }); err != nil {
 268                         t.Fatalf("failed to send request: %v", err)
 269                 }
 270                 r, err := stream.Recv()
 271                 if err != nil {
 272                         // io.EOF is not ok.
 273                         t.Fatalf("failed to recv response: %v", err)
 274                 }
 275
 276                 switch r.MessageResponse.(type) {
 277                 case *rpb.ServerReflectionResponse_ErrorResponse:
 278                 default:
 279                         t.Errorf("FileByFilename(%v) = %v, want type <ServerReflectionResponse_ErrorResponse>", test, r.MessageResponse)
 280                 }
 281         }
 282 }
 283
 284 func testFileContainingSymbol(t *testing.T, stream rpb.ServerReflection_ServerReflectionInfoClient) {
 285         for _, test := range []struct {
 286                 symbol string
 287                 want   []byte
 288         }{
 289                 {"grpc.testing.SearchService", fdTestByte},
 290                 {"grpc.testing.SearchService.Search", fdTestByte},
 291                 {"grpc.testing.SearchService.StreamingSearch", fdTestByte},
 292                 {"grpc.testing.SearchResponse", fdTestByte},
 293                 {"grpc.testing.ToBeExtended", fdProto2Byte},
 294                 // Test support package v3.
 295                 {"grpc.testingv3.SearchServiceV3", fdTestv3Byte},
 296                 {"grpc.testingv3.SearchServiceV3.Search", fdTestv3Byte},
 297                 {"grpc.testingv3.SearchServiceV3.StreamingSearch", fdTestv3Byte},
 298                 {"grpc.testingv3.SearchResponseV3", fdTestv3Byte},
 299         } {
 300                 if err := stream.Send(&rpb.ServerReflectionRequest{
 301                         MessageRequest: &rpb.ServerReflectionRequest_FileContainingSymbol{
 302                                 FileContainingSymbol: test.symbol,
 303                         },
 304                 }); err != nil {
 305                         t.Fatalf("failed to send request: %v", err)
 306                 }
 307                 r, err := stream.Recv()
 308                 if err != nil {
 309                         // io.EOF is not ok.
 310                         t.Fatalf("failed to recv response: %v", err)
 311                 }
 312
 313                 switch r.MessageResponse.(type) {
 314                 case *rpb.ServerReflectionResponse_FileDescriptorResponse:
 315                         if !reflect.DeepEqual(r.GetFileDescriptorResponse().FileDescriptorProto[0], test.want) {
 316                                 t.Errorf("FileContainingSymbol(%v)\nreceived: %q,\nwant: %q", test.symbol, r.GetFileDescriptorResponse().FileDescriptorProto[0], test.want)
 317                         }
 318                 default:
 319                         t.Errorf("FileContainingSymbol(%v) = %v, want type <ServerReflectionResponse_FileDescriptorResponse>", test.symbol, r.MessageResponse)
 320                 }
 321         }
 322 }
 323
 324 func testFileContainingSymbolError(t *testing.T, stream rpb.ServerReflection_ServerReflectionInfoClient) {
 325         for _, test := range []string{
 326                 "grpc.testing.SerchService",
 327                 "grpc.testing.SearchService.SearchE",
 328                 "grpc.tesing.SearchResponse",
 329                 "gpc.testing.ToBeExtended",
 330         } {
 331                 if err := stream.Send(&rpb.ServerReflectionRequest{
 332                         MessageRequest: &rpb.ServerReflectionRequest_FileContainingSymbol{
 333                                 FileContainingSymbol: test,
 334                         },
 335                 }); err != nil {
 336                         t.Fatalf("failed to send request: %v", err)
 337                 }
 338                 r, err := stream.Recv()
 339                 if err != nil {
 340                         // io.EOF is not ok.
 341                         t.Fatalf("failed to recv response: %v", err)
 342                 }
 343
 344                 switch r.MessageResponse.(type) {
 345                 case *rpb.ServerReflectionResponse_ErrorResponse:
 346                 default:
 347                         t.Errorf("FileContainingSymbol(%v) = %v, want type <ServerReflectionResponse_ErrorResponse>", test, r.MessageResponse)
 348                 }
 349         }
 350 }
 351
 352 func testFileContainingExtension(t *testing.T, stream rpb.ServerReflection_ServerReflectionInfoClient) {
 353         for _, test := range []struct {
 354                 typeName string
 355                 extNum   int32
 356                 want     []byte
 357         }{
 358                 {"grpc.testing.ToBeExtended", 13, fdProto2ExtByte},
 359                 {"grpc.testing.ToBeExtended", 17, fdProto2ExtByte},
 360                 {"grpc.testing.ToBeExtended", 19, fdProto2ExtByte},
 361                 {"grpc.testing.ToBeExtended", 23, fdProto2Ext2Byte},
 362                 {"grpc.testing.ToBeExtended", 29, fdProto2Ext2Byte},
 363         } {
 364                 if err := stream.Send(&rpb.ServerReflectionRequest{
 365                         MessageRequest: &rpb.ServerReflectionRequest_FileContainingExtension{
 366                                 FileContainingExtension: &rpb.ExtensionRequest{
 367                                         ContainingType:  test.typeName,
 368                                         ExtensionNumber: test.extNum,
 369                                 },
 370                         },
 371                 }); err != nil {
 372                         t.Fatalf("failed to send request: %v", err)
 373                 }
 374                 r, err := stream.Recv()
 375                 if err != nil {
 376                         // io.EOF is not ok.
 377                         t.Fatalf("failed to recv response: %v", err)
 378                 }
 379
 380                 switch r.MessageResponse.(type) {
 381                 case *rpb.ServerReflectionResponse_FileDescriptorResponse:
 382                         if !reflect.DeepEqual(r.GetFileDescriptorResponse().FileDescriptorProto[0], test.want) {
 383                                 t.Errorf("FileContainingExtension(%v, %v)\nreceived: %q,\nwant: %q", test.typeName, test.extNum, r.GetFileDescriptorResponse().FileDescriptorProto[0], test.want)
 384                         }
 385                 default:
 386                         t.Errorf("FileContainingExtension(%v, %v) = %v, want type <ServerReflectionResponse_FileDescriptorResponse>", test.typeName, test.extNum, r.MessageResponse)
 387                 }
 388         }
 389 }
 390
 391 func testFileContainingExtensionError(t *testing.T, stream rpb.ServerReflection_ServerReflectionInfoClient) {
 392         for _, test := range []struct {
 393                 typeName string
 394                 extNum   int32
 395         }{
 396                 {"grpc.testing.ToBExtended", 17},
 397                 {"grpc.testing.ToBeExtended", 15},
 398         } {
 399                 if err := stream.Send(&rpb.ServerReflectionRequest{
 400                         MessageRequest: &rpb.ServerReflectionRequest_FileContainingExtension{
 401                                 FileContainingExtension: &rpb.ExtensionRequest{
 402                                         ContainingType:  test.typeName,
 403                                         ExtensionNumber: test.extNum,
 404                                 },
 405                         },
 406                 }); err != nil {
 407                         t.Fatalf("failed to send request: %v", err)
 408                 }
 409                 r, err := stream.Recv()
 410                 if err != nil {
 411                         // io.EOF is not ok.
 412                         t.Fatalf("failed to recv response: %v", err)
 413                 }
 414
 415                 switch r.MessageResponse.(type) {
 416                 case *rpb.ServerReflectionResponse_ErrorResponse:
 417                 default:
 418                         t.Errorf("FileContainingExtension(%v, %v) = %v, want type <ServerReflectionResponse_FileDescriptorResponse>", test.typeName, test.extNum, r.MessageResponse)
 419                 }
 420         }
 421 }
 422
 423 func testAllExtensionNumbersOfType(t *testing.T, stream rpb.ServerReflection_ServerReflectionInfoClient) {
 424         for _, test := range []struct {
 425                 typeName string
 426                 want     []int32
 427         }{
 428                 {"grpc.testing.ToBeExtended", []int32{13, 17, 19, 23, 29}},
 429         } {
 430                 if err := stream.Send(&rpb.ServerReflectionRequest{
 431                         MessageRequest: &rpb.ServerReflectionRequest_AllExtensionNumbersOfType{
 432                                 AllExtensionNumbersOfType: test.typeName,
 433                         },
 434                 }); err != nil {
 435                         t.Fatalf("failed to send request: %v", err)
 436                 }
 437                 r, err := stream.Recv()
 438                 if err != nil {
 439                         // io.EOF is not ok.
 440                         t.Fatalf("failed to recv response: %v", err)
 441                 }
 442
 443                 switch r.MessageResponse.(type) {
 444                 case *rpb.ServerReflectionResponse_AllExtensionNumbersResponse:
 445                         extNum := r.GetAllExtensionNumbersResponse().ExtensionNumber
 446                         sort.Sort(intArray(extNum))
 447                         if r.GetAllExtensionNumbersResponse().BaseTypeName != test.typeName ||
 448                                 !reflect.DeepEqual(extNum, test.want) {
 449                                 t.Errorf("AllExtensionNumbersOfType(%v)\nreceived: %v,\nwant: {%q %v}", r.GetAllExtensionNumbersResponse(), test.typeName, test.typeName, test.want)
 450                         }
 451                 default:
 452                         t.Errorf("AllExtensionNumbersOfType(%v) = %v, want type <ServerReflectionResponse_AllExtensionNumbersResponse>", test.typeName, r.MessageResponse)
 453                 }
 454         }
 455 }
 456
 457 func testAllExtensionNumbersOfTypeError(t *testing.T, stream rpb.ServerReflection_ServerReflectionInfoClient) {
 458         for _, test := range []string{
 459                 "grpc.testing.ToBeExtendedE",
 460         } {
 461                 if err := stream.Send(&rpb.ServerReflectionRequest{
 462                         MessageRequest: &rpb.ServerReflectionRequest_AllExtensionNumbersOfType{
 463                                 AllExtensionNumbersOfType: test,
 464                         },
 465                 }); err != nil {
 466                         t.Fatalf("failed to send request: %v", err)
 467                 }
 468                 r, err := stream.Recv()
 469                 if err != nil {
 470                         // io.EOF is not ok.
 471                         t.Fatalf("failed to recv response: %v", err)
 472                 }
 473
 474                 switch r.MessageResponse.(type) {
 475                 case *rpb.ServerReflectionResponse_ErrorResponse:
 476                 default:
 477                         t.Errorf("AllExtensionNumbersOfType(%v) = %v, want type <ServerReflectionResponse_ErrorResponse>", test, r.MessageResponse)
 478                 }
 479         }
 480 }
 481
 482 func testListServices(t *testing.T, stream rpb.ServerReflection_ServerReflectionInfoClient) {
 483         if err := stream.Send(&rpb.ServerReflectionRequest{
 484                 MessageRequest: &rpb.ServerReflectionRequest_ListServices{},
 485         }); err != nil {
 486                 t.Fatalf("failed to send request: %v", err)
 487         }
 488         r, err := stream.Recv()
 489         if err != nil {
 490                 // io.EOF is not ok.
 491                 t.Fatalf("failed to recv response: %v", err)
 492         }
 493
 494         switch r.MessageResponse.(type) {
 495         case *rpb.ServerReflectionResponse_ListServicesResponse:
 496                 services := r.GetListServicesResponse().Service
 497                 want := []string{
 498                         "grpc.testingv3.SearchServiceV3",
 499                         "grpc.testing.SearchService",
 500                         "grpc.reflection.v1alpha.ServerReflection",
 501                 }
 502                 // Compare service names in response with want.
 503                 if len(services) != len(want) {
 504                         t.Errorf("= %v, want service names: %v", services, want)
 505                 }
 506                 m := make(map[string]int)
 507                 for _, e := range services {
 508                         m[e.Name]++
 509                 }
 510                 for _, e := range want {
 511                         if m[e] > 0 {
 512                                 m[e]--
 513                                 continue
 514                         }
 515                         t.Errorf("ListService\nreceived: %v,\nwant: %q", services, want)
 516                 }
 517         default:
 518                 t.Errorf("ListServices = %v, want type <ServerReflectionResponse_ListServicesResponse>", r.MessageResponse)
 519         }
 520 }