1// Copyright 2020 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// Code generated by gapic-generator. DO NOT EDIT. 16 17package pubsub 18 19import ( 20 "context" 21 "flag" 22 "fmt" 23 "io" 24 "log" 25 "net" 26 "os" 27 "strings" 28 "testing" 29 30 "google.golang.org/api/option" 31 pubsubpb "google.golang.org/genproto/googleapis/pubsub/v1" 32 field_maskpb "google.golang.org/genproto/protobuf/field_mask" 33 "google.golang.org/protobuf/proto" 34 "google.golang.org/protobuf/types/known/emptypb" 35 "google.golang.org/protobuf/types/known/timestamppb" 36 37 status "google.golang.org/genproto/googleapis/rpc/status" 38 "google.golang.org/grpc" 39 "google.golang.org/grpc/codes" 40 "google.golang.org/grpc/metadata" 41 42 gstatus "google.golang.org/grpc/status" 43) 44 45var _ = io.EOF 46var _ status.Status 47 48type mockPublisherServer struct { 49 // Embed for forward compatibility. 50 // Tests will keep working if more methods are added 51 // in the future. 52 pubsubpb.PublisherServer 53 54 reqs []proto.Message 55 56 // If set, all calls return this error. 57 err error 58 59 // responses to return if err == nil 60 resps []proto.Message 61} 62 63func (s *mockPublisherServer) CreateTopic(ctx context.Context, req *pubsubpb.Topic) (*pubsubpb.Topic, error) { 64 md, _ := metadata.FromIncomingContext(ctx) 65 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 66 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 67 } 68 s.reqs = append(s.reqs, req) 69 if s.err != nil { 70 return nil, s.err 71 } 72 return s.resps[0].(*pubsubpb.Topic), nil 73} 74 75func (s *mockPublisherServer) UpdateTopic(ctx context.Context, req *pubsubpb.UpdateTopicRequest) (*pubsubpb.Topic, error) { 76 md, _ := metadata.FromIncomingContext(ctx) 77 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 78 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 79 } 80 s.reqs = append(s.reqs, req) 81 if s.err != nil { 82 return nil, s.err 83 } 84 return s.resps[0].(*pubsubpb.Topic), nil 85} 86 87func (s *mockPublisherServer) Publish(ctx context.Context, req *pubsubpb.PublishRequest) (*pubsubpb.PublishResponse, error) { 88 md, _ := metadata.FromIncomingContext(ctx) 89 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 90 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 91 } 92 s.reqs = append(s.reqs, req) 93 if s.err != nil { 94 return nil, s.err 95 } 96 return s.resps[0].(*pubsubpb.PublishResponse), nil 97} 98 99func (s *mockPublisherServer) GetTopic(ctx context.Context, req *pubsubpb.GetTopicRequest) (*pubsubpb.Topic, error) { 100 md, _ := metadata.FromIncomingContext(ctx) 101 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 102 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 103 } 104 s.reqs = append(s.reqs, req) 105 if s.err != nil { 106 return nil, s.err 107 } 108 return s.resps[0].(*pubsubpb.Topic), nil 109} 110 111func (s *mockPublisherServer) ListTopics(ctx context.Context, req *pubsubpb.ListTopicsRequest) (*pubsubpb.ListTopicsResponse, error) { 112 md, _ := metadata.FromIncomingContext(ctx) 113 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 114 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 115 } 116 s.reqs = append(s.reqs, req) 117 if s.err != nil { 118 return nil, s.err 119 } 120 return s.resps[0].(*pubsubpb.ListTopicsResponse), nil 121} 122 123func (s *mockPublisherServer) ListTopicSubscriptions(ctx context.Context, req *pubsubpb.ListTopicSubscriptionsRequest) (*pubsubpb.ListTopicSubscriptionsResponse, error) { 124 md, _ := metadata.FromIncomingContext(ctx) 125 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 126 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 127 } 128 s.reqs = append(s.reqs, req) 129 if s.err != nil { 130 return nil, s.err 131 } 132 return s.resps[0].(*pubsubpb.ListTopicSubscriptionsResponse), nil 133} 134 135func (s *mockPublisherServer) DeleteTopic(ctx context.Context, req *pubsubpb.DeleteTopicRequest) (*emptypb.Empty, error) { 136 md, _ := metadata.FromIncomingContext(ctx) 137 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 138 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 139 } 140 s.reqs = append(s.reqs, req) 141 if s.err != nil { 142 return nil, s.err 143 } 144 return s.resps[0].(*emptypb.Empty), nil 145} 146 147type mockSubscriberServer struct { 148 // Embed for forward compatibility. 149 // Tests will keep working if more methods are added 150 // in the future. 151 pubsubpb.SubscriberServer 152 153 reqs []proto.Message 154 155 // If set, all calls return this error. 156 err error 157 158 // responses to return if err == nil 159 resps []proto.Message 160} 161 162func (s *mockSubscriberServer) CreateSubscription(ctx context.Context, req *pubsubpb.Subscription) (*pubsubpb.Subscription, error) { 163 md, _ := metadata.FromIncomingContext(ctx) 164 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 165 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 166 } 167 s.reqs = append(s.reqs, req) 168 if s.err != nil { 169 return nil, s.err 170 } 171 return s.resps[0].(*pubsubpb.Subscription), nil 172} 173 174func (s *mockSubscriberServer) GetSubscription(ctx context.Context, req *pubsubpb.GetSubscriptionRequest) (*pubsubpb.Subscription, error) { 175 md, _ := metadata.FromIncomingContext(ctx) 176 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 177 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 178 } 179 s.reqs = append(s.reqs, req) 180 if s.err != nil { 181 return nil, s.err 182 } 183 return s.resps[0].(*pubsubpb.Subscription), nil 184} 185 186func (s *mockSubscriberServer) UpdateSubscription(ctx context.Context, req *pubsubpb.UpdateSubscriptionRequest) (*pubsubpb.Subscription, error) { 187 md, _ := metadata.FromIncomingContext(ctx) 188 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 189 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 190 } 191 s.reqs = append(s.reqs, req) 192 if s.err != nil { 193 return nil, s.err 194 } 195 return s.resps[0].(*pubsubpb.Subscription), nil 196} 197 198func (s *mockSubscriberServer) ListSubscriptions(ctx context.Context, req *pubsubpb.ListSubscriptionsRequest) (*pubsubpb.ListSubscriptionsResponse, error) { 199 md, _ := metadata.FromIncomingContext(ctx) 200 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 201 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 202 } 203 s.reqs = append(s.reqs, req) 204 if s.err != nil { 205 return nil, s.err 206 } 207 return s.resps[0].(*pubsubpb.ListSubscriptionsResponse), nil 208} 209 210func (s *mockSubscriberServer) DeleteSubscription(ctx context.Context, req *pubsubpb.DeleteSubscriptionRequest) (*emptypb.Empty, error) { 211 md, _ := metadata.FromIncomingContext(ctx) 212 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 213 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 214 } 215 s.reqs = append(s.reqs, req) 216 if s.err != nil { 217 return nil, s.err 218 } 219 return s.resps[0].(*emptypb.Empty), nil 220} 221 222func (s *mockSubscriberServer) ModifyAckDeadline(ctx context.Context, req *pubsubpb.ModifyAckDeadlineRequest) (*emptypb.Empty, error) { 223 md, _ := metadata.FromIncomingContext(ctx) 224 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 225 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 226 } 227 s.reqs = append(s.reqs, req) 228 if s.err != nil { 229 return nil, s.err 230 } 231 return s.resps[0].(*emptypb.Empty), nil 232} 233 234func (s *mockSubscriberServer) Acknowledge(ctx context.Context, req *pubsubpb.AcknowledgeRequest) (*emptypb.Empty, error) { 235 md, _ := metadata.FromIncomingContext(ctx) 236 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 237 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 238 } 239 s.reqs = append(s.reqs, req) 240 if s.err != nil { 241 return nil, s.err 242 } 243 return s.resps[0].(*emptypb.Empty), nil 244} 245 246func (s *mockSubscriberServer) Pull(ctx context.Context, req *pubsubpb.PullRequest) (*pubsubpb.PullResponse, error) { 247 md, _ := metadata.FromIncomingContext(ctx) 248 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 249 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 250 } 251 s.reqs = append(s.reqs, req) 252 if s.err != nil { 253 return nil, s.err 254 } 255 return s.resps[0].(*pubsubpb.PullResponse), nil 256} 257 258func (s *mockSubscriberServer) StreamingPull(stream pubsubpb.Subscriber_StreamingPullServer) error { 259 md, _ := metadata.FromIncomingContext(stream.Context()) 260 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 261 return fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 262 } 263 for { 264 if req, err := stream.Recv(); err == io.EOF { 265 break 266 } else if err != nil { 267 return err 268 } else { 269 s.reqs = append(s.reqs, req) 270 } 271 } 272 if s.err != nil { 273 return s.err 274 } 275 for _, v := range s.resps { 276 if err := stream.Send(v.(*pubsubpb.StreamingPullResponse)); err != nil { 277 return err 278 } 279 } 280 return nil 281} 282 283func (s *mockSubscriberServer) ModifyPushConfig(ctx context.Context, req *pubsubpb.ModifyPushConfigRequest) (*emptypb.Empty, error) { 284 md, _ := metadata.FromIncomingContext(ctx) 285 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 286 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 287 } 288 s.reqs = append(s.reqs, req) 289 if s.err != nil { 290 return nil, s.err 291 } 292 return s.resps[0].(*emptypb.Empty), nil 293} 294 295func (s *mockSubscriberServer) ListSnapshots(ctx context.Context, req *pubsubpb.ListSnapshotsRequest) (*pubsubpb.ListSnapshotsResponse, error) { 296 md, _ := metadata.FromIncomingContext(ctx) 297 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 298 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 299 } 300 s.reqs = append(s.reqs, req) 301 if s.err != nil { 302 return nil, s.err 303 } 304 return s.resps[0].(*pubsubpb.ListSnapshotsResponse), nil 305} 306 307func (s *mockSubscriberServer) CreateSnapshot(ctx context.Context, req *pubsubpb.CreateSnapshotRequest) (*pubsubpb.Snapshot, error) { 308 md, _ := metadata.FromIncomingContext(ctx) 309 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 310 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 311 } 312 s.reqs = append(s.reqs, req) 313 if s.err != nil { 314 return nil, s.err 315 } 316 return s.resps[0].(*pubsubpb.Snapshot), nil 317} 318 319func (s *mockSubscriberServer) UpdateSnapshot(ctx context.Context, req *pubsubpb.UpdateSnapshotRequest) (*pubsubpb.Snapshot, error) { 320 md, _ := metadata.FromIncomingContext(ctx) 321 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 322 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 323 } 324 s.reqs = append(s.reqs, req) 325 if s.err != nil { 326 return nil, s.err 327 } 328 return s.resps[0].(*pubsubpb.Snapshot), nil 329} 330 331func (s *mockSubscriberServer) DeleteSnapshot(ctx context.Context, req *pubsubpb.DeleteSnapshotRequest) (*emptypb.Empty, error) { 332 md, _ := metadata.FromIncomingContext(ctx) 333 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 334 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 335 } 336 s.reqs = append(s.reqs, req) 337 if s.err != nil { 338 return nil, s.err 339 } 340 return s.resps[0].(*emptypb.Empty), nil 341} 342 343func (s *mockSubscriberServer) Seek(ctx context.Context, req *pubsubpb.SeekRequest) (*pubsubpb.SeekResponse, error) { 344 md, _ := metadata.FromIncomingContext(ctx) 345 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 346 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 347 } 348 s.reqs = append(s.reqs, req) 349 if s.err != nil { 350 return nil, s.err 351 } 352 return s.resps[0].(*pubsubpb.SeekResponse), nil 353} 354 355// clientOpt is the option tests should use to connect to the test server. 356// It is initialized by TestMain. 357var clientOpt option.ClientOption 358 359var ( 360 mockPublisher mockPublisherServer 361 mockSubscriber mockSubscriberServer 362) 363 364func TestMain(m *testing.M) { 365 flag.Parse() 366 367 serv := grpc.NewServer() 368 pubsubpb.RegisterPublisherServer(serv, &mockPublisher) 369 pubsubpb.RegisterSubscriberServer(serv, &mockSubscriber) 370 371 lis, err := net.Listen("tcp", "localhost:0") 372 if err != nil { 373 log.Fatal(err) 374 } 375 go serv.Serve(lis) 376 377 conn, err := grpc.Dial(lis.Addr().String(), grpc.WithInsecure()) 378 if err != nil { 379 log.Fatal(err) 380 } 381 clientOpt = option.WithGRPCConn(conn) 382 383 os.Exit(m.Run()) 384} 385 386func TestPublisherCreateTopic(t *testing.T) { 387 var name2 string = "name2-1052831874" 388 var kmsKeyName string = "kmsKeyName2094986649" 389 var expectedResponse = &pubsubpb.Topic{ 390 Name: name2, 391 KmsKeyName: kmsKeyName, 392 } 393 394 mockPublisher.err = nil 395 mockPublisher.reqs = nil 396 397 mockPublisher.resps = append(mockPublisher.resps[:0], expectedResponse) 398 399 var formattedName string = fmt.Sprintf("projects/%s/topics/%s", "[PROJECT]", "[TOPIC]") 400 var request = &pubsubpb.Topic{ 401 Name: formattedName, 402 } 403 404 c, err := NewPublisherClient(context.Background(), clientOpt) 405 if err != nil { 406 t.Fatal(err) 407 } 408 409 resp, err := c.CreateTopic(context.Background(), request) 410 411 if err != nil { 412 t.Fatal(err) 413 } 414 415 if want, got := request, mockPublisher.reqs[0]; !proto.Equal(want, got) { 416 t.Errorf("wrong request %q, want %q", got, want) 417 } 418 419 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 420 t.Errorf("wrong response %q, want %q)", got, want) 421 } 422} 423 424func TestPublisherCreateTopicError(t *testing.T) { 425 errCode := codes.PermissionDenied 426 mockPublisher.err = gstatus.Error(errCode, "test error") 427 428 var formattedName string = fmt.Sprintf("projects/%s/topics/%s", "[PROJECT]", "[TOPIC]") 429 var request = &pubsubpb.Topic{ 430 Name: formattedName, 431 } 432 433 c, err := NewPublisherClient(context.Background(), clientOpt) 434 if err != nil { 435 t.Fatal(err) 436 } 437 438 resp, err := c.CreateTopic(context.Background(), request) 439 440 if st, ok := gstatus.FromError(err); !ok { 441 t.Errorf("got error %v, expected grpc error", err) 442 } else if c := st.Code(); c != errCode { 443 t.Errorf("got error code %q, want %q", c, errCode) 444 } 445 _ = resp 446} 447func TestPublisherUpdateTopic(t *testing.T) { 448 var name string = "name3373707" 449 var kmsKeyName string = "kmsKeyName2094986649" 450 var expectedResponse = &pubsubpb.Topic{ 451 Name: name, 452 KmsKeyName: kmsKeyName, 453 } 454 455 mockPublisher.err = nil 456 mockPublisher.reqs = nil 457 458 mockPublisher.resps = append(mockPublisher.resps[:0], expectedResponse) 459 460 var topic *pubsubpb.Topic = &pubsubpb.Topic{} 461 var updateMask *field_maskpb.FieldMask = &field_maskpb.FieldMask{} 462 var request = &pubsubpb.UpdateTopicRequest{ 463 Topic: topic, 464 UpdateMask: updateMask, 465 } 466 467 c, err := NewPublisherClient(context.Background(), clientOpt) 468 if err != nil { 469 t.Fatal(err) 470 } 471 472 resp, err := c.UpdateTopic(context.Background(), request) 473 474 if err != nil { 475 t.Fatal(err) 476 } 477 478 if want, got := request, mockPublisher.reqs[0]; !proto.Equal(want, got) { 479 t.Errorf("wrong request %q, want %q", got, want) 480 } 481 482 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 483 t.Errorf("wrong response %q, want %q)", got, want) 484 } 485} 486 487func TestPublisherUpdateTopicError(t *testing.T) { 488 errCode := codes.PermissionDenied 489 mockPublisher.err = gstatus.Error(errCode, "test error") 490 491 var topic *pubsubpb.Topic = &pubsubpb.Topic{} 492 var updateMask *field_maskpb.FieldMask = &field_maskpb.FieldMask{} 493 var request = &pubsubpb.UpdateTopicRequest{ 494 Topic: topic, 495 UpdateMask: updateMask, 496 } 497 498 c, err := NewPublisherClient(context.Background(), clientOpt) 499 if err != nil { 500 t.Fatal(err) 501 } 502 503 resp, err := c.UpdateTopic(context.Background(), request) 504 505 if st, ok := gstatus.FromError(err); !ok { 506 t.Errorf("got error %v, expected grpc error", err) 507 } else if c := st.Code(); c != errCode { 508 t.Errorf("got error code %q, want %q", c, errCode) 509 } 510 _ = resp 511} 512func TestPublisherPublish(t *testing.T) { 513 var messageIdsElement string = "messageIdsElement-744837059" 514 var messageIds = []string{messageIdsElement} 515 var expectedResponse = &pubsubpb.PublishResponse{ 516 MessageIds: messageIds, 517 } 518 519 mockPublisher.err = nil 520 mockPublisher.reqs = nil 521 522 mockPublisher.resps = append(mockPublisher.resps[:0], expectedResponse) 523 524 var formattedTopic string = fmt.Sprintf("projects/%s/topics/%s", "[PROJECT]", "[TOPIC]") 525 var data []byte = []byte("-86") 526 var messagesElement = &pubsubpb.PubsubMessage{ 527 Data: data, 528 } 529 var messages = []*pubsubpb.PubsubMessage{messagesElement} 530 var request = &pubsubpb.PublishRequest{ 531 Topic: formattedTopic, 532 Messages: messages, 533 } 534 535 c, err := NewPublisherClient(context.Background(), clientOpt) 536 if err != nil { 537 t.Fatal(err) 538 } 539 540 resp, err := c.Publish(context.Background(), request) 541 542 if err != nil { 543 t.Fatal(err) 544 } 545 546 if want, got := request, mockPublisher.reqs[0]; !proto.Equal(want, got) { 547 t.Errorf("wrong request %q, want %q", got, want) 548 } 549 550 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 551 t.Errorf("wrong response %q, want %q)", got, want) 552 } 553} 554 555func TestPublisherPublishError(t *testing.T) { 556 errCode := codes.PermissionDenied 557 mockPublisher.err = gstatus.Error(errCode, "test error") 558 559 var formattedTopic string = fmt.Sprintf("projects/%s/topics/%s", "[PROJECT]", "[TOPIC]") 560 var data []byte = []byte("-86") 561 var messagesElement = &pubsubpb.PubsubMessage{ 562 Data: data, 563 } 564 var messages = []*pubsubpb.PubsubMessage{messagesElement} 565 var request = &pubsubpb.PublishRequest{ 566 Topic: formattedTopic, 567 Messages: messages, 568 } 569 570 c, err := NewPublisherClient(context.Background(), clientOpt) 571 if err != nil { 572 t.Fatal(err) 573 } 574 575 resp, err := c.Publish(context.Background(), request) 576 577 if st, ok := gstatus.FromError(err); !ok { 578 t.Errorf("got error %v, expected grpc error", err) 579 } else if c := st.Code(); c != errCode { 580 t.Errorf("got error code %q, want %q", c, errCode) 581 } 582 _ = resp 583} 584func TestPublisherGetTopic(t *testing.T) { 585 var name string = "name3373707" 586 var kmsKeyName string = "kmsKeyName2094986649" 587 var expectedResponse = &pubsubpb.Topic{ 588 Name: name, 589 KmsKeyName: kmsKeyName, 590 } 591 592 mockPublisher.err = nil 593 mockPublisher.reqs = nil 594 595 mockPublisher.resps = append(mockPublisher.resps[:0], expectedResponse) 596 597 var formattedTopic string = fmt.Sprintf("projects/%s/topics/%s", "[PROJECT]", "[TOPIC]") 598 var request = &pubsubpb.GetTopicRequest{ 599 Topic: formattedTopic, 600 } 601 602 c, err := NewPublisherClient(context.Background(), clientOpt) 603 if err != nil { 604 t.Fatal(err) 605 } 606 607 resp, err := c.GetTopic(context.Background(), request) 608 609 if err != nil { 610 t.Fatal(err) 611 } 612 613 if want, got := request, mockPublisher.reqs[0]; !proto.Equal(want, got) { 614 t.Errorf("wrong request %q, want %q", got, want) 615 } 616 617 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 618 t.Errorf("wrong response %q, want %q)", got, want) 619 } 620} 621 622func TestPublisherGetTopicError(t *testing.T) { 623 errCode := codes.PermissionDenied 624 mockPublisher.err = gstatus.Error(errCode, "test error") 625 626 var formattedTopic string = fmt.Sprintf("projects/%s/topics/%s", "[PROJECT]", "[TOPIC]") 627 var request = &pubsubpb.GetTopicRequest{ 628 Topic: formattedTopic, 629 } 630 631 c, err := NewPublisherClient(context.Background(), clientOpt) 632 if err != nil { 633 t.Fatal(err) 634 } 635 636 resp, err := c.GetTopic(context.Background(), request) 637 638 if st, ok := gstatus.FromError(err); !ok { 639 t.Errorf("got error %v, expected grpc error", err) 640 } else if c := st.Code(); c != errCode { 641 t.Errorf("got error code %q, want %q", c, errCode) 642 } 643 _ = resp 644} 645func TestPublisherListTopics(t *testing.T) { 646 var nextPageToken string = "" 647 var topicsElement *pubsubpb.Topic = &pubsubpb.Topic{} 648 var topics = []*pubsubpb.Topic{topicsElement} 649 var expectedResponse = &pubsubpb.ListTopicsResponse{ 650 NextPageToken: nextPageToken, 651 Topics: topics, 652 } 653 654 mockPublisher.err = nil 655 mockPublisher.reqs = nil 656 657 mockPublisher.resps = append(mockPublisher.resps[:0], expectedResponse) 658 659 var formattedProject string = fmt.Sprintf("projects/%s", "[PROJECT]") 660 var request = &pubsubpb.ListTopicsRequest{ 661 Project: formattedProject, 662 } 663 664 c, err := NewPublisherClient(context.Background(), clientOpt) 665 if err != nil { 666 t.Fatal(err) 667 } 668 669 resp, err := c.ListTopics(context.Background(), request).Next() 670 671 if err != nil { 672 t.Fatal(err) 673 } 674 675 if want, got := request, mockPublisher.reqs[0]; !proto.Equal(want, got) { 676 t.Errorf("wrong request %q, want %q", got, want) 677 } 678 679 want := (interface{})(expectedResponse.Topics[0]) 680 got := (interface{})(resp) 681 var ok bool 682 683 switch want := (want).(type) { 684 case proto.Message: 685 ok = proto.Equal(want, got.(proto.Message)) 686 default: 687 ok = want == got 688 } 689 if !ok { 690 t.Errorf("wrong response %q, want %q)", got, want) 691 } 692} 693 694func TestPublisherListTopicsError(t *testing.T) { 695 errCode := codes.PermissionDenied 696 mockPublisher.err = gstatus.Error(errCode, "test error") 697 698 var formattedProject string = fmt.Sprintf("projects/%s", "[PROJECT]") 699 var request = &pubsubpb.ListTopicsRequest{ 700 Project: formattedProject, 701 } 702 703 c, err := NewPublisherClient(context.Background(), clientOpt) 704 if err != nil { 705 t.Fatal(err) 706 } 707 708 resp, err := c.ListTopics(context.Background(), request).Next() 709 710 if st, ok := gstatus.FromError(err); !ok { 711 t.Errorf("got error %v, expected grpc error", err) 712 } else if c := st.Code(); c != errCode { 713 t.Errorf("got error code %q, want %q", c, errCode) 714 } 715 _ = resp 716} 717func TestPublisherListTopicSubscriptions(t *testing.T) { 718 var nextPageToken string = "" 719 var subscriptionsElement string = "subscriptionsElement1698708147" 720 var subscriptions = []string{subscriptionsElement} 721 var expectedResponse = &pubsubpb.ListTopicSubscriptionsResponse{ 722 NextPageToken: nextPageToken, 723 Subscriptions: subscriptions, 724 } 725 726 mockPublisher.err = nil 727 mockPublisher.reqs = nil 728 729 mockPublisher.resps = append(mockPublisher.resps[:0], expectedResponse) 730 731 var formattedTopic string = fmt.Sprintf("projects/%s/topics/%s", "[PROJECT]", "[TOPIC]") 732 var request = &pubsubpb.ListTopicSubscriptionsRequest{ 733 Topic: formattedTopic, 734 } 735 736 c, err := NewPublisherClient(context.Background(), clientOpt) 737 if err != nil { 738 t.Fatal(err) 739 } 740 741 resp, err := c.ListTopicSubscriptions(context.Background(), request).Next() 742 743 if err != nil { 744 t.Fatal(err) 745 } 746 747 if want, got := request, mockPublisher.reqs[0]; !proto.Equal(want, got) { 748 t.Errorf("wrong request %q, want %q", got, want) 749 } 750 751 want := (interface{})(expectedResponse.Subscriptions[0]) 752 got := (interface{})(resp) 753 var ok bool 754 755 switch want := (want).(type) { 756 case proto.Message: 757 ok = proto.Equal(want, got.(proto.Message)) 758 default: 759 ok = want == got 760 } 761 if !ok { 762 t.Errorf("wrong response %q, want %q)", got, want) 763 } 764} 765 766func TestPublisherListTopicSubscriptionsError(t *testing.T) { 767 errCode := codes.PermissionDenied 768 mockPublisher.err = gstatus.Error(errCode, "test error") 769 770 var formattedTopic string = fmt.Sprintf("projects/%s/topics/%s", "[PROJECT]", "[TOPIC]") 771 var request = &pubsubpb.ListTopicSubscriptionsRequest{ 772 Topic: formattedTopic, 773 } 774 775 c, err := NewPublisherClient(context.Background(), clientOpt) 776 if err != nil { 777 t.Fatal(err) 778 } 779 780 resp, err := c.ListTopicSubscriptions(context.Background(), request).Next() 781 782 if st, ok := gstatus.FromError(err); !ok { 783 t.Errorf("got error %v, expected grpc error", err) 784 } else if c := st.Code(); c != errCode { 785 t.Errorf("got error code %q, want %q", c, errCode) 786 } 787 _ = resp 788} 789func TestPublisherDeleteTopic(t *testing.T) { 790 var expectedResponse *emptypb.Empty = &emptypb.Empty{} 791 792 mockPublisher.err = nil 793 mockPublisher.reqs = nil 794 795 mockPublisher.resps = append(mockPublisher.resps[:0], expectedResponse) 796 797 var formattedTopic string = fmt.Sprintf("projects/%s/topics/%s", "[PROJECT]", "[TOPIC]") 798 var request = &pubsubpb.DeleteTopicRequest{ 799 Topic: formattedTopic, 800 } 801 802 c, err := NewPublisherClient(context.Background(), clientOpt) 803 if err != nil { 804 t.Fatal(err) 805 } 806 807 err = c.DeleteTopic(context.Background(), request) 808 809 if err != nil { 810 t.Fatal(err) 811 } 812 813 if want, got := request, mockPublisher.reqs[0]; !proto.Equal(want, got) { 814 t.Errorf("wrong request %q, want %q", got, want) 815 } 816 817} 818 819func TestPublisherDeleteTopicError(t *testing.T) { 820 errCode := codes.PermissionDenied 821 mockPublisher.err = gstatus.Error(errCode, "test error") 822 823 var formattedTopic string = fmt.Sprintf("projects/%s/topics/%s", "[PROJECT]", "[TOPIC]") 824 var request = &pubsubpb.DeleteTopicRequest{ 825 Topic: formattedTopic, 826 } 827 828 c, err := NewPublisherClient(context.Background(), clientOpt) 829 if err != nil { 830 t.Fatal(err) 831 } 832 833 err = c.DeleteTopic(context.Background(), request) 834 835 if st, ok := gstatus.FromError(err); !ok { 836 t.Errorf("got error %v, expected grpc error", err) 837 } else if c := st.Code(); c != errCode { 838 t.Errorf("got error code %q, want %q", c, errCode) 839 } 840} 841func TestSubscriberCreateSubscription(t *testing.T) { 842 var name2 string = "name2-1052831874" 843 var topic2 string = "topic2-1139259102" 844 var ackDeadlineSeconds int32 = 2135351438 845 var retainAckedMessages bool = false 846 var enableMessageOrdering bool = true 847 var expectedResponse = &pubsubpb.Subscription{ 848 Name: name2, 849 Topic: topic2, 850 AckDeadlineSeconds: ackDeadlineSeconds, 851 RetainAckedMessages: retainAckedMessages, 852 EnableMessageOrdering: enableMessageOrdering, 853 } 854 855 mockSubscriber.err = nil 856 mockSubscriber.reqs = nil 857 858 mockSubscriber.resps = append(mockSubscriber.resps[:0], expectedResponse) 859 860 var formattedName string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]") 861 var formattedTopic string = fmt.Sprintf("projects/%s/topics/%s", "[PROJECT]", "[TOPIC]") 862 var request = &pubsubpb.Subscription{ 863 Name: formattedName, 864 Topic: formattedTopic, 865 } 866 867 c, err := NewSubscriberClient(context.Background(), clientOpt) 868 if err != nil { 869 t.Fatal(err) 870 } 871 872 resp, err := c.CreateSubscription(context.Background(), request) 873 874 if err != nil { 875 t.Fatal(err) 876 } 877 878 if want, got := request, mockSubscriber.reqs[0]; !proto.Equal(want, got) { 879 t.Errorf("wrong request %q, want %q", got, want) 880 } 881 882 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 883 t.Errorf("wrong response %q, want %q)", got, want) 884 } 885} 886 887func TestSubscriberCreateSubscriptionError(t *testing.T) { 888 errCode := codes.PermissionDenied 889 mockSubscriber.err = gstatus.Error(errCode, "test error") 890 891 var formattedName string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]") 892 var formattedTopic string = fmt.Sprintf("projects/%s/topics/%s", "[PROJECT]", "[TOPIC]") 893 var request = &pubsubpb.Subscription{ 894 Name: formattedName, 895 Topic: formattedTopic, 896 } 897 898 c, err := NewSubscriberClient(context.Background(), clientOpt) 899 if err != nil { 900 t.Fatal(err) 901 } 902 903 resp, err := c.CreateSubscription(context.Background(), request) 904 905 if st, ok := gstatus.FromError(err); !ok { 906 t.Errorf("got error %v, expected grpc error", err) 907 } else if c := st.Code(); c != errCode { 908 t.Errorf("got error code %q, want %q", c, errCode) 909 } 910 _ = resp 911} 912func TestSubscriberGetSubscription(t *testing.T) { 913 var name string = "name3373707" 914 var topic string = "topic110546223" 915 var ackDeadlineSeconds int32 = 2135351438 916 var retainAckedMessages bool = false 917 var enableMessageOrdering bool = true 918 var expectedResponse = &pubsubpb.Subscription{ 919 Name: name, 920 Topic: topic, 921 AckDeadlineSeconds: ackDeadlineSeconds, 922 RetainAckedMessages: retainAckedMessages, 923 EnableMessageOrdering: enableMessageOrdering, 924 } 925 926 mockSubscriber.err = nil 927 mockSubscriber.reqs = nil 928 929 mockSubscriber.resps = append(mockSubscriber.resps[:0], expectedResponse) 930 931 var formattedSubscription string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]") 932 var request = &pubsubpb.GetSubscriptionRequest{ 933 Subscription: formattedSubscription, 934 } 935 936 c, err := NewSubscriberClient(context.Background(), clientOpt) 937 if err != nil { 938 t.Fatal(err) 939 } 940 941 resp, err := c.GetSubscription(context.Background(), request) 942 943 if err != nil { 944 t.Fatal(err) 945 } 946 947 if want, got := request, mockSubscriber.reqs[0]; !proto.Equal(want, got) { 948 t.Errorf("wrong request %q, want %q", got, want) 949 } 950 951 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 952 t.Errorf("wrong response %q, want %q)", got, want) 953 } 954} 955 956func TestSubscriberGetSubscriptionError(t *testing.T) { 957 errCode := codes.PermissionDenied 958 mockSubscriber.err = gstatus.Error(errCode, "test error") 959 960 var formattedSubscription string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]") 961 var request = &pubsubpb.GetSubscriptionRequest{ 962 Subscription: formattedSubscription, 963 } 964 965 c, err := NewSubscriberClient(context.Background(), clientOpt) 966 if err != nil { 967 t.Fatal(err) 968 } 969 970 resp, err := c.GetSubscription(context.Background(), request) 971 972 if st, ok := gstatus.FromError(err); !ok { 973 t.Errorf("got error %v, expected grpc error", err) 974 } else if c := st.Code(); c != errCode { 975 t.Errorf("got error code %q, want %q", c, errCode) 976 } 977 _ = resp 978} 979func TestSubscriberUpdateSubscription(t *testing.T) { 980 var name string = "name3373707" 981 var topic string = "topic110546223" 982 var ackDeadlineSeconds2 int32 = 921632575 983 var retainAckedMessages bool = false 984 var enableMessageOrdering bool = true 985 var expectedResponse = &pubsubpb.Subscription{ 986 Name: name, 987 Topic: topic, 988 AckDeadlineSeconds: ackDeadlineSeconds2, 989 RetainAckedMessages: retainAckedMessages, 990 EnableMessageOrdering: enableMessageOrdering, 991 } 992 993 mockSubscriber.err = nil 994 mockSubscriber.reqs = nil 995 996 mockSubscriber.resps = append(mockSubscriber.resps[:0], expectedResponse) 997 998 var ackDeadlineSeconds int32 = 42 999 var subscription = &pubsubpb.Subscription{ 1000 AckDeadlineSeconds: ackDeadlineSeconds, 1001 } 1002 var pathsElement string = "ack_deadline_seconds" 1003 var paths = []string{pathsElement} 1004 var updateMask = &field_maskpb.FieldMask{ 1005 Paths: paths, 1006 } 1007 var request = &pubsubpb.UpdateSubscriptionRequest{ 1008 Subscription: subscription, 1009 UpdateMask: updateMask, 1010 } 1011 1012 c, err := NewSubscriberClient(context.Background(), clientOpt) 1013 if err != nil { 1014 t.Fatal(err) 1015 } 1016 1017 resp, err := c.UpdateSubscription(context.Background(), request) 1018 1019 if err != nil { 1020 t.Fatal(err) 1021 } 1022 1023 if want, got := request, mockSubscriber.reqs[0]; !proto.Equal(want, got) { 1024 t.Errorf("wrong request %q, want %q", got, want) 1025 } 1026 1027 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1028 t.Errorf("wrong response %q, want %q)", got, want) 1029 } 1030} 1031 1032func TestSubscriberUpdateSubscriptionError(t *testing.T) { 1033 errCode := codes.PermissionDenied 1034 mockSubscriber.err = gstatus.Error(errCode, "test error") 1035 1036 var ackDeadlineSeconds int32 = 42 1037 var subscription = &pubsubpb.Subscription{ 1038 AckDeadlineSeconds: ackDeadlineSeconds, 1039 } 1040 var pathsElement string = "ack_deadline_seconds" 1041 var paths = []string{pathsElement} 1042 var updateMask = &field_maskpb.FieldMask{ 1043 Paths: paths, 1044 } 1045 var request = &pubsubpb.UpdateSubscriptionRequest{ 1046 Subscription: subscription, 1047 UpdateMask: updateMask, 1048 } 1049 1050 c, err := NewSubscriberClient(context.Background(), clientOpt) 1051 if err != nil { 1052 t.Fatal(err) 1053 } 1054 1055 resp, err := c.UpdateSubscription(context.Background(), request) 1056 1057 if st, ok := gstatus.FromError(err); !ok { 1058 t.Errorf("got error %v, expected grpc error", err) 1059 } else if c := st.Code(); c != errCode { 1060 t.Errorf("got error code %q, want %q", c, errCode) 1061 } 1062 _ = resp 1063} 1064func TestSubscriberListSubscriptions(t *testing.T) { 1065 var nextPageToken string = "" 1066 var subscriptionsElement *pubsubpb.Subscription = &pubsubpb.Subscription{} 1067 var subscriptions = []*pubsubpb.Subscription{subscriptionsElement} 1068 var expectedResponse = &pubsubpb.ListSubscriptionsResponse{ 1069 NextPageToken: nextPageToken, 1070 Subscriptions: subscriptions, 1071 } 1072 1073 mockSubscriber.err = nil 1074 mockSubscriber.reqs = nil 1075 1076 mockSubscriber.resps = append(mockSubscriber.resps[:0], expectedResponse) 1077 1078 var formattedProject string = fmt.Sprintf("projects/%s", "[PROJECT]") 1079 var request = &pubsubpb.ListSubscriptionsRequest{ 1080 Project: formattedProject, 1081 } 1082 1083 c, err := NewSubscriberClient(context.Background(), clientOpt) 1084 if err != nil { 1085 t.Fatal(err) 1086 } 1087 1088 resp, err := c.ListSubscriptions(context.Background(), request).Next() 1089 1090 if err != nil { 1091 t.Fatal(err) 1092 } 1093 1094 if want, got := request, mockSubscriber.reqs[0]; !proto.Equal(want, got) { 1095 t.Errorf("wrong request %q, want %q", got, want) 1096 } 1097 1098 want := (interface{})(expectedResponse.Subscriptions[0]) 1099 got := (interface{})(resp) 1100 var ok bool 1101 1102 switch want := (want).(type) { 1103 case proto.Message: 1104 ok = proto.Equal(want, got.(proto.Message)) 1105 default: 1106 ok = want == got 1107 } 1108 if !ok { 1109 t.Errorf("wrong response %q, want %q)", got, want) 1110 } 1111} 1112 1113func TestSubscriberListSubscriptionsError(t *testing.T) { 1114 errCode := codes.PermissionDenied 1115 mockSubscriber.err = gstatus.Error(errCode, "test error") 1116 1117 var formattedProject string = fmt.Sprintf("projects/%s", "[PROJECT]") 1118 var request = &pubsubpb.ListSubscriptionsRequest{ 1119 Project: formattedProject, 1120 } 1121 1122 c, err := NewSubscriberClient(context.Background(), clientOpt) 1123 if err != nil { 1124 t.Fatal(err) 1125 } 1126 1127 resp, err := c.ListSubscriptions(context.Background(), request).Next() 1128 1129 if st, ok := gstatus.FromError(err); !ok { 1130 t.Errorf("got error %v, expected grpc error", err) 1131 } else if c := st.Code(); c != errCode { 1132 t.Errorf("got error code %q, want %q", c, errCode) 1133 } 1134 _ = resp 1135} 1136func TestSubscriberDeleteSubscription(t *testing.T) { 1137 var expectedResponse *emptypb.Empty = &emptypb.Empty{} 1138 1139 mockSubscriber.err = nil 1140 mockSubscriber.reqs = nil 1141 1142 mockSubscriber.resps = append(mockSubscriber.resps[:0], expectedResponse) 1143 1144 var formattedSubscription string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]") 1145 var request = &pubsubpb.DeleteSubscriptionRequest{ 1146 Subscription: formattedSubscription, 1147 } 1148 1149 c, err := NewSubscriberClient(context.Background(), clientOpt) 1150 if err != nil { 1151 t.Fatal(err) 1152 } 1153 1154 err = c.DeleteSubscription(context.Background(), request) 1155 1156 if err != nil { 1157 t.Fatal(err) 1158 } 1159 1160 if want, got := request, mockSubscriber.reqs[0]; !proto.Equal(want, got) { 1161 t.Errorf("wrong request %q, want %q", got, want) 1162 } 1163 1164} 1165 1166func TestSubscriberDeleteSubscriptionError(t *testing.T) { 1167 errCode := codes.PermissionDenied 1168 mockSubscriber.err = gstatus.Error(errCode, "test error") 1169 1170 var formattedSubscription string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]") 1171 var request = &pubsubpb.DeleteSubscriptionRequest{ 1172 Subscription: formattedSubscription, 1173 } 1174 1175 c, err := NewSubscriberClient(context.Background(), clientOpt) 1176 if err != nil { 1177 t.Fatal(err) 1178 } 1179 1180 err = c.DeleteSubscription(context.Background(), request) 1181 1182 if st, ok := gstatus.FromError(err); !ok { 1183 t.Errorf("got error %v, expected grpc error", err) 1184 } else if c := st.Code(); c != errCode { 1185 t.Errorf("got error code %q, want %q", c, errCode) 1186 } 1187} 1188func TestSubscriberModifyAckDeadline(t *testing.T) { 1189 var expectedResponse *emptypb.Empty = &emptypb.Empty{} 1190 1191 mockSubscriber.err = nil 1192 mockSubscriber.reqs = nil 1193 1194 mockSubscriber.resps = append(mockSubscriber.resps[:0], expectedResponse) 1195 1196 var formattedSubscription string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]") 1197 var ackIds []string = nil 1198 var ackDeadlineSeconds int32 = 2135351438 1199 var request = &pubsubpb.ModifyAckDeadlineRequest{ 1200 Subscription: formattedSubscription, 1201 AckIds: ackIds, 1202 AckDeadlineSeconds: ackDeadlineSeconds, 1203 } 1204 1205 c, err := NewSubscriberClient(context.Background(), clientOpt) 1206 if err != nil { 1207 t.Fatal(err) 1208 } 1209 1210 err = c.ModifyAckDeadline(context.Background(), request) 1211 1212 if err != nil { 1213 t.Fatal(err) 1214 } 1215 1216 if want, got := request, mockSubscriber.reqs[0]; !proto.Equal(want, got) { 1217 t.Errorf("wrong request %q, want %q", got, want) 1218 } 1219 1220} 1221 1222func TestSubscriberModifyAckDeadlineError(t *testing.T) { 1223 errCode := codes.PermissionDenied 1224 mockSubscriber.err = gstatus.Error(errCode, "test error") 1225 1226 var formattedSubscription string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]") 1227 var ackIds []string = nil 1228 var ackDeadlineSeconds int32 = 2135351438 1229 var request = &pubsubpb.ModifyAckDeadlineRequest{ 1230 Subscription: formattedSubscription, 1231 AckIds: ackIds, 1232 AckDeadlineSeconds: ackDeadlineSeconds, 1233 } 1234 1235 c, err := NewSubscriberClient(context.Background(), clientOpt) 1236 if err != nil { 1237 t.Fatal(err) 1238 } 1239 1240 err = c.ModifyAckDeadline(context.Background(), request) 1241 1242 if st, ok := gstatus.FromError(err); !ok { 1243 t.Errorf("got error %v, expected grpc error", err) 1244 } else if c := st.Code(); c != errCode { 1245 t.Errorf("got error code %q, want %q", c, errCode) 1246 } 1247} 1248func TestSubscriberAcknowledge(t *testing.T) { 1249 var expectedResponse *emptypb.Empty = &emptypb.Empty{} 1250 1251 mockSubscriber.err = nil 1252 mockSubscriber.reqs = nil 1253 1254 mockSubscriber.resps = append(mockSubscriber.resps[:0], expectedResponse) 1255 1256 var formattedSubscription string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]") 1257 var ackIds []string = nil 1258 var request = &pubsubpb.AcknowledgeRequest{ 1259 Subscription: formattedSubscription, 1260 AckIds: ackIds, 1261 } 1262 1263 c, err := NewSubscriberClient(context.Background(), clientOpt) 1264 if err != nil { 1265 t.Fatal(err) 1266 } 1267 1268 err = c.Acknowledge(context.Background(), request) 1269 1270 if err != nil { 1271 t.Fatal(err) 1272 } 1273 1274 if want, got := request, mockSubscriber.reqs[0]; !proto.Equal(want, got) { 1275 t.Errorf("wrong request %q, want %q", got, want) 1276 } 1277 1278} 1279 1280func TestSubscriberAcknowledgeError(t *testing.T) { 1281 errCode := codes.PermissionDenied 1282 mockSubscriber.err = gstatus.Error(errCode, "test error") 1283 1284 var formattedSubscription string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]") 1285 var ackIds []string = nil 1286 var request = &pubsubpb.AcknowledgeRequest{ 1287 Subscription: formattedSubscription, 1288 AckIds: ackIds, 1289 } 1290 1291 c, err := NewSubscriberClient(context.Background(), clientOpt) 1292 if err != nil { 1293 t.Fatal(err) 1294 } 1295 1296 err = c.Acknowledge(context.Background(), request) 1297 1298 if st, ok := gstatus.FromError(err); !ok { 1299 t.Errorf("got error %v, expected grpc error", err) 1300 } else if c := st.Code(); c != errCode { 1301 t.Errorf("got error code %q, want %q", c, errCode) 1302 } 1303} 1304func TestSubscriberPull(t *testing.T) { 1305 var expectedResponse *pubsubpb.PullResponse = &pubsubpb.PullResponse{} 1306 1307 mockSubscriber.err = nil 1308 mockSubscriber.reqs = nil 1309 1310 mockSubscriber.resps = append(mockSubscriber.resps[:0], expectedResponse) 1311 1312 var formattedSubscription string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]") 1313 var maxMessages int32 = 496131527 1314 var request = &pubsubpb.PullRequest{ 1315 Subscription: formattedSubscription, 1316 MaxMessages: maxMessages, 1317 } 1318 1319 c, err := NewSubscriberClient(context.Background(), clientOpt) 1320 if err != nil { 1321 t.Fatal(err) 1322 } 1323 1324 resp, err := c.Pull(context.Background(), request) 1325 1326 if err != nil { 1327 t.Fatal(err) 1328 } 1329 1330 if want, got := request, mockSubscriber.reqs[0]; !proto.Equal(want, got) { 1331 t.Errorf("wrong request %q, want %q", got, want) 1332 } 1333 1334 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1335 t.Errorf("wrong response %q, want %q)", got, want) 1336 } 1337} 1338 1339func TestSubscriberPullError(t *testing.T) { 1340 errCode := codes.PermissionDenied 1341 mockSubscriber.err = gstatus.Error(errCode, "test error") 1342 1343 var formattedSubscription string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]") 1344 var maxMessages int32 = 496131527 1345 var request = &pubsubpb.PullRequest{ 1346 Subscription: formattedSubscription, 1347 MaxMessages: maxMessages, 1348 } 1349 1350 c, err := NewSubscriberClient(context.Background(), clientOpt) 1351 if err != nil { 1352 t.Fatal(err) 1353 } 1354 1355 resp, err := c.Pull(context.Background(), request) 1356 1357 if st, ok := gstatus.FromError(err); !ok { 1358 t.Errorf("got error %v, expected grpc error", err) 1359 } else if c := st.Code(); c != errCode { 1360 t.Errorf("got error code %q, want %q", c, errCode) 1361 } 1362 _ = resp 1363} 1364func TestSubscriberStreamingPull(t *testing.T) { 1365 var receivedMessagesElement *pubsubpb.ReceivedMessage = &pubsubpb.ReceivedMessage{} 1366 var receivedMessages = []*pubsubpb.ReceivedMessage{receivedMessagesElement} 1367 var expectedResponse = &pubsubpb.StreamingPullResponse{ 1368 ReceivedMessages: receivedMessages, 1369 } 1370 1371 mockSubscriber.err = nil 1372 mockSubscriber.reqs = nil 1373 1374 mockSubscriber.resps = append(mockSubscriber.resps[:0], expectedResponse) 1375 1376 var formattedSubscription string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]") 1377 var streamAckDeadlineSeconds int32 = 1875467245 1378 var request = &pubsubpb.StreamingPullRequest{ 1379 Subscription: formattedSubscription, 1380 StreamAckDeadlineSeconds: streamAckDeadlineSeconds, 1381 } 1382 1383 c, err := NewSubscriberClient(context.Background(), clientOpt) 1384 if err != nil { 1385 t.Fatal(err) 1386 } 1387 1388 stream, err := c.StreamingPull(context.Background()) 1389 if err != nil { 1390 t.Fatal(err) 1391 } 1392 if err := stream.Send(request); err != nil { 1393 t.Fatal(err) 1394 } 1395 if err := stream.CloseSend(); err != nil { 1396 t.Fatal(err) 1397 } 1398 resp, err := stream.Recv() 1399 1400 if err != nil { 1401 t.Fatal(err) 1402 } 1403 1404 if want, got := request, mockSubscriber.reqs[0]; !proto.Equal(want, got) { 1405 t.Errorf("wrong request %q, want %q", got, want) 1406 } 1407 1408 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1409 t.Errorf("wrong response %q, want %q)", got, want) 1410 } 1411} 1412 1413func TestSubscriberStreamingPullError(t *testing.T) { 1414 errCode := codes.PermissionDenied 1415 mockSubscriber.err = gstatus.Error(errCode, "test error") 1416 1417 var formattedSubscription string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]") 1418 var streamAckDeadlineSeconds int32 = 1875467245 1419 var request = &pubsubpb.StreamingPullRequest{ 1420 Subscription: formattedSubscription, 1421 StreamAckDeadlineSeconds: streamAckDeadlineSeconds, 1422 } 1423 1424 c, err := NewSubscriberClient(context.Background(), clientOpt) 1425 if err != nil { 1426 t.Fatal(err) 1427 } 1428 1429 stream, err := c.StreamingPull(context.Background()) 1430 if err != nil { 1431 t.Fatal(err) 1432 } 1433 if err := stream.Send(request); err != nil { 1434 t.Fatal(err) 1435 } 1436 if err := stream.CloseSend(); err != nil { 1437 t.Fatal(err) 1438 } 1439 resp, err := stream.Recv() 1440 1441 if st, ok := gstatus.FromError(err); !ok { 1442 t.Errorf("got error %v, expected grpc error", err) 1443 } else if c := st.Code(); c != errCode { 1444 t.Errorf("got error code %q, want %q", c, errCode) 1445 } 1446 _ = resp 1447} 1448func TestSubscriberModifyPushConfig(t *testing.T) { 1449 var expectedResponse *emptypb.Empty = &emptypb.Empty{} 1450 1451 mockSubscriber.err = nil 1452 mockSubscriber.reqs = nil 1453 1454 mockSubscriber.resps = append(mockSubscriber.resps[:0], expectedResponse) 1455 1456 var formattedSubscription string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]") 1457 var pushConfig *pubsubpb.PushConfig = &pubsubpb.PushConfig{} 1458 var request = &pubsubpb.ModifyPushConfigRequest{ 1459 Subscription: formattedSubscription, 1460 PushConfig: pushConfig, 1461 } 1462 1463 c, err := NewSubscriberClient(context.Background(), clientOpt) 1464 if err != nil { 1465 t.Fatal(err) 1466 } 1467 1468 err = c.ModifyPushConfig(context.Background(), request) 1469 1470 if err != nil { 1471 t.Fatal(err) 1472 } 1473 1474 if want, got := request, mockSubscriber.reqs[0]; !proto.Equal(want, got) { 1475 t.Errorf("wrong request %q, want %q", got, want) 1476 } 1477 1478} 1479 1480func TestSubscriberModifyPushConfigError(t *testing.T) { 1481 errCode := codes.PermissionDenied 1482 mockSubscriber.err = gstatus.Error(errCode, "test error") 1483 1484 var formattedSubscription string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]") 1485 var pushConfig *pubsubpb.PushConfig = &pubsubpb.PushConfig{} 1486 var request = &pubsubpb.ModifyPushConfigRequest{ 1487 Subscription: formattedSubscription, 1488 PushConfig: pushConfig, 1489 } 1490 1491 c, err := NewSubscriberClient(context.Background(), clientOpt) 1492 if err != nil { 1493 t.Fatal(err) 1494 } 1495 1496 err = c.ModifyPushConfig(context.Background(), request) 1497 1498 if st, ok := gstatus.FromError(err); !ok { 1499 t.Errorf("got error %v, expected grpc error", err) 1500 } else if c := st.Code(); c != errCode { 1501 t.Errorf("got error code %q, want %q", c, errCode) 1502 } 1503} 1504func TestSubscriberListSnapshots(t *testing.T) { 1505 var nextPageToken string = "" 1506 var snapshotsElement *pubsubpb.Snapshot = &pubsubpb.Snapshot{} 1507 var snapshots = []*pubsubpb.Snapshot{snapshotsElement} 1508 var expectedResponse = &pubsubpb.ListSnapshotsResponse{ 1509 NextPageToken: nextPageToken, 1510 Snapshots: snapshots, 1511 } 1512 1513 mockSubscriber.err = nil 1514 mockSubscriber.reqs = nil 1515 1516 mockSubscriber.resps = append(mockSubscriber.resps[:0], expectedResponse) 1517 1518 var formattedProject string = fmt.Sprintf("projects/%s", "[PROJECT]") 1519 var request = &pubsubpb.ListSnapshotsRequest{ 1520 Project: formattedProject, 1521 } 1522 1523 c, err := NewSubscriberClient(context.Background(), clientOpt) 1524 if err != nil { 1525 t.Fatal(err) 1526 } 1527 1528 resp, err := c.ListSnapshots(context.Background(), request).Next() 1529 1530 if err != nil { 1531 t.Fatal(err) 1532 } 1533 1534 if want, got := request, mockSubscriber.reqs[0]; !proto.Equal(want, got) { 1535 t.Errorf("wrong request %q, want %q", got, want) 1536 } 1537 1538 want := (interface{})(expectedResponse.Snapshots[0]) 1539 got := (interface{})(resp) 1540 var ok bool 1541 1542 switch want := (want).(type) { 1543 case proto.Message: 1544 ok = proto.Equal(want, got.(proto.Message)) 1545 default: 1546 ok = want == got 1547 } 1548 if !ok { 1549 t.Errorf("wrong response %q, want %q)", got, want) 1550 } 1551} 1552 1553func TestSubscriberListSnapshotsError(t *testing.T) { 1554 errCode := codes.PermissionDenied 1555 mockSubscriber.err = gstatus.Error(errCode, "test error") 1556 1557 var formattedProject string = fmt.Sprintf("projects/%s", "[PROJECT]") 1558 var request = &pubsubpb.ListSnapshotsRequest{ 1559 Project: formattedProject, 1560 } 1561 1562 c, err := NewSubscriberClient(context.Background(), clientOpt) 1563 if err != nil { 1564 t.Fatal(err) 1565 } 1566 1567 resp, err := c.ListSnapshots(context.Background(), request).Next() 1568 1569 if st, ok := gstatus.FromError(err); !ok { 1570 t.Errorf("got error %v, expected grpc error", err) 1571 } else if c := st.Code(); c != errCode { 1572 t.Errorf("got error code %q, want %q", c, errCode) 1573 } 1574 _ = resp 1575} 1576func TestSubscriberCreateSnapshot(t *testing.T) { 1577 var name2 string = "name2-1052831874" 1578 var topic string = "topic110546223" 1579 var expectedResponse = &pubsubpb.Snapshot{ 1580 Name: name2, 1581 Topic: topic, 1582 } 1583 1584 mockSubscriber.err = nil 1585 mockSubscriber.reqs = nil 1586 1587 mockSubscriber.resps = append(mockSubscriber.resps[:0], expectedResponse) 1588 1589 var formattedName string = fmt.Sprintf("projects/%s/snapshots/%s", "[PROJECT]", "[SNAPSHOT]") 1590 var formattedSubscription string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]") 1591 var request = &pubsubpb.CreateSnapshotRequest{ 1592 Name: formattedName, 1593 Subscription: formattedSubscription, 1594 } 1595 1596 c, err := NewSubscriberClient(context.Background(), clientOpt) 1597 if err != nil { 1598 t.Fatal(err) 1599 } 1600 1601 resp, err := c.CreateSnapshot(context.Background(), request) 1602 1603 if err != nil { 1604 t.Fatal(err) 1605 } 1606 1607 if want, got := request, mockSubscriber.reqs[0]; !proto.Equal(want, got) { 1608 t.Errorf("wrong request %q, want %q", got, want) 1609 } 1610 1611 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1612 t.Errorf("wrong response %q, want %q)", got, want) 1613 } 1614} 1615 1616func TestSubscriberCreateSnapshotError(t *testing.T) { 1617 errCode := codes.PermissionDenied 1618 mockSubscriber.err = gstatus.Error(errCode, "test error") 1619 1620 var formattedName string = fmt.Sprintf("projects/%s/snapshots/%s", "[PROJECT]", "[SNAPSHOT]") 1621 var formattedSubscription string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]") 1622 var request = &pubsubpb.CreateSnapshotRequest{ 1623 Name: formattedName, 1624 Subscription: formattedSubscription, 1625 } 1626 1627 c, err := NewSubscriberClient(context.Background(), clientOpt) 1628 if err != nil { 1629 t.Fatal(err) 1630 } 1631 1632 resp, err := c.CreateSnapshot(context.Background(), request) 1633 1634 if st, ok := gstatus.FromError(err); !ok { 1635 t.Errorf("got error %v, expected grpc error", err) 1636 } else if c := st.Code(); c != errCode { 1637 t.Errorf("got error code %q, want %q", c, errCode) 1638 } 1639 _ = resp 1640} 1641func TestSubscriberUpdateSnapshot(t *testing.T) { 1642 var name string = "name3373707" 1643 var topic string = "topic110546223" 1644 var expectedResponse = &pubsubpb.Snapshot{ 1645 Name: name, 1646 Topic: topic, 1647 } 1648 1649 mockSubscriber.err = nil 1650 mockSubscriber.reqs = nil 1651 1652 mockSubscriber.resps = append(mockSubscriber.resps[:0], expectedResponse) 1653 1654 var seconds int64 = 123456 1655 var expireTime = ×tamppb.Timestamp{ 1656 Seconds: seconds, 1657 } 1658 var snapshot = &pubsubpb.Snapshot{ 1659 ExpireTime: expireTime, 1660 } 1661 var pathsElement string = "expire_time" 1662 var paths = []string{pathsElement} 1663 var updateMask = &field_maskpb.FieldMask{ 1664 Paths: paths, 1665 } 1666 var request = &pubsubpb.UpdateSnapshotRequest{ 1667 Snapshot: snapshot, 1668 UpdateMask: updateMask, 1669 } 1670 1671 c, err := NewSubscriberClient(context.Background(), clientOpt) 1672 if err != nil { 1673 t.Fatal(err) 1674 } 1675 1676 resp, err := c.UpdateSnapshot(context.Background(), request) 1677 1678 if err != nil { 1679 t.Fatal(err) 1680 } 1681 1682 if want, got := request, mockSubscriber.reqs[0]; !proto.Equal(want, got) { 1683 t.Errorf("wrong request %q, want %q", got, want) 1684 } 1685 1686 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1687 t.Errorf("wrong response %q, want %q)", got, want) 1688 } 1689} 1690 1691func TestSubscriberUpdateSnapshotError(t *testing.T) { 1692 errCode := codes.PermissionDenied 1693 mockSubscriber.err = gstatus.Error(errCode, "test error") 1694 1695 var seconds int64 = 123456 1696 var expireTime = ×tamppb.Timestamp{ 1697 Seconds: seconds, 1698 } 1699 var snapshot = &pubsubpb.Snapshot{ 1700 ExpireTime: expireTime, 1701 } 1702 var pathsElement string = "expire_time" 1703 var paths = []string{pathsElement} 1704 var updateMask = &field_maskpb.FieldMask{ 1705 Paths: paths, 1706 } 1707 var request = &pubsubpb.UpdateSnapshotRequest{ 1708 Snapshot: snapshot, 1709 UpdateMask: updateMask, 1710 } 1711 1712 c, err := NewSubscriberClient(context.Background(), clientOpt) 1713 if err != nil { 1714 t.Fatal(err) 1715 } 1716 1717 resp, err := c.UpdateSnapshot(context.Background(), request) 1718 1719 if st, ok := gstatus.FromError(err); !ok { 1720 t.Errorf("got error %v, expected grpc error", err) 1721 } else if c := st.Code(); c != errCode { 1722 t.Errorf("got error code %q, want %q", c, errCode) 1723 } 1724 _ = resp 1725} 1726func TestSubscriberDeleteSnapshot(t *testing.T) { 1727 var expectedResponse *emptypb.Empty = &emptypb.Empty{} 1728 1729 mockSubscriber.err = nil 1730 mockSubscriber.reqs = nil 1731 1732 mockSubscriber.resps = append(mockSubscriber.resps[:0], expectedResponse) 1733 1734 var formattedSnapshot string = fmt.Sprintf("projects/%s/snapshots/%s", "[PROJECT]", "[SNAPSHOT]") 1735 var request = &pubsubpb.DeleteSnapshotRequest{ 1736 Snapshot: formattedSnapshot, 1737 } 1738 1739 c, err := NewSubscriberClient(context.Background(), clientOpt) 1740 if err != nil { 1741 t.Fatal(err) 1742 } 1743 1744 err = c.DeleteSnapshot(context.Background(), request) 1745 1746 if err != nil { 1747 t.Fatal(err) 1748 } 1749 1750 if want, got := request, mockSubscriber.reqs[0]; !proto.Equal(want, got) { 1751 t.Errorf("wrong request %q, want %q", got, want) 1752 } 1753 1754} 1755 1756func TestSubscriberDeleteSnapshotError(t *testing.T) { 1757 errCode := codes.PermissionDenied 1758 mockSubscriber.err = gstatus.Error(errCode, "test error") 1759 1760 var formattedSnapshot string = fmt.Sprintf("projects/%s/snapshots/%s", "[PROJECT]", "[SNAPSHOT]") 1761 var request = &pubsubpb.DeleteSnapshotRequest{ 1762 Snapshot: formattedSnapshot, 1763 } 1764 1765 c, err := NewSubscriberClient(context.Background(), clientOpt) 1766 if err != nil { 1767 t.Fatal(err) 1768 } 1769 1770 err = c.DeleteSnapshot(context.Background(), request) 1771 1772 if st, ok := gstatus.FromError(err); !ok { 1773 t.Errorf("got error %v, expected grpc error", err) 1774 } else if c := st.Code(); c != errCode { 1775 t.Errorf("got error code %q, want %q", c, errCode) 1776 } 1777} 1778func TestSubscriberSeek(t *testing.T) { 1779 var expectedResponse *pubsubpb.SeekResponse = &pubsubpb.SeekResponse{} 1780 1781 mockSubscriber.err = nil 1782 mockSubscriber.reqs = nil 1783 1784 mockSubscriber.resps = append(mockSubscriber.resps[:0], expectedResponse) 1785 1786 var formattedSubscription string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]") 1787 var request = &pubsubpb.SeekRequest{ 1788 Subscription: formattedSubscription, 1789 } 1790 1791 c, err := NewSubscriberClient(context.Background(), clientOpt) 1792 if err != nil { 1793 t.Fatal(err) 1794 } 1795 1796 resp, err := c.Seek(context.Background(), request) 1797 1798 if err != nil { 1799 t.Fatal(err) 1800 } 1801 1802 if want, got := request, mockSubscriber.reqs[0]; !proto.Equal(want, got) { 1803 t.Errorf("wrong request %q, want %q", got, want) 1804 } 1805 1806 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1807 t.Errorf("wrong response %q, want %q)", got, want) 1808 } 1809} 1810 1811func TestSubscriberSeekError(t *testing.T) { 1812 errCode := codes.PermissionDenied 1813 mockSubscriber.err = gstatus.Error(errCode, "test error") 1814 1815 var formattedSubscription string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]") 1816 var request = &pubsubpb.SeekRequest{ 1817 Subscription: formattedSubscription, 1818 } 1819 1820 c, err := NewSubscriberClient(context.Background(), clientOpt) 1821 if err != nil { 1822 t.Fatal(err) 1823 } 1824 1825 resp, err := c.Seek(context.Background(), request) 1826 1827 if st, ok := gstatus.FromError(err); !ok { 1828 t.Errorf("got error %v, expected grpc error", err) 1829 } else if c := st.Code(); c != errCode { 1830 t.Errorf("got error code %q, want %q", c, errCode) 1831 } 1832 _ = resp 1833} 1834