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 cloudtasks 18 19import ( 20 emptypb "github.com/golang/protobuf/ptypes/empty" 21 taskspb "google.golang.org/genproto/googleapis/cloud/tasks/v2beta3" 22 iampb "google.golang.org/genproto/googleapis/iam/v1" 23) 24 25import ( 26 "context" 27 "flag" 28 "fmt" 29 "io" 30 "log" 31 "net" 32 "os" 33 "strings" 34 "testing" 35 36 "github.com/golang/protobuf/proto" 37 "github.com/golang/protobuf/ptypes" 38 "google.golang.org/api/option" 39 status "google.golang.org/genproto/googleapis/rpc/status" 40 "google.golang.org/grpc" 41 "google.golang.org/grpc/codes" 42 "google.golang.org/grpc/metadata" 43 gstatus "google.golang.org/grpc/status" 44) 45 46var _ = io.EOF 47var _ = ptypes.MarshalAny 48var _ status.Status 49 50type mockCloudTasksServer struct { 51 // Embed for forward compatibility. 52 // Tests will keep working if more methods are added 53 // in the future. 54 taskspb.CloudTasksServer 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 *mockCloudTasksServer) ListQueues(ctx context.Context, req *taskspb.ListQueuesRequest) (*taskspb.ListQueuesResponse, 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].(*taskspb.ListQueuesResponse), nil 75} 76 77func (s *mockCloudTasksServer) GetQueue(ctx context.Context, req *taskspb.GetQueueRequest) (*taskspb.Queue, 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].(*taskspb.Queue), nil 87} 88 89func (s *mockCloudTasksServer) CreateQueue(ctx context.Context, req *taskspb.CreateQueueRequest) (*taskspb.Queue, 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].(*taskspb.Queue), nil 99} 100 101func (s *mockCloudTasksServer) UpdateQueue(ctx context.Context, req *taskspb.UpdateQueueRequest) (*taskspb.Queue, 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].(*taskspb.Queue), nil 111} 112 113func (s *mockCloudTasksServer) DeleteQueue(ctx context.Context, req *taskspb.DeleteQueueRequest) (*emptypb.Empty, 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].(*emptypb.Empty), nil 123} 124 125func (s *mockCloudTasksServer) PurgeQueue(ctx context.Context, req *taskspb.PurgeQueueRequest) (*taskspb.Queue, 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].(*taskspb.Queue), nil 135} 136 137func (s *mockCloudTasksServer) PauseQueue(ctx context.Context, req *taskspb.PauseQueueRequest) (*taskspb.Queue, 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].(*taskspb.Queue), nil 147} 148 149func (s *mockCloudTasksServer) ResumeQueue(ctx context.Context, req *taskspb.ResumeQueueRequest) (*taskspb.Queue, error) { 150 md, _ := metadata.FromIncomingContext(ctx) 151 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 152 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 153 } 154 s.reqs = append(s.reqs, req) 155 if s.err != nil { 156 return nil, s.err 157 } 158 return s.resps[0].(*taskspb.Queue), nil 159} 160 161func (s *mockCloudTasksServer) GetIamPolicy(ctx context.Context, req *iampb.GetIamPolicyRequest) (*iampb.Policy, error) { 162 md, _ := metadata.FromIncomingContext(ctx) 163 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 164 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 165 } 166 s.reqs = append(s.reqs, req) 167 if s.err != nil { 168 return nil, s.err 169 } 170 return s.resps[0].(*iampb.Policy), nil 171} 172 173func (s *mockCloudTasksServer) SetIamPolicy(ctx context.Context, req *iampb.SetIamPolicyRequest) (*iampb.Policy, error) { 174 md, _ := metadata.FromIncomingContext(ctx) 175 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 176 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 177 } 178 s.reqs = append(s.reqs, req) 179 if s.err != nil { 180 return nil, s.err 181 } 182 return s.resps[0].(*iampb.Policy), nil 183} 184 185func (s *mockCloudTasksServer) TestIamPermissions(ctx context.Context, req *iampb.TestIamPermissionsRequest) (*iampb.TestIamPermissionsResponse, error) { 186 md, _ := metadata.FromIncomingContext(ctx) 187 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 188 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 189 } 190 s.reqs = append(s.reqs, req) 191 if s.err != nil { 192 return nil, s.err 193 } 194 return s.resps[0].(*iampb.TestIamPermissionsResponse), nil 195} 196 197func (s *mockCloudTasksServer) ListTasks(ctx context.Context, req *taskspb.ListTasksRequest) (*taskspb.ListTasksResponse, error) { 198 md, _ := metadata.FromIncomingContext(ctx) 199 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 200 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 201 } 202 s.reqs = append(s.reqs, req) 203 if s.err != nil { 204 return nil, s.err 205 } 206 return s.resps[0].(*taskspb.ListTasksResponse), nil 207} 208 209func (s *mockCloudTasksServer) GetTask(ctx context.Context, req *taskspb.GetTaskRequest) (*taskspb.Task, error) { 210 md, _ := metadata.FromIncomingContext(ctx) 211 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 212 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 213 } 214 s.reqs = append(s.reqs, req) 215 if s.err != nil { 216 return nil, s.err 217 } 218 return s.resps[0].(*taskspb.Task), nil 219} 220 221func (s *mockCloudTasksServer) CreateTask(ctx context.Context, req *taskspb.CreateTaskRequest) (*taskspb.Task, error) { 222 md, _ := metadata.FromIncomingContext(ctx) 223 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 224 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 225 } 226 s.reqs = append(s.reqs, req) 227 if s.err != nil { 228 return nil, s.err 229 } 230 return s.resps[0].(*taskspb.Task), nil 231} 232 233func (s *mockCloudTasksServer) DeleteTask(ctx context.Context, req *taskspb.DeleteTaskRequest) (*emptypb.Empty, error) { 234 md, _ := metadata.FromIncomingContext(ctx) 235 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 236 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 237 } 238 s.reqs = append(s.reqs, req) 239 if s.err != nil { 240 return nil, s.err 241 } 242 return s.resps[0].(*emptypb.Empty), nil 243} 244 245func (s *mockCloudTasksServer) RunTask(ctx context.Context, req *taskspb.RunTaskRequest) (*taskspb.Task, error) { 246 md, _ := metadata.FromIncomingContext(ctx) 247 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 248 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 249 } 250 s.reqs = append(s.reqs, req) 251 if s.err != nil { 252 return nil, s.err 253 } 254 return s.resps[0].(*taskspb.Task), nil 255} 256 257// clientOpt is the option tests should use to connect to the test server. 258// It is initialized by TestMain. 259var clientOpt option.ClientOption 260 261var ( 262 mockCloudTasks mockCloudTasksServer 263) 264 265func TestMain(m *testing.M) { 266 flag.Parse() 267 268 serv := grpc.NewServer() 269 taskspb.RegisterCloudTasksServer(serv, &mockCloudTasks) 270 271 lis, err := net.Listen("tcp", "localhost:0") 272 if err != nil { 273 log.Fatal(err) 274 } 275 go serv.Serve(lis) 276 277 conn, err := grpc.Dial(lis.Addr().String(), grpc.WithInsecure()) 278 if err != nil { 279 log.Fatal(err) 280 } 281 clientOpt = option.WithGRPCConn(conn) 282 283 os.Exit(m.Run()) 284} 285 286func TestCloudTasksListQueues(t *testing.T) { 287 var nextPageToken string = "" 288 var queuesElement *taskspb.Queue = &taskspb.Queue{} 289 var queues = []*taskspb.Queue{queuesElement} 290 var expectedResponse = &taskspb.ListQueuesResponse{ 291 NextPageToken: nextPageToken, 292 Queues: queues, 293 } 294 295 mockCloudTasks.err = nil 296 mockCloudTasks.reqs = nil 297 298 mockCloudTasks.resps = append(mockCloudTasks.resps[:0], expectedResponse) 299 300 var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]") 301 var request = &taskspb.ListQueuesRequest{ 302 Parent: formattedParent, 303 } 304 305 c, err := NewClient(context.Background(), clientOpt) 306 if err != nil { 307 t.Fatal(err) 308 } 309 310 resp, err := c.ListQueues(context.Background(), request).Next() 311 312 if err != nil { 313 t.Fatal(err) 314 } 315 316 if want, got := request, mockCloudTasks.reqs[0]; !proto.Equal(want, got) { 317 t.Errorf("wrong request %q, want %q", got, want) 318 } 319 320 want := (interface{})(expectedResponse.Queues[0]) 321 got := (interface{})(resp) 322 var ok bool 323 324 switch want := (want).(type) { 325 case proto.Message: 326 ok = proto.Equal(want, got.(proto.Message)) 327 default: 328 ok = want == got 329 } 330 if !ok { 331 t.Errorf("wrong response %q, want %q)", got, want) 332 } 333} 334 335func TestCloudTasksListQueuesError(t *testing.T) { 336 errCode := codes.PermissionDenied 337 mockCloudTasks.err = gstatus.Error(errCode, "test error") 338 339 var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]") 340 var request = &taskspb.ListQueuesRequest{ 341 Parent: formattedParent, 342 } 343 344 c, err := NewClient(context.Background(), clientOpt) 345 if err != nil { 346 t.Fatal(err) 347 } 348 349 resp, err := c.ListQueues(context.Background(), request).Next() 350 351 if st, ok := gstatus.FromError(err); !ok { 352 t.Errorf("got error %v, expected grpc error", err) 353 } else if c := st.Code(); c != errCode { 354 t.Errorf("got error code %q, want %q", c, errCode) 355 } 356 _ = resp 357} 358func TestCloudTasksGetQueue(t *testing.T) { 359 var name2 string = "name2-1052831874" 360 var expectedResponse = &taskspb.Queue{ 361 Name: name2, 362 } 363 364 mockCloudTasks.err = nil 365 mockCloudTasks.reqs = nil 366 367 mockCloudTasks.resps = append(mockCloudTasks.resps[:0], expectedResponse) 368 369 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 370 var request = &taskspb.GetQueueRequest{ 371 Name: formattedName, 372 } 373 374 c, err := NewClient(context.Background(), clientOpt) 375 if err != nil { 376 t.Fatal(err) 377 } 378 379 resp, err := c.GetQueue(context.Background(), request) 380 381 if err != nil { 382 t.Fatal(err) 383 } 384 385 if want, got := request, mockCloudTasks.reqs[0]; !proto.Equal(want, got) { 386 t.Errorf("wrong request %q, want %q", got, want) 387 } 388 389 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 390 t.Errorf("wrong response %q, want %q)", got, want) 391 } 392} 393 394func TestCloudTasksGetQueueError(t *testing.T) { 395 errCode := codes.PermissionDenied 396 mockCloudTasks.err = gstatus.Error(errCode, "test error") 397 398 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 399 var request = &taskspb.GetQueueRequest{ 400 Name: formattedName, 401 } 402 403 c, err := NewClient(context.Background(), clientOpt) 404 if err != nil { 405 t.Fatal(err) 406 } 407 408 resp, err := c.GetQueue(context.Background(), request) 409 410 if st, ok := gstatus.FromError(err); !ok { 411 t.Errorf("got error %v, expected grpc error", err) 412 } else if c := st.Code(); c != errCode { 413 t.Errorf("got error code %q, want %q", c, errCode) 414 } 415 _ = resp 416} 417func TestCloudTasksCreateQueue(t *testing.T) { 418 var name string = "name3373707" 419 var expectedResponse = &taskspb.Queue{ 420 Name: name, 421 } 422 423 mockCloudTasks.err = nil 424 mockCloudTasks.reqs = nil 425 426 mockCloudTasks.resps = append(mockCloudTasks.resps[:0], expectedResponse) 427 428 var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]") 429 var queue *taskspb.Queue = &taskspb.Queue{} 430 var request = &taskspb.CreateQueueRequest{ 431 Parent: formattedParent, 432 Queue: queue, 433 } 434 435 c, err := NewClient(context.Background(), clientOpt) 436 if err != nil { 437 t.Fatal(err) 438 } 439 440 resp, err := c.CreateQueue(context.Background(), request) 441 442 if err != nil { 443 t.Fatal(err) 444 } 445 446 if want, got := request, mockCloudTasks.reqs[0]; !proto.Equal(want, got) { 447 t.Errorf("wrong request %q, want %q", got, want) 448 } 449 450 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 451 t.Errorf("wrong response %q, want %q)", got, want) 452 } 453} 454 455func TestCloudTasksCreateQueueError(t *testing.T) { 456 errCode := codes.PermissionDenied 457 mockCloudTasks.err = gstatus.Error(errCode, "test error") 458 459 var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]") 460 var queue *taskspb.Queue = &taskspb.Queue{} 461 var request = &taskspb.CreateQueueRequest{ 462 Parent: formattedParent, 463 Queue: queue, 464 } 465 466 c, err := NewClient(context.Background(), clientOpt) 467 if err != nil { 468 t.Fatal(err) 469 } 470 471 resp, err := c.CreateQueue(context.Background(), request) 472 473 if st, ok := gstatus.FromError(err); !ok { 474 t.Errorf("got error %v, expected grpc error", err) 475 } else if c := st.Code(); c != errCode { 476 t.Errorf("got error code %q, want %q", c, errCode) 477 } 478 _ = resp 479} 480func TestCloudTasksUpdateQueue(t *testing.T) { 481 var name string = "name3373707" 482 var expectedResponse = &taskspb.Queue{ 483 Name: name, 484 } 485 486 mockCloudTasks.err = nil 487 mockCloudTasks.reqs = nil 488 489 mockCloudTasks.resps = append(mockCloudTasks.resps[:0], expectedResponse) 490 491 var queue *taskspb.Queue = &taskspb.Queue{} 492 var request = &taskspb.UpdateQueueRequest{ 493 Queue: queue, 494 } 495 496 c, err := NewClient(context.Background(), clientOpt) 497 if err != nil { 498 t.Fatal(err) 499 } 500 501 resp, err := c.UpdateQueue(context.Background(), request) 502 503 if err != nil { 504 t.Fatal(err) 505 } 506 507 if want, got := request, mockCloudTasks.reqs[0]; !proto.Equal(want, got) { 508 t.Errorf("wrong request %q, want %q", got, want) 509 } 510 511 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 512 t.Errorf("wrong response %q, want %q)", got, want) 513 } 514} 515 516func TestCloudTasksUpdateQueueError(t *testing.T) { 517 errCode := codes.PermissionDenied 518 mockCloudTasks.err = gstatus.Error(errCode, "test error") 519 520 var queue *taskspb.Queue = &taskspb.Queue{} 521 var request = &taskspb.UpdateQueueRequest{ 522 Queue: queue, 523 } 524 525 c, err := NewClient(context.Background(), clientOpt) 526 if err != nil { 527 t.Fatal(err) 528 } 529 530 resp, err := c.UpdateQueue(context.Background(), request) 531 532 if st, ok := gstatus.FromError(err); !ok { 533 t.Errorf("got error %v, expected grpc error", err) 534 } else if c := st.Code(); c != errCode { 535 t.Errorf("got error code %q, want %q", c, errCode) 536 } 537 _ = resp 538} 539func TestCloudTasksDeleteQueue(t *testing.T) { 540 var expectedResponse *emptypb.Empty = &emptypb.Empty{} 541 542 mockCloudTasks.err = nil 543 mockCloudTasks.reqs = nil 544 545 mockCloudTasks.resps = append(mockCloudTasks.resps[:0], expectedResponse) 546 547 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 548 var request = &taskspb.DeleteQueueRequest{ 549 Name: formattedName, 550 } 551 552 c, err := NewClient(context.Background(), clientOpt) 553 if err != nil { 554 t.Fatal(err) 555 } 556 557 err = c.DeleteQueue(context.Background(), request) 558 559 if err != nil { 560 t.Fatal(err) 561 } 562 563 if want, got := request, mockCloudTasks.reqs[0]; !proto.Equal(want, got) { 564 t.Errorf("wrong request %q, want %q", got, want) 565 } 566 567} 568 569func TestCloudTasksDeleteQueueError(t *testing.T) { 570 errCode := codes.PermissionDenied 571 mockCloudTasks.err = gstatus.Error(errCode, "test error") 572 573 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 574 var request = &taskspb.DeleteQueueRequest{ 575 Name: formattedName, 576 } 577 578 c, err := NewClient(context.Background(), clientOpt) 579 if err != nil { 580 t.Fatal(err) 581 } 582 583 err = c.DeleteQueue(context.Background(), request) 584 585 if st, ok := gstatus.FromError(err); !ok { 586 t.Errorf("got error %v, expected grpc error", err) 587 } else if c := st.Code(); c != errCode { 588 t.Errorf("got error code %q, want %q", c, errCode) 589 } 590} 591func TestCloudTasksPurgeQueue(t *testing.T) { 592 var name2 string = "name2-1052831874" 593 var expectedResponse = &taskspb.Queue{ 594 Name: name2, 595 } 596 597 mockCloudTasks.err = nil 598 mockCloudTasks.reqs = nil 599 600 mockCloudTasks.resps = append(mockCloudTasks.resps[:0], expectedResponse) 601 602 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 603 var request = &taskspb.PurgeQueueRequest{ 604 Name: formattedName, 605 } 606 607 c, err := NewClient(context.Background(), clientOpt) 608 if err != nil { 609 t.Fatal(err) 610 } 611 612 resp, err := c.PurgeQueue(context.Background(), request) 613 614 if err != nil { 615 t.Fatal(err) 616 } 617 618 if want, got := request, mockCloudTasks.reqs[0]; !proto.Equal(want, got) { 619 t.Errorf("wrong request %q, want %q", got, want) 620 } 621 622 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 623 t.Errorf("wrong response %q, want %q)", got, want) 624 } 625} 626 627func TestCloudTasksPurgeQueueError(t *testing.T) { 628 errCode := codes.PermissionDenied 629 mockCloudTasks.err = gstatus.Error(errCode, "test error") 630 631 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 632 var request = &taskspb.PurgeQueueRequest{ 633 Name: formattedName, 634 } 635 636 c, err := NewClient(context.Background(), clientOpt) 637 if err != nil { 638 t.Fatal(err) 639 } 640 641 resp, err := c.PurgeQueue(context.Background(), request) 642 643 if st, ok := gstatus.FromError(err); !ok { 644 t.Errorf("got error %v, expected grpc error", err) 645 } else if c := st.Code(); c != errCode { 646 t.Errorf("got error code %q, want %q", c, errCode) 647 } 648 _ = resp 649} 650func TestCloudTasksPauseQueue(t *testing.T) { 651 var name2 string = "name2-1052831874" 652 var expectedResponse = &taskspb.Queue{ 653 Name: name2, 654 } 655 656 mockCloudTasks.err = nil 657 mockCloudTasks.reqs = nil 658 659 mockCloudTasks.resps = append(mockCloudTasks.resps[:0], expectedResponse) 660 661 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 662 var request = &taskspb.PauseQueueRequest{ 663 Name: formattedName, 664 } 665 666 c, err := NewClient(context.Background(), clientOpt) 667 if err != nil { 668 t.Fatal(err) 669 } 670 671 resp, err := c.PauseQueue(context.Background(), request) 672 673 if err != nil { 674 t.Fatal(err) 675 } 676 677 if want, got := request, mockCloudTasks.reqs[0]; !proto.Equal(want, got) { 678 t.Errorf("wrong request %q, want %q", got, want) 679 } 680 681 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 682 t.Errorf("wrong response %q, want %q)", got, want) 683 } 684} 685 686func TestCloudTasksPauseQueueError(t *testing.T) { 687 errCode := codes.PermissionDenied 688 mockCloudTasks.err = gstatus.Error(errCode, "test error") 689 690 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 691 var request = &taskspb.PauseQueueRequest{ 692 Name: formattedName, 693 } 694 695 c, err := NewClient(context.Background(), clientOpt) 696 if err != nil { 697 t.Fatal(err) 698 } 699 700 resp, err := c.PauseQueue(context.Background(), request) 701 702 if st, ok := gstatus.FromError(err); !ok { 703 t.Errorf("got error %v, expected grpc error", err) 704 } else if c := st.Code(); c != errCode { 705 t.Errorf("got error code %q, want %q", c, errCode) 706 } 707 _ = resp 708} 709func TestCloudTasksResumeQueue(t *testing.T) { 710 var name2 string = "name2-1052831874" 711 var expectedResponse = &taskspb.Queue{ 712 Name: name2, 713 } 714 715 mockCloudTasks.err = nil 716 mockCloudTasks.reqs = nil 717 718 mockCloudTasks.resps = append(mockCloudTasks.resps[:0], expectedResponse) 719 720 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 721 var request = &taskspb.ResumeQueueRequest{ 722 Name: formattedName, 723 } 724 725 c, err := NewClient(context.Background(), clientOpt) 726 if err != nil { 727 t.Fatal(err) 728 } 729 730 resp, err := c.ResumeQueue(context.Background(), request) 731 732 if err != nil { 733 t.Fatal(err) 734 } 735 736 if want, got := request, mockCloudTasks.reqs[0]; !proto.Equal(want, got) { 737 t.Errorf("wrong request %q, want %q", got, want) 738 } 739 740 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 741 t.Errorf("wrong response %q, want %q)", got, want) 742 } 743} 744 745func TestCloudTasksResumeQueueError(t *testing.T) { 746 errCode := codes.PermissionDenied 747 mockCloudTasks.err = gstatus.Error(errCode, "test error") 748 749 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 750 var request = &taskspb.ResumeQueueRequest{ 751 Name: formattedName, 752 } 753 754 c, err := NewClient(context.Background(), clientOpt) 755 if err != nil { 756 t.Fatal(err) 757 } 758 759 resp, err := c.ResumeQueue(context.Background(), request) 760 761 if st, ok := gstatus.FromError(err); !ok { 762 t.Errorf("got error %v, expected grpc error", err) 763 } else if c := st.Code(); c != errCode { 764 t.Errorf("got error code %q, want %q", c, errCode) 765 } 766 _ = resp 767} 768func TestCloudTasksGetIamPolicy(t *testing.T) { 769 var version int32 = 351608024 770 var etag []byte = []byte("21") 771 var expectedResponse = &iampb.Policy{ 772 Version: version, 773 Etag: etag, 774 } 775 776 mockCloudTasks.err = nil 777 mockCloudTasks.reqs = nil 778 779 mockCloudTasks.resps = append(mockCloudTasks.resps[:0], expectedResponse) 780 781 var formattedResource string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 782 var request = &iampb.GetIamPolicyRequest{ 783 Resource: formattedResource, 784 } 785 786 c, err := NewClient(context.Background(), clientOpt) 787 if err != nil { 788 t.Fatal(err) 789 } 790 791 resp, err := c.GetIamPolicy(context.Background(), request) 792 793 if err != nil { 794 t.Fatal(err) 795 } 796 797 if want, got := request, mockCloudTasks.reqs[0]; !proto.Equal(want, got) { 798 t.Errorf("wrong request %q, want %q", got, want) 799 } 800 801 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 802 t.Errorf("wrong response %q, want %q)", got, want) 803 } 804} 805 806func TestCloudTasksGetIamPolicyError(t *testing.T) { 807 errCode := codes.PermissionDenied 808 mockCloudTasks.err = gstatus.Error(errCode, "test error") 809 810 var formattedResource string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 811 var request = &iampb.GetIamPolicyRequest{ 812 Resource: formattedResource, 813 } 814 815 c, err := NewClient(context.Background(), clientOpt) 816 if err != nil { 817 t.Fatal(err) 818 } 819 820 resp, err := c.GetIamPolicy(context.Background(), request) 821 822 if st, ok := gstatus.FromError(err); !ok { 823 t.Errorf("got error %v, expected grpc error", err) 824 } else if c := st.Code(); c != errCode { 825 t.Errorf("got error code %q, want %q", c, errCode) 826 } 827 _ = resp 828} 829func TestCloudTasksSetIamPolicy(t *testing.T) { 830 var version int32 = 351608024 831 var etag []byte = []byte("21") 832 var expectedResponse = &iampb.Policy{ 833 Version: version, 834 Etag: etag, 835 } 836 837 mockCloudTasks.err = nil 838 mockCloudTasks.reqs = nil 839 840 mockCloudTasks.resps = append(mockCloudTasks.resps[:0], expectedResponse) 841 842 var formattedResource string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 843 var policy *iampb.Policy = &iampb.Policy{} 844 var request = &iampb.SetIamPolicyRequest{ 845 Resource: formattedResource, 846 Policy: policy, 847 } 848 849 c, err := NewClient(context.Background(), clientOpt) 850 if err != nil { 851 t.Fatal(err) 852 } 853 854 resp, err := c.SetIamPolicy(context.Background(), request) 855 856 if err != nil { 857 t.Fatal(err) 858 } 859 860 if want, got := request, mockCloudTasks.reqs[0]; !proto.Equal(want, got) { 861 t.Errorf("wrong request %q, want %q", got, want) 862 } 863 864 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 865 t.Errorf("wrong response %q, want %q)", got, want) 866 } 867} 868 869func TestCloudTasksSetIamPolicyError(t *testing.T) { 870 errCode := codes.PermissionDenied 871 mockCloudTasks.err = gstatus.Error(errCode, "test error") 872 873 var formattedResource string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 874 var policy *iampb.Policy = &iampb.Policy{} 875 var request = &iampb.SetIamPolicyRequest{ 876 Resource: formattedResource, 877 Policy: policy, 878 } 879 880 c, err := NewClient(context.Background(), clientOpt) 881 if err != nil { 882 t.Fatal(err) 883 } 884 885 resp, err := c.SetIamPolicy(context.Background(), request) 886 887 if st, ok := gstatus.FromError(err); !ok { 888 t.Errorf("got error %v, expected grpc error", err) 889 } else if c := st.Code(); c != errCode { 890 t.Errorf("got error code %q, want %q", c, errCode) 891 } 892 _ = resp 893} 894func TestCloudTasksTestIamPermissions(t *testing.T) { 895 var expectedResponse *iampb.TestIamPermissionsResponse = &iampb.TestIamPermissionsResponse{} 896 897 mockCloudTasks.err = nil 898 mockCloudTasks.reqs = nil 899 900 mockCloudTasks.resps = append(mockCloudTasks.resps[:0], expectedResponse) 901 902 var formattedResource string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 903 var permissions []string = nil 904 var request = &iampb.TestIamPermissionsRequest{ 905 Resource: formattedResource, 906 Permissions: permissions, 907 } 908 909 c, err := NewClient(context.Background(), clientOpt) 910 if err != nil { 911 t.Fatal(err) 912 } 913 914 resp, err := c.TestIamPermissions(context.Background(), request) 915 916 if err != nil { 917 t.Fatal(err) 918 } 919 920 if want, got := request, mockCloudTasks.reqs[0]; !proto.Equal(want, got) { 921 t.Errorf("wrong request %q, want %q", got, want) 922 } 923 924 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 925 t.Errorf("wrong response %q, want %q)", got, want) 926 } 927} 928 929func TestCloudTasksTestIamPermissionsError(t *testing.T) { 930 errCode := codes.PermissionDenied 931 mockCloudTasks.err = gstatus.Error(errCode, "test error") 932 933 var formattedResource string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 934 var permissions []string = nil 935 var request = &iampb.TestIamPermissionsRequest{ 936 Resource: formattedResource, 937 Permissions: permissions, 938 } 939 940 c, err := NewClient(context.Background(), clientOpt) 941 if err != nil { 942 t.Fatal(err) 943 } 944 945 resp, err := c.TestIamPermissions(context.Background(), request) 946 947 if st, ok := gstatus.FromError(err); !ok { 948 t.Errorf("got error %v, expected grpc error", err) 949 } else if c := st.Code(); c != errCode { 950 t.Errorf("got error code %q, want %q", c, errCode) 951 } 952 _ = resp 953} 954func TestCloudTasksListTasks(t *testing.T) { 955 var nextPageToken string = "" 956 var tasksElement *taskspb.Task = &taskspb.Task{} 957 var tasks = []*taskspb.Task{tasksElement} 958 var expectedResponse = &taskspb.ListTasksResponse{ 959 NextPageToken: nextPageToken, 960 Tasks: tasks, 961 } 962 963 mockCloudTasks.err = nil 964 mockCloudTasks.reqs = nil 965 966 mockCloudTasks.resps = append(mockCloudTasks.resps[:0], expectedResponse) 967 968 var formattedParent string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 969 var request = &taskspb.ListTasksRequest{ 970 Parent: formattedParent, 971 } 972 973 c, err := NewClient(context.Background(), clientOpt) 974 if err != nil { 975 t.Fatal(err) 976 } 977 978 resp, err := c.ListTasks(context.Background(), request).Next() 979 980 if err != nil { 981 t.Fatal(err) 982 } 983 984 if want, got := request, mockCloudTasks.reqs[0]; !proto.Equal(want, got) { 985 t.Errorf("wrong request %q, want %q", got, want) 986 } 987 988 want := (interface{})(expectedResponse.Tasks[0]) 989 got := (interface{})(resp) 990 var ok bool 991 992 switch want := (want).(type) { 993 case proto.Message: 994 ok = proto.Equal(want, got.(proto.Message)) 995 default: 996 ok = want == got 997 } 998 if !ok { 999 t.Errorf("wrong response %q, want %q)", got, want) 1000 } 1001} 1002 1003func TestCloudTasksListTasksError(t *testing.T) { 1004 errCode := codes.PermissionDenied 1005 mockCloudTasks.err = gstatus.Error(errCode, "test error") 1006 1007 var formattedParent string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 1008 var request = &taskspb.ListTasksRequest{ 1009 Parent: formattedParent, 1010 } 1011 1012 c, err := NewClient(context.Background(), clientOpt) 1013 if err != nil { 1014 t.Fatal(err) 1015 } 1016 1017 resp, err := c.ListTasks(context.Background(), request).Next() 1018 1019 if st, ok := gstatus.FromError(err); !ok { 1020 t.Errorf("got error %v, expected grpc error", err) 1021 } else if c := st.Code(); c != errCode { 1022 t.Errorf("got error code %q, want %q", c, errCode) 1023 } 1024 _ = resp 1025} 1026func TestCloudTasksGetTask(t *testing.T) { 1027 var name2 string = "name2-1052831874" 1028 var dispatchCount int32 = 1217252086 1029 var responseCount int32 = 424727441 1030 var expectedResponse = &taskspb.Task{ 1031 Name: name2, 1032 DispatchCount: dispatchCount, 1033 ResponseCount: responseCount, 1034 } 1035 1036 mockCloudTasks.err = nil 1037 mockCloudTasks.reqs = nil 1038 1039 mockCloudTasks.resps = append(mockCloudTasks.resps[:0], expectedResponse) 1040 1041 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/queues/%s/tasks/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]", "[TASK]") 1042 var request = &taskspb.GetTaskRequest{ 1043 Name: formattedName, 1044 } 1045 1046 c, err := NewClient(context.Background(), clientOpt) 1047 if err != nil { 1048 t.Fatal(err) 1049 } 1050 1051 resp, err := c.GetTask(context.Background(), request) 1052 1053 if err != nil { 1054 t.Fatal(err) 1055 } 1056 1057 if want, got := request, mockCloudTasks.reqs[0]; !proto.Equal(want, got) { 1058 t.Errorf("wrong request %q, want %q", got, want) 1059 } 1060 1061 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1062 t.Errorf("wrong response %q, want %q)", got, want) 1063 } 1064} 1065 1066func TestCloudTasksGetTaskError(t *testing.T) { 1067 errCode := codes.PermissionDenied 1068 mockCloudTasks.err = gstatus.Error(errCode, "test error") 1069 1070 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/queues/%s/tasks/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]", "[TASK]") 1071 var request = &taskspb.GetTaskRequest{ 1072 Name: formattedName, 1073 } 1074 1075 c, err := NewClient(context.Background(), clientOpt) 1076 if err != nil { 1077 t.Fatal(err) 1078 } 1079 1080 resp, err := c.GetTask(context.Background(), request) 1081 1082 if st, ok := gstatus.FromError(err); !ok { 1083 t.Errorf("got error %v, expected grpc error", err) 1084 } else if c := st.Code(); c != errCode { 1085 t.Errorf("got error code %q, want %q", c, errCode) 1086 } 1087 _ = resp 1088} 1089func TestCloudTasksCreateTask(t *testing.T) { 1090 var name string = "name3373707" 1091 var dispatchCount int32 = 1217252086 1092 var responseCount int32 = 424727441 1093 var expectedResponse = &taskspb.Task{ 1094 Name: name, 1095 DispatchCount: dispatchCount, 1096 ResponseCount: responseCount, 1097 } 1098 1099 mockCloudTasks.err = nil 1100 mockCloudTasks.reqs = nil 1101 1102 mockCloudTasks.resps = append(mockCloudTasks.resps[:0], expectedResponse) 1103 1104 var formattedParent string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 1105 var task *taskspb.Task = &taskspb.Task{} 1106 var request = &taskspb.CreateTaskRequest{ 1107 Parent: formattedParent, 1108 Task: task, 1109 } 1110 1111 c, err := NewClient(context.Background(), clientOpt) 1112 if err != nil { 1113 t.Fatal(err) 1114 } 1115 1116 resp, err := c.CreateTask(context.Background(), request) 1117 1118 if err != nil { 1119 t.Fatal(err) 1120 } 1121 1122 if want, got := request, mockCloudTasks.reqs[0]; !proto.Equal(want, got) { 1123 t.Errorf("wrong request %q, want %q", got, want) 1124 } 1125 1126 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1127 t.Errorf("wrong response %q, want %q)", got, want) 1128 } 1129} 1130 1131func TestCloudTasksCreateTaskError(t *testing.T) { 1132 errCode := codes.PermissionDenied 1133 mockCloudTasks.err = gstatus.Error(errCode, "test error") 1134 1135 var formattedParent string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 1136 var task *taskspb.Task = &taskspb.Task{} 1137 var request = &taskspb.CreateTaskRequest{ 1138 Parent: formattedParent, 1139 Task: task, 1140 } 1141 1142 c, err := NewClient(context.Background(), clientOpt) 1143 if err != nil { 1144 t.Fatal(err) 1145 } 1146 1147 resp, err := c.CreateTask(context.Background(), request) 1148 1149 if st, ok := gstatus.FromError(err); !ok { 1150 t.Errorf("got error %v, expected grpc error", err) 1151 } else if c := st.Code(); c != errCode { 1152 t.Errorf("got error code %q, want %q", c, errCode) 1153 } 1154 _ = resp 1155} 1156func TestCloudTasksDeleteTask(t *testing.T) { 1157 var expectedResponse *emptypb.Empty = &emptypb.Empty{} 1158 1159 mockCloudTasks.err = nil 1160 mockCloudTasks.reqs = nil 1161 1162 mockCloudTasks.resps = append(mockCloudTasks.resps[:0], expectedResponse) 1163 1164 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/queues/%s/tasks/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]", "[TASK]") 1165 var request = &taskspb.DeleteTaskRequest{ 1166 Name: formattedName, 1167 } 1168 1169 c, err := NewClient(context.Background(), clientOpt) 1170 if err != nil { 1171 t.Fatal(err) 1172 } 1173 1174 err = c.DeleteTask(context.Background(), request) 1175 1176 if err != nil { 1177 t.Fatal(err) 1178 } 1179 1180 if want, got := request, mockCloudTasks.reqs[0]; !proto.Equal(want, got) { 1181 t.Errorf("wrong request %q, want %q", got, want) 1182 } 1183 1184} 1185 1186func TestCloudTasksDeleteTaskError(t *testing.T) { 1187 errCode := codes.PermissionDenied 1188 mockCloudTasks.err = gstatus.Error(errCode, "test error") 1189 1190 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/queues/%s/tasks/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]", "[TASK]") 1191 var request = &taskspb.DeleteTaskRequest{ 1192 Name: formattedName, 1193 } 1194 1195 c, err := NewClient(context.Background(), clientOpt) 1196 if err != nil { 1197 t.Fatal(err) 1198 } 1199 1200 err = c.DeleteTask(context.Background(), request) 1201 1202 if st, ok := gstatus.FromError(err); !ok { 1203 t.Errorf("got error %v, expected grpc error", err) 1204 } else if c := st.Code(); c != errCode { 1205 t.Errorf("got error code %q, want %q", c, errCode) 1206 } 1207} 1208func TestCloudTasksRunTask(t *testing.T) { 1209 var name2 string = "name2-1052831874" 1210 var dispatchCount int32 = 1217252086 1211 var responseCount int32 = 424727441 1212 var expectedResponse = &taskspb.Task{ 1213 Name: name2, 1214 DispatchCount: dispatchCount, 1215 ResponseCount: responseCount, 1216 } 1217 1218 mockCloudTasks.err = nil 1219 mockCloudTasks.reqs = nil 1220 1221 mockCloudTasks.resps = append(mockCloudTasks.resps[:0], expectedResponse) 1222 1223 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/queues/%s/tasks/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]", "[TASK]") 1224 var request = &taskspb.RunTaskRequest{ 1225 Name: formattedName, 1226 } 1227 1228 c, err := NewClient(context.Background(), clientOpt) 1229 if err != nil { 1230 t.Fatal(err) 1231 } 1232 1233 resp, err := c.RunTask(context.Background(), request) 1234 1235 if err != nil { 1236 t.Fatal(err) 1237 } 1238 1239 if want, got := request, mockCloudTasks.reqs[0]; !proto.Equal(want, got) { 1240 t.Errorf("wrong request %q, want %q", got, want) 1241 } 1242 1243 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1244 t.Errorf("wrong response %q, want %q)", got, want) 1245 } 1246} 1247 1248func TestCloudTasksRunTaskError(t *testing.T) { 1249 errCode := codes.PermissionDenied 1250 mockCloudTasks.err = gstatus.Error(errCode, "test error") 1251 1252 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/queues/%s/tasks/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]", "[TASK]") 1253 var request = &taskspb.RunTaskRequest{ 1254 Name: formattedName, 1255 } 1256 1257 c, err := NewClient(context.Background(), clientOpt) 1258 if err != nil { 1259 t.Fatal(err) 1260 } 1261 1262 resp, err := c.RunTask(context.Background(), request) 1263 1264 if st, ok := gstatus.FromError(err); !ok { 1265 t.Errorf("got error %v, expected grpc error", err) 1266 } else if c := st.Code(); c != errCode { 1267 t.Errorf("got error code %q, want %q", c, errCode) 1268 } 1269 _ = resp 1270} 1271