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