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