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 kms
18
19import (
20	durationpb "github.com/golang/protobuf/ptypes/duration"
21	timestamppb "github.com/golang/protobuf/ptypes/timestamp"
22	kmspb "google.golang.org/genproto/googleapis/cloud/kms/v1"
23	iampb "google.golang.org/genproto/googleapis/iam/v1"
24	field_maskpb "google.golang.org/genproto/protobuf/field_mask"
25)
26
27import (
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	"golang.org/x/net/context"
40	"google.golang.org/api/option"
41	status "google.golang.org/genproto/googleapis/rpc/status"
42	"google.golang.org/grpc"
43	"google.golang.org/grpc/codes"
44	"google.golang.org/grpc/metadata"
45	gstatus "google.golang.org/grpc/status"
46)
47
48var _ = io.EOF
49var _ = ptypes.MarshalAny
50var _ status.Status
51
52type mockKeyManagementServer struct {
53	// Embed for forward compatibility.
54	// Tests will keep working if more methods are added
55	// in the future.
56	kmspb.KeyManagementServiceServer
57
58	reqs []proto.Message
59
60	// If set, all calls return this error.
61	err error
62
63	// responses to return if err == nil
64	resps []proto.Message
65}
66
67func (s *mockKeyManagementServer) ListKeyRings(ctx context.Context, req *kmspb.ListKeyRingsRequest) (*kmspb.ListKeyRingsResponse, error) {
68	md, _ := metadata.FromIncomingContext(ctx)
69	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
70		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
71	}
72	s.reqs = append(s.reqs, req)
73	if s.err != nil {
74		return nil, s.err
75	}
76	return s.resps[0].(*kmspb.ListKeyRingsResponse), nil
77}
78
79func (s *mockKeyManagementServer) ListCryptoKeys(ctx context.Context, req *kmspb.ListCryptoKeysRequest) (*kmspb.ListCryptoKeysResponse, error) {
80	md, _ := metadata.FromIncomingContext(ctx)
81	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
82		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
83	}
84	s.reqs = append(s.reqs, req)
85	if s.err != nil {
86		return nil, s.err
87	}
88	return s.resps[0].(*kmspb.ListCryptoKeysResponse), nil
89}
90
91func (s *mockKeyManagementServer) ListCryptoKeyVersions(ctx context.Context, req *kmspb.ListCryptoKeyVersionsRequest) (*kmspb.ListCryptoKeyVersionsResponse, error) {
92	md, _ := metadata.FromIncomingContext(ctx)
93	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
94		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
95	}
96	s.reqs = append(s.reqs, req)
97	if s.err != nil {
98		return nil, s.err
99	}
100	return s.resps[0].(*kmspb.ListCryptoKeyVersionsResponse), nil
101}
102
103func (s *mockKeyManagementServer) GetKeyRing(ctx context.Context, req *kmspb.GetKeyRingRequest) (*kmspb.KeyRing, error) {
104	md, _ := metadata.FromIncomingContext(ctx)
105	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
106		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
107	}
108	s.reqs = append(s.reqs, req)
109	if s.err != nil {
110		return nil, s.err
111	}
112	return s.resps[0].(*kmspb.KeyRing), nil
113}
114
115func (s *mockKeyManagementServer) GetCryptoKey(ctx context.Context, req *kmspb.GetCryptoKeyRequest) (*kmspb.CryptoKey, error) {
116	md, _ := metadata.FromIncomingContext(ctx)
117	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
118		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
119	}
120	s.reqs = append(s.reqs, req)
121	if s.err != nil {
122		return nil, s.err
123	}
124	return s.resps[0].(*kmspb.CryptoKey), nil
125}
126
127func (s *mockKeyManagementServer) GetCryptoKeyVersion(ctx context.Context, req *kmspb.GetCryptoKeyVersionRequest) (*kmspb.CryptoKeyVersion, error) {
128	md, _ := metadata.FromIncomingContext(ctx)
129	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
130		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
131	}
132	s.reqs = append(s.reqs, req)
133	if s.err != nil {
134		return nil, s.err
135	}
136	return s.resps[0].(*kmspb.CryptoKeyVersion), nil
137}
138
139func (s *mockKeyManagementServer) CreateKeyRing(ctx context.Context, req *kmspb.CreateKeyRingRequest) (*kmspb.KeyRing, error) {
140	md, _ := metadata.FromIncomingContext(ctx)
141	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
142		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
143	}
144	s.reqs = append(s.reqs, req)
145	if s.err != nil {
146		return nil, s.err
147	}
148	return s.resps[0].(*kmspb.KeyRing), nil
149}
150
151func (s *mockKeyManagementServer) CreateCryptoKey(ctx context.Context, req *kmspb.CreateCryptoKeyRequest) (*kmspb.CryptoKey, error) {
152	md, _ := metadata.FromIncomingContext(ctx)
153	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
154		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
155	}
156	s.reqs = append(s.reqs, req)
157	if s.err != nil {
158		return nil, s.err
159	}
160	return s.resps[0].(*kmspb.CryptoKey), nil
161}
162
163func (s *mockKeyManagementServer) CreateCryptoKeyVersion(ctx context.Context, req *kmspb.CreateCryptoKeyVersionRequest) (*kmspb.CryptoKeyVersion, error) {
164	md, _ := metadata.FromIncomingContext(ctx)
165	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
166		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
167	}
168	s.reqs = append(s.reqs, req)
169	if s.err != nil {
170		return nil, s.err
171	}
172	return s.resps[0].(*kmspb.CryptoKeyVersion), nil
173}
174
175func (s *mockKeyManagementServer) UpdateCryptoKey(ctx context.Context, req *kmspb.UpdateCryptoKeyRequest) (*kmspb.CryptoKey, error) {
176	md, _ := metadata.FromIncomingContext(ctx)
177	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
178		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
179	}
180	s.reqs = append(s.reqs, req)
181	if s.err != nil {
182		return nil, s.err
183	}
184	return s.resps[0].(*kmspb.CryptoKey), nil
185}
186
187func (s *mockKeyManagementServer) UpdateCryptoKeyVersion(ctx context.Context, req *kmspb.UpdateCryptoKeyVersionRequest) (*kmspb.CryptoKeyVersion, error) {
188	md, _ := metadata.FromIncomingContext(ctx)
189	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
190		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
191	}
192	s.reqs = append(s.reqs, req)
193	if s.err != nil {
194		return nil, s.err
195	}
196	return s.resps[0].(*kmspb.CryptoKeyVersion), nil
197}
198
199func (s *mockKeyManagementServer) Encrypt(ctx context.Context, req *kmspb.EncryptRequest) (*kmspb.EncryptResponse, error) {
200	md, _ := metadata.FromIncomingContext(ctx)
201	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
202		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
203	}
204	s.reqs = append(s.reqs, req)
205	if s.err != nil {
206		return nil, s.err
207	}
208	return s.resps[0].(*kmspb.EncryptResponse), nil
209}
210
211func (s *mockKeyManagementServer) Decrypt(ctx context.Context, req *kmspb.DecryptRequest) (*kmspb.DecryptResponse, error) {
212	md, _ := metadata.FromIncomingContext(ctx)
213	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
214		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
215	}
216	s.reqs = append(s.reqs, req)
217	if s.err != nil {
218		return nil, s.err
219	}
220	return s.resps[0].(*kmspb.DecryptResponse), nil
221}
222
223func (s *mockKeyManagementServer) UpdateCryptoKeyPrimaryVersion(ctx context.Context, req *kmspb.UpdateCryptoKeyPrimaryVersionRequest) (*kmspb.CryptoKey, error) {
224	md, _ := metadata.FromIncomingContext(ctx)
225	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
226		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
227	}
228	s.reqs = append(s.reqs, req)
229	if s.err != nil {
230		return nil, s.err
231	}
232	return s.resps[0].(*kmspb.CryptoKey), nil
233}
234
235func (s *mockKeyManagementServer) DestroyCryptoKeyVersion(ctx context.Context, req *kmspb.DestroyCryptoKeyVersionRequest) (*kmspb.CryptoKeyVersion, error) {
236	md, _ := metadata.FromIncomingContext(ctx)
237	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
238		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
239	}
240	s.reqs = append(s.reqs, req)
241	if s.err != nil {
242		return nil, s.err
243	}
244	return s.resps[0].(*kmspb.CryptoKeyVersion), nil
245}
246
247func (s *mockKeyManagementServer) RestoreCryptoKeyVersion(ctx context.Context, req *kmspb.RestoreCryptoKeyVersionRequest) (*kmspb.CryptoKeyVersion, error) {
248	md, _ := metadata.FromIncomingContext(ctx)
249	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
250		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
251	}
252	s.reqs = append(s.reqs, req)
253	if s.err != nil {
254		return nil, s.err
255	}
256	return s.resps[0].(*kmspb.CryptoKeyVersion), nil
257}
258
259type mockIamPolicyServer struct {
260	// Embed for forward compatibility.
261	// Tests will keep working if more methods are added
262	// in the future.
263	iampb.IAMPolicyServer
264
265	reqs []proto.Message
266
267	// If set, all calls return this error.
268	err error
269
270	// responses to return if err == nil
271	resps []proto.Message
272}
273
274func (s *mockIamPolicyServer) SetIamPolicy(ctx context.Context, req *iampb.SetIamPolicyRequest) (*iampb.Policy, error) {
275	md, _ := metadata.FromIncomingContext(ctx)
276	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
277		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
278	}
279	s.reqs = append(s.reqs, req)
280	if s.err != nil {
281		return nil, s.err
282	}
283	return s.resps[0].(*iampb.Policy), nil
284}
285
286func (s *mockIamPolicyServer) GetIamPolicy(ctx context.Context, req *iampb.GetIamPolicyRequest) (*iampb.Policy, error) {
287	md, _ := metadata.FromIncomingContext(ctx)
288	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
289		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
290	}
291	s.reqs = append(s.reqs, req)
292	if s.err != nil {
293		return nil, s.err
294	}
295	return s.resps[0].(*iampb.Policy), nil
296}
297
298func (s *mockIamPolicyServer) TestIamPermissions(ctx context.Context, req *iampb.TestIamPermissionsRequest) (*iampb.TestIamPermissionsResponse, error) {
299	md, _ := metadata.FromIncomingContext(ctx)
300	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
301		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
302	}
303	s.reqs = append(s.reqs, req)
304	if s.err != nil {
305		return nil, s.err
306	}
307	return s.resps[0].(*iampb.TestIamPermissionsResponse), nil
308}
309
310// clientOpt is the option tests should use to connect to the test server.
311// It is initialized by TestMain.
312var clientOpt option.ClientOption
313
314var (
315	mockKeyManagement mockKeyManagementServer
316	mockIamPolicy     mockIamPolicyServer
317)
318
319func TestMain(m *testing.M) {
320	flag.Parse()
321
322	serv := grpc.NewServer()
323	kmspb.RegisterKeyManagementServiceServer(serv, &mockKeyManagement)
324	iampb.RegisterIAMPolicyServer(serv, &mockIamPolicy)
325
326	lis, err := net.Listen("tcp", "localhost:0")
327	if err != nil {
328		log.Fatal(err)
329	}
330	go serv.Serve(lis)
331
332	conn, err := grpc.Dial(lis.Addr().String(), grpc.WithInsecure())
333	if err != nil {
334		log.Fatal(err)
335	}
336	clientOpt = option.WithGRPCConn(conn)
337
338	os.Exit(m.Run())
339}
340
341func TestKeyManagementServiceListKeyRings(t *testing.T) {
342	var nextPageToken string = ""
343	var totalSize int32 = 705419236
344	var keyRingsElement *kmspb.KeyRing = &kmspb.KeyRing{}
345	var keyRings = []*kmspb.KeyRing{keyRingsElement}
346	var expectedResponse = &kmspb.ListKeyRingsResponse{
347		NextPageToken: nextPageToken,
348		TotalSize:     totalSize,
349		KeyRings:      keyRings,
350	}
351
352	mockKeyManagement.err = nil
353	mockKeyManagement.reqs = nil
354
355	mockKeyManagement.resps = append(mockKeyManagement.resps[:0], expectedResponse)
356
357	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]")
358	var request = &kmspb.ListKeyRingsRequest{
359		Parent: formattedParent,
360	}
361
362	c, err := NewKeyManagementClient(context.Background(), clientOpt)
363	if err != nil {
364		t.Fatal(err)
365	}
366
367	resp, err := c.ListKeyRings(context.Background(), request).Next()
368
369	if err != nil {
370		t.Fatal(err)
371	}
372
373	if want, got := request, mockKeyManagement.reqs[0]; !proto.Equal(want, got) {
374		t.Errorf("wrong request %q, want %q", got, want)
375	}
376
377	want := (interface{})(expectedResponse.KeyRings[0])
378	got := (interface{})(resp)
379	var ok bool
380
381	switch want := (want).(type) {
382	case proto.Message:
383		ok = proto.Equal(want, got.(proto.Message))
384	default:
385		ok = want == got
386	}
387	if !ok {
388		t.Errorf("wrong response %q, want %q)", got, want)
389	}
390}
391
392func TestKeyManagementServiceListKeyRingsError(t *testing.T) {
393	errCode := codes.PermissionDenied
394	mockKeyManagement.err = gstatus.Error(errCode, "test error")
395
396	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]")
397	var request = &kmspb.ListKeyRingsRequest{
398		Parent: formattedParent,
399	}
400
401	c, err := NewKeyManagementClient(context.Background(), clientOpt)
402	if err != nil {
403		t.Fatal(err)
404	}
405
406	resp, err := c.ListKeyRings(context.Background(), request).Next()
407
408	if st, ok := gstatus.FromError(err); !ok {
409		t.Errorf("got error %v, expected grpc error", err)
410	} else if c := st.Code(); c != errCode {
411		t.Errorf("got error code %q, want %q", c, errCode)
412	}
413	_ = resp
414}
415func TestKeyManagementServiceListCryptoKeys(t *testing.T) {
416	var nextPageToken string = ""
417	var totalSize int32 = 705419236
418	var cryptoKeysElement *kmspb.CryptoKey = &kmspb.CryptoKey{}
419	var cryptoKeys = []*kmspb.CryptoKey{cryptoKeysElement}
420	var expectedResponse = &kmspb.ListCryptoKeysResponse{
421		NextPageToken: nextPageToken,
422		TotalSize:     totalSize,
423		CryptoKeys:    cryptoKeys,
424	}
425
426	mockKeyManagement.err = nil
427	mockKeyManagement.reqs = nil
428
429	mockKeyManagement.resps = append(mockKeyManagement.resps[:0], expectedResponse)
430
431	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]")
432	var request = &kmspb.ListCryptoKeysRequest{
433		Parent: formattedParent,
434	}
435
436	c, err := NewKeyManagementClient(context.Background(), clientOpt)
437	if err != nil {
438		t.Fatal(err)
439	}
440
441	resp, err := c.ListCryptoKeys(context.Background(), request).Next()
442
443	if err != nil {
444		t.Fatal(err)
445	}
446
447	if want, got := request, mockKeyManagement.reqs[0]; !proto.Equal(want, got) {
448		t.Errorf("wrong request %q, want %q", got, want)
449	}
450
451	want := (interface{})(expectedResponse.CryptoKeys[0])
452	got := (interface{})(resp)
453	var ok bool
454
455	switch want := (want).(type) {
456	case proto.Message:
457		ok = proto.Equal(want, got.(proto.Message))
458	default:
459		ok = want == got
460	}
461	if !ok {
462		t.Errorf("wrong response %q, want %q)", got, want)
463	}
464}
465
466func TestKeyManagementServiceListCryptoKeysError(t *testing.T) {
467	errCode := codes.PermissionDenied
468	mockKeyManagement.err = gstatus.Error(errCode, "test error")
469
470	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]")
471	var request = &kmspb.ListCryptoKeysRequest{
472		Parent: formattedParent,
473	}
474
475	c, err := NewKeyManagementClient(context.Background(), clientOpt)
476	if err != nil {
477		t.Fatal(err)
478	}
479
480	resp, err := c.ListCryptoKeys(context.Background(), request).Next()
481
482	if st, ok := gstatus.FromError(err); !ok {
483		t.Errorf("got error %v, expected grpc error", err)
484	} else if c := st.Code(); c != errCode {
485		t.Errorf("got error code %q, want %q", c, errCode)
486	}
487	_ = resp
488}
489func TestKeyManagementServiceListCryptoKeyVersions(t *testing.T) {
490	var nextPageToken string = ""
491	var totalSize int32 = 705419236
492	var cryptoKeyVersionsElement *kmspb.CryptoKeyVersion = &kmspb.CryptoKeyVersion{}
493	var cryptoKeyVersions = []*kmspb.CryptoKeyVersion{cryptoKeyVersionsElement}
494	var expectedResponse = &kmspb.ListCryptoKeyVersionsResponse{
495		NextPageToken:     nextPageToken,
496		TotalSize:         totalSize,
497		CryptoKeyVersions: cryptoKeyVersions,
498	}
499
500	mockKeyManagement.err = nil
501	mockKeyManagement.reqs = nil
502
503	mockKeyManagement.resps = append(mockKeyManagement.resps[:0], expectedResponse)
504
505	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
506	var request = &kmspb.ListCryptoKeyVersionsRequest{
507		Parent: formattedParent,
508	}
509
510	c, err := NewKeyManagementClient(context.Background(), clientOpt)
511	if err != nil {
512		t.Fatal(err)
513	}
514
515	resp, err := c.ListCryptoKeyVersions(context.Background(), request).Next()
516
517	if err != nil {
518		t.Fatal(err)
519	}
520
521	if want, got := request, mockKeyManagement.reqs[0]; !proto.Equal(want, got) {
522		t.Errorf("wrong request %q, want %q", got, want)
523	}
524
525	want := (interface{})(expectedResponse.CryptoKeyVersions[0])
526	got := (interface{})(resp)
527	var ok bool
528
529	switch want := (want).(type) {
530	case proto.Message:
531		ok = proto.Equal(want, got.(proto.Message))
532	default:
533		ok = want == got
534	}
535	if !ok {
536		t.Errorf("wrong response %q, want %q)", got, want)
537	}
538}
539
540func TestKeyManagementServiceListCryptoKeyVersionsError(t *testing.T) {
541	errCode := codes.PermissionDenied
542	mockKeyManagement.err = gstatus.Error(errCode, "test error")
543
544	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
545	var request = &kmspb.ListCryptoKeyVersionsRequest{
546		Parent: formattedParent,
547	}
548
549	c, err := NewKeyManagementClient(context.Background(), clientOpt)
550	if err != nil {
551		t.Fatal(err)
552	}
553
554	resp, err := c.ListCryptoKeyVersions(context.Background(), request).Next()
555
556	if st, ok := gstatus.FromError(err); !ok {
557		t.Errorf("got error %v, expected grpc error", err)
558	} else if c := st.Code(); c != errCode {
559		t.Errorf("got error code %q, want %q", c, errCode)
560	}
561	_ = resp
562}
563func TestKeyManagementServiceGetKeyRing(t *testing.T) {
564	var name2 string = "name2-1052831874"
565	var expectedResponse = &kmspb.KeyRing{
566		Name: name2,
567	}
568
569	mockKeyManagement.err = nil
570	mockKeyManagement.reqs = nil
571
572	mockKeyManagement.resps = append(mockKeyManagement.resps[:0], expectedResponse)
573
574	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]")
575	var request = &kmspb.GetKeyRingRequest{
576		Name: formattedName,
577	}
578
579	c, err := NewKeyManagementClient(context.Background(), clientOpt)
580	if err != nil {
581		t.Fatal(err)
582	}
583
584	resp, err := c.GetKeyRing(context.Background(), request)
585
586	if err != nil {
587		t.Fatal(err)
588	}
589
590	if want, got := request, mockKeyManagement.reqs[0]; !proto.Equal(want, got) {
591		t.Errorf("wrong request %q, want %q", got, want)
592	}
593
594	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
595		t.Errorf("wrong response %q, want %q)", got, want)
596	}
597}
598
599func TestKeyManagementServiceGetKeyRingError(t *testing.T) {
600	errCode := codes.PermissionDenied
601	mockKeyManagement.err = gstatus.Error(errCode, "test error")
602
603	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]")
604	var request = &kmspb.GetKeyRingRequest{
605		Name: formattedName,
606	}
607
608	c, err := NewKeyManagementClient(context.Background(), clientOpt)
609	if err != nil {
610		t.Fatal(err)
611	}
612
613	resp, err := c.GetKeyRing(context.Background(), request)
614
615	if st, ok := gstatus.FromError(err); !ok {
616		t.Errorf("got error %v, expected grpc error", err)
617	} else if c := st.Code(); c != errCode {
618		t.Errorf("got error code %q, want %q", c, errCode)
619	}
620	_ = resp
621}
622func TestKeyManagementServiceGetCryptoKey(t *testing.T) {
623	var name2 string = "name2-1052831874"
624	var expectedResponse = &kmspb.CryptoKey{
625		Name: name2,
626	}
627
628	mockKeyManagement.err = nil
629	mockKeyManagement.reqs = nil
630
631	mockKeyManagement.resps = append(mockKeyManagement.resps[:0], expectedResponse)
632
633	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
634	var request = &kmspb.GetCryptoKeyRequest{
635		Name: formattedName,
636	}
637
638	c, err := NewKeyManagementClient(context.Background(), clientOpt)
639	if err != nil {
640		t.Fatal(err)
641	}
642
643	resp, err := c.GetCryptoKey(context.Background(), request)
644
645	if err != nil {
646		t.Fatal(err)
647	}
648
649	if want, got := request, mockKeyManagement.reqs[0]; !proto.Equal(want, got) {
650		t.Errorf("wrong request %q, want %q", got, want)
651	}
652
653	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
654		t.Errorf("wrong response %q, want %q)", got, want)
655	}
656}
657
658func TestKeyManagementServiceGetCryptoKeyError(t *testing.T) {
659	errCode := codes.PermissionDenied
660	mockKeyManagement.err = gstatus.Error(errCode, "test error")
661
662	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
663	var request = &kmspb.GetCryptoKeyRequest{
664		Name: formattedName,
665	}
666
667	c, err := NewKeyManagementClient(context.Background(), clientOpt)
668	if err != nil {
669		t.Fatal(err)
670	}
671
672	resp, err := c.GetCryptoKey(context.Background(), request)
673
674	if st, ok := gstatus.FromError(err); !ok {
675		t.Errorf("got error %v, expected grpc error", err)
676	} else if c := st.Code(); c != errCode {
677		t.Errorf("got error code %q, want %q", c, errCode)
678	}
679	_ = resp
680}
681func TestKeyManagementServiceGetCryptoKeyVersion(t *testing.T) {
682	var name2 string = "name2-1052831874"
683	var expectedResponse = &kmspb.CryptoKeyVersion{
684		Name: name2,
685	}
686
687	mockKeyManagement.err = nil
688	mockKeyManagement.reqs = nil
689
690	mockKeyManagement.resps = append(mockKeyManagement.resps[:0], expectedResponse)
691
692	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s/cryptoKeyVersions/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]", "[CRYPTO_KEY_VERSION]")
693	var request = &kmspb.GetCryptoKeyVersionRequest{
694		Name: formattedName,
695	}
696
697	c, err := NewKeyManagementClient(context.Background(), clientOpt)
698	if err != nil {
699		t.Fatal(err)
700	}
701
702	resp, err := c.GetCryptoKeyVersion(context.Background(), request)
703
704	if err != nil {
705		t.Fatal(err)
706	}
707
708	if want, got := request, mockKeyManagement.reqs[0]; !proto.Equal(want, got) {
709		t.Errorf("wrong request %q, want %q", got, want)
710	}
711
712	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
713		t.Errorf("wrong response %q, want %q)", got, want)
714	}
715}
716
717func TestKeyManagementServiceGetCryptoKeyVersionError(t *testing.T) {
718	errCode := codes.PermissionDenied
719	mockKeyManagement.err = gstatus.Error(errCode, "test error")
720
721	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s/cryptoKeyVersions/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]", "[CRYPTO_KEY_VERSION]")
722	var request = &kmspb.GetCryptoKeyVersionRequest{
723		Name: formattedName,
724	}
725
726	c, err := NewKeyManagementClient(context.Background(), clientOpt)
727	if err != nil {
728		t.Fatal(err)
729	}
730
731	resp, err := c.GetCryptoKeyVersion(context.Background(), request)
732
733	if st, ok := gstatus.FromError(err); !ok {
734		t.Errorf("got error %v, expected grpc error", err)
735	} else if c := st.Code(); c != errCode {
736		t.Errorf("got error code %q, want %q", c, errCode)
737	}
738	_ = resp
739}
740func TestKeyManagementServiceCreateKeyRing(t *testing.T) {
741	var name string = "name3373707"
742	var expectedResponse = &kmspb.KeyRing{
743		Name: name,
744	}
745
746	mockKeyManagement.err = nil
747	mockKeyManagement.reqs = nil
748
749	mockKeyManagement.resps = append(mockKeyManagement.resps[:0], expectedResponse)
750
751	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]")
752	var keyRingId string = "keyRingId-2056646742"
753	var keyRing *kmspb.KeyRing = &kmspb.KeyRing{}
754	var request = &kmspb.CreateKeyRingRequest{
755		Parent:    formattedParent,
756		KeyRingId: keyRingId,
757		KeyRing:   keyRing,
758	}
759
760	c, err := NewKeyManagementClient(context.Background(), clientOpt)
761	if err != nil {
762		t.Fatal(err)
763	}
764
765	resp, err := c.CreateKeyRing(context.Background(), request)
766
767	if err != nil {
768		t.Fatal(err)
769	}
770
771	if want, got := request, mockKeyManagement.reqs[0]; !proto.Equal(want, got) {
772		t.Errorf("wrong request %q, want %q", got, want)
773	}
774
775	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
776		t.Errorf("wrong response %q, want %q)", got, want)
777	}
778}
779
780func TestKeyManagementServiceCreateKeyRingError(t *testing.T) {
781	errCode := codes.PermissionDenied
782	mockKeyManagement.err = gstatus.Error(errCode, "test error")
783
784	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]")
785	var keyRingId string = "keyRingId-2056646742"
786	var keyRing *kmspb.KeyRing = &kmspb.KeyRing{}
787	var request = &kmspb.CreateKeyRingRequest{
788		Parent:    formattedParent,
789		KeyRingId: keyRingId,
790		KeyRing:   keyRing,
791	}
792
793	c, err := NewKeyManagementClient(context.Background(), clientOpt)
794	if err != nil {
795		t.Fatal(err)
796	}
797
798	resp, err := c.CreateKeyRing(context.Background(), request)
799
800	if st, ok := gstatus.FromError(err); !ok {
801		t.Errorf("got error %v, expected grpc error", err)
802	} else if c := st.Code(); c != errCode {
803		t.Errorf("got error code %q, want %q", c, errCode)
804	}
805	_ = resp
806}
807func TestKeyManagementServiceCreateCryptoKey(t *testing.T) {
808	var name string = "name3373707"
809	var expectedResponse = &kmspb.CryptoKey{
810		Name: name,
811	}
812
813	mockKeyManagement.err = nil
814	mockKeyManagement.reqs = nil
815
816	mockKeyManagement.resps = append(mockKeyManagement.resps[:0], expectedResponse)
817
818	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]")
819	var cryptoKeyId string = "my-app-key"
820	var purpose kmspb.CryptoKey_CryptoKeyPurpose = kmspb.CryptoKey_ENCRYPT_DECRYPT
821	var seconds int64 = 2147483647
822	var nextRotationTime = &timestamppb.Timestamp{
823		Seconds: seconds,
824	}
825	var seconds2 int64 = 604800
826	var rotationPeriod = &durationpb.Duration{
827		Seconds: seconds2,
828	}
829	var cryptoKey = &kmspb.CryptoKey{
830		Purpose:          purpose,
831		NextRotationTime: nextRotationTime,
832		RotationSchedule: &kmspb.CryptoKey_RotationPeriod{
833			RotationPeriod: rotationPeriod,
834		},
835	}
836	var request = &kmspb.CreateCryptoKeyRequest{
837		Parent:      formattedParent,
838		CryptoKeyId: cryptoKeyId,
839		CryptoKey:   cryptoKey,
840	}
841
842	c, err := NewKeyManagementClient(context.Background(), clientOpt)
843	if err != nil {
844		t.Fatal(err)
845	}
846
847	resp, err := c.CreateCryptoKey(context.Background(), request)
848
849	if err != nil {
850		t.Fatal(err)
851	}
852
853	if want, got := request, mockKeyManagement.reqs[0]; !proto.Equal(want, got) {
854		t.Errorf("wrong request %q, want %q", got, want)
855	}
856
857	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
858		t.Errorf("wrong response %q, want %q)", got, want)
859	}
860}
861
862func TestKeyManagementServiceCreateCryptoKeyError(t *testing.T) {
863	errCode := codes.PermissionDenied
864	mockKeyManagement.err = gstatus.Error(errCode, "test error")
865
866	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]")
867	var cryptoKeyId string = "my-app-key"
868	var purpose kmspb.CryptoKey_CryptoKeyPurpose = kmspb.CryptoKey_ENCRYPT_DECRYPT
869	var seconds int64 = 2147483647
870	var nextRotationTime = &timestamppb.Timestamp{
871		Seconds: seconds,
872	}
873	var seconds2 int64 = 604800
874	var rotationPeriod = &durationpb.Duration{
875		Seconds: seconds2,
876	}
877	var cryptoKey = &kmspb.CryptoKey{
878		Purpose:          purpose,
879		NextRotationTime: nextRotationTime,
880		RotationSchedule: &kmspb.CryptoKey_RotationPeriod{
881			RotationPeriod: rotationPeriod,
882		},
883	}
884	var request = &kmspb.CreateCryptoKeyRequest{
885		Parent:      formattedParent,
886		CryptoKeyId: cryptoKeyId,
887		CryptoKey:   cryptoKey,
888	}
889
890	c, err := NewKeyManagementClient(context.Background(), clientOpt)
891	if err != nil {
892		t.Fatal(err)
893	}
894
895	resp, err := c.CreateCryptoKey(context.Background(), request)
896
897	if st, ok := gstatus.FromError(err); !ok {
898		t.Errorf("got error %v, expected grpc error", err)
899	} else if c := st.Code(); c != errCode {
900		t.Errorf("got error code %q, want %q", c, errCode)
901	}
902	_ = resp
903}
904func TestKeyManagementServiceCreateCryptoKeyVersion(t *testing.T) {
905	var name string = "name3373707"
906	var expectedResponse = &kmspb.CryptoKeyVersion{
907		Name: name,
908	}
909
910	mockKeyManagement.err = nil
911	mockKeyManagement.reqs = nil
912
913	mockKeyManagement.resps = append(mockKeyManagement.resps[:0], expectedResponse)
914
915	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
916	var cryptoKeyVersion *kmspb.CryptoKeyVersion = &kmspb.CryptoKeyVersion{}
917	var request = &kmspb.CreateCryptoKeyVersionRequest{
918		Parent:           formattedParent,
919		CryptoKeyVersion: cryptoKeyVersion,
920	}
921
922	c, err := NewKeyManagementClient(context.Background(), clientOpt)
923	if err != nil {
924		t.Fatal(err)
925	}
926
927	resp, err := c.CreateCryptoKeyVersion(context.Background(), request)
928
929	if err != nil {
930		t.Fatal(err)
931	}
932
933	if want, got := request, mockKeyManagement.reqs[0]; !proto.Equal(want, got) {
934		t.Errorf("wrong request %q, want %q", got, want)
935	}
936
937	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
938		t.Errorf("wrong response %q, want %q)", got, want)
939	}
940}
941
942func TestKeyManagementServiceCreateCryptoKeyVersionError(t *testing.T) {
943	errCode := codes.PermissionDenied
944	mockKeyManagement.err = gstatus.Error(errCode, "test error")
945
946	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
947	var cryptoKeyVersion *kmspb.CryptoKeyVersion = &kmspb.CryptoKeyVersion{}
948	var request = &kmspb.CreateCryptoKeyVersionRequest{
949		Parent:           formattedParent,
950		CryptoKeyVersion: cryptoKeyVersion,
951	}
952
953	c, err := NewKeyManagementClient(context.Background(), clientOpt)
954	if err != nil {
955		t.Fatal(err)
956	}
957
958	resp, err := c.CreateCryptoKeyVersion(context.Background(), request)
959
960	if st, ok := gstatus.FromError(err); !ok {
961		t.Errorf("got error %v, expected grpc error", err)
962	} else if c := st.Code(); c != errCode {
963		t.Errorf("got error code %q, want %q", c, errCode)
964	}
965	_ = resp
966}
967func TestKeyManagementServiceUpdateCryptoKey(t *testing.T) {
968	var name string = "name3373707"
969	var expectedResponse = &kmspb.CryptoKey{
970		Name: name,
971	}
972
973	mockKeyManagement.err = nil
974	mockKeyManagement.reqs = nil
975
976	mockKeyManagement.resps = append(mockKeyManagement.resps[:0], expectedResponse)
977
978	var cryptoKey *kmspb.CryptoKey = &kmspb.CryptoKey{}
979	var updateMask *field_maskpb.FieldMask = &field_maskpb.FieldMask{}
980	var request = &kmspb.UpdateCryptoKeyRequest{
981		CryptoKey:  cryptoKey,
982		UpdateMask: updateMask,
983	}
984
985	c, err := NewKeyManagementClient(context.Background(), clientOpt)
986	if err != nil {
987		t.Fatal(err)
988	}
989
990	resp, err := c.UpdateCryptoKey(context.Background(), request)
991
992	if err != nil {
993		t.Fatal(err)
994	}
995
996	if want, got := request, mockKeyManagement.reqs[0]; !proto.Equal(want, got) {
997		t.Errorf("wrong request %q, want %q", got, want)
998	}
999
1000	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1001		t.Errorf("wrong response %q, want %q)", got, want)
1002	}
1003}
1004
1005func TestKeyManagementServiceUpdateCryptoKeyError(t *testing.T) {
1006	errCode := codes.PermissionDenied
1007	mockKeyManagement.err = gstatus.Error(errCode, "test error")
1008
1009	var cryptoKey *kmspb.CryptoKey = &kmspb.CryptoKey{}
1010	var updateMask *field_maskpb.FieldMask = &field_maskpb.FieldMask{}
1011	var request = &kmspb.UpdateCryptoKeyRequest{
1012		CryptoKey:  cryptoKey,
1013		UpdateMask: updateMask,
1014	}
1015
1016	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1017	if err != nil {
1018		t.Fatal(err)
1019	}
1020
1021	resp, err := c.UpdateCryptoKey(context.Background(), request)
1022
1023	if st, ok := gstatus.FromError(err); !ok {
1024		t.Errorf("got error %v, expected grpc error", err)
1025	} else if c := st.Code(); c != errCode {
1026		t.Errorf("got error code %q, want %q", c, errCode)
1027	}
1028	_ = resp
1029}
1030func TestKeyManagementServiceUpdateCryptoKeyVersion(t *testing.T) {
1031	var name string = "name3373707"
1032	var expectedResponse = &kmspb.CryptoKeyVersion{
1033		Name: name,
1034	}
1035
1036	mockKeyManagement.err = nil
1037	mockKeyManagement.reqs = nil
1038
1039	mockKeyManagement.resps = append(mockKeyManagement.resps[:0], expectedResponse)
1040
1041	var cryptoKeyVersion *kmspb.CryptoKeyVersion = &kmspb.CryptoKeyVersion{}
1042	var updateMask *field_maskpb.FieldMask = &field_maskpb.FieldMask{}
1043	var request = &kmspb.UpdateCryptoKeyVersionRequest{
1044		CryptoKeyVersion: cryptoKeyVersion,
1045		UpdateMask:       updateMask,
1046	}
1047
1048	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1049	if err != nil {
1050		t.Fatal(err)
1051	}
1052
1053	resp, err := c.UpdateCryptoKeyVersion(context.Background(), request)
1054
1055	if err != nil {
1056		t.Fatal(err)
1057	}
1058
1059	if want, got := request, mockKeyManagement.reqs[0]; !proto.Equal(want, got) {
1060		t.Errorf("wrong request %q, want %q", got, want)
1061	}
1062
1063	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1064		t.Errorf("wrong response %q, want %q)", got, want)
1065	}
1066}
1067
1068func TestKeyManagementServiceUpdateCryptoKeyVersionError(t *testing.T) {
1069	errCode := codes.PermissionDenied
1070	mockKeyManagement.err = gstatus.Error(errCode, "test error")
1071
1072	var cryptoKeyVersion *kmspb.CryptoKeyVersion = &kmspb.CryptoKeyVersion{}
1073	var updateMask *field_maskpb.FieldMask = &field_maskpb.FieldMask{}
1074	var request = &kmspb.UpdateCryptoKeyVersionRequest{
1075		CryptoKeyVersion: cryptoKeyVersion,
1076		UpdateMask:       updateMask,
1077	}
1078
1079	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1080	if err != nil {
1081		t.Fatal(err)
1082	}
1083
1084	resp, err := c.UpdateCryptoKeyVersion(context.Background(), request)
1085
1086	if st, ok := gstatus.FromError(err); !ok {
1087		t.Errorf("got error %v, expected grpc error", err)
1088	} else if c := st.Code(); c != errCode {
1089		t.Errorf("got error code %q, want %q", c, errCode)
1090	}
1091	_ = resp
1092}
1093func TestKeyManagementServiceEncrypt(t *testing.T) {
1094	var name2 string = "name2-1052831874"
1095	var ciphertext []byte = []byte("-72")
1096	var expectedResponse = &kmspb.EncryptResponse{
1097		Name:       name2,
1098		Ciphertext: ciphertext,
1099	}
1100
1101	mockKeyManagement.err = nil
1102	mockKeyManagement.reqs = nil
1103
1104	mockKeyManagement.resps = append(mockKeyManagement.resps[:0], expectedResponse)
1105
1106	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY_PATH]")
1107	var plaintext []byte = []byte("-9")
1108	var request = &kmspb.EncryptRequest{
1109		Name:      formattedName,
1110		Plaintext: plaintext,
1111	}
1112
1113	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1114	if err != nil {
1115		t.Fatal(err)
1116	}
1117
1118	resp, err := c.Encrypt(context.Background(), request)
1119
1120	if err != nil {
1121		t.Fatal(err)
1122	}
1123
1124	if want, got := request, mockKeyManagement.reqs[0]; !proto.Equal(want, got) {
1125		t.Errorf("wrong request %q, want %q", got, want)
1126	}
1127
1128	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1129		t.Errorf("wrong response %q, want %q)", got, want)
1130	}
1131}
1132
1133func TestKeyManagementServiceEncryptError(t *testing.T) {
1134	errCode := codes.PermissionDenied
1135	mockKeyManagement.err = gstatus.Error(errCode, "test error")
1136
1137	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY_PATH]")
1138	var plaintext []byte = []byte("-9")
1139	var request = &kmspb.EncryptRequest{
1140		Name:      formattedName,
1141		Plaintext: plaintext,
1142	}
1143
1144	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1145	if err != nil {
1146		t.Fatal(err)
1147	}
1148
1149	resp, err := c.Encrypt(context.Background(), request)
1150
1151	if st, ok := gstatus.FromError(err); !ok {
1152		t.Errorf("got error %v, expected grpc error", err)
1153	} else if c := st.Code(); c != errCode {
1154		t.Errorf("got error code %q, want %q", c, errCode)
1155	}
1156	_ = resp
1157}
1158func TestKeyManagementServiceDecrypt(t *testing.T) {
1159	var plaintext []byte = []byte("-9")
1160	var expectedResponse = &kmspb.DecryptResponse{
1161		Plaintext: plaintext,
1162	}
1163
1164	mockKeyManagement.err = nil
1165	mockKeyManagement.reqs = nil
1166
1167	mockKeyManagement.resps = append(mockKeyManagement.resps[:0], expectedResponse)
1168
1169	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
1170	var ciphertext []byte = []byte("-72")
1171	var request = &kmspb.DecryptRequest{
1172		Name:       formattedName,
1173		Ciphertext: ciphertext,
1174	}
1175
1176	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1177	if err != nil {
1178		t.Fatal(err)
1179	}
1180
1181	resp, err := c.Decrypt(context.Background(), request)
1182
1183	if err != nil {
1184		t.Fatal(err)
1185	}
1186
1187	if want, got := request, mockKeyManagement.reqs[0]; !proto.Equal(want, got) {
1188		t.Errorf("wrong request %q, want %q", got, want)
1189	}
1190
1191	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1192		t.Errorf("wrong response %q, want %q)", got, want)
1193	}
1194}
1195
1196func TestKeyManagementServiceDecryptError(t *testing.T) {
1197	errCode := codes.PermissionDenied
1198	mockKeyManagement.err = gstatus.Error(errCode, "test error")
1199
1200	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
1201	var ciphertext []byte = []byte("-72")
1202	var request = &kmspb.DecryptRequest{
1203		Name:       formattedName,
1204		Ciphertext: ciphertext,
1205	}
1206
1207	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1208	if err != nil {
1209		t.Fatal(err)
1210	}
1211
1212	resp, err := c.Decrypt(context.Background(), request)
1213
1214	if st, ok := gstatus.FromError(err); !ok {
1215		t.Errorf("got error %v, expected grpc error", err)
1216	} else if c := st.Code(); c != errCode {
1217		t.Errorf("got error code %q, want %q", c, errCode)
1218	}
1219	_ = resp
1220}
1221func TestKeyManagementServiceUpdateCryptoKeyPrimaryVersion(t *testing.T) {
1222	var name2 string = "name2-1052831874"
1223	var expectedResponse = &kmspb.CryptoKey{
1224		Name: name2,
1225	}
1226
1227	mockKeyManagement.err = nil
1228	mockKeyManagement.reqs = nil
1229
1230	mockKeyManagement.resps = append(mockKeyManagement.resps[:0], expectedResponse)
1231
1232	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
1233	var cryptoKeyVersionId string = "cryptoKeyVersionId729489152"
1234	var request = &kmspb.UpdateCryptoKeyPrimaryVersionRequest{
1235		Name:               formattedName,
1236		CryptoKeyVersionId: cryptoKeyVersionId,
1237	}
1238
1239	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1240	if err != nil {
1241		t.Fatal(err)
1242	}
1243
1244	resp, err := c.UpdateCryptoKeyPrimaryVersion(context.Background(), request)
1245
1246	if err != nil {
1247		t.Fatal(err)
1248	}
1249
1250	if want, got := request, mockKeyManagement.reqs[0]; !proto.Equal(want, got) {
1251		t.Errorf("wrong request %q, want %q", got, want)
1252	}
1253
1254	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1255		t.Errorf("wrong response %q, want %q)", got, want)
1256	}
1257}
1258
1259func TestKeyManagementServiceUpdateCryptoKeyPrimaryVersionError(t *testing.T) {
1260	errCode := codes.PermissionDenied
1261	mockKeyManagement.err = gstatus.Error(errCode, "test error")
1262
1263	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
1264	var cryptoKeyVersionId string = "cryptoKeyVersionId729489152"
1265	var request = &kmspb.UpdateCryptoKeyPrimaryVersionRequest{
1266		Name:               formattedName,
1267		CryptoKeyVersionId: cryptoKeyVersionId,
1268	}
1269
1270	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1271	if err != nil {
1272		t.Fatal(err)
1273	}
1274
1275	resp, err := c.UpdateCryptoKeyPrimaryVersion(context.Background(), request)
1276
1277	if st, ok := gstatus.FromError(err); !ok {
1278		t.Errorf("got error %v, expected grpc error", err)
1279	} else if c := st.Code(); c != errCode {
1280		t.Errorf("got error code %q, want %q", c, errCode)
1281	}
1282	_ = resp
1283}
1284func TestKeyManagementServiceDestroyCryptoKeyVersion(t *testing.T) {
1285	var name2 string = "name2-1052831874"
1286	var expectedResponse = &kmspb.CryptoKeyVersion{
1287		Name: name2,
1288	}
1289
1290	mockKeyManagement.err = nil
1291	mockKeyManagement.reqs = nil
1292
1293	mockKeyManagement.resps = append(mockKeyManagement.resps[:0], expectedResponse)
1294
1295	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s/cryptoKeyVersions/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]", "[CRYPTO_KEY_VERSION]")
1296	var request = &kmspb.DestroyCryptoKeyVersionRequest{
1297		Name: formattedName,
1298	}
1299
1300	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1301	if err != nil {
1302		t.Fatal(err)
1303	}
1304
1305	resp, err := c.DestroyCryptoKeyVersion(context.Background(), request)
1306
1307	if err != nil {
1308		t.Fatal(err)
1309	}
1310
1311	if want, got := request, mockKeyManagement.reqs[0]; !proto.Equal(want, got) {
1312		t.Errorf("wrong request %q, want %q", got, want)
1313	}
1314
1315	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1316		t.Errorf("wrong response %q, want %q)", got, want)
1317	}
1318}
1319
1320func TestKeyManagementServiceDestroyCryptoKeyVersionError(t *testing.T) {
1321	errCode := codes.PermissionDenied
1322	mockKeyManagement.err = gstatus.Error(errCode, "test error")
1323
1324	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s/cryptoKeyVersions/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]", "[CRYPTO_KEY_VERSION]")
1325	var request = &kmspb.DestroyCryptoKeyVersionRequest{
1326		Name: formattedName,
1327	}
1328
1329	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1330	if err != nil {
1331		t.Fatal(err)
1332	}
1333
1334	resp, err := c.DestroyCryptoKeyVersion(context.Background(), request)
1335
1336	if st, ok := gstatus.FromError(err); !ok {
1337		t.Errorf("got error %v, expected grpc error", err)
1338	} else if c := st.Code(); c != errCode {
1339		t.Errorf("got error code %q, want %q", c, errCode)
1340	}
1341	_ = resp
1342}
1343func TestKeyManagementServiceRestoreCryptoKeyVersion(t *testing.T) {
1344	var name2 string = "name2-1052831874"
1345	var expectedResponse = &kmspb.CryptoKeyVersion{
1346		Name: name2,
1347	}
1348
1349	mockKeyManagement.err = nil
1350	mockKeyManagement.reqs = nil
1351
1352	mockKeyManagement.resps = append(mockKeyManagement.resps[:0], expectedResponse)
1353
1354	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s/cryptoKeyVersions/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]", "[CRYPTO_KEY_VERSION]")
1355	var request = &kmspb.RestoreCryptoKeyVersionRequest{
1356		Name: formattedName,
1357	}
1358
1359	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1360	if err != nil {
1361		t.Fatal(err)
1362	}
1363
1364	resp, err := c.RestoreCryptoKeyVersion(context.Background(), request)
1365
1366	if err != nil {
1367		t.Fatal(err)
1368	}
1369
1370	if want, got := request, mockKeyManagement.reqs[0]; !proto.Equal(want, got) {
1371		t.Errorf("wrong request %q, want %q", got, want)
1372	}
1373
1374	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1375		t.Errorf("wrong response %q, want %q)", got, want)
1376	}
1377}
1378
1379func TestKeyManagementServiceRestoreCryptoKeyVersionError(t *testing.T) {
1380	errCode := codes.PermissionDenied
1381	mockKeyManagement.err = gstatus.Error(errCode, "test error")
1382
1383	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s/cryptoKeyVersions/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]", "[CRYPTO_KEY_VERSION]")
1384	var request = &kmspb.RestoreCryptoKeyVersionRequest{
1385		Name: formattedName,
1386	}
1387
1388	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1389	if err != nil {
1390		t.Fatal(err)
1391	}
1392
1393	resp, err := c.RestoreCryptoKeyVersion(context.Background(), request)
1394
1395	if st, ok := gstatus.FromError(err); !ok {
1396		t.Errorf("got error %v, expected grpc error", err)
1397	} else if c := st.Code(); c != errCode {
1398		t.Errorf("got error code %q, want %q", c, errCode)
1399	}
1400	_ = resp
1401}
1402