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 dataproc
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	dataprocpb "google.golang.org/genproto/googleapis/cloud/dataproc/v1"
35	longrunningpb "google.golang.org/genproto/googleapis/longrunning"
36	field_maskpb "google.golang.org/genproto/protobuf/field_mask"
37
38	status "google.golang.org/genproto/googleapis/rpc/status"
39	"google.golang.org/grpc"
40	"google.golang.org/grpc/codes"
41	"google.golang.org/grpc/metadata"
42
43	gstatus "google.golang.org/grpc/status"
44)
45
46var _ = io.EOF
47var _ = ptypes.MarshalAny
48var _ status.Status
49
50type mockClusterControllerServer struct {
51	// Embed for forward compatibility.
52	// Tests will keep working if more methods are added
53	// in the future.
54	dataprocpb.ClusterControllerServer
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 *mockClusterControllerServer) CreateCluster(ctx context.Context, req *dataprocpb.CreateClusterRequest) (*longrunningpb.Operation, 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].(*longrunningpb.Operation), nil
75}
76
77func (s *mockClusterControllerServer) UpdateCluster(ctx context.Context, req *dataprocpb.UpdateClusterRequest) (*longrunningpb.Operation, 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].(*longrunningpb.Operation), nil
87}
88
89func (s *mockClusterControllerServer) DeleteCluster(ctx context.Context, req *dataprocpb.DeleteClusterRequest) (*longrunningpb.Operation, 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].(*longrunningpb.Operation), nil
99}
100
101func (s *mockClusterControllerServer) GetCluster(ctx context.Context, req *dataprocpb.GetClusterRequest) (*dataprocpb.Cluster, 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].(*dataprocpb.Cluster), nil
111}
112
113func (s *mockClusterControllerServer) ListClusters(ctx context.Context, req *dataprocpb.ListClustersRequest) (*dataprocpb.ListClustersResponse, 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].(*dataprocpb.ListClustersResponse), nil
123}
124
125func (s *mockClusterControllerServer) DiagnoseCluster(ctx context.Context, req *dataprocpb.DiagnoseClusterRequest) (*longrunningpb.Operation, 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].(*longrunningpb.Operation), nil
135}
136
137type mockJobControllerServer struct {
138	// Embed for forward compatibility.
139	// Tests will keep working if more methods are added
140	// in the future.
141	dataprocpb.JobControllerServer
142
143	reqs []proto.Message
144
145	// If set, all calls return this error.
146	err error
147
148	// responses to return if err == nil
149	resps []proto.Message
150}
151
152func (s *mockJobControllerServer) SubmitJob(ctx context.Context, req *dataprocpb.SubmitJobRequest) (*dataprocpb.Job, error) {
153	md, _ := metadata.FromIncomingContext(ctx)
154	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
155		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
156	}
157	s.reqs = append(s.reqs, req)
158	if s.err != nil {
159		return nil, s.err
160	}
161	return s.resps[0].(*dataprocpb.Job), nil
162}
163
164func (s *mockJobControllerServer) GetJob(ctx context.Context, req *dataprocpb.GetJobRequest) (*dataprocpb.Job, error) {
165	md, _ := metadata.FromIncomingContext(ctx)
166	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
167		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
168	}
169	s.reqs = append(s.reqs, req)
170	if s.err != nil {
171		return nil, s.err
172	}
173	return s.resps[0].(*dataprocpb.Job), nil
174}
175
176func (s *mockJobControllerServer) ListJobs(ctx context.Context, req *dataprocpb.ListJobsRequest) (*dataprocpb.ListJobsResponse, error) {
177	md, _ := metadata.FromIncomingContext(ctx)
178	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
179		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
180	}
181	s.reqs = append(s.reqs, req)
182	if s.err != nil {
183		return nil, s.err
184	}
185	return s.resps[0].(*dataprocpb.ListJobsResponse), nil
186}
187
188func (s *mockJobControllerServer) UpdateJob(ctx context.Context, req *dataprocpb.UpdateJobRequest) (*dataprocpb.Job, error) {
189	md, _ := metadata.FromIncomingContext(ctx)
190	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
191		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
192	}
193	s.reqs = append(s.reqs, req)
194	if s.err != nil {
195		return nil, s.err
196	}
197	return s.resps[0].(*dataprocpb.Job), nil
198}
199
200func (s *mockJobControllerServer) CancelJob(ctx context.Context, req *dataprocpb.CancelJobRequest) (*dataprocpb.Job, error) {
201	md, _ := metadata.FromIncomingContext(ctx)
202	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
203		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
204	}
205	s.reqs = append(s.reqs, req)
206	if s.err != nil {
207		return nil, s.err
208	}
209	return s.resps[0].(*dataprocpb.Job), nil
210}
211
212func (s *mockJobControllerServer) DeleteJob(ctx context.Context, req *dataprocpb.DeleteJobRequest) (*emptypb.Empty, error) {
213	md, _ := metadata.FromIncomingContext(ctx)
214	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
215		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
216	}
217	s.reqs = append(s.reqs, req)
218	if s.err != nil {
219		return nil, s.err
220	}
221	return s.resps[0].(*emptypb.Empty), nil
222}
223
224type mockWorkflowTemplateServer struct {
225	// Embed for forward compatibility.
226	// Tests will keep working if more methods are added
227	// in the future.
228	dataprocpb.WorkflowTemplateServiceServer
229
230	reqs []proto.Message
231
232	// If set, all calls return this error.
233	err error
234
235	// responses to return if err == nil
236	resps []proto.Message
237}
238
239func (s *mockWorkflowTemplateServer) CreateWorkflowTemplate(ctx context.Context, req *dataprocpb.CreateWorkflowTemplateRequest) (*dataprocpb.WorkflowTemplate, error) {
240	md, _ := metadata.FromIncomingContext(ctx)
241	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
242		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
243	}
244	s.reqs = append(s.reqs, req)
245	if s.err != nil {
246		return nil, s.err
247	}
248	return s.resps[0].(*dataprocpb.WorkflowTemplate), nil
249}
250
251func (s *mockWorkflowTemplateServer) GetWorkflowTemplate(ctx context.Context, req *dataprocpb.GetWorkflowTemplateRequest) (*dataprocpb.WorkflowTemplate, error) {
252	md, _ := metadata.FromIncomingContext(ctx)
253	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
254		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
255	}
256	s.reqs = append(s.reqs, req)
257	if s.err != nil {
258		return nil, s.err
259	}
260	return s.resps[0].(*dataprocpb.WorkflowTemplate), nil
261}
262
263func (s *mockWorkflowTemplateServer) InstantiateWorkflowTemplate(ctx context.Context, req *dataprocpb.InstantiateWorkflowTemplateRequest) (*longrunningpb.Operation, error) {
264	md, _ := metadata.FromIncomingContext(ctx)
265	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
266		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
267	}
268	s.reqs = append(s.reqs, req)
269	if s.err != nil {
270		return nil, s.err
271	}
272	return s.resps[0].(*longrunningpb.Operation), nil
273}
274
275func (s *mockWorkflowTemplateServer) InstantiateInlineWorkflowTemplate(ctx context.Context, req *dataprocpb.InstantiateInlineWorkflowTemplateRequest) (*longrunningpb.Operation, error) {
276	md, _ := metadata.FromIncomingContext(ctx)
277	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
278		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
279	}
280	s.reqs = append(s.reqs, req)
281	if s.err != nil {
282		return nil, s.err
283	}
284	return s.resps[0].(*longrunningpb.Operation), nil
285}
286
287func (s *mockWorkflowTemplateServer) UpdateWorkflowTemplate(ctx context.Context, req *dataprocpb.UpdateWorkflowTemplateRequest) (*dataprocpb.WorkflowTemplate, error) {
288	md, _ := metadata.FromIncomingContext(ctx)
289	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
290		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
291	}
292	s.reqs = append(s.reqs, req)
293	if s.err != nil {
294		return nil, s.err
295	}
296	return s.resps[0].(*dataprocpb.WorkflowTemplate), nil
297}
298
299func (s *mockWorkflowTemplateServer) ListWorkflowTemplates(ctx context.Context, req *dataprocpb.ListWorkflowTemplatesRequest) (*dataprocpb.ListWorkflowTemplatesResponse, error) {
300	md, _ := metadata.FromIncomingContext(ctx)
301	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
302		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
303	}
304	s.reqs = append(s.reqs, req)
305	if s.err != nil {
306		return nil, s.err
307	}
308	return s.resps[0].(*dataprocpb.ListWorkflowTemplatesResponse), nil
309}
310
311func (s *mockWorkflowTemplateServer) DeleteWorkflowTemplate(ctx context.Context, req *dataprocpb.DeleteWorkflowTemplateRequest) (*emptypb.Empty, error) {
312	md, _ := metadata.FromIncomingContext(ctx)
313	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
314		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
315	}
316	s.reqs = append(s.reqs, req)
317	if s.err != nil {
318		return nil, s.err
319	}
320	return s.resps[0].(*emptypb.Empty), nil
321}
322
323// clientOpt is the option tests should use to connect to the test server.
324// It is initialized by TestMain.
325var clientOpt option.ClientOption
326
327var (
328	mockClusterController mockClusterControllerServer
329	mockJobController     mockJobControllerServer
330	mockWorkflowTemplate  mockWorkflowTemplateServer
331)
332
333func TestMain(m *testing.M) {
334	flag.Parse()
335
336	serv := grpc.NewServer()
337	dataprocpb.RegisterClusterControllerServer(serv, &mockClusterController)
338	dataprocpb.RegisterJobControllerServer(serv, &mockJobController)
339	dataprocpb.RegisterWorkflowTemplateServiceServer(serv, &mockWorkflowTemplate)
340
341	lis, err := net.Listen("tcp", "localhost:0")
342	if err != nil {
343		log.Fatal(err)
344	}
345	go serv.Serve(lis)
346
347	conn, err := grpc.Dial(lis.Addr().String(), grpc.WithInsecure())
348	if err != nil {
349		log.Fatal(err)
350	}
351	clientOpt = option.WithGRPCConn(conn)
352
353	os.Exit(m.Run())
354}
355
356func TestClusterControllerCreateCluster(t *testing.T) {
357	var projectId2 string = "projectId2939242356"
358	var clusterName string = "clusterName-1018081872"
359	var clusterUuid string = "clusterUuid-1017854240"
360	var expectedResponse = &dataprocpb.Cluster{
361		ProjectId:   projectId2,
362		ClusterName: clusterName,
363		ClusterUuid: clusterUuid,
364	}
365
366	mockClusterController.err = nil
367	mockClusterController.reqs = nil
368
369	any, err := ptypes.MarshalAny(expectedResponse)
370	if err != nil {
371		t.Fatal(err)
372	}
373	mockClusterController.resps = append(mockClusterController.resps[:0], &longrunningpb.Operation{
374		Name:   "longrunning-test",
375		Done:   true,
376		Result: &longrunningpb.Operation_Response{Response: any},
377	})
378
379	var projectId string = "projectId-1969970175"
380	var region string = "region-934795532"
381	var cluster *dataprocpb.Cluster = &dataprocpb.Cluster{}
382	var request = &dataprocpb.CreateClusterRequest{
383		ProjectId: projectId,
384		Region:    region,
385		Cluster:   cluster,
386	}
387
388	c, err := NewClusterControllerClient(context.Background(), clientOpt)
389	if err != nil {
390		t.Fatal(err)
391	}
392
393	respLRO, err := c.CreateCluster(context.Background(), request)
394	if err != nil {
395		t.Fatal(err)
396	}
397	resp, err := respLRO.Wait(context.Background())
398
399	if err != nil {
400		t.Fatal(err)
401	}
402
403	if want, got := request, mockClusterController.reqs[0]; !proto.Equal(want, got) {
404		t.Errorf("wrong request %q, want %q", got, want)
405	}
406
407	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
408		t.Errorf("wrong response %q, want %q)", got, want)
409	}
410}
411
412func TestClusterControllerCreateClusterError(t *testing.T) {
413	errCode := codes.PermissionDenied
414	mockClusterController.err = nil
415	mockClusterController.resps = append(mockClusterController.resps[:0], &longrunningpb.Operation{
416		Name: "longrunning-test",
417		Done: true,
418		Result: &longrunningpb.Operation_Error{
419			Error: &status.Status{
420				Code:    int32(errCode),
421				Message: "test error",
422			},
423		},
424	})
425
426	var projectId string = "projectId-1969970175"
427	var region string = "region-934795532"
428	var cluster *dataprocpb.Cluster = &dataprocpb.Cluster{}
429	var request = &dataprocpb.CreateClusterRequest{
430		ProjectId: projectId,
431		Region:    region,
432		Cluster:   cluster,
433	}
434
435	c, err := NewClusterControllerClient(context.Background(), clientOpt)
436	if err != nil {
437		t.Fatal(err)
438	}
439
440	respLRO, err := c.CreateCluster(context.Background(), request)
441	if err != nil {
442		t.Fatal(err)
443	}
444	resp, err := respLRO.Wait(context.Background())
445
446	if st, ok := gstatus.FromError(err); !ok {
447		t.Errorf("got error %v, expected grpc error", err)
448	} else if c := st.Code(); c != errCode {
449		t.Errorf("got error code %q, want %q", c, errCode)
450	}
451	_ = resp
452}
453func TestClusterControllerUpdateCluster(t *testing.T) {
454	var projectId2 string = "projectId2939242356"
455	var clusterName2 string = "clusterName2875867491"
456	var clusterUuid string = "clusterUuid-1017854240"
457	var expectedResponse = &dataprocpb.Cluster{
458		ProjectId:   projectId2,
459		ClusterName: clusterName2,
460		ClusterUuid: clusterUuid,
461	}
462
463	mockClusterController.err = nil
464	mockClusterController.reqs = nil
465
466	any, err := ptypes.MarshalAny(expectedResponse)
467	if err != nil {
468		t.Fatal(err)
469	}
470	mockClusterController.resps = append(mockClusterController.resps[:0], &longrunningpb.Operation{
471		Name:   "longrunning-test",
472		Done:   true,
473		Result: &longrunningpb.Operation_Response{Response: any},
474	})
475
476	var projectId string = "projectId-1969970175"
477	var region string = "region-934795532"
478	var clusterName string = "clusterName-1018081872"
479	var cluster *dataprocpb.Cluster = &dataprocpb.Cluster{}
480	var updateMask *field_maskpb.FieldMask = &field_maskpb.FieldMask{}
481	var request = &dataprocpb.UpdateClusterRequest{
482		ProjectId:   projectId,
483		Region:      region,
484		ClusterName: clusterName,
485		Cluster:     cluster,
486		UpdateMask:  updateMask,
487	}
488
489	c, err := NewClusterControllerClient(context.Background(), clientOpt)
490	if err != nil {
491		t.Fatal(err)
492	}
493
494	respLRO, err := c.UpdateCluster(context.Background(), request)
495	if err != nil {
496		t.Fatal(err)
497	}
498	resp, err := respLRO.Wait(context.Background())
499
500	if err != nil {
501		t.Fatal(err)
502	}
503
504	if want, got := request, mockClusterController.reqs[0]; !proto.Equal(want, got) {
505		t.Errorf("wrong request %q, want %q", got, want)
506	}
507
508	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
509		t.Errorf("wrong response %q, want %q)", got, want)
510	}
511}
512
513func TestClusterControllerUpdateClusterError(t *testing.T) {
514	errCode := codes.PermissionDenied
515	mockClusterController.err = nil
516	mockClusterController.resps = append(mockClusterController.resps[:0], &longrunningpb.Operation{
517		Name: "longrunning-test",
518		Done: true,
519		Result: &longrunningpb.Operation_Error{
520			Error: &status.Status{
521				Code:    int32(errCode),
522				Message: "test error",
523			},
524		},
525	})
526
527	var projectId string = "projectId-1969970175"
528	var region string = "region-934795532"
529	var clusterName string = "clusterName-1018081872"
530	var cluster *dataprocpb.Cluster = &dataprocpb.Cluster{}
531	var updateMask *field_maskpb.FieldMask = &field_maskpb.FieldMask{}
532	var request = &dataprocpb.UpdateClusterRequest{
533		ProjectId:   projectId,
534		Region:      region,
535		ClusterName: clusterName,
536		Cluster:     cluster,
537		UpdateMask:  updateMask,
538	}
539
540	c, err := NewClusterControllerClient(context.Background(), clientOpt)
541	if err != nil {
542		t.Fatal(err)
543	}
544
545	respLRO, err := c.UpdateCluster(context.Background(), request)
546	if err != nil {
547		t.Fatal(err)
548	}
549	resp, err := respLRO.Wait(context.Background())
550
551	if st, ok := gstatus.FromError(err); !ok {
552		t.Errorf("got error %v, expected grpc error", err)
553	} else if c := st.Code(); c != errCode {
554		t.Errorf("got error code %q, want %q", c, errCode)
555	}
556	_ = resp
557}
558func TestClusterControllerDeleteCluster(t *testing.T) {
559	var expectedResponse *emptypb.Empty = &emptypb.Empty{}
560
561	mockClusterController.err = nil
562	mockClusterController.reqs = nil
563
564	any, err := ptypes.MarshalAny(expectedResponse)
565	if err != nil {
566		t.Fatal(err)
567	}
568	mockClusterController.resps = append(mockClusterController.resps[:0], &longrunningpb.Operation{
569		Name:   "longrunning-test",
570		Done:   true,
571		Result: &longrunningpb.Operation_Response{Response: any},
572	})
573
574	var projectId string = "projectId-1969970175"
575	var region string = "region-934795532"
576	var clusterName string = "clusterName-1018081872"
577	var request = &dataprocpb.DeleteClusterRequest{
578		ProjectId:   projectId,
579		Region:      region,
580		ClusterName: clusterName,
581	}
582
583	c, err := NewClusterControllerClient(context.Background(), clientOpt)
584	if err != nil {
585		t.Fatal(err)
586	}
587
588	respLRO, err := c.DeleteCluster(context.Background(), request)
589	if err != nil {
590		t.Fatal(err)
591	}
592	err = respLRO.Wait(context.Background())
593
594	if err != nil {
595		t.Fatal(err)
596	}
597
598	if want, got := request, mockClusterController.reqs[0]; !proto.Equal(want, got) {
599		t.Errorf("wrong request %q, want %q", got, want)
600	}
601
602}
603
604func TestClusterControllerDeleteClusterError(t *testing.T) {
605	errCode := codes.PermissionDenied
606	mockClusterController.err = nil
607	mockClusterController.resps = append(mockClusterController.resps[:0], &longrunningpb.Operation{
608		Name: "longrunning-test",
609		Done: true,
610		Result: &longrunningpb.Operation_Error{
611			Error: &status.Status{
612				Code:    int32(errCode),
613				Message: "test error",
614			},
615		},
616	})
617
618	var projectId string = "projectId-1969970175"
619	var region string = "region-934795532"
620	var clusterName string = "clusterName-1018081872"
621	var request = &dataprocpb.DeleteClusterRequest{
622		ProjectId:   projectId,
623		Region:      region,
624		ClusterName: clusterName,
625	}
626
627	c, err := NewClusterControllerClient(context.Background(), clientOpt)
628	if err != nil {
629		t.Fatal(err)
630	}
631
632	respLRO, err := c.DeleteCluster(context.Background(), request)
633	if err != nil {
634		t.Fatal(err)
635	}
636	err = respLRO.Wait(context.Background())
637
638	if st, ok := gstatus.FromError(err); !ok {
639		t.Errorf("got error %v, expected grpc error", err)
640	} else if c := st.Code(); c != errCode {
641		t.Errorf("got error code %q, want %q", c, errCode)
642	}
643}
644func TestClusterControllerGetCluster(t *testing.T) {
645	var projectId2 string = "projectId2939242356"
646	var clusterName2 string = "clusterName2875867491"
647	var clusterUuid string = "clusterUuid-1017854240"
648	var expectedResponse = &dataprocpb.Cluster{
649		ProjectId:   projectId2,
650		ClusterName: clusterName2,
651		ClusterUuid: clusterUuid,
652	}
653
654	mockClusterController.err = nil
655	mockClusterController.reqs = nil
656
657	mockClusterController.resps = append(mockClusterController.resps[:0], expectedResponse)
658
659	var projectId string = "projectId-1969970175"
660	var region string = "region-934795532"
661	var clusterName string = "clusterName-1018081872"
662	var request = &dataprocpb.GetClusterRequest{
663		ProjectId:   projectId,
664		Region:      region,
665		ClusterName: clusterName,
666	}
667
668	c, err := NewClusterControllerClient(context.Background(), clientOpt)
669	if err != nil {
670		t.Fatal(err)
671	}
672
673	resp, err := c.GetCluster(context.Background(), request)
674
675	if err != nil {
676		t.Fatal(err)
677	}
678
679	if want, got := request, mockClusterController.reqs[0]; !proto.Equal(want, got) {
680		t.Errorf("wrong request %q, want %q", got, want)
681	}
682
683	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
684		t.Errorf("wrong response %q, want %q)", got, want)
685	}
686}
687
688func TestClusterControllerGetClusterError(t *testing.T) {
689	errCode := codes.PermissionDenied
690	mockClusterController.err = gstatus.Error(errCode, "test error")
691
692	var projectId string = "projectId-1969970175"
693	var region string = "region-934795532"
694	var clusterName string = "clusterName-1018081872"
695	var request = &dataprocpb.GetClusterRequest{
696		ProjectId:   projectId,
697		Region:      region,
698		ClusterName: clusterName,
699	}
700
701	c, err := NewClusterControllerClient(context.Background(), clientOpt)
702	if err != nil {
703		t.Fatal(err)
704	}
705
706	resp, err := c.GetCluster(context.Background(), request)
707
708	if st, ok := gstatus.FromError(err); !ok {
709		t.Errorf("got error %v, expected grpc error", err)
710	} else if c := st.Code(); c != errCode {
711		t.Errorf("got error code %q, want %q", c, errCode)
712	}
713	_ = resp
714}
715func TestClusterControllerListClusters(t *testing.T) {
716	var nextPageToken string = ""
717	var clustersElement *dataprocpb.Cluster = &dataprocpb.Cluster{}
718	var clusters = []*dataprocpb.Cluster{clustersElement}
719	var expectedResponse = &dataprocpb.ListClustersResponse{
720		NextPageToken: nextPageToken,
721		Clusters:      clusters,
722	}
723
724	mockClusterController.err = nil
725	mockClusterController.reqs = nil
726
727	mockClusterController.resps = append(mockClusterController.resps[:0], expectedResponse)
728
729	var projectId string = "projectId-1969970175"
730	var region string = "region-934795532"
731	var request = &dataprocpb.ListClustersRequest{
732		ProjectId: projectId,
733		Region:    region,
734	}
735
736	c, err := NewClusterControllerClient(context.Background(), clientOpt)
737	if err != nil {
738		t.Fatal(err)
739	}
740
741	resp, err := c.ListClusters(context.Background(), request).Next()
742
743	if err != nil {
744		t.Fatal(err)
745	}
746
747	if want, got := request, mockClusterController.reqs[0]; !proto.Equal(want, got) {
748		t.Errorf("wrong request %q, want %q", got, want)
749	}
750
751	want := (interface{})(expectedResponse.Clusters[0])
752	got := (interface{})(resp)
753	var ok bool
754
755	switch want := (want).(type) {
756	case proto.Message:
757		ok = proto.Equal(want, got.(proto.Message))
758	default:
759		ok = want == got
760	}
761	if !ok {
762		t.Errorf("wrong response %q, want %q)", got, want)
763	}
764}
765
766func TestClusterControllerListClustersError(t *testing.T) {
767	errCode := codes.PermissionDenied
768	mockClusterController.err = gstatus.Error(errCode, "test error")
769
770	var projectId string = "projectId-1969970175"
771	var region string = "region-934795532"
772	var request = &dataprocpb.ListClustersRequest{
773		ProjectId: projectId,
774		Region:    region,
775	}
776
777	c, err := NewClusterControllerClient(context.Background(), clientOpt)
778	if err != nil {
779		t.Fatal(err)
780	}
781
782	resp, err := c.ListClusters(context.Background(), request).Next()
783
784	if st, ok := gstatus.FromError(err); !ok {
785		t.Errorf("got error %v, expected grpc error", err)
786	} else if c := st.Code(); c != errCode {
787		t.Errorf("got error code %q, want %q", c, errCode)
788	}
789	_ = resp
790}
791func TestClusterControllerDiagnoseCluster(t *testing.T) {
792	var expectedResponse *dataprocpb.DiagnoseClusterResults = &dataprocpb.DiagnoseClusterResults{}
793
794	mockClusterController.err = nil
795	mockClusterController.reqs = nil
796
797	any, err := ptypes.MarshalAny(expectedResponse)
798	if err != nil {
799		t.Fatal(err)
800	}
801	mockClusterController.resps = append(mockClusterController.resps[:0], &longrunningpb.Operation{
802		Name:   "longrunning-test",
803		Done:   true,
804		Result: &longrunningpb.Operation_Response{Response: any},
805	})
806
807	var projectId string = "projectId-1969970175"
808	var region string = "region-934795532"
809	var clusterName string = "clusterName-1018081872"
810	var request = &dataprocpb.DiagnoseClusterRequest{
811		ProjectId:   projectId,
812		Region:      region,
813		ClusterName: clusterName,
814	}
815
816	c, err := NewClusterControllerClient(context.Background(), clientOpt)
817	if err != nil {
818		t.Fatal(err)
819	}
820
821	respLRO, err := c.DiagnoseCluster(context.Background(), request)
822	if err != nil {
823		t.Fatal(err)
824	}
825	_, err = respLRO.Wait(context.Background())
826
827	if err != nil {
828		t.Fatal(err)
829	}
830
831	if want, got := request, mockClusterController.reqs[0]; !proto.Equal(want, got) {
832		t.Errorf("wrong request %q, want %q", got, want)
833	}
834
835}
836
837func TestClusterControllerDiagnoseClusterError(t *testing.T) {
838	errCode := codes.PermissionDenied
839	mockClusterController.err = nil
840	mockClusterController.resps = append(mockClusterController.resps[:0], &longrunningpb.Operation{
841		Name: "longrunning-test",
842		Done: true,
843		Result: &longrunningpb.Operation_Error{
844			Error: &status.Status{
845				Code:    int32(errCode),
846				Message: "test error",
847			},
848		},
849	})
850
851	var projectId string = "projectId-1969970175"
852	var region string = "region-934795532"
853	var clusterName string = "clusterName-1018081872"
854	var request = &dataprocpb.DiagnoseClusterRequest{
855		ProjectId:   projectId,
856		Region:      region,
857		ClusterName: clusterName,
858	}
859
860	c, err := NewClusterControllerClient(context.Background(), clientOpt)
861	if err != nil {
862		t.Fatal(err)
863	}
864
865	respLRO, err := c.DiagnoseCluster(context.Background(), request)
866	if err != nil {
867		t.Fatal(err)
868	}
869	_, err = respLRO.Wait(context.Background())
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}
877func TestJobControllerSubmitJob(t *testing.T) {
878	var driverOutputResourceUri string = "driverOutputResourceUri-542229086"
879	var driverControlFilesUri string = "driverControlFilesUri207057643"
880	var jobUuid string = "jobUuid-1615012099"
881	var expectedResponse = &dataprocpb.Job{
882		DriverOutputResourceUri: driverOutputResourceUri,
883		DriverControlFilesUri:   driverControlFilesUri,
884		JobUuid:                 jobUuid,
885	}
886
887	mockJobController.err = nil
888	mockJobController.reqs = nil
889
890	mockJobController.resps = append(mockJobController.resps[:0], expectedResponse)
891
892	var projectId string = "projectId-1969970175"
893	var region string = "region-934795532"
894	var job *dataprocpb.Job = &dataprocpb.Job{}
895	var request = &dataprocpb.SubmitJobRequest{
896		ProjectId: projectId,
897		Region:    region,
898		Job:       job,
899	}
900
901	c, err := NewJobControllerClient(context.Background(), clientOpt)
902	if err != nil {
903		t.Fatal(err)
904	}
905
906	resp, err := c.SubmitJob(context.Background(), request)
907
908	if err != nil {
909		t.Fatal(err)
910	}
911
912	if want, got := request, mockJobController.reqs[0]; !proto.Equal(want, got) {
913		t.Errorf("wrong request %q, want %q", got, want)
914	}
915
916	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
917		t.Errorf("wrong response %q, want %q)", got, want)
918	}
919}
920
921func TestJobControllerSubmitJobError(t *testing.T) {
922	errCode := codes.PermissionDenied
923	mockJobController.err = gstatus.Error(errCode, "test error")
924
925	var projectId string = "projectId-1969970175"
926	var region string = "region-934795532"
927	var job *dataprocpb.Job = &dataprocpb.Job{}
928	var request = &dataprocpb.SubmitJobRequest{
929		ProjectId: projectId,
930		Region:    region,
931		Job:       job,
932	}
933
934	c, err := NewJobControllerClient(context.Background(), clientOpt)
935	if err != nil {
936		t.Fatal(err)
937	}
938
939	resp, err := c.SubmitJob(context.Background(), request)
940
941	if st, ok := gstatus.FromError(err); !ok {
942		t.Errorf("got error %v, expected grpc error", err)
943	} else if c := st.Code(); c != errCode {
944		t.Errorf("got error code %q, want %q", c, errCode)
945	}
946	_ = resp
947}
948func TestJobControllerGetJob(t *testing.T) {
949	var driverOutputResourceUri string = "driverOutputResourceUri-542229086"
950	var driverControlFilesUri string = "driverControlFilesUri207057643"
951	var jobUuid string = "jobUuid-1615012099"
952	var expectedResponse = &dataprocpb.Job{
953		DriverOutputResourceUri: driverOutputResourceUri,
954		DriverControlFilesUri:   driverControlFilesUri,
955		JobUuid:                 jobUuid,
956	}
957
958	mockJobController.err = nil
959	mockJobController.reqs = nil
960
961	mockJobController.resps = append(mockJobController.resps[:0], expectedResponse)
962
963	var projectId string = "projectId-1969970175"
964	var region string = "region-934795532"
965	var jobId string = "jobId-1154752291"
966	var request = &dataprocpb.GetJobRequest{
967		ProjectId: projectId,
968		Region:    region,
969		JobId:     jobId,
970	}
971
972	c, err := NewJobControllerClient(context.Background(), clientOpt)
973	if err != nil {
974		t.Fatal(err)
975	}
976
977	resp, err := c.GetJob(context.Background(), request)
978
979	if err != nil {
980		t.Fatal(err)
981	}
982
983	if want, got := request, mockJobController.reqs[0]; !proto.Equal(want, got) {
984		t.Errorf("wrong request %q, want %q", got, want)
985	}
986
987	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
988		t.Errorf("wrong response %q, want %q)", got, want)
989	}
990}
991
992func TestJobControllerGetJobError(t *testing.T) {
993	errCode := codes.PermissionDenied
994	mockJobController.err = gstatus.Error(errCode, "test error")
995
996	var projectId string = "projectId-1969970175"
997	var region string = "region-934795532"
998	var jobId string = "jobId-1154752291"
999	var request = &dataprocpb.GetJobRequest{
1000		ProjectId: projectId,
1001		Region:    region,
1002		JobId:     jobId,
1003	}
1004
1005	c, err := NewJobControllerClient(context.Background(), clientOpt)
1006	if err != nil {
1007		t.Fatal(err)
1008	}
1009
1010	resp, err := c.GetJob(context.Background(), request)
1011
1012	if st, ok := gstatus.FromError(err); !ok {
1013		t.Errorf("got error %v, expected grpc error", err)
1014	} else if c := st.Code(); c != errCode {
1015		t.Errorf("got error code %q, want %q", c, errCode)
1016	}
1017	_ = resp
1018}
1019func TestJobControllerListJobs(t *testing.T) {
1020	var nextPageToken string = ""
1021	var jobsElement *dataprocpb.Job = &dataprocpb.Job{}
1022	var jobs = []*dataprocpb.Job{jobsElement}
1023	var expectedResponse = &dataprocpb.ListJobsResponse{
1024		NextPageToken: nextPageToken,
1025		Jobs:          jobs,
1026	}
1027
1028	mockJobController.err = nil
1029	mockJobController.reqs = nil
1030
1031	mockJobController.resps = append(mockJobController.resps[:0], expectedResponse)
1032
1033	var projectId string = "projectId-1969970175"
1034	var region string = "region-934795532"
1035	var request = &dataprocpb.ListJobsRequest{
1036		ProjectId: projectId,
1037		Region:    region,
1038	}
1039
1040	c, err := NewJobControllerClient(context.Background(), clientOpt)
1041	if err != nil {
1042		t.Fatal(err)
1043	}
1044
1045	resp, err := c.ListJobs(context.Background(), request).Next()
1046
1047	if err != nil {
1048		t.Fatal(err)
1049	}
1050
1051	if want, got := request, mockJobController.reqs[0]; !proto.Equal(want, got) {
1052		t.Errorf("wrong request %q, want %q", got, want)
1053	}
1054
1055	want := (interface{})(expectedResponse.Jobs[0])
1056	got := (interface{})(resp)
1057	var ok bool
1058
1059	switch want := (want).(type) {
1060	case proto.Message:
1061		ok = proto.Equal(want, got.(proto.Message))
1062	default:
1063		ok = want == got
1064	}
1065	if !ok {
1066		t.Errorf("wrong response %q, want %q)", got, want)
1067	}
1068}
1069
1070func TestJobControllerListJobsError(t *testing.T) {
1071	errCode := codes.PermissionDenied
1072	mockJobController.err = gstatus.Error(errCode, "test error")
1073
1074	var projectId string = "projectId-1969970175"
1075	var region string = "region-934795532"
1076	var request = &dataprocpb.ListJobsRequest{
1077		ProjectId: projectId,
1078		Region:    region,
1079	}
1080
1081	c, err := NewJobControllerClient(context.Background(), clientOpt)
1082	if err != nil {
1083		t.Fatal(err)
1084	}
1085
1086	resp, err := c.ListJobs(context.Background(), request).Next()
1087
1088	if st, ok := gstatus.FromError(err); !ok {
1089		t.Errorf("got error %v, expected grpc error", err)
1090	} else if c := st.Code(); c != errCode {
1091		t.Errorf("got error code %q, want %q", c, errCode)
1092	}
1093	_ = resp
1094}
1095func TestJobControllerUpdateJob(t *testing.T) {
1096	var driverOutputResourceUri string = "driverOutputResourceUri-542229086"
1097	var driverControlFilesUri string = "driverControlFilesUri207057643"
1098	var jobUuid string = "jobUuid-1615012099"
1099	var expectedResponse = &dataprocpb.Job{
1100		DriverOutputResourceUri: driverOutputResourceUri,
1101		DriverControlFilesUri:   driverControlFilesUri,
1102		JobUuid:                 jobUuid,
1103	}
1104
1105	mockJobController.err = nil
1106	mockJobController.reqs = nil
1107
1108	mockJobController.resps = append(mockJobController.resps[:0], expectedResponse)
1109
1110	var projectId string = "projectId-1969970175"
1111	var region string = "region-934795532"
1112	var jobId string = "jobId-1154752291"
1113	var job *dataprocpb.Job = &dataprocpb.Job{}
1114	var updateMask *field_maskpb.FieldMask = &field_maskpb.FieldMask{}
1115	var request = &dataprocpb.UpdateJobRequest{
1116		ProjectId:  projectId,
1117		Region:     region,
1118		JobId:      jobId,
1119		Job:        job,
1120		UpdateMask: updateMask,
1121	}
1122
1123	c, err := NewJobControllerClient(context.Background(), clientOpt)
1124	if err != nil {
1125		t.Fatal(err)
1126	}
1127
1128	resp, err := c.UpdateJob(context.Background(), request)
1129
1130	if err != nil {
1131		t.Fatal(err)
1132	}
1133
1134	if want, got := request, mockJobController.reqs[0]; !proto.Equal(want, got) {
1135		t.Errorf("wrong request %q, want %q", got, want)
1136	}
1137
1138	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1139		t.Errorf("wrong response %q, want %q)", got, want)
1140	}
1141}
1142
1143func TestJobControllerUpdateJobError(t *testing.T) {
1144	errCode := codes.PermissionDenied
1145	mockJobController.err = gstatus.Error(errCode, "test error")
1146
1147	var projectId string = "projectId-1969970175"
1148	var region string = "region-934795532"
1149	var jobId string = "jobId-1154752291"
1150	var job *dataprocpb.Job = &dataprocpb.Job{}
1151	var updateMask *field_maskpb.FieldMask = &field_maskpb.FieldMask{}
1152	var request = &dataprocpb.UpdateJobRequest{
1153		ProjectId:  projectId,
1154		Region:     region,
1155		JobId:      jobId,
1156		Job:        job,
1157		UpdateMask: updateMask,
1158	}
1159
1160	c, err := NewJobControllerClient(context.Background(), clientOpt)
1161	if err != nil {
1162		t.Fatal(err)
1163	}
1164
1165	resp, err := c.UpdateJob(context.Background(), request)
1166
1167	if st, ok := gstatus.FromError(err); !ok {
1168		t.Errorf("got error %v, expected grpc error", err)
1169	} else if c := st.Code(); c != errCode {
1170		t.Errorf("got error code %q, want %q", c, errCode)
1171	}
1172	_ = resp
1173}
1174func TestJobControllerCancelJob(t *testing.T) {
1175	var driverOutputResourceUri string = "driverOutputResourceUri-542229086"
1176	var driverControlFilesUri string = "driverControlFilesUri207057643"
1177	var jobUuid string = "jobUuid-1615012099"
1178	var expectedResponse = &dataprocpb.Job{
1179		DriverOutputResourceUri: driverOutputResourceUri,
1180		DriverControlFilesUri:   driverControlFilesUri,
1181		JobUuid:                 jobUuid,
1182	}
1183
1184	mockJobController.err = nil
1185	mockJobController.reqs = nil
1186
1187	mockJobController.resps = append(mockJobController.resps[:0], expectedResponse)
1188
1189	var projectId string = "projectId-1969970175"
1190	var region string = "region-934795532"
1191	var jobId string = "jobId-1154752291"
1192	var request = &dataprocpb.CancelJobRequest{
1193		ProjectId: projectId,
1194		Region:    region,
1195		JobId:     jobId,
1196	}
1197
1198	c, err := NewJobControllerClient(context.Background(), clientOpt)
1199	if err != nil {
1200		t.Fatal(err)
1201	}
1202
1203	resp, err := c.CancelJob(context.Background(), request)
1204
1205	if err != nil {
1206		t.Fatal(err)
1207	}
1208
1209	if want, got := request, mockJobController.reqs[0]; !proto.Equal(want, got) {
1210		t.Errorf("wrong request %q, want %q", got, want)
1211	}
1212
1213	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1214		t.Errorf("wrong response %q, want %q)", got, want)
1215	}
1216}
1217
1218func TestJobControllerCancelJobError(t *testing.T) {
1219	errCode := codes.PermissionDenied
1220	mockJobController.err = gstatus.Error(errCode, "test error")
1221
1222	var projectId string = "projectId-1969970175"
1223	var region string = "region-934795532"
1224	var jobId string = "jobId-1154752291"
1225	var request = &dataprocpb.CancelJobRequest{
1226		ProjectId: projectId,
1227		Region:    region,
1228		JobId:     jobId,
1229	}
1230
1231	c, err := NewJobControllerClient(context.Background(), clientOpt)
1232	if err != nil {
1233		t.Fatal(err)
1234	}
1235
1236	resp, err := c.CancelJob(context.Background(), request)
1237
1238	if st, ok := gstatus.FromError(err); !ok {
1239		t.Errorf("got error %v, expected grpc error", err)
1240	} else if c := st.Code(); c != errCode {
1241		t.Errorf("got error code %q, want %q", c, errCode)
1242	}
1243	_ = resp
1244}
1245func TestJobControllerDeleteJob(t *testing.T) {
1246	var expectedResponse *emptypb.Empty = &emptypb.Empty{}
1247
1248	mockJobController.err = nil
1249	mockJobController.reqs = nil
1250
1251	mockJobController.resps = append(mockJobController.resps[:0], expectedResponse)
1252
1253	var projectId string = "projectId-1969970175"
1254	var region string = "region-934795532"
1255	var jobId string = "jobId-1154752291"
1256	var request = &dataprocpb.DeleteJobRequest{
1257		ProjectId: projectId,
1258		Region:    region,
1259		JobId:     jobId,
1260	}
1261
1262	c, err := NewJobControllerClient(context.Background(), clientOpt)
1263	if err != nil {
1264		t.Fatal(err)
1265	}
1266
1267	err = c.DeleteJob(context.Background(), request)
1268
1269	if err != nil {
1270		t.Fatal(err)
1271	}
1272
1273	if want, got := request, mockJobController.reqs[0]; !proto.Equal(want, got) {
1274		t.Errorf("wrong request %q, want %q", got, want)
1275	}
1276
1277}
1278
1279func TestJobControllerDeleteJobError(t *testing.T) {
1280	errCode := codes.PermissionDenied
1281	mockJobController.err = gstatus.Error(errCode, "test error")
1282
1283	var projectId string = "projectId-1969970175"
1284	var region string = "region-934795532"
1285	var jobId string = "jobId-1154752291"
1286	var request = &dataprocpb.DeleteJobRequest{
1287		ProjectId: projectId,
1288		Region:    region,
1289		JobId:     jobId,
1290	}
1291
1292	c, err := NewJobControllerClient(context.Background(), clientOpt)
1293	if err != nil {
1294		t.Fatal(err)
1295	}
1296
1297	err = c.DeleteJob(context.Background(), request)
1298
1299	if st, ok := gstatus.FromError(err); !ok {
1300		t.Errorf("got error %v, expected grpc error", err)
1301	} else if c := st.Code(); c != errCode {
1302		t.Errorf("got error code %q, want %q", c, errCode)
1303	}
1304}
1305func TestWorkflowTemplateServiceCreateWorkflowTemplate(t *testing.T) {
1306	var id string = "id3355"
1307	var name string = "name3373707"
1308	var version int32 = 351608024
1309	var expectedResponse = &dataprocpb.WorkflowTemplate{
1310		Id:      id,
1311		Name:    name,
1312		Version: version,
1313	}
1314
1315	mockWorkflowTemplate.err = nil
1316	mockWorkflowTemplate.reqs = nil
1317
1318	mockWorkflowTemplate.resps = append(mockWorkflowTemplate.resps[:0], expectedResponse)
1319
1320	var formattedParent string = fmt.Sprintf("projects/%s/regions/%s", "[PROJECT]", "[REGION]")
1321	var template *dataprocpb.WorkflowTemplate = &dataprocpb.WorkflowTemplate{}
1322	var request = &dataprocpb.CreateWorkflowTemplateRequest{
1323		Parent:   formattedParent,
1324		Template: template,
1325	}
1326
1327	c, err := NewWorkflowTemplateClient(context.Background(), clientOpt)
1328	if err != nil {
1329		t.Fatal(err)
1330	}
1331
1332	resp, err := c.CreateWorkflowTemplate(context.Background(), request)
1333
1334	if err != nil {
1335		t.Fatal(err)
1336	}
1337
1338	if want, got := request, mockWorkflowTemplate.reqs[0]; !proto.Equal(want, got) {
1339		t.Errorf("wrong request %q, want %q", got, want)
1340	}
1341
1342	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1343		t.Errorf("wrong response %q, want %q)", got, want)
1344	}
1345}
1346
1347func TestWorkflowTemplateServiceCreateWorkflowTemplateError(t *testing.T) {
1348	errCode := codes.PermissionDenied
1349	mockWorkflowTemplate.err = gstatus.Error(errCode, "test error")
1350
1351	var formattedParent string = fmt.Sprintf("projects/%s/regions/%s", "[PROJECT]", "[REGION]")
1352	var template *dataprocpb.WorkflowTemplate = &dataprocpb.WorkflowTemplate{}
1353	var request = &dataprocpb.CreateWorkflowTemplateRequest{
1354		Parent:   formattedParent,
1355		Template: template,
1356	}
1357
1358	c, err := NewWorkflowTemplateClient(context.Background(), clientOpt)
1359	if err != nil {
1360		t.Fatal(err)
1361	}
1362
1363	resp, err := c.CreateWorkflowTemplate(context.Background(), request)
1364
1365	if st, ok := gstatus.FromError(err); !ok {
1366		t.Errorf("got error %v, expected grpc error", err)
1367	} else if c := st.Code(); c != errCode {
1368		t.Errorf("got error code %q, want %q", c, errCode)
1369	}
1370	_ = resp
1371}
1372func TestWorkflowTemplateServiceGetWorkflowTemplate(t *testing.T) {
1373	var id string = "id3355"
1374	var name2 string = "name2-1052831874"
1375	var version int32 = 351608024
1376	var expectedResponse = &dataprocpb.WorkflowTemplate{
1377		Id:      id,
1378		Name:    name2,
1379		Version: version,
1380	}
1381
1382	mockWorkflowTemplate.err = nil
1383	mockWorkflowTemplate.reqs = nil
1384
1385	mockWorkflowTemplate.resps = append(mockWorkflowTemplate.resps[:0], expectedResponse)
1386
1387	var formattedName string = fmt.Sprintf("projects/%s/regions/%s/workflowTemplates/%s", "[PROJECT]", "[REGION]", "[WORKFLOW_TEMPLATE]")
1388	var request = &dataprocpb.GetWorkflowTemplateRequest{
1389		Name: formattedName,
1390	}
1391
1392	c, err := NewWorkflowTemplateClient(context.Background(), clientOpt)
1393	if err != nil {
1394		t.Fatal(err)
1395	}
1396
1397	resp, err := c.GetWorkflowTemplate(context.Background(), request)
1398
1399	if err != nil {
1400		t.Fatal(err)
1401	}
1402
1403	if want, got := request, mockWorkflowTemplate.reqs[0]; !proto.Equal(want, got) {
1404		t.Errorf("wrong request %q, want %q", got, want)
1405	}
1406
1407	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1408		t.Errorf("wrong response %q, want %q)", got, want)
1409	}
1410}
1411
1412func TestWorkflowTemplateServiceGetWorkflowTemplateError(t *testing.T) {
1413	errCode := codes.PermissionDenied
1414	mockWorkflowTemplate.err = gstatus.Error(errCode, "test error")
1415
1416	var formattedName string = fmt.Sprintf("projects/%s/regions/%s/workflowTemplates/%s", "[PROJECT]", "[REGION]", "[WORKFLOW_TEMPLATE]")
1417	var request = &dataprocpb.GetWorkflowTemplateRequest{
1418		Name: formattedName,
1419	}
1420
1421	c, err := NewWorkflowTemplateClient(context.Background(), clientOpt)
1422	if err != nil {
1423		t.Fatal(err)
1424	}
1425
1426	resp, err := c.GetWorkflowTemplate(context.Background(), request)
1427
1428	if st, ok := gstatus.FromError(err); !ok {
1429		t.Errorf("got error %v, expected grpc error", err)
1430	} else if c := st.Code(); c != errCode {
1431		t.Errorf("got error code %q, want %q", c, errCode)
1432	}
1433	_ = resp
1434}
1435func TestWorkflowTemplateServiceInstantiateWorkflowTemplate(t *testing.T) {
1436	var expectedResponse *emptypb.Empty = &emptypb.Empty{}
1437
1438	mockWorkflowTemplate.err = nil
1439	mockWorkflowTemplate.reqs = nil
1440
1441	any, err := ptypes.MarshalAny(expectedResponse)
1442	if err != nil {
1443		t.Fatal(err)
1444	}
1445	mockWorkflowTemplate.resps = append(mockWorkflowTemplate.resps[:0], &longrunningpb.Operation{
1446		Name:   "longrunning-test",
1447		Done:   true,
1448		Result: &longrunningpb.Operation_Response{Response: any},
1449	})
1450
1451	var formattedName string = fmt.Sprintf("projects/%s/regions/%s/workflowTemplates/%s", "[PROJECT]", "[REGION]", "[WORKFLOW_TEMPLATE]")
1452	var request = &dataprocpb.InstantiateWorkflowTemplateRequest{
1453		Name: formattedName,
1454	}
1455
1456	c, err := NewWorkflowTemplateClient(context.Background(), clientOpt)
1457	if err != nil {
1458		t.Fatal(err)
1459	}
1460
1461	respLRO, err := c.InstantiateWorkflowTemplate(context.Background(), request)
1462	if err != nil {
1463		t.Fatal(err)
1464	}
1465	err = respLRO.Wait(context.Background())
1466
1467	if err != nil {
1468		t.Fatal(err)
1469	}
1470
1471	if want, got := request, mockWorkflowTemplate.reqs[0]; !proto.Equal(want, got) {
1472		t.Errorf("wrong request %q, want %q", got, want)
1473	}
1474
1475}
1476
1477func TestWorkflowTemplateServiceInstantiateWorkflowTemplateError(t *testing.T) {
1478	errCode := codes.PermissionDenied
1479	mockWorkflowTemplate.err = nil
1480	mockWorkflowTemplate.resps = append(mockWorkflowTemplate.resps[:0], &longrunningpb.Operation{
1481		Name: "longrunning-test",
1482		Done: true,
1483		Result: &longrunningpb.Operation_Error{
1484			Error: &status.Status{
1485				Code:    int32(errCode),
1486				Message: "test error",
1487			},
1488		},
1489	})
1490
1491	var formattedName string = fmt.Sprintf("projects/%s/regions/%s/workflowTemplates/%s", "[PROJECT]", "[REGION]", "[WORKFLOW_TEMPLATE]")
1492	var request = &dataprocpb.InstantiateWorkflowTemplateRequest{
1493		Name: formattedName,
1494	}
1495
1496	c, err := NewWorkflowTemplateClient(context.Background(), clientOpt)
1497	if err != nil {
1498		t.Fatal(err)
1499	}
1500
1501	respLRO, err := c.InstantiateWorkflowTemplate(context.Background(), request)
1502	if err != nil {
1503		t.Fatal(err)
1504	}
1505	err = respLRO.Wait(context.Background())
1506
1507	if st, ok := gstatus.FromError(err); !ok {
1508		t.Errorf("got error %v, expected grpc error", err)
1509	} else if c := st.Code(); c != errCode {
1510		t.Errorf("got error code %q, want %q", c, errCode)
1511	}
1512}
1513func TestWorkflowTemplateServiceInstantiateInlineWorkflowTemplate(t *testing.T) {
1514	var expectedResponse *emptypb.Empty = &emptypb.Empty{}
1515
1516	mockWorkflowTemplate.err = nil
1517	mockWorkflowTemplate.reqs = nil
1518
1519	any, err := ptypes.MarshalAny(expectedResponse)
1520	if err != nil {
1521		t.Fatal(err)
1522	}
1523	mockWorkflowTemplate.resps = append(mockWorkflowTemplate.resps[:0], &longrunningpb.Operation{
1524		Name:   "longrunning-test",
1525		Done:   true,
1526		Result: &longrunningpb.Operation_Response{Response: any},
1527	})
1528
1529	var formattedParent string = fmt.Sprintf("projects/%s/regions/%s", "[PROJECT]", "[REGION]")
1530	var template *dataprocpb.WorkflowTemplate = &dataprocpb.WorkflowTemplate{}
1531	var request = &dataprocpb.InstantiateInlineWorkflowTemplateRequest{
1532		Parent:   formattedParent,
1533		Template: template,
1534	}
1535
1536	c, err := NewWorkflowTemplateClient(context.Background(), clientOpt)
1537	if err != nil {
1538		t.Fatal(err)
1539	}
1540
1541	respLRO, err := c.InstantiateInlineWorkflowTemplate(context.Background(), request)
1542	if err != nil {
1543		t.Fatal(err)
1544	}
1545	err = respLRO.Wait(context.Background())
1546
1547	if err != nil {
1548		t.Fatal(err)
1549	}
1550
1551	if want, got := request, mockWorkflowTemplate.reqs[0]; !proto.Equal(want, got) {
1552		t.Errorf("wrong request %q, want %q", got, want)
1553	}
1554
1555}
1556
1557func TestWorkflowTemplateServiceInstantiateInlineWorkflowTemplateError(t *testing.T) {
1558	errCode := codes.PermissionDenied
1559	mockWorkflowTemplate.err = nil
1560	mockWorkflowTemplate.resps = append(mockWorkflowTemplate.resps[:0], &longrunningpb.Operation{
1561		Name: "longrunning-test",
1562		Done: true,
1563		Result: &longrunningpb.Operation_Error{
1564			Error: &status.Status{
1565				Code:    int32(errCode),
1566				Message: "test error",
1567			},
1568		},
1569	})
1570
1571	var formattedParent string = fmt.Sprintf("projects/%s/regions/%s", "[PROJECT]", "[REGION]")
1572	var template *dataprocpb.WorkflowTemplate = &dataprocpb.WorkflowTemplate{}
1573	var request = &dataprocpb.InstantiateInlineWorkflowTemplateRequest{
1574		Parent:   formattedParent,
1575		Template: template,
1576	}
1577
1578	c, err := NewWorkflowTemplateClient(context.Background(), clientOpt)
1579	if err != nil {
1580		t.Fatal(err)
1581	}
1582
1583	respLRO, err := c.InstantiateInlineWorkflowTemplate(context.Background(), request)
1584	if err != nil {
1585		t.Fatal(err)
1586	}
1587	err = respLRO.Wait(context.Background())
1588
1589	if st, ok := gstatus.FromError(err); !ok {
1590		t.Errorf("got error %v, expected grpc error", err)
1591	} else if c := st.Code(); c != errCode {
1592		t.Errorf("got error code %q, want %q", c, errCode)
1593	}
1594}
1595func TestWorkflowTemplateServiceUpdateWorkflowTemplate(t *testing.T) {
1596	var id string = "id3355"
1597	var name string = "name3373707"
1598	var version int32 = 351608024
1599	var expectedResponse = &dataprocpb.WorkflowTemplate{
1600		Id:      id,
1601		Name:    name,
1602		Version: version,
1603	}
1604
1605	mockWorkflowTemplate.err = nil
1606	mockWorkflowTemplate.reqs = nil
1607
1608	mockWorkflowTemplate.resps = append(mockWorkflowTemplate.resps[:0], expectedResponse)
1609
1610	var template *dataprocpb.WorkflowTemplate = &dataprocpb.WorkflowTemplate{}
1611	var request = &dataprocpb.UpdateWorkflowTemplateRequest{
1612		Template: template,
1613	}
1614
1615	c, err := NewWorkflowTemplateClient(context.Background(), clientOpt)
1616	if err != nil {
1617		t.Fatal(err)
1618	}
1619
1620	resp, err := c.UpdateWorkflowTemplate(context.Background(), request)
1621
1622	if err != nil {
1623		t.Fatal(err)
1624	}
1625
1626	if want, got := request, mockWorkflowTemplate.reqs[0]; !proto.Equal(want, got) {
1627		t.Errorf("wrong request %q, want %q", got, want)
1628	}
1629
1630	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1631		t.Errorf("wrong response %q, want %q)", got, want)
1632	}
1633}
1634
1635func TestWorkflowTemplateServiceUpdateWorkflowTemplateError(t *testing.T) {
1636	errCode := codes.PermissionDenied
1637	mockWorkflowTemplate.err = gstatus.Error(errCode, "test error")
1638
1639	var template *dataprocpb.WorkflowTemplate = &dataprocpb.WorkflowTemplate{}
1640	var request = &dataprocpb.UpdateWorkflowTemplateRequest{
1641		Template: template,
1642	}
1643
1644	c, err := NewWorkflowTemplateClient(context.Background(), clientOpt)
1645	if err != nil {
1646		t.Fatal(err)
1647	}
1648
1649	resp, err := c.UpdateWorkflowTemplate(context.Background(), request)
1650
1651	if st, ok := gstatus.FromError(err); !ok {
1652		t.Errorf("got error %v, expected grpc error", err)
1653	} else if c := st.Code(); c != errCode {
1654		t.Errorf("got error code %q, want %q", c, errCode)
1655	}
1656	_ = resp
1657}
1658func TestWorkflowTemplateServiceListWorkflowTemplates(t *testing.T) {
1659	var nextPageToken string = ""
1660	var templatesElement *dataprocpb.WorkflowTemplate = &dataprocpb.WorkflowTemplate{}
1661	var templates = []*dataprocpb.WorkflowTemplate{templatesElement}
1662	var expectedResponse = &dataprocpb.ListWorkflowTemplatesResponse{
1663		NextPageToken: nextPageToken,
1664		Templates:     templates,
1665	}
1666
1667	mockWorkflowTemplate.err = nil
1668	mockWorkflowTemplate.reqs = nil
1669
1670	mockWorkflowTemplate.resps = append(mockWorkflowTemplate.resps[:0], expectedResponse)
1671
1672	var formattedParent string = fmt.Sprintf("projects/%s/regions/%s", "[PROJECT]", "[REGION]")
1673	var request = &dataprocpb.ListWorkflowTemplatesRequest{
1674		Parent: formattedParent,
1675	}
1676
1677	c, err := NewWorkflowTemplateClient(context.Background(), clientOpt)
1678	if err != nil {
1679		t.Fatal(err)
1680	}
1681
1682	resp, err := c.ListWorkflowTemplates(context.Background(), request).Next()
1683
1684	if err != nil {
1685		t.Fatal(err)
1686	}
1687
1688	if want, got := request, mockWorkflowTemplate.reqs[0]; !proto.Equal(want, got) {
1689		t.Errorf("wrong request %q, want %q", got, want)
1690	}
1691
1692	want := (interface{})(expectedResponse.Templates[0])
1693	got := (interface{})(resp)
1694	var ok bool
1695
1696	switch want := (want).(type) {
1697	case proto.Message:
1698		ok = proto.Equal(want, got.(proto.Message))
1699	default:
1700		ok = want == got
1701	}
1702	if !ok {
1703		t.Errorf("wrong response %q, want %q)", got, want)
1704	}
1705}
1706
1707func TestWorkflowTemplateServiceListWorkflowTemplatesError(t *testing.T) {
1708	errCode := codes.PermissionDenied
1709	mockWorkflowTemplate.err = gstatus.Error(errCode, "test error")
1710
1711	var formattedParent string = fmt.Sprintf("projects/%s/regions/%s", "[PROJECT]", "[REGION]")
1712	var request = &dataprocpb.ListWorkflowTemplatesRequest{
1713		Parent: formattedParent,
1714	}
1715
1716	c, err := NewWorkflowTemplateClient(context.Background(), clientOpt)
1717	if err != nil {
1718		t.Fatal(err)
1719	}
1720
1721	resp, err := c.ListWorkflowTemplates(context.Background(), request).Next()
1722
1723	if st, ok := gstatus.FromError(err); !ok {
1724		t.Errorf("got error %v, expected grpc error", err)
1725	} else if c := st.Code(); c != errCode {
1726		t.Errorf("got error code %q, want %q", c, errCode)
1727	}
1728	_ = resp
1729}
1730func TestWorkflowTemplateServiceDeleteWorkflowTemplate(t *testing.T) {
1731	var expectedResponse *emptypb.Empty = &emptypb.Empty{}
1732
1733	mockWorkflowTemplate.err = nil
1734	mockWorkflowTemplate.reqs = nil
1735
1736	mockWorkflowTemplate.resps = append(mockWorkflowTemplate.resps[:0], expectedResponse)
1737
1738	var formattedName string = fmt.Sprintf("projects/%s/regions/%s/workflowTemplates/%s", "[PROJECT]", "[REGION]", "[WORKFLOW_TEMPLATE]")
1739	var request = &dataprocpb.DeleteWorkflowTemplateRequest{
1740		Name: formattedName,
1741	}
1742
1743	c, err := NewWorkflowTemplateClient(context.Background(), clientOpt)
1744	if err != nil {
1745		t.Fatal(err)
1746	}
1747
1748	err = c.DeleteWorkflowTemplate(context.Background(), request)
1749
1750	if err != nil {
1751		t.Fatal(err)
1752	}
1753
1754	if want, got := request, mockWorkflowTemplate.reqs[0]; !proto.Equal(want, got) {
1755		t.Errorf("wrong request %q, want %q", got, want)
1756	}
1757
1758}
1759
1760func TestWorkflowTemplateServiceDeleteWorkflowTemplateError(t *testing.T) {
1761	errCode := codes.PermissionDenied
1762	mockWorkflowTemplate.err = gstatus.Error(errCode, "test error")
1763
1764	var formattedName string = fmt.Sprintf("projects/%s/regions/%s/workflowTemplates/%s", "[PROJECT]", "[REGION]", "[WORKFLOW_TEMPLATE]")
1765	var request = &dataprocpb.DeleteWorkflowTemplateRequest{
1766		Name: formattedName,
1767	}
1768
1769	c, err := NewWorkflowTemplateClient(context.Background(), clientOpt)
1770	if err != nil {
1771		t.Fatal(err)
1772	}
1773
1774	err = c.DeleteWorkflowTemplate(context.Background(), request)
1775
1776	if st, ok := gstatus.FromError(err); !ok {
1777		t.Errorf("got error %v, expected grpc error", err)
1778	} else if c := st.Code(); c != errCode {
1779		t.Errorf("got error code %q, want %q", c, errCode)
1780	}
1781}
1782