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 container 18 19import ( 20 "context" 21 "flag" 22 "fmt" 23 "io" 24 "log" 25 "net" 26 "os" 27 "strings" 28 "testing" 29 30 "github.com/golang/protobuf/proto" 31 "github.com/golang/protobuf/ptypes" 32 emptypb "github.com/golang/protobuf/ptypes/empty" 33 "google.golang.org/api/option" 34 containerpb "google.golang.org/genproto/googleapis/container/v1" 35 36 status "google.golang.org/genproto/googleapis/rpc/status" 37 "google.golang.org/grpc" 38 "google.golang.org/grpc/codes" 39 "google.golang.org/grpc/metadata" 40 41 gstatus "google.golang.org/grpc/status" 42) 43 44var _ = io.EOF 45var _ = ptypes.MarshalAny 46var _ status.Status 47 48type mockClusterManagerServer struct { 49 // Embed for forward compatibility. 50 // Tests will keep working if more methods are added 51 // in the future. 52 containerpb.ClusterManagerServer 53 54 reqs []proto.Message 55 56 // If set, all calls return this error. 57 err error 58 59 // responses to return if err == nil 60 resps []proto.Message 61} 62 63func (s *mockClusterManagerServer) ListClusters(ctx context.Context, req *containerpb.ListClustersRequest) (*containerpb.ListClustersResponse, error) { 64 md, _ := metadata.FromIncomingContext(ctx) 65 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 66 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 67 } 68 s.reqs = append(s.reqs, req) 69 if s.err != nil { 70 return nil, s.err 71 } 72 return s.resps[0].(*containerpb.ListClustersResponse), nil 73} 74 75func (s *mockClusterManagerServer) GetCluster(ctx context.Context, req *containerpb.GetClusterRequest) (*containerpb.Cluster, error) { 76 md, _ := metadata.FromIncomingContext(ctx) 77 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 78 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 79 } 80 s.reqs = append(s.reqs, req) 81 if s.err != nil { 82 return nil, s.err 83 } 84 return s.resps[0].(*containerpb.Cluster), nil 85} 86 87func (s *mockClusterManagerServer) CreateCluster(ctx context.Context, req *containerpb.CreateClusterRequest) (*containerpb.Operation, error) { 88 md, _ := metadata.FromIncomingContext(ctx) 89 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 90 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 91 } 92 s.reqs = append(s.reqs, req) 93 if s.err != nil { 94 return nil, s.err 95 } 96 return s.resps[0].(*containerpb.Operation), nil 97} 98 99func (s *mockClusterManagerServer) UpdateCluster(ctx context.Context, req *containerpb.UpdateClusterRequest) (*containerpb.Operation, error) { 100 md, _ := metadata.FromIncomingContext(ctx) 101 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 102 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 103 } 104 s.reqs = append(s.reqs, req) 105 if s.err != nil { 106 return nil, s.err 107 } 108 return s.resps[0].(*containerpb.Operation), nil 109} 110 111func (s *mockClusterManagerServer) UpdateNodePool(ctx context.Context, req *containerpb.UpdateNodePoolRequest) (*containerpb.Operation, error) { 112 md, _ := metadata.FromIncomingContext(ctx) 113 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 114 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 115 } 116 s.reqs = append(s.reqs, req) 117 if s.err != nil { 118 return nil, s.err 119 } 120 return s.resps[0].(*containerpb.Operation), nil 121} 122 123func (s *mockClusterManagerServer) SetNodePoolAutoscaling(ctx context.Context, req *containerpb.SetNodePoolAutoscalingRequest) (*containerpb.Operation, error) { 124 md, _ := metadata.FromIncomingContext(ctx) 125 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 126 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 127 } 128 s.reqs = append(s.reqs, req) 129 if s.err != nil { 130 return nil, s.err 131 } 132 return s.resps[0].(*containerpb.Operation), nil 133} 134 135func (s *mockClusterManagerServer) SetLoggingService(ctx context.Context, req *containerpb.SetLoggingServiceRequest) (*containerpb.Operation, error) { 136 md, _ := metadata.FromIncomingContext(ctx) 137 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 138 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 139 } 140 s.reqs = append(s.reqs, req) 141 if s.err != nil { 142 return nil, s.err 143 } 144 return s.resps[0].(*containerpb.Operation), nil 145} 146 147func (s *mockClusterManagerServer) SetMonitoringService(ctx context.Context, req *containerpb.SetMonitoringServiceRequest) (*containerpb.Operation, error) { 148 md, _ := metadata.FromIncomingContext(ctx) 149 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 150 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 151 } 152 s.reqs = append(s.reqs, req) 153 if s.err != nil { 154 return nil, s.err 155 } 156 return s.resps[0].(*containerpb.Operation), nil 157} 158 159func (s *mockClusterManagerServer) SetAddonsConfig(ctx context.Context, req *containerpb.SetAddonsConfigRequest) (*containerpb.Operation, error) { 160 md, _ := metadata.FromIncomingContext(ctx) 161 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 162 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 163 } 164 s.reqs = append(s.reqs, req) 165 if s.err != nil { 166 return nil, s.err 167 } 168 return s.resps[0].(*containerpb.Operation), nil 169} 170 171func (s *mockClusterManagerServer) SetLocations(ctx context.Context, req *containerpb.SetLocationsRequest) (*containerpb.Operation, error) { 172 md, _ := metadata.FromIncomingContext(ctx) 173 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 174 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 175 } 176 s.reqs = append(s.reqs, req) 177 if s.err != nil { 178 return nil, s.err 179 } 180 return s.resps[0].(*containerpb.Operation), nil 181} 182 183func (s *mockClusterManagerServer) UpdateMaster(ctx context.Context, req *containerpb.UpdateMasterRequest) (*containerpb.Operation, error) { 184 md, _ := metadata.FromIncomingContext(ctx) 185 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 186 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 187 } 188 s.reqs = append(s.reqs, req) 189 if s.err != nil { 190 return nil, s.err 191 } 192 return s.resps[0].(*containerpb.Operation), nil 193} 194 195func (s *mockClusterManagerServer) SetMasterAuth(ctx context.Context, req *containerpb.SetMasterAuthRequest) (*containerpb.Operation, error) { 196 md, _ := metadata.FromIncomingContext(ctx) 197 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 198 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 199 } 200 s.reqs = append(s.reqs, req) 201 if s.err != nil { 202 return nil, s.err 203 } 204 return s.resps[0].(*containerpb.Operation), nil 205} 206 207func (s *mockClusterManagerServer) DeleteCluster(ctx context.Context, req *containerpb.DeleteClusterRequest) (*containerpb.Operation, error) { 208 md, _ := metadata.FromIncomingContext(ctx) 209 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 210 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 211 } 212 s.reqs = append(s.reqs, req) 213 if s.err != nil { 214 return nil, s.err 215 } 216 return s.resps[0].(*containerpb.Operation), nil 217} 218 219func (s *mockClusterManagerServer) ListOperations(ctx context.Context, req *containerpb.ListOperationsRequest) (*containerpb.ListOperationsResponse, error) { 220 md, _ := metadata.FromIncomingContext(ctx) 221 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 222 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 223 } 224 s.reqs = append(s.reqs, req) 225 if s.err != nil { 226 return nil, s.err 227 } 228 return s.resps[0].(*containerpb.ListOperationsResponse), nil 229} 230 231func (s *mockClusterManagerServer) GetOperation(ctx context.Context, req *containerpb.GetOperationRequest) (*containerpb.Operation, error) { 232 md, _ := metadata.FromIncomingContext(ctx) 233 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 234 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 235 } 236 s.reqs = append(s.reqs, req) 237 if s.err != nil { 238 return nil, s.err 239 } 240 return s.resps[0].(*containerpb.Operation), nil 241} 242 243func (s *mockClusterManagerServer) CancelOperation(ctx context.Context, req *containerpb.CancelOperationRequest) (*emptypb.Empty, error) { 244 md, _ := metadata.FromIncomingContext(ctx) 245 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 246 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 247 } 248 s.reqs = append(s.reqs, req) 249 if s.err != nil { 250 return nil, s.err 251 } 252 return s.resps[0].(*emptypb.Empty), nil 253} 254 255func (s *mockClusterManagerServer) GetServerConfig(ctx context.Context, req *containerpb.GetServerConfigRequest) (*containerpb.ServerConfig, error) { 256 md, _ := metadata.FromIncomingContext(ctx) 257 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 258 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 259 } 260 s.reqs = append(s.reqs, req) 261 if s.err != nil { 262 return nil, s.err 263 } 264 return s.resps[0].(*containerpb.ServerConfig), nil 265} 266 267func (s *mockClusterManagerServer) ListNodePools(ctx context.Context, req *containerpb.ListNodePoolsRequest) (*containerpb.ListNodePoolsResponse, error) { 268 md, _ := metadata.FromIncomingContext(ctx) 269 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 270 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 271 } 272 s.reqs = append(s.reqs, req) 273 if s.err != nil { 274 return nil, s.err 275 } 276 return s.resps[0].(*containerpb.ListNodePoolsResponse), nil 277} 278 279func (s *mockClusterManagerServer) GetNodePool(ctx context.Context, req *containerpb.GetNodePoolRequest) (*containerpb.NodePool, error) { 280 md, _ := metadata.FromIncomingContext(ctx) 281 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 282 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 283 } 284 s.reqs = append(s.reqs, req) 285 if s.err != nil { 286 return nil, s.err 287 } 288 return s.resps[0].(*containerpb.NodePool), nil 289} 290 291func (s *mockClusterManagerServer) CreateNodePool(ctx context.Context, req *containerpb.CreateNodePoolRequest) (*containerpb.Operation, error) { 292 md, _ := metadata.FromIncomingContext(ctx) 293 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 294 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 295 } 296 s.reqs = append(s.reqs, req) 297 if s.err != nil { 298 return nil, s.err 299 } 300 return s.resps[0].(*containerpb.Operation), nil 301} 302 303func (s *mockClusterManagerServer) DeleteNodePool(ctx context.Context, req *containerpb.DeleteNodePoolRequest) (*containerpb.Operation, error) { 304 md, _ := metadata.FromIncomingContext(ctx) 305 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 306 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 307 } 308 s.reqs = append(s.reqs, req) 309 if s.err != nil { 310 return nil, s.err 311 } 312 return s.resps[0].(*containerpb.Operation), nil 313} 314 315func (s *mockClusterManagerServer) RollbackNodePoolUpgrade(ctx context.Context, req *containerpb.RollbackNodePoolUpgradeRequest) (*containerpb.Operation, error) { 316 md, _ := metadata.FromIncomingContext(ctx) 317 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 318 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 319 } 320 s.reqs = append(s.reqs, req) 321 if s.err != nil { 322 return nil, s.err 323 } 324 return s.resps[0].(*containerpb.Operation), nil 325} 326 327func (s *mockClusterManagerServer) SetNodePoolManagement(ctx context.Context, req *containerpb.SetNodePoolManagementRequest) (*containerpb.Operation, error) { 328 md, _ := metadata.FromIncomingContext(ctx) 329 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 330 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 331 } 332 s.reqs = append(s.reqs, req) 333 if s.err != nil { 334 return nil, s.err 335 } 336 return s.resps[0].(*containerpb.Operation), nil 337} 338 339func (s *mockClusterManagerServer) SetLabels(ctx context.Context, req *containerpb.SetLabelsRequest) (*containerpb.Operation, error) { 340 md, _ := metadata.FromIncomingContext(ctx) 341 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 342 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 343 } 344 s.reqs = append(s.reqs, req) 345 if s.err != nil { 346 return nil, s.err 347 } 348 return s.resps[0].(*containerpb.Operation), nil 349} 350 351func (s *mockClusterManagerServer) SetLegacyAbac(ctx context.Context, req *containerpb.SetLegacyAbacRequest) (*containerpb.Operation, error) { 352 md, _ := metadata.FromIncomingContext(ctx) 353 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 354 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 355 } 356 s.reqs = append(s.reqs, req) 357 if s.err != nil { 358 return nil, s.err 359 } 360 return s.resps[0].(*containerpb.Operation), nil 361} 362 363func (s *mockClusterManagerServer) StartIPRotation(ctx context.Context, req *containerpb.StartIPRotationRequest) (*containerpb.Operation, error) { 364 md, _ := metadata.FromIncomingContext(ctx) 365 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 366 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 367 } 368 s.reqs = append(s.reqs, req) 369 if s.err != nil { 370 return nil, s.err 371 } 372 return s.resps[0].(*containerpb.Operation), nil 373} 374 375func (s *mockClusterManagerServer) CompleteIPRotation(ctx context.Context, req *containerpb.CompleteIPRotationRequest) (*containerpb.Operation, error) { 376 md, _ := metadata.FromIncomingContext(ctx) 377 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 378 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 379 } 380 s.reqs = append(s.reqs, req) 381 if s.err != nil { 382 return nil, s.err 383 } 384 return s.resps[0].(*containerpb.Operation), nil 385} 386 387func (s *mockClusterManagerServer) SetNodePoolSize(ctx context.Context, req *containerpb.SetNodePoolSizeRequest) (*containerpb.Operation, error) { 388 md, _ := metadata.FromIncomingContext(ctx) 389 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 390 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 391 } 392 s.reqs = append(s.reqs, req) 393 if s.err != nil { 394 return nil, s.err 395 } 396 return s.resps[0].(*containerpb.Operation), nil 397} 398 399func (s *mockClusterManagerServer) SetNetworkPolicy(ctx context.Context, req *containerpb.SetNetworkPolicyRequest) (*containerpb.Operation, error) { 400 md, _ := metadata.FromIncomingContext(ctx) 401 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 402 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 403 } 404 s.reqs = append(s.reqs, req) 405 if s.err != nil { 406 return nil, s.err 407 } 408 return s.resps[0].(*containerpb.Operation), nil 409} 410 411func (s *mockClusterManagerServer) SetMaintenancePolicy(ctx context.Context, req *containerpb.SetMaintenancePolicyRequest) (*containerpb.Operation, error) { 412 md, _ := metadata.FromIncomingContext(ctx) 413 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 414 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 415 } 416 s.reqs = append(s.reqs, req) 417 if s.err != nil { 418 return nil, s.err 419 } 420 return s.resps[0].(*containerpb.Operation), nil 421} 422 423// clientOpt is the option tests should use to connect to the test server. 424// It is initialized by TestMain. 425var clientOpt option.ClientOption 426 427var ( 428 mockClusterManager mockClusterManagerServer 429) 430 431func TestMain(m *testing.M) { 432 flag.Parse() 433 434 serv := grpc.NewServer() 435 containerpb.RegisterClusterManagerServer(serv, &mockClusterManager) 436 437 lis, err := net.Listen("tcp", "localhost:0") 438 if err != nil { 439 log.Fatal(err) 440 } 441 go serv.Serve(lis) 442 443 conn, err := grpc.Dial(lis.Addr().String(), grpc.WithInsecure()) 444 if err != nil { 445 log.Fatal(err) 446 } 447 clientOpt = option.WithGRPCConn(conn) 448 449 os.Exit(m.Run()) 450} 451 452func TestClusterManagerListClusters(t *testing.T) { 453 var expectedResponse *containerpb.ListClustersResponse = &containerpb.ListClustersResponse{} 454 455 mockClusterManager.err = nil 456 mockClusterManager.reqs = nil 457 458 mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse) 459 460 var projectId string = "projectId-1969970175" 461 var zone string = "zone3744684" 462 var request = &containerpb.ListClustersRequest{ 463 ProjectId: projectId, 464 Zone: zone, 465 } 466 467 c, err := NewClusterManagerClient(context.Background(), clientOpt) 468 if err != nil { 469 t.Fatal(err) 470 } 471 472 resp, err := c.ListClusters(context.Background(), request) 473 474 if err != nil { 475 t.Fatal(err) 476 } 477 478 if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) { 479 t.Errorf("wrong request %q, want %q", got, want) 480 } 481 482 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 483 t.Errorf("wrong response %q, want %q)", got, want) 484 } 485} 486 487func TestClusterManagerListClustersError(t *testing.T) { 488 errCode := codes.PermissionDenied 489 mockClusterManager.err = gstatus.Error(errCode, "test error") 490 491 var projectId string = "projectId-1969970175" 492 var zone string = "zone3744684" 493 var request = &containerpb.ListClustersRequest{ 494 ProjectId: projectId, 495 Zone: zone, 496 } 497 498 c, err := NewClusterManagerClient(context.Background(), clientOpt) 499 if err != nil { 500 t.Fatal(err) 501 } 502 503 resp, err := c.ListClusters(context.Background(), request) 504 505 if st, ok := gstatus.FromError(err); !ok { 506 t.Errorf("got error %v, expected grpc error", err) 507 } else if c := st.Code(); c != errCode { 508 t.Errorf("got error code %q, want %q", c, errCode) 509 } 510 _ = resp 511} 512func TestClusterManagerGetCluster(t *testing.T) { 513 var name string = "name3373707" 514 var description string = "description-1724546052" 515 var initialNodeCount int32 = 1682564205 516 var loggingService string = "loggingService-1700501035" 517 var monitoringService string = "monitoringService1469270462" 518 var network string = "network1843485230" 519 var clusterIpv4Cidr string = "clusterIpv4Cidr-141875831" 520 var subnetwork string = "subnetwork-1302785042" 521 var enableKubernetesAlpha bool = false 522 var labelFingerprint string = "labelFingerprint714995737" 523 var selfLink string = "selfLink-1691268851" 524 var zone2 string = "zone2-696322977" 525 var endpoint string = "endpoint1741102485" 526 var initialClusterVersion string = "initialClusterVersion-276373352" 527 var currentMasterVersion string = "currentMasterVersion-920953983" 528 var currentNodeVersion string = "currentNodeVersion-407476063" 529 var createTime string = "createTime-493574096" 530 var statusMessage string = "statusMessage-239442758" 531 var nodeIpv4CidrSize int32 = 1181176815 532 var servicesIpv4Cidr string = "servicesIpv4Cidr1966438125" 533 var currentNodeCount int32 = 178977560 534 var expireTime string = "expireTime-96179731" 535 var expectedResponse = &containerpb.Cluster{ 536 Name: name, 537 Description: description, 538 InitialNodeCount: initialNodeCount, 539 LoggingService: loggingService, 540 MonitoringService: monitoringService, 541 Network: network, 542 ClusterIpv4Cidr: clusterIpv4Cidr, 543 Subnetwork: subnetwork, 544 EnableKubernetesAlpha: enableKubernetesAlpha, 545 LabelFingerprint: labelFingerprint, 546 SelfLink: selfLink, 547 Zone: zone2, 548 Endpoint: endpoint, 549 InitialClusterVersion: initialClusterVersion, 550 CurrentMasterVersion: currentMasterVersion, 551 CurrentNodeVersion: currentNodeVersion, 552 CreateTime: createTime, 553 StatusMessage: statusMessage, 554 NodeIpv4CidrSize: nodeIpv4CidrSize, 555 ServicesIpv4Cidr: servicesIpv4Cidr, 556 CurrentNodeCount: currentNodeCount, 557 ExpireTime: expireTime, 558 } 559 560 mockClusterManager.err = nil 561 mockClusterManager.reqs = nil 562 563 mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse) 564 565 var projectId string = "projectId-1969970175" 566 var zone string = "zone3744684" 567 var clusterId string = "clusterId240280960" 568 var request = &containerpb.GetClusterRequest{ 569 ProjectId: projectId, 570 Zone: zone, 571 ClusterId: clusterId, 572 } 573 574 c, err := NewClusterManagerClient(context.Background(), clientOpt) 575 if err != nil { 576 t.Fatal(err) 577 } 578 579 resp, err := c.GetCluster(context.Background(), request) 580 581 if err != nil { 582 t.Fatal(err) 583 } 584 585 if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) { 586 t.Errorf("wrong request %q, want %q", got, want) 587 } 588 589 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 590 t.Errorf("wrong response %q, want %q)", got, want) 591 } 592} 593 594func TestClusterManagerGetClusterError(t *testing.T) { 595 errCode := codes.PermissionDenied 596 mockClusterManager.err = gstatus.Error(errCode, "test error") 597 598 var projectId string = "projectId-1969970175" 599 var zone string = "zone3744684" 600 var clusterId string = "clusterId240280960" 601 var request = &containerpb.GetClusterRequest{ 602 ProjectId: projectId, 603 Zone: zone, 604 ClusterId: clusterId, 605 } 606 607 c, err := NewClusterManagerClient(context.Background(), clientOpt) 608 if err != nil { 609 t.Fatal(err) 610 } 611 612 resp, err := c.GetCluster(context.Background(), request) 613 614 if st, ok := gstatus.FromError(err); !ok { 615 t.Errorf("got error %v, expected grpc error", err) 616 } else if c := st.Code(); c != errCode { 617 t.Errorf("got error code %q, want %q", c, errCode) 618 } 619 _ = resp 620} 621func TestClusterManagerCreateCluster(t *testing.T) { 622 var name string = "name3373707" 623 var zone2 string = "zone2-696322977" 624 var detail string = "detail-1335224239" 625 var statusMessage string = "statusMessage-239442758" 626 var selfLink string = "selfLink-1691268851" 627 var targetLink string = "targetLink-2084812312" 628 var startTime string = "startTime-1573145462" 629 var endTime string = "endTime1725551537" 630 var expectedResponse = &containerpb.Operation{ 631 Name: name, 632 Zone: zone2, 633 Detail: detail, 634 StatusMessage: statusMessage, 635 SelfLink: selfLink, 636 TargetLink: targetLink, 637 StartTime: startTime, 638 EndTime: endTime, 639 } 640 641 mockClusterManager.err = nil 642 mockClusterManager.reqs = nil 643 644 mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse) 645 646 var projectId string = "projectId-1969970175" 647 var zone string = "zone3744684" 648 var cluster *containerpb.Cluster = &containerpb.Cluster{} 649 var request = &containerpb.CreateClusterRequest{ 650 ProjectId: projectId, 651 Zone: zone, 652 Cluster: cluster, 653 } 654 655 c, err := NewClusterManagerClient(context.Background(), clientOpt) 656 if err != nil { 657 t.Fatal(err) 658 } 659 660 resp, err := c.CreateCluster(context.Background(), request) 661 662 if err != nil { 663 t.Fatal(err) 664 } 665 666 if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) { 667 t.Errorf("wrong request %q, want %q", got, want) 668 } 669 670 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 671 t.Errorf("wrong response %q, want %q)", got, want) 672 } 673} 674 675func TestClusterManagerCreateClusterError(t *testing.T) { 676 errCode := codes.PermissionDenied 677 mockClusterManager.err = gstatus.Error(errCode, "test error") 678 679 var projectId string = "projectId-1969970175" 680 var zone string = "zone3744684" 681 var cluster *containerpb.Cluster = &containerpb.Cluster{} 682 var request = &containerpb.CreateClusterRequest{ 683 ProjectId: projectId, 684 Zone: zone, 685 Cluster: cluster, 686 } 687 688 c, err := NewClusterManagerClient(context.Background(), clientOpt) 689 if err != nil { 690 t.Fatal(err) 691 } 692 693 resp, err := c.CreateCluster(context.Background(), request) 694 695 if st, ok := gstatus.FromError(err); !ok { 696 t.Errorf("got error %v, expected grpc error", err) 697 } else if c := st.Code(); c != errCode { 698 t.Errorf("got error code %q, want %q", c, errCode) 699 } 700 _ = resp 701} 702func TestClusterManagerUpdateCluster(t *testing.T) { 703 var name string = "name3373707" 704 var zone2 string = "zone2-696322977" 705 var detail string = "detail-1335224239" 706 var statusMessage string = "statusMessage-239442758" 707 var selfLink string = "selfLink-1691268851" 708 var targetLink string = "targetLink-2084812312" 709 var startTime string = "startTime-1573145462" 710 var endTime string = "endTime1725551537" 711 var expectedResponse = &containerpb.Operation{ 712 Name: name, 713 Zone: zone2, 714 Detail: detail, 715 StatusMessage: statusMessage, 716 SelfLink: selfLink, 717 TargetLink: targetLink, 718 StartTime: startTime, 719 EndTime: endTime, 720 } 721 722 mockClusterManager.err = nil 723 mockClusterManager.reqs = nil 724 725 mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse) 726 727 var projectId string = "projectId-1969970175" 728 var zone string = "zone3744684" 729 var clusterId string = "clusterId240280960" 730 var update *containerpb.ClusterUpdate = &containerpb.ClusterUpdate{} 731 var request = &containerpb.UpdateClusterRequest{ 732 ProjectId: projectId, 733 Zone: zone, 734 ClusterId: clusterId, 735 Update: update, 736 } 737 738 c, err := NewClusterManagerClient(context.Background(), clientOpt) 739 if err != nil { 740 t.Fatal(err) 741 } 742 743 resp, err := c.UpdateCluster(context.Background(), request) 744 745 if err != nil { 746 t.Fatal(err) 747 } 748 749 if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) { 750 t.Errorf("wrong request %q, want %q", got, want) 751 } 752 753 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 754 t.Errorf("wrong response %q, want %q)", got, want) 755 } 756} 757 758func TestClusterManagerUpdateClusterError(t *testing.T) { 759 errCode := codes.PermissionDenied 760 mockClusterManager.err = gstatus.Error(errCode, "test error") 761 762 var projectId string = "projectId-1969970175" 763 var zone string = "zone3744684" 764 var clusterId string = "clusterId240280960" 765 var update *containerpb.ClusterUpdate = &containerpb.ClusterUpdate{} 766 var request = &containerpb.UpdateClusterRequest{ 767 ProjectId: projectId, 768 Zone: zone, 769 ClusterId: clusterId, 770 Update: update, 771 } 772 773 c, err := NewClusterManagerClient(context.Background(), clientOpt) 774 if err != nil { 775 t.Fatal(err) 776 } 777 778 resp, err := c.UpdateCluster(context.Background(), request) 779 780 if st, ok := gstatus.FromError(err); !ok { 781 t.Errorf("got error %v, expected grpc error", err) 782 } else if c := st.Code(); c != errCode { 783 t.Errorf("got error code %q, want %q", c, errCode) 784 } 785 _ = resp 786} 787func TestClusterManagerUpdateNodePool(t *testing.T) { 788 var name string = "name3373707" 789 var zone2 string = "zone2-696322977" 790 var detail string = "detail-1335224239" 791 var statusMessage string = "statusMessage-239442758" 792 var selfLink string = "selfLink-1691268851" 793 var targetLink string = "targetLink-2084812312" 794 var startTime string = "startTime-1573145462" 795 var endTime string = "endTime1725551537" 796 var expectedResponse = &containerpb.Operation{ 797 Name: name, 798 Zone: zone2, 799 Detail: detail, 800 StatusMessage: statusMessage, 801 SelfLink: selfLink, 802 TargetLink: targetLink, 803 StartTime: startTime, 804 EndTime: endTime, 805 } 806 807 mockClusterManager.err = nil 808 mockClusterManager.reqs = nil 809 810 mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse) 811 812 var projectId string = "projectId-1969970175" 813 var zone string = "zone3744684" 814 var clusterId string = "clusterId240280960" 815 var nodePoolId string = "nodePoolId1043384033" 816 var nodeVersion string = "nodeVersion1790136219" 817 var imageType string = "imageType-1442758754" 818 var request = &containerpb.UpdateNodePoolRequest{ 819 ProjectId: projectId, 820 Zone: zone, 821 ClusterId: clusterId, 822 NodePoolId: nodePoolId, 823 NodeVersion: nodeVersion, 824 ImageType: imageType, 825 } 826 827 c, err := NewClusterManagerClient(context.Background(), clientOpt) 828 if err != nil { 829 t.Fatal(err) 830 } 831 832 resp, err := c.UpdateNodePool(context.Background(), request) 833 834 if err != nil { 835 t.Fatal(err) 836 } 837 838 if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) { 839 t.Errorf("wrong request %q, want %q", got, want) 840 } 841 842 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 843 t.Errorf("wrong response %q, want %q)", got, want) 844 } 845} 846 847func TestClusterManagerUpdateNodePoolError(t *testing.T) { 848 errCode := codes.PermissionDenied 849 mockClusterManager.err = gstatus.Error(errCode, "test error") 850 851 var projectId string = "projectId-1969970175" 852 var zone string = "zone3744684" 853 var clusterId string = "clusterId240280960" 854 var nodePoolId string = "nodePoolId1043384033" 855 var nodeVersion string = "nodeVersion1790136219" 856 var imageType string = "imageType-1442758754" 857 var request = &containerpb.UpdateNodePoolRequest{ 858 ProjectId: projectId, 859 Zone: zone, 860 ClusterId: clusterId, 861 NodePoolId: nodePoolId, 862 NodeVersion: nodeVersion, 863 ImageType: imageType, 864 } 865 866 c, err := NewClusterManagerClient(context.Background(), clientOpt) 867 if err != nil { 868 t.Fatal(err) 869 } 870 871 resp, err := c.UpdateNodePool(context.Background(), request) 872 873 if st, ok := gstatus.FromError(err); !ok { 874 t.Errorf("got error %v, expected grpc error", err) 875 } else if c := st.Code(); c != errCode { 876 t.Errorf("got error code %q, want %q", c, errCode) 877 } 878 _ = resp 879} 880func TestClusterManagerSetNodePoolAutoscaling(t *testing.T) { 881 var name string = "name3373707" 882 var zone2 string = "zone2-696322977" 883 var detail string = "detail-1335224239" 884 var statusMessage string = "statusMessage-239442758" 885 var selfLink string = "selfLink-1691268851" 886 var targetLink string = "targetLink-2084812312" 887 var startTime string = "startTime-1573145462" 888 var endTime string = "endTime1725551537" 889 var expectedResponse = &containerpb.Operation{ 890 Name: name, 891 Zone: zone2, 892 Detail: detail, 893 StatusMessage: statusMessage, 894 SelfLink: selfLink, 895 TargetLink: targetLink, 896 StartTime: startTime, 897 EndTime: endTime, 898 } 899 900 mockClusterManager.err = nil 901 mockClusterManager.reqs = nil 902 903 mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse) 904 905 var projectId string = "projectId-1969970175" 906 var zone string = "zone3744684" 907 var clusterId string = "clusterId240280960" 908 var nodePoolId string = "nodePoolId1043384033" 909 var autoscaling *containerpb.NodePoolAutoscaling = &containerpb.NodePoolAutoscaling{} 910 var request = &containerpb.SetNodePoolAutoscalingRequest{ 911 ProjectId: projectId, 912 Zone: zone, 913 ClusterId: clusterId, 914 NodePoolId: nodePoolId, 915 Autoscaling: autoscaling, 916 } 917 918 c, err := NewClusterManagerClient(context.Background(), clientOpt) 919 if err != nil { 920 t.Fatal(err) 921 } 922 923 resp, err := c.SetNodePoolAutoscaling(context.Background(), request) 924 925 if err != nil { 926 t.Fatal(err) 927 } 928 929 if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) { 930 t.Errorf("wrong request %q, want %q", got, want) 931 } 932 933 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 934 t.Errorf("wrong response %q, want %q)", got, want) 935 } 936} 937 938func TestClusterManagerSetNodePoolAutoscalingError(t *testing.T) { 939 errCode := codes.PermissionDenied 940 mockClusterManager.err = gstatus.Error(errCode, "test error") 941 942 var projectId string = "projectId-1969970175" 943 var zone string = "zone3744684" 944 var clusterId string = "clusterId240280960" 945 var nodePoolId string = "nodePoolId1043384033" 946 var autoscaling *containerpb.NodePoolAutoscaling = &containerpb.NodePoolAutoscaling{} 947 var request = &containerpb.SetNodePoolAutoscalingRequest{ 948 ProjectId: projectId, 949 Zone: zone, 950 ClusterId: clusterId, 951 NodePoolId: nodePoolId, 952 Autoscaling: autoscaling, 953 } 954 955 c, err := NewClusterManagerClient(context.Background(), clientOpt) 956 if err != nil { 957 t.Fatal(err) 958 } 959 960 resp, err := c.SetNodePoolAutoscaling(context.Background(), request) 961 962 if st, ok := gstatus.FromError(err); !ok { 963 t.Errorf("got error %v, expected grpc error", err) 964 } else if c := st.Code(); c != errCode { 965 t.Errorf("got error code %q, want %q", c, errCode) 966 } 967 _ = resp 968} 969func TestClusterManagerSetLoggingService(t *testing.T) { 970 var name string = "name3373707" 971 var zone2 string = "zone2-696322977" 972 var detail string = "detail-1335224239" 973 var statusMessage string = "statusMessage-239442758" 974 var selfLink string = "selfLink-1691268851" 975 var targetLink string = "targetLink-2084812312" 976 var startTime string = "startTime-1573145462" 977 var endTime string = "endTime1725551537" 978 var expectedResponse = &containerpb.Operation{ 979 Name: name, 980 Zone: zone2, 981 Detail: detail, 982 StatusMessage: statusMessage, 983 SelfLink: selfLink, 984 TargetLink: targetLink, 985 StartTime: startTime, 986 EndTime: endTime, 987 } 988 989 mockClusterManager.err = nil 990 mockClusterManager.reqs = nil 991 992 mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse) 993 994 var projectId string = "projectId-1969970175" 995 var zone string = "zone3744684" 996 var clusterId string = "clusterId240280960" 997 var loggingService string = "loggingService-1700501035" 998 var request = &containerpb.SetLoggingServiceRequest{ 999 ProjectId: projectId, 1000 Zone: zone, 1001 ClusterId: clusterId, 1002 LoggingService: loggingService, 1003 } 1004 1005 c, err := NewClusterManagerClient(context.Background(), clientOpt) 1006 if err != nil { 1007 t.Fatal(err) 1008 } 1009 1010 resp, err := c.SetLoggingService(context.Background(), request) 1011 1012 if err != nil { 1013 t.Fatal(err) 1014 } 1015 1016 if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) { 1017 t.Errorf("wrong request %q, want %q", got, want) 1018 } 1019 1020 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1021 t.Errorf("wrong response %q, want %q)", got, want) 1022 } 1023} 1024 1025func TestClusterManagerSetLoggingServiceError(t *testing.T) { 1026 errCode := codes.PermissionDenied 1027 mockClusterManager.err = gstatus.Error(errCode, "test error") 1028 1029 var projectId string = "projectId-1969970175" 1030 var zone string = "zone3744684" 1031 var clusterId string = "clusterId240280960" 1032 var loggingService string = "loggingService-1700501035" 1033 var request = &containerpb.SetLoggingServiceRequest{ 1034 ProjectId: projectId, 1035 Zone: zone, 1036 ClusterId: clusterId, 1037 LoggingService: loggingService, 1038 } 1039 1040 c, err := NewClusterManagerClient(context.Background(), clientOpt) 1041 if err != nil { 1042 t.Fatal(err) 1043 } 1044 1045 resp, err := c.SetLoggingService(context.Background(), request) 1046 1047 if st, ok := gstatus.FromError(err); !ok { 1048 t.Errorf("got error %v, expected grpc error", err) 1049 } else if c := st.Code(); c != errCode { 1050 t.Errorf("got error code %q, want %q", c, errCode) 1051 } 1052 _ = resp 1053} 1054func TestClusterManagerSetMonitoringService(t *testing.T) { 1055 var name string = "name3373707" 1056 var zone2 string = "zone2-696322977" 1057 var detail string = "detail-1335224239" 1058 var statusMessage string = "statusMessage-239442758" 1059 var selfLink string = "selfLink-1691268851" 1060 var targetLink string = "targetLink-2084812312" 1061 var startTime string = "startTime-1573145462" 1062 var endTime string = "endTime1725551537" 1063 var expectedResponse = &containerpb.Operation{ 1064 Name: name, 1065 Zone: zone2, 1066 Detail: detail, 1067 StatusMessage: statusMessage, 1068 SelfLink: selfLink, 1069 TargetLink: targetLink, 1070 StartTime: startTime, 1071 EndTime: endTime, 1072 } 1073 1074 mockClusterManager.err = nil 1075 mockClusterManager.reqs = nil 1076 1077 mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse) 1078 1079 var projectId string = "projectId-1969970175" 1080 var zone string = "zone3744684" 1081 var clusterId string = "clusterId240280960" 1082 var monitoringService string = "monitoringService1469270462" 1083 var request = &containerpb.SetMonitoringServiceRequest{ 1084 ProjectId: projectId, 1085 Zone: zone, 1086 ClusterId: clusterId, 1087 MonitoringService: monitoringService, 1088 } 1089 1090 c, err := NewClusterManagerClient(context.Background(), clientOpt) 1091 if err != nil { 1092 t.Fatal(err) 1093 } 1094 1095 resp, err := c.SetMonitoringService(context.Background(), request) 1096 1097 if err != nil { 1098 t.Fatal(err) 1099 } 1100 1101 if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) { 1102 t.Errorf("wrong request %q, want %q", got, want) 1103 } 1104 1105 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1106 t.Errorf("wrong response %q, want %q)", got, want) 1107 } 1108} 1109 1110func TestClusterManagerSetMonitoringServiceError(t *testing.T) { 1111 errCode := codes.PermissionDenied 1112 mockClusterManager.err = gstatus.Error(errCode, "test error") 1113 1114 var projectId string = "projectId-1969970175" 1115 var zone string = "zone3744684" 1116 var clusterId string = "clusterId240280960" 1117 var monitoringService string = "monitoringService1469270462" 1118 var request = &containerpb.SetMonitoringServiceRequest{ 1119 ProjectId: projectId, 1120 Zone: zone, 1121 ClusterId: clusterId, 1122 MonitoringService: monitoringService, 1123 } 1124 1125 c, err := NewClusterManagerClient(context.Background(), clientOpt) 1126 if err != nil { 1127 t.Fatal(err) 1128 } 1129 1130 resp, err := c.SetMonitoringService(context.Background(), request) 1131 1132 if st, ok := gstatus.FromError(err); !ok { 1133 t.Errorf("got error %v, expected grpc error", err) 1134 } else if c := st.Code(); c != errCode { 1135 t.Errorf("got error code %q, want %q", c, errCode) 1136 } 1137 _ = resp 1138} 1139func TestClusterManagerSetAddonsConfig(t *testing.T) { 1140 var name string = "name3373707" 1141 var zone2 string = "zone2-696322977" 1142 var detail string = "detail-1335224239" 1143 var statusMessage string = "statusMessage-239442758" 1144 var selfLink string = "selfLink-1691268851" 1145 var targetLink string = "targetLink-2084812312" 1146 var startTime string = "startTime-1573145462" 1147 var endTime string = "endTime1725551537" 1148 var expectedResponse = &containerpb.Operation{ 1149 Name: name, 1150 Zone: zone2, 1151 Detail: detail, 1152 StatusMessage: statusMessage, 1153 SelfLink: selfLink, 1154 TargetLink: targetLink, 1155 StartTime: startTime, 1156 EndTime: endTime, 1157 } 1158 1159 mockClusterManager.err = nil 1160 mockClusterManager.reqs = nil 1161 1162 mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse) 1163 1164 var projectId string = "projectId-1969970175" 1165 var zone string = "zone3744684" 1166 var clusterId string = "clusterId240280960" 1167 var addonsConfig *containerpb.AddonsConfig = &containerpb.AddonsConfig{} 1168 var request = &containerpb.SetAddonsConfigRequest{ 1169 ProjectId: projectId, 1170 Zone: zone, 1171 ClusterId: clusterId, 1172 AddonsConfig: addonsConfig, 1173 } 1174 1175 c, err := NewClusterManagerClient(context.Background(), clientOpt) 1176 if err != nil { 1177 t.Fatal(err) 1178 } 1179 1180 resp, err := c.SetAddonsConfig(context.Background(), request) 1181 1182 if err != nil { 1183 t.Fatal(err) 1184 } 1185 1186 if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) { 1187 t.Errorf("wrong request %q, want %q", got, want) 1188 } 1189 1190 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1191 t.Errorf("wrong response %q, want %q)", got, want) 1192 } 1193} 1194 1195func TestClusterManagerSetAddonsConfigError(t *testing.T) { 1196 errCode := codes.PermissionDenied 1197 mockClusterManager.err = gstatus.Error(errCode, "test error") 1198 1199 var projectId string = "projectId-1969970175" 1200 var zone string = "zone3744684" 1201 var clusterId string = "clusterId240280960" 1202 var addonsConfig *containerpb.AddonsConfig = &containerpb.AddonsConfig{} 1203 var request = &containerpb.SetAddonsConfigRequest{ 1204 ProjectId: projectId, 1205 Zone: zone, 1206 ClusterId: clusterId, 1207 AddonsConfig: addonsConfig, 1208 } 1209 1210 c, err := NewClusterManagerClient(context.Background(), clientOpt) 1211 if err != nil { 1212 t.Fatal(err) 1213 } 1214 1215 resp, err := c.SetAddonsConfig(context.Background(), request) 1216 1217 if st, ok := gstatus.FromError(err); !ok { 1218 t.Errorf("got error %v, expected grpc error", err) 1219 } else if c := st.Code(); c != errCode { 1220 t.Errorf("got error code %q, want %q", c, errCode) 1221 } 1222 _ = resp 1223} 1224func TestClusterManagerSetLocations(t *testing.T) { 1225 var name string = "name3373707" 1226 var zone2 string = "zone2-696322977" 1227 var detail string = "detail-1335224239" 1228 var statusMessage string = "statusMessage-239442758" 1229 var selfLink string = "selfLink-1691268851" 1230 var targetLink string = "targetLink-2084812312" 1231 var startTime string = "startTime-1573145462" 1232 var endTime string = "endTime1725551537" 1233 var expectedResponse = &containerpb.Operation{ 1234 Name: name, 1235 Zone: zone2, 1236 Detail: detail, 1237 StatusMessage: statusMessage, 1238 SelfLink: selfLink, 1239 TargetLink: targetLink, 1240 StartTime: startTime, 1241 EndTime: endTime, 1242 } 1243 1244 mockClusterManager.err = nil 1245 mockClusterManager.reqs = nil 1246 1247 mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse) 1248 1249 var projectId string = "projectId-1969970175" 1250 var zone string = "zone3744684" 1251 var clusterId string = "clusterId240280960" 1252 var locations []string = nil 1253 var request = &containerpb.SetLocationsRequest{ 1254 ProjectId: projectId, 1255 Zone: zone, 1256 ClusterId: clusterId, 1257 Locations: locations, 1258 } 1259 1260 c, err := NewClusterManagerClient(context.Background(), clientOpt) 1261 if err != nil { 1262 t.Fatal(err) 1263 } 1264 1265 resp, err := c.SetLocations(context.Background(), request) 1266 1267 if err != nil { 1268 t.Fatal(err) 1269 } 1270 1271 if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) { 1272 t.Errorf("wrong request %q, want %q", got, want) 1273 } 1274 1275 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1276 t.Errorf("wrong response %q, want %q)", got, want) 1277 } 1278} 1279 1280func TestClusterManagerSetLocationsError(t *testing.T) { 1281 errCode := codes.PermissionDenied 1282 mockClusterManager.err = gstatus.Error(errCode, "test error") 1283 1284 var projectId string = "projectId-1969970175" 1285 var zone string = "zone3744684" 1286 var clusterId string = "clusterId240280960" 1287 var locations []string = nil 1288 var request = &containerpb.SetLocationsRequest{ 1289 ProjectId: projectId, 1290 Zone: zone, 1291 ClusterId: clusterId, 1292 Locations: locations, 1293 } 1294 1295 c, err := NewClusterManagerClient(context.Background(), clientOpt) 1296 if err != nil { 1297 t.Fatal(err) 1298 } 1299 1300 resp, err := c.SetLocations(context.Background(), request) 1301 1302 if st, ok := gstatus.FromError(err); !ok { 1303 t.Errorf("got error %v, expected grpc error", err) 1304 } else if c := st.Code(); c != errCode { 1305 t.Errorf("got error code %q, want %q", c, errCode) 1306 } 1307 _ = resp 1308} 1309func TestClusterManagerUpdateMaster(t *testing.T) { 1310 var name string = "name3373707" 1311 var zone2 string = "zone2-696322977" 1312 var detail string = "detail-1335224239" 1313 var statusMessage string = "statusMessage-239442758" 1314 var selfLink string = "selfLink-1691268851" 1315 var targetLink string = "targetLink-2084812312" 1316 var startTime string = "startTime-1573145462" 1317 var endTime string = "endTime1725551537" 1318 var expectedResponse = &containerpb.Operation{ 1319 Name: name, 1320 Zone: zone2, 1321 Detail: detail, 1322 StatusMessage: statusMessage, 1323 SelfLink: selfLink, 1324 TargetLink: targetLink, 1325 StartTime: startTime, 1326 EndTime: endTime, 1327 } 1328 1329 mockClusterManager.err = nil 1330 mockClusterManager.reqs = nil 1331 1332 mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse) 1333 1334 var projectId string = "projectId-1969970175" 1335 var zone string = "zone3744684" 1336 var clusterId string = "clusterId240280960" 1337 var masterVersion string = "masterVersion-2139460613" 1338 var request = &containerpb.UpdateMasterRequest{ 1339 ProjectId: projectId, 1340 Zone: zone, 1341 ClusterId: clusterId, 1342 MasterVersion: masterVersion, 1343 } 1344 1345 c, err := NewClusterManagerClient(context.Background(), clientOpt) 1346 if err != nil { 1347 t.Fatal(err) 1348 } 1349 1350 resp, err := c.UpdateMaster(context.Background(), request) 1351 1352 if err != nil { 1353 t.Fatal(err) 1354 } 1355 1356 if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) { 1357 t.Errorf("wrong request %q, want %q", got, want) 1358 } 1359 1360 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1361 t.Errorf("wrong response %q, want %q)", got, want) 1362 } 1363} 1364 1365func TestClusterManagerUpdateMasterError(t *testing.T) { 1366 errCode := codes.PermissionDenied 1367 mockClusterManager.err = gstatus.Error(errCode, "test error") 1368 1369 var projectId string = "projectId-1969970175" 1370 var zone string = "zone3744684" 1371 var clusterId string = "clusterId240280960" 1372 var masterVersion string = "masterVersion-2139460613" 1373 var request = &containerpb.UpdateMasterRequest{ 1374 ProjectId: projectId, 1375 Zone: zone, 1376 ClusterId: clusterId, 1377 MasterVersion: masterVersion, 1378 } 1379 1380 c, err := NewClusterManagerClient(context.Background(), clientOpt) 1381 if err != nil { 1382 t.Fatal(err) 1383 } 1384 1385 resp, err := c.UpdateMaster(context.Background(), request) 1386 1387 if st, ok := gstatus.FromError(err); !ok { 1388 t.Errorf("got error %v, expected grpc error", err) 1389 } else if c := st.Code(); c != errCode { 1390 t.Errorf("got error code %q, want %q", c, errCode) 1391 } 1392 _ = resp 1393} 1394func TestClusterManagerSetMasterAuth(t *testing.T) { 1395 var name string = "name3373707" 1396 var zone2 string = "zone2-696322977" 1397 var detail string = "detail-1335224239" 1398 var statusMessage string = "statusMessage-239442758" 1399 var selfLink string = "selfLink-1691268851" 1400 var targetLink string = "targetLink-2084812312" 1401 var startTime string = "startTime-1573145462" 1402 var endTime string = "endTime1725551537" 1403 var expectedResponse = &containerpb.Operation{ 1404 Name: name, 1405 Zone: zone2, 1406 Detail: detail, 1407 StatusMessage: statusMessage, 1408 SelfLink: selfLink, 1409 TargetLink: targetLink, 1410 StartTime: startTime, 1411 EndTime: endTime, 1412 } 1413 1414 mockClusterManager.err = nil 1415 mockClusterManager.reqs = nil 1416 1417 mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse) 1418 1419 var projectId string = "projectId-1969970175" 1420 var zone string = "zone3744684" 1421 var clusterId string = "clusterId240280960" 1422 var action containerpb.SetMasterAuthRequest_Action = containerpb.SetMasterAuthRequest_UNKNOWN 1423 var update *containerpb.MasterAuth = &containerpb.MasterAuth{} 1424 var request = &containerpb.SetMasterAuthRequest{ 1425 ProjectId: projectId, 1426 Zone: zone, 1427 ClusterId: clusterId, 1428 Action: action, 1429 Update: update, 1430 } 1431 1432 c, err := NewClusterManagerClient(context.Background(), clientOpt) 1433 if err != nil { 1434 t.Fatal(err) 1435 } 1436 1437 resp, err := c.SetMasterAuth(context.Background(), request) 1438 1439 if err != nil { 1440 t.Fatal(err) 1441 } 1442 1443 if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) { 1444 t.Errorf("wrong request %q, want %q", got, want) 1445 } 1446 1447 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1448 t.Errorf("wrong response %q, want %q)", got, want) 1449 } 1450} 1451 1452func TestClusterManagerSetMasterAuthError(t *testing.T) { 1453 errCode := codes.PermissionDenied 1454 mockClusterManager.err = gstatus.Error(errCode, "test error") 1455 1456 var projectId string = "projectId-1969970175" 1457 var zone string = "zone3744684" 1458 var clusterId string = "clusterId240280960" 1459 var action containerpb.SetMasterAuthRequest_Action = containerpb.SetMasterAuthRequest_UNKNOWN 1460 var update *containerpb.MasterAuth = &containerpb.MasterAuth{} 1461 var request = &containerpb.SetMasterAuthRequest{ 1462 ProjectId: projectId, 1463 Zone: zone, 1464 ClusterId: clusterId, 1465 Action: action, 1466 Update: update, 1467 } 1468 1469 c, err := NewClusterManagerClient(context.Background(), clientOpt) 1470 if err != nil { 1471 t.Fatal(err) 1472 } 1473 1474 resp, err := c.SetMasterAuth(context.Background(), request) 1475 1476 if st, ok := gstatus.FromError(err); !ok { 1477 t.Errorf("got error %v, expected grpc error", err) 1478 } else if c := st.Code(); c != errCode { 1479 t.Errorf("got error code %q, want %q", c, errCode) 1480 } 1481 _ = resp 1482} 1483func TestClusterManagerDeleteCluster(t *testing.T) { 1484 var name string = "name3373707" 1485 var zone2 string = "zone2-696322977" 1486 var detail string = "detail-1335224239" 1487 var statusMessage string = "statusMessage-239442758" 1488 var selfLink string = "selfLink-1691268851" 1489 var targetLink string = "targetLink-2084812312" 1490 var startTime string = "startTime-1573145462" 1491 var endTime string = "endTime1725551537" 1492 var expectedResponse = &containerpb.Operation{ 1493 Name: name, 1494 Zone: zone2, 1495 Detail: detail, 1496 StatusMessage: statusMessage, 1497 SelfLink: selfLink, 1498 TargetLink: targetLink, 1499 StartTime: startTime, 1500 EndTime: endTime, 1501 } 1502 1503 mockClusterManager.err = nil 1504 mockClusterManager.reqs = nil 1505 1506 mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse) 1507 1508 var projectId string = "projectId-1969970175" 1509 var zone string = "zone3744684" 1510 var clusterId string = "clusterId240280960" 1511 var request = &containerpb.DeleteClusterRequest{ 1512 ProjectId: projectId, 1513 Zone: zone, 1514 ClusterId: clusterId, 1515 } 1516 1517 c, err := NewClusterManagerClient(context.Background(), clientOpt) 1518 if err != nil { 1519 t.Fatal(err) 1520 } 1521 1522 resp, err := c.DeleteCluster(context.Background(), request) 1523 1524 if err != nil { 1525 t.Fatal(err) 1526 } 1527 1528 if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) { 1529 t.Errorf("wrong request %q, want %q", got, want) 1530 } 1531 1532 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1533 t.Errorf("wrong response %q, want %q)", got, want) 1534 } 1535} 1536 1537func TestClusterManagerDeleteClusterError(t *testing.T) { 1538 errCode := codes.PermissionDenied 1539 mockClusterManager.err = gstatus.Error(errCode, "test error") 1540 1541 var projectId string = "projectId-1969970175" 1542 var zone string = "zone3744684" 1543 var clusterId string = "clusterId240280960" 1544 var request = &containerpb.DeleteClusterRequest{ 1545 ProjectId: projectId, 1546 Zone: zone, 1547 ClusterId: clusterId, 1548 } 1549 1550 c, err := NewClusterManagerClient(context.Background(), clientOpt) 1551 if err != nil { 1552 t.Fatal(err) 1553 } 1554 1555 resp, err := c.DeleteCluster(context.Background(), request) 1556 1557 if st, ok := gstatus.FromError(err); !ok { 1558 t.Errorf("got error %v, expected grpc error", err) 1559 } else if c := st.Code(); c != errCode { 1560 t.Errorf("got error code %q, want %q", c, errCode) 1561 } 1562 _ = resp 1563} 1564func TestClusterManagerListOperations(t *testing.T) { 1565 var expectedResponse *containerpb.ListOperationsResponse = &containerpb.ListOperationsResponse{} 1566 1567 mockClusterManager.err = nil 1568 mockClusterManager.reqs = nil 1569 1570 mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse) 1571 1572 var projectId string = "projectId-1969970175" 1573 var zone string = "zone3744684" 1574 var request = &containerpb.ListOperationsRequest{ 1575 ProjectId: projectId, 1576 Zone: zone, 1577 } 1578 1579 c, err := NewClusterManagerClient(context.Background(), clientOpt) 1580 if err != nil { 1581 t.Fatal(err) 1582 } 1583 1584 resp, err := c.ListOperations(context.Background(), request) 1585 1586 if err != nil { 1587 t.Fatal(err) 1588 } 1589 1590 if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) { 1591 t.Errorf("wrong request %q, want %q", got, want) 1592 } 1593 1594 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1595 t.Errorf("wrong response %q, want %q)", got, want) 1596 } 1597} 1598 1599func TestClusterManagerListOperationsError(t *testing.T) { 1600 errCode := codes.PermissionDenied 1601 mockClusterManager.err = gstatus.Error(errCode, "test error") 1602 1603 var projectId string = "projectId-1969970175" 1604 var zone string = "zone3744684" 1605 var request = &containerpb.ListOperationsRequest{ 1606 ProjectId: projectId, 1607 Zone: zone, 1608 } 1609 1610 c, err := NewClusterManagerClient(context.Background(), clientOpt) 1611 if err != nil { 1612 t.Fatal(err) 1613 } 1614 1615 resp, err := c.ListOperations(context.Background(), request) 1616 1617 if st, ok := gstatus.FromError(err); !ok { 1618 t.Errorf("got error %v, expected grpc error", err) 1619 } else if c := st.Code(); c != errCode { 1620 t.Errorf("got error code %q, want %q", c, errCode) 1621 } 1622 _ = resp 1623} 1624func TestClusterManagerGetOperation(t *testing.T) { 1625 var name string = "name3373707" 1626 var zone2 string = "zone2-696322977" 1627 var detail string = "detail-1335224239" 1628 var statusMessage string = "statusMessage-239442758" 1629 var selfLink string = "selfLink-1691268851" 1630 var targetLink string = "targetLink-2084812312" 1631 var startTime string = "startTime-1573145462" 1632 var endTime string = "endTime1725551537" 1633 var expectedResponse = &containerpb.Operation{ 1634 Name: name, 1635 Zone: zone2, 1636 Detail: detail, 1637 StatusMessage: statusMessage, 1638 SelfLink: selfLink, 1639 TargetLink: targetLink, 1640 StartTime: startTime, 1641 EndTime: endTime, 1642 } 1643 1644 mockClusterManager.err = nil 1645 mockClusterManager.reqs = nil 1646 1647 mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse) 1648 1649 var projectId string = "projectId-1969970175" 1650 var zone string = "zone3744684" 1651 var operationId string = "operationId-274116877" 1652 var request = &containerpb.GetOperationRequest{ 1653 ProjectId: projectId, 1654 Zone: zone, 1655 OperationId: operationId, 1656 } 1657 1658 c, err := NewClusterManagerClient(context.Background(), clientOpt) 1659 if err != nil { 1660 t.Fatal(err) 1661 } 1662 1663 resp, err := c.GetOperation(context.Background(), request) 1664 1665 if err != nil { 1666 t.Fatal(err) 1667 } 1668 1669 if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) { 1670 t.Errorf("wrong request %q, want %q", got, want) 1671 } 1672 1673 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1674 t.Errorf("wrong response %q, want %q)", got, want) 1675 } 1676} 1677 1678func TestClusterManagerGetOperationError(t *testing.T) { 1679 errCode := codes.PermissionDenied 1680 mockClusterManager.err = gstatus.Error(errCode, "test error") 1681 1682 var projectId string = "projectId-1969970175" 1683 var zone string = "zone3744684" 1684 var operationId string = "operationId-274116877" 1685 var request = &containerpb.GetOperationRequest{ 1686 ProjectId: projectId, 1687 Zone: zone, 1688 OperationId: operationId, 1689 } 1690 1691 c, err := NewClusterManagerClient(context.Background(), clientOpt) 1692 if err != nil { 1693 t.Fatal(err) 1694 } 1695 1696 resp, err := c.GetOperation(context.Background(), request) 1697 1698 if st, ok := gstatus.FromError(err); !ok { 1699 t.Errorf("got error %v, expected grpc error", err) 1700 } else if c := st.Code(); c != errCode { 1701 t.Errorf("got error code %q, want %q", c, errCode) 1702 } 1703 _ = resp 1704} 1705func TestClusterManagerCancelOperation(t *testing.T) { 1706 var expectedResponse *emptypb.Empty = &emptypb.Empty{} 1707 1708 mockClusterManager.err = nil 1709 mockClusterManager.reqs = nil 1710 1711 mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse) 1712 1713 var projectId string = "projectId-1969970175" 1714 var zone string = "zone3744684" 1715 var operationId string = "operationId-274116877" 1716 var request = &containerpb.CancelOperationRequest{ 1717 ProjectId: projectId, 1718 Zone: zone, 1719 OperationId: operationId, 1720 } 1721 1722 c, err := NewClusterManagerClient(context.Background(), clientOpt) 1723 if err != nil { 1724 t.Fatal(err) 1725 } 1726 1727 err = c.CancelOperation(context.Background(), request) 1728 1729 if err != nil { 1730 t.Fatal(err) 1731 } 1732 1733 if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) { 1734 t.Errorf("wrong request %q, want %q", got, want) 1735 } 1736 1737} 1738 1739func TestClusterManagerCancelOperationError(t *testing.T) { 1740 errCode := codes.PermissionDenied 1741 mockClusterManager.err = gstatus.Error(errCode, "test error") 1742 1743 var projectId string = "projectId-1969970175" 1744 var zone string = "zone3744684" 1745 var operationId string = "operationId-274116877" 1746 var request = &containerpb.CancelOperationRequest{ 1747 ProjectId: projectId, 1748 Zone: zone, 1749 OperationId: operationId, 1750 } 1751 1752 c, err := NewClusterManagerClient(context.Background(), clientOpt) 1753 if err != nil { 1754 t.Fatal(err) 1755 } 1756 1757 err = c.CancelOperation(context.Background(), request) 1758 1759 if st, ok := gstatus.FromError(err); !ok { 1760 t.Errorf("got error %v, expected grpc error", err) 1761 } else if c := st.Code(); c != errCode { 1762 t.Errorf("got error code %q, want %q", c, errCode) 1763 } 1764} 1765func TestClusterManagerGetServerConfig(t *testing.T) { 1766 var defaultClusterVersion string = "defaultClusterVersion111003029" 1767 var defaultImageType string = "defaultImageType-918225828" 1768 var expectedResponse = &containerpb.ServerConfig{ 1769 DefaultClusterVersion: defaultClusterVersion, 1770 DefaultImageType: defaultImageType, 1771 } 1772 1773 mockClusterManager.err = nil 1774 mockClusterManager.reqs = nil 1775 1776 mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse) 1777 1778 var projectId string = "projectId-1969970175" 1779 var zone string = "zone3744684" 1780 var request = &containerpb.GetServerConfigRequest{ 1781 ProjectId: projectId, 1782 Zone: zone, 1783 } 1784 1785 c, err := NewClusterManagerClient(context.Background(), clientOpt) 1786 if err != nil { 1787 t.Fatal(err) 1788 } 1789 1790 resp, err := c.GetServerConfig(context.Background(), request) 1791 1792 if err != nil { 1793 t.Fatal(err) 1794 } 1795 1796 if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) { 1797 t.Errorf("wrong request %q, want %q", got, want) 1798 } 1799 1800 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1801 t.Errorf("wrong response %q, want %q)", got, want) 1802 } 1803} 1804 1805func TestClusterManagerGetServerConfigError(t *testing.T) { 1806 errCode := codes.PermissionDenied 1807 mockClusterManager.err = gstatus.Error(errCode, "test error") 1808 1809 var projectId string = "projectId-1969970175" 1810 var zone string = "zone3744684" 1811 var request = &containerpb.GetServerConfigRequest{ 1812 ProjectId: projectId, 1813 Zone: zone, 1814 } 1815 1816 c, err := NewClusterManagerClient(context.Background(), clientOpt) 1817 if err != nil { 1818 t.Fatal(err) 1819 } 1820 1821 resp, err := c.GetServerConfig(context.Background(), request) 1822 1823 if st, ok := gstatus.FromError(err); !ok { 1824 t.Errorf("got error %v, expected grpc error", err) 1825 } else if c := st.Code(); c != errCode { 1826 t.Errorf("got error code %q, want %q", c, errCode) 1827 } 1828 _ = resp 1829} 1830func TestClusterManagerListNodePools(t *testing.T) { 1831 var expectedResponse *containerpb.ListNodePoolsResponse = &containerpb.ListNodePoolsResponse{} 1832 1833 mockClusterManager.err = nil 1834 mockClusterManager.reqs = nil 1835 1836 mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse) 1837 1838 var projectId string = "projectId-1969970175" 1839 var zone string = "zone3744684" 1840 var clusterId string = "clusterId240280960" 1841 var request = &containerpb.ListNodePoolsRequest{ 1842 ProjectId: projectId, 1843 Zone: zone, 1844 ClusterId: clusterId, 1845 } 1846 1847 c, err := NewClusterManagerClient(context.Background(), clientOpt) 1848 if err != nil { 1849 t.Fatal(err) 1850 } 1851 1852 resp, err := c.ListNodePools(context.Background(), request) 1853 1854 if err != nil { 1855 t.Fatal(err) 1856 } 1857 1858 if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) { 1859 t.Errorf("wrong request %q, want %q", got, want) 1860 } 1861 1862 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1863 t.Errorf("wrong response %q, want %q)", got, want) 1864 } 1865} 1866 1867func TestClusterManagerListNodePoolsError(t *testing.T) { 1868 errCode := codes.PermissionDenied 1869 mockClusterManager.err = gstatus.Error(errCode, "test error") 1870 1871 var projectId string = "projectId-1969970175" 1872 var zone string = "zone3744684" 1873 var clusterId string = "clusterId240280960" 1874 var request = &containerpb.ListNodePoolsRequest{ 1875 ProjectId: projectId, 1876 Zone: zone, 1877 ClusterId: clusterId, 1878 } 1879 1880 c, err := NewClusterManagerClient(context.Background(), clientOpt) 1881 if err != nil { 1882 t.Fatal(err) 1883 } 1884 1885 resp, err := c.ListNodePools(context.Background(), request) 1886 1887 if st, ok := gstatus.FromError(err); !ok { 1888 t.Errorf("got error %v, expected grpc error", err) 1889 } else if c := st.Code(); c != errCode { 1890 t.Errorf("got error code %q, want %q", c, errCode) 1891 } 1892 _ = resp 1893} 1894func TestClusterManagerGetNodePool(t *testing.T) { 1895 var name string = "name3373707" 1896 var initialNodeCount int32 = 1682564205 1897 var selfLink string = "selfLink-1691268851" 1898 var version string = "version351608024" 1899 var statusMessage string = "statusMessage-239442758" 1900 var expectedResponse = &containerpb.NodePool{ 1901 Name: name, 1902 InitialNodeCount: initialNodeCount, 1903 SelfLink: selfLink, 1904 Version: version, 1905 StatusMessage: statusMessage, 1906 } 1907 1908 mockClusterManager.err = nil 1909 mockClusterManager.reqs = nil 1910 1911 mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse) 1912 1913 var projectId string = "projectId-1969970175" 1914 var zone string = "zone3744684" 1915 var clusterId string = "clusterId240280960" 1916 var nodePoolId string = "nodePoolId1043384033" 1917 var request = &containerpb.GetNodePoolRequest{ 1918 ProjectId: projectId, 1919 Zone: zone, 1920 ClusterId: clusterId, 1921 NodePoolId: nodePoolId, 1922 } 1923 1924 c, err := NewClusterManagerClient(context.Background(), clientOpt) 1925 if err != nil { 1926 t.Fatal(err) 1927 } 1928 1929 resp, err := c.GetNodePool(context.Background(), request) 1930 1931 if err != nil { 1932 t.Fatal(err) 1933 } 1934 1935 if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) { 1936 t.Errorf("wrong request %q, want %q", got, want) 1937 } 1938 1939 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1940 t.Errorf("wrong response %q, want %q)", got, want) 1941 } 1942} 1943 1944func TestClusterManagerGetNodePoolError(t *testing.T) { 1945 errCode := codes.PermissionDenied 1946 mockClusterManager.err = gstatus.Error(errCode, "test error") 1947 1948 var projectId string = "projectId-1969970175" 1949 var zone string = "zone3744684" 1950 var clusterId string = "clusterId240280960" 1951 var nodePoolId string = "nodePoolId1043384033" 1952 var request = &containerpb.GetNodePoolRequest{ 1953 ProjectId: projectId, 1954 Zone: zone, 1955 ClusterId: clusterId, 1956 NodePoolId: nodePoolId, 1957 } 1958 1959 c, err := NewClusterManagerClient(context.Background(), clientOpt) 1960 if err != nil { 1961 t.Fatal(err) 1962 } 1963 1964 resp, err := c.GetNodePool(context.Background(), request) 1965 1966 if st, ok := gstatus.FromError(err); !ok { 1967 t.Errorf("got error %v, expected grpc error", err) 1968 } else if c := st.Code(); c != errCode { 1969 t.Errorf("got error code %q, want %q", c, errCode) 1970 } 1971 _ = resp 1972} 1973func TestClusterManagerCreateNodePool(t *testing.T) { 1974 var name string = "name3373707" 1975 var zone2 string = "zone2-696322977" 1976 var detail string = "detail-1335224239" 1977 var statusMessage string = "statusMessage-239442758" 1978 var selfLink string = "selfLink-1691268851" 1979 var targetLink string = "targetLink-2084812312" 1980 var startTime string = "startTime-1573145462" 1981 var endTime string = "endTime1725551537" 1982 var expectedResponse = &containerpb.Operation{ 1983 Name: name, 1984 Zone: zone2, 1985 Detail: detail, 1986 StatusMessage: statusMessage, 1987 SelfLink: selfLink, 1988 TargetLink: targetLink, 1989 StartTime: startTime, 1990 EndTime: endTime, 1991 } 1992 1993 mockClusterManager.err = nil 1994 mockClusterManager.reqs = nil 1995 1996 mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse) 1997 1998 var projectId string = "projectId-1969970175" 1999 var zone string = "zone3744684" 2000 var clusterId string = "clusterId240280960" 2001 var nodePool *containerpb.NodePool = &containerpb.NodePool{} 2002 var request = &containerpb.CreateNodePoolRequest{ 2003 ProjectId: projectId, 2004 Zone: zone, 2005 ClusterId: clusterId, 2006 NodePool: nodePool, 2007 } 2008 2009 c, err := NewClusterManagerClient(context.Background(), clientOpt) 2010 if err != nil { 2011 t.Fatal(err) 2012 } 2013 2014 resp, err := c.CreateNodePool(context.Background(), request) 2015 2016 if err != nil { 2017 t.Fatal(err) 2018 } 2019 2020 if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) { 2021 t.Errorf("wrong request %q, want %q", got, want) 2022 } 2023 2024 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 2025 t.Errorf("wrong response %q, want %q)", got, want) 2026 } 2027} 2028 2029func TestClusterManagerCreateNodePoolError(t *testing.T) { 2030 errCode := codes.PermissionDenied 2031 mockClusterManager.err = gstatus.Error(errCode, "test error") 2032 2033 var projectId string = "projectId-1969970175" 2034 var zone string = "zone3744684" 2035 var clusterId string = "clusterId240280960" 2036 var nodePool *containerpb.NodePool = &containerpb.NodePool{} 2037 var request = &containerpb.CreateNodePoolRequest{ 2038 ProjectId: projectId, 2039 Zone: zone, 2040 ClusterId: clusterId, 2041 NodePool: nodePool, 2042 } 2043 2044 c, err := NewClusterManagerClient(context.Background(), clientOpt) 2045 if err != nil { 2046 t.Fatal(err) 2047 } 2048 2049 resp, err := c.CreateNodePool(context.Background(), request) 2050 2051 if st, ok := gstatus.FromError(err); !ok { 2052 t.Errorf("got error %v, expected grpc error", err) 2053 } else if c := st.Code(); c != errCode { 2054 t.Errorf("got error code %q, want %q", c, errCode) 2055 } 2056 _ = resp 2057} 2058func TestClusterManagerDeleteNodePool(t *testing.T) { 2059 var name string = "name3373707" 2060 var zone2 string = "zone2-696322977" 2061 var detail string = "detail-1335224239" 2062 var statusMessage string = "statusMessage-239442758" 2063 var selfLink string = "selfLink-1691268851" 2064 var targetLink string = "targetLink-2084812312" 2065 var startTime string = "startTime-1573145462" 2066 var endTime string = "endTime1725551537" 2067 var expectedResponse = &containerpb.Operation{ 2068 Name: name, 2069 Zone: zone2, 2070 Detail: detail, 2071 StatusMessage: statusMessage, 2072 SelfLink: selfLink, 2073 TargetLink: targetLink, 2074 StartTime: startTime, 2075 EndTime: endTime, 2076 } 2077 2078 mockClusterManager.err = nil 2079 mockClusterManager.reqs = nil 2080 2081 mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse) 2082 2083 var projectId string = "projectId-1969970175" 2084 var zone string = "zone3744684" 2085 var clusterId string = "clusterId240280960" 2086 var nodePoolId string = "nodePoolId1043384033" 2087 var request = &containerpb.DeleteNodePoolRequest{ 2088 ProjectId: projectId, 2089 Zone: zone, 2090 ClusterId: clusterId, 2091 NodePoolId: nodePoolId, 2092 } 2093 2094 c, err := NewClusterManagerClient(context.Background(), clientOpt) 2095 if err != nil { 2096 t.Fatal(err) 2097 } 2098 2099 resp, err := c.DeleteNodePool(context.Background(), request) 2100 2101 if err != nil { 2102 t.Fatal(err) 2103 } 2104 2105 if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) { 2106 t.Errorf("wrong request %q, want %q", got, want) 2107 } 2108 2109 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 2110 t.Errorf("wrong response %q, want %q)", got, want) 2111 } 2112} 2113 2114func TestClusterManagerDeleteNodePoolError(t *testing.T) { 2115 errCode := codes.PermissionDenied 2116 mockClusterManager.err = gstatus.Error(errCode, "test error") 2117 2118 var projectId string = "projectId-1969970175" 2119 var zone string = "zone3744684" 2120 var clusterId string = "clusterId240280960" 2121 var nodePoolId string = "nodePoolId1043384033" 2122 var request = &containerpb.DeleteNodePoolRequest{ 2123 ProjectId: projectId, 2124 Zone: zone, 2125 ClusterId: clusterId, 2126 NodePoolId: nodePoolId, 2127 } 2128 2129 c, err := NewClusterManagerClient(context.Background(), clientOpt) 2130 if err != nil { 2131 t.Fatal(err) 2132 } 2133 2134 resp, err := c.DeleteNodePool(context.Background(), request) 2135 2136 if st, ok := gstatus.FromError(err); !ok { 2137 t.Errorf("got error %v, expected grpc error", err) 2138 } else if c := st.Code(); c != errCode { 2139 t.Errorf("got error code %q, want %q", c, errCode) 2140 } 2141 _ = resp 2142} 2143func TestClusterManagerRollbackNodePoolUpgrade(t *testing.T) { 2144 var name string = "name3373707" 2145 var zone2 string = "zone2-696322977" 2146 var detail string = "detail-1335224239" 2147 var statusMessage string = "statusMessage-239442758" 2148 var selfLink string = "selfLink-1691268851" 2149 var targetLink string = "targetLink-2084812312" 2150 var startTime string = "startTime-1573145462" 2151 var endTime string = "endTime1725551537" 2152 var expectedResponse = &containerpb.Operation{ 2153 Name: name, 2154 Zone: zone2, 2155 Detail: detail, 2156 StatusMessage: statusMessage, 2157 SelfLink: selfLink, 2158 TargetLink: targetLink, 2159 StartTime: startTime, 2160 EndTime: endTime, 2161 } 2162 2163 mockClusterManager.err = nil 2164 mockClusterManager.reqs = nil 2165 2166 mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse) 2167 2168 var projectId string = "projectId-1969970175" 2169 var zone string = "zone3744684" 2170 var clusterId string = "clusterId240280960" 2171 var nodePoolId string = "nodePoolId1043384033" 2172 var request = &containerpb.RollbackNodePoolUpgradeRequest{ 2173 ProjectId: projectId, 2174 Zone: zone, 2175 ClusterId: clusterId, 2176 NodePoolId: nodePoolId, 2177 } 2178 2179 c, err := NewClusterManagerClient(context.Background(), clientOpt) 2180 if err != nil { 2181 t.Fatal(err) 2182 } 2183 2184 resp, err := c.RollbackNodePoolUpgrade(context.Background(), request) 2185 2186 if err != nil { 2187 t.Fatal(err) 2188 } 2189 2190 if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) { 2191 t.Errorf("wrong request %q, want %q", got, want) 2192 } 2193 2194 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 2195 t.Errorf("wrong response %q, want %q)", got, want) 2196 } 2197} 2198 2199func TestClusterManagerRollbackNodePoolUpgradeError(t *testing.T) { 2200 errCode := codes.PermissionDenied 2201 mockClusterManager.err = gstatus.Error(errCode, "test error") 2202 2203 var projectId string = "projectId-1969970175" 2204 var zone string = "zone3744684" 2205 var clusterId string = "clusterId240280960" 2206 var nodePoolId string = "nodePoolId1043384033" 2207 var request = &containerpb.RollbackNodePoolUpgradeRequest{ 2208 ProjectId: projectId, 2209 Zone: zone, 2210 ClusterId: clusterId, 2211 NodePoolId: nodePoolId, 2212 } 2213 2214 c, err := NewClusterManagerClient(context.Background(), clientOpt) 2215 if err != nil { 2216 t.Fatal(err) 2217 } 2218 2219 resp, err := c.RollbackNodePoolUpgrade(context.Background(), request) 2220 2221 if st, ok := gstatus.FromError(err); !ok { 2222 t.Errorf("got error %v, expected grpc error", err) 2223 } else if c := st.Code(); c != errCode { 2224 t.Errorf("got error code %q, want %q", c, errCode) 2225 } 2226 _ = resp 2227} 2228func TestClusterManagerSetNodePoolManagement(t *testing.T) { 2229 var name string = "name3373707" 2230 var zone2 string = "zone2-696322977" 2231 var detail string = "detail-1335224239" 2232 var statusMessage string = "statusMessage-239442758" 2233 var selfLink string = "selfLink-1691268851" 2234 var targetLink string = "targetLink-2084812312" 2235 var startTime string = "startTime-1573145462" 2236 var endTime string = "endTime1725551537" 2237 var expectedResponse = &containerpb.Operation{ 2238 Name: name, 2239 Zone: zone2, 2240 Detail: detail, 2241 StatusMessage: statusMessage, 2242 SelfLink: selfLink, 2243 TargetLink: targetLink, 2244 StartTime: startTime, 2245 EndTime: endTime, 2246 } 2247 2248 mockClusterManager.err = nil 2249 mockClusterManager.reqs = nil 2250 2251 mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse) 2252 2253 var projectId string = "projectId-1969970175" 2254 var zone string = "zone3744684" 2255 var clusterId string = "clusterId240280960" 2256 var nodePoolId string = "nodePoolId1043384033" 2257 var management *containerpb.NodeManagement = &containerpb.NodeManagement{} 2258 var request = &containerpb.SetNodePoolManagementRequest{ 2259 ProjectId: projectId, 2260 Zone: zone, 2261 ClusterId: clusterId, 2262 NodePoolId: nodePoolId, 2263 Management: management, 2264 } 2265 2266 c, err := NewClusterManagerClient(context.Background(), clientOpt) 2267 if err != nil { 2268 t.Fatal(err) 2269 } 2270 2271 resp, err := c.SetNodePoolManagement(context.Background(), request) 2272 2273 if err != nil { 2274 t.Fatal(err) 2275 } 2276 2277 if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) { 2278 t.Errorf("wrong request %q, want %q", got, want) 2279 } 2280 2281 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 2282 t.Errorf("wrong response %q, want %q)", got, want) 2283 } 2284} 2285 2286func TestClusterManagerSetNodePoolManagementError(t *testing.T) { 2287 errCode := codes.PermissionDenied 2288 mockClusterManager.err = gstatus.Error(errCode, "test error") 2289 2290 var projectId string = "projectId-1969970175" 2291 var zone string = "zone3744684" 2292 var clusterId string = "clusterId240280960" 2293 var nodePoolId string = "nodePoolId1043384033" 2294 var management *containerpb.NodeManagement = &containerpb.NodeManagement{} 2295 var request = &containerpb.SetNodePoolManagementRequest{ 2296 ProjectId: projectId, 2297 Zone: zone, 2298 ClusterId: clusterId, 2299 NodePoolId: nodePoolId, 2300 Management: management, 2301 } 2302 2303 c, err := NewClusterManagerClient(context.Background(), clientOpt) 2304 if err != nil { 2305 t.Fatal(err) 2306 } 2307 2308 resp, err := c.SetNodePoolManagement(context.Background(), request) 2309 2310 if st, ok := gstatus.FromError(err); !ok { 2311 t.Errorf("got error %v, expected grpc error", err) 2312 } else if c := st.Code(); c != errCode { 2313 t.Errorf("got error code %q, want %q", c, errCode) 2314 } 2315 _ = resp 2316} 2317func TestClusterManagerSetLabels(t *testing.T) { 2318 var name string = "name3373707" 2319 var zone2 string = "zone2-696322977" 2320 var detail string = "detail-1335224239" 2321 var statusMessage string = "statusMessage-239442758" 2322 var selfLink string = "selfLink-1691268851" 2323 var targetLink string = "targetLink-2084812312" 2324 var startTime string = "startTime-1573145462" 2325 var endTime string = "endTime1725551537" 2326 var expectedResponse = &containerpb.Operation{ 2327 Name: name, 2328 Zone: zone2, 2329 Detail: detail, 2330 StatusMessage: statusMessage, 2331 SelfLink: selfLink, 2332 TargetLink: targetLink, 2333 StartTime: startTime, 2334 EndTime: endTime, 2335 } 2336 2337 mockClusterManager.err = nil 2338 mockClusterManager.reqs = nil 2339 2340 mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse) 2341 2342 var projectId string = "projectId-1969970175" 2343 var zone string = "zone3744684" 2344 var clusterId string = "clusterId240280960" 2345 var resourceLabels map[string]string = nil 2346 var labelFingerprint string = "labelFingerprint714995737" 2347 var request = &containerpb.SetLabelsRequest{ 2348 ProjectId: projectId, 2349 Zone: zone, 2350 ClusterId: clusterId, 2351 ResourceLabels: resourceLabels, 2352 LabelFingerprint: labelFingerprint, 2353 } 2354 2355 c, err := NewClusterManagerClient(context.Background(), clientOpt) 2356 if err != nil { 2357 t.Fatal(err) 2358 } 2359 2360 resp, err := c.SetLabels(context.Background(), request) 2361 2362 if err != nil { 2363 t.Fatal(err) 2364 } 2365 2366 if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) { 2367 t.Errorf("wrong request %q, want %q", got, want) 2368 } 2369 2370 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 2371 t.Errorf("wrong response %q, want %q)", got, want) 2372 } 2373} 2374 2375func TestClusterManagerSetLabelsError(t *testing.T) { 2376 errCode := codes.PermissionDenied 2377 mockClusterManager.err = gstatus.Error(errCode, "test error") 2378 2379 var projectId string = "projectId-1969970175" 2380 var zone string = "zone3744684" 2381 var clusterId string = "clusterId240280960" 2382 var resourceLabels map[string]string = nil 2383 var labelFingerprint string = "labelFingerprint714995737" 2384 var request = &containerpb.SetLabelsRequest{ 2385 ProjectId: projectId, 2386 Zone: zone, 2387 ClusterId: clusterId, 2388 ResourceLabels: resourceLabels, 2389 LabelFingerprint: labelFingerprint, 2390 } 2391 2392 c, err := NewClusterManagerClient(context.Background(), clientOpt) 2393 if err != nil { 2394 t.Fatal(err) 2395 } 2396 2397 resp, err := c.SetLabels(context.Background(), request) 2398 2399 if st, ok := gstatus.FromError(err); !ok { 2400 t.Errorf("got error %v, expected grpc error", err) 2401 } else if c := st.Code(); c != errCode { 2402 t.Errorf("got error code %q, want %q", c, errCode) 2403 } 2404 _ = resp 2405} 2406func TestClusterManagerSetLegacyAbac(t *testing.T) { 2407 var name string = "name3373707" 2408 var zone2 string = "zone2-696322977" 2409 var detail string = "detail-1335224239" 2410 var statusMessage string = "statusMessage-239442758" 2411 var selfLink string = "selfLink-1691268851" 2412 var targetLink string = "targetLink-2084812312" 2413 var startTime string = "startTime-1573145462" 2414 var endTime string = "endTime1725551537" 2415 var expectedResponse = &containerpb.Operation{ 2416 Name: name, 2417 Zone: zone2, 2418 Detail: detail, 2419 StatusMessage: statusMessage, 2420 SelfLink: selfLink, 2421 TargetLink: targetLink, 2422 StartTime: startTime, 2423 EndTime: endTime, 2424 } 2425 2426 mockClusterManager.err = nil 2427 mockClusterManager.reqs = nil 2428 2429 mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse) 2430 2431 var projectId string = "projectId-1969970175" 2432 var zone string = "zone3744684" 2433 var clusterId string = "clusterId240280960" 2434 var enabled bool = false 2435 var request = &containerpb.SetLegacyAbacRequest{ 2436 ProjectId: projectId, 2437 Zone: zone, 2438 ClusterId: clusterId, 2439 Enabled: enabled, 2440 } 2441 2442 c, err := NewClusterManagerClient(context.Background(), clientOpt) 2443 if err != nil { 2444 t.Fatal(err) 2445 } 2446 2447 resp, err := c.SetLegacyAbac(context.Background(), request) 2448 2449 if err != nil { 2450 t.Fatal(err) 2451 } 2452 2453 if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) { 2454 t.Errorf("wrong request %q, want %q", got, want) 2455 } 2456 2457 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 2458 t.Errorf("wrong response %q, want %q)", got, want) 2459 } 2460} 2461 2462func TestClusterManagerSetLegacyAbacError(t *testing.T) { 2463 errCode := codes.PermissionDenied 2464 mockClusterManager.err = gstatus.Error(errCode, "test error") 2465 2466 var projectId string = "projectId-1969970175" 2467 var zone string = "zone3744684" 2468 var clusterId string = "clusterId240280960" 2469 var enabled bool = false 2470 var request = &containerpb.SetLegacyAbacRequest{ 2471 ProjectId: projectId, 2472 Zone: zone, 2473 ClusterId: clusterId, 2474 Enabled: enabled, 2475 } 2476 2477 c, err := NewClusterManagerClient(context.Background(), clientOpt) 2478 if err != nil { 2479 t.Fatal(err) 2480 } 2481 2482 resp, err := c.SetLegacyAbac(context.Background(), request) 2483 2484 if st, ok := gstatus.FromError(err); !ok { 2485 t.Errorf("got error %v, expected grpc error", err) 2486 } else if c := st.Code(); c != errCode { 2487 t.Errorf("got error code %q, want %q", c, errCode) 2488 } 2489 _ = resp 2490} 2491func TestClusterManagerStartIPRotation(t *testing.T) { 2492 var name string = "name3373707" 2493 var zone2 string = "zone2-696322977" 2494 var detail string = "detail-1335224239" 2495 var statusMessage string = "statusMessage-239442758" 2496 var selfLink string = "selfLink-1691268851" 2497 var targetLink string = "targetLink-2084812312" 2498 var startTime string = "startTime-1573145462" 2499 var endTime string = "endTime1725551537" 2500 var expectedResponse = &containerpb.Operation{ 2501 Name: name, 2502 Zone: zone2, 2503 Detail: detail, 2504 StatusMessage: statusMessage, 2505 SelfLink: selfLink, 2506 TargetLink: targetLink, 2507 StartTime: startTime, 2508 EndTime: endTime, 2509 } 2510 2511 mockClusterManager.err = nil 2512 mockClusterManager.reqs = nil 2513 2514 mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse) 2515 2516 var projectId string = "projectId-1969970175" 2517 var zone string = "zone3744684" 2518 var clusterId string = "clusterId240280960" 2519 var request = &containerpb.StartIPRotationRequest{ 2520 ProjectId: projectId, 2521 Zone: zone, 2522 ClusterId: clusterId, 2523 } 2524 2525 c, err := NewClusterManagerClient(context.Background(), clientOpt) 2526 if err != nil { 2527 t.Fatal(err) 2528 } 2529 2530 resp, err := c.StartIPRotation(context.Background(), request) 2531 2532 if err != nil { 2533 t.Fatal(err) 2534 } 2535 2536 if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) { 2537 t.Errorf("wrong request %q, want %q", got, want) 2538 } 2539 2540 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 2541 t.Errorf("wrong response %q, want %q)", got, want) 2542 } 2543} 2544 2545func TestClusterManagerStartIPRotationError(t *testing.T) { 2546 errCode := codes.PermissionDenied 2547 mockClusterManager.err = gstatus.Error(errCode, "test error") 2548 2549 var projectId string = "projectId-1969970175" 2550 var zone string = "zone3744684" 2551 var clusterId string = "clusterId240280960" 2552 var request = &containerpb.StartIPRotationRequest{ 2553 ProjectId: projectId, 2554 Zone: zone, 2555 ClusterId: clusterId, 2556 } 2557 2558 c, err := NewClusterManagerClient(context.Background(), clientOpt) 2559 if err != nil { 2560 t.Fatal(err) 2561 } 2562 2563 resp, err := c.StartIPRotation(context.Background(), request) 2564 2565 if st, ok := gstatus.FromError(err); !ok { 2566 t.Errorf("got error %v, expected grpc error", err) 2567 } else if c := st.Code(); c != errCode { 2568 t.Errorf("got error code %q, want %q", c, errCode) 2569 } 2570 _ = resp 2571} 2572func TestClusterManagerCompleteIPRotation(t *testing.T) { 2573 var name string = "name3373707" 2574 var zone2 string = "zone2-696322977" 2575 var detail string = "detail-1335224239" 2576 var statusMessage string = "statusMessage-239442758" 2577 var selfLink string = "selfLink-1691268851" 2578 var targetLink string = "targetLink-2084812312" 2579 var startTime string = "startTime-1573145462" 2580 var endTime string = "endTime1725551537" 2581 var expectedResponse = &containerpb.Operation{ 2582 Name: name, 2583 Zone: zone2, 2584 Detail: detail, 2585 StatusMessage: statusMessage, 2586 SelfLink: selfLink, 2587 TargetLink: targetLink, 2588 StartTime: startTime, 2589 EndTime: endTime, 2590 } 2591 2592 mockClusterManager.err = nil 2593 mockClusterManager.reqs = nil 2594 2595 mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse) 2596 2597 var projectId string = "projectId-1969970175" 2598 var zone string = "zone3744684" 2599 var clusterId string = "clusterId240280960" 2600 var request = &containerpb.CompleteIPRotationRequest{ 2601 ProjectId: projectId, 2602 Zone: zone, 2603 ClusterId: clusterId, 2604 } 2605 2606 c, err := NewClusterManagerClient(context.Background(), clientOpt) 2607 if err != nil { 2608 t.Fatal(err) 2609 } 2610 2611 resp, err := c.CompleteIPRotation(context.Background(), request) 2612 2613 if err != nil { 2614 t.Fatal(err) 2615 } 2616 2617 if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) { 2618 t.Errorf("wrong request %q, want %q", got, want) 2619 } 2620 2621 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 2622 t.Errorf("wrong response %q, want %q)", got, want) 2623 } 2624} 2625 2626func TestClusterManagerCompleteIPRotationError(t *testing.T) { 2627 errCode := codes.PermissionDenied 2628 mockClusterManager.err = gstatus.Error(errCode, "test error") 2629 2630 var projectId string = "projectId-1969970175" 2631 var zone string = "zone3744684" 2632 var clusterId string = "clusterId240280960" 2633 var request = &containerpb.CompleteIPRotationRequest{ 2634 ProjectId: projectId, 2635 Zone: zone, 2636 ClusterId: clusterId, 2637 } 2638 2639 c, err := NewClusterManagerClient(context.Background(), clientOpt) 2640 if err != nil { 2641 t.Fatal(err) 2642 } 2643 2644 resp, err := c.CompleteIPRotation(context.Background(), request) 2645 2646 if st, ok := gstatus.FromError(err); !ok { 2647 t.Errorf("got error %v, expected grpc error", err) 2648 } else if c := st.Code(); c != errCode { 2649 t.Errorf("got error code %q, want %q", c, errCode) 2650 } 2651 _ = resp 2652} 2653func TestClusterManagerSetNodePoolSize(t *testing.T) { 2654 var name string = "name3373707" 2655 var zone2 string = "zone2-696322977" 2656 var detail string = "detail-1335224239" 2657 var statusMessage string = "statusMessage-239442758" 2658 var selfLink string = "selfLink-1691268851" 2659 var targetLink string = "targetLink-2084812312" 2660 var startTime string = "startTime-1573145462" 2661 var endTime string = "endTime1725551537" 2662 var expectedResponse = &containerpb.Operation{ 2663 Name: name, 2664 Zone: zone2, 2665 Detail: detail, 2666 StatusMessage: statusMessage, 2667 SelfLink: selfLink, 2668 TargetLink: targetLink, 2669 StartTime: startTime, 2670 EndTime: endTime, 2671 } 2672 2673 mockClusterManager.err = nil 2674 mockClusterManager.reqs = nil 2675 2676 mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse) 2677 2678 var projectId string = "projectId-1969970175" 2679 var zone string = "zone3744684" 2680 var clusterId string = "clusterId240280960" 2681 var nodePoolId string = "nodePoolId1043384033" 2682 var nodeCount int32 = 1539922066 2683 var request = &containerpb.SetNodePoolSizeRequest{ 2684 ProjectId: projectId, 2685 Zone: zone, 2686 ClusterId: clusterId, 2687 NodePoolId: nodePoolId, 2688 NodeCount: nodeCount, 2689 } 2690 2691 c, err := NewClusterManagerClient(context.Background(), clientOpt) 2692 if err != nil { 2693 t.Fatal(err) 2694 } 2695 2696 resp, err := c.SetNodePoolSize(context.Background(), request) 2697 2698 if err != nil { 2699 t.Fatal(err) 2700 } 2701 2702 if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) { 2703 t.Errorf("wrong request %q, want %q", got, want) 2704 } 2705 2706 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 2707 t.Errorf("wrong response %q, want %q)", got, want) 2708 } 2709} 2710 2711func TestClusterManagerSetNodePoolSizeError(t *testing.T) { 2712 errCode := codes.PermissionDenied 2713 mockClusterManager.err = gstatus.Error(errCode, "test error") 2714 2715 var projectId string = "projectId-1969970175" 2716 var zone string = "zone3744684" 2717 var clusterId string = "clusterId240280960" 2718 var nodePoolId string = "nodePoolId1043384033" 2719 var nodeCount int32 = 1539922066 2720 var request = &containerpb.SetNodePoolSizeRequest{ 2721 ProjectId: projectId, 2722 Zone: zone, 2723 ClusterId: clusterId, 2724 NodePoolId: nodePoolId, 2725 NodeCount: nodeCount, 2726 } 2727 2728 c, err := NewClusterManagerClient(context.Background(), clientOpt) 2729 if err != nil { 2730 t.Fatal(err) 2731 } 2732 2733 resp, err := c.SetNodePoolSize(context.Background(), request) 2734 2735 if st, ok := gstatus.FromError(err); !ok { 2736 t.Errorf("got error %v, expected grpc error", err) 2737 } else if c := st.Code(); c != errCode { 2738 t.Errorf("got error code %q, want %q", c, errCode) 2739 } 2740 _ = resp 2741} 2742func TestClusterManagerSetNetworkPolicy(t *testing.T) { 2743 var name string = "name3373707" 2744 var zone2 string = "zone2-696322977" 2745 var detail string = "detail-1335224239" 2746 var statusMessage string = "statusMessage-239442758" 2747 var selfLink string = "selfLink-1691268851" 2748 var targetLink string = "targetLink-2084812312" 2749 var startTime string = "startTime-1573145462" 2750 var endTime string = "endTime1725551537" 2751 var expectedResponse = &containerpb.Operation{ 2752 Name: name, 2753 Zone: zone2, 2754 Detail: detail, 2755 StatusMessage: statusMessage, 2756 SelfLink: selfLink, 2757 TargetLink: targetLink, 2758 StartTime: startTime, 2759 EndTime: endTime, 2760 } 2761 2762 mockClusterManager.err = nil 2763 mockClusterManager.reqs = nil 2764 2765 mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse) 2766 2767 var projectId string = "projectId-1969970175" 2768 var zone string = "zone3744684" 2769 var clusterId string = "clusterId240280960" 2770 var networkPolicy *containerpb.NetworkPolicy = &containerpb.NetworkPolicy{} 2771 var request = &containerpb.SetNetworkPolicyRequest{ 2772 ProjectId: projectId, 2773 Zone: zone, 2774 ClusterId: clusterId, 2775 NetworkPolicy: networkPolicy, 2776 } 2777 2778 c, err := NewClusterManagerClient(context.Background(), clientOpt) 2779 if err != nil { 2780 t.Fatal(err) 2781 } 2782 2783 resp, err := c.SetNetworkPolicy(context.Background(), request) 2784 2785 if err != nil { 2786 t.Fatal(err) 2787 } 2788 2789 if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) { 2790 t.Errorf("wrong request %q, want %q", got, want) 2791 } 2792 2793 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 2794 t.Errorf("wrong response %q, want %q)", got, want) 2795 } 2796} 2797 2798func TestClusterManagerSetNetworkPolicyError(t *testing.T) { 2799 errCode := codes.PermissionDenied 2800 mockClusterManager.err = gstatus.Error(errCode, "test error") 2801 2802 var projectId string = "projectId-1969970175" 2803 var zone string = "zone3744684" 2804 var clusterId string = "clusterId240280960" 2805 var networkPolicy *containerpb.NetworkPolicy = &containerpb.NetworkPolicy{} 2806 var request = &containerpb.SetNetworkPolicyRequest{ 2807 ProjectId: projectId, 2808 Zone: zone, 2809 ClusterId: clusterId, 2810 NetworkPolicy: networkPolicy, 2811 } 2812 2813 c, err := NewClusterManagerClient(context.Background(), clientOpt) 2814 if err != nil { 2815 t.Fatal(err) 2816 } 2817 2818 resp, err := c.SetNetworkPolicy(context.Background(), request) 2819 2820 if st, ok := gstatus.FromError(err); !ok { 2821 t.Errorf("got error %v, expected grpc error", err) 2822 } else if c := st.Code(); c != errCode { 2823 t.Errorf("got error code %q, want %q", c, errCode) 2824 } 2825 _ = resp 2826} 2827func TestClusterManagerSetMaintenancePolicy(t *testing.T) { 2828 var name string = "name3373707" 2829 var zone2 string = "zone2-696322977" 2830 var detail string = "detail-1335224239" 2831 var statusMessage string = "statusMessage-239442758" 2832 var selfLink string = "selfLink-1691268851" 2833 var targetLink string = "targetLink-2084812312" 2834 var startTime string = "startTime-1573145462" 2835 var endTime string = "endTime1725551537" 2836 var expectedResponse = &containerpb.Operation{ 2837 Name: name, 2838 Zone: zone2, 2839 Detail: detail, 2840 StatusMessage: statusMessage, 2841 SelfLink: selfLink, 2842 TargetLink: targetLink, 2843 StartTime: startTime, 2844 EndTime: endTime, 2845 } 2846 2847 mockClusterManager.err = nil 2848 mockClusterManager.reqs = nil 2849 2850 mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse) 2851 2852 var projectId string = "projectId-1969970175" 2853 var zone string = "zone3744684" 2854 var clusterId string = "clusterId240280960" 2855 var maintenancePolicy *containerpb.MaintenancePolicy = &containerpb.MaintenancePolicy{} 2856 var request = &containerpb.SetMaintenancePolicyRequest{ 2857 ProjectId: projectId, 2858 Zone: zone, 2859 ClusterId: clusterId, 2860 MaintenancePolicy: maintenancePolicy, 2861 } 2862 2863 c, err := NewClusterManagerClient(context.Background(), clientOpt) 2864 if err != nil { 2865 t.Fatal(err) 2866 } 2867 2868 resp, err := c.SetMaintenancePolicy(context.Background(), request) 2869 2870 if err != nil { 2871 t.Fatal(err) 2872 } 2873 2874 if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) { 2875 t.Errorf("wrong request %q, want %q", got, want) 2876 } 2877 2878 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 2879 t.Errorf("wrong response %q, want %q)", got, want) 2880 } 2881} 2882 2883func TestClusterManagerSetMaintenancePolicyError(t *testing.T) { 2884 errCode := codes.PermissionDenied 2885 mockClusterManager.err = gstatus.Error(errCode, "test error") 2886 2887 var projectId string = "projectId-1969970175" 2888 var zone string = "zone3744684" 2889 var clusterId string = "clusterId240280960" 2890 var maintenancePolicy *containerpb.MaintenancePolicy = &containerpb.MaintenancePolicy{} 2891 var request = &containerpb.SetMaintenancePolicyRequest{ 2892 ProjectId: projectId, 2893 Zone: zone, 2894 ClusterId: clusterId, 2895 MaintenancePolicy: maintenancePolicy, 2896 } 2897 2898 c, err := NewClusterManagerClient(context.Background(), clientOpt) 2899 if err != nil { 2900 t.Fatal(err) 2901 } 2902 2903 resp, err := c.SetMaintenancePolicy(context.Background(), request) 2904 2905 if st, ok := gstatus.FromError(err); !ok { 2906 t.Errorf("got error %v, expected grpc error", err) 2907 } else if c := st.Code(); c != errCode { 2908 t.Errorf("got error code %q, want %q", c, errCode) 2909 } 2910 _ = resp 2911} 2912