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