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