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	"context"
21	"flag"
22	"fmt"
23	"io"
24	"log"
25	"net"
26	"os"
27	"strings"
28	"testing"
29
30	"github.com/golang/protobuf/proto"
31	"github.com/golang/protobuf/ptypes"
32	durationpb "github.com/golang/protobuf/ptypes/duration"
33	timestamppb "github.com/golang/protobuf/ptypes/timestamp"
34	"google.golang.org/api/option"
35	kmspb "google.golang.org/genproto/googleapis/cloud/kms/v1"
36	field_maskpb "google.golang.org/genproto/protobuf/field_mask"
37
38	status "google.golang.org/genproto/googleapis/rpc/status"
39	"google.golang.org/grpc"
40	"google.golang.org/grpc/codes"
41	"google.golang.org/grpc/metadata"
42
43	gstatus "google.golang.org/grpc/status"
44)
45
46var _ = io.EOF
47var _ = ptypes.MarshalAny
48var _ status.Status
49
50type mockKeyManagementServer struct {
51	// Embed for forward compatibility.
52	// Tests will keep working if more methods are added
53	// in the future.
54	kmspb.KeyManagementServiceServer
55
56	reqs []proto.Message
57
58	// If set, all calls return this error.
59	err error
60
61	// responses to return if err == nil
62	resps []proto.Message
63}
64
65func (s *mockKeyManagementServer) ListKeyRings(ctx context.Context, req *kmspb.ListKeyRingsRequest) (*kmspb.ListKeyRingsResponse, error) {
66	md, _ := metadata.FromIncomingContext(ctx)
67	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
68		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
69	}
70	s.reqs = append(s.reqs, req)
71	if s.err != nil {
72		return nil, s.err
73	}
74	return s.resps[0].(*kmspb.ListKeyRingsResponse), nil
75}
76
77func (s *mockKeyManagementServer) ListCryptoKeys(ctx context.Context, req *kmspb.ListCryptoKeysRequest) (*kmspb.ListCryptoKeysResponse, error) {
78	md, _ := metadata.FromIncomingContext(ctx)
79	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
80		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
81	}
82	s.reqs = append(s.reqs, req)
83	if s.err != nil {
84		return nil, s.err
85	}
86	return s.resps[0].(*kmspb.ListCryptoKeysResponse), nil
87}
88
89func (s *mockKeyManagementServer) ListCryptoKeyVersions(ctx context.Context, req *kmspb.ListCryptoKeyVersionsRequest) (*kmspb.ListCryptoKeyVersionsResponse, error) {
90	md, _ := metadata.FromIncomingContext(ctx)
91	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
92		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
93	}
94	s.reqs = append(s.reqs, req)
95	if s.err != nil {
96		return nil, s.err
97	}
98	return s.resps[0].(*kmspb.ListCryptoKeyVersionsResponse), nil
99}
100
101func (s *mockKeyManagementServer) ListImportJobs(ctx context.Context, req *kmspb.ListImportJobsRequest) (*kmspb.ListImportJobsResponse, error) {
102	md, _ := metadata.FromIncomingContext(ctx)
103	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
104		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
105	}
106	s.reqs = append(s.reqs, req)
107	if s.err != nil {
108		return nil, s.err
109	}
110	return s.resps[0].(*kmspb.ListImportJobsResponse), nil
111}
112
113func (s *mockKeyManagementServer) GetKeyRing(ctx context.Context, req *kmspb.GetKeyRingRequest) (*kmspb.KeyRing, error) {
114	md, _ := metadata.FromIncomingContext(ctx)
115	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
116		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
117	}
118	s.reqs = append(s.reqs, req)
119	if s.err != nil {
120		return nil, s.err
121	}
122	return s.resps[0].(*kmspb.KeyRing), nil
123}
124
125func (s *mockKeyManagementServer) GetCryptoKey(ctx context.Context, req *kmspb.GetCryptoKeyRequest) (*kmspb.CryptoKey, error) {
126	md, _ := metadata.FromIncomingContext(ctx)
127	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
128		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
129	}
130	s.reqs = append(s.reqs, req)
131	if s.err != nil {
132		return nil, s.err
133	}
134	return s.resps[0].(*kmspb.CryptoKey), nil
135}
136
137func (s *mockKeyManagementServer) GetCryptoKeyVersion(ctx context.Context, req *kmspb.GetCryptoKeyVersionRequest) (*kmspb.CryptoKeyVersion, error) {
138	md, _ := metadata.FromIncomingContext(ctx)
139	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
140		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
141	}
142	s.reqs = append(s.reqs, req)
143	if s.err != nil {
144		return nil, s.err
145	}
146	return s.resps[0].(*kmspb.CryptoKeyVersion), nil
147}
148
149func (s *mockKeyManagementServer) GetPublicKey(ctx context.Context, req *kmspb.GetPublicKeyRequest) (*kmspb.PublicKey, error) {
150	md, _ := metadata.FromIncomingContext(ctx)
151	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
152		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
153	}
154	s.reqs = append(s.reqs, req)
155	if s.err != nil {
156		return nil, s.err
157	}
158	return s.resps[0].(*kmspb.PublicKey), nil
159}
160
161func (s *mockKeyManagementServer) GetImportJob(ctx context.Context, req *kmspb.GetImportJobRequest) (*kmspb.ImportJob, error) {
162	md, _ := metadata.FromIncomingContext(ctx)
163	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
164		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
165	}
166	s.reqs = append(s.reqs, req)
167	if s.err != nil {
168		return nil, s.err
169	}
170	return s.resps[0].(*kmspb.ImportJob), nil
171}
172
173func (s *mockKeyManagementServer) CreateKeyRing(ctx context.Context, req *kmspb.CreateKeyRingRequest) (*kmspb.KeyRing, error) {
174	md, _ := metadata.FromIncomingContext(ctx)
175	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
176		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
177	}
178	s.reqs = append(s.reqs, req)
179	if s.err != nil {
180		return nil, s.err
181	}
182	return s.resps[0].(*kmspb.KeyRing), nil
183}
184
185func (s *mockKeyManagementServer) CreateCryptoKey(ctx context.Context, req *kmspb.CreateCryptoKeyRequest) (*kmspb.CryptoKey, error) {
186	md, _ := metadata.FromIncomingContext(ctx)
187	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
188		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
189	}
190	s.reqs = append(s.reqs, req)
191	if s.err != nil {
192		return nil, s.err
193	}
194	return s.resps[0].(*kmspb.CryptoKey), nil
195}
196
197func (s *mockKeyManagementServer) CreateCryptoKeyVersion(ctx context.Context, req *kmspb.CreateCryptoKeyVersionRequest) (*kmspb.CryptoKeyVersion, error) {
198	md, _ := metadata.FromIncomingContext(ctx)
199	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
200		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
201	}
202	s.reqs = append(s.reqs, req)
203	if s.err != nil {
204		return nil, s.err
205	}
206	return s.resps[0].(*kmspb.CryptoKeyVersion), nil
207}
208
209func (s *mockKeyManagementServer) ImportCryptoKeyVersion(ctx context.Context, req *kmspb.ImportCryptoKeyVersionRequest) (*kmspb.CryptoKeyVersion, error) {
210	md, _ := metadata.FromIncomingContext(ctx)
211	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
212		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
213	}
214	s.reqs = append(s.reqs, req)
215	if s.err != nil {
216		return nil, s.err
217	}
218	return s.resps[0].(*kmspb.CryptoKeyVersion), nil
219}
220
221func (s *mockKeyManagementServer) CreateImportJob(ctx context.Context, req *kmspb.CreateImportJobRequest) (*kmspb.ImportJob, error) {
222	md, _ := metadata.FromIncomingContext(ctx)
223	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
224		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
225	}
226	s.reqs = append(s.reqs, req)
227	if s.err != nil {
228		return nil, s.err
229	}
230	return s.resps[0].(*kmspb.ImportJob), nil
231}
232
233func (s *mockKeyManagementServer) UpdateCryptoKey(ctx context.Context, req *kmspb.UpdateCryptoKeyRequest) (*kmspb.CryptoKey, error) {
234	md, _ := metadata.FromIncomingContext(ctx)
235	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
236		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
237	}
238	s.reqs = append(s.reqs, req)
239	if s.err != nil {
240		return nil, s.err
241	}
242	return s.resps[0].(*kmspb.CryptoKey), nil
243}
244
245func (s *mockKeyManagementServer) UpdateCryptoKeyVersion(ctx context.Context, req *kmspb.UpdateCryptoKeyVersionRequest) (*kmspb.CryptoKeyVersion, error) {
246	md, _ := metadata.FromIncomingContext(ctx)
247	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
248		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
249	}
250	s.reqs = append(s.reqs, req)
251	if s.err != nil {
252		return nil, s.err
253	}
254	return s.resps[0].(*kmspb.CryptoKeyVersion), nil
255}
256
257func (s *mockKeyManagementServer) Encrypt(ctx context.Context, req *kmspb.EncryptRequest) (*kmspb.EncryptResponse, error) {
258	md, _ := metadata.FromIncomingContext(ctx)
259	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
260		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
261	}
262	s.reqs = append(s.reqs, req)
263	if s.err != nil {
264		return nil, s.err
265	}
266	return s.resps[0].(*kmspb.EncryptResponse), nil
267}
268
269func (s *mockKeyManagementServer) Decrypt(ctx context.Context, req *kmspb.DecryptRequest) (*kmspb.DecryptResponse, error) {
270	md, _ := metadata.FromIncomingContext(ctx)
271	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
272		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
273	}
274	s.reqs = append(s.reqs, req)
275	if s.err != nil {
276		return nil, s.err
277	}
278	return s.resps[0].(*kmspb.DecryptResponse), nil
279}
280
281func (s *mockKeyManagementServer) AsymmetricSign(ctx context.Context, req *kmspb.AsymmetricSignRequest) (*kmspb.AsymmetricSignResponse, error) {
282	md, _ := metadata.FromIncomingContext(ctx)
283	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
284		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
285	}
286	s.reqs = append(s.reqs, req)
287	if s.err != nil {
288		return nil, s.err
289	}
290	return s.resps[0].(*kmspb.AsymmetricSignResponse), nil
291}
292
293func (s *mockKeyManagementServer) AsymmetricDecrypt(ctx context.Context, req *kmspb.AsymmetricDecryptRequest) (*kmspb.AsymmetricDecryptResponse, error) {
294	md, _ := metadata.FromIncomingContext(ctx)
295	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
296		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
297	}
298	s.reqs = append(s.reqs, req)
299	if s.err != nil {
300		return nil, s.err
301	}
302	return s.resps[0].(*kmspb.AsymmetricDecryptResponse), nil
303}
304
305func (s *mockKeyManagementServer) UpdateCryptoKeyPrimaryVersion(ctx context.Context, req *kmspb.UpdateCryptoKeyPrimaryVersionRequest) (*kmspb.CryptoKey, error) {
306	md, _ := metadata.FromIncomingContext(ctx)
307	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
308		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
309	}
310	s.reqs = append(s.reqs, req)
311	if s.err != nil {
312		return nil, s.err
313	}
314	return s.resps[0].(*kmspb.CryptoKey), nil
315}
316
317func (s *mockKeyManagementServer) DestroyCryptoKeyVersion(ctx context.Context, req *kmspb.DestroyCryptoKeyVersionRequest) (*kmspb.CryptoKeyVersion, error) {
318	md, _ := metadata.FromIncomingContext(ctx)
319	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
320		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
321	}
322	s.reqs = append(s.reqs, req)
323	if s.err != nil {
324		return nil, s.err
325	}
326	return s.resps[0].(*kmspb.CryptoKeyVersion), nil
327}
328
329func (s *mockKeyManagementServer) RestoreCryptoKeyVersion(ctx context.Context, req *kmspb.RestoreCryptoKeyVersionRequest) (*kmspb.CryptoKeyVersion, error) {
330	md, _ := metadata.FromIncomingContext(ctx)
331	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
332		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
333	}
334	s.reqs = append(s.reqs, req)
335	if s.err != nil {
336		return nil, s.err
337	}
338	return s.resps[0].(*kmspb.CryptoKeyVersion), nil
339}
340
341// clientOpt is the option tests should use to connect to the test server.
342// It is initialized by TestMain.
343var clientOpt option.ClientOption
344
345var (
346	mockKeyManagement mockKeyManagementServer
347)
348
349func TestMain(m *testing.M) {
350	flag.Parse()
351
352	serv := grpc.NewServer()
353	kmspb.RegisterKeyManagementServiceServer(serv, &mockKeyManagement)
354
355	lis, err := net.Listen("tcp", "localhost:0")
356	if err != nil {
357		log.Fatal(err)
358	}
359	go serv.Serve(lis)
360
361	conn, err := grpc.Dial(lis.Addr().String(), grpc.WithInsecure())
362	if err != nil {
363		log.Fatal(err)
364	}
365	clientOpt = option.WithGRPCConn(conn)
366
367	os.Exit(m.Run())
368}
369
370func TestKeyManagementServiceListKeyRings(t *testing.T) {
371	var nextPageToken string = ""
372	var totalSize int32 = 705419236
373	var keyRingsElement *kmspb.KeyRing = &kmspb.KeyRing{}
374	var keyRings = []*kmspb.KeyRing{keyRingsElement}
375	var expectedResponse = &kmspb.ListKeyRingsResponse{
376		NextPageToken: nextPageToken,
377		TotalSize:     totalSize,
378		KeyRings:      keyRings,
379	}
380
381	mockKeyManagement.err = nil
382	mockKeyManagement.reqs = nil
383
384	mockKeyManagement.resps = append(mockKeyManagement.resps[:0], expectedResponse)
385
386	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]")
387	var request = &kmspb.ListKeyRingsRequest{
388		Parent: formattedParent,
389	}
390
391	c, err := NewKeyManagementClient(context.Background(), clientOpt)
392	if err != nil {
393		t.Fatal(err)
394	}
395
396	resp, err := c.ListKeyRings(context.Background(), request).Next()
397
398	if err != nil {
399		t.Fatal(err)
400	}
401
402	if want, got := request, mockKeyManagement.reqs[0]; !proto.Equal(want, got) {
403		t.Errorf("wrong request %q, want %q", got, want)
404	}
405
406	want := (interface{})(expectedResponse.KeyRings[0])
407	got := (interface{})(resp)
408	var ok bool
409
410	switch want := (want).(type) {
411	case proto.Message:
412		ok = proto.Equal(want, got.(proto.Message))
413	default:
414		ok = want == got
415	}
416	if !ok {
417		t.Errorf("wrong response %q, want %q)", got, want)
418	}
419}
420
421func TestKeyManagementServiceListKeyRingsError(t *testing.T) {
422	errCode := codes.PermissionDenied
423	mockKeyManagement.err = gstatus.Error(errCode, "test error")
424
425	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]")
426	var request = &kmspb.ListKeyRingsRequest{
427		Parent: formattedParent,
428	}
429
430	c, err := NewKeyManagementClient(context.Background(), clientOpt)
431	if err != nil {
432		t.Fatal(err)
433	}
434
435	resp, err := c.ListKeyRings(context.Background(), request).Next()
436
437	if st, ok := gstatus.FromError(err); !ok {
438		t.Errorf("got error %v, expected grpc error", err)
439	} else if c := st.Code(); c != errCode {
440		t.Errorf("got error code %q, want %q", c, errCode)
441	}
442	_ = resp
443}
444func TestKeyManagementServiceListImportJobs(t *testing.T) {
445	var nextPageToken string = ""
446	var totalSize int32 = 705419236
447	var importJobsElement *kmspb.ImportJob = &kmspb.ImportJob{}
448	var importJobs = []*kmspb.ImportJob{importJobsElement}
449	var expectedResponse = &kmspb.ListImportJobsResponse{
450		NextPageToken: nextPageToken,
451		TotalSize:     totalSize,
452		ImportJobs:    importJobs,
453	}
454
455	mockKeyManagement.err = nil
456	mockKeyManagement.reqs = nil
457
458	mockKeyManagement.resps = append(mockKeyManagement.resps[:0], expectedResponse)
459
460	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]")
461	var request = &kmspb.ListImportJobsRequest{
462		Parent: formattedParent,
463	}
464
465	c, err := NewKeyManagementClient(context.Background(), clientOpt)
466	if err != nil {
467		t.Fatal(err)
468	}
469
470	resp, err := c.ListImportJobs(context.Background(), request).Next()
471
472	if err != nil {
473		t.Fatal(err)
474	}
475
476	if want, got := request, mockKeyManagement.reqs[0]; !proto.Equal(want, got) {
477		t.Errorf("wrong request %q, want %q", got, want)
478	}
479
480	want := (interface{})(expectedResponse.ImportJobs[0])
481	got := (interface{})(resp)
482	var ok bool
483
484	switch want := (want).(type) {
485	case proto.Message:
486		ok = proto.Equal(want, got.(proto.Message))
487	default:
488		ok = want == got
489	}
490	if !ok {
491		t.Errorf("wrong response %q, want %q)", got, want)
492	}
493}
494
495func TestKeyManagementServiceListImportJobsError(t *testing.T) {
496	errCode := codes.PermissionDenied
497	mockKeyManagement.err = gstatus.Error(errCode, "test error")
498
499	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]")
500	var request = &kmspb.ListImportJobsRequest{
501		Parent: formattedParent,
502	}
503
504	c, err := NewKeyManagementClient(context.Background(), clientOpt)
505	if err != nil {
506		t.Fatal(err)
507	}
508
509	resp, err := c.ListImportJobs(context.Background(), request).Next()
510
511	if st, ok := gstatus.FromError(err); !ok {
512		t.Errorf("got error %v, expected grpc error", err)
513	} else if c := st.Code(); c != errCode {
514		t.Errorf("got error code %q, want %q", c, errCode)
515	}
516	_ = resp
517}
518func TestKeyManagementServiceListCryptoKeys(t *testing.T) {
519	var nextPageToken string = ""
520	var totalSize int32 = 705419236
521	var cryptoKeysElement *kmspb.CryptoKey = &kmspb.CryptoKey{}
522	var cryptoKeys = []*kmspb.CryptoKey{cryptoKeysElement}
523	var expectedResponse = &kmspb.ListCryptoKeysResponse{
524		NextPageToken: nextPageToken,
525		TotalSize:     totalSize,
526		CryptoKeys:    cryptoKeys,
527	}
528
529	mockKeyManagement.err = nil
530	mockKeyManagement.reqs = nil
531
532	mockKeyManagement.resps = append(mockKeyManagement.resps[:0], expectedResponse)
533
534	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]")
535	var request = &kmspb.ListCryptoKeysRequest{
536		Parent: formattedParent,
537	}
538
539	c, err := NewKeyManagementClient(context.Background(), clientOpt)
540	if err != nil {
541		t.Fatal(err)
542	}
543
544	resp, err := c.ListCryptoKeys(context.Background(), request).Next()
545
546	if err != nil {
547		t.Fatal(err)
548	}
549
550	if want, got := request, mockKeyManagement.reqs[0]; !proto.Equal(want, got) {
551		t.Errorf("wrong request %q, want %q", got, want)
552	}
553
554	want := (interface{})(expectedResponse.CryptoKeys[0])
555	got := (interface{})(resp)
556	var ok bool
557
558	switch want := (want).(type) {
559	case proto.Message:
560		ok = proto.Equal(want, got.(proto.Message))
561	default:
562		ok = want == got
563	}
564	if !ok {
565		t.Errorf("wrong response %q, want %q)", got, want)
566	}
567}
568
569func TestKeyManagementServiceListCryptoKeysError(t *testing.T) {
570	errCode := codes.PermissionDenied
571	mockKeyManagement.err = gstatus.Error(errCode, "test error")
572
573	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]")
574	var request = &kmspb.ListCryptoKeysRequest{
575		Parent: formattedParent,
576	}
577
578	c, err := NewKeyManagementClient(context.Background(), clientOpt)
579	if err != nil {
580		t.Fatal(err)
581	}
582
583	resp, err := c.ListCryptoKeys(context.Background(), request).Next()
584
585	if st, ok := gstatus.FromError(err); !ok {
586		t.Errorf("got error %v, expected grpc error", err)
587	} else if c := st.Code(); c != errCode {
588		t.Errorf("got error code %q, want %q", c, errCode)
589	}
590	_ = resp
591}
592func TestKeyManagementServiceListCryptoKeyVersions(t *testing.T) {
593	var nextPageToken string = ""
594	var totalSize int32 = 705419236
595	var cryptoKeyVersionsElement *kmspb.CryptoKeyVersion = &kmspb.CryptoKeyVersion{}
596	var cryptoKeyVersions = []*kmspb.CryptoKeyVersion{cryptoKeyVersionsElement}
597	var expectedResponse = &kmspb.ListCryptoKeyVersionsResponse{
598		NextPageToken:     nextPageToken,
599		TotalSize:         totalSize,
600		CryptoKeyVersions: cryptoKeyVersions,
601	}
602
603	mockKeyManagement.err = nil
604	mockKeyManagement.reqs = nil
605
606	mockKeyManagement.resps = append(mockKeyManagement.resps[:0], expectedResponse)
607
608	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
609	var request = &kmspb.ListCryptoKeyVersionsRequest{
610		Parent: formattedParent,
611	}
612
613	c, err := NewKeyManagementClient(context.Background(), clientOpt)
614	if err != nil {
615		t.Fatal(err)
616	}
617
618	resp, err := c.ListCryptoKeyVersions(context.Background(), request).Next()
619
620	if err != nil {
621		t.Fatal(err)
622	}
623
624	if want, got := request, mockKeyManagement.reqs[0]; !proto.Equal(want, got) {
625		t.Errorf("wrong request %q, want %q", got, want)
626	}
627
628	want := (interface{})(expectedResponse.CryptoKeyVersions[0])
629	got := (interface{})(resp)
630	var ok bool
631
632	switch want := (want).(type) {
633	case proto.Message:
634		ok = proto.Equal(want, got.(proto.Message))
635	default:
636		ok = want == got
637	}
638	if !ok {
639		t.Errorf("wrong response %q, want %q)", got, want)
640	}
641}
642
643func TestKeyManagementServiceListCryptoKeyVersionsError(t *testing.T) {
644	errCode := codes.PermissionDenied
645	mockKeyManagement.err = gstatus.Error(errCode, "test error")
646
647	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
648	var request = &kmspb.ListCryptoKeyVersionsRequest{
649		Parent: formattedParent,
650	}
651
652	c, err := NewKeyManagementClient(context.Background(), clientOpt)
653	if err != nil {
654		t.Fatal(err)
655	}
656
657	resp, err := c.ListCryptoKeyVersions(context.Background(), request).Next()
658
659	if st, ok := gstatus.FromError(err); !ok {
660		t.Errorf("got error %v, expected grpc error", err)
661	} else if c := st.Code(); c != errCode {
662		t.Errorf("got error code %q, want %q", c, errCode)
663	}
664	_ = resp
665}
666func TestKeyManagementServiceGetKeyRing(t *testing.T) {
667	var name2 string = "name2-1052831874"
668	var expectedResponse = &kmspb.KeyRing{
669		Name: name2,
670	}
671
672	mockKeyManagement.err = nil
673	mockKeyManagement.reqs = nil
674
675	mockKeyManagement.resps = append(mockKeyManagement.resps[:0], expectedResponse)
676
677	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]")
678	var request = &kmspb.GetKeyRingRequest{
679		Name: formattedName,
680	}
681
682	c, err := NewKeyManagementClient(context.Background(), clientOpt)
683	if err != nil {
684		t.Fatal(err)
685	}
686
687	resp, err := c.GetKeyRing(context.Background(), request)
688
689	if err != nil {
690		t.Fatal(err)
691	}
692
693	if want, got := request, mockKeyManagement.reqs[0]; !proto.Equal(want, got) {
694		t.Errorf("wrong request %q, want %q", got, want)
695	}
696
697	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
698		t.Errorf("wrong response %q, want %q)", got, want)
699	}
700}
701
702func TestKeyManagementServiceGetKeyRingError(t *testing.T) {
703	errCode := codes.PermissionDenied
704	mockKeyManagement.err = gstatus.Error(errCode, "test error")
705
706	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]")
707	var request = &kmspb.GetKeyRingRequest{
708		Name: formattedName,
709	}
710
711	c, err := NewKeyManagementClient(context.Background(), clientOpt)
712	if err != nil {
713		t.Fatal(err)
714	}
715
716	resp, err := c.GetKeyRing(context.Background(), request)
717
718	if st, ok := gstatus.FromError(err); !ok {
719		t.Errorf("got error %v, expected grpc error", err)
720	} else if c := st.Code(); c != errCode {
721		t.Errorf("got error code %q, want %q", c, errCode)
722	}
723	_ = resp
724}
725func TestKeyManagementServiceGetImportJob(t *testing.T) {
726	var name2 string = "name2-1052831874"
727	var expectedResponse = &kmspb.ImportJob{
728		Name: name2,
729	}
730
731	mockKeyManagement.err = nil
732	mockKeyManagement.reqs = nil
733
734	mockKeyManagement.resps = append(mockKeyManagement.resps[:0], expectedResponse)
735
736	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/importJobs/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[IMPORT_JOB]")
737	var request = &kmspb.GetImportJobRequest{
738		Name: formattedName,
739	}
740
741	c, err := NewKeyManagementClient(context.Background(), clientOpt)
742	if err != nil {
743		t.Fatal(err)
744	}
745
746	resp, err := c.GetImportJob(context.Background(), request)
747
748	if err != nil {
749		t.Fatal(err)
750	}
751
752	if want, got := request, mockKeyManagement.reqs[0]; !proto.Equal(want, got) {
753		t.Errorf("wrong request %q, want %q", got, want)
754	}
755
756	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
757		t.Errorf("wrong response %q, want %q)", got, want)
758	}
759}
760
761func TestKeyManagementServiceGetImportJobError(t *testing.T) {
762	errCode := codes.PermissionDenied
763	mockKeyManagement.err = gstatus.Error(errCode, "test error")
764
765	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/importJobs/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[IMPORT_JOB]")
766	var request = &kmspb.GetImportJobRequest{
767		Name: formattedName,
768	}
769
770	c, err := NewKeyManagementClient(context.Background(), clientOpt)
771	if err != nil {
772		t.Fatal(err)
773	}
774
775	resp, err := c.GetImportJob(context.Background(), request)
776
777	if st, ok := gstatus.FromError(err); !ok {
778		t.Errorf("got error %v, expected grpc error", err)
779	} else if c := st.Code(); c != errCode {
780		t.Errorf("got error code %q, want %q", c, errCode)
781	}
782	_ = resp
783}
784func TestKeyManagementServiceGetCryptoKey(t *testing.T) {
785	var name2 string = "name2-1052831874"
786	var expectedResponse = &kmspb.CryptoKey{
787		Name: name2,
788	}
789
790	mockKeyManagement.err = nil
791	mockKeyManagement.reqs = nil
792
793	mockKeyManagement.resps = append(mockKeyManagement.resps[:0], expectedResponse)
794
795	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
796	var request = &kmspb.GetCryptoKeyRequest{
797		Name: formattedName,
798	}
799
800	c, err := NewKeyManagementClient(context.Background(), clientOpt)
801	if err != nil {
802		t.Fatal(err)
803	}
804
805	resp, err := c.GetCryptoKey(context.Background(), request)
806
807	if err != nil {
808		t.Fatal(err)
809	}
810
811	if want, got := request, mockKeyManagement.reqs[0]; !proto.Equal(want, got) {
812		t.Errorf("wrong request %q, want %q", got, want)
813	}
814
815	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
816		t.Errorf("wrong response %q, want %q)", got, want)
817	}
818}
819
820func TestKeyManagementServiceGetCryptoKeyError(t *testing.T) {
821	errCode := codes.PermissionDenied
822	mockKeyManagement.err = gstatus.Error(errCode, "test error")
823
824	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
825	var request = &kmspb.GetCryptoKeyRequest{
826		Name: formattedName,
827	}
828
829	c, err := NewKeyManagementClient(context.Background(), clientOpt)
830	if err != nil {
831		t.Fatal(err)
832	}
833
834	resp, err := c.GetCryptoKey(context.Background(), request)
835
836	if st, ok := gstatus.FromError(err); !ok {
837		t.Errorf("got error %v, expected grpc error", err)
838	} else if c := st.Code(); c != errCode {
839		t.Errorf("got error code %q, want %q", c, errCode)
840	}
841	_ = resp
842}
843func TestKeyManagementServiceGetCryptoKeyVersion(t *testing.T) {
844	var name2 string = "name2-1052831874"
845	var importJob string = "importJob2125587491"
846	var importFailureReason string = "importFailureReason-494073229"
847	var expectedResponse = &kmspb.CryptoKeyVersion{
848		Name:                name2,
849		ImportJob:           importJob,
850		ImportFailureReason: importFailureReason,
851	}
852
853	mockKeyManagement.err = nil
854	mockKeyManagement.reqs = nil
855
856	mockKeyManagement.resps = append(mockKeyManagement.resps[:0], expectedResponse)
857
858	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s/cryptoKeyVersions/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]", "[CRYPTO_KEY_VERSION]")
859	var request = &kmspb.GetCryptoKeyVersionRequest{
860		Name: formattedName,
861	}
862
863	c, err := NewKeyManagementClient(context.Background(), clientOpt)
864	if err != nil {
865		t.Fatal(err)
866	}
867
868	resp, err := c.GetCryptoKeyVersion(context.Background(), request)
869
870	if err != nil {
871		t.Fatal(err)
872	}
873
874	if want, got := request, mockKeyManagement.reqs[0]; !proto.Equal(want, got) {
875		t.Errorf("wrong request %q, want %q", got, want)
876	}
877
878	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
879		t.Errorf("wrong response %q, want %q)", got, want)
880	}
881}
882
883func TestKeyManagementServiceGetCryptoKeyVersionError(t *testing.T) {
884	errCode := codes.PermissionDenied
885	mockKeyManagement.err = gstatus.Error(errCode, "test error")
886
887	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s/cryptoKeyVersions/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]", "[CRYPTO_KEY_VERSION]")
888	var request = &kmspb.GetCryptoKeyVersionRequest{
889		Name: formattedName,
890	}
891
892	c, err := NewKeyManagementClient(context.Background(), clientOpt)
893	if err != nil {
894		t.Fatal(err)
895	}
896
897	resp, err := c.GetCryptoKeyVersion(context.Background(), request)
898
899	if st, ok := gstatus.FromError(err); !ok {
900		t.Errorf("got error %v, expected grpc error", err)
901	} else if c := st.Code(); c != errCode {
902		t.Errorf("got error code %q, want %q", c, errCode)
903	}
904	_ = resp
905}
906func TestKeyManagementServiceCreateKeyRing(t *testing.T) {
907	var name string = "name3373707"
908	var expectedResponse = &kmspb.KeyRing{
909		Name: name,
910	}
911
912	mockKeyManagement.err = nil
913	mockKeyManagement.reqs = nil
914
915	mockKeyManagement.resps = append(mockKeyManagement.resps[:0], expectedResponse)
916
917	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]")
918	var keyRingId string = "keyRingId-2056646742"
919	var keyRing *kmspb.KeyRing = &kmspb.KeyRing{}
920	var request = &kmspb.CreateKeyRingRequest{
921		Parent:    formattedParent,
922		KeyRingId: keyRingId,
923		KeyRing:   keyRing,
924	}
925
926	c, err := NewKeyManagementClient(context.Background(), clientOpt)
927	if err != nil {
928		t.Fatal(err)
929	}
930
931	resp, err := c.CreateKeyRing(context.Background(), request)
932
933	if err != nil {
934		t.Fatal(err)
935	}
936
937	if want, got := request, mockKeyManagement.reqs[0]; !proto.Equal(want, got) {
938		t.Errorf("wrong request %q, want %q", got, want)
939	}
940
941	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
942		t.Errorf("wrong response %q, want %q)", got, want)
943	}
944}
945
946func TestKeyManagementServiceCreateKeyRingError(t *testing.T) {
947	errCode := codes.PermissionDenied
948	mockKeyManagement.err = gstatus.Error(errCode, "test error")
949
950	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]")
951	var keyRingId string = "keyRingId-2056646742"
952	var keyRing *kmspb.KeyRing = &kmspb.KeyRing{}
953	var request = &kmspb.CreateKeyRingRequest{
954		Parent:    formattedParent,
955		KeyRingId: keyRingId,
956		KeyRing:   keyRing,
957	}
958
959	c, err := NewKeyManagementClient(context.Background(), clientOpt)
960	if err != nil {
961		t.Fatal(err)
962	}
963
964	resp, err := c.CreateKeyRing(context.Background(), request)
965
966	if st, ok := gstatus.FromError(err); !ok {
967		t.Errorf("got error %v, expected grpc error", err)
968	} else if c := st.Code(); c != errCode {
969		t.Errorf("got error code %q, want %q", c, errCode)
970	}
971	_ = resp
972}
973func TestKeyManagementServiceCreateImportJob(t *testing.T) {
974	var name string = "name3373707"
975	var expectedResponse = &kmspb.ImportJob{
976		Name: name,
977	}
978
979	mockKeyManagement.err = nil
980	mockKeyManagement.reqs = nil
981
982	mockKeyManagement.resps = append(mockKeyManagement.resps[:0], expectedResponse)
983
984	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]")
985	var importJobId string = "my-import-job"
986	var importMethod kmspb.ImportJob_ImportMethod = kmspb.ImportJob_RSA_OAEP_3072_SHA1_AES_256
987	var protectionLevel kmspb.ProtectionLevel = kmspb.ProtectionLevel_HSM
988	var importJob = &kmspb.ImportJob{
989		ImportMethod:    importMethod,
990		ProtectionLevel: protectionLevel,
991	}
992	var request = &kmspb.CreateImportJobRequest{
993		Parent:      formattedParent,
994		ImportJobId: importJobId,
995		ImportJob:   importJob,
996	}
997
998	c, err := NewKeyManagementClient(context.Background(), clientOpt)
999	if err != nil {
1000		t.Fatal(err)
1001	}
1002
1003	resp, err := c.CreateImportJob(context.Background(), request)
1004
1005	if err != nil {
1006		t.Fatal(err)
1007	}
1008
1009	if want, got := request, mockKeyManagement.reqs[0]; !proto.Equal(want, got) {
1010		t.Errorf("wrong request %q, want %q", got, want)
1011	}
1012
1013	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1014		t.Errorf("wrong response %q, want %q)", got, want)
1015	}
1016}
1017
1018func TestKeyManagementServiceCreateImportJobError(t *testing.T) {
1019	errCode := codes.PermissionDenied
1020	mockKeyManagement.err = gstatus.Error(errCode, "test error")
1021
1022	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]")
1023	var importJobId string = "my-import-job"
1024	var importMethod kmspb.ImportJob_ImportMethod = kmspb.ImportJob_RSA_OAEP_3072_SHA1_AES_256
1025	var protectionLevel kmspb.ProtectionLevel = kmspb.ProtectionLevel_HSM
1026	var importJob = &kmspb.ImportJob{
1027		ImportMethod:    importMethod,
1028		ProtectionLevel: protectionLevel,
1029	}
1030	var request = &kmspb.CreateImportJobRequest{
1031		Parent:      formattedParent,
1032		ImportJobId: importJobId,
1033		ImportJob:   importJob,
1034	}
1035
1036	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1037	if err != nil {
1038		t.Fatal(err)
1039	}
1040
1041	resp, err := c.CreateImportJob(context.Background(), request)
1042
1043	if st, ok := gstatus.FromError(err); !ok {
1044		t.Errorf("got error %v, expected grpc error", err)
1045	} else if c := st.Code(); c != errCode {
1046		t.Errorf("got error code %q, want %q", c, errCode)
1047	}
1048	_ = resp
1049}
1050func TestKeyManagementServiceCreateCryptoKey(t *testing.T) {
1051	var name string = "name3373707"
1052	var expectedResponse = &kmspb.CryptoKey{
1053		Name: name,
1054	}
1055
1056	mockKeyManagement.err = nil
1057	mockKeyManagement.reqs = nil
1058
1059	mockKeyManagement.resps = append(mockKeyManagement.resps[:0], expectedResponse)
1060
1061	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]")
1062	var cryptoKeyId string = "my-app-key"
1063	var purpose kmspb.CryptoKey_CryptoKeyPurpose = kmspb.CryptoKey_ENCRYPT_DECRYPT
1064	var seconds int64 = 2147483647
1065	var nextRotationTime = &timestamppb.Timestamp{
1066		Seconds: seconds,
1067	}
1068	var seconds2 int64 = 604800
1069	var rotationPeriod = &durationpb.Duration{
1070		Seconds: seconds2,
1071	}
1072	var cryptoKey = &kmspb.CryptoKey{
1073		Purpose:          purpose,
1074		NextRotationTime: nextRotationTime,
1075		RotationSchedule: &kmspb.CryptoKey_RotationPeriod{
1076			RotationPeriod: rotationPeriod,
1077		},
1078	}
1079	var request = &kmspb.CreateCryptoKeyRequest{
1080		Parent:      formattedParent,
1081		CryptoKeyId: cryptoKeyId,
1082		CryptoKey:   cryptoKey,
1083	}
1084
1085	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1086	if err != nil {
1087		t.Fatal(err)
1088	}
1089
1090	resp, err := c.CreateCryptoKey(context.Background(), request)
1091
1092	if err != nil {
1093		t.Fatal(err)
1094	}
1095
1096	if want, got := request, mockKeyManagement.reqs[0]; !proto.Equal(want, got) {
1097		t.Errorf("wrong request %q, want %q", got, want)
1098	}
1099
1100	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1101		t.Errorf("wrong response %q, want %q)", got, want)
1102	}
1103}
1104
1105func TestKeyManagementServiceCreateCryptoKeyError(t *testing.T) {
1106	errCode := codes.PermissionDenied
1107	mockKeyManagement.err = gstatus.Error(errCode, "test error")
1108
1109	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]")
1110	var cryptoKeyId string = "my-app-key"
1111	var purpose kmspb.CryptoKey_CryptoKeyPurpose = kmspb.CryptoKey_ENCRYPT_DECRYPT
1112	var seconds int64 = 2147483647
1113	var nextRotationTime = &timestamppb.Timestamp{
1114		Seconds: seconds,
1115	}
1116	var seconds2 int64 = 604800
1117	var rotationPeriod = &durationpb.Duration{
1118		Seconds: seconds2,
1119	}
1120	var cryptoKey = &kmspb.CryptoKey{
1121		Purpose:          purpose,
1122		NextRotationTime: nextRotationTime,
1123		RotationSchedule: &kmspb.CryptoKey_RotationPeriod{
1124			RotationPeriod: rotationPeriod,
1125		},
1126	}
1127	var request = &kmspb.CreateCryptoKeyRequest{
1128		Parent:      formattedParent,
1129		CryptoKeyId: cryptoKeyId,
1130		CryptoKey:   cryptoKey,
1131	}
1132
1133	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1134	if err != nil {
1135		t.Fatal(err)
1136	}
1137
1138	resp, err := c.CreateCryptoKey(context.Background(), request)
1139
1140	if st, ok := gstatus.FromError(err); !ok {
1141		t.Errorf("got error %v, expected grpc error", err)
1142	} else if c := st.Code(); c != errCode {
1143		t.Errorf("got error code %q, want %q", c, errCode)
1144	}
1145	_ = resp
1146}
1147func TestKeyManagementServiceCreateCryptoKeyVersion(t *testing.T) {
1148	var name string = "name3373707"
1149	var importJob string = "importJob2125587491"
1150	var importFailureReason string = "importFailureReason-494073229"
1151	var expectedResponse = &kmspb.CryptoKeyVersion{
1152		Name:                name,
1153		ImportJob:           importJob,
1154		ImportFailureReason: importFailureReason,
1155	}
1156
1157	mockKeyManagement.err = nil
1158	mockKeyManagement.reqs = nil
1159
1160	mockKeyManagement.resps = append(mockKeyManagement.resps[:0], expectedResponse)
1161
1162	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
1163	var cryptoKeyVersion *kmspb.CryptoKeyVersion = &kmspb.CryptoKeyVersion{}
1164	var request = &kmspb.CreateCryptoKeyVersionRequest{
1165		Parent:           formattedParent,
1166		CryptoKeyVersion: cryptoKeyVersion,
1167	}
1168
1169	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1170	if err != nil {
1171		t.Fatal(err)
1172	}
1173
1174	resp, err := c.CreateCryptoKeyVersion(context.Background(), request)
1175
1176	if err != nil {
1177		t.Fatal(err)
1178	}
1179
1180	if want, got := request, mockKeyManagement.reqs[0]; !proto.Equal(want, got) {
1181		t.Errorf("wrong request %q, want %q", got, want)
1182	}
1183
1184	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1185		t.Errorf("wrong response %q, want %q)", got, want)
1186	}
1187}
1188
1189func TestKeyManagementServiceCreateCryptoKeyVersionError(t *testing.T) {
1190	errCode := codes.PermissionDenied
1191	mockKeyManagement.err = gstatus.Error(errCode, "test error")
1192
1193	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
1194	var cryptoKeyVersion *kmspb.CryptoKeyVersion = &kmspb.CryptoKeyVersion{}
1195	var request = &kmspb.CreateCryptoKeyVersionRequest{
1196		Parent:           formattedParent,
1197		CryptoKeyVersion: cryptoKeyVersion,
1198	}
1199
1200	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1201	if err != nil {
1202		t.Fatal(err)
1203	}
1204
1205	resp, err := c.CreateCryptoKeyVersion(context.Background(), request)
1206
1207	if st, ok := gstatus.FromError(err); !ok {
1208		t.Errorf("got error %v, expected grpc error", err)
1209	} else if c := st.Code(); c != errCode {
1210		t.Errorf("got error code %q, want %q", c, errCode)
1211	}
1212	_ = resp
1213}
1214func TestKeyManagementServiceImportCryptoKeyVersion(t *testing.T) {
1215	var name string = "name3373707"
1216	var importJob2 string = "importJob2-1714851050"
1217	var importFailureReason string = "importFailureReason-494073229"
1218	var expectedResponse = &kmspb.CryptoKeyVersion{
1219		Name:                name,
1220		ImportJob:           importJob2,
1221		ImportFailureReason: importFailureReason,
1222	}
1223
1224	mockKeyManagement.err = nil
1225	mockKeyManagement.reqs = nil
1226
1227	mockKeyManagement.resps = append(mockKeyManagement.resps[:0], expectedResponse)
1228
1229	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
1230	var algorithm kmspb.CryptoKeyVersion_CryptoKeyVersionAlgorithm = kmspb.CryptoKeyVersion_CRYPTO_KEY_VERSION_ALGORITHM_UNSPECIFIED
1231	var importJob string = "importJob2125587491"
1232	var request = &kmspb.ImportCryptoKeyVersionRequest{
1233		Parent:    formattedParent,
1234		Algorithm: algorithm,
1235		ImportJob: importJob,
1236	}
1237
1238	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1239	if err != nil {
1240		t.Fatal(err)
1241	}
1242
1243	resp, err := c.ImportCryptoKeyVersion(context.Background(), request)
1244
1245	if err != nil {
1246		t.Fatal(err)
1247	}
1248
1249	if want, got := request, mockKeyManagement.reqs[0]; !proto.Equal(want, got) {
1250		t.Errorf("wrong request %q, want %q", got, want)
1251	}
1252
1253	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1254		t.Errorf("wrong response %q, want %q)", got, want)
1255	}
1256}
1257
1258func TestKeyManagementServiceImportCryptoKeyVersionError(t *testing.T) {
1259	errCode := codes.PermissionDenied
1260	mockKeyManagement.err = gstatus.Error(errCode, "test error")
1261
1262	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
1263	var algorithm kmspb.CryptoKeyVersion_CryptoKeyVersionAlgorithm = kmspb.CryptoKeyVersion_CRYPTO_KEY_VERSION_ALGORITHM_UNSPECIFIED
1264	var importJob string = "importJob2125587491"
1265	var request = &kmspb.ImportCryptoKeyVersionRequest{
1266		Parent:    formattedParent,
1267		Algorithm: algorithm,
1268		ImportJob: importJob,
1269	}
1270
1271	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1272	if err != nil {
1273		t.Fatal(err)
1274	}
1275
1276	resp, err := c.ImportCryptoKeyVersion(context.Background(), request)
1277
1278	if st, ok := gstatus.FromError(err); !ok {
1279		t.Errorf("got error %v, expected grpc error", err)
1280	} else if c := st.Code(); c != errCode {
1281		t.Errorf("got error code %q, want %q", c, errCode)
1282	}
1283	_ = resp
1284}
1285func TestKeyManagementServiceUpdateCryptoKey(t *testing.T) {
1286	var name string = "name3373707"
1287	var expectedResponse = &kmspb.CryptoKey{
1288		Name: name,
1289	}
1290
1291	mockKeyManagement.err = nil
1292	mockKeyManagement.reqs = nil
1293
1294	mockKeyManagement.resps = append(mockKeyManagement.resps[:0], expectedResponse)
1295
1296	var cryptoKey *kmspb.CryptoKey = &kmspb.CryptoKey{}
1297	var updateMask *field_maskpb.FieldMask = &field_maskpb.FieldMask{}
1298	var request = &kmspb.UpdateCryptoKeyRequest{
1299		CryptoKey:  cryptoKey,
1300		UpdateMask: updateMask,
1301	}
1302
1303	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1304	if err != nil {
1305		t.Fatal(err)
1306	}
1307
1308	resp, err := c.UpdateCryptoKey(context.Background(), request)
1309
1310	if err != nil {
1311		t.Fatal(err)
1312	}
1313
1314	if want, got := request, mockKeyManagement.reqs[0]; !proto.Equal(want, got) {
1315		t.Errorf("wrong request %q, want %q", got, want)
1316	}
1317
1318	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1319		t.Errorf("wrong response %q, want %q)", got, want)
1320	}
1321}
1322
1323func TestKeyManagementServiceUpdateCryptoKeyError(t *testing.T) {
1324	errCode := codes.PermissionDenied
1325	mockKeyManagement.err = gstatus.Error(errCode, "test error")
1326
1327	var cryptoKey *kmspb.CryptoKey = &kmspb.CryptoKey{}
1328	var updateMask *field_maskpb.FieldMask = &field_maskpb.FieldMask{}
1329	var request = &kmspb.UpdateCryptoKeyRequest{
1330		CryptoKey:  cryptoKey,
1331		UpdateMask: updateMask,
1332	}
1333
1334	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1335	if err != nil {
1336		t.Fatal(err)
1337	}
1338
1339	resp, err := c.UpdateCryptoKey(context.Background(), request)
1340
1341	if st, ok := gstatus.FromError(err); !ok {
1342		t.Errorf("got error %v, expected grpc error", err)
1343	} else if c := st.Code(); c != errCode {
1344		t.Errorf("got error code %q, want %q", c, errCode)
1345	}
1346	_ = resp
1347}
1348func TestKeyManagementServiceUpdateCryptoKeyVersion(t *testing.T) {
1349	var name string = "name3373707"
1350	var importJob string = "importJob2125587491"
1351	var importFailureReason string = "importFailureReason-494073229"
1352	var expectedResponse = &kmspb.CryptoKeyVersion{
1353		Name:                name,
1354		ImportJob:           importJob,
1355		ImportFailureReason: importFailureReason,
1356	}
1357
1358	mockKeyManagement.err = nil
1359	mockKeyManagement.reqs = nil
1360
1361	mockKeyManagement.resps = append(mockKeyManagement.resps[:0], expectedResponse)
1362
1363	var cryptoKeyVersion *kmspb.CryptoKeyVersion = &kmspb.CryptoKeyVersion{}
1364	var updateMask *field_maskpb.FieldMask = &field_maskpb.FieldMask{}
1365	var request = &kmspb.UpdateCryptoKeyVersionRequest{
1366		CryptoKeyVersion: cryptoKeyVersion,
1367		UpdateMask:       updateMask,
1368	}
1369
1370	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1371	if err != nil {
1372		t.Fatal(err)
1373	}
1374
1375	resp, err := c.UpdateCryptoKeyVersion(context.Background(), request)
1376
1377	if err != nil {
1378		t.Fatal(err)
1379	}
1380
1381	if want, got := request, mockKeyManagement.reqs[0]; !proto.Equal(want, got) {
1382		t.Errorf("wrong request %q, want %q", got, want)
1383	}
1384
1385	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1386		t.Errorf("wrong response %q, want %q)", got, want)
1387	}
1388}
1389
1390func TestKeyManagementServiceUpdateCryptoKeyVersionError(t *testing.T) {
1391	errCode := codes.PermissionDenied
1392	mockKeyManagement.err = gstatus.Error(errCode, "test error")
1393
1394	var cryptoKeyVersion *kmspb.CryptoKeyVersion = &kmspb.CryptoKeyVersion{}
1395	var updateMask *field_maskpb.FieldMask = &field_maskpb.FieldMask{}
1396	var request = &kmspb.UpdateCryptoKeyVersionRequest{
1397		CryptoKeyVersion: cryptoKeyVersion,
1398		UpdateMask:       updateMask,
1399	}
1400
1401	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1402	if err != nil {
1403		t.Fatal(err)
1404	}
1405
1406	resp, err := c.UpdateCryptoKeyVersion(context.Background(), request)
1407
1408	if st, ok := gstatus.FromError(err); !ok {
1409		t.Errorf("got error %v, expected grpc error", err)
1410	} else if c := st.Code(); c != errCode {
1411		t.Errorf("got error code %q, want %q", c, errCode)
1412	}
1413	_ = resp
1414}
1415func TestKeyManagementServiceEncrypt(t *testing.T) {
1416	var name2 string = "name2-1052831874"
1417	var ciphertext []byte = []byte("-72")
1418	var expectedResponse = &kmspb.EncryptResponse{
1419		Name:       name2,
1420		Ciphertext: ciphertext,
1421	}
1422
1423	mockKeyManagement.err = nil
1424	mockKeyManagement.reqs = nil
1425
1426	mockKeyManagement.resps = append(mockKeyManagement.resps[:0], expectedResponse)
1427
1428	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY_PATH]")
1429	var plaintext []byte = []byte("-9")
1430	var request = &kmspb.EncryptRequest{
1431		Name:      formattedName,
1432		Plaintext: plaintext,
1433	}
1434
1435	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1436	if err != nil {
1437		t.Fatal(err)
1438	}
1439
1440	resp, err := c.Encrypt(context.Background(), request)
1441
1442	if err != nil {
1443		t.Fatal(err)
1444	}
1445
1446	if want, got := request, mockKeyManagement.reqs[0]; !proto.Equal(want, got) {
1447		t.Errorf("wrong request %q, want %q", got, want)
1448	}
1449
1450	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1451		t.Errorf("wrong response %q, want %q)", got, want)
1452	}
1453}
1454
1455func TestKeyManagementServiceEncryptError(t *testing.T) {
1456	errCode := codes.PermissionDenied
1457	mockKeyManagement.err = gstatus.Error(errCode, "test error")
1458
1459	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY_PATH]")
1460	var plaintext []byte = []byte("-9")
1461	var request = &kmspb.EncryptRequest{
1462		Name:      formattedName,
1463		Plaintext: plaintext,
1464	}
1465
1466	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1467	if err != nil {
1468		t.Fatal(err)
1469	}
1470
1471	resp, err := c.Encrypt(context.Background(), request)
1472
1473	if st, ok := gstatus.FromError(err); !ok {
1474		t.Errorf("got error %v, expected grpc error", err)
1475	} else if c := st.Code(); c != errCode {
1476		t.Errorf("got error code %q, want %q", c, errCode)
1477	}
1478	_ = resp
1479}
1480func TestKeyManagementServiceDecrypt(t *testing.T) {
1481	var plaintext []byte = []byte("-9")
1482	var expectedResponse = &kmspb.DecryptResponse{
1483		Plaintext: plaintext,
1484	}
1485
1486	mockKeyManagement.err = nil
1487	mockKeyManagement.reqs = nil
1488
1489	mockKeyManagement.resps = append(mockKeyManagement.resps[:0], expectedResponse)
1490
1491	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
1492	var ciphertext []byte = []byte("-72")
1493	var request = &kmspb.DecryptRequest{
1494		Name:       formattedName,
1495		Ciphertext: ciphertext,
1496	}
1497
1498	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1499	if err != nil {
1500		t.Fatal(err)
1501	}
1502
1503	resp, err := c.Decrypt(context.Background(), request)
1504
1505	if err != nil {
1506		t.Fatal(err)
1507	}
1508
1509	if want, got := request, mockKeyManagement.reqs[0]; !proto.Equal(want, got) {
1510		t.Errorf("wrong request %q, want %q", got, want)
1511	}
1512
1513	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1514		t.Errorf("wrong response %q, want %q)", got, want)
1515	}
1516}
1517
1518func TestKeyManagementServiceDecryptError(t *testing.T) {
1519	errCode := codes.PermissionDenied
1520	mockKeyManagement.err = gstatus.Error(errCode, "test error")
1521
1522	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
1523	var ciphertext []byte = []byte("-72")
1524	var request = &kmspb.DecryptRequest{
1525		Name:       formattedName,
1526		Ciphertext: ciphertext,
1527	}
1528
1529	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1530	if err != nil {
1531		t.Fatal(err)
1532	}
1533
1534	resp, err := c.Decrypt(context.Background(), request)
1535
1536	if st, ok := gstatus.FromError(err); !ok {
1537		t.Errorf("got error %v, expected grpc error", err)
1538	} else if c := st.Code(); c != errCode {
1539		t.Errorf("got error code %q, want %q", c, errCode)
1540	}
1541	_ = resp
1542}
1543func TestKeyManagementServiceUpdateCryptoKeyPrimaryVersion(t *testing.T) {
1544	var name2 string = "name2-1052831874"
1545	var expectedResponse = &kmspb.CryptoKey{
1546		Name: name2,
1547	}
1548
1549	mockKeyManagement.err = nil
1550	mockKeyManagement.reqs = nil
1551
1552	mockKeyManagement.resps = append(mockKeyManagement.resps[:0], expectedResponse)
1553
1554	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
1555	var cryptoKeyVersionId string = "cryptoKeyVersionId729489152"
1556	var request = &kmspb.UpdateCryptoKeyPrimaryVersionRequest{
1557		Name:               formattedName,
1558		CryptoKeyVersionId: cryptoKeyVersionId,
1559	}
1560
1561	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1562	if err != nil {
1563		t.Fatal(err)
1564	}
1565
1566	resp, err := c.UpdateCryptoKeyPrimaryVersion(context.Background(), request)
1567
1568	if err != nil {
1569		t.Fatal(err)
1570	}
1571
1572	if want, got := request, mockKeyManagement.reqs[0]; !proto.Equal(want, got) {
1573		t.Errorf("wrong request %q, want %q", got, want)
1574	}
1575
1576	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1577		t.Errorf("wrong response %q, want %q)", got, want)
1578	}
1579}
1580
1581func TestKeyManagementServiceUpdateCryptoKeyPrimaryVersionError(t *testing.T) {
1582	errCode := codes.PermissionDenied
1583	mockKeyManagement.err = gstatus.Error(errCode, "test error")
1584
1585	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
1586	var cryptoKeyVersionId string = "cryptoKeyVersionId729489152"
1587	var request = &kmspb.UpdateCryptoKeyPrimaryVersionRequest{
1588		Name:               formattedName,
1589		CryptoKeyVersionId: cryptoKeyVersionId,
1590	}
1591
1592	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1593	if err != nil {
1594		t.Fatal(err)
1595	}
1596
1597	resp, err := c.UpdateCryptoKeyPrimaryVersion(context.Background(), request)
1598
1599	if st, ok := gstatus.FromError(err); !ok {
1600		t.Errorf("got error %v, expected grpc error", err)
1601	} else if c := st.Code(); c != errCode {
1602		t.Errorf("got error code %q, want %q", c, errCode)
1603	}
1604	_ = resp
1605}
1606func TestKeyManagementServiceDestroyCryptoKeyVersion(t *testing.T) {
1607	var name2 string = "name2-1052831874"
1608	var importJob string = "importJob2125587491"
1609	var importFailureReason string = "importFailureReason-494073229"
1610	var expectedResponse = &kmspb.CryptoKeyVersion{
1611		Name:                name2,
1612		ImportJob:           importJob,
1613		ImportFailureReason: importFailureReason,
1614	}
1615
1616	mockKeyManagement.err = nil
1617	mockKeyManagement.reqs = nil
1618
1619	mockKeyManagement.resps = append(mockKeyManagement.resps[:0], expectedResponse)
1620
1621	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s/cryptoKeyVersions/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]", "[CRYPTO_KEY_VERSION]")
1622	var request = &kmspb.DestroyCryptoKeyVersionRequest{
1623		Name: formattedName,
1624	}
1625
1626	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1627	if err != nil {
1628		t.Fatal(err)
1629	}
1630
1631	resp, err := c.DestroyCryptoKeyVersion(context.Background(), request)
1632
1633	if err != nil {
1634		t.Fatal(err)
1635	}
1636
1637	if want, got := request, mockKeyManagement.reqs[0]; !proto.Equal(want, got) {
1638		t.Errorf("wrong request %q, want %q", got, want)
1639	}
1640
1641	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1642		t.Errorf("wrong response %q, want %q)", got, want)
1643	}
1644}
1645
1646func TestKeyManagementServiceDestroyCryptoKeyVersionError(t *testing.T) {
1647	errCode := codes.PermissionDenied
1648	mockKeyManagement.err = gstatus.Error(errCode, "test error")
1649
1650	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s/cryptoKeyVersions/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]", "[CRYPTO_KEY_VERSION]")
1651	var request = &kmspb.DestroyCryptoKeyVersionRequest{
1652		Name: formattedName,
1653	}
1654
1655	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1656	if err != nil {
1657		t.Fatal(err)
1658	}
1659
1660	resp, err := c.DestroyCryptoKeyVersion(context.Background(), request)
1661
1662	if st, ok := gstatus.FromError(err); !ok {
1663		t.Errorf("got error %v, expected grpc error", err)
1664	} else if c := st.Code(); c != errCode {
1665		t.Errorf("got error code %q, want %q", c, errCode)
1666	}
1667	_ = resp
1668}
1669func TestKeyManagementServiceRestoreCryptoKeyVersion(t *testing.T) {
1670	var name2 string = "name2-1052831874"
1671	var importJob string = "importJob2125587491"
1672	var importFailureReason string = "importFailureReason-494073229"
1673	var expectedResponse = &kmspb.CryptoKeyVersion{
1674		Name:                name2,
1675		ImportJob:           importJob,
1676		ImportFailureReason: importFailureReason,
1677	}
1678
1679	mockKeyManagement.err = nil
1680	mockKeyManagement.reqs = nil
1681
1682	mockKeyManagement.resps = append(mockKeyManagement.resps[:0], expectedResponse)
1683
1684	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s/cryptoKeyVersions/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]", "[CRYPTO_KEY_VERSION]")
1685	var request = &kmspb.RestoreCryptoKeyVersionRequest{
1686		Name: formattedName,
1687	}
1688
1689	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1690	if err != nil {
1691		t.Fatal(err)
1692	}
1693
1694	resp, err := c.RestoreCryptoKeyVersion(context.Background(), request)
1695
1696	if err != nil {
1697		t.Fatal(err)
1698	}
1699
1700	if want, got := request, mockKeyManagement.reqs[0]; !proto.Equal(want, got) {
1701		t.Errorf("wrong request %q, want %q", got, want)
1702	}
1703
1704	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1705		t.Errorf("wrong response %q, want %q)", got, want)
1706	}
1707}
1708
1709func TestKeyManagementServiceRestoreCryptoKeyVersionError(t *testing.T) {
1710	errCode := codes.PermissionDenied
1711	mockKeyManagement.err = gstatus.Error(errCode, "test error")
1712
1713	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s/cryptoKeyVersions/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]", "[CRYPTO_KEY_VERSION]")
1714	var request = &kmspb.RestoreCryptoKeyVersionRequest{
1715		Name: formattedName,
1716	}
1717
1718	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1719	if err != nil {
1720		t.Fatal(err)
1721	}
1722
1723	resp, err := c.RestoreCryptoKeyVersion(context.Background(), request)
1724
1725	if st, ok := gstatus.FromError(err); !ok {
1726		t.Errorf("got error %v, expected grpc error", err)
1727	} else if c := st.Code(); c != errCode {
1728		t.Errorf("got error code %q, want %q", c, errCode)
1729	}
1730	_ = resp
1731}
1732func TestKeyManagementServiceGetPublicKey(t *testing.T) {
1733	var pem string = "pem110872"
1734	var expectedResponse = &kmspb.PublicKey{
1735		Pem: pem,
1736	}
1737
1738	mockKeyManagement.err = nil
1739	mockKeyManagement.reqs = nil
1740
1741	mockKeyManagement.resps = append(mockKeyManagement.resps[:0], expectedResponse)
1742
1743	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s/cryptoKeyVersions/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]", "[CRYPTO_KEY_VERSION]")
1744	var request = &kmspb.GetPublicKeyRequest{
1745		Name: formattedName,
1746	}
1747
1748	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1749	if err != nil {
1750		t.Fatal(err)
1751	}
1752
1753	resp, err := c.GetPublicKey(context.Background(), request)
1754
1755	if err != nil {
1756		t.Fatal(err)
1757	}
1758
1759	if want, got := request, mockKeyManagement.reqs[0]; !proto.Equal(want, got) {
1760		t.Errorf("wrong request %q, want %q", got, want)
1761	}
1762
1763	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1764		t.Errorf("wrong response %q, want %q)", got, want)
1765	}
1766}
1767
1768func TestKeyManagementServiceGetPublicKeyError(t *testing.T) {
1769	errCode := codes.PermissionDenied
1770	mockKeyManagement.err = gstatus.Error(errCode, "test error")
1771
1772	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s/cryptoKeyVersions/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]", "[CRYPTO_KEY_VERSION]")
1773	var request = &kmspb.GetPublicKeyRequest{
1774		Name: formattedName,
1775	}
1776
1777	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1778	if err != nil {
1779		t.Fatal(err)
1780	}
1781
1782	resp, err := c.GetPublicKey(context.Background(), request)
1783
1784	if st, ok := gstatus.FromError(err); !ok {
1785		t.Errorf("got error %v, expected grpc error", err)
1786	} else if c := st.Code(); c != errCode {
1787		t.Errorf("got error code %q, want %q", c, errCode)
1788	}
1789	_ = resp
1790}
1791func TestKeyManagementServiceAsymmetricDecrypt(t *testing.T) {
1792	var plaintext []byte = []byte("-9")
1793	var expectedResponse = &kmspb.AsymmetricDecryptResponse{
1794		Plaintext: plaintext,
1795	}
1796
1797	mockKeyManagement.err = nil
1798	mockKeyManagement.reqs = nil
1799
1800	mockKeyManagement.resps = append(mockKeyManagement.resps[:0], expectedResponse)
1801
1802	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s/cryptoKeyVersions/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]", "[CRYPTO_KEY_VERSION]")
1803	var ciphertext []byte = []byte("-72")
1804	var request = &kmspb.AsymmetricDecryptRequest{
1805		Name:       formattedName,
1806		Ciphertext: ciphertext,
1807	}
1808
1809	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1810	if err != nil {
1811		t.Fatal(err)
1812	}
1813
1814	resp, err := c.AsymmetricDecrypt(context.Background(), request)
1815
1816	if err != nil {
1817		t.Fatal(err)
1818	}
1819
1820	if want, got := request, mockKeyManagement.reqs[0]; !proto.Equal(want, got) {
1821		t.Errorf("wrong request %q, want %q", got, want)
1822	}
1823
1824	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1825		t.Errorf("wrong response %q, want %q)", got, want)
1826	}
1827}
1828
1829func TestKeyManagementServiceAsymmetricDecryptError(t *testing.T) {
1830	errCode := codes.PermissionDenied
1831	mockKeyManagement.err = gstatus.Error(errCode, "test error")
1832
1833	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s/cryptoKeyVersions/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]", "[CRYPTO_KEY_VERSION]")
1834	var ciphertext []byte = []byte("-72")
1835	var request = &kmspb.AsymmetricDecryptRequest{
1836		Name:       formattedName,
1837		Ciphertext: ciphertext,
1838	}
1839
1840	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1841	if err != nil {
1842		t.Fatal(err)
1843	}
1844
1845	resp, err := c.AsymmetricDecrypt(context.Background(), request)
1846
1847	if st, ok := gstatus.FromError(err); !ok {
1848		t.Errorf("got error %v, expected grpc error", err)
1849	} else if c := st.Code(); c != errCode {
1850		t.Errorf("got error code %q, want %q", c, errCode)
1851	}
1852	_ = resp
1853}
1854func TestKeyManagementServiceAsymmetricSign(t *testing.T) {
1855	var signature []byte = []byte("106")
1856	var expectedResponse = &kmspb.AsymmetricSignResponse{
1857		Signature: signature,
1858	}
1859
1860	mockKeyManagement.err = nil
1861	mockKeyManagement.reqs = nil
1862
1863	mockKeyManagement.resps = append(mockKeyManagement.resps[:0], expectedResponse)
1864
1865	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s/cryptoKeyVersions/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]", "[CRYPTO_KEY_VERSION]")
1866	var digest *kmspb.Digest = &kmspb.Digest{}
1867	var request = &kmspb.AsymmetricSignRequest{
1868		Name:   formattedName,
1869		Digest: digest,
1870	}
1871
1872	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1873	if err != nil {
1874		t.Fatal(err)
1875	}
1876
1877	resp, err := c.AsymmetricSign(context.Background(), request)
1878
1879	if err != nil {
1880		t.Fatal(err)
1881	}
1882
1883	if want, got := request, mockKeyManagement.reqs[0]; !proto.Equal(want, got) {
1884		t.Errorf("wrong request %q, want %q", got, want)
1885	}
1886
1887	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1888		t.Errorf("wrong response %q, want %q)", got, want)
1889	}
1890}
1891
1892func TestKeyManagementServiceAsymmetricSignError(t *testing.T) {
1893	errCode := codes.PermissionDenied
1894	mockKeyManagement.err = gstatus.Error(errCode, "test error")
1895
1896	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s/cryptoKeyVersions/%s", "[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]", "[CRYPTO_KEY_VERSION]")
1897	var digest *kmspb.Digest = &kmspb.Digest{}
1898	var request = &kmspb.AsymmetricSignRequest{
1899		Name:   formattedName,
1900		Digest: digest,
1901	}
1902
1903	c, err := NewKeyManagementClient(context.Background(), clientOpt)
1904	if err != nil {
1905		t.Fatal(err)
1906	}
1907
1908	resp, err := c.AsymmetricSign(context.Background(), request)
1909
1910	if st, ok := gstatus.FromError(err); !ok {
1911		t.Errorf("got error %v, expected grpc error", err)
1912	} else if c := st.Code(); c != errCode {
1913		t.Errorf("got error code %q, want %q", c, errCode)
1914	}
1915	_ = resp
1916}
1917