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 "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 durationpb "github.com/golang/protobuf/ptypes/duration" 33 emptypb "github.com/golang/protobuf/ptypes/empty" 34 timestamppb "github.com/golang/protobuf/ptypes/timestamp" 35 "google.golang.org/api/option" 36 taskspb "google.golang.org/genproto/googleapis/cloud/tasks/v2beta2" 37 iampb "google.golang.org/genproto/googleapis/iam/v1" 38 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 44 gstatus "google.golang.org/grpc/status" 45) 46 47var _ = io.EOF 48var _ = ptypes.MarshalAny 49var _ status.Status 50 51type mockCloudTasksServer struct { 52 // Embed for forward compatibility. 53 // Tests will keep working if more methods are added 54 // in the future. 55 taskspb.CloudTasksServer 56 57 reqs []proto.Message 58 59 // If set, all calls return this error. 60 err error 61 62 // responses to return if err == nil 63 resps []proto.Message 64} 65 66func (s *mockCloudTasksServer) ListQueues(ctx context.Context, req *taskspb.ListQueuesRequest) (*taskspb.ListQueuesResponse, error) { 67 md, _ := metadata.FromIncomingContext(ctx) 68 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 69 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 70 } 71 s.reqs = append(s.reqs, req) 72 if s.err != nil { 73 return nil, s.err 74 } 75 return s.resps[0].(*taskspb.ListQueuesResponse), nil 76} 77 78func (s *mockCloudTasksServer) GetQueue(ctx context.Context, req *taskspb.GetQueueRequest) (*taskspb.Queue, error) { 79 md, _ := metadata.FromIncomingContext(ctx) 80 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 81 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 82 } 83 s.reqs = append(s.reqs, req) 84 if s.err != nil { 85 return nil, s.err 86 } 87 return s.resps[0].(*taskspb.Queue), nil 88} 89 90func (s *mockCloudTasksServer) CreateQueue(ctx context.Context, req *taskspb.CreateQueueRequest) (*taskspb.Queue, error) { 91 md, _ := metadata.FromIncomingContext(ctx) 92 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 93 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 94 } 95 s.reqs = append(s.reqs, req) 96 if s.err != nil { 97 return nil, s.err 98 } 99 return s.resps[0].(*taskspb.Queue), nil 100} 101 102func (s *mockCloudTasksServer) UpdateQueue(ctx context.Context, req *taskspb.UpdateQueueRequest) (*taskspb.Queue, error) { 103 md, _ := metadata.FromIncomingContext(ctx) 104 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 105 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 106 } 107 s.reqs = append(s.reqs, req) 108 if s.err != nil { 109 return nil, s.err 110 } 111 return s.resps[0].(*taskspb.Queue), nil 112} 113 114func (s *mockCloudTasksServer) DeleteQueue(ctx context.Context, req *taskspb.DeleteQueueRequest) (*emptypb.Empty, error) { 115 md, _ := metadata.FromIncomingContext(ctx) 116 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 117 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 118 } 119 s.reqs = append(s.reqs, req) 120 if s.err != nil { 121 return nil, s.err 122 } 123 return s.resps[0].(*emptypb.Empty), nil 124} 125 126func (s *mockCloudTasksServer) PurgeQueue(ctx context.Context, req *taskspb.PurgeQueueRequest) (*taskspb.Queue, error) { 127 md, _ := metadata.FromIncomingContext(ctx) 128 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 129 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 130 } 131 s.reqs = append(s.reqs, req) 132 if s.err != nil { 133 return nil, s.err 134 } 135 return s.resps[0].(*taskspb.Queue), nil 136} 137 138func (s *mockCloudTasksServer) PauseQueue(ctx context.Context, req *taskspb.PauseQueueRequest) (*taskspb.Queue, error) { 139 md, _ := metadata.FromIncomingContext(ctx) 140 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 141 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 142 } 143 s.reqs = append(s.reqs, req) 144 if s.err != nil { 145 return nil, s.err 146 } 147 return s.resps[0].(*taskspb.Queue), nil 148} 149 150func (s *mockCloudTasksServer) ResumeQueue(ctx context.Context, req *taskspb.ResumeQueueRequest) (*taskspb.Queue, error) { 151 md, _ := metadata.FromIncomingContext(ctx) 152 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 153 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 154 } 155 s.reqs = append(s.reqs, req) 156 if s.err != nil { 157 return nil, s.err 158 } 159 return s.resps[0].(*taskspb.Queue), nil 160} 161 162func (s *mockCloudTasksServer) GetIamPolicy(ctx context.Context, req *iampb.GetIamPolicyRequest) (*iampb.Policy, error) { 163 md, _ := metadata.FromIncomingContext(ctx) 164 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 165 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 166 } 167 s.reqs = append(s.reqs, req) 168 if s.err != nil { 169 return nil, s.err 170 } 171 return s.resps[0].(*iampb.Policy), nil 172} 173 174func (s *mockCloudTasksServer) SetIamPolicy(ctx context.Context, req *iampb.SetIamPolicyRequest) (*iampb.Policy, error) { 175 md, _ := metadata.FromIncomingContext(ctx) 176 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 177 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 178 } 179 s.reqs = append(s.reqs, req) 180 if s.err != nil { 181 return nil, s.err 182 } 183 return s.resps[0].(*iampb.Policy), nil 184} 185 186func (s *mockCloudTasksServer) TestIamPermissions(ctx context.Context, req *iampb.TestIamPermissionsRequest) (*iampb.TestIamPermissionsResponse, error) { 187 md, _ := metadata.FromIncomingContext(ctx) 188 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 189 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 190 } 191 s.reqs = append(s.reqs, req) 192 if s.err != nil { 193 return nil, s.err 194 } 195 return s.resps[0].(*iampb.TestIamPermissionsResponse), nil 196} 197 198func (s *mockCloudTasksServer) ListTasks(ctx context.Context, req *taskspb.ListTasksRequest) (*taskspb.ListTasksResponse, error) { 199 md, _ := metadata.FromIncomingContext(ctx) 200 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 201 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 202 } 203 s.reqs = append(s.reqs, req) 204 if s.err != nil { 205 return nil, s.err 206 } 207 return s.resps[0].(*taskspb.ListTasksResponse), nil 208} 209 210func (s *mockCloudTasksServer) GetTask(ctx context.Context, req *taskspb.GetTaskRequest) (*taskspb.Task, error) { 211 md, _ := metadata.FromIncomingContext(ctx) 212 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 213 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 214 } 215 s.reqs = append(s.reqs, req) 216 if s.err != nil { 217 return nil, s.err 218 } 219 return s.resps[0].(*taskspb.Task), nil 220} 221 222func (s *mockCloudTasksServer) CreateTask(ctx context.Context, req *taskspb.CreateTaskRequest) (*taskspb.Task, error) { 223 md, _ := metadata.FromIncomingContext(ctx) 224 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 225 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 226 } 227 s.reqs = append(s.reqs, req) 228 if s.err != nil { 229 return nil, s.err 230 } 231 return s.resps[0].(*taskspb.Task), nil 232} 233 234func (s *mockCloudTasksServer) DeleteTask(ctx context.Context, req *taskspb.DeleteTaskRequest) (*emptypb.Empty, error) { 235 md, _ := metadata.FromIncomingContext(ctx) 236 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 237 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 238 } 239 s.reqs = append(s.reqs, req) 240 if s.err != nil { 241 return nil, s.err 242 } 243 return s.resps[0].(*emptypb.Empty), nil 244} 245 246func (s *mockCloudTasksServer) LeaseTasks(ctx context.Context, req *taskspb.LeaseTasksRequest) (*taskspb.LeaseTasksResponse, error) { 247 md, _ := metadata.FromIncomingContext(ctx) 248 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 249 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 250 } 251 s.reqs = append(s.reqs, req) 252 if s.err != nil { 253 return nil, s.err 254 } 255 return s.resps[0].(*taskspb.LeaseTasksResponse), nil 256} 257 258func (s *mockCloudTasksServer) AcknowledgeTask(ctx context.Context, req *taskspb.AcknowledgeTaskRequest) (*emptypb.Empty, error) { 259 md, _ := metadata.FromIncomingContext(ctx) 260 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 261 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 262 } 263 s.reqs = append(s.reqs, req) 264 if s.err != nil { 265 return nil, s.err 266 } 267 return s.resps[0].(*emptypb.Empty), nil 268} 269 270func (s *mockCloudTasksServer) RenewLease(ctx context.Context, req *taskspb.RenewLeaseRequest) (*taskspb.Task, error) { 271 md, _ := metadata.FromIncomingContext(ctx) 272 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 273 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 274 } 275 s.reqs = append(s.reqs, req) 276 if s.err != nil { 277 return nil, s.err 278 } 279 return s.resps[0].(*taskspb.Task), nil 280} 281 282func (s *mockCloudTasksServer) CancelLease(ctx context.Context, req *taskspb.CancelLeaseRequest) (*taskspb.Task, error) { 283 md, _ := metadata.FromIncomingContext(ctx) 284 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 285 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 286 } 287 s.reqs = append(s.reqs, req) 288 if s.err != nil { 289 return nil, s.err 290 } 291 return s.resps[0].(*taskspb.Task), nil 292} 293 294func (s *mockCloudTasksServer) RunTask(ctx context.Context, req *taskspb.RunTaskRequest) (*taskspb.Task, error) { 295 md, _ := metadata.FromIncomingContext(ctx) 296 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 297 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 298 } 299 s.reqs = append(s.reqs, req) 300 if s.err != nil { 301 return nil, s.err 302 } 303 return s.resps[0].(*taskspb.Task), nil 304} 305 306// clientOpt is the option tests should use to connect to the test server. 307// It is initialized by TestMain. 308var clientOpt option.ClientOption 309 310var ( 311 mockCloudTasks mockCloudTasksServer 312) 313 314func TestMain(m *testing.M) { 315 flag.Parse() 316 317 serv := grpc.NewServer() 318 taskspb.RegisterCloudTasksServer(serv, &mockCloudTasks) 319 320 lis, err := net.Listen("tcp", "localhost:0") 321 if err != nil { 322 log.Fatal(err) 323 } 324 go serv.Serve(lis) 325 326 conn, err := grpc.Dial(lis.Addr().String(), grpc.WithInsecure()) 327 if err != nil { 328 log.Fatal(err) 329 } 330 clientOpt = option.WithGRPCConn(conn) 331 332 os.Exit(m.Run()) 333} 334 335func TestCloudTasksListQueues(t *testing.T) { 336 var nextPageToken string = "" 337 var queuesElement *taskspb.Queue = &taskspb.Queue{} 338 var queues = []*taskspb.Queue{queuesElement} 339 var expectedResponse = &taskspb.ListQueuesResponse{ 340 NextPageToken: nextPageToken, 341 Queues: queues, 342 } 343 344 mockCloudTasks.err = nil 345 mockCloudTasks.reqs = nil 346 347 mockCloudTasks.resps = append(mockCloudTasks.resps[:0], expectedResponse) 348 349 var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]") 350 var request = &taskspb.ListQueuesRequest{ 351 Parent: formattedParent, 352 } 353 354 c, err := NewClient(context.Background(), clientOpt) 355 if err != nil { 356 t.Fatal(err) 357 } 358 359 resp, err := c.ListQueues(context.Background(), request).Next() 360 361 if err != nil { 362 t.Fatal(err) 363 } 364 365 if want, got := request, mockCloudTasks.reqs[0]; !proto.Equal(want, got) { 366 t.Errorf("wrong request %q, want %q", got, want) 367 } 368 369 want := (interface{})(expectedResponse.Queues[0]) 370 got := (interface{})(resp) 371 var ok bool 372 373 switch want := (want).(type) { 374 case proto.Message: 375 ok = proto.Equal(want, got.(proto.Message)) 376 default: 377 ok = want == got 378 } 379 if !ok { 380 t.Errorf("wrong response %q, want %q)", got, want) 381 } 382} 383 384func TestCloudTasksListQueuesError(t *testing.T) { 385 errCode := codes.PermissionDenied 386 mockCloudTasks.err = gstatus.Error(errCode, "test error") 387 388 var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]") 389 var request = &taskspb.ListQueuesRequest{ 390 Parent: formattedParent, 391 } 392 393 c, err := NewClient(context.Background(), clientOpt) 394 if err != nil { 395 t.Fatal(err) 396 } 397 398 resp, err := c.ListQueues(context.Background(), request).Next() 399 400 if st, ok := gstatus.FromError(err); !ok { 401 t.Errorf("got error %v, expected grpc error", err) 402 } else if c := st.Code(); c != errCode { 403 t.Errorf("got error code %q, want %q", c, errCode) 404 } 405 _ = resp 406} 407func TestCloudTasksGetQueue(t *testing.T) { 408 var name2 string = "name2-1052831874" 409 var expectedResponse = &taskspb.Queue{ 410 Name: name2, 411 } 412 413 mockCloudTasks.err = nil 414 mockCloudTasks.reqs = nil 415 416 mockCloudTasks.resps = append(mockCloudTasks.resps[:0], expectedResponse) 417 418 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 419 var request = &taskspb.GetQueueRequest{ 420 Name: formattedName, 421 } 422 423 c, err := NewClient(context.Background(), clientOpt) 424 if err != nil { 425 t.Fatal(err) 426 } 427 428 resp, err := c.GetQueue(context.Background(), request) 429 430 if err != nil { 431 t.Fatal(err) 432 } 433 434 if want, got := request, mockCloudTasks.reqs[0]; !proto.Equal(want, got) { 435 t.Errorf("wrong request %q, want %q", got, want) 436 } 437 438 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 439 t.Errorf("wrong response %q, want %q)", got, want) 440 } 441} 442 443func TestCloudTasksGetQueueError(t *testing.T) { 444 errCode := codes.PermissionDenied 445 mockCloudTasks.err = gstatus.Error(errCode, "test error") 446 447 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 448 var request = &taskspb.GetQueueRequest{ 449 Name: formattedName, 450 } 451 452 c, err := NewClient(context.Background(), clientOpt) 453 if err != nil { 454 t.Fatal(err) 455 } 456 457 resp, err := c.GetQueue(context.Background(), request) 458 459 if st, ok := gstatus.FromError(err); !ok { 460 t.Errorf("got error %v, expected grpc error", err) 461 } else if c := st.Code(); c != errCode { 462 t.Errorf("got error code %q, want %q", c, errCode) 463 } 464 _ = resp 465} 466func TestCloudTasksCreateQueue(t *testing.T) { 467 var name string = "name3373707" 468 var expectedResponse = &taskspb.Queue{ 469 Name: name, 470 } 471 472 mockCloudTasks.err = nil 473 mockCloudTasks.reqs = nil 474 475 mockCloudTasks.resps = append(mockCloudTasks.resps[:0], expectedResponse) 476 477 var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]") 478 var queue *taskspb.Queue = &taskspb.Queue{} 479 var request = &taskspb.CreateQueueRequest{ 480 Parent: formattedParent, 481 Queue: queue, 482 } 483 484 c, err := NewClient(context.Background(), clientOpt) 485 if err != nil { 486 t.Fatal(err) 487 } 488 489 resp, err := c.CreateQueue(context.Background(), request) 490 491 if err != nil { 492 t.Fatal(err) 493 } 494 495 if want, got := request, mockCloudTasks.reqs[0]; !proto.Equal(want, got) { 496 t.Errorf("wrong request %q, want %q", got, want) 497 } 498 499 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 500 t.Errorf("wrong response %q, want %q)", got, want) 501 } 502} 503 504func TestCloudTasksCreateQueueError(t *testing.T) { 505 errCode := codes.PermissionDenied 506 mockCloudTasks.err = gstatus.Error(errCode, "test error") 507 508 var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]") 509 var queue *taskspb.Queue = &taskspb.Queue{} 510 var request = &taskspb.CreateQueueRequest{ 511 Parent: formattedParent, 512 Queue: queue, 513 } 514 515 c, err := NewClient(context.Background(), clientOpt) 516 if err != nil { 517 t.Fatal(err) 518 } 519 520 resp, err := c.CreateQueue(context.Background(), request) 521 522 if st, ok := gstatus.FromError(err); !ok { 523 t.Errorf("got error %v, expected grpc error", err) 524 } else if c := st.Code(); c != errCode { 525 t.Errorf("got error code %q, want %q", c, errCode) 526 } 527 _ = resp 528} 529func TestCloudTasksUpdateQueue(t *testing.T) { 530 var name string = "name3373707" 531 var expectedResponse = &taskspb.Queue{ 532 Name: name, 533 } 534 535 mockCloudTasks.err = nil 536 mockCloudTasks.reqs = nil 537 538 mockCloudTasks.resps = append(mockCloudTasks.resps[:0], expectedResponse) 539 540 var queue *taskspb.Queue = &taskspb.Queue{} 541 var request = &taskspb.UpdateQueueRequest{ 542 Queue: queue, 543 } 544 545 c, err := NewClient(context.Background(), clientOpt) 546 if err != nil { 547 t.Fatal(err) 548 } 549 550 resp, err := c.UpdateQueue(context.Background(), request) 551 552 if err != nil { 553 t.Fatal(err) 554 } 555 556 if want, got := request, mockCloudTasks.reqs[0]; !proto.Equal(want, got) { 557 t.Errorf("wrong request %q, want %q", got, want) 558 } 559 560 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 561 t.Errorf("wrong response %q, want %q)", got, want) 562 } 563} 564 565func TestCloudTasksUpdateQueueError(t *testing.T) { 566 errCode := codes.PermissionDenied 567 mockCloudTasks.err = gstatus.Error(errCode, "test error") 568 569 var queue *taskspb.Queue = &taskspb.Queue{} 570 var request = &taskspb.UpdateQueueRequest{ 571 Queue: queue, 572 } 573 574 c, err := NewClient(context.Background(), clientOpt) 575 if err != nil { 576 t.Fatal(err) 577 } 578 579 resp, err := c.UpdateQueue(context.Background(), request) 580 581 if st, ok := gstatus.FromError(err); !ok { 582 t.Errorf("got error %v, expected grpc error", err) 583 } else if c := st.Code(); c != errCode { 584 t.Errorf("got error code %q, want %q", c, errCode) 585 } 586 _ = resp 587} 588func TestCloudTasksDeleteQueue(t *testing.T) { 589 var expectedResponse *emptypb.Empty = &emptypb.Empty{} 590 591 mockCloudTasks.err = nil 592 mockCloudTasks.reqs = nil 593 594 mockCloudTasks.resps = append(mockCloudTasks.resps[:0], expectedResponse) 595 596 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 597 var request = &taskspb.DeleteQueueRequest{ 598 Name: formattedName, 599 } 600 601 c, err := NewClient(context.Background(), clientOpt) 602 if err != nil { 603 t.Fatal(err) 604 } 605 606 err = c.DeleteQueue(context.Background(), request) 607 608 if err != nil { 609 t.Fatal(err) 610 } 611 612 if want, got := request, mockCloudTasks.reqs[0]; !proto.Equal(want, got) { 613 t.Errorf("wrong request %q, want %q", got, want) 614 } 615 616} 617 618func TestCloudTasksDeleteQueueError(t *testing.T) { 619 errCode := codes.PermissionDenied 620 mockCloudTasks.err = gstatus.Error(errCode, "test error") 621 622 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 623 var request = &taskspb.DeleteQueueRequest{ 624 Name: formattedName, 625 } 626 627 c, err := NewClient(context.Background(), clientOpt) 628 if err != nil { 629 t.Fatal(err) 630 } 631 632 err = c.DeleteQueue(context.Background(), request) 633 634 if st, ok := gstatus.FromError(err); !ok { 635 t.Errorf("got error %v, expected grpc error", err) 636 } else if c := st.Code(); c != errCode { 637 t.Errorf("got error code %q, want %q", c, errCode) 638 } 639} 640func TestCloudTasksPurgeQueue(t *testing.T) { 641 var name2 string = "name2-1052831874" 642 var expectedResponse = &taskspb.Queue{ 643 Name: name2, 644 } 645 646 mockCloudTasks.err = nil 647 mockCloudTasks.reqs = nil 648 649 mockCloudTasks.resps = append(mockCloudTasks.resps[:0], expectedResponse) 650 651 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 652 var request = &taskspb.PurgeQueueRequest{ 653 Name: formattedName, 654 } 655 656 c, err := NewClient(context.Background(), clientOpt) 657 if err != nil { 658 t.Fatal(err) 659 } 660 661 resp, err := c.PurgeQueue(context.Background(), request) 662 663 if err != nil { 664 t.Fatal(err) 665 } 666 667 if want, got := request, mockCloudTasks.reqs[0]; !proto.Equal(want, got) { 668 t.Errorf("wrong request %q, want %q", got, want) 669 } 670 671 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 672 t.Errorf("wrong response %q, want %q)", got, want) 673 } 674} 675 676func TestCloudTasksPurgeQueueError(t *testing.T) { 677 errCode := codes.PermissionDenied 678 mockCloudTasks.err = gstatus.Error(errCode, "test error") 679 680 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 681 var request = &taskspb.PurgeQueueRequest{ 682 Name: formattedName, 683 } 684 685 c, err := NewClient(context.Background(), clientOpt) 686 if err != nil { 687 t.Fatal(err) 688 } 689 690 resp, err := c.PurgeQueue(context.Background(), request) 691 692 if st, ok := gstatus.FromError(err); !ok { 693 t.Errorf("got error %v, expected grpc error", err) 694 } else if c := st.Code(); c != errCode { 695 t.Errorf("got error code %q, want %q", c, errCode) 696 } 697 _ = resp 698} 699func TestCloudTasksPauseQueue(t *testing.T) { 700 var name2 string = "name2-1052831874" 701 var expectedResponse = &taskspb.Queue{ 702 Name: name2, 703 } 704 705 mockCloudTasks.err = nil 706 mockCloudTasks.reqs = nil 707 708 mockCloudTasks.resps = append(mockCloudTasks.resps[:0], expectedResponse) 709 710 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 711 var request = &taskspb.PauseQueueRequest{ 712 Name: formattedName, 713 } 714 715 c, err := NewClient(context.Background(), clientOpt) 716 if err != nil { 717 t.Fatal(err) 718 } 719 720 resp, err := c.PauseQueue(context.Background(), request) 721 722 if err != nil { 723 t.Fatal(err) 724 } 725 726 if want, got := request, mockCloudTasks.reqs[0]; !proto.Equal(want, got) { 727 t.Errorf("wrong request %q, want %q", got, want) 728 } 729 730 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 731 t.Errorf("wrong response %q, want %q)", got, want) 732 } 733} 734 735func TestCloudTasksPauseQueueError(t *testing.T) { 736 errCode := codes.PermissionDenied 737 mockCloudTasks.err = gstatus.Error(errCode, "test error") 738 739 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 740 var request = &taskspb.PauseQueueRequest{ 741 Name: formattedName, 742 } 743 744 c, err := NewClient(context.Background(), clientOpt) 745 if err != nil { 746 t.Fatal(err) 747 } 748 749 resp, err := c.PauseQueue(context.Background(), request) 750 751 if st, ok := gstatus.FromError(err); !ok { 752 t.Errorf("got error %v, expected grpc error", err) 753 } else if c := st.Code(); c != errCode { 754 t.Errorf("got error code %q, want %q", c, errCode) 755 } 756 _ = resp 757} 758func TestCloudTasksResumeQueue(t *testing.T) { 759 var name2 string = "name2-1052831874" 760 var expectedResponse = &taskspb.Queue{ 761 Name: name2, 762 } 763 764 mockCloudTasks.err = nil 765 mockCloudTasks.reqs = nil 766 767 mockCloudTasks.resps = append(mockCloudTasks.resps[:0], expectedResponse) 768 769 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 770 var request = &taskspb.ResumeQueueRequest{ 771 Name: formattedName, 772 } 773 774 c, err := NewClient(context.Background(), clientOpt) 775 if err != nil { 776 t.Fatal(err) 777 } 778 779 resp, err := c.ResumeQueue(context.Background(), request) 780 781 if err != nil { 782 t.Fatal(err) 783 } 784 785 if want, got := request, mockCloudTasks.reqs[0]; !proto.Equal(want, got) { 786 t.Errorf("wrong request %q, want %q", got, want) 787 } 788 789 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 790 t.Errorf("wrong response %q, want %q)", got, want) 791 } 792} 793 794func TestCloudTasksResumeQueueError(t *testing.T) { 795 errCode := codes.PermissionDenied 796 mockCloudTasks.err = gstatus.Error(errCode, "test error") 797 798 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 799 var request = &taskspb.ResumeQueueRequest{ 800 Name: formattedName, 801 } 802 803 c, err := NewClient(context.Background(), clientOpt) 804 if err != nil { 805 t.Fatal(err) 806 } 807 808 resp, err := c.ResumeQueue(context.Background(), request) 809 810 if st, ok := gstatus.FromError(err); !ok { 811 t.Errorf("got error %v, expected grpc error", err) 812 } else if c := st.Code(); c != errCode { 813 t.Errorf("got error code %q, want %q", c, errCode) 814 } 815 _ = resp 816} 817func TestCloudTasksGetIamPolicy(t *testing.T) { 818 var version int32 = 351608024 819 var etag []byte = []byte("21") 820 var expectedResponse = &iampb.Policy{ 821 Version: version, 822 Etag: etag, 823 } 824 825 mockCloudTasks.err = nil 826 mockCloudTasks.reqs = nil 827 828 mockCloudTasks.resps = append(mockCloudTasks.resps[:0], expectedResponse) 829 830 var formattedResource string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 831 var request = &iampb.GetIamPolicyRequest{ 832 Resource: formattedResource, 833 } 834 835 c, err := NewClient(context.Background(), clientOpt) 836 if err != nil { 837 t.Fatal(err) 838 } 839 840 resp, err := c.GetIamPolicy(context.Background(), request) 841 842 if err != nil { 843 t.Fatal(err) 844 } 845 846 if want, got := request, mockCloudTasks.reqs[0]; !proto.Equal(want, got) { 847 t.Errorf("wrong request %q, want %q", got, want) 848 } 849 850 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 851 t.Errorf("wrong response %q, want %q)", got, want) 852 } 853} 854 855func TestCloudTasksGetIamPolicyError(t *testing.T) { 856 errCode := codes.PermissionDenied 857 mockCloudTasks.err = gstatus.Error(errCode, "test error") 858 859 var formattedResource string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 860 var request = &iampb.GetIamPolicyRequest{ 861 Resource: formattedResource, 862 } 863 864 c, err := NewClient(context.Background(), clientOpt) 865 if err != nil { 866 t.Fatal(err) 867 } 868 869 resp, err := c.GetIamPolicy(context.Background(), request) 870 871 if st, ok := gstatus.FromError(err); !ok { 872 t.Errorf("got error %v, expected grpc error", err) 873 } else if c := st.Code(); c != errCode { 874 t.Errorf("got error code %q, want %q", c, errCode) 875 } 876 _ = resp 877} 878func TestCloudTasksSetIamPolicy(t *testing.T) { 879 var version int32 = 351608024 880 var etag []byte = []byte("21") 881 var expectedResponse = &iampb.Policy{ 882 Version: version, 883 Etag: etag, 884 } 885 886 mockCloudTasks.err = nil 887 mockCloudTasks.reqs = nil 888 889 mockCloudTasks.resps = append(mockCloudTasks.resps[:0], expectedResponse) 890 891 var formattedResource string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 892 var policy *iampb.Policy = &iampb.Policy{} 893 var request = &iampb.SetIamPolicyRequest{ 894 Resource: formattedResource, 895 Policy: policy, 896 } 897 898 c, err := NewClient(context.Background(), clientOpt) 899 if err != nil { 900 t.Fatal(err) 901 } 902 903 resp, err := c.SetIamPolicy(context.Background(), request) 904 905 if err != nil { 906 t.Fatal(err) 907 } 908 909 if want, got := request, mockCloudTasks.reqs[0]; !proto.Equal(want, got) { 910 t.Errorf("wrong request %q, want %q", got, want) 911 } 912 913 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 914 t.Errorf("wrong response %q, want %q)", got, want) 915 } 916} 917 918func TestCloudTasksSetIamPolicyError(t *testing.T) { 919 errCode := codes.PermissionDenied 920 mockCloudTasks.err = gstatus.Error(errCode, "test error") 921 922 var formattedResource string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 923 var policy *iampb.Policy = &iampb.Policy{} 924 var request = &iampb.SetIamPolicyRequest{ 925 Resource: formattedResource, 926 Policy: policy, 927 } 928 929 c, err := NewClient(context.Background(), clientOpt) 930 if err != nil { 931 t.Fatal(err) 932 } 933 934 resp, err := c.SetIamPolicy(context.Background(), request) 935 936 if st, ok := gstatus.FromError(err); !ok { 937 t.Errorf("got error %v, expected grpc error", err) 938 } else if c := st.Code(); c != errCode { 939 t.Errorf("got error code %q, want %q", c, errCode) 940 } 941 _ = resp 942} 943func TestCloudTasksTestIamPermissions(t *testing.T) { 944 var expectedResponse *iampb.TestIamPermissionsResponse = &iampb.TestIamPermissionsResponse{} 945 946 mockCloudTasks.err = nil 947 mockCloudTasks.reqs = nil 948 949 mockCloudTasks.resps = append(mockCloudTasks.resps[:0], expectedResponse) 950 951 var formattedResource string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 952 var permissions []string = nil 953 var request = &iampb.TestIamPermissionsRequest{ 954 Resource: formattedResource, 955 Permissions: permissions, 956 } 957 958 c, err := NewClient(context.Background(), clientOpt) 959 if err != nil { 960 t.Fatal(err) 961 } 962 963 resp, err := c.TestIamPermissions(context.Background(), request) 964 965 if err != nil { 966 t.Fatal(err) 967 } 968 969 if want, got := request, mockCloudTasks.reqs[0]; !proto.Equal(want, got) { 970 t.Errorf("wrong request %q, want %q", got, want) 971 } 972 973 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 974 t.Errorf("wrong response %q, want %q)", got, want) 975 } 976} 977 978func TestCloudTasksTestIamPermissionsError(t *testing.T) { 979 errCode := codes.PermissionDenied 980 mockCloudTasks.err = gstatus.Error(errCode, "test error") 981 982 var formattedResource string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 983 var permissions []string = nil 984 var request = &iampb.TestIamPermissionsRequest{ 985 Resource: formattedResource, 986 Permissions: permissions, 987 } 988 989 c, err := NewClient(context.Background(), clientOpt) 990 if err != nil { 991 t.Fatal(err) 992 } 993 994 resp, err := c.TestIamPermissions(context.Background(), request) 995 996 if st, ok := gstatus.FromError(err); !ok { 997 t.Errorf("got error %v, expected grpc error", err) 998 } else if c := st.Code(); c != errCode { 999 t.Errorf("got error code %q, want %q", c, errCode) 1000 } 1001 _ = resp 1002} 1003func TestCloudTasksListTasks(t *testing.T) { 1004 var nextPageToken string = "" 1005 var tasksElement *taskspb.Task = &taskspb.Task{} 1006 var tasks = []*taskspb.Task{tasksElement} 1007 var expectedResponse = &taskspb.ListTasksResponse{ 1008 NextPageToken: nextPageToken, 1009 Tasks: tasks, 1010 } 1011 1012 mockCloudTasks.err = nil 1013 mockCloudTasks.reqs = nil 1014 1015 mockCloudTasks.resps = append(mockCloudTasks.resps[:0], expectedResponse) 1016 1017 var formattedParent string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 1018 var request = &taskspb.ListTasksRequest{ 1019 Parent: formattedParent, 1020 } 1021 1022 c, err := NewClient(context.Background(), clientOpt) 1023 if err != nil { 1024 t.Fatal(err) 1025 } 1026 1027 resp, err := c.ListTasks(context.Background(), request).Next() 1028 1029 if err != nil { 1030 t.Fatal(err) 1031 } 1032 1033 if want, got := request, mockCloudTasks.reqs[0]; !proto.Equal(want, got) { 1034 t.Errorf("wrong request %q, want %q", got, want) 1035 } 1036 1037 want := (interface{})(expectedResponse.Tasks[0]) 1038 got := (interface{})(resp) 1039 var ok bool 1040 1041 switch want := (want).(type) { 1042 case proto.Message: 1043 ok = proto.Equal(want, got.(proto.Message)) 1044 default: 1045 ok = want == got 1046 } 1047 if !ok { 1048 t.Errorf("wrong response %q, want %q)", got, want) 1049 } 1050} 1051 1052func TestCloudTasksListTasksError(t *testing.T) { 1053 errCode := codes.PermissionDenied 1054 mockCloudTasks.err = gstatus.Error(errCode, "test error") 1055 1056 var formattedParent string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 1057 var request = &taskspb.ListTasksRequest{ 1058 Parent: formattedParent, 1059 } 1060 1061 c, err := NewClient(context.Background(), clientOpt) 1062 if err != nil { 1063 t.Fatal(err) 1064 } 1065 1066 resp, err := c.ListTasks(context.Background(), request).Next() 1067 1068 if st, ok := gstatus.FromError(err); !ok { 1069 t.Errorf("got error %v, expected grpc error", err) 1070 } else if c := st.Code(); c != errCode { 1071 t.Errorf("got error code %q, want %q", c, errCode) 1072 } 1073 _ = resp 1074} 1075func TestCloudTasksGetTask(t *testing.T) { 1076 var name2 string = "name2-1052831874" 1077 var expectedResponse = &taskspb.Task{ 1078 Name: name2, 1079 } 1080 1081 mockCloudTasks.err = nil 1082 mockCloudTasks.reqs = nil 1083 1084 mockCloudTasks.resps = append(mockCloudTasks.resps[:0], expectedResponse) 1085 1086 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/queues/%s/tasks/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]", "[TASK]") 1087 var request = &taskspb.GetTaskRequest{ 1088 Name: formattedName, 1089 } 1090 1091 c, err := NewClient(context.Background(), clientOpt) 1092 if err != nil { 1093 t.Fatal(err) 1094 } 1095 1096 resp, err := c.GetTask(context.Background(), request) 1097 1098 if err != nil { 1099 t.Fatal(err) 1100 } 1101 1102 if want, got := request, mockCloudTasks.reqs[0]; !proto.Equal(want, got) { 1103 t.Errorf("wrong request %q, want %q", got, want) 1104 } 1105 1106 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1107 t.Errorf("wrong response %q, want %q)", got, want) 1108 } 1109} 1110 1111func TestCloudTasksGetTaskError(t *testing.T) { 1112 errCode := codes.PermissionDenied 1113 mockCloudTasks.err = gstatus.Error(errCode, "test error") 1114 1115 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/queues/%s/tasks/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]", "[TASK]") 1116 var request = &taskspb.GetTaskRequest{ 1117 Name: formattedName, 1118 } 1119 1120 c, err := NewClient(context.Background(), clientOpt) 1121 if err != nil { 1122 t.Fatal(err) 1123 } 1124 1125 resp, err := c.GetTask(context.Background(), request) 1126 1127 if st, ok := gstatus.FromError(err); !ok { 1128 t.Errorf("got error %v, expected grpc error", err) 1129 } else if c := st.Code(); c != errCode { 1130 t.Errorf("got error code %q, want %q", c, errCode) 1131 } 1132 _ = resp 1133} 1134func TestCloudTasksCreateTask(t *testing.T) { 1135 var name string = "name3373707" 1136 var expectedResponse = &taskspb.Task{ 1137 Name: name, 1138 } 1139 1140 mockCloudTasks.err = nil 1141 mockCloudTasks.reqs = nil 1142 1143 mockCloudTasks.resps = append(mockCloudTasks.resps[:0], expectedResponse) 1144 1145 var formattedParent string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 1146 var task *taskspb.Task = &taskspb.Task{} 1147 var request = &taskspb.CreateTaskRequest{ 1148 Parent: formattedParent, 1149 Task: task, 1150 } 1151 1152 c, err := NewClient(context.Background(), clientOpt) 1153 if err != nil { 1154 t.Fatal(err) 1155 } 1156 1157 resp, err := c.CreateTask(context.Background(), request) 1158 1159 if err != nil { 1160 t.Fatal(err) 1161 } 1162 1163 if want, got := request, mockCloudTasks.reqs[0]; !proto.Equal(want, got) { 1164 t.Errorf("wrong request %q, want %q", got, want) 1165 } 1166 1167 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1168 t.Errorf("wrong response %q, want %q)", got, want) 1169 } 1170} 1171 1172func TestCloudTasksCreateTaskError(t *testing.T) { 1173 errCode := codes.PermissionDenied 1174 mockCloudTasks.err = gstatus.Error(errCode, "test error") 1175 1176 var formattedParent string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 1177 var task *taskspb.Task = &taskspb.Task{} 1178 var request = &taskspb.CreateTaskRequest{ 1179 Parent: formattedParent, 1180 Task: task, 1181 } 1182 1183 c, err := NewClient(context.Background(), clientOpt) 1184 if err != nil { 1185 t.Fatal(err) 1186 } 1187 1188 resp, err := c.CreateTask(context.Background(), request) 1189 1190 if st, ok := gstatus.FromError(err); !ok { 1191 t.Errorf("got error %v, expected grpc error", err) 1192 } else if c := st.Code(); c != errCode { 1193 t.Errorf("got error code %q, want %q", c, errCode) 1194 } 1195 _ = resp 1196} 1197func TestCloudTasksDeleteTask(t *testing.T) { 1198 var expectedResponse *emptypb.Empty = &emptypb.Empty{} 1199 1200 mockCloudTasks.err = nil 1201 mockCloudTasks.reqs = nil 1202 1203 mockCloudTasks.resps = append(mockCloudTasks.resps[:0], expectedResponse) 1204 1205 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/queues/%s/tasks/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]", "[TASK]") 1206 var request = &taskspb.DeleteTaskRequest{ 1207 Name: formattedName, 1208 } 1209 1210 c, err := NewClient(context.Background(), clientOpt) 1211 if err != nil { 1212 t.Fatal(err) 1213 } 1214 1215 err = c.DeleteTask(context.Background(), request) 1216 1217 if err != nil { 1218 t.Fatal(err) 1219 } 1220 1221 if want, got := request, mockCloudTasks.reqs[0]; !proto.Equal(want, got) { 1222 t.Errorf("wrong request %q, want %q", got, want) 1223 } 1224 1225} 1226 1227func TestCloudTasksDeleteTaskError(t *testing.T) { 1228 errCode := codes.PermissionDenied 1229 mockCloudTasks.err = gstatus.Error(errCode, "test error") 1230 1231 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/queues/%s/tasks/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]", "[TASK]") 1232 var request = &taskspb.DeleteTaskRequest{ 1233 Name: formattedName, 1234 } 1235 1236 c, err := NewClient(context.Background(), clientOpt) 1237 if err != nil { 1238 t.Fatal(err) 1239 } 1240 1241 err = c.DeleteTask(context.Background(), request) 1242 1243 if st, ok := gstatus.FromError(err); !ok { 1244 t.Errorf("got error %v, expected grpc error", err) 1245 } else if c := st.Code(); c != errCode { 1246 t.Errorf("got error code %q, want %q", c, errCode) 1247 } 1248} 1249func TestCloudTasksLeaseTasks(t *testing.T) { 1250 var expectedResponse *taskspb.LeaseTasksResponse = &taskspb.LeaseTasksResponse{} 1251 1252 mockCloudTasks.err = nil 1253 mockCloudTasks.reqs = nil 1254 1255 mockCloudTasks.resps = append(mockCloudTasks.resps[:0], expectedResponse) 1256 1257 var formattedParent string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 1258 var leaseDuration *durationpb.Duration = &durationpb.Duration{} 1259 var request = &taskspb.LeaseTasksRequest{ 1260 Parent: formattedParent, 1261 LeaseDuration: leaseDuration, 1262 } 1263 1264 c, err := NewClient(context.Background(), clientOpt) 1265 if err != nil { 1266 t.Fatal(err) 1267 } 1268 1269 resp, err := c.LeaseTasks(context.Background(), request) 1270 1271 if err != nil { 1272 t.Fatal(err) 1273 } 1274 1275 if want, got := request, mockCloudTasks.reqs[0]; !proto.Equal(want, got) { 1276 t.Errorf("wrong request %q, want %q", got, want) 1277 } 1278 1279 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1280 t.Errorf("wrong response %q, want %q)", got, want) 1281 } 1282} 1283 1284func TestCloudTasksLeaseTasksError(t *testing.T) { 1285 errCode := codes.PermissionDenied 1286 mockCloudTasks.err = gstatus.Error(errCode, "test error") 1287 1288 var formattedParent string = fmt.Sprintf("projects/%s/locations/%s/queues/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]") 1289 var leaseDuration *durationpb.Duration = &durationpb.Duration{} 1290 var request = &taskspb.LeaseTasksRequest{ 1291 Parent: formattedParent, 1292 LeaseDuration: leaseDuration, 1293 } 1294 1295 c, err := NewClient(context.Background(), clientOpt) 1296 if err != nil { 1297 t.Fatal(err) 1298 } 1299 1300 resp, err := c.LeaseTasks(context.Background(), request) 1301 1302 if st, ok := gstatus.FromError(err); !ok { 1303 t.Errorf("got error %v, expected grpc error", err) 1304 } else if c := st.Code(); c != errCode { 1305 t.Errorf("got error code %q, want %q", c, errCode) 1306 } 1307 _ = resp 1308} 1309func TestCloudTasksAcknowledgeTask(t *testing.T) { 1310 var expectedResponse *emptypb.Empty = &emptypb.Empty{} 1311 1312 mockCloudTasks.err = nil 1313 mockCloudTasks.reqs = nil 1314 1315 mockCloudTasks.resps = append(mockCloudTasks.resps[:0], expectedResponse) 1316 1317 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/queues/%s/tasks/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]", "[TASK]") 1318 var scheduleTime *timestamppb.Timestamp = ×tamppb.Timestamp{} 1319 var request = &taskspb.AcknowledgeTaskRequest{ 1320 Name: formattedName, 1321 ScheduleTime: scheduleTime, 1322 } 1323 1324 c, err := NewClient(context.Background(), clientOpt) 1325 if err != nil { 1326 t.Fatal(err) 1327 } 1328 1329 err = c.AcknowledgeTask(context.Background(), request) 1330 1331 if err != nil { 1332 t.Fatal(err) 1333 } 1334 1335 if want, got := request, mockCloudTasks.reqs[0]; !proto.Equal(want, got) { 1336 t.Errorf("wrong request %q, want %q", got, want) 1337 } 1338 1339} 1340 1341func TestCloudTasksAcknowledgeTaskError(t *testing.T) { 1342 errCode := codes.PermissionDenied 1343 mockCloudTasks.err = gstatus.Error(errCode, "test error") 1344 1345 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/queues/%s/tasks/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]", "[TASK]") 1346 var scheduleTime *timestamppb.Timestamp = ×tamppb.Timestamp{} 1347 var request = &taskspb.AcknowledgeTaskRequest{ 1348 Name: formattedName, 1349 ScheduleTime: scheduleTime, 1350 } 1351 1352 c, err := NewClient(context.Background(), clientOpt) 1353 if err != nil { 1354 t.Fatal(err) 1355 } 1356 1357 err = c.AcknowledgeTask(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} 1365func TestCloudTasksRenewLease(t *testing.T) { 1366 var name2 string = "name2-1052831874" 1367 var expectedResponse = &taskspb.Task{ 1368 Name: name2, 1369 } 1370 1371 mockCloudTasks.err = nil 1372 mockCloudTasks.reqs = nil 1373 1374 mockCloudTasks.resps = append(mockCloudTasks.resps[:0], expectedResponse) 1375 1376 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/queues/%s/tasks/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]", "[TASK]") 1377 var scheduleTime *timestamppb.Timestamp = ×tamppb.Timestamp{} 1378 var leaseDuration *durationpb.Duration = &durationpb.Duration{} 1379 var request = &taskspb.RenewLeaseRequest{ 1380 Name: formattedName, 1381 ScheduleTime: scheduleTime, 1382 LeaseDuration: leaseDuration, 1383 } 1384 1385 c, err := NewClient(context.Background(), clientOpt) 1386 if err != nil { 1387 t.Fatal(err) 1388 } 1389 1390 resp, err := c.RenewLease(context.Background(), request) 1391 1392 if err != nil { 1393 t.Fatal(err) 1394 } 1395 1396 if want, got := request, mockCloudTasks.reqs[0]; !proto.Equal(want, got) { 1397 t.Errorf("wrong request %q, want %q", got, want) 1398 } 1399 1400 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1401 t.Errorf("wrong response %q, want %q)", got, want) 1402 } 1403} 1404 1405func TestCloudTasksRenewLeaseError(t *testing.T) { 1406 errCode := codes.PermissionDenied 1407 mockCloudTasks.err = gstatus.Error(errCode, "test error") 1408 1409 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/queues/%s/tasks/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]", "[TASK]") 1410 var scheduleTime *timestamppb.Timestamp = ×tamppb.Timestamp{} 1411 var leaseDuration *durationpb.Duration = &durationpb.Duration{} 1412 var request = &taskspb.RenewLeaseRequest{ 1413 Name: formattedName, 1414 ScheduleTime: scheduleTime, 1415 LeaseDuration: leaseDuration, 1416 } 1417 1418 c, err := NewClient(context.Background(), clientOpt) 1419 if err != nil { 1420 t.Fatal(err) 1421 } 1422 1423 resp, err := c.RenewLease(context.Background(), request) 1424 1425 if st, ok := gstatus.FromError(err); !ok { 1426 t.Errorf("got error %v, expected grpc error", err) 1427 } else if c := st.Code(); c != errCode { 1428 t.Errorf("got error code %q, want %q", c, errCode) 1429 } 1430 _ = resp 1431} 1432func TestCloudTasksCancelLease(t *testing.T) { 1433 var name2 string = "name2-1052831874" 1434 var expectedResponse = &taskspb.Task{ 1435 Name: name2, 1436 } 1437 1438 mockCloudTasks.err = nil 1439 mockCloudTasks.reqs = nil 1440 1441 mockCloudTasks.resps = append(mockCloudTasks.resps[:0], expectedResponse) 1442 1443 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/queues/%s/tasks/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]", "[TASK]") 1444 var scheduleTime *timestamppb.Timestamp = ×tamppb.Timestamp{} 1445 var request = &taskspb.CancelLeaseRequest{ 1446 Name: formattedName, 1447 ScheduleTime: scheduleTime, 1448 } 1449 1450 c, err := NewClient(context.Background(), clientOpt) 1451 if err != nil { 1452 t.Fatal(err) 1453 } 1454 1455 resp, err := c.CancelLease(context.Background(), request) 1456 1457 if err != nil { 1458 t.Fatal(err) 1459 } 1460 1461 if want, got := request, mockCloudTasks.reqs[0]; !proto.Equal(want, got) { 1462 t.Errorf("wrong request %q, want %q", got, want) 1463 } 1464 1465 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1466 t.Errorf("wrong response %q, want %q)", got, want) 1467 } 1468} 1469 1470func TestCloudTasksCancelLeaseError(t *testing.T) { 1471 errCode := codes.PermissionDenied 1472 mockCloudTasks.err = gstatus.Error(errCode, "test error") 1473 1474 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/queues/%s/tasks/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]", "[TASK]") 1475 var scheduleTime *timestamppb.Timestamp = ×tamppb.Timestamp{} 1476 var request = &taskspb.CancelLeaseRequest{ 1477 Name: formattedName, 1478 ScheduleTime: scheduleTime, 1479 } 1480 1481 c, err := NewClient(context.Background(), clientOpt) 1482 if err != nil { 1483 t.Fatal(err) 1484 } 1485 1486 resp, err := c.CancelLease(context.Background(), request) 1487 1488 if st, ok := gstatus.FromError(err); !ok { 1489 t.Errorf("got error %v, expected grpc error", err) 1490 } else if c := st.Code(); c != errCode { 1491 t.Errorf("got error code %q, want %q", c, errCode) 1492 } 1493 _ = resp 1494} 1495func TestCloudTasksRunTask(t *testing.T) { 1496 var name2 string = "name2-1052831874" 1497 var expectedResponse = &taskspb.Task{ 1498 Name: name2, 1499 } 1500 1501 mockCloudTasks.err = nil 1502 mockCloudTasks.reqs = nil 1503 1504 mockCloudTasks.resps = append(mockCloudTasks.resps[:0], expectedResponse) 1505 1506 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/queues/%s/tasks/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]", "[TASK]") 1507 var request = &taskspb.RunTaskRequest{ 1508 Name: formattedName, 1509 } 1510 1511 c, err := NewClient(context.Background(), clientOpt) 1512 if err != nil { 1513 t.Fatal(err) 1514 } 1515 1516 resp, err := c.RunTask(context.Background(), request) 1517 1518 if err != nil { 1519 t.Fatal(err) 1520 } 1521 1522 if want, got := request, mockCloudTasks.reqs[0]; !proto.Equal(want, got) { 1523 t.Errorf("wrong request %q, want %q", got, want) 1524 } 1525 1526 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1527 t.Errorf("wrong response %q, want %q)", got, want) 1528 } 1529} 1530 1531func TestCloudTasksRunTaskError(t *testing.T) { 1532 errCode := codes.PermissionDenied 1533 mockCloudTasks.err = gstatus.Error(errCode, "test error") 1534 1535 var formattedName string = fmt.Sprintf("projects/%s/locations/%s/queues/%s/tasks/%s", "[PROJECT]", "[LOCATION]", "[QUEUE]", "[TASK]") 1536 var request = &taskspb.RunTaskRequest{ 1537 Name: formattedName, 1538 } 1539 1540 c, err := NewClient(context.Background(), clientOpt) 1541 if err != nil { 1542 t.Fatal(err) 1543 } 1544 1545 resp, err := c.RunTask(context.Background(), request) 1546 1547 if st, ok := gstatus.FromError(err); !ok { 1548 t.Errorf("got error %v, expected grpc error", err) 1549 } else if c := st.Code(); c != errCode { 1550 t.Errorf("got error code %q, want %q", c, errCode) 1551 } 1552 _ = resp 1553} 1554