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