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