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/v1"
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) FailoverInstance(ctx context.Context, req *redispb.FailoverInstanceRequest) (*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) DeleteInstance(ctx context.Context, req *redispb.DeleteInstanceRequest) (*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
138// clientOpt is the option tests should use to connect to the test server.
139// It is initialized by TestMain.
140var clientOpt option.ClientOption
141
142var (
143	mockCloudRedis mockCloudRedisServer
144)
145
146func TestMain(m *testing.M) {
147	flag.Parse()
148
149	serv := grpc.NewServer()
150	redispb.RegisterCloudRedisServer(serv, &mockCloudRedis)
151
152	lis, err := net.Listen("tcp", "localhost:0")
153	if err != nil {
154		log.Fatal(err)
155	}
156	go serv.Serve(lis)
157
158	conn, err := grpc.Dial(lis.Addr().String(), grpc.WithInsecure())
159	if err != nil {
160		log.Fatal(err)
161	}
162	clientOpt = option.WithGRPCConn(conn)
163
164	os.Exit(m.Run())
165}
166
167func TestCloudRedisListInstances(t *testing.T) {
168	var nextPageToken string = ""
169	var instancesElement *redispb.Instance = &redispb.Instance{}
170	var instances = []*redispb.Instance{instancesElement}
171	var expectedResponse = &redispb.ListInstancesResponse{
172		NextPageToken: nextPageToken,
173		Instances:     instances,
174	}
175
176	mockCloudRedis.err = nil
177	mockCloudRedis.reqs = nil
178
179	mockCloudRedis.resps = append(mockCloudRedis.resps[:0], expectedResponse)
180
181	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]")
182	var request = &redispb.ListInstancesRequest{
183		Parent: formattedParent,
184	}
185
186	c, err := NewCloudRedisClient(context.Background(), clientOpt)
187	if err != nil {
188		t.Fatal(err)
189	}
190
191	resp, err := c.ListInstances(context.Background(), request).Next()
192
193	if err != nil {
194		t.Fatal(err)
195	}
196
197	if want, got := request, mockCloudRedis.reqs[0]; !proto.Equal(want, got) {
198		t.Errorf("wrong request %q, want %q", got, want)
199	}
200
201	want := (interface{})(expectedResponse.Instances[0])
202	got := (interface{})(resp)
203	var ok bool
204
205	switch want := (want).(type) {
206	case proto.Message:
207		ok = proto.Equal(want, got.(proto.Message))
208	default:
209		ok = want == got
210	}
211	if !ok {
212		t.Errorf("wrong response %q, want %q)", got, want)
213	}
214}
215
216func TestCloudRedisListInstancesError(t *testing.T) {
217	errCode := codes.PermissionDenied
218	mockCloudRedis.err = gstatus.Error(errCode, "test error")
219
220	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]")
221	var request = &redispb.ListInstancesRequest{
222		Parent: formattedParent,
223	}
224
225	c, err := NewCloudRedisClient(context.Background(), clientOpt)
226	if err != nil {
227		t.Fatal(err)
228	}
229
230	resp, err := c.ListInstances(context.Background(), request).Next()
231
232	if st, ok := gstatus.FromError(err); !ok {
233		t.Errorf("got error %v, expected grpc error", err)
234	} else if c := st.Code(); c != errCode {
235		t.Errorf("got error code %q, want %q", c, errCode)
236	}
237	_ = resp
238}
239func TestCloudRedisGetInstance(t *testing.T) {
240	var name2 string = "name2-1052831874"
241	var displayName string = "displayName1615086568"
242	var locationId string = "locationId552319461"
243	var alternativeLocationId string = "alternativeLocationId-718920621"
244	var redisVersion string = "redisVersion-685310444"
245	var reservedIpRange string = "reservedIpRange-1082940580"
246	var host string = "host3208616"
247	var port int32 = 3446913
248	var currentLocationId string = "currentLocationId1312712735"
249	var statusMessage string = "statusMessage-239442758"
250	var memorySizeGb int32 = 34199707
251	var authorizedNetwork string = "authorizedNetwork-1733809270"
252	var expectedResponse = &redispb.Instance{
253		Name:                  name2,
254		DisplayName:           displayName,
255		LocationId:            locationId,
256		AlternativeLocationId: alternativeLocationId,
257		RedisVersion:          redisVersion,
258		ReservedIpRange:       reservedIpRange,
259		Host:                  host,
260		Port:                  port,
261		CurrentLocationId:     currentLocationId,
262		StatusMessage:         statusMessage,
263		MemorySizeGb:          memorySizeGb,
264		AuthorizedNetwork:     authorizedNetwork,
265	}
266
267	mockCloudRedis.err = nil
268	mockCloudRedis.reqs = nil
269
270	mockCloudRedis.resps = append(mockCloudRedis.resps[:0], expectedResponse)
271
272	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/instances/%s", "[PROJECT]", "[LOCATION]", "[INSTANCE]")
273	var request = &redispb.GetInstanceRequest{
274		Name: formattedName,
275	}
276
277	c, err := NewCloudRedisClient(context.Background(), clientOpt)
278	if err != nil {
279		t.Fatal(err)
280	}
281
282	resp, err := c.GetInstance(context.Background(), request)
283
284	if err != nil {
285		t.Fatal(err)
286	}
287
288	if want, got := request, mockCloudRedis.reqs[0]; !proto.Equal(want, got) {
289		t.Errorf("wrong request %q, want %q", got, want)
290	}
291
292	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
293		t.Errorf("wrong response %q, want %q)", got, want)
294	}
295}
296
297func TestCloudRedisGetInstanceError(t *testing.T) {
298	errCode := codes.PermissionDenied
299	mockCloudRedis.err = gstatus.Error(errCode, "test error")
300
301	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/instances/%s", "[PROJECT]", "[LOCATION]", "[INSTANCE]")
302	var request = &redispb.GetInstanceRequest{
303		Name: formattedName,
304	}
305
306	c, err := NewCloudRedisClient(context.Background(), clientOpt)
307	if err != nil {
308		t.Fatal(err)
309	}
310
311	resp, err := c.GetInstance(context.Background(), request)
312
313	if st, ok := gstatus.FromError(err); !ok {
314		t.Errorf("got error %v, expected grpc error", err)
315	} else if c := st.Code(); c != errCode {
316		t.Errorf("got error code %q, want %q", c, errCode)
317	}
318	_ = resp
319}
320func TestCloudRedisCreateInstance(t *testing.T) {
321	var name string = "name3373707"
322	var displayName string = "displayName1615086568"
323	var locationId string = "locationId552319461"
324	var alternativeLocationId string = "alternativeLocationId-718920621"
325	var redisVersion string = "redisVersion-685310444"
326	var reservedIpRange string = "reservedIpRange-1082940580"
327	var host string = "host3208616"
328	var port int32 = 3446913
329	var currentLocationId string = "currentLocationId1312712735"
330	var statusMessage string = "statusMessage-239442758"
331	var memorySizeGb2 int32 = 1493816946
332	var authorizedNetwork string = "authorizedNetwork-1733809270"
333	var expectedResponse = &redispb.Instance{
334		Name:                  name,
335		DisplayName:           displayName,
336		LocationId:            locationId,
337		AlternativeLocationId: alternativeLocationId,
338		RedisVersion:          redisVersion,
339		ReservedIpRange:       reservedIpRange,
340		Host:                  host,
341		Port:                  port,
342		CurrentLocationId:     currentLocationId,
343		StatusMessage:         statusMessage,
344		MemorySizeGb:          memorySizeGb2,
345		AuthorizedNetwork:     authorizedNetwork,
346	}
347
348	mockCloudRedis.err = nil
349	mockCloudRedis.reqs = nil
350
351	any, err := ptypes.MarshalAny(expectedResponse)
352	if err != nil {
353		t.Fatal(err)
354	}
355	mockCloudRedis.resps = append(mockCloudRedis.resps[:0], &longrunningpb.Operation{
356		Name:   "longrunning-test",
357		Done:   true,
358		Result: &longrunningpb.Operation_Response{Response: any},
359	})
360
361	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]")
362	var instanceId string = "test_instance"
363	var tier redispb.Instance_Tier = redispb.Instance_BASIC
364	var memorySizeGb int32 = 1
365	var instance = &redispb.Instance{
366		Tier:         tier,
367		MemorySizeGb: memorySizeGb,
368	}
369	var request = &redispb.CreateInstanceRequest{
370		Parent:     formattedParent,
371		InstanceId: instanceId,
372		Instance:   instance,
373	}
374
375	c, err := NewCloudRedisClient(context.Background(), clientOpt)
376	if err != nil {
377		t.Fatal(err)
378	}
379
380	respLRO, err := c.CreateInstance(context.Background(), request)
381	if err != nil {
382		t.Fatal(err)
383	}
384	resp, err := respLRO.Wait(context.Background())
385
386	if err != nil {
387		t.Fatal(err)
388	}
389
390	if want, got := request, mockCloudRedis.reqs[0]; !proto.Equal(want, got) {
391		t.Errorf("wrong request %q, want %q", got, want)
392	}
393
394	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
395		t.Errorf("wrong response %q, want %q)", got, want)
396	}
397}
398
399func TestCloudRedisCreateInstanceError(t *testing.T) {
400	errCode := codes.PermissionDenied
401	mockCloudRedis.err = nil
402	mockCloudRedis.resps = append(mockCloudRedis.resps[:0], &longrunningpb.Operation{
403		Name: "longrunning-test",
404		Done: true,
405		Result: &longrunningpb.Operation_Error{
406			Error: &status.Status{
407				Code:    int32(errCode),
408				Message: "test error",
409			},
410		},
411	})
412
413	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]")
414	var instanceId string = "test_instance"
415	var tier redispb.Instance_Tier = redispb.Instance_BASIC
416	var memorySizeGb int32 = 1
417	var instance = &redispb.Instance{
418		Tier:         tier,
419		MemorySizeGb: memorySizeGb,
420	}
421	var request = &redispb.CreateInstanceRequest{
422		Parent:     formattedParent,
423		InstanceId: instanceId,
424		Instance:   instance,
425	}
426
427	c, err := NewCloudRedisClient(context.Background(), clientOpt)
428	if err != nil {
429		t.Fatal(err)
430	}
431
432	respLRO, err := c.CreateInstance(context.Background(), request)
433	if err != nil {
434		t.Fatal(err)
435	}
436	resp, err := respLRO.Wait(context.Background())
437
438	if st, ok := gstatus.FromError(err); !ok {
439		t.Errorf("got error %v, expected grpc error", err)
440	} else if c := st.Code(); c != errCode {
441		t.Errorf("got error code %q, want %q", c, errCode)
442	}
443	_ = resp
444}
445func TestCloudRedisUpdateInstance(t *testing.T) {
446	var name string = "name3373707"
447	var displayName2 string = "displayName21615000987"
448	var locationId string = "locationId552319461"
449	var alternativeLocationId string = "alternativeLocationId-718920621"
450	var redisVersion string = "redisVersion-685310444"
451	var reservedIpRange string = "reservedIpRange-1082940580"
452	var host string = "host3208616"
453	var port int32 = 3446913
454	var currentLocationId string = "currentLocationId1312712735"
455	var statusMessage string = "statusMessage-239442758"
456	var memorySizeGb2 int32 = 1493816946
457	var authorizedNetwork string = "authorizedNetwork-1733809270"
458	var expectedResponse = &redispb.Instance{
459		Name:                  name,
460		DisplayName:           displayName2,
461		LocationId:            locationId,
462		AlternativeLocationId: alternativeLocationId,
463		RedisVersion:          redisVersion,
464		ReservedIpRange:       reservedIpRange,
465		Host:                  host,
466		Port:                  port,
467		CurrentLocationId:     currentLocationId,
468		StatusMessage:         statusMessage,
469		MemorySizeGb:          memorySizeGb2,
470		AuthorizedNetwork:     authorizedNetwork,
471	}
472
473	mockCloudRedis.err = nil
474	mockCloudRedis.reqs = nil
475
476	any, err := ptypes.MarshalAny(expectedResponse)
477	if err != nil {
478		t.Fatal(err)
479	}
480	mockCloudRedis.resps = append(mockCloudRedis.resps[:0], &longrunningpb.Operation{
481		Name:   "longrunning-test",
482		Done:   true,
483		Result: &longrunningpb.Operation_Response{Response: any},
484	})
485
486	var pathsElement string = "display_name"
487	var pathsElement2 string = "memory_size_gb"
488	var paths = []string{pathsElement, pathsElement2}
489	var updateMask = &field_maskpb.FieldMask{
490		Paths: paths,
491	}
492	var displayName string = "UpdatedDisplayName"
493	var memorySizeGb int32 = 4
494	var instance = &redispb.Instance{
495		DisplayName:  displayName,
496		MemorySizeGb: memorySizeGb,
497	}
498	var request = &redispb.UpdateInstanceRequest{
499		UpdateMask: updateMask,
500		Instance:   instance,
501	}
502
503	c, err := NewCloudRedisClient(context.Background(), clientOpt)
504	if err != nil {
505		t.Fatal(err)
506	}
507
508	respLRO, err := c.UpdateInstance(context.Background(), request)
509	if err != nil {
510		t.Fatal(err)
511	}
512	resp, err := respLRO.Wait(context.Background())
513
514	if err != nil {
515		t.Fatal(err)
516	}
517
518	if want, got := request, mockCloudRedis.reqs[0]; !proto.Equal(want, got) {
519		t.Errorf("wrong request %q, want %q", got, want)
520	}
521
522	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
523		t.Errorf("wrong response %q, want %q)", got, want)
524	}
525}
526
527func TestCloudRedisUpdateInstanceError(t *testing.T) {
528	errCode := codes.PermissionDenied
529	mockCloudRedis.err = nil
530	mockCloudRedis.resps = append(mockCloudRedis.resps[:0], &longrunningpb.Operation{
531		Name: "longrunning-test",
532		Done: true,
533		Result: &longrunningpb.Operation_Error{
534			Error: &status.Status{
535				Code:    int32(errCode),
536				Message: "test error",
537			},
538		},
539	})
540
541	var pathsElement string = "display_name"
542	var pathsElement2 string = "memory_size_gb"
543	var paths = []string{pathsElement, pathsElement2}
544	var updateMask = &field_maskpb.FieldMask{
545		Paths: paths,
546	}
547	var displayName string = "UpdatedDisplayName"
548	var memorySizeGb int32 = 4
549	var instance = &redispb.Instance{
550		DisplayName:  displayName,
551		MemorySizeGb: memorySizeGb,
552	}
553	var request = &redispb.UpdateInstanceRequest{
554		UpdateMask: updateMask,
555		Instance:   instance,
556	}
557
558	c, err := NewCloudRedisClient(context.Background(), clientOpt)
559	if err != nil {
560		t.Fatal(err)
561	}
562
563	respLRO, err := c.UpdateInstance(context.Background(), request)
564	if err != nil {
565		t.Fatal(err)
566	}
567	resp, err := respLRO.Wait(context.Background())
568
569	if st, ok := gstatus.FromError(err); !ok {
570		t.Errorf("got error %v, expected grpc error", err)
571	} else if c := st.Code(); c != errCode {
572		t.Errorf("got error code %q, want %q", c, errCode)
573	}
574	_ = resp
575}
576func TestCloudRedisDeleteInstance(t *testing.T) {
577	var expectedResponse *emptypb.Empty = &emptypb.Empty{}
578
579	mockCloudRedis.err = nil
580	mockCloudRedis.reqs = nil
581
582	any, err := ptypes.MarshalAny(expectedResponse)
583	if err != nil {
584		t.Fatal(err)
585	}
586	mockCloudRedis.resps = append(mockCloudRedis.resps[:0], &longrunningpb.Operation{
587		Name:   "longrunning-test",
588		Done:   true,
589		Result: &longrunningpb.Operation_Response{Response: any},
590	})
591
592	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/instances/%s", "[PROJECT]", "[LOCATION]", "[INSTANCE]")
593	var request = &redispb.DeleteInstanceRequest{
594		Name: formattedName,
595	}
596
597	c, err := NewCloudRedisClient(context.Background(), clientOpt)
598	if err != nil {
599		t.Fatal(err)
600	}
601
602	respLRO, err := c.DeleteInstance(context.Background(), request)
603	if err != nil {
604		t.Fatal(err)
605	}
606	err = respLRO.Wait(context.Background())
607
608	if err != nil {
609		t.Fatal(err)
610	}
611
612	if want, got := request, mockCloudRedis.reqs[0]; !proto.Equal(want, got) {
613		t.Errorf("wrong request %q, want %q", got, want)
614	}
615
616}
617
618func TestCloudRedisDeleteInstanceError(t *testing.T) {
619	errCode := codes.PermissionDenied
620	mockCloudRedis.err = nil
621	mockCloudRedis.resps = append(mockCloudRedis.resps[:0], &longrunningpb.Operation{
622		Name: "longrunning-test",
623		Done: true,
624		Result: &longrunningpb.Operation_Error{
625			Error: &status.Status{
626				Code:    int32(errCode),
627				Message: "test error",
628			},
629		},
630	})
631
632	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/instances/%s", "[PROJECT]", "[LOCATION]", "[INSTANCE]")
633	var request = &redispb.DeleteInstanceRequest{
634		Name: formattedName,
635	}
636
637	c, err := NewCloudRedisClient(context.Background(), clientOpt)
638	if err != nil {
639		t.Fatal(err)
640	}
641
642	respLRO, err := c.DeleteInstance(context.Background(), request)
643	if err != nil {
644		t.Fatal(err)
645	}
646	err = respLRO.Wait(context.Background())
647
648	if st, ok := gstatus.FromError(err); !ok {
649		t.Errorf("got error %v, expected grpc error", err)
650	} else if c := st.Code(); c != errCode {
651		t.Errorf("got error code %q, want %q", c, errCode)
652	}
653}
654func TestCloudRedisFailoverInstance(t *testing.T) {
655	var name2 string = "name2-1052831874"
656	var displayName string = "displayName1615086568"
657	var locationId string = "locationId552319461"
658	var alternativeLocationId string = "alternativeLocationId-718920621"
659	var redisVersion string = "redisVersion-685310444"
660	var reservedIpRange string = "reservedIpRange-1082940580"
661	var host string = "host3208616"
662	var port int32 = 3446913
663	var currentLocationId string = "currentLocationId1312712735"
664	var statusMessage string = "statusMessage-239442758"
665	var memorySizeGb int32 = 34199707
666	var authorizedNetwork string = "authorizedNetwork-1733809270"
667	var expectedResponse = &redispb.Instance{
668		Name:                  name2,
669		DisplayName:           displayName,
670		LocationId:            locationId,
671		AlternativeLocationId: alternativeLocationId,
672		RedisVersion:          redisVersion,
673		ReservedIpRange:       reservedIpRange,
674		Host:                  host,
675		Port:                  port,
676		CurrentLocationId:     currentLocationId,
677		StatusMessage:         statusMessage,
678		MemorySizeGb:          memorySizeGb,
679		AuthorizedNetwork:     authorizedNetwork,
680	}
681
682	mockCloudRedis.err = nil
683	mockCloudRedis.reqs = nil
684
685	any, err := ptypes.MarshalAny(expectedResponse)
686	if err != nil {
687		t.Fatal(err)
688	}
689	mockCloudRedis.resps = append(mockCloudRedis.resps[:0], &longrunningpb.Operation{
690		Name:   "longrunning-test",
691		Done:   true,
692		Result: &longrunningpb.Operation_Response{Response: any},
693	})
694
695	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/instances/%s", "[PROJECT]", "[LOCATION]", "[INSTANCE]")
696	var dataProtectionMode redispb.FailoverInstanceRequest_DataProtectionMode = redispb.FailoverInstanceRequest_DATA_PROTECTION_MODE_UNSPECIFIED
697	var request = &redispb.FailoverInstanceRequest{
698		Name:               formattedName,
699		DataProtectionMode: dataProtectionMode,
700	}
701
702	c, err := NewCloudRedisClient(context.Background(), clientOpt)
703	if err != nil {
704		t.Fatal(err)
705	}
706
707	respLRO, err := c.FailoverInstance(context.Background(), request)
708	if err != nil {
709		t.Fatal(err)
710	}
711	resp, err := respLRO.Wait(context.Background())
712
713	if err != nil {
714		t.Fatal(err)
715	}
716
717	if want, got := request, mockCloudRedis.reqs[0]; !proto.Equal(want, got) {
718		t.Errorf("wrong request %q, want %q", got, want)
719	}
720
721	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
722		t.Errorf("wrong response %q, want %q)", got, want)
723	}
724}
725
726func TestCloudRedisFailoverInstanceError(t *testing.T) {
727	errCode := codes.PermissionDenied
728	mockCloudRedis.err = nil
729	mockCloudRedis.resps = append(mockCloudRedis.resps[:0], &longrunningpb.Operation{
730		Name: "longrunning-test",
731		Done: true,
732		Result: &longrunningpb.Operation_Error{
733			Error: &status.Status{
734				Code:    int32(errCode),
735				Message: "test error",
736			},
737		},
738	})
739
740	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/instances/%s", "[PROJECT]", "[LOCATION]", "[INSTANCE]")
741	var dataProtectionMode redispb.FailoverInstanceRequest_DataProtectionMode = redispb.FailoverInstanceRequest_DATA_PROTECTION_MODE_UNSPECIFIED
742	var request = &redispb.FailoverInstanceRequest{
743		Name:               formattedName,
744		DataProtectionMode: dataProtectionMode,
745	}
746
747	c, err := NewCloudRedisClient(context.Background(), clientOpt)
748	if err != nil {
749		t.Fatal(err)
750	}
751
752	respLRO, err := c.FailoverInstance(context.Background(), request)
753	if err != nil {
754		t.Fatal(err)
755	}
756	resp, err := respLRO.Wait(context.Background())
757
758	if st, ok := gstatus.FromError(err); !ok {
759		t.Errorf("got error %v, expected grpc error", err)
760	} else if c := st.Code(); c != errCode {
761		t.Errorf("got error code %q, want %q", c, errCode)
762	}
763	_ = resp
764}
765