1// Copyright 2018 Google LLC 2// 3// Licensed under the Apache License, Version 2.0 (the "License"); 4// you may not use this file except in compliance with the License. 5// You may obtain a copy of the License at 6// 7// https://www.apache.org/licenses/LICENSE-2.0 8// 9// Unless required by applicable law or agreed to in writing, software 10// distributed under the License is distributed on an "AS IS" BASIS, 11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12// See the License for the specific language governing permissions and 13// limitations under the License. 14 15// AUTO-GENERATED CODE. DO NOT EDIT. 16 17package redis 18 19import ( 20 emptypb "github.com/golang/protobuf/ptypes/empty" 21 redispb "google.golang.org/genproto/googleapis/cloud/redis/v1beta1" 22 longrunningpb "google.golang.org/genproto/googleapis/longrunning" 23 field_maskpb "google.golang.org/genproto/protobuf/field_mask" 24) 25 26import ( 27 "context" 28 "flag" 29 "fmt" 30 "io" 31 "log" 32 "net" 33 "os" 34 "strings" 35 "testing" 36 37 "github.com/golang/protobuf/proto" 38 "github.com/golang/protobuf/ptypes" 39 "google.golang.org/api/option" 40 status "google.golang.org/genproto/googleapis/rpc/status" 41 "google.golang.org/grpc" 42 "google.golang.org/grpc/codes" 43 "google.golang.org/grpc/metadata" 44 gstatus "google.golang.org/grpc/status" 45) 46 47var _ = io.EOF 48var _ = ptypes.MarshalAny 49var _ status.Status 50 51type mockCloudRedisServer struct { 52 // Embed for forward compatibility. 53 // Tests will keep working if more methods are added 54 // in the future. 55 redispb.CloudRedisServer 56 57 reqs []proto.Message 58 59 // If set, all calls return this error. 60 err error 61 62 // responses to return if err == nil 63 resps []proto.Message 64} 65 66func (s *mockCloudRedisServer) ListInstances(ctx context.Context, req *redispb.ListInstancesRequest) (*redispb.ListInstancesResponse, error) { 67 md, _ := metadata.FromIncomingContext(ctx) 68 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 69 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 70 } 71 s.reqs = append(s.reqs, req) 72 if s.err != nil { 73 return nil, s.err 74 } 75 return s.resps[0].(*redispb.ListInstancesResponse), nil 76} 77 78func (s *mockCloudRedisServer) GetInstance(ctx context.Context, req *redispb.GetInstanceRequest) (*redispb.Instance, error) { 79 md, _ := metadata.FromIncomingContext(ctx) 80 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 81 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 82 } 83 s.reqs = append(s.reqs, req) 84 if s.err != nil { 85 return nil, s.err 86 } 87 return s.resps[0].(*redispb.Instance), nil 88} 89 90func (s *mockCloudRedisServer) CreateInstance(ctx context.Context, req *redispb.CreateInstanceRequest) (*longrunningpb.Operation, error) { 91 md, _ := metadata.FromIncomingContext(ctx) 92 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 93 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 94 } 95 s.reqs = append(s.reqs, req) 96 if s.err != nil { 97 return nil, s.err 98 } 99 return s.resps[0].(*longrunningpb.Operation), nil 100} 101 102func (s *mockCloudRedisServer) UpdateInstance(ctx context.Context, req *redispb.UpdateInstanceRequest) (*longrunningpb.Operation, error) { 103 md, _ := metadata.FromIncomingContext(ctx) 104 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 105 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 106 } 107 s.reqs = append(s.reqs, req) 108 if s.err != nil { 109 return nil, s.err 110 } 111 return s.resps[0].(*longrunningpb.Operation), nil 112} 113 114func (s *mockCloudRedisServer) DeleteInstance(ctx context.Context, req *redispb.DeleteInstanceRequest) (*longrunningpb.Operation, error) { 115 md, _ := metadata.FromIncomingContext(ctx) 116 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 117 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 118 } 119 s.reqs = append(s.reqs, req) 120 if s.err != nil { 121 return nil, s.err 122 } 123 return s.resps[0].(*longrunningpb.Operation), nil 124} 125 126// clientOpt is the option tests should use to connect to the test server. 127// It is initialized by TestMain. 128var clientOpt option.ClientOption 129 130var ( 131 mockCloudRedis mockCloudRedisServer 132) 133 134func TestMain(m *testing.M) { 135 flag.Parse() 136 137 serv := grpc.NewServer() 138 redispb.RegisterCloudRedisServer(serv, &mockCloudRedis) 139 140 lis, err := net.Listen("tcp", "localhost:0") 141 if err != nil { 142 log.Fatal(err) 143 } 144 go serv.Serve(lis) 145 146 conn, err := grpc.Dial(lis.Addr().String(), grpc.WithInsecure()) 147 if err != nil { 148 log.Fatal(err) 149 } 150 clientOpt = option.WithGRPCConn(conn) 151 152 os.Exit(m.Run()) 153} 154 155func TestCloudRedisListInstances(t *testing.T) { 156 var nextPageToken string = "" 157 var instancesElement *redispb.Instance = &redispb.Instance{} 158 var instances = []*redispb.Instance{instancesElement} 159 var expectedResponse = &redispb.ListInstancesResponse{ 160 NextPageToken: nextPageToken, 161 Instances: instances, 162 } 163 164 mockCloudRedis.err = nil 165 mockCloudRedis.reqs = nil 166 167 mockCloudRedis.resps = append(mockCloudRedis.resps[:0], expectedResponse) 168 169 var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]") 170 var request = &redispb.ListInstancesRequest{ 171 Parent: formattedParent, 172 } 173 174 c, err := NewCloudRedisClient(context.Background(), clientOpt) 175 if err != nil { 176 t.Fatal(err) 177 } 178 179 resp, err := c.ListInstances(context.Background(), request).Next() 180 181 if err != nil { 182 t.Fatal(err) 183 } 184 185 if want, got := request, mockCloudRedis.reqs[0]; !proto.Equal(want, got) { 186 t.Errorf("wrong request %q, want %q", got, want) 187 } 188 189 want := (interface{})(expectedResponse.Instances[0]) 190 got := (interface{})(resp) 191 var ok bool 192 193 switch want := (want).(type) { 194 case proto.Message: 195 ok = proto.Equal(want, got.(proto.Message)) 196 default: 197 ok = want == got 198 } 199 if !ok { 200 t.Errorf("wrong response %q, want %q)", got, want) 201 } 202} 203 204func TestCloudRedisListInstancesError(t *testing.T) { 205 errCode := codes.PermissionDenied 206 mockCloudRedis.err = gstatus.Error(errCode, "test error") 207 208 var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]") 209 var request = &redispb.ListInstancesRequest{ 210 Parent: formattedParent, 211 } 212 213 c, err := NewCloudRedisClient(context.Background(), clientOpt) 214 if err != nil { 215 t.Fatal(err) 216 } 217 218 resp, err := c.ListInstances(context.Background(), request).Next() 219 220 if st, ok := gstatus.FromError(err); !ok { 221 t.Errorf("got error %v, expected grpc error", err) 222 } else if c := st.Code(); c != errCode { 223 t.Errorf("got error code %q, want %q", c, errCode) 224 } 225 _ = resp 226} 227func TestCloudRedisGetInstance(t *testing.T) { 228 var name2 string = "name2-1052831874" 229 var displayName string = "displayName1615086568" 230 var locationId string = "locationId552319461" 231 var alternativeLocationId string = "alternativeLocationId-718920621" 232 var redisVersion string = "redisVersion-685310444" 233 var reservedIpRange string = "reservedIpRange-1082940580" 234 var host string = "host3208616" 235 var port int32 = 3446913 236 var currentLocationId string = "currentLocationId1312712735" 237 var statusMessage string = "statusMessage-239442758" 238 var memorySizeGb int32 = 34199707 239 var authorizedNetwork string = "authorizedNetwork-1733809270" 240 var expectedResponse = &redispb.Instance{ 241 Name: name2, 242 DisplayName: displayName, 243 LocationId: locationId, 244 AlternativeLocationId: alternativeLocationId, 245 RedisVersion: redisVersion, 246 ReservedIpRange: reservedIpRange, 247 Host: host, 248 Port: port, 249 CurrentLocationId: currentLocationId, 250 StatusMessage: statusMessage, 251 MemorySizeGb: memorySizeGb, 252 AuthorizedNetwork: authorizedNetwork, 253 } 254 255 mockCloudRedis.err = nil 256 mockCloudRedis.reqs = nil 257 258 mockCloudRedis.resps = append(mockCloudRedis.resps[:0], expectedResponse) 259 260 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/instances/%s", "[PROJECT]", "[LOCATION]", "[INSTANCE]") 261 var request = &redispb.GetInstanceRequest{ 262 Name: formattedName, 263 } 264 265 c, err := NewCloudRedisClient(context.Background(), clientOpt) 266 if err != nil { 267 t.Fatal(err) 268 } 269 270 resp, err := c.GetInstance(context.Background(), request) 271 272 if err != nil { 273 t.Fatal(err) 274 } 275 276 if want, got := request, mockCloudRedis.reqs[0]; !proto.Equal(want, got) { 277 t.Errorf("wrong request %q, want %q", got, want) 278 } 279 280 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 281 t.Errorf("wrong response %q, want %q)", got, want) 282 } 283} 284 285func TestCloudRedisGetInstanceError(t *testing.T) { 286 errCode := codes.PermissionDenied 287 mockCloudRedis.err = gstatus.Error(errCode, "test error") 288 289 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/instances/%s", "[PROJECT]", "[LOCATION]", "[INSTANCE]") 290 var request = &redispb.GetInstanceRequest{ 291 Name: formattedName, 292 } 293 294 c, err := NewCloudRedisClient(context.Background(), clientOpt) 295 if err != nil { 296 t.Fatal(err) 297 } 298 299 resp, err := c.GetInstance(context.Background(), request) 300 301 if st, ok := gstatus.FromError(err); !ok { 302 t.Errorf("got error %v, expected grpc error", err) 303 } else if c := st.Code(); c != errCode { 304 t.Errorf("got error code %q, want %q", c, errCode) 305 } 306 _ = resp 307} 308func TestCloudRedisCreateInstance(t *testing.T) { 309 var name string = "name3373707" 310 var displayName string = "displayName1615086568" 311 var locationId string = "locationId552319461" 312 var alternativeLocationId string = "alternativeLocationId-718920621" 313 var redisVersion string = "redisVersion-685310444" 314 var reservedIpRange string = "reservedIpRange-1082940580" 315 var host string = "host3208616" 316 var port int32 = 3446913 317 var currentLocationId string = "currentLocationId1312712735" 318 var statusMessage string = "statusMessage-239442758" 319 var memorySizeGb2 int32 = 1493816946 320 var authorizedNetwork string = "authorizedNetwork-1733809270" 321 var expectedResponse = &redispb.Instance{ 322 Name: name, 323 DisplayName: displayName, 324 LocationId: locationId, 325 AlternativeLocationId: alternativeLocationId, 326 RedisVersion: redisVersion, 327 ReservedIpRange: reservedIpRange, 328 Host: host, 329 Port: port, 330 CurrentLocationId: currentLocationId, 331 StatusMessage: statusMessage, 332 MemorySizeGb: memorySizeGb2, 333 AuthorizedNetwork: authorizedNetwork, 334 } 335 336 mockCloudRedis.err = nil 337 mockCloudRedis.reqs = nil 338 339 any, err := ptypes.MarshalAny(expectedResponse) 340 if err != nil { 341 t.Fatal(err) 342 } 343 mockCloudRedis.resps = append(mockCloudRedis.resps[:0], &longrunningpb.Operation{ 344 Name: "longrunning-test", 345 Done: true, 346 Result: &longrunningpb.Operation_Response{Response: any}, 347 }) 348 349 var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]") 350 var instanceId string = "test_instance" 351 var tier redispb.Instance_Tier = redispb.Instance_BASIC 352 var memorySizeGb int32 = 1 353 var instance = &redispb.Instance{ 354 Tier: tier, 355 MemorySizeGb: memorySizeGb, 356 } 357 var request = &redispb.CreateInstanceRequest{ 358 Parent: formattedParent, 359 InstanceId: instanceId, 360 Instance: instance, 361 } 362 363 c, err := NewCloudRedisClient(context.Background(), clientOpt) 364 if err != nil { 365 t.Fatal(err) 366 } 367 368 respLRO, err := c.CreateInstance(context.Background(), request) 369 if err != nil { 370 t.Fatal(err) 371 } 372 resp, err := respLRO.Wait(context.Background()) 373 374 if err != nil { 375 t.Fatal(err) 376 } 377 378 if want, got := request, mockCloudRedis.reqs[0]; !proto.Equal(want, got) { 379 t.Errorf("wrong request %q, want %q", got, want) 380 } 381 382 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 383 t.Errorf("wrong response %q, want %q)", got, want) 384 } 385} 386 387func TestCloudRedisCreateInstanceError(t *testing.T) { 388 errCode := codes.PermissionDenied 389 mockCloudRedis.err = nil 390 mockCloudRedis.resps = append(mockCloudRedis.resps[:0], &longrunningpb.Operation{ 391 Name: "longrunning-test", 392 Done: true, 393 Result: &longrunningpb.Operation_Error{ 394 Error: &status.Status{ 395 Code: int32(errCode), 396 Message: "test error", 397 }, 398 }, 399 }) 400 401 var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]") 402 var instanceId string = "test_instance" 403 var tier redispb.Instance_Tier = redispb.Instance_BASIC 404 var memorySizeGb int32 = 1 405 var instance = &redispb.Instance{ 406 Tier: tier, 407 MemorySizeGb: memorySizeGb, 408 } 409 var request = &redispb.CreateInstanceRequest{ 410 Parent: formattedParent, 411 InstanceId: instanceId, 412 Instance: instance, 413 } 414 415 c, err := NewCloudRedisClient(context.Background(), clientOpt) 416 if err != nil { 417 t.Fatal(err) 418 } 419 420 respLRO, err := c.CreateInstance(context.Background(), request) 421 if err != nil { 422 t.Fatal(err) 423 } 424 resp, err := respLRO.Wait(context.Background()) 425 426 if st, ok := gstatus.FromError(err); !ok { 427 t.Errorf("got error %v, expected grpc error", err) 428 } else if c := st.Code(); c != errCode { 429 t.Errorf("got error code %q, want %q", c, errCode) 430 } 431 _ = resp 432} 433func TestCloudRedisUpdateInstance(t *testing.T) { 434 var name string = "name3373707" 435 var displayName2 string = "displayName21615000987" 436 var locationId string = "locationId552319461" 437 var alternativeLocationId string = "alternativeLocationId-718920621" 438 var redisVersion string = "redisVersion-685310444" 439 var reservedIpRange string = "reservedIpRange-1082940580" 440 var host string = "host3208616" 441 var port int32 = 3446913 442 var currentLocationId string = "currentLocationId1312712735" 443 var statusMessage string = "statusMessage-239442758" 444 var memorySizeGb2 int32 = 1493816946 445 var authorizedNetwork string = "authorizedNetwork-1733809270" 446 var expectedResponse = &redispb.Instance{ 447 Name: name, 448 DisplayName: displayName2, 449 LocationId: locationId, 450 AlternativeLocationId: alternativeLocationId, 451 RedisVersion: redisVersion, 452 ReservedIpRange: reservedIpRange, 453 Host: host, 454 Port: port, 455 CurrentLocationId: currentLocationId, 456 StatusMessage: statusMessage, 457 MemorySizeGb: memorySizeGb2, 458 AuthorizedNetwork: authorizedNetwork, 459 } 460 461 mockCloudRedis.err = nil 462 mockCloudRedis.reqs = nil 463 464 any, err := ptypes.MarshalAny(expectedResponse) 465 if err != nil { 466 t.Fatal(err) 467 } 468 mockCloudRedis.resps = append(mockCloudRedis.resps[:0], &longrunningpb.Operation{ 469 Name: "longrunning-test", 470 Done: true, 471 Result: &longrunningpb.Operation_Response{Response: any}, 472 }) 473 474 var pathsElement string = "display_name" 475 var pathsElement2 string = "memory_size_gb" 476 var paths = []string{pathsElement, pathsElement2} 477 var updateMask = &field_maskpb.FieldMask{ 478 Paths: paths, 479 } 480 var displayName string = "UpdatedDisplayName" 481 var memorySizeGb int32 = 4 482 var instance = &redispb.Instance{ 483 DisplayName: displayName, 484 MemorySizeGb: memorySizeGb, 485 } 486 var request = &redispb.UpdateInstanceRequest{ 487 UpdateMask: updateMask, 488 Instance: instance, 489 } 490 491 c, err := NewCloudRedisClient(context.Background(), clientOpt) 492 if err != nil { 493 t.Fatal(err) 494 } 495 496 respLRO, err := c.UpdateInstance(context.Background(), request) 497 if err != nil { 498 t.Fatal(err) 499 } 500 resp, err := respLRO.Wait(context.Background()) 501 502 if err != nil { 503 t.Fatal(err) 504 } 505 506 if want, got := request, mockCloudRedis.reqs[0]; !proto.Equal(want, got) { 507 t.Errorf("wrong request %q, want %q", got, want) 508 } 509 510 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 511 t.Errorf("wrong response %q, want %q)", got, want) 512 } 513} 514 515func TestCloudRedisUpdateInstanceError(t *testing.T) { 516 errCode := codes.PermissionDenied 517 mockCloudRedis.err = nil 518 mockCloudRedis.resps = append(mockCloudRedis.resps[:0], &longrunningpb.Operation{ 519 Name: "longrunning-test", 520 Done: true, 521 Result: &longrunningpb.Operation_Error{ 522 Error: &status.Status{ 523 Code: int32(errCode), 524 Message: "test error", 525 }, 526 }, 527 }) 528 529 var pathsElement string = "display_name" 530 var pathsElement2 string = "memory_size_gb" 531 var paths = []string{pathsElement, pathsElement2} 532 var updateMask = &field_maskpb.FieldMask{ 533 Paths: paths, 534 } 535 var displayName string = "UpdatedDisplayName" 536 var memorySizeGb int32 = 4 537 var instance = &redispb.Instance{ 538 DisplayName: displayName, 539 MemorySizeGb: memorySizeGb, 540 } 541 var request = &redispb.UpdateInstanceRequest{ 542 UpdateMask: updateMask, 543 Instance: instance, 544 } 545 546 c, err := NewCloudRedisClient(context.Background(), clientOpt) 547 if err != nil { 548 t.Fatal(err) 549 } 550 551 respLRO, err := c.UpdateInstance(context.Background(), request) 552 if err != nil { 553 t.Fatal(err) 554 } 555 resp, err := respLRO.Wait(context.Background()) 556 557 if st, ok := gstatus.FromError(err); !ok { 558 t.Errorf("got error %v, expected grpc error", err) 559 } else if c := st.Code(); c != errCode { 560 t.Errorf("got error code %q, want %q", c, errCode) 561 } 562 _ = resp 563} 564func TestCloudRedisDeleteInstance(t *testing.T) { 565 var expectedResponse *emptypb.Empty = &emptypb.Empty{} 566 567 mockCloudRedis.err = nil 568 mockCloudRedis.reqs = nil 569 570 any, err := ptypes.MarshalAny(expectedResponse) 571 if err != nil { 572 t.Fatal(err) 573 } 574 mockCloudRedis.resps = append(mockCloudRedis.resps[:0], &longrunningpb.Operation{ 575 Name: "longrunning-test", 576 Done: true, 577 Result: &longrunningpb.Operation_Response{Response: any}, 578 }) 579 580 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/instances/%s", "[PROJECT]", "[LOCATION]", "[INSTANCE]") 581 var request = &redispb.DeleteInstanceRequest{ 582 Name: formattedName, 583 } 584 585 c, err := NewCloudRedisClient(context.Background(), clientOpt) 586 if err != nil { 587 t.Fatal(err) 588 } 589 590 respLRO, err := c.DeleteInstance(context.Background(), request) 591 if err != nil { 592 t.Fatal(err) 593 } 594 err = respLRO.Wait(context.Background()) 595 596 if err != nil { 597 t.Fatal(err) 598 } 599 600 if want, got := request, mockCloudRedis.reqs[0]; !proto.Equal(want, got) { 601 t.Errorf("wrong request %q, want %q", got, want) 602 } 603 604} 605 606func TestCloudRedisDeleteInstanceError(t *testing.T) { 607 errCode := codes.PermissionDenied 608 mockCloudRedis.err = nil 609 mockCloudRedis.resps = append(mockCloudRedis.resps[:0], &longrunningpb.Operation{ 610 Name: "longrunning-test", 611 Done: true, 612 Result: &longrunningpb.Operation_Error{ 613 Error: &status.Status{ 614 Code: int32(errCode), 615 Message: "test error", 616 }, 617 }, 618 }) 619 620 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/instances/%s", "[PROJECT]", "[LOCATION]", "[INSTANCE]") 621 var request = &redispb.DeleteInstanceRequest{ 622 Name: formattedName, 623 } 624 625 c, err := NewCloudRedisClient(context.Background(), clientOpt) 626 if err != nil { 627 t.Fatal(err) 628 } 629 630 respLRO, err := c.DeleteInstance(context.Background(), request) 631 if err != nil { 632 t.Fatal(err) 633 } 634 err = respLRO.Wait(context.Background()) 635 636 if st, ok := gstatus.FromError(err); !ok { 637 t.Errorf("got error %v, expected grpc error", err) 638 } else if c := st.Code(); c != errCode { 639 t.Errorf("got error code %q, want %q", c, errCode) 640 } 641} 642