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 redis
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	redispb "google.golang.org/genproto/googleapis/cloud/redis/v1beta1"
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 mockCloudRedisServer struct {
51	// Embed for forward compatibility.
52	// Tests will keep working if more methods are added
53	// in the future.
54	redispb.CloudRedisServer
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 *mockCloudRedisServer) ListInstances(ctx context.Context, req *redispb.ListInstancesRequest) (*redispb.ListInstancesResponse, 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].(*redispb.ListInstancesResponse), nil
75}
76
77func (s *mockCloudRedisServer) GetInstance(ctx context.Context, req *redispb.GetInstanceRequest) (*redispb.Instance, 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].(*redispb.Instance), nil
87}
88
89func (s *mockCloudRedisServer) CreateInstance(ctx context.Context, req *redispb.CreateInstanceRequest) (*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 *mockCloudRedisServer) UpdateInstance(ctx context.Context, req *redispb.UpdateInstanceRequest) (*longrunningpb.Operation, 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].(*longrunningpb.Operation), nil
111}
112
113func (s *mockCloudRedisServer) ImportInstance(ctx context.Context, req *redispb.ImportInstanceRequest) (*longrunningpb.Operation, 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].(*longrunningpb.Operation), nil
123}
124
125func (s *mockCloudRedisServer) ExportInstance(ctx context.Context, req *redispb.ExportInstanceRequest) (*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
137func (s *mockCloudRedisServer) FailoverInstance(ctx context.Context, req *redispb.FailoverInstanceRequest) (*longrunningpb.Operation, error) {
138	md, _ := metadata.FromIncomingContext(ctx)
139	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
140		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
141	}
142	s.reqs = append(s.reqs, req)
143	if s.err != nil {
144		return nil, s.err
145	}
146	return s.resps[0].(*longrunningpb.Operation), nil
147}
148
149func (s *mockCloudRedisServer) DeleteInstance(ctx context.Context, req *redispb.DeleteInstanceRequest) (*longrunningpb.Operation, error) {
150	md, _ := metadata.FromIncomingContext(ctx)
151	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
152		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
153	}
154	s.reqs = append(s.reqs, req)
155	if s.err != nil {
156		return nil, s.err
157	}
158	return s.resps[0].(*longrunningpb.Operation), nil
159}
160
161// clientOpt is the option tests should use to connect to the test server.
162// It is initialized by TestMain.
163var clientOpt option.ClientOption
164
165var (
166	mockCloudRedis mockCloudRedisServer
167)
168
169func TestMain(m *testing.M) {
170	flag.Parse()
171
172	serv := grpc.NewServer()
173	redispb.RegisterCloudRedisServer(serv, &mockCloudRedis)
174
175	lis, err := net.Listen("tcp", "localhost:0")
176	if err != nil {
177		log.Fatal(err)
178	}
179	go serv.Serve(lis)
180
181	conn, err := grpc.Dial(lis.Addr().String(), grpc.WithInsecure())
182	if err != nil {
183		log.Fatal(err)
184	}
185	clientOpt = option.WithGRPCConn(conn)
186
187	os.Exit(m.Run())
188}
189
190func TestCloudRedisListInstances(t *testing.T) {
191	var nextPageToken string = ""
192	var instancesElement *redispb.Instance = &redispb.Instance{}
193	var instances = []*redispb.Instance{instancesElement}
194	var expectedResponse = &redispb.ListInstancesResponse{
195		NextPageToken: nextPageToken,
196		Instances:     instances,
197	}
198
199	mockCloudRedis.err = nil
200	mockCloudRedis.reqs = nil
201
202	mockCloudRedis.resps = append(mockCloudRedis.resps[:0], expectedResponse)
203
204	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]")
205	var request = &redispb.ListInstancesRequest{
206		Parent: formattedParent,
207	}
208
209	c, err := NewCloudRedisClient(context.Background(), clientOpt)
210	if err != nil {
211		t.Fatal(err)
212	}
213
214	resp, err := c.ListInstances(context.Background(), request).Next()
215
216	if err != nil {
217		t.Fatal(err)
218	}
219
220	if want, got := request, mockCloudRedis.reqs[0]; !proto.Equal(want, got) {
221		t.Errorf("wrong request %q, want %q", got, want)
222	}
223
224	want := (interface{})(expectedResponse.Instances[0])
225	got := (interface{})(resp)
226	var ok bool
227
228	switch want := (want).(type) {
229	case proto.Message:
230		ok = proto.Equal(want, got.(proto.Message))
231	default:
232		ok = want == got
233	}
234	if !ok {
235		t.Errorf("wrong response %q, want %q)", got, want)
236	}
237}
238
239func TestCloudRedisListInstancesError(t *testing.T) {
240	errCode := codes.PermissionDenied
241	mockCloudRedis.err = gstatus.Error(errCode, "test error")
242
243	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]")
244	var request = &redispb.ListInstancesRequest{
245		Parent: formattedParent,
246	}
247
248	c, err := NewCloudRedisClient(context.Background(), clientOpt)
249	if err != nil {
250		t.Fatal(err)
251	}
252
253	resp, err := c.ListInstances(context.Background(), request).Next()
254
255	if st, ok := gstatus.FromError(err); !ok {
256		t.Errorf("got error %v, expected grpc error", err)
257	} else if c := st.Code(); c != errCode {
258		t.Errorf("got error code %q, want %q", c, errCode)
259	}
260	_ = resp
261}
262func TestCloudRedisGetInstance(t *testing.T) {
263	var name2 string = "name2-1052831874"
264	var displayName string = "displayName1615086568"
265	var locationId string = "locationId552319461"
266	var alternativeLocationId string = "alternativeLocationId-718920621"
267	var redisVersion string = "redisVersion-685310444"
268	var reservedIpRange string = "reservedIpRange-1082940580"
269	var host string = "host3208616"
270	var port int32 = 3446913
271	var currentLocationId string = "currentLocationId1312712735"
272	var statusMessage string = "statusMessage-239442758"
273	var memorySizeGb int32 = 34199707
274	var authorizedNetwork string = "authorizedNetwork-1733809270"
275	var persistenceIamIdentity string = "persistenceIamIdentity1061944584"
276	var expectedResponse = &redispb.Instance{
277		Name:                   name2,
278		DisplayName:            displayName,
279		LocationId:             locationId,
280		AlternativeLocationId:  alternativeLocationId,
281		RedisVersion:           redisVersion,
282		ReservedIpRange:        reservedIpRange,
283		Host:                   host,
284		Port:                   port,
285		CurrentLocationId:      currentLocationId,
286		StatusMessage:          statusMessage,
287		MemorySizeGb:           memorySizeGb,
288		AuthorizedNetwork:      authorizedNetwork,
289		PersistenceIamIdentity: persistenceIamIdentity,
290	}
291
292	mockCloudRedis.err = nil
293	mockCloudRedis.reqs = nil
294
295	mockCloudRedis.resps = append(mockCloudRedis.resps[:0], expectedResponse)
296
297	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/instances/%s", "[PROJECT]", "[LOCATION]", "[INSTANCE]")
298	var request = &redispb.GetInstanceRequest{
299		Name: formattedName,
300	}
301
302	c, err := NewCloudRedisClient(context.Background(), clientOpt)
303	if err != nil {
304		t.Fatal(err)
305	}
306
307	resp, err := c.GetInstance(context.Background(), request)
308
309	if err != nil {
310		t.Fatal(err)
311	}
312
313	if want, got := request, mockCloudRedis.reqs[0]; !proto.Equal(want, got) {
314		t.Errorf("wrong request %q, want %q", got, want)
315	}
316
317	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
318		t.Errorf("wrong response %q, want %q)", got, want)
319	}
320}
321
322func TestCloudRedisGetInstanceError(t *testing.T) {
323	errCode := codes.PermissionDenied
324	mockCloudRedis.err = gstatus.Error(errCode, "test error")
325
326	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/instances/%s", "[PROJECT]", "[LOCATION]", "[INSTANCE]")
327	var request = &redispb.GetInstanceRequest{
328		Name: formattedName,
329	}
330
331	c, err := NewCloudRedisClient(context.Background(), clientOpt)
332	if err != nil {
333		t.Fatal(err)
334	}
335
336	resp, err := c.GetInstance(context.Background(), request)
337
338	if st, ok := gstatus.FromError(err); !ok {
339		t.Errorf("got error %v, expected grpc error", err)
340	} else if c := st.Code(); c != errCode {
341		t.Errorf("got error code %q, want %q", c, errCode)
342	}
343	_ = resp
344}
345func TestCloudRedisCreateInstance(t *testing.T) {
346	var name string = "name3373707"
347	var displayName string = "displayName1615086568"
348	var locationId string = "locationId552319461"
349	var alternativeLocationId string = "alternativeLocationId-718920621"
350	var redisVersion string = "redisVersion-685310444"
351	var reservedIpRange string = "reservedIpRange-1082940580"
352	var host string = "host3208616"
353	var port int32 = 3446913
354	var currentLocationId string = "currentLocationId1312712735"
355	var statusMessage string = "statusMessage-239442758"
356	var memorySizeGb2 int32 = 1493816946
357	var authorizedNetwork string = "authorizedNetwork-1733809270"
358	var persistenceIamIdentity string = "persistenceIamIdentity1061944584"
359	var expectedResponse = &redispb.Instance{
360		Name:                   name,
361		DisplayName:            displayName,
362		LocationId:             locationId,
363		AlternativeLocationId:  alternativeLocationId,
364		RedisVersion:           redisVersion,
365		ReservedIpRange:        reservedIpRange,
366		Host:                   host,
367		Port:                   port,
368		CurrentLocationId:      currentLocationId,
369		StatusMessage:          statusMessage,
370		MemorySizeGb:           memorySizeGb2,
371		AuthorizedNetwork:      authorizedNetwork,
372		PersistenceIamIdentity: persistenceIamIdentity,
373	}
374
375	mockCloudRedis.err = nil
376	mockCloudRedis.reqs = nil
377
378	any, err := ptypes.MarshalAny(expectedResponse)
379	if err != nil {
380		t.Fatal(err)
381	}
382	mockCloudRedis.resps = append(mockCloudRedis.resps[:0], &longrunningpb.Operation{
383		Name:   "longrunning-test",
384		Done:   true,
385		Result: &longrunningpb.Operation_Response{Response: any},
386	})
387
388	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]")
389	var instanceId string = "test_instance"
390	var tier redispb.Instance_Tier = redispb.Instance_BASIC
391	var memorySizeGb int32 = 1
392	var instance = &redispb.Instance{
393		Tier:         tier,
394		MemorySizeGb: memorySizeGb,
395	}
396	var request = &redispb.CreateInstanceRequest{
397		Parent:     formattedParent,
398		InstanceId: instanceId,
399		Instance:   instance,
400	}
401
402	c, err := NewCloudRedisClient(context.Background(), clientOpt)
403	if err != nil {
404		t.Fatal(err)
405	}
406
407	respLRO, err := c.CreateInstance(context.Background(), request)
408	if err != nil {
409		t.Fatal(err)
410	}
411	resp, err := respLRO.Wait(context.Background())
412
413	if err != nil {
414		t.Fatal(err)
415	}
416
417	if want, got := request, mockCloudRedis.reqs[0]; !proto.Equal(want, got) {
418		t.Errorf("wrong request %q, want %q", got, want)
419	}
420
421	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
422		t.Errorf("wrong response %q, want %q)", got, want)
423	}
424}
425
426func TestCloudRedisCreateInstanceError(t *testing.T) {
427	errCode := codes.PermissionDenied
428	mockCloudRedis.err = nil
429	mockCloudRedis.resps = append(mockCloudRedis.resps[:0], &longrunningpb.Operation{
430		Name: "longrunning-test",
431		Done: true,
432		Result: &longrunningpb.Operation_Error{
433			Error: &status.Status{
434				Code:    int32(errCode),
435				Message: "test error",
436			},
437		},
438	})
439
440	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]")
441	var instanceId string = "test_instance"
442	var tier redispb.Instance_Tier = redispb.Instance_BASIC
443	var memorySizeGb int32 = 1
444	var instance = &redispb.Instance{
445		Tier:         tier,
446		MemorySizeGb: memorySizeGb,
447	}
448	var request = &redispb.CreateInstanceRequest{
449		Parent:     formattedParent,
450		InstanceId: instanceId,
451		Instance:   instance,
452	}
453
454	c, err := NewCloudRedisClient(context.Background(), clientOpt)
455	if err != nil {
456		t.Fatal(err)
457	}
458
459	respLRO, err := c.CreateInstance(context.Background(), request)
460	if err != nil {
461		t.Fatal(err)
462	}
463	resp, err := respLRO.Wait(context.Background())
464
465	if st, ok := gstatus.FromError(err); !ok {
466		t.Errorf("got error %v, expected grpc error", err)
467	} else if c := st.Code(); c != errCode {
468		t.Errorf("got error code %q, want %q", c, errCode)
469	}
470	_ = resp
471}
472func TestCloudRedisUpdateInstance(t *testing.T) {
473	var name string = "name3373707"
474	var displayName2 string = "displayName21615000987"
475	var locationId string = "locationId552319461"
476	var alternativeLocationId string = "alternativeLocationId-718920621"
477	var redisVersion string = "redisVersion-685310444"
478	var reservedIpRange string = "reservedIpRange-1082940580"
479	var host string = "host3208616"
480	var port int32 = 3446913
481	var currentLocationId string = "currentLocationId1312712735"
482	var statusMessage string = "statusMessage-239442758"
483	var memorySizeGb2 int32 = 1493816946
484	var authorizedNetwork string = "authorizedNetwork-1733809270"
485	var persistenceIamIdentity string = "persistenceIamIdentity1061944584"
486	var expectedResponse = &redispb.Instance{
487		Name:                   name,
488		DisplayName:            displayName2,
489		LocationId:             locationId,
490		AlternativeLocationId:  alternativeLocationId,
491		RedisVersion:           redisVersion,
492		ReservedIpRange:        reservedIpRange,
493		Host:                   host,
494		Port:                   port,
495		CurrentLocationId:      currentLocationId,
496		StatusMessage:          statusMessage,
497		MemorySizeGb:           memorySizeGb2,
498		AuthorizedNetwork:      authorizedNetwork,
499		PersistenceIamIdentity: persistenceIamIdentity,
500	}
501
502	mockCloudRedis.err = nil
503	mockCloudRedis.reqs = nil
504
505	any, err := ptypes.MarshalAny(expectedResponse)
506	if err != nil {
507		t.Fatal(err)
508	}
509	mockCloudRedis.resps = append(mockCloudRedis.resps[:0], &longrunningpb.Operation{
510		Name:   "longrunning-test",
511		Done:   true,
512		Result: &longrunningpb.Operation_Response{Response: any},
513	})
514
515	var pathsElement string = "display_name"
516	var pathsElement2 string = "memory_size_gb"
517	var paths = []string{pathsElement, pathsElement2}
518	var updateMask = &field_maskpb.FieldMask{
519		Paths: paths,
520	}
521	var displayName string = "UpdatedDisplayName"
522	var memorySizeGb int32 = 4
523	var instance = &redispb.Instance{
524		DisplayName:  displayName,
525		MemorySizeGb: memorySizeGb,
526	}
527	var request = &redispb.UpdateInstanceRequest{
528		UpdateMask: updateMask,
529		Instance:   instance,
530	}
531
532	c, err := NewCloudRedisClient(context.Background(), clientOpt)
533	if err != nil {
534		t.Fatal(err)
535	}
536
537	respLRO, err := c.UpdateInstance(context.Background(), request)
538	if err != nil {
539		t.Fatal(err)
540	}
541	resp, err := respLRO.Wait(context.Background())
542
543	if err != nil {
544		t.Fatal(err)
545	}
546
547	if want, got := request, mockCloudRedis.reqs[0]; !proto.Equal(want, got) {
548		t.Errorf("wrong request %q, want %q", got, want)
549	}
550
551	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
552		t.Errorf("wrong response %q, want %q)", got, want)
553	}
554}
555
556func TestCloudRedisUpdateInstanceError(t *testing.T) {
557	errCode := codes.PermissionDenied
558	mockCloudRedis.err = nil
559	mockCloudRedis.resps = append(mockCloudRedis.resps[:0], &longrunningpb.Operation{
560		Name: "longrunning-test",
561		Done: true,
562		Result: &longrunningpb.Operation_Error{
563			Error: &status.Status{
564				Code:    int32(errCode),
565				Message: "test error",
566			},
567		},
568	})
569
570	var pathsElement string = "display_name"
571	var pathsElement2 string = "memory_size_gb"
572	var paths = []string{pathsElement, pathsElement2}
573	var updateMask = &field_maskpb.FieldMask{
574		Paths: paths,
575	}
576	var displayName string = "UpdatedDisplayName"
577	var memorySizeGb int32 = 4
578	var instance = &redispb.Instance{
579		DisplayName:  displayName,
580		MemorySizeGb: memorySizeGb,
581	}
582	var request = &redispb.UpdateInstanceRequest{
583		UpdateMask: updateMask,
584		Instance:   instance,
585	}
586
587	c, err := NewCloudRedisClient(context.Background(), clientOpt)
588	if err != nil {
589		t.Fatal(err)
590	}
591
592	respLRO, err := c.UpdateInstance(context.Background(), request)
593	if err != nil {
594		t.Fatal(err)
595	}
596	resp, err := respLRO.Wait(context.Background())
597
598	if st, ok := gstatus.FromError(err); !ok {
599		t.Errorf("got error %v, expected grpc error", err)
600	} else if c := st.Code(); c != errCode {
601		t.Errorf("got error code %q, want %q", c, errCode)
602	}
603	_ = resp
604}
605func TestCloudRedisImportInstance(t *testing.T) {
606	var name2 string = "name2-1052831874"
607	var displayName string = "displayName1615086568"
608	var locationId string = "locationId552319461"
609	var alternativeLocationId string = "alternativeLocationId-718920621"
610	var redisVersion string = "redisVersion-685310444"
611	var reservedIpRange string = "reservedIpRange-1082940580"
612	var host string = "host3208616"
613	var port int32 = 3446913
614	var currentLocationId string = "currentLocationId1312712735"
615	var statusMessage string = "statusMessage-239442758"
616	var memorySizeGb int32 = 34199707
617	var authorizedNetwork string = "authorizedNetwork-1733809270"
618	var persistenceIamIdentity string = "persistenceIamIdentity1061944584"
619	var expectedResponse = &redispb.Instance{
620		Name:                   name2,
621		DisplayName:            displayName,
622		LocationId:             locationId,
623		AlternativeLocationId:  alternativeLocationId,
624		RedisVersion:           redisVersion,
625		ReservedIpRange:        reservedIpRange,
626		Host:                   host,
627		Port:                   port,
628		CurrentLocationId:      currentLocationId,
629		StatusMessage:          statusMessage,
630		MemorySizeGb:           memorySizeGb,
631		AuthorizedNetwork:      authorizedNetwork,
632		PersistenceIamIdentity: persistenceIamIdentity,
633	}
634
635	mockCloudRedis.err = nil
636	mockCloudRedis.reqs = nil
637
638	any, err := ptypes.MarshalAny(expectedResponse)
639	if err != nil {
640		t.Fatal(err)
641	}
642	mockCloudRedis.resps = append(mockCloudRedis.resps[:0], &longrunningpb.Operation{
643		Name:   "longrunning-test",
644		Done:   true,
645		Result: &longrunningpb.Operation_Response{Response: any},
646	})
647
648	var name string = "name3373707"
649	var inputConfig *redispb.InputConfig = &redispb.InputConfig{}
650	var request = &redispb.ImportInstanceRequest{
651		Name:        name,
652		InputConfig: inputConfig,
653	}
654
655	c, err := NewCloudRedisClient(context.Background(), clientOpt)
656	if err != nil {
657		t.Fatal(err)
658	}
659
660	respLRO, err := c.ImportInstance(context.Background(), request)
661	if err != nil {
662		t.Fatal(err)
663	}
664	resp, err := respLRO.Wait(context.Background())
665
666	if err != nil {
667		t.Fatal(err)
668	}
669
670	if want, got := request, mockCloudRedis.reqs[0]; !proto.Equal(want, got) {
671		t.Errorf("wrong request %q, want %q", got, want)
672	}
673
674	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
675		t.Errorf("wrong response %q, want %q)", got, want)
676	}
677}
678
679func TestCloudRedisImportInstanceError(t *testing.T) {
680	errCode := codes.PermissionDenied
681	mockCloudRedis.err = nil
682	mockCloudRedis.resps = append(mockCloudRedis.resps[:0], &longrunningpb.Operation{
683		Name: "longrunning-test",
684		Done: true,
685		Result: &longrunningpb.Operation_Error{
686			Error: &status.Status{
687				Code:    int32(errCode),
688				Message: "test error",
689			},
690		},
691	})
692
693	var name string = "name3373707"
694	var inputConfig *redispb.InputConfig = &redispb.InputConfig{}
695	var request = &redispb.ImportInstanceRequest{
696		Name:        name,
697		InputConfig: inputConfig,
698	}
699
700	c, err := NewCloudRedisClient(context.Background(), clientOpt)
701	if err != nil {
702		t.Fatal(err)
703	}
704
705	respLRO, err := c.ImportInstance(context.Background(), request)
706	if err != nil {
707		t.Fatal(err)
708	}
709	resp, err := respLRO.Wait(context.Background())
710
711	if st, ok := gstatus.FromError(err); !ok {
712		t.Errorf("got error %v, expected grpc error", err)
713	} else if c := st.Code(); c != errCode {
714		t.Errorf("got error code %q, want %q", c, errCode)
715	}
716	_ = resp
717}
718func TestCloudRedisExportInstance(t *testing.T) {
719	var name2 string = "name2-1052831874"
720	var displayName string = "displayName1615086568"
721	var locationId string = "locationId552319461"
722	var alternativeLocationId string = "alternativeLocationId-718920621"
723	var redisVersion string = "redisVersion-685310444"
724	var reservedIpRange string = "reservedIpRange-1082940580"
725	var host string = "host3208616"
726	var port int32 = 3446913
727	var currentLocationId string = "currentLocationId1312712735"
728	var statusMessage string = "statusMessage-239442758"
729	var memorySizeGb int32 = 34199707
730	var authorizedNetwork string = "authorizedNetwork-1733809270"
731	var persistenceIamIdentity string = "persistenceIamIdentity1061944584"
732	var expectedResponse = &redispb.Instance{
733		Name:                   name2,
734		DisplayName:            displayName,
735		LocationId:             locationId,
736		AlternativeLocationId:  alternativeLocationId,
737		RedisVersion:           redisVersion,
738		ReservedIpRange:        reservedIpRange,
739		Host:                   host,
740		Port:                   port,
741		CurrentLocationId:      currentLocationId,
742		StatusMessage:          statusMessage,
743		MemorySizeGb:           memorySizeGb,
744		AuthorizedNetwork:      authorizedNetwork,
745		PersistenceIamIdentity: persistenceIamIdentity,
746	}
747
748	mockCloudRedis.err = nil
749	mockCloudRedis.reqs = nil
750
751	any, err := ptypes.MarshalAny(expectedResponse)
752	if err != nil {
753		t.Fatal(err)
754	}
755	mockCloudRedis.resps = append(mockCloudRedis.resps[:0], &longrunningpb.Operation{
756		Name:   "longrunning-test",
757		Done:   true,
758		Result: &longrunningpb.Operation_Response{Response: any},
759	})
760
761	var name string = "name3373707"
762	var outputConfig *redispb.OutputConfig = &redispb.OutputConfig{}
763	var request = &redispb.ExportInstanceRequest{
764		Name:         name,
765		OutputConfig: outputConfig,
766	}
767
768	c, err := NewCloudRedisClient(context.Background(), clientOpt)
769	if err != nil {
770		t.Fatal(err)
771	}
772
773	respLRO, err := c.ExportInstance(context.Background(), request)
774	if err != nil {
775		t.Fatal(err)
776	}
777	resp, err := respLRO.Wait(context.Background())
778
779	if err != nil {
780		t.Fatal(err)
781	}
782
783	if want, got := request, mockCloudRedis.reqs[0]; !proto.Equal(want, got) {
784		t.Errorf("wrong request %q, want %q", got, want)
785	}
786
787	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
788		t.Errorf("wrong response %q, want %q)", got, want)
789	}
790}
791
792func TestCloudRedisExportInstanceError(t *testing.T) {
793	errCode := codes.PermissionDenied
794	mockCloudRedis.err = nil
795	mockCloudRedis.resps = append(mockCloudRedis.resps[:0], &longrunningpb.Operation{
796		Name: "longrunning-test",
797		Done: true,
798		Result: &longrunningpb.Operation_Error{
799			Error: &status.Status{
800				Code:    int32(errCode),
801				Message: "test error",
802			},
803		},
804	})
805
806	var name string = "name3373707"
807	var outputConfig *redispb.OutputConfig = &redispb.OutputConfig{}
808	var request = &redispb.ExportInstanceRequest{
809		Name:         name,
810		OutputConfig: outputConfig,
811	}
812
813	c, err := NewCloudRedisClient(context.Background(), clientOpt)
814	if err != nil {
815		t.Fatal(err)
816	}
817
818	respLRO, err := c.ExportInstance(context.Background(), request)
819	if err != nil {
820		t.Fatal(err)
821	}
822	resp, err := respLRO.Wait(context.Background())
823
824	if st, ok := gstatus.FromError(err); !ok {
825		t.Errorf("got error %v, expected grpc error", err)
826	} else if c := st.Code(); c != errCode {
827		t.Errorf("got error code %q, want %q", c, errCode)
828	}
829	_ = resp
830}
831func TestCloudRedisFailoverInstance(t *testing.T) {
832	var name2 string = "name2-1052831874"
833	var displayName string = "displayName1615086568"
834	var locationId string = "locationId552319461"
835	var alternativeLocationId string = "alternativeLocationId-718920621"
836	var redisVersion string = "redisVersion-685310444"
837	var reservedIpRange string = "reservedIpRange-1082940580"
838	var host string = "host3208616"
839	var port int32 = 3446913
840	var currentLocationId string = "currentLocationId1312712735"
841	var statusMessage string = "statusMessage-239442758"
842	var memorySizeGb int32 = 34199707
843	var authorizedNetwork string = "authorizedNetwork-1733809270"
844	var persistenceIamIdentity string = "persistenceIamIdentity1061944584"
845	var expectedResponse = &redispb.Instance{
846		Name:                   name2,
847		DisplayName:            displayName,
848		LocationId:             locationId,
849		AlternativeLocationId:  alternativeLocationId,
850		RedisVersion:           redisVersion,
851		ReservedIpRange:        reservedIpRange,
852		Host:                   host,
853		Port:                   port,
854		CurrentLocationId:      currentLocationId,
855		StatusMessage:          statusMessage,
856		MemorySizeGb:           memorySizeGb,
857		AuthorizedNetwork:      authorizedNetwork,
858		PersistenceIamIdentity: persistenceIamIdentity,
859	}
860
861	mockCloudRedis.err = nil
862	mockCloudRedis.reqs = nil
863
864	any, err := ptypes.MarshalAny(expectedResponse)
865	if err != nil {
866		t.Fatal(err)
867	}
868	mockCloudRedis.resps = append(mockCloudRedis.resps[:0], &longrunningpb.Operation{
869		Name:   "longrunning-test",
870		Done:   true,
871		Result: &longrunningpb.Operation_Response{Response: any},
872	})
873
874	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/instances/%s", "[PROJECT]", "[LOCATION]", "[INSTANCE]")
875	var request = &redispb.FailoverInstanceRequest{
876		Name: formattedName,
877	}
878
879	c, err := NewCloudRedisClient(context.Background(), clientOpt)
880	if err != nil {
881		t.Fatal(err)
882	}
883
884	respLRO, err := c.FailoverInstance(context.Background(), request)
885	if err != nil {
886		t.Fatal(err)
887	}
888	resp, err := respLRO.Wait(context.Background())
889
890	if err != nil {
891		t.Fatal(err)
892	}
893
894	if want, got := request, mockCloudRedis.reqs[0]; !proto.Equal(want, got) {
895		t.Errorf("wrong request %q, want %q", got, want)
896	}
897
898	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
899		t.Errorf("wrong response %q, want %q)", got, want)
900	}
901}
902
903func TestCloudRedisFailoverInstanceError(t *testing.T) {
904	errCode := codes.PermissionDenied
905	mockCloudRedis.err = nil
906	mockCloudRedis.resps = append(mockCloudRedis.resps[:0], &longrunningpb.Operation{
907		Name: "longrunning-test",
908		Done: true,
909		Result: &longrunningpb.Operation_Error{
910			Error: &status.Status{
911				Code:    int32(errCode),
912				Message: "test error",
913			},
914		},
915	})
916
917	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/instances/%s", "[PROJECT]", "[LOCATION]", "[INSTANCE]")
918	var request = &redispb.FailoverInstanceRequest{
919		Name: formattedName,
920	}
921
922	c, err := NewCloudRedisClient(context.Background(), clientOpt)
923	if err != nil {
924		t.Fatal(err)
925	}
926
927	respLRO, err := c.FailoverInstance(context.Background(), request)
928	if err != nil {
929		t.Fatal(err)
930	}
931	resp, err := respLRO.Wait(context.Background())
932
933	if st, ok := gstatus.FromError(err); !ok {
934		t.Errorf("got error %v, expected grpc error", err)
935	} else if c := st.Code(); c != errCode {
936		t.Errorf("got error code %q, want %q", c, errCode)
937	}
938	_ = resp
939}
940func TestCloudRedisDeleteInstance(t *testing.T) {
941	var expectedResponse *emptypb.Empty = &emptypb.Empty{}
942
943	mockCloudRedis.err = nil
944	mockCloudRedis.reqs = nil
945
946	any, err := ptypes.MarshalAny(expectedResponse)
947	if err != nil {
948		t.Fatal(err)
949	}
950	mockCloudRedis.resps = append(mockCloudRedis.resps[:0], &longrunningpb.Operation{
951		Name:   "longrunning-test",
952		Done:   true,
953		Result: &longrunningpb.Operation_Response{Response: any},
954	})
955
956	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/instances/%s", "[PROJECT]", "[LOCATION]", "[INSTANCE]")
957	var request = &redispb.DeleteInstanceRequest{
958		Name: formattedName,
959	}
960
961	c, err := NewCloudRedisClient(context.Background(), clientOpt)
962	if err != nil {
963		t.Fatal(err)
964	}
965
966	respLRO, err := c.DeleteInstance(context.Background(), request)
967	if err != nil {
968		t.Fatal(err)
969	}
970	err = respLRO.Wait(context.Background())
971
972	if err != nil {
973		t.Fatal(err)
974	}
975
976	if want, got := request, mockCloudRedis.reqs[0]; !proto.Equal(want, got) {
977		t.Errorf("wrong request %q, want %q", got, want)
978	}
979
980}
981
982func TestCloudRedisDeleteInstanceError(t *testing.T) {
983	errCode := codes.PermissionDenied
984	mockCloudRedis.err = nil
985	mockCloudRedis.resps = append(mockCloudRedis.resps[:0], &longrunningpb.Operation{
986		Name: "longrunning-test",
987		Done: true,
988		Result: &longrunningpb.Operation_Error{
989			Error: &status.Status{
990				Code:    int32(errCode),
991				Message: "test error",
992			},
993		},
994	})
995
996	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/instances/%s", "[PROJECT]", "[LOCATION]", "[INSTANCE]")
997	var request = &redispb.DeleteInstanceRequest{
998		Name: formattedName,
999	}
1000
1001	c, err := NewCloudRedisClient(context.Background(), clientOpt)
1002	if err != nil {
1003		t.Fatal(err)
1004	}
1005
1006	respLRO, err := c.DeleteInstance(context.Background(), request)
1007	if err != nil {
1008		t.Fatal(err)
1009	}
1010	err = respLRO.Wait(context.Background())
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}
1018