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 = &timestamppb.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 = &timestamppb.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 = &timestamppb.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 = &timestamppb.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 = &timestamppb.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 = &timestamppb.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