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