Update unit tests

Author: chrischdi

internal/controllers/machinedeployment/machinedeployment_controller_test.go

@@ -26,13 +26,15 @@ import (
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/client-go/tools/record"
 	"k8s.io/client-go/util/retry"
+	utilfeature "k8s.io/component-base/featuregate/testing"
 	"k8s.io/utils/ptr"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/client/fake"
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 
 	clusterv1 "sigs.k8s.io/cluster-api/api/core/v1beta2"
 	"sigs.k8s.io/cluster-api/controllers/external"
+	"sigs.k8s.io/cluster-api/feature"
 	"sigs.k8s.io/cluster-api/util"
 	v1beta1conditions "sigs.k8s.io/cluster-api/util/conditions/deprecated/v1beta1"
 	"sigs.k8s.io/cluster-api/util/patch"
@@ -49,6 +51,8 @@ func TestMachineDeploymentReconciler(t *testing.T) {
 	setup := func(t *testing.T, g *WithT) (*corev1.Namespace, *clusterv1.Cluster) {
 		t.Helper()
 
+		utilfeature.SetFeatureGateDuringTest(t, feature.Gates, feature.MachineTaintPropagation, true)
+
 		t.Log("Creating the namespace")
 		ns, err := env.CreateNamespace(ctx, machineDeploymentNamespace)
 		g.Expect(err).ToNot(HaveOccurred())
@@ -416,6 +420,30 @@ func TestMachineDeploymentReconciler(t *testing.T) {
 			g.Expect(machineSets.Items[1].Spec.Deletion.Order).Should(Equal(clusterv1.NewestMachineSetDeletionOrder))
 		}).Should(Succeed())
 
+		// Update the taints of the MachineDeployment,
+		// expect the Reconcile to be called and the MachineSet to be updated in-place.
+		t.Log("Updating deletion.order on the MachineDeployment")
+		additionalTaint := clusterv1.MachineTaint{
+			Key:         "additional-taint-key",
+			Value:       "additional-taint-value",
+			Effect:      corev1.TaintEffectNoSchedule,
+			Propagation: clusterv1.MachineTaintPropagationAlways,
+		}
+		modifyFunc = func(d *clusterv1.MachineDeployment) {
+			d.Spec.Template.Spec.Taints = append(d.Spec.Template.Spec.Taints, additionalTaint)
+		}
+		g.Expect(updateMachineDeployment(ctx, env, deployment, modifyFunc)).To(Succeed())
+		g.Eventually(func(g Gomega) {
+			g.Expect(env.List(ctx, machineSets, msListOpts...)).Should(Succeed())
+			// Verify we still only have 2 MachineSets.
+			g.Expect(machineSets.Items).To(HaveLen(2))
+			// Verify the taints value is updated
+			g.Expect(machineSets.Items[0].Spec.Template.Spec.Taints).Should(ContainElement(additionalTaint))
+
+			// Verify that the old machine set has the new taints.
+			g.Expect(machineSets.Items[1].Spec.Template.Spec.Taints).Should(ContainElement(additionalTaint))
+		}).Should(Succeed())
+
 		// Verify that all the MachineSets have the expected OwnerRef.
 		t.Log("Verifying MachineSet owner references")
 		g.Eventually(func() bool {

internal/controllers/machinedeployment/mdutil/util_test.go

@@ -415,6 +415,9 @@ func TestFindNewAndOldMachineSets(t *testing.T) {
 
 	matchingMSDiffersInPlaceMutableFields := generateMS(deployment)
 	matchingMSDiffersInPlaceMutableFields.Spec.Template.Spec.Deletion.NodeDrainTimeoutSeconds = ptr.To(int32(20))
+	matchingMSDiffersInPlaceMutableFields.Spec.Template.Spec.Taints = []clusterv1.MachineTaint{
+		{Key: "taint-key", Value: "taint-value", Effect: corev1.TaintEffectNoSchedule, Propagation: clusterv1.MachineTaintPropagationAlways},
+	}
 
 	oldMS := generateMS(deployment)
 	oldMS.Spec.Template.Spec.InfrastructureRef.Name = "old-infra-ref"

internal/controllers/machineset/machineset_controller_test.go

@@ -472,28 +472,39 @@ func TestMachineSetReconciler(t *testing.T) {
 		}
 
 		// Verify that in-place mutable fields propagate from MachineSet to Machines.
-		t.Log("Updating NodeDrainTimeoutSeconds on MachineSet")
+		t.Log("Updating NodeDrainTimeoutSeconds and Taints on MachineSet")
 		patchHelper, err := patch.NewHelper(instance, env)
 		g.Expect(err).ToNot(HaveOccurred())
 		instance.Spec.Template.Spec.Deletion.NodeDrainTimeoutSeconds = duration5m
+		additionalTaint := clusterv1.MachineTaint{
+			Key:         "additional-taint-key",
+			Value:       "additional-taint-value",
+			Effect:      corev1.TaintEffectNoSchedule,
+			Propagation: clusterv1.MachineTaintPropagationAlways,
+		}
+		instance.Spec.Template.Spec.Taints = []clusterv1.MachineTaint{additionalTaint}
 		g.Expect(patchHelper.Patch(ctx, instance)).Should(Succeed())
 
 		t.Log("Verifying new NodeDrainTimeoutSeconds value is set on Machines")
 		g.Eventually(func() bool {
 			if err := env.List(ctx, machines, client.InNamespace(namespace.Name)); err != nil {
 				return false
 			}
-			// All the machines should have the new NodeDrainTimeoutValue
+			// All the machines should have the new NodeDrainTimeoutValue and the new taint
 			for _, m := range machines.Items {
 				if m.Spec.Deletion.NodeDrainTimeoutSeconds == nil {
 					return false
 				}
 				if *m.Spec.Deletion.NodeDrainTimeoutSeconds != *duration5m {
 					return false
 				}
+				if len(m.Spec.Taints) != 1 || m.Spec.Taints[0].Key != additionalTaint.Key ||
+					m.Spec.Taints[0].Value != additionalTaint.Value || m.Spec.Taints[0].Effect != additionalTaint.Effect {
+					return false
+				}
 			}
 			return true
-		}, timeout).Should(BeTrue(), "machine should have the updated NodeDrainTimeoutSeconds value")
+		}, timeout).Should(BeTrue(), "machine should have the updated NodeDrainTimeoutSeconds and Taints values")
 
 		// Try to delete 1 machine and check the MachineSet scales back up.
 		machineToBeDeleted := machines.Items[0]
@@ -3528,6 +3539,19 @@ func TestComputeDesiredMachine(t *testing.T) {
 	duration5s := ptr.To(int32(5))
 	duration10s := ptr.To(int32(10))
 
+	machineTaint := clusterv1.MachineTaint{
+		Key:         "taint-key",
+		Value:       "taint-value",
+		Effect:      corev1.TaintEffectNoSchedule,
+		Propagation: clusterv1.MachineTaintPropagationAlways,
+	}
+	changedMachineTaint := clusterv1.MachineTaint{
+		Key:         "changed-taint-key",
+		Value:       "changed-taint-value",
+		Effect:      corev1.TaintEffectNoSchedule,
+		Propagation: clusterv1.MachineTaintPropagationAlways,
+	}
+
 	namingTemplateKey := "-md"
 	mdName := "testmd"
 	msName := "ms1"
@@ -3567,6 +3591,9 @@ func TestComputeDesiredMachine(t *testing.T) {
 				NodeDeletionTimeoutSeconds:     duration10s,
 			},
 			MinReadySeconds: ptr.To[int32](10),
+			Taints: []clusterv1.MachineTaint{
+				machineTaint,
+			},
 		},
 	}
 
@@ -3590,6 +3617,7 @@ func TestComputeDesiredMachine(t *testing.T) {
 				NodeDeletionTimeoutSeconds:     duration10s,
 			},
 			MinReadySeconds: ptr.To[int32](10),
+			Taints:          []clusterv1.MachineTaint{machineTaint},
 		},
 	}
 
@@ -3618,6 +3646,7 @@ func TestComputeDesiredMachine(t *testing.T) {
 	existingMachine.Spec.Deletion.NodeDeletionTimeoutSeconds = duration5s
 	existingMachine.Spec.Deletion.NodeVolumeDetachTimeoutSeconds = duration5s
 	existingMachine.Spec.MinReadySeconds = ptr.To[int32](5)
+	existingMachine.Spec.Taints = []clusterv1.MachineTaint{changedMachineTaint}
 
 	expectedUpdatedMachine := skeletonMachine.DeepCopy()
 	expectedUpdatedMachine.Name = existingMachine.Name