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 = ×tamppb.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 = ×tamppb.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