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/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 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 memorySizeGb int32 = 34199707
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:           memorySizeGb,
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 = " instance.memory_size_gb=4"
522	var instance = &redispb.Instance{
523		DisplayName: displayName,
524	}
525	var request = &redispb.UpdateInstanceRequest{
526		UpdateMask: updateMask,
527		Instance:   instance,
528	}
529
530	c, err := NewCloudRedisClient(context.Background(), clientOpt)
531	if err != nil {
532		t.Fatal(err)
533	}
534
535	respLRO, err := c.UpdateInstance(context.Background(), request)
536	if err != nil {
537		t.Fatal(err)
538	}
539	resp, err := respLRO.Wait(context.Background())
540
541	if err != nil {
542		t.Fatal(err)
543	}
544
545	if want, got := request, mockCloudRedis.reqs[0]; !proto.Equal(want, got) {
546		t.Errorf("wrong request %q, want %q", got, want)
547	}
548
549	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
550		t.Errorf("wrong response %q, want %q)", got, want)
551	}
552}
553
554func TestCloudRedisUpdateInstanceError(t *testing.T) {
555	errCode := codes.PermissionDenied
556	mockCloudRedis.err = nil
557	mockCloudRedis.resps = append(mockCloudRedis.resps[:0], &longrunningpb.Operation{
558		Name: "longrunning-test",
559		Done: true,
560		Result: &longrunningpb.Operation_Error{
561			Error: &status.Status{
562				Code:    int32(errCode),
563				Message: "test error",
564			},
565		},
566	})
567
568	var pathsElement string = "display_name"
569	var pathsElement2 string = "memory_size_gb"
570	var paths = []string{pathsElement, pathsElement2}
571	var updateMask = &field_maskpb.FieldMask{
572		Paths: paths,
573	}
574	var displayName string = " instance.memory_size_gb=4"
575	var instance = &redispb.Instance{
576		DisplayName: displayName,
577	}
578	var request = &redispb.UpdateInstanceRequest{
579		UpdateMask: updateMask,
580		Instance:   instance,
581	}
582
583	c, err := NewCloudRedisClient(context.Background(), clientOpt)
584	if err != nil {
585		t.Fatal(err)
586	}
587
588	respLRO, err := c.UpdateInstance(context.Background(), request)
589	if err != nil {
590		t.Fatal(err)
591	}
592	resp, err := respLRO.Wait(context.Background())
593
594	if st, ok := gstatus.FromError(err); !ok {
595		t.Errorf("got error %v, expected grpc error", err)
596	} else if c := st.Code(); c != errCode {
597		t.Errorf("got error code %q, want %q", c, errCode)
598	}
599	_ = resp
600}
601func TestCloudRedisImportInstance(t *testing.T) {
602	var name2 string = "name2-1052831874"
603	var displayName string = "displayName1615086568"
604	var locationId string = "locationId552319461"
605	var alternativeLocationId string = "alternativeLocationId-718920621"
606	var redisVersion string = "redisVersion-685310444"
607	var reservedIpRange string = "reservedIpRange-1082940580"
608	var host string = "host3208616"
609	var port int32 = 3446913
610	var currentLocationId string = "currentLocationId1312712735"
611	var statusMessage string = "statusMessage-239442758"
612	var memorySizeGb int32 = 34199707
613	var authorizedNetwork string = "authorizedNetwork-1733809270"
614	var persistenceIamIdentity string = "persistenceIamIdentity1061944584"
615	var expectedResponse = &redispb.Instance{
616		Name:                   name2,
617		DisplayName:            displayName,
618		LocationId:             locationId,
619		AlternativeLocationId:  alternativeLocationId,
620		RedisVersion:           redisVersion,
621		ReservedIpRange:        reservedIpRange,
622		Host:                   host,
623		Port:                   port,
624		CurrentLocationId:      currentLocationId,
625		StatusMessage:          statusMessage,
626		MemorySizeGb:           memorySizeGb,
627		AuthorizedNetwork:      authorizedNetwork,
628		PersistenceIamIdentity: persistenceIamIdentity,
629	}
630
631	mockCloudRedis.err = nil
632	mockCloudRedis.reqs = nil
633
634	any, err := ptypes.MarshalAny(expectedResponse)
635	if err != nil {
636		t.Fatal(err)
637	}
638	mockCloudRedis.resps = append(mockCloudRedis.resps[:0], &longrunningpb.Operation{
639		Name:   "longrunning-test",
640		Done:   true,
641		Result: &longrunningpb.Operation_Response{Response: any},
642	})
643
644	var name string = "name3373707"
645	var inputConfig *redispb.InputConfig = &redispb.InputConfig{}
646	var request = &redispb.ImportInstanceRequest{
647		Name:        name,
648		InputConfig: inputConfig,
649	}
650
651	c, err := NewCloudRedisClient(context.Background(), clientOpt)
652	if err != nil {
653		t.Fatal(err)
654	}
655
656	respLRO, err := c.ImportInstance(context.Background(), request)
657	if err != nil {
658		t.Fatal(err)
659	}
660	resp, err := respLRO.Wait(context.Background())
661
662	if err != nil {
663		t.Fatal(err)
664	}
665
666	if want, got := request, mockCloudRedis.reqs[0]; !proto.Equal(want, got) {
667		t.Errorf("wrong request %q, want %q", got, want)
668	}
669
670	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
671		t.Errorf("wrong response %q, want %q)", got, want)
672	}
673}
674
675func TestCloudRedisImportInstanceError(t *testing.T) {
676	errCode := codes.PermissionDenied
677	mockCloudRedis.err = nil
678	mockCloudRedis.resps = append(mockCloudRedis.resps[:0], &longrunningpb.Operation{
679		Name: "longrunning-test",
680		Done: true,
681		Result: &longrunningpb.Operation_Error{
682			Error: &status.Status{
683				Code:    int32(errCode),
684				Message: "test error",
685			},
686		},
687	})
688
689	var name string = "name3373707"
690	var inputConfig *redispb.InputConfig = &redispb.InputConfig{}
691	var request = &redispb.ImportInstanceRequest{
692		Name:        name,
693		InputConfig: inputConfig,
694	}
695
696	c, err := NewCloudRedisClient(context.Background(), clientOpt)
697	if err != nil {
698		t.Fatal(err)
699	}
700
701	respLRO, err := c.ImportInstance(context.Background(), request)
702	if err != nil {
703		t.Fatal(err)
704	}
705	resp, err := respLRO.Wait(context.Background())
706
707	if st, ok := gstatus.FromError(err); !ok {
708		t.Errorf("got error %v, expected grpc error", err)
709	} else if c := st.Code(); c != errCode {
710		t.Errorf("got error code %q, want %q", c, errCode)
711	}
712	_ = resp
713}
714func TestCloudRedisExportInstance(t *testing.T) {
715	var name2 string = "name2-1052831874"
716	var displayName string = "displayName1615086568"
717	var locationId string = "locationId552319461"
718	var alternativeLocationId string = "alternativeLocationId-718920621"
719	var redisVersion string = "redisVersion-685310444"
720	var reservedIpRange string = "reservedIpRange-1082940580"
721	var host string = "host3208616"
722	var port int32 = 3446913
723	var currentLocationId string = "currentLocationId1312712735"
724	var statusMessage string = "statusMessage-239442758"
725	var memorySizeGb int32 = 34199707
726	var authorizedNetwork string = "authorizedNetwork-1733809270"
727	var persistenceIamIdentity string = "persistenceIamIdentity1061944584"
728	var expectedResponse = &redispb.Instance{
729		Name:                   name2,
730		DisplayName:            displayName,
731		LocationId:             locationId,
732		AlternativeLocationId:  alternativeLocationId,
733		RedisVersion:           redisVersion,
734		ReservedIpRange:        reservedIpRange,
735		Host:                   host,
736		Port:                   port,
737		CurrentLocationId:      currentLocationId,
738		StatusMessage:          statusMessage,
739		MemorySizeGb:           memorySizeGb,
740		AuthorizedNetwork:      authorizedNetwork,
741		PersistenceIamIdentity: persistenceIamIdentity,
742	}
743
744	mockCloudRedis.err = nil
745	mockCloudRedis.reqs = nil
746
747	any, err := ptypes.MarshalAny(expectedResponse)
748	if err != nil {
749		t.Fatal(err)
750	}
751	mockCloudRedis.resps = append(mockCloudRedis.resps[:0], &longrunningpb.Operation{
752		Name:   "longrunning-test",
753		Done:   true,
754		Result: &longrunningpb.Operation_Response{Response: any},
755	})
756
757	var name string = "name3373707"
758	var outputConfig *redispb.OutputConfig = &redispb.OutputConfig{}
759	var request = &redispb.ExportInstanceRequest{
760		Name:         name,
761		OutputConfig: outputConfig,
762	}
763
764	c, err := NewCloudRedisClient(context.Background(), clientOpt)
765	if err != nil {
766		t.Fatal(err)
767	}
768
769	respLRO, err := c.ExportInstance(context.Background(), request)
770	if err != nil {
771		t.Fatal(err)
772	}
773	resp, err := respLRO.Wait(context.Background())
774
775	if err != nil {
776		t.Fatal(err)
777	}
778
779	if want, got := request, mockCloudRedis.reqs[0]; !proto.Equal(want, got) {
780		t.Errorf("wrong request %q, want %q", got, want)
781	}
782
783	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
784		t.Errorf("wrong response %q, want %q)", got, want)
785	}
786}
787
788func TestCloudRedisExportInstanceError(t *testing.T) {
789	errCode := codes.PermissionDenied
790	mockCloudRedis.err = nil
791	mockCloudRedis.resps = append(mockCloudRedis.resps[:0], &longrunningpb.Operation{
792		Name: "longrunning-test",
793		Done: true,
794		Result: &longrunningpb.Operation_Error{
795			Error: &status.Status{
796				Code:    int32(errCode),
797				Message: "test error",
798			},
799		},
800	})
801
802	var name string = "name3373707"
803	var outputConfig *redispb.OutputConfig = &redispb.OutputConfig{}
804	var request = &redispb.ExportInstanceRequest{
805		Name:         name,
806		OutputConfig: outputConfig,
807	}
808
809	c, err := NewCloudRedisClient(context.Background(), clientOpt)
810	if err != nil {
811		t.Fatal(err)
812	}
813
814	respLRO, err := c.ExportInstance(context.Background(), request)
815	if err != nil {
816		t.Fatal(err)
817	}
818	resp, err := respLRO.Wait(context.Background())
819
820	if st, ok := gstatus.FromError(err); !ok {
821		t.Errorf("got error %v, expected grpc error", err)
822	} else if c := st.Code(); c != errCode {
823		t.Errorf("got error code %q, want %q", c, errCode)
824	}
825	_ = resp
826}
827func TestCloudRedisFailoverInstance(t *testing.T) {
828	var name2 string = "name2-1052831874"
829	var displayName string = "displayName1615086568"
830	var locationId string = "locationId552319461"
831	var alternativeLocationId string = "alternativeLocationId-718920621"
832	var redisVersion string = "redisVersion-685310444"
833	var reservedIpRange string = "reservedIpRange-1082940580"
834	var host string = "host3208616"
835	var port int32 = 3446913
836	var currentLocationId string = "currentLocationId1312712735"
837	var statusMessage string = "statusMessage-239442758"
838	var memorySizeGb int32 = 34199707
839	var authorizedNetwork string = "authorizedNetwork-1733809270"
840	var persistenceIamIdentity string = "persistenceIamIdentity1061944584"
841	var expectedResponse = &redispb.Instance{
842		Name:                   name2,
843		DisplayName:            displayName,
844		LocationId:             locationId,
845		AlternativeLocationId:  alternativeLocationId,
846		RedisVersion:           redisVersion,
847		ReservedIpRange:        reservedIpRange,
848		Host:                   host,
849		Port:                   port,
850		CurrentLocationId:      currentLocationId,
851		StatusMessage:          statusMessage,
852		MemorySizeGb:           memorySizeGb,
853		AuthorizedNetwork:      authorizedNetwork,
854		PersistenceIamIdentity: persistenceIamIdentity,
855	}
856
857	mockCloudRedis.err = nil
858	mockCloudRedis.reqs = nil
859
860	any, err := ptypes.MarshalAny(expectedResponse)
861	if err != nil {
862		t.Fatal(err)
863	}
864	mockCloudRedis.resps = append(mockCloudRedis.resps[:0], &longrunningpb.Operation{
865		Name:   "longrunning-test",
866		Done:   true,
867		Result: &longrunningpb.Operation_Response{Response: any},
868	})
869
870	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/instances/%s", "[PROJECT]", "[LOCATION]", "[INSTANCE]")
871	var request = &redispb.FailoverInstanceRequest{
872		Name: formattedName,
873	}
874
875	c, err := NewCloudRedisClient(context.Background(), clientOpt)
876	if err != nil {
877		t.Fatal(err)
878	}
879
880	respLRO, err := c.FailoverInstance(context.Background(), request)
881	if err != nil {
882		t.Fatal(err)
883	}
884	resp, err := respLRO.Wait(context.Background())
885
886	if err != nil {
887		t.Fatal(err)
888	}
889
890	if want, got := request, mockCloudRedis.reqs[0]; !proto.Equal(want, got) {
891		t.Errorf("wrong request %q, want %q", got, want)
892	}
893
894	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
895		t.Errorf("wrong response %q, want %q)", got, want)
896	}
897}
898
899func TestCloudRedisFailoverInstanceError(t *testing.T) {
900	errCode := codes.PermissionDenied
901	mockCloudRedis.err = nil
902	mockCloudRedis.resps = append(mockCloudRedis.resps[:0], &longrunningpb.Operation{
903		Name: "longrunning-test",
904		Done: true,
905		Result: &longrunningpb.Operation_Error{
906			Error: &status.Status{
907				Code:    int32(errCode),
908				Message: "test error",
909			},
910		},
911	})
912
913	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/instances/%s", "[PROJECT]", "[LOCATION]", "[INSTANCE]")
914	var request = &redispb.FailoverInstanceRequest{
915		Name: formattedName,
916	}
917
918	c, err := NewCloudRedisClient(context.Background(), clientOpt)
919	if err != nil {
920		t.Fatal(err)
921	}
922
923	respLRO, err := c.FailoverInstance(context.Background(), request)
924	if err != nil {
925		t.Fatal(err)
926	}
927	resp, err := respLRO.Wait(context.Background())
928
929	if st, ok := gstatus.FromError(err); !ok {
930		t.Errorf("got error %v, expected grpc error", err)
931	} else if c := st.Code(); c != errCode {
932		t.Errorf("got error code %q, want %q", c, errCode)
933	}
934	_ = resp
935}
936func TestCloudRedisDeleteInstance(t *testing.T) {
937	var expectedResponse *emptypb.Empty = &emptypb.Empty{}
938
939	mockCloudRedis.err = nil
940	mockCloudRedis.reqs = nil
941
942	any, err := ptypes.MarshalAny(expectedResponse)
943	if err != nil {
944		t.Fatal(err)
945	}
946	mockCloudRedis.resps = append(mockCloudRedis.resps[:0], &longrunningpb.Operation{
947		Name:   "longrunning-test",
948		Done:   true,
949		Result: &longrunningpb.Operation_Response{Response: any},
950	})
951
952	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/instances/%s", "[PROJECT]", "[LOCATION]", "[INSTANCE]")
953	var request = &redispb.DeleteInstanceRequest{
954		Name: formattedName,
955	}
956
957	c, err := NewCloudRedisClient(context.Background(), clientOpt)
958	if err != nil {
959		t.Fatal(err)
960	}
961
962	respLRO, err := c.DeleteInstance(context.Background(), request)
963	if err != nil {
964		t.Fatal(err)
965	}
966	err = respLRO.Wait(context.Background())
967
968	if err != nil {
969		t.Fatal(err)
970	}
971
972	if want, got := request, mockCloudRedis.reqs[0]; !proto.Equal(want, got) {
973		t.Errorf("wrong request %q, want %q", got, want)
974	}
975
976}
977
978func TestCloudRedisDeleteInstanceError(t *testing.T) {
979	errCode := codes.PermissionDenied
980	mockCloudRedis.err = nil
981	mockCloudRedis.resps = append(mockCloudRedis.resps[:0], &longrunningpb.Operation{
982		Name: "longrunning-test",
983		Done: true,
984		Result: &longrunningpb.Operation_Error{
985			Error: &status.Status{
986				Code:    int32(errCode),
987				Message: "test error",
988			},
989		},
990	})
991
992	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/instances/%s", "[PROJECT]", "[LOCATION]", "[INSTANCE]")
993	var request = &redispb.DeleteInstanceRequest{
994		Name: formattedName,
995	}
996
997	c, err := NewCloudRedisClient(context.Background(), clientOpt)
998	if err != nil {
999		t.Fatal(err)
1000	}
1001
1002	respLRO, err := c.DeleteInstance(context.Background(), request)
1003	if err != nil {
1004		t.Fatal(err)
1005	}
1006	err = respLRO.Wait(context.Background())
1007
1008	if st, ok := gstatus.FromError(err); !ok {
1009		t.Errorf("got error %v, expected grpc error", err)
1010	} else if c := st.Code(); c != errCode {
1011		t.Errorf("got error code %q, want %q", c, errCode)
1012	}
1013}
1014