sigs.k8s.io/cluster-api@v1.7.1/cmd/clusterctl/client/alpha/rollout_pauser_test.go (about)

     1  /*
     2  Copyright 2020 The Kubernetes Authors.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8      http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package alpha
    18  
    19  import (
    20  	"context"
    21  	"testing"
    22  
    23  	. "github.com/onsi/gomega"
    24  	corev1 "k8s.io/api/core/v1"
    25  	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    26  	"sigs.k8s.io/controller-runtime/pkg/client"
    27  
    28  	clusterv1 "sigs.k8s.io/cluster-api/api/v1beta1"
    29  	"sigs.k8s.io/cluster-api/cmd/clusterctl/internal/test"
    30  	controlplanev1 "sigs.k8s.io/cluster-api/controlplane/kubeadm/api/v1beta1"
    31  	"sigs.k8s.io/cluster-api/util/annotations"
    32  )
    33  
    34  func Test_ObjectPauser(t *testing.T) {
    35  	type fields struct {
    36  		objs []client.Object
    37  		ref  corev1.ObjectReference
    38  	}
    39  	tests := []struct {
    40  		name       string
    41  		fields     fields
    42  		wantErr    bool
    43  		wantPaused bool
    44  	}{
    45  		{
    46  			name: "machinedeployment should be paused",
    47  			fields: fields{
    48  				objs: []client.Object{
    49  					&clusterv1.MachineDeployment{
    50  						TypeMeta: metav1.TypeMeta{
    51  							Kind: "MachineDeployment",
    52  						},
    53  						ObjectMeta: metav1.ObjectMeta{
    54  							Namespace: "default",
    55  							Name:      "md-1",
    56  						},
    57  					},
    58  				},
    59  				ref: corev1.ObjectReference{
    60  					Kind:      MachineDeployment,
    61  					Name:      "md-1",
    62  					Namespace: "default",
    63  				},
    64  			},
    65  			wantErr:    false,
    66  			wantPaused: true,
    67  		},
    68  		{
    69  			name: "re-pausing an already paused machinedeployment should return error",
    70  			fields: fields{
    71  				objs: []client.Object{
    72  					&clusterv1.MachineDeployment{
    73  						TypeMeta: metav1.TypeMeta{
    74  							Kind: "MachineDeployment",
    75  						},
    76  						ObjectMeta: metav1.ObjectMeta{
    77  							Namespace: "default",
    78  							Name:      "md-1",
    79  						},
    80  						Spec: clusterv1.MachineDeploymentSpec{
    81  							Paused: true,
    82  						},
    83  					},
    84  				},
    85  				ref: corev1.ObjectReference{
    86  					Kind:      MachineDeployment,
    87  					Name:      "md-1",
    88  					Namespace: "default",
    89  				},
    90  			},
    91  			wantErr:    true,
    92  			wantPaused: false,
    93  		},
    94  		{
    95  			name: "kubeadmcontrolplane should be paused",
    96  			fields: fields{
    97  				objs: []client.Object{
    98  					&controlplanev1.KubeadmControlPlane{
    99  						TypeMeta: metav1.TypeMeta{
   100  							Kind: "KubeadmControlPlane",
   101  						},
   102  						ObjectMeta: metav1.ObjectMeta{
   103  							Namespace: "default",
   104  							Name:      "kcp",
   105  						},
   106  					},
   107  				},
   108  				ref: corev1.ObjectReference{
   109  					Kind:      KubeadmControlPlane,
   110  					Name:      "kcp",
   111  					Namespace: "default",
   112  				},
   113  			},
   114  			wantErr:    false,
   115  			wantPaused: true,
   116  		},
   117  		{
   118  			name: "re-pausing an already paused kubeadmcontrolplane should return error",
   119  			fields: fields{
   120  				objs: []client.Object{
   121  					&controlplanev1.KubeadmControlPlane{
   122  						TypeMeta: metav1.TypeMeta{
   123  							Kind: "KubeadmControlPlane",
   124  						},
   125  						ObjectMeta: metav1.ObjectMeta{
   126  							Namespace: "default",
   127  							Name:      "kcp",
   128  							Annotations: map[string]string{
   129  								clusterv1.PausedAnnotation: "true",
   130  							},
   131  						},
   132  					},
   133  				},
   134  				ref: corev1.ObjectReference{
   135  					Kind:      KubeadmControlPlane,
   136  					Name:      "kcp",
   137  					Namespace: "default",
   138  				},
   139  			},
   140  			wantErr:    true,
   141  			wantPaused: false,
   142  		},
   143  	}
   144  	for _, tt := range tests {
   145  		t.Run(tt.name, func(t *testing.T) {
   146  			g := NewWithT(t)
   147  			r := newRolloutClient()
   148  			proxy := test.NewFakeProxy().WithObjs(tt.fields.objs...)
   149  			err := r.ObjectPauser(context.Background(), proxy, tt.fields.ref)
   150  			if tt.wantErr {
   151  				g.Expect(err).To(HaveOccurred())
   152  				return
   153  			}
   154  			g.Expect(err).ToNot(HaveOccurred())
   155  			for _, obj := range tt.fields.objs {
   156  				cl, err := proxy.NewClient(context.Background())
   157  				g.Expect(err).ToNot(HaveOccurred())
   158  				key := client.ObjectKeyFromObject(obj)
   159  				switch obj.(type) {
   160  				case *clusterv1.MachineDeployment:
   161  					md := &clusterv1.MachineDeployment{}
   162  					err = cl.Get(context.TODO(), key, md)
   163  					g.Expect(err).ToNot(HaveOccurred())
   164  					g.Expect(md.Spec.Paused).To(Equal(tt.wantPaused))
   165  				case *controlplanev1.KubeadmControlPlane:
   166  					kcp := &controlplanev1.KubeadmControlPlane{}
   167  					err = cl.Get(context.TODO(), key, kcp)
   168  					g.Expect(err).ToNot(HaveOccurred())
   169  					g.Expect(annotations.HasPaused(kcp.GetObjectMeta())).To(Equal(tt.wantPaused))
   170  				}
   171  			}
   172  		})
   173  	}
   174  }