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