mirror of
https://github.com/Luzifer/nginx-sso.git
synced 2024-12-21 05:11:17 +00:00
2912 lines
87 KiB
Go
2912 lines
87 KiB
Go
// Copyright 2018 Google LLC
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// https://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
// AUTO-GENERATED CODE. DO NOT EDIT.
|
|
|
|
package container
|
|
|
|
import (
|
|
emptypb "github.com/golang/protobuf/ptypes/empty"
|
|
containerpb "google.golang.org/genproto/googleapis/container/v1"
|
|
)
|
|
|
|
import (
|
|
"context"
|
|
"flag"
|
|
"fmt"
|
|
"io"
|
|
"log"
|
|
"net"
|
|
"os"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/golang/protobuf/proto"
|
|
"github.com/golang/protobuf/ptypes"
|
|
"google.golang.org/api/option"
|
|
status "google.golang.org/genproto/googleapis/rpc/status"
|
|
"google.golang.org/grpc"
|
|
"google.golang.org/grpc/codes"
|
|
"google.golang.org/grpc/metadata"
|
|
gstatus "google.golang.org/grpc/status"
|
|
)
|
|
|
|
var _ = io.EOF
|
|
var _ = ptypes.MarshalAny
|
|
var _ status.Status
|
|
|
|
type mockClusterManagerServer struct {
|
|
// Embed for forward compatibility.
|
|
// Tests will keep working if more methods are added
|
|
// in the future.
|
|
containerpb.ClusterManagerServer
|
|
|
|
reqs []proto.Message
|
|
|
|
// If set, all calls return this error.
|
|
err error
|
|
|
|
// responses to return if err == nil
|
|
resps []proto.Message
|
|
}
|
|
|
|
func (s *mockClusterManagerServer) ListClusters(ctx context.Context, req *containerpb.ListClustersRequest) (*containerpb.ListClustersResponse, error) {
|
|
md, _ := metadata.FromIncomingContext(ctx)
|
|
if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
|
|
return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
|
|
}
|
|
s.reqs = append(s.reqs, req)
|
|
if s.err != nil {
|
|
return nil, s.err
|
|
}
|
|
return s.resps[0].(*containerpb.ListClustersResponse), nil
|
|
}
|
|
|
|
func (s *mockClusterManagerServer) GetCluster(ctx context.Context, req *containerpb.GetClusterRequest) (*containerpb.Cluster, error) {
|
|
md, _ := metadata.FromIncomingContext(ctx)
|
|
if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
|
|
return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
|
|
}
|
|
s.reqs = append(s.reqs, req)
|
|
if s.err != nil {
|
|
return nil, s.err
|
|
}
|
|
return s.resps[0].(*containerpb.Cluster), nil
|
|
}
|
|
|
|
func (s *mockClusterManagerServer) CreateCluster(ctx context.Context, req *containerpb.CreateClusterRequest) (*containerpb.Operation, error) {
|
|
md, _ := metadata.FromIncomingContext(ctx)
|
|
if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
|
|
return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
|
|
}
|
|
s.reqs = append(s.reqs, req)
|
|
if s.err != nil {
|
|
return nil, s.err
|
|
}
|
|
return s.resps[0].(*containerpb.Operation), nil
|
|
}
|
|
|
|
func (s *mockClusterManagerServer) UpdateCluster(ctx context.Context, req *containerpb.UpdateClusterRequest) (*containerpb.Operation, error) {
|
|
md, _ := metadata.FromIncomingContext(ctx)
|
|
if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
|
|
return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
|
|
}
|
|
s.reqs = append(s.reqs, req)
|
|
if s.err != nil {
|
|
return nil, s.err
|
|
}
|
|
return s.resps[0].(*containerpb.Operation), nil
|
|
}
|
|
|
|
func (s *mockClusterManagerServer) UpdateNodePool(ctx context.Context, req *containerpb.UpdateNodePoolRequest) (*containerpb.Operation, error) {
|
|
md, _ := metadata.FromIncomingContext(ctx)
|
|
if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
|
|
return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
|
|
}
|
|
s.reqs = append(s.reqs, req)
|
|
if s.err != nil {
|
|
return nil, s.err
|
|
}
|
|
return s.resps[0].(*containerpb.Operation), nil
|
|
}
|
|
|
|
func (s *mockClusterManagerServer) SetNodePoolAutoscaling(ctx context.Context, req *containerpb.SetNodePoolAutoscalingRequest) (*containerpb.Operation, error) {
|
|
md, _ := metadata.FromIncomingContext(ctx)
|
|
if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
|
|
return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
|
|
}
|
|
s.reqs = append(s.reqs, req)
|
|
if s.err != nil {
|
|
return nil, s.err
|
|
}
|
|
return s.resps[0].(*containerpb.Operation), nil
|
|
}
|
|
|
|
func (s *mockClusterManagerServer) SetLoggingService(ctx context.Context, req *containerpb.SetLoggingServiceRequest) (*containerpb.Operation, error) {
|
|
md, _ := metadata.FromIncomingContext(ctx)
|
|
if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
|
|
return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
|
|
}
|
|
s.reqs = append(s.reqs, req)
|
|
if s.err != nil {
|
|
return nil, s.err
|
|
}
|
|
return s.resps[0].(*containerpb.Operation), nil
|
|
}
|
|
|
|
func (s *mockClusterManagerServer) SetMonitoringService(ctx context.Context, req *containerpb.SetMonitoringServiceRequest) (*containerpb.Operation, error) {
|
|
md, _ := metadata.FromIncomingContext(ctx)
|
|
if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
|
|
return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
|
|
}
|
|
s.reqs = append(s.reqs, req)
|
|
if s.err != nil {
|
|
return nil, s.err
|
|
}
|
|
return s.resps[0].(*containerpb.Operation), nil
|
|
}
|
|
|
|
func (s *mockClusterManagerServer) SetAddonsConfig(ctx context.Context, req *containerpb.SetAddonsConfigRequest) (*containerpb.Operation, error) {
|
|
md, _ := metadata.FromIncomingContext(ctx)
|
|
if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
|
|
return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
|
|
}
|
|
s.reqs = append(s.reqs, req)
|
|
if s.err != nil {
|
|
return nil, s.err
|
|
}
|
|
return s.resps[0].(*containerpb.Operation), nil
|
|
}
|
|
|
|
func (s *mockClusterManagerServer) SetLocations(ctx context.Context, req *containerpb.SetLocationsRequest) (*containerpb.Operation, error) {
|
|
md, _ := metadata.FromIncomingContext(ctx)
|
|
if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
|
|
return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
|
|
}
|
|
s.reqs = append(s.reqs, req)
|
|
if s.err != nil {
|
|
return nil, s.err
|
|
}
|
|
return s.resps[0].(*containerpb.Operation), nil
|
|
}
|
|
|
|
func (s *mockClusterManagerServer) UpdateMaster(ctx context.Context, req *containerpb.UpdateMasterRequest) (*containerpb.Operation, error) {
|
|
md, _ := metadata.FromIncomingContext(ctx)
|
|
if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
|
|
return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
|
|
}
|
|
s.reqs = append(s.reqs, req)
|
|
if s.err != nil {
|
|
return nil, s.err
|
|
}
|
|
return s.resps[0].(*containerpb.Operation), nil
|
|
}
|
|
|
|
func (s *mockClusterManagerServer) SetMasterAuth(ctx context.Context, req *containerpb.SetMasterAuthRequest) (*containerpb.Operation, error) {
|
|
md, _ := metadata.FromIncomingContext(ctx)
|
|
if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
|
|
return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
|
|
}
|
|
s.reqs = append(s.reqs, req)
|
|
if s.err != nil {
|
|
return nil, s.err
|
|
}
|
|
return s.resps[0].(*containerpb.Operation), nil
|
|
}
|
|
|
|
func (s *mockClusterManagerServer) DeleteCluster(ctx context.Context, req *containerpb.DeleteClusterRequest) (*containerpb.Operation, error) {
|
|
md, _ := metadata.FromIncomingContext(ctx)
|
|
if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
|
|
return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
|
|
}
|
|
s.reqs = append(s.reqs, req)
|
|
if s.err != nil {
|
|
return nil, s.err
|
|
}
|
|
return s.resps[0].(*containerpb.Operation), nil
|
|
}
|
|
|
|
func (s *mockClusterManagerServer) ListOperations(ctx context.Context, req *containerpb.ListOperationsRequest) (*containerpb.ListOperationsResponse, error) {
|
|
md, _ := metadata.FromIncomingContext(ctx)
|
|
if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
|
|
return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
|
|
}
|
|
s.reqs = append(s.reqs, req)
|
|
if s.err != nil {
|
|
return nil, s.err
|
|
}
|
|
return s.resps[0].(*containerpb.ListOperationsResponse), nil
|
|
}
|
|
|
|
func (s *mockClusterManagerServer) GetOperation(ctx context.Context, req *containerpb.GetOperationRequest) (*containerpb.Operation, error) {
|
|
md, _ := metadata.FromIncomingContext(ctx)
|
|
if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
|
|
return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
|
|
}
|
|
s.reqs = append(s.reqs, req)
|
|
if s.err != nil {
|
|
return nil, s.err
|
|
}
|
|
return s.resps[0].(*containerpb.Operation), nil
|
|
}
|
|
|
|
func (s *mockClusterManagerServer) CancelOperation(ctx context.Context, req *containerpb.CancelOperationRequest) (*emptypb.Empty, error) {
|
|
md, _ := metadata.FromIncomingContext(ctx)
|
|
if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
|
|
return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
|
|
}
|
|
s.reqs = append(s.reqs, req)
|
|
if s.err != nil {
|
|
return nil, s.err
|
|
}
|
|
return s.resps[0].(*emptypb.Empty), nil
|
|
}
|
|
|
|
func (s *mockClusterManagerServer) GetServerConfig(ctx context.Context, req *containerpb.GetServerConfigRequest) (*containerpb.ServerConfig, error) {
|
|
md, _ := metadata.FromIncomingContext(ctx)
|
|
if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
|
|
return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
|
|
}
|
|
s.reqs = append(s.reqs, req)
|
|
if s.err != nil {
|
|
return nil, s.err
|
|
}
|
|
return s.resps[0].(*containerpb.ServerConfig), nil
|
|
}
|
|
|
|
func (s *mockClusterManagerServer) ListNodePools(ctx context.Context, req *containerpb.ListNodePoolsRequest) (*containerpb.ListNodePoolsResponse, error) {
|
|
md, _ := metadata.FromIncomingContext(ctx)
|
|
if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
|
|
return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
|
|
}
|
|
s.reqs = append(s.reqs, req)
|
|
if s.err != nil {
|
|
return nil, s.err
|
|
}
|
|
return s.resps[0].(*containerpb.ListNodePoolsResponse), nil
|
|
}
|
|
|
|
func (s *mockClusterManagerServer) GetNodePool(ctx context.Context, req *containerpb.GetNodePoolRequest) (*containerpb.NodePool, error) {
|
|
md, _ := metadata.FromIncomingContext(ctx)
|
|
if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
|
|
return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
|
|
}
|
|
s.reqs = append(s.reqs, req)
|
|
if s.err != nil {
|
|
return nil, s.err
|
|
}
|
|
return s.resps[0].(*containerpb.NodePool), nil
|
|
}
|
|
|
|
func (s *mockClusterManagerServer) CreateNodePool(ctx context.Context, req *containerpb.CreateNodePoolRequest) (*containerpb.Operation, error) {
|
|
md, _ := metadata.FromIncomingContext(ctx)
|
|
if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
|
|
return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
|
|
}
|
|
s.reqs = append(s.reqs, req)
|
|
if s.err != nil {
|
|
return nil, s.err
|
|
}
|
|
return s.resps[0].(*containerpb.Operation), nil
|
|
}
|
|
|
|
func (s *mockClusterManagerServer) DeleteNodePool(ctx context.Context, req *containerpb.DeleteNodePoolRequest) (*containerpb.Operation, error) {
|
|
md, _ := metadata.FromIncomingContext(ctx)
|
|
if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
|
|
return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
|
|
}
|
|
s.reqs = append(s.reqs, req)
|
|
if s.err != nil {
|
|
return nil, s.err
|
|
}
|
|
return s.resps[0].(*containerpb.Operation), nil
|
|
}
|
|
|
|
func (s *mockClusterManagerServer) RollbackNodePoolUpgrade(ctx context.Context, req *containerpb.RollbackNodePoolUpgradeRequest) (*containerpb.Operation, error) {
|
|
md, _ := metadata.FromIncomingContext(ctx)
|
|
if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
|
|
return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
|
|
}
|
|
s.reqs = append(s.reqs, req)
|
|
if s.err != nil {
|
|
return nil, s.err
|
|
}
|
|
return s.resps[0].(*containerpb.Operation), nil
|
|
}
|
|
|
|
func (s *mockClusterManagerServer) SetNodePoolManagement(ctx context.Context, req *containerpb.SetNodePoolManagementRequest) (*containerpb.Operation, error) {
|
|
md, _ := metadata.FromIncomingContext(ctx)
|
|
if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
|
|
return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
|
|
}
|
|
s.reqs = append(s.reqs, req)
|
|
if s.err != nil {
|
|
return nil, s.err
|
|
}
|
|
return s.resps[0].(*containerpb.Operation), nil
|
|
}
|
|
|
|
func (s *mockClusterManagerServer) SetLabels(ctx context.Context, req *containerpb.SetLabelsRequest) (*containerpb.Operation, error) {
|
|
md, _ := metadata.FromIncomingContext(ctx)
|
|
if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
|
|
return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
|
|
}
|
|
s.reqs = append(s.reqs, req)
|
|
if s.err != nil {
|
|
return nil, s.err
|
|
}
|
|
return s.resps[0].(*containerpb.Operation), nil
|
|
}
|
|
|
|
func (s *mockClusterManagerServer) SetLegacyAbac(ctx context.Context, req *containerpb.SetLegacyAbacRequest) (*containerpb.Operation, error) {
|
|
md, _ := metadata.FromIncomingContext(ctx)
|
|
if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
|
|
return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
|
|
}
|
|
s.reqs = append(s.reqs, req)
|
|
if s.err != nil {
|
|
return nil, s.err
|
|
}
|
|
return s.resps[0].(*containerpb.Operation), nil
|
|
}
|
|
|
|
func (s *mockClusterManagerServer) StartIPRotation(ctx context.Context, req *containerpb.StartIPRotationRequest) (*containerpb.Operation, error) {
|
|
md, _ := metadata.FromIncomingContext(ctx)
|
|
if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
|
|
return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
|
|
}
|
|
s.reqs = append(s.reqs, req)
|
|
if s.err != nil {
|
|
return nil, s.err
|
|
}
|
|
return s.resps[0].(*containerpb.Operation), nil
|
|
}
|
|
|
|
func (s *mockClusterManagerServer) CompleteIPRotation(ctx context.Context, req *containerpb.CompleteIPRotationRequest) (*containerpb.Operation, error) {
|
|
md, _ := metadata.FromIncomingContext(ctx)
|
|
if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
|
|
return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
|
|
}
|
|
s.reqs = append(s.reqs, req)
|
|
if s.err != nil {
|
|
return nil, s.err
|
|
}
|
|
return s.resps[0].(*containerpb.Operation), nil
|
|
}
|
|
|
|
func (s *mockClusterManagerServer) SetNodePoolSize(ctx context.Context, req *containerpb.SetNodePoolSizeRequest) (*containerpb.Operation, error) {
|
|
md, _ := metadata.FromIncomingContext(ctx)
|
|
if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
|
|
return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
|
|
}
|
|
s.reqs = append(s.reqs, req)
|
|
if s.err != nil {
|
|
return nil, s.err
|
|
}
|
|
return s.resps[0].(*containerpb.Operation), nil
|
|
}
|
|
|
|
func (s *mockClusterManagerServer) SetNetworkPolicy(ctx context.Context, req *containerpb.SetNetworkPolicyRequest) (*containerpb.Operation, error) {
|
|
md, _ := metadata.FromIncomingContext(ctx)
|
|
if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
|
|
return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
|
|
}
|
|
s.reqs = append(s.reqs, req)
|
|
if s.err != nil {
|
|
return nil, s.err
|
|
}
|
|
return s.resps[0].(*containerpb.Operation), nil
|
|
}
|
|
|
|
func (s *mockClusterManagerServer) SetMaintenancePolicy(ctx context.Context, req *containerpb.SetMaintenancePolicyRequest) (*containerpb.Operation, error) {
|
|
md, _ := metadata.FromIncomingContext(ctx)
|
|
if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
|
|
return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
|
|
}
|
|
s.reqs = append(s.reqs, req)
|
|
if s.err != nil {
|
|
return nil, s.err
|
|
}
|
|
return s.resps[0].(*containerpb.Operation), nil
|
|
}
|
|
|
|
// clientOpt is the option tests should use to connect to the test server.
|
|
// It is initialized by TestMain.
|
|
var clientOpt option.ClientOption
|
|
|
|
var (
|
|
mockClusterManager mockClusterManagerServer
|
|
)
|
|
|
|
func TestMain(m *testing.M) {
|
|
flag.Parse()
|
|
|
|
serv := grpc.NewServer()
|
|
containerpb.RegisterClusterManagerServer(serv, &mockClusterManager)
|
|
|
|
lis, err := net.Listen("tcp", "localhost:0")
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
go serv.Serve(lis)
|
|
|
|
conn, err := grpc.Dial(lis.Addr().String(), grpc.WithInsecure())
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
clientOpt = option.WithGRPCConn(conn)
|
|
|
|
os.Exit(m.Run())
|
|
}
|
|
|
|
func TestClusterManagerListClusters(t *testing.T) {
|
|
var expectedResponse *containerpb.ListClustersResponse = &containerpb.ListClustersResponse{}
|
|
|
|
mockClusterManager.err = nil
|
|
mockClusterManager.reqs = nil
|
|
|
|
mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse)
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var request = &containerpb.ListClustersRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.ListClusters(context.Background(), request)
|
|
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) {
|
|
t.Errorf("wrong request %q, want %q", got, want)
|
|
}
|
|
|
|
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
|
|
t.Errorf("wrong response %q, want %q)", got, want)
|
|
}
|
|
}
|
|
|
|
func TestClusterManagerListClustersError(t *testing.T) {
|
|
errCode := codes.PermissionDenied
|
|
mockClusterManager.err = gstatus.Error(errCode, "test error")
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var request = &containerpb.ListClustersRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.ListClusters(context.Background(), request)
|
|
|
|
if st, ok := gstatus.FromError(err); !ok {
|
|
t.Errorf("got error %v, expected grpc error", err)
|
|
} else if c := st.Code(); c != errCode {
|
|
t.Errorf("got error code %q, want %q", c, errCode)
|
|
}
|
|
_ = resp
|
|
}
|
|
func TestClusterManagerGetCluster(t *testing.T) {
|
|
var name string = "name3373707"
|
|
var description string = "description-1724546052"
|
|
var initialNodeCount int32 = 1682564205
|
|
var loggingService string = "loggingService-1700501035"
|
|
var monitoringService string = "monitoringService1469270462"
|
|
var network string = "network1843485230"
|
|
var clusterIpv4Cidr string = "clusterIpv4Cidr-141875831"
|
|
var subnetwork string = "subnetwork-1302785042"
|
|
var enableKubernetesAlpha bool = false
|
|
var labelFingerprint string = "labelFingerprint714995737"
|
|
var selfLink string = "selfLink-1691268851"
|
|
var zone2 string = "zone2-696322977"
|
|
var endpoint string = "endpoint1741102485"
|
|
var initialClusterVersion string = "initialClusterVersion-276373352"
|
|
var currentMasterVersion string = "currentMasterVersion-920953983"
|
|
var currentNodeVersion string = "currentNodeVersion-407476063"
|
|
var createTime string = "createTime-493574096"
|
|
var statusMessage string = "statusMessage-239442758"
|
|
var nodeIpv4CidrSize int32 = 1181176815
|
|
var servicesIpv4Cidr string = "servicesIpv4Cidr1966438125"
|
|
var currentNodeCount int32 = 178977560
|
|
var expireTime string = "expireTime-96179731"
|
|
var expectedResponse = &containerpb.Cluster{
|
|
Name: name,
|
|
Description: description,
|
|
InitialNodeCount: initialNodeCount,
|
|
LoggingService: loggingService,
|
|
MonitoringService: monitoringService,
|
|
Network: network,
|
|
ClusterIpv4Cidr: clusterIpv4Cidr,
|
|
Subnetwork: subnetwork,
|
|
EnableKubernetesAlpha: enableKubernetesAlpha,
|
|
LabelFingerprint: labelFingerprint,
|
|
SelfLink: selfLink,
|
|
Zone: zone2,
|
|
Endpoint: endpoint,
|
|
InitialClusterVersion: initialClusterVersion,
|
|
CurrentMasterVersion: currentMasterVersion,
|
|
CurrentNodeVersion: currentNodeVersion,
|
|
CreateTime: createTime,
|
|
StatusMessage: statusMessage,
|
|
NodeIpv4CidrSize: nodeIpv4CidrSize,
|
|
ServicesIpv4Cidr: servicesIpv4Cidr,
|
|
CurrentNodeCount: currentNodeCount,
|
|
ExpireTime: expireTime,
|
|
}
|
|
|
|
mockClusterManager.err = nil
|
|
mockClusterManager.reqs = nil
|
|
|
|
mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse)
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var request = &containerpb.GetClusterRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.GetCluster(context.Background(), request)
|
|
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) {
|
|
t.Errorf("wrong request %q, want %q", got, want)
|
|
}
|
|
|
|
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
|
|
t.Errorf("wrong response %q, want %q)", got, want)
|
|
}
|
|
}
|
|
|
|
func TestClusterManagerGetClusterError(t *testing.T) {
|
|
errCode := codes.PermissionDenied
|
|
mockClusterManager.err = gstatus.Error(errCode, "test error")
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var request = &containerpb.GetClusterRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.GetCluster(context.Background(), request)
|
|
|
|
if st, ok := gstatus.FromError(err); !ok {
|
|
t.Errorf("got error %v, expected grpc error", err)
|
|
} else if c := st.Code(); c != errCode {
|
|
t.Errorf("got error code %q, want %q", c, errCode)
|
|
}
|
|
_ = resp
|
|
}
|
|
func TestClusterManagerCreateCluster(t *testing.T) {
|
|
var name string = "name3373707"
|
|
var zone2 string = "zone2-696322977"
|
|
var detail string = "detail-1335224239"
|
|
var statusMessage string = "statusMessage-239442758"
|
|
var selfLink string = "selfLink-1691268851"
|
|
var targetLink string = "targetLink-2084812312"
|
|
var startTime string = "startTime-1573145462"
|
|
var endTime string = "endTime1725551537"
|
|
var expectedResponse = &containerpb.Operation{
|
|
Name: name,
|
|
Zone: zone2,
|
|
Detail: detail,
|
|
StatusMessage: statusMessage,
|
|
SelfLink: selfLink,
|
|
TargetLink: targetLink,
|
|
StartTime: startTime,
|
|
EndTime: endTime,
|
|
}
|
|
|
|
mockClusterManager.err = nil
|
|
mockClusterManager.reqs = nil
|
|
|
|
mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse)
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var cluster *containerpb.Cluster = &containerpb.Cluster{}
|
|
var request = &containerpb.CreateClusterRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
Cluster: cluster,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.CreateCluster(context.Background(), request)
|
|
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) {
|
|
t.Errorf("wrong request %q, want %q", got, want)
|
|
}
|
|
|
|
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
|
|
t.Errorf("wrong response %q, want %q)", got, want)
|
|
}
|
|
}
|
|
|
|
func TestClusterManagerCreateClusterError(t *testing.T) {
|
|
errCode := codes.PermissionDenied
|
|
mockClusterManager.err = gstatus.Error(errCode, "test error")
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var cluster *containerpb.Cluster = &containerpb.Cluster{}
|
|
var request = &containerpb.CreateClusterRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
Cluster: cluster,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.CreateCluster(context.Background(), request)
|
|
|
|
if st, ok := gstatus.FromError(err); !ok {
|
|
t.Errorf("got error %v, expected grpc error", err)
|
|
} else if c := st.Code(); c != errCode {
|
|
t.Errorf("got error code %q, want %q", c, errCode)
|
|
}
|
|
_ = resp
|
|
}
|
|
func TestClusterManagerUpdateCluster(t *testing.T) {
|
|
var name string = "name3373707"
|
|
var zone2 string = "zone2-696322977"
|
|
var detail string = "detail-1335224239"
|
|
var statusMessage string = "statusMessage-239442758"
|
|
var selfLink string = "selfLink-1691268851"
|
|
var targetLink string = "targetLink-2084812312"
|
|
var startTime string = "startTime-1573145462"
|
|
var endTime string = "endTime1725551537"
|
|
var expectedResponse = &containerpb.Operation{
|
|
Name: name,
|
|
Zone: zone2,
|
|
Detail: detail,
|
|
StatusMessage: statusMessage,
|
|
SelfLink: selfLink,
|
|
TargetLink: targetLink,
|
|
StartTime: startTime,
|
|
EndTime: endTime,
|
|
}
|
|
|
|
mockClusterManager.err = nil
|
|
mockClusterManager.reqs = nil
|
|
|
|
mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse)
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var update *containerpb.ClusterUpdate = &containerpb.ClusterUpdate{}
|
|
var request = &containerpb.UpdateClusterRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
Update: update,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.UpdateCluster(context.Background(), request)
|
|
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) {
|
|
t.Errorf("wrong request %q, want %q", got, want)
|
|
}
|
|
|
|
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
|
|
t.Errorf("wrong response %q, want %q)", got, want)
|
|
}
|
|
}
|
|
|
|
func TestClusterManagerUpdateClusterError(t *testing.T) {
|
|
errCode := codes.PermissionDenied
|
|
mockClusterManager.err = gstatus.Error(errCode, "test error")
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var update *containerpb.ClusterUpdate = &containerpb.ClusterUpdate{}
|
|
var request = &containerpb.UpdateClusterRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
Update: update,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.UpdateCluster(context.Background(), request)
|
|
|
|
if st, ok := gstatus.FromError(err); !ok {
|
|
t.Errorf("got error %v, expected grpc error", err)
|
|
} else if c := st.Code(); c != errCode {
|
|
t.Errorf("got error code %q, want %q", c, errCode)
|
|
}
|
|
_ = resp
|
|
}
|
|
func TestClusterManagerUpdateNodePool(t *testing.T) {
|
|
var name string = "name3373707"
|
|
var zone2 string = "zone2-696322977"
|
|
var detail string = "detail-1335224239"
|
|
var statusMessage string = "statusMessage-239442758"
|
|
var selfLink string = "selfLink-1691268851"
|
|
var targetLink string = "targetLink-2084812312"
|
|
var startTime string = "startTime-1573145462"
|
|
var endTime string = "endTime1725551537"
|
|
var expectedResponse = &containerpb.Operation{
|
|
Name: name,
|
|
Zone: zone2,
|
|
Detail: detail,
|
|
StatusMessage: statusMessage,
|
|
SelfLink: selfLink,
|
|
TargetLink: targetLink,
|
|
StartTime: startTime,
|
|
EndTime: endTime,
|
|
}
|
|
|
|
mockClusterManager.err = nil
|
|
mockClusterManager.reqs = nil
|
|
|
|
mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse)
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var nodePoolId string = "nodePoolId1043384033"
|
|
var nodeVersion string = "nodeVersion1790136219"
|
|
var imageType string = "imageType-1442758754"
|
|
var request = &containerpb.UpdateNodePoolRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
NodePoolId: nodePoolId,
|
|
NodeVersion: nodeVersion,
|
|
ImageType: imageType,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.UpdateNodePool(context.Background(), request)
|
|
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) {
|
|
t.Errorf("wrong request %q, want %q", got, want)
|
|
}
|
|
|
|
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
|
|
t.Errorf("wrong response %q, want %q)", got, want)
|
|
}
|
|
}
|
|
|
|
func TestClusterManagerUpdateNodePoolError(t *testing.T) {
|
|
errCode := codes.PermissionDenied
|
|
mockClusterManager.err = gstatus.Error(errCode, "test error")
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var nodePoolId string = "nodePoolId1043384033"
|
|
var nodeVersion string = "nodeVersion1790136219"
|
|
var imageType string = "imageType-1442758754"
|
|
var request = &containerpb.UpdateNodePoolRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
NodePoolId: nodePoolId,
|
|
NodeVersion: nodeVersion,
|
|
ImageType: imageType,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.UpdateNodePool(context.Background(), request)
|
|
|
|
if st, ok := gstatus.FromError(err); !ok {
|
|
t.Errorf("got error %v, expected grpc error", err)
|
|
} else if c := st.Code(); c != errCode {
|
|
t.Errorf("got error code %q, want %q", c, errCode)
|
|
}
|
|
_ = resp
|
|
}
|
|
func TestClusterManagerSetNodePoolAutoscaling(t *testing.T) {
|
|
var name string = "name3373707"
|
|
var zone2 string = "zone2-696322977"
|
|
var detail string = "detail-1335224239"
|
|
var statusMessage string = "statusMessage-239442758"
|
|
var selfLink string = "selfLink-1691268851"
|
|
var targetLink string = "targetLink-2084812312"
|
|
var startTime string = "startTime-1573145462"
|
|
var endTime string = "endTime1725551537"
|
|
var expectedResponse = &containerpb.Operation{
|
|
Name: name,
|
|
Zone: zone2,
|
|
Detail: detail,
|
|
StatusMessage: statusMessage,
|
|
SelfLink: selfLink,
|
|
TargetLink: targetLink,
|
|
StartTime: startTime,
|
|
EndTime: endTime,
|
|
}
|
|
|
|
mockClusterManager.err = nil
|
|
mockClusterManager.reqs = nil
|
|
|
|
mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse)
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var nodePoolId string = "nodePoolId1043384033"
|
|
var autoscaling *containerpb.NodePoolAutoscaling = &containerpb.NodePoolAutoscaling{}
|
|
var request = &containerpb.SetNodePoolAutoscalingRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
NodePoolId: nodePoolId,
|
|
Autoscaling: autoscaling,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.SetNodePoolAutoscaling(context.Background(), request)
|
|
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) {
|
|
t.Errorf("wrong request %q, want %q", got, want)
|
|
}
|
|
|
|
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
|
|
t.Errorf("wrong response %q, want %q)", got, want)
|
|
}
|
|
}
|
|
|
|
func TestClusterManagerSetNodePoolAutoscalingError(t *testing.T) {
|
|
errCode := codes.PermissionDenied
|
|
mockClusterManager.err = gstatus.Error(errCode, "test error")
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var nodePoolId string = "nodePoolId1043384033"
|
|
var autoscaling *containerpb.NodePoolAutoscaling = &containerpb.NodePoolAutoscaling{}
|
|
var request = &containerpb.SetNodePoolAutoscalingRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
NodePoolId: nodePoolId,
|
|
Autoscaling: autoscaling,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.SetNodePoolAutoscaling(context.Background(), request)
|
|
|
|
if st, ok := gstatus.FromError(err); !ok {
|
|
t.Errorf("got error %v, expected grpc error", err)
|
|
} else if c := st.Code(); c != errCode {
|
|
t.Errorf("got error code %q, want %q", c, errCode)
|
|
}
|
|
_ = resp
|
|
}
|
|
func TestClusterManagerSetLoggingService(t *testing.T) {
|
|
var name string = "name3373707"
|
|
var zone2 string = "zone2-696322977"
|
|
var detail string = "detail-1335224239"
|
|
var statusMessage string = "statusMessage-239442758"
|
|
var selfLink string = "selfLink-1691268851"
|
|
var targetLink string = "targetLink-2084812312"
|
|
var startTime string = "startTime-1573145462"
|
|
var endTime string = "endTime1725551537"
|
|
var expectedResponse = &containerpb.Operation{
|
|
Name: name,
|
|
Zone: zone2,
|
|
Detail: detail,
|
|
StatusMessage: statusMessage,
|
|
SelfLink: selfLink,
|
|
TargetLink: targetLink,
|
|
StartTime: startTime,
|
|
EndTime: endTime,
|
|
}
|
|
|
|
mockClusterManager.err = nil
|
|
mockClusterManager.reqs = nil
|
|
|
|
mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse)
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var loggingService string = "loggingService-1700501035"
|
|
var request = &containerpb.SetLoggingServiceRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
LoggingService: loggingService,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.SetLoggingService(context.Background(), request)
|
|
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) {
|
|
t.Errorf("wrong request %q, want %q", got, want)
|
|
}
|
|
|
|
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
|
|
t.Errorf("wrong response %q, want %q)", got, want)
|
|
}
|
|
}
|
|
|
|
func TestClusterManagerSetLoggingServiceError(t *testing.T) {
|
|
errCode := codes.PermissionDenied
|
|
mockClusterManager.err = gstatus.Error(errCode, "test error")
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var loggingService string = "loggingService-1700501035"
|
|
var request = &containerpb.SetLoggingServiceRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
LoggingService: loggingService,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.SetLoggingService(context.Background(), request)
|
|
|
|
if st, ok := gstatus.FromError(err); !ok {
|
|
t.Errorf("got error %v, expected grpc error", err)
|
|
} else if c := st.Code(); c != errCode {
|
|
t.Errorf("got error code %q, want %q", c, errCode)
|
|
}
|
|
_ = resp
|
|
}
|
|
func TestClusterManagerSetMonitoringService(t *testing.T) {
|
|
var name string = "name3373707"
|
|
var zone2 string = "zone2-696322977"
|
|
var detail string = "detail-1335224239"
|
|
var statusMessage string = "statusMessage-239442758"
|
|
var selfLink string = "selfLink-1691268851"
|
|
var targetLink string = "targetLink-2084812312"
|
|
var startTime string = "startTime-1573145462"
|
|
var endTime string = "endTime1725551537"
|
|
var expectedResponse = &containerpb.Operation{
|
|
Name: name,
|
|
Zone: zone2,
|
|
Detail: detail,
|
|
StatusMessage: statusMessage,
|
|
SelfLink: selfLink,
|
|
TargetLink: targetLink,
|
|
StartTime: startTime,
|
|
EndTime: endTime,
|
|
}
|
|
|
|
mockClusterManager.err = nil
|
|
mockClusterManager.reqs = nil
|
|
|
|
mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse)
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var monitoringService string = "monitoringService1469270462"
|
|
var request = &containerpb.SetMonitoringServiceRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
MonitoringService: monitoringService,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.SetMonitoringService(context.Background(), request)
|
|
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) {
|
|
t.Errorf("wrong request %q, want %q", got, want)
|
|
}
|
|
|
|
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
|
|
t.Errorf("wrong response %q, want %q)", got, want)
|
|
}
|
|
}
|
|
|
|
func TestClusterManagerSetMonitoringServiceError(t *testing.T) {
|
|
errCode := codes.PermissionDenied
|
|
mockClusterManager.err = gstatus.Error(errCode, "test error")
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var monitoringService string = "monitoringService1469270462"
|
|
var request = &containerpb.SetMonitoringServiceRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
MonitoringService: monitoringService,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.SetMonitoringService(context.Background(), request)
|
|
|
|
if st, ok := gstatus.FromError(err); !ok {
|
|
t.Errorf("got error %v, expected grpc error", err)
|
|
} else if c := st.Code(); c != errCode {
|
|
t.Errorf("got error code %q, want %q", c, errCode)
|
|
}
|
|
_ = resp
|
|
}
|
|
func TestClusterManagerSetAddonsConfig(t *testing.T) {
|
|
var name string = "name3373707"
|
|
var zone2 string = "zone2-696322977"
|
|
var detail string = "detail-1335224239"
|
|
var statusMessage string = "statusMessage-239442758"
|
|
var selfLink string = "selfLink-1691268851"
|
|
var targetLink string = "targetLink-2084812312"
|
|
var startTime string = "startTime-1573145462"
|
|
var endTime string = "endTime1725551537"
|
|
var expectedResponse = &containerpb.Operation{
|
|
Name: name,
|
|
Zone: zone2,
|
|
Detail: detail,
|
|
StatusMessage: statusMessage,
|
|
SelfLink: selfLink,
|
|
TargetLink: targetLink,
|
|
StartTime: startTime,
|
|
EndTime: endTime,
|
|
}
|
|
|
|
mockClusterManager.err = nil
|
|
mockClusterManager.reqs = nil
|
|
|
|
mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse)
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var addonsConfig *containerpb.AddonsConfig = &containerpb.AddonsConfig{}
|
|
var request = &containerpb.SetAddonsConfigRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
AddonsConfig: addonsConfig,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.SetAddonsConfig(context.Background(), request)
|
|
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) {
|
|
t.Errorf("wrong request %q, want %q", got, want)
|
|
}
|
|
|
|
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
|
|
t.Errorf("wrong response %q, want %q)", got, want)
|
|
}
|
|
}
|
|
|
|
func TestClusterManagerSetAddonsConfigError(t *testing.T) {
|
|
errCode := codes.PermissionDenied
|
|
mockClusterManager.err = gstatus.Error(errCode, "test error")
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var addonsConfig *containerpb.AddonsConfig = &containerpb.AddonsConfig{}
|
|
var request = &containerpb.SetAddonsConfigRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
AddonsConfig: addonsConfig,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.SetAddonsConfig(context.Background(), request)
|
|
|
|
if st, ok := gstatus.FromError(err); !ok {
|
|
t.Errorf("got error %v, expected grpc error", err)
|
|
} else if c := st.Code(); c != errCode {
|
|
t.Errorf("got error code %q, want %q", c, errCode)
|
|
}
|
|
_ = resp
|
|
}
|
|
func TestClusterManagerSetLocations(t *testing.T) {
|
|
var name string = "name3373707"
|
|
var zone2 string = "zone2-696322977"
|
|
var detail string = "detail-1335224239"
|
|
var statusMessage string = "statusMessage-239442758"
|
|
var selfLink string = "selfLink-1691268851"
|
|
var targetLink string = "targetLink-2084812312"
|
|
var startTime string = "startTime-1573145462"
|
|
var endTime string = "endTime1725551537"
|
|
var expectedResponse = &containerpb.Operation{
|
|
Name: name,
|
|
Zone: zone2,
|
|
Detail: detail,
|
|
StatusMessage: statusMessage,
|
|
SelfLink: selfLink,
|
|
TargetLink: targetLink,
|
|
StartTime: startTime,
|
|
EndTime: endTime,
|
|
}
|
|
|
|
mockClusterManager.err = nil
|
|
mockClusterManager.reqs = nil
|
|
|
|
mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse)
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var locations []string = nil
|
|
var request = &containerpb.SetLocationsRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
Locations: locations,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.SetLocations(context.Background(), request)
|
|
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) {
|
|
t.Errorf("wrong request %q, want %q", got, want)
|
|
}
|
|
|
|
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
|
|
t.Errorf("wrong response %q, want %q)", got, want)
|
|
}
|
|
}
|
|
|
|
func TestClusterManagerSetLocationsError(t *testing.T) {
|
|
errCode := codes.PermissionDenied
|
|
mockClusterManager.err = gstatus.Error(errCode, "test error")
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var locations []string = nil
|
|
var request = &containerpb.SetLocationsRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
Locations: locations,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.SetLocations(context.Background(), request)
|
|
|
|
if st, ok := gstatus.FromError(err); !ok {
|
|
t.Errorf("got error %v, expected grpc error", err)
|
|
} else if c := st.Code(); c != errCode {
|
|
t.Errorf("got error code %q, want %q", c, errCode)
|
|
}
|
|
_ = resp
|
|
}
|
|
func TestClusterManagerUpdateMaster(t *testing.T) {
|
|
var name string = "name3373707"
|
|
var zone2 string = "zone2-696322977"
|
|
var detail string = "detail-1335224239"
|
|
var statusMessage string = "statusMessage-239442758"
|
|
var selfLink string = "selfLink-1691268851"
|
|
var targetLink string = "targetLink-2084812312"
|
|
var startTime string = "startTime-1573145462"
|
|
var endTime string = "endTime1725551537"
|
|
var expectedResponse = &containerpb.Operation{
|
|
Name: name,
|
|
Zone: zone2,
|
|
Detail: detail,
|
|
StatusMessage: statusMessage,
|
|
SelfLink: selfLink,
|
|
TargetLink: targetLink,
|
|
StartTime: startTime,
|
|
EndTime: endTime,
|
|
}
|
|
|
|
mockClusterManager.err = nil
|
|
mockClusterManager.reqs = nil
|
|
|
|
mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse)
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var masterVersion string = "masterVersion-2139460613"
|
|
var request = &containerpb.UpdateMasterRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
MasterVersion: masterVersion,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.UpdateMaster(context.Background(), request)
|
|
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) {
|
|
t.Errorf("wrong request %q, want %q", got, want)
|
|
}
|
|
|
|
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
|
|
t.Errorf("wrong response %q, want %q)", got, want)
|
|
}
|
|
}
|
|
|
|
func TestClusterManagerUpdateMasterError(t *testing.T) {
|
|
errCode := codes.PermissionDenied
|
|
mockClusterManager.err = gstatus.Error(errCode, "test error")
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var masterVersion string = "masterVersion-2139460613"
|
|
var request = &containerpb.UpdateMasterRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
MasterVersion: masterVersion,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.UpdateMaster(context.Background(), request)
|
|
|
|
if st, ok := gstatus.FromError(err); !ok {
|
|
t.Errorf("got error %v, expected grpc error", err)
|
|
} else if c := st.Code(); c != errCode {
|
|
t.Errorf("got error code %q, want %q", c, errCode)
|
|
}
|
|
_ = resp
|
|
}
|
|
func TestClusterManagerSetMasterAuth(t *testing.T) {
|
|
var name string = "name3373707"
|
|
var zone2 string = "zone2-696322977"
|
|
var detail string = "detail-1335224239"
|
|
var statusMessage string = "statusMessage-239442758"
|
|
var selfLink string = "selfLink-1691268851"
|
|
var targetLink string = "targetLink-2084812312"
|
|
var startTime string = "startTime-1573145462"
|
|
var endTime string = "endTime1725551537"
|
|
var expectedResponse = &containerpb.Operation{
|
|
Name: name,
|
|
Zone: zone2,
|
|
Detail: detail,
|
|
StatusMessage: statusMessage,
|
|
SelfLink: selfLink,
|
|
TargetLink: targetLink,
|
|
StartTime: startTime,
|
|
EndTime: endTime,
|
|
}
|
|
|
|
mockClusterManager.err = nil
|
|
mockClusterManager.reqs = nil
|
|
|
|
mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse)
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var action containerpb.SetMasterAuthRequest_Action = containerpb.SetMasterAuthRequest_UNKNOWN
|
|
var update *containerpb.MasterAuth = &containerpb.MasterAuth{}
|
|
var request = &containerpb.SetMasterAuthRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
Action: action,
|
|
Update: update,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.SetMasterAuth(context.Background(), request)
|
|
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) {
|
|
t.Errorf("wrong request %q, want %q", got, want)
|
|
}
|
|
|
|
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
|
|
t.Errorf("wrong response %q, want %q)", got, want)
|
|
}
|
|
}
|
|
|
|
func TestClusterManagerSetMasterAuthError(t *testing.T) {
|
|
errCode := codes.PermissionDenied
|
|
mockClusterManager.err = gstatus.Error(errCode, "test error")
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var action containerpb.SetMasterAuthRequest_Action = containerpb.SetMasterAuthRequest_UNKNOWN
|
|
var update *containerpb.MasterAuth = &containerpb.MasterAuth{}
|
|
var request = &containerpb.SetMasterAuthRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
Action: action,
|
|
Update: update,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.SetMasterAuth(context.Background(), request)
|
|
|
|
if st, ok := gstatus.FromError(err); !ok {
|
|
t.Errorf("got error %v, expected grpc error", err)
|
|
} else if c := st.Code(); c != errCode {
|
|
t.Errorf("got error code %q, want %q", c, errCode)
|
|
}
|
|
_ = resp
|
|
}
|
|
func TestClusterManagerDeleteCluster(t *testing.T) {
|
|
var name string = "name3373707"
|
|
var zone2 string = "zone2-696322977"
|
|
var detail string = "detail-1335224239"
|
|
var statusMessage string = "statusMessage-239442758"
|
|
var selfLink string = "selfLink-1691268851"
|
|
var targetLink string = "targetLink-2084812312"
|
|
var startTime string = "startTime-1573145462"
|
|
var endTime string = "endTime1725551537"
|
|
var expectedResponse = &containerpb.Operation{
|
|
Name: name,
|
|
Zone: zone2,
|
|
Detail: detail,
|
|
StatusMessage: statusMessage,
|
|
SelfLink: selfLink,
|
|
TargetLink: targetLink,
|
|
StartTime: startTime,
|
|
EndTime: endTime,
|
|
}
|
|
|
|
mockClusterManager.err = nil
|
|
mockClusterManager.reqs = nil
|
|
|
|
mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse)
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var request = &containerpb.DeleteClusterRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.DeleteCluster(context.Background(), request)
|
|
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) {
|
|
t.Errorf("wrong request %q, want %q", got, want)
|
|
}
|
|
|
|
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
|
|
t.Errorf("wrong response %q, want %q)", got, want)
|
|
}
|
|
}
|
|
|
|
func TestClusterManagerDeleteClusterError(t *testing.T) {
|
|
errCode := codes.PermissionDenied
|
|
mockClusterManager.err = gstatus.Error(errCode, "test error")
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var request = &containerpb.DeleteClusterRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.DeleteCluster(context.Background(), request)
|
|
|
|
if st, ok := gstatus.FromError(err); !ok {
|
|
t.Errorf("got error %v, expected grpc error", err)
|
|
} else if c := st.Code(); c != errCode {
|
|
t.Errorf("got error code %q, want %q", c, errCode)
|
|
}
|
|
_ = resp
|
|
}
|
|
func TestClusterManagerListOperations(t *testing.T) {
|
|
var expectedResponse *containerpb.ListOperationsResponse = &containerpb.ListOperationsResponse{}
|
|
|
|
mockClusterManager.err = nil
|
|
mockClusterManager.reqs = nil
|
|
|
|
mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse)
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var request = &containerpb.ListOperationsRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.ListOperations(context.Background(), request)
|
|
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) {
|
|
t.Errorf("wrong request %q, want %q", got, want)
|
|
}
|
|
|
|
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
|
|
t.Errorf("wrong response %q, want %q)", got, want)
|
|
}
|
|
}
|
|
|
|
func TestClusterManagerListOperationsError(t *testing.T) {
|
|
errCode := codes.PermissionDenied
|
|
mockClusterManager.err = gstatus.Error(errCode, "test error")
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var request = &containerpb.ListOperationsRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.ListOperations(context.Background(), request)
|
|
|
|
if st, ok := gstatus.FromError(err); !ok {
|
|
t.Errorf("got error %v, expected grpc error", err)
|
|
} else if c := st.Code(); c != errCode {
|
|
t.Errorf("got error code %q, want %q", c, errCode)
|
|
}
|
|
_ = resp
|
|
}
|
|
func TestClusterManagerGetOperation(t *testing.T) {
|
|
var name string = "name3373707"
|
|
var zone2 string = "zone2-696322977"
|
|
var detail string = "detail-1335224239"
|
|
var statusMessage string = "statusMessage-239442758"
|
|
var selfLink string = "selfLink-1691268851"
|
|
var targetLink string = "targetLink-2084812312"
|
|
var startTime string = "startTime-1573145462"
|
|
var endTime string = "endTime1725551537"
|
|
var expectedResponse = &containerpb.Operation{
|
|
Name: name,
|
|
Zone: zone2,
|
|
Detail: detail,
|
|
StatusMessage: statusMessage,
|
|
SelfLink: selfLink,
|
|
TargetLink: targetLink,
|
|
StartTime: startTime,
|
|
EndTime: endTime,
|
|
}
|
|
|
|
mockClusterManager.err = nil
|
|
mockClusterManager.reqs = nil
|
|
|
|
mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse)
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var operationId string = "operationId-274116877"
|
|
var request = &containerpb.GetOperationRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
OperationId: operationId,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.GetOperation(context.Background(), request)
|
|
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) {
|
|
t.Errorf("wrong request %q, want %q", got, want)
|
|
}
|
|
|
|
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
|
|
t.Errorf("wrong response %q, want %q)", got, want)
|
|
}
|
|
}
|
|
|
|
func TestClusterManagerGetOperationError(t *testing.T) {
|
|
errCode := codes.PermissionDenied
|
|
mockClusterManager.err = gstatus.Error(errCode, "test error")
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var operationId string = "operationId-274116877"
|
|
var request = &containerpb.GetOperationRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
OperationId: operationId,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.GetOperation(context.Background(), request)
|
|
|
|
if st, ok := gstatus.FromError(err); !ok {
|
|
t.Errorf("got error %v, expected grpc error", err)
|
|
} else if c := st.Code(); c != errCode {
|
|
t.Errorf("got error code %q, want %q", c, errCode)
|
|
}
|
|
_ = resp
|
|
}
|
|
func TestClusterManagerCancelOperation(t *testing.T) {
|
|
var expectedResponse *emptypb.Empty = &emptypb.Empty{}
|
|
|
|
mockClusterManager.err = nil
|
|
mockClusterManager.reqs = nil
|
|
|
|
mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse)
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var operationId string = "operationId-274116877"
|
|
var request = &containerpb.CancelOperationRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
OperationId: operationId,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
err = c.CancelOperation(context.Background(), request)
|
|
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) {
|
|
t.Errorf("wrong request %q, want %q", got, want)
|
|
}
|
|
|
|
}
|
|
|
|
func TestClusterManagerCancelOperationError(t *testing.T) {
|
|
errCode := codes.PermissionDenied
|
|
mockClusterManager.err = gstatus.Error(errCode, "test error")
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var operationId string = "operationId-274116877"
|
|
var request = &containerpb.CancelOperationRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
OperationId: operationId,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
err = c.CancelOperation(context.Background(), request)
|
|
|
|
if st, ok := gstatus.FromError(err); !ok {
|
|
t.Errorf("got error %v, expected grpc error", err)
|
|
} else if c := st.Code(); c != errCode {
|
|
t.Errorf("got error code %q, want %q", c, errCode)
|
|
}
|
|
}
|
|
func TestClusterManagerGetServerConfig(t *testing.T) {
|
|
var defaultClusterVersion string = "defaultClusterVersion111003029"
|
|
var defaultImageType string = "defaultImageType-918225828"
|
|
var expectedResponse = &containerpb.ServerConfig{
|
|
DefaultClusterVersion: defaultClusterVersion,
|
|
DefaultImageType: defaultImageType,
|
|
}
|
|
|
|
mockClusterManager.err = nil
|
|
mockClusterManager.reqs = nil
|
|
|
|
mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse)
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var request = &containerpb.GetServerConfigRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.GetServerConfig(context.Background(), request)
|
|
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) {
|
|
t.Errorf("wrong request %q, want %q", got, want)
|
|
}
|
|
|
|
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
|
|
t.Errorf("wrong response %q, want %q)", got, want)
|
|
}
|
|
}
|
|
|
|
func TestClusterManagerGetServerConfigError(t *testing.T) {
|
|
errCode := codes.PermissionDenied
|
|
mockClusterManager.err = gstatus.Error(errCode, "test error")
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var request = &containerpb.GetServerConfigRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.GetServerConfig(context.Background(), request)
|
|
|
|
if st, ok := gstatus.FromError(err); !ok {
|
|
t.Errorf("got error %v, expected grpc error", err)
|
|
} else if c := st.Code(); c != errCode {
|
|
t.Errorf("got error code %q, want %q", c, errCode)
|
|
}
|
|
_ = resp
|
|
}
|
|
func TestClusterManagerListNodePools(t *testing.T) {
|
|
var expectedResponse *containerpb.ListNodePoolsResponse = &containerpb.ListNodePoolsResponse{}
|
|
|
|
mockClusterManager.err = nil
|
|
mockClusterManager.reqs = nil
|
|
|
|
mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse)
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var request = &containerpb.ListNodePoolsRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.ListNodePools(context.Background(), request)
|
|
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) {
|
|
t.Errorf("wrong request %q, want %q", got, want)
|
|
}
|
|
|
|
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
|
|
t.Errorf("wrong response %q, want %q)", got, want)
|
|
}
|
|
}
|
|
|
|
func TestClusterManagerListNodePoolsError(t *testing.T) {
|
|
errCode := codes.PermissionDenied
|
|
mockClusterManager.err = gstatus.Error(errCode, "test error")
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var request = &containerpb.ListNodePoolsRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.ListNodePools(context.Background(), request)
|
|
|
|
if st, ok := gstatus.FromError(err); !ok {
|
|
t.Errorf("got error %v, expected grpc error", err)
|
|
} else if c := st.Code(); c != errCode {
|
|
t.Errorf("got error code %q, want %q", c, errCode)
|
|
}
|
|
_ = resp
|
|
}
|
|
func TestClusterManagerGetNodePool(t *testing.T) {
|
|
var name string = "name3373707"
|
|
var initialNodeCount int32 = 1682564205
|
|
var selfLink string = "selfLink-1691268851"
|
|
var version string = "version351608024"
|
|
var statusMessage string = "statusMessage-239442758"
|
|
var expectedResponse = &containerpb.NodePool{
|
|
Name: name,
|
|
InitialNodeCount: initialNodeCount,
|
|
SelfLink: selfLink,
|
|
Version: version,
|
|
StatusMessage: statusMessage,
|
|
}
|
|
|
|
mockClusterManager.err = nil
|
|
mockClusterManager.reqs = nil
|
|
|
|
mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse)
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var nodePoolId string = "nodePoolId1043384033"
|
|
var request = &containerpb.GetNodePoolRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
NodePoolId: nodePoolId,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.GetNodePool(context.Background(), request)
|
|
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) {
|
|
t.Errorf("wrong request %q, want %q", got, want)
|
|
}
|
|
|
|
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
|
|
t.Errorf("wrong response %q, want %q)", got, want)
|
|
}
|
|
}
|
|
|
|
func TestClusterManagerGetNodePoolError(t *testing.T) {
|
|
errCode := codes.PermissionDenied
|
|
mockClusterManager.err = gstatus.Error(errCode, "test error")
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var nodePoolId string = "nodePoolId1043384033"
|
|
var request = &containerpb.GetNodePoolRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
NodePoolId: nodePoolId,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.GetNodePool(context.Background(), request)
|
|
|
|
if st, ok := gstatus.FromError(err); !ok {
|
|
t.Errorf("got error %v, expected grpc error", err)
|
|
} else if c := st.Code(); c != errCode {
|
|
t.Errorf("got error code %q, want %q", c, errCode)
|
|
}
|
|
_ = resp
|
|
}
|
|
func TestClusterManagerCreateNodePool(t *testing.T) {
|
|
var name string = "name3373707"
|
|
var zone2 string = "zone2-696322977"
|
|
var detail string = "detail-1335224239"
|
|
var statusMessage string = "statusMessage-239442758"
|
|
var selfLink string = "selfLink-1691268851"
|
|
var targetLink string = "targetLink-2084812312"
|
|
var startTime string = "startTime-1573145462"
|
|
var endTime string = "endTime1725551537"
|
|
var expectedResponse = &containerpb.Operation{
|
|
Name: name,
|
|
Zone: zone2,
|
|
Detail: detail,
|
|
StatusMessage: statusMessage,
|
|
SelfLink: selfLink,
|
|
TargetLink: targetLink,
|
|
StartTime: startTime,
|
|
EndTime: endTime,
|
|
}
|
|
|
|
mockClusterManager.err = nil
|
|
mockClusterManager.reqs = nil
|
|
|
|
mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse)
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var nodePool *containerpb.NodePool = &containerpb.NodePool{}
|
|
var request = &containerpb.CreateNodePoolRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
NodePool: nodePool,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.CreateNodePool(context.Background(), request)
|
|
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) {
|
|
t.Errorf("wrong request %q, want %q", got, want)
|
|
}
|
|
|
|
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
|
|
t.Errorf("wrong response %q, want %q)", got, want)
|
|
}
|
|
}
|
|
|
|
func TestClusterManagerCreateNodePoolError(t *testing.T) {
|
|
errCode := codes.PermissionDenied
|
|
mockClusterManager.err = gstatus.Error(errCode, "test error")
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var nodePool *containerpb.NodePool = &containerpb.NodePool{}
|
|
var request = &containerpb.CreateNodePoolRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
NodePool: nodePool,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.CreateNodePool(context.Background(), request)
|
|
|
|
if st, ok := gstatus.FromError(err); !ok {
|
|
t.Errorf("got error %v, expected grpc error", err)
|
|
} else if c := st.Code(); c != errCode {
|
|
t.Errorf("got error code %q, want %q", c, errCode)
|
|
}
|
|
_ = resp
|
|
}
|
|
func TestClusterManagerDeleteNodePool(t *testing.T) {
|
|
var name string = "name3373707"
|
|
var zone2 string = "zone2-696322977"
|
|
var detail string = "detail-1335224239"
|
|
var statusMessage string = "statusMessage-239442758"
|
|
var selfLink string = "selfLink-1691268851"
|
|
var targetLink string = "targetLink-2084812312"
|
|
var startTime string = "startTime-1573145462"
|
|
var endTime string = "endTime1725551537"
|
|
var expectedResponse = &containerpb.Operation{
|
|
Name: name,
|
|
Zone: zone2,
|
|
Detail: detail,
|
|
StatusMessage: statusMessage,
|
|
SelfLink: selfLink,
|
|
TargetLink: targetLink,
|
|
StartTime: startTime,
|
|
EndTime: endTime,
|
|
}
|
|
|
|
mockClusterManager.err = nil
|
|
mockClusterManager.reqs = nil
|
|
|
|
mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse)
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var nodePoolId string = "nodePoolId1043384033"
|
|
var request = &containerpb.DeleteNodePoolRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
NodePoolId: nodePoolId,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.DeleteNodePool(context.Background(), request)
|
|
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) {
|
|
t.Errorf("wrong request %q, want %q", got, want)
|
|
}
|
|
|
|
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
|
|
t.Errorf("wrong response %q, want %q)", got, want)
|
|
}
|
|
}
|
|
|
|
func TestClusterManagerDeleteNodePoolError(t *testing.T) {
|
|
errCode := codes.PermissionDenied
|
|
mockClusterManager.err = gstatus.Error(errCode, "test error")
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var nodePoolId string = "nodePoolId1043384033"
|
|
var request = &containerpb.DeleteNodePoolRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
NodePoolId: nodePoolId,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.DeleteNodePool(context.Background(), request)
|
|
|
|
if st, ok := gstatus.FromError(err); !ok {
|
|
t.Errorf("got error %v, expected grpc error", err)
|
|
} else if c := st.Code(); c != errCode {
|
|
t.Errorf("got error code %q, want %q", c, errCode)
|
|
}
|
|
_ = resp
|
|
}
|
|
func TestClusterManagerRollbackNodePoolUpgrade(t *testing.T) {
|
|
var name string = "name3373707"
|
|
var zone2 string = "zone2-696322977"
|
|
var detail string = "detail-1335224239"
|
|
var statusMessage string = "statusMessage-239442758"
|
|
var selfLink string = "selfLink-1691268851"
|
|
var targetLink string = "targetLink-2084812312"
|
|
var startTime string = "startTime-1573145462"
|
|
var endTime string = "endTime1725551537"
|
|
var expectedResponse = &containerpb.Operation{
|
|
Name: name,
|
|
Zone: zone2,
|
|
Detail: detail,
|
|
StatusMessage: statusMessage,
|
|
SelfLink: selfLink,
|
|
TargetLink: targetLink,
|
|
StartTime: startTime,
|
|
EndTime: endTime,
|
|
}
|
|
|
|
mockClusterManager.err = nil
|
|
mockClusterManager.reqs = nil
|
|
|
|
mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse)
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var nodePoolId string = "nodePoolId1043384033"
|
|
var request = &containerpb.RollbackNodePoolUpgradeRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
NodePoolId: nodePoolId,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.RollbackNodePoolUpgrade(context.Background(), request)
|
|
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) {
|
|
t.Errorf("wrong request %q, want %q", got, want)
|
|
}
|
|
|
|
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
|
|
t.Errorf("wrong response %q, want %q)", got, want)
|
|
}
|
|
}
|
|
|
|
func TestClusterManagerRollbackNodePoolUpgradeError(t *testing.T) {
|
|
errCode := codes.PermissionDenied
|
|
mockClusterManager.err = gstatus.Error(errCode, "test error")
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var nodePoolId string = "nodePoolId1043384033"
|
|
var request = &containerpb.RollbackNodePoolUpgradeRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
NodePoolId: nodePoolId,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.RollbackNodePoolUpgrade(context.Background(), request)
|
|
|
|
if st, ok := gstatus.FromError(err); !ok {
|
|
t.Errorf("got error %v, expected grpc error", err)
|
|
} else if c := st.Code(); c != errCode {
|
|
t.Errorf("got error code %q, want %q", c, errCode)
|
|
}
|
|
_ = resp
|
|
}
|
|
func TestClusterManagerSetNodePoolManagement(t *testing.T) {
|
|
var name string = "name3373707"
|
|
var zone2 string = "zone2-696322977"
|
|
var detail string = "detail-1335224239"
|
|
var statusMessage string = "statusMessage-239442758"
|
|
var selfLink string = "selfLink-1691268851"
|
|
var targetLink string = "targetLink-2084812312"
|
|
var startTime string = "startTime-1573145462"
|
|
var endTime string = "endTime1725551537"
|
|
var expectedResponse = &containerpb.Operation{
|
|
Name: name,
|
|
Zone: zone2,
|
|
Detail: detail,
|
|
StatusMessage: statusMessage,
|
|
SelfLink: selfLink,
|
|
TargetLink: targetLink,
|
|
StartTime: startTime,
|
|
EndTime: endTime,
|
|
}
|
|
|
|
mockClusterManager.err = nil
|
|
mockClusterManager.reqs = nil
|
|
|
|
mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse)
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var nodePoolId string = "nodePoolId1043384033"
|
|
var management *containerpb.NodeManagement = &containerpb.NodeManagement{}
|
|
var request = &containerpb.SetNodePoolManagementRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
NodePoolId: nodePoolId,
|
|
Management: management,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.SetNodePoolManagement(context.Background(), request)
|
|
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) {
|
|
t.Errorf("wrong request %q, want %q", got, want)
|
|
}
|
|
|
|
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
|
|
t.Errorf("wrong response %q, want %q)", got, want)
|
|
}
|
|
}
|
|
|
|
func TestClusterManagerSetNodePoolManagementError(t *testing.T) {
|
|
errCode := codes.PermissionDenied
|
|
mockClusterManager.err = gstatus.Error(errCode, "test error")
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var nodePoolId string = "nodePoolId1043384033"
|
|
var management *containerpb.NodeManagement = &containerpb.NodeManagement{}
|
|
var request = &containerpb.SetNodePoolManagementRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
NodePoolId: nodePoolId,
|
|
Management: management,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.SetNodePoolManagement(context.Background(), request)
|
|
|
|
if st, ok := gstatus.FromError(err); !ok {
|
|
t.Errorf("got error %v, expected grpc error", err)
|
|
} else if c := st.Code(); c != errCode {
|
|
t.Errorf("got error code %q, want %q", c, errCode)
|
|
}
|
|
_ = resp
|
|
}
|
|
func TestClusterManagerSetLabels(t *testing.T) {
|
|
var name string = "name3373707"
|
|
var zone2 string = "zone2-696322977"
|
|
var detail string = "detail-1335224239"
|
|
var statusMessage string = "statusMessage-239442758"
|
|
var selfLink string = "selfLink-1691268851"
|
|
var targetLink string = "targetLink-2084812312"
|
|
var startTime string = "startTime-1573145462"
|
|
var endTime string = "endTime1725551537"
|
|
var expectedResponse = &containerpb.Operation{
|
|
Name: name,
|
|
Zone: zone2,
|
|
Detail: detail,
|
|
StatusMessage: statusMessage,
|
|
SelfLink: selfLink,
|
|
TargetLink: targetLink,
|
|
StartTime: startTime,
|
|
EndTime: endTime,
|
|
}
|
|
|
|
mockClusterManager.err = nil
|
|
mockClusterManager.reqs = nil
|
|
|
|
mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse)
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var resourceLabels map[string]string = nil
|
|
var labelFingerprint string = "labelFingerprint714995737"
|
|
var request = &containerpb.SetLabelsRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
ResourceLabels: resourceLabels,
|
|
LabelFingerprint: labelFingerprint,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.SetLabels(context.Background(), request)
|
|
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) {
|
|
t.Errorf("wrong request %q, want %q", got, want)
|
|
}
|
|
|
|
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
|
|
t.Errorf("wrong response %q, want %q)", got, want)
|
|
}
|
|
}
|
|
|
|
func TestClusterManagerSetLabelsError(t *testing.T) {
|
|
errCode := codes.PermissionDenied
|
|
mockClusterManager.err = gstatus.Error(errCode, "test error")
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var resourceLabels map[string]string = nil
|
|
var labelFingerprint string = "labelFingerprint714995737"
|
|
var request = &containerpb.SetLabelsRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
ResourceLabels: resourceLabels,
|
|
LabelFingerprint: labelFingerprint,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.SetLabels(context.Background(), request)
|
|
|
|
if st, ok := gstatus.FromError(err); !ok {
|
|
t.Errorf("got error %v, expected grpc error", err)
|
|
} else if c := st.Code(); c != errCode {
|
|
t.Errorf("got error code %q, want %q", c, errCode)
|
|
}
|
|
_ = resp
|
|
}
|
|
func TestClusterManagerSetLegacyAbac(t *testing.T) {
|
|
var name string = "name3373707"
|
|
var zone2 string = "zone2-696322977"
|
|
var detail string = "detail-1335224239"
|
|
var statusMessage string = "statusMessage-239442758"
|
|
var selfLink string = "selfLink-1691268851"
|
|
var targetLink string = "targetLink-2084812312"
|
|
var startTime string = "startTime-1573145462"
|
|
var endTime string = "endTime1725551537"
|
|
var expectedResponse = &containerpb.Operation{
|
|
Name: name,
|
|
Zone: zone2,
|
|
Detail: detail,
|
|
StatusMessage: statusMessage,
|
|
SelfLink: selfLink,
|
|
TargetLink: targetLink,
|
|
StartTime: startTime,
|
|
EndTime: endTime,
|
|
}
|
|
|
|
mockClusterManager.err = nil
|
|
mockClusterManager.reqs = nil
|
|
|
|
mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse)
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var enabled bool = false
|
|
var request = &containerpb.SetLegacyAbacRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
Enabled: enabled,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.SetLegacyAbac(context.Background(), request)
|
|
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) {
|
|
t.Errorf("wrong request %q, want %q", got, want)
|
|
}
|
|
|
|
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
|
|
t.Errorf("wrong response %q, want %q)", got, want)
|
|
}
|
|
}
|
|
|
|
func TestClusterManagerSetLegacyAbacError(t *testing.T) {
|
|
errCode := codes.PermissionDenied
|
|
mockClusterManager.err = gstatus.Error(errCode, "test error")
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var enabled bool = false
|
|
var request = &containerpb.SetLegacyAbacRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
Enabled: enabled,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.SetLegacyAbac(context.Background(), request)
|
|
|
|
if st, ok := gstatus.FromError(err); !ok {
|
|
t.Errorf("got error %v, expected grpc error", err)
|
|
} else if c := st.Code(); c != errCode {
|
|
t.Errorf("got error code %q, want %q", c, errCode)
|
|
}
|
|
_ = resp
|
|
}
|
|
func TestClusterManagerStartIPRotation(t *testing.T) {
|
|
var name string = "name3373707"
|
|
var zone2 string = "zone2-696322977"
|
|
var detail string = "detail-1335224239"
|
|
var statusMessage string = "statusMessage-239442758"
|
|
var selfLink string = "selfLink-1691268851"
|
|
var targetLink string = "targetLink-2084812312"
|
|
var startTime string = "startTime-1573145462"
|
|
var endTime string = "endTime1725551537"
|
|
var expectedResponse = &containerpb.Operation{
|
|
Name: name,
|
|
Zone: zone2,
|
|
Detail: detail,
|
|
StatusMessage: statusMessage,
|
|
SelfLink: selfLink,
|
|
TargetLink: targetLink,
|
|
StartTime: startTime,
|
|
EndTime: endTime,
|
|
}
|
|
|
|
mockClusterManager.err = nil
|
|
mockClusterManager.reqs = nil
|
|
|
|
mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse)
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var request = &containerpb.StartIPRotationRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.StartIPRotation(context.Background(), request)
|
|
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) {
|
|
t.Errorf("wrong request %q, want %q", got, want)
|
|
}
|
|
|
|
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
|
|
t.Errorf("wrong response %q, want %q)", got, want)
|
|
}
|
|
}
|
|
|
|
func TestClusterManagerStartIPRotationError(t *testing.T) {
|
|
errCode := codes.PermissionDenied
|
|
mockClusterManager.err = gstatus.Error(errCode, "test error")
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var request = &containerpb.StartIPRotationRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.StartIPRotation(context.Background(), request)
|
|
|
|
if st, ok := gstatus.FromError(err); !ok {
|
|
t.Errorf("got error %v, expected grpc error", err)
|
|
} else if c := st.Code(); c != errCode {
|
|
t.Errorf("got error code %q, want %q", c, errCode)
|
|
}
|
|
_ = resp
|
|
}
|
|
func TestClusterManagerCompleteIPRotation(t *testing.T) {
|
|
var name string = "name3373707"
|
|
var zone2 string = "zone2-696322977"
|
|
var detail string = "detail-1335224239"
|
|
var statusMessage string = "statusMessage-239442758"
|
|
var selfLink string = "selfLink-1691268851"
|
|
var targetLink string = "targetLink-2084812312"
|
|
var startTime string = "startTime-1573145462"
|
|
var endTime string = "endTime1725551537"
|
|
var expectedResponse = &containerpb.Operation{
|
|
Name: name,
|
|
Zone: zone2,
|
|
Detail: detail,
|
|
StatusMessage: statusMessage,
|
|
SelfLink: selfLink,
|
|
TargetLink: targetLink,
|
|
StartTime: startTime,
|
|
EndTime: endTime,
|
|
}
|
|
|
|
mockClusterManager.err = nil
|
|
mockClusterManager.reqs = nil
|
|
|
|
mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse)
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var request = &containerpb.CompleteIPRotationRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.CompleteIPRotation(context.Background(), request)
|
|
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) {
|
|
t.Errorf("wrong request %q, want %q", got, want)
|
|
}
|
|
|
|
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
|
|
t.Errorf("wrong response %q, want %q)", got, want)
|
|
}
|
|
}
|
|
|
|
func TestClusterManagerCompleteIPRotationError(t *testing.T) {
|
|
errCode := codes.PermissionDenied
|
|
mockClusterManager.err = gstatus.Error(errCode, "test error")
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var request = &containerpb.CompleteIPRotationRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.CompleteIPRotation(context.Background(), request)
|
|
|
|
if st, ok := gstatus.FromError(err); !ok {
|
|
t.Errorf("got error %v, expected grpc error", err)
|
|
} else if c := st.Code(); c != errCode {
|
|
t.Errorf("got error code %q, want %q", c, errCode)
|
|
}
|
|
_ = resp
|
|
}
|
|
func TestClusterManagerSetNodePoolSize(t *testing.T) {
|
|
var name string = "name3373707"
|
|
var zone2 string = "zone2-696322977"
|
|
var detail string = "detail-1335224239"
|
|
var statusMessage string = "statusMessage-239442758"
|
|
var selfLink string = "selfLink-1691268851"
|
|
var targetLink string = "targetLink-2084812312"
|
|
var startTime string = "startTime-1573145462"
|
|
var endTime string = "endTime1725551537"
|
|
var expectedResponse = &containerpb.Operation{
|
|
Name: name,
|
|
Zone: zone2,
|
|
Detail: detail,
|
|
StatusMessage: statusMessage,
|
|
SelfLink: selfLink,
|
|
TargetLink: targetLink,
|
|
StartTime: startTime,
|
|
EndTime: endTime,
|
|
}
|
|
|
|
mockClusterManager.err = nil
|
|
mockClusterManager.reqs = nil
|
|
|
|
mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse)
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var nodePoolId string = "nodePoolId1043384033"
|
|
var nodeCount int32 = 1539922066
|
|
var request = &containerpb.SetNodePoolSizeRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
NodePoolId: nodePoolId,
|
|
NodeCount: nodeCount,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.SetNodePoolSize(context.Background(), request)
|
|
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) {
|
|
t.Errorf("wrong request %q, want %q", got, want)
|
|
}
|
|
|
|
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
|
|
t.Errorf("wrong response %q, want %q)", got, want)
|
|
}
|
|
}
|
|
|
|
func TestClusterManagerSetNodePoolSizeError(t *testing.T) {
|
|
errCode := codes.PermissionDenied
|
|
mockClusterManager.err = gstatus.Error(errCode, "test error")
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var nodePoolId string = "nodePoolId1043384033"
|
|
var nodeCount int32 = 1539922066
|
|
var request = &containerpb.SetNodePoolSizeRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
NodePoolId: nodePoolId,
|
|
NodeCount: nodeCount,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.SetNodePoolSize(context.Background(), request)
|
|
|
|
if st, ok := gstatus.FromError(err); !ok {
|
|
t.Errorf("got error %v, expected grpc error", err)
|
|
} else if c := st.Code(); c != errCode {
|
|
t.Errorf("got error code %q, want %q", c, errCode)
|
|
}
|
|
_ = resp
|
|
}
|
|
func TestClusterManagerSetNetworkPolicy(t *testing.T) {
|
|
var name string = "name3373707"
|
|
var zone2 string = "zone2-696322977"
|
|
var detail string = "detail-1335224239"
|
|
var statusMessage string = "statusMessage-239442758"
|
|
var selfLink string = "selfLink-1691268851"
|
|
var targetLink string = "targetLink-2084812312"
|
|
var startTime string = "startTime-1573145462"
|
|
var endTime string = "endTime1725551537"
|
|
var expectedResponse = &containerpb.Operation{
|
|
Name: name,
|
|
Zone: zone2,
|
|
Detail: detail,
|
|
StatusMessage: statusMessage,
|
|
SelfLink: selfLink,
|
|
TargetLink: targetLink,
|
|
StartTime: startTime,
|
|
EndTime: endTime,
|
|
}
|
|
|
|
mockClusterManager.err = nil
|
|
mockClusterManager.reqs = nil
|
|
|
|
mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse)
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var networkPolicy *containerpb.NetworkPolicy = &containerpb.NetworkPolicy{}
|
|
var request = &containerpb.SetNetworkPolicyRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
NetworkPolicy: networkPolicy,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.SetNetworkPolicy(context.Background(), request)
|
|
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) {
|
|
t.Errorf("wrong request %q, want %q", got, want)
|
|
}
|
|
|
|
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
|
|
t.Errorf("wrong response %q, want %q)", got, want)
|
|
}
|
|
}
|
|
|
|
func TestClusterManagerSetNetworkPolicyError(t *testing.T) {
|
|
errCode := codes.PermissionDenied
|
|
mockClusterManager.err = gstatus.Error(errCode, "test error")
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var networkPolicy *containerpb.NetworkPolicy = &containerpb.NetworkPolicy{}
|
|
var request = &containerpb.SetNetworkPolicyRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
NetworkPolicy: networkPolicy,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.SetNetworkPolicy(context.Background(), request)
|
|
|
|
if st, ok := gstatus.FromError(err); !ok {
|
|
t.Errorf("got error %v, expected grpc error", err)
|
|
} else if c := st.Code(); c != errCode {
|
|
t.Errorf("got error code %q, want %q", c, errCode)
|
|
}
|
|
_ = resp
|
|
}
|
|
func TestClusterManagerSetMaintenancePolicy(t *testing.T) {
|
|
var name string = "name3373707"
|
|
var zone2 string = "zone2-696322977"
|
|
var detail string = "detail-1335224239"
|
|
var statusMessage string = "statusMessage-239442758"
|
|
var selfLink string = "selfLink-1691268851"
|
|
var targetLink string = "targetLink-2084812312"
|
|
var startTime string = "startTime-1573145462"
|
|
var endTime string = "endTime1725551537"
|
|
var expectedResponse = &containerpb.Operation{
|
|
Name: name,
|
|
Zone: zone2,
|
|
Detail: detail,
|
|
StatusMessage: statusMessage,
|
|
SelfLink: selfLink,
|
|
TargetLink: targetLink,
|
|
StartTime: startTime,
|
|
EndTime: endTime,
|
|
}
|
|
|
|
mockClusterManager.err = nil
|
|
mockClusterManager.reqs = nil
|
|
|
|
mockClusterManager.resps = append(mockClusterManager.resps[:0], expectedResponse)
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var maintenancePolicy *containerpb.MaintenancePolicy = &containerpb.MaintenancePolicy{}
|
|
var request = &containerpb.SetMaintenancePolicyRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
MaintenancePolicy: maintenancePolicy,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.SetMaintenancePolicy(context.Background(), request)
|
|
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if want, got := request, mockClusterManager.reqs[0]; !proto.Equal(want, got) {
|
|
t.Errorf("wrong request %q, want %q", got, want)
|
|
}
|
|
|
|
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
|
|
t.Errorf("wrong response %q, want %q)", got, want)
|
|
}
|
|
}
|
|
|
|
func TestClusterManagerSetMaintenancePolicyError(t *testing.T) {
|
|
errCode := codes.PermissionDenied
|
|
mockClusterManager.err = gstatus.Error(errCode, "test error")
|
|
|
|
var projectId string = "projectId-1969970175"
|
|
var zone string = "zone3744684"
|
|
var clusterId string = "clusterId240280960"
|
|
var maintenancePolicy *containerpb.MaintenancePolicy = &containerpb.MaintenancePolicy{}
|
|
var request = &containerpb.SetMaintenancePolicyRequest{
|
|
ProjectId: projectId,
|
|
Zone: zone,
|
|
ClusterId: clusterId,
|
|
MaintenancePolicy: maintenancePolicy,
|
|
}
|
|
|
|
c, err := NewClusterManagerClient(context.Background(), clientOpt)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resp, err := c.SetMaintenancePolicy(context.Background(), request)
|
|
|
|
if st, ok := gstatus.FromError(err); !ok {
|
|
t.Errorf("got error %v, expected grpc error", err)
|
|
} else if c := st.Code(); c != errCode {
|
|
t.Errorf("got error code %q, want %q", c, errCode)
|
|
}
|
|
_ = resp
|
|
}
|