Review changes v1

chrischdi · chrischdi · commit 89fd7f361c52 · 2025-11-10T10:46:57.000+01:00
diff --git a/api/core/v1beta1/conversion.go b/api/core/v1beta1/conversion.go
@@ -408,11 +408,11 @@ func (src *Machine) ConvertTo(dstRaw conversion.Hub) error {
 	// Recover other values.
 	if ok {
 		dst.Spec.MinReadySeconds = restored.Spec.MinReadySeconds
+		dst.Spec.Taints = restored.Spec.Taints
 		// Restore the phase, this also means that any client using v1beta1 during a round-trip
 		// won't be able to write the Phase field. But that's okay as the only client writing the Phase
 		// field should be the Machine controller.
 		dst.Status.Phase = restored.Status.Phase
-		dst.Spec.Taints = restored.Spec.Taints
 	}
 
 	return nil
diff --git a/api/core/v1beta2/common_types.go b/api/core/v1beta2/common_types.go
@@ -419,15 +419,17 @@ type MachineTaint struct {
 
 	// value is the taint value corresponding to the taint key.
 	// +optional
+	// +kubebuilder:validation:MinLength=1
 	// +kubebuilder:validation:MaxLength=63
-	Value *string `json:"value,omitempty"`
+	Value string `json:"value,omitempty"`
 
 	// effect is the effect for the taint. Valid values are NoSchedule, PreferNoSchedule and NoExecute.
 	// +required
 	// +kubebuilder:validation:Enum=NoSchedule;PreferNoSchedule;NoExecute
 	Effect corev1.TaintEffect `json:"effect,omitempty"`
 
 	// propagation defines how this taint should be propagated to nodes.
+	// Valid values are 'Always' and 'OnInitialization'.
 	// Always: The taint will be continuously reconciled. If it is not set for a node, it will be added during reconciliation.
 	// OnInitialization: The taint will be added during node initialization. If it gets removed from the node later on it will not get added again.
 	// +required
@@ -439,18 +441,18 @@ type MachineTaint struct {
 type MachineTaintPropagation string
 
 const (
-	// TaintPropagationAlways means the taint should be continuously reconciled and kept on the node.
+	// MachineTaintPropagationAlways means the taint should be continuously reconciled and kept on the node.
 	// - If an Always taint is added to the Machine, the taint will be added to the node.
 	// - If an Always taint is removed from the Machine, the taint will be removed from the node.
 	// - If an OnInitialization taint is changed to Always, the Machine controller will ensure the taint is set on the node.
 	// - If an Always taint is removed from the node, it will be re-added during reconciliation.
-	TaintPropagationAlways MachineTaintPropagation = "Always"
+	MachineTaintPropagationAlways MachineTaintPropagation = "Always"
 
-	// TaintPropagationOnInitialization means the taint should be set once during initialization and then
+	// MachineTaintPropagationOnInitialization means the taint should be set once during initialization and then
 	// left alone.
 	// - If an OnInitialization taint is added to the Machine, the taint will only be added to the node on initialization.
 	// - If an OnInitialization taint is removed from the Machine nothing will be changed on the node.
 	// - If an Always taint is changed to OnInitialization, the taint will only be added to the node on initialization.
 	// - If an OnInitialization taint is removed from the node, it will not be re-added during reconciliation.
-	TaintPropagationOnInitialization MachineTaintPropagation = "OnInitialization"
+	MachineTaintPropagationOnInitialization MachineTaintPropagation = "OnInitialization"
 )
diff --git a/api/core/v1beta2/machine_types.go b/api/core/v1beta2/machine_types.go
@@ -490,11 +490,13 @@ type MachineSpec struct {
 	Deletion MachineDeletionSpec `json:"deletion,omitempty,omitzero"`
 
 	// taints are the node taints that Cluster API will manage.
-	// This list is not necessarily complete: other Kubernetes components may add or remove other taints.
+	// This list is not necessarily complete: other Kubernetes components may add or remove other taints from nodes,
+	// e.g. the node controller might add the node.kubernetes.io/not-ready taint.
 	// Only those taints defined in this list will be added or removed by core Cluster API controllers.
 	//
+	// There can be at most 64 taints.
+	//
 	// NOTE: This list is implemented as a "map" type, meaning that individual elements can be managed by different owners.
-	// As of Kubernetes 1.33, this is different from the implementation on corev1.NodeSpec, but provides a more flexible API for components building on top of Cluster API.
 	// +optional
 	// +listType=map
 	// +listMapKey=key
diff --git a/controlplane/kubeadm/internal/controllers/inplace_canupdatemachine_test.go b/controlplane/kubeadm/internal/controllers/inplace_canupdatemachine_test.go
@@ -23,7 +23,6 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/google/go-cmp/cmp"
 	. "github.com/onsi/gomega"
 	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -465,7 +464,7 @@ func Test_canExtensionsUpdateMachine(t *testing.T) {
 				g.Expect(err).ToNot(HaveOccurred())
 			}
 			g.Expect(canUpdateMachine).To(Equal(tt.wantCanUpdateMachine))
-			g.Expect(reasons).To(BeEquivalentTo(tt.wantReasons), cmp.Diff(reasons, tt.wantReasons))
+			g.Expect(reasons).To(BeComparableTo(tt.wantReasons))
 		})
 	}
 }
diff --git a/docs/book/src/tasks/experimental-features/experimental-features.md b/docs/book/src/tasks/experimental-features/experimental-features.md
@@ -14,6 +14,8 @@ Currently Cluster API has the following experimental features:
 * `ClusterTopology` (env var: `CLUSTER_TOPOLOGY`): [ClusterClass](./cluster-class/index.md)
 * `RuntimeSDK` (env var: `EXP_RUNTIME_SDK`): [RuntimeSDK](./runtime-sdk/index.md)
 * `KubeadmBootstrapFormatIgnition` (env var: `EXP_KUBEADM_BOOTSTRAP_FORMAT_IGNITION`): [Ignition](./ignition.md)
+* `MachineTaintPropagation` (env var: `EXP_MACHINE_TAINT_PROPAGATION`):
+  * Allows in-place propagation of taints to nodes using the taint fields within Machines, MachineSets, and MachineDeployments.
 
 ## Enabling Experimental Features for Management Clusters Started with clusterctl
 
diff --git a/feature/feature.go b/feature/feature.go
@@ -83,7 +83,6 @@ const (
 	InPlaceUpdates featuregate.Feature = "InPlaceUpdates"
 
 	// MachineTaintPropagation is a feature gate for the machine taint propagation functionality.
-	// See docs/proposals/20250513-propogate-taints.md for more details.
 	//
 	// alpha: v1.12
 	MachineTaintPropagation featuregate.Feature = "MachineTaintPropagation"
diff --git a/internal/controllers/machine/machine_controller_noderef.go b/internal/controllers/machine/machine_controller_noderef.go
@@ -29,7 +29,6 @@ import (
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/util/sets"
 	"k8s.io/klog/v2"
-	"k8s.io/utils/ptr"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 
@@ -342,7 +341,7 @@ func (r *Reconciler) patchNode(ctx context.Context, remoteClient client.Client,
 	if feature.Gates.Enabled(feature.MachineTaintPropagation) {
 		var err error
 		if propagateTaintsChanges, err = propagateMachineTaintsToNode(newNode, m.Spec.Taints); err != nil {
-			return errors.Wrapf(err, "failed to propagate machine taints to node %s", klog.KRef("", node.Name))
+			return errors.Wrapf(err, "failed to propagate Machine taints to Node %s", klog.KObj(node))
 		}
 	}
 
@@ -361,10 +360,8 @@ func (r *Reconciler) patchNode(ctx context.Context, remoteClient client.Client,
 		return nil
 	}
 
-	var mergeOptions []client.MergeFromOption
-	if feature.Gates.Enabled(feature.MachineTaintPropagation) {
-		mergeOptions = append(mergeOptions, client.MergeFromWithOptimisticLock{})
-	}
+	// Use optimistic locking to avoid conflicts with other controllers.
+	mergeOptions := []client.MergeFromOption{client.MergeFromWithOptimisticLock{}}
 
 	return remoteClient.Patch(ctx, newNode, client.StrategicMergeFrom(node, mergeOptions...))
 }
@@ -389,14 +386,14 @@ func propagateMachineTaintsToNode(node *corev1.Node, machineTaints []clusterv1.M
 		// Collect Always and OnInitialization taints to identify taints to delete.
 		// Separating Always taints so the tracking annotation can be updated accordingly.
 		switch taint.Propagation {
-		case clusterv1.TaintPropagationAlways:
+		case clusterv1.MachineTaintPropagationAlways:
 			newOwnedTaints.Insert(fmt.Sprintf("%s:%s", taint.Key, taint.Effect))
-		case clusterv1.TaintPropagationOnInitialization:
+		case clusterv1.MachineTaintPropagationOnInitialization:
 			onInitializationTaints.Insert(fmt.Sprintf("%s:%s", taint.Key, taint.Effect))
 		}
 
 		// Only add OnInitialization taints if the tracking annotation has not been set yet.
-		if taint.Propagation == clusterv1.TaintPropagationOnInitialization && nodeTaintsInitialized {
+		if taint.Propagation == clusterv1.MachineTaintPropagationOnInitialization && nodeTaintsInitialized {
 			continue
 		}
 
@@ -454,7 +451,7 @@ func unmarshalMachineTaintsAnnotation(annotationValue string) sets.Set[string] {
 func convertMachineTaintToCoreV1Taint(machineTaint clusterv1.MachineTaint) corev1.Taint {
 	return corev1.Taint{
 		Key:    machineTaint.Key,
-		Value:  ptr.Deref(machineTaint.Value, ""),
+		Value:  machineTaint.Value,
 		Effect: machineTaint.Effect,
 	}
 }
diff --git a/internal/controllers/machine/machine_controller_noderef_test.go b/internal/controllers/machine/machine_controller_noderef_test.go
@@ -65,15 +65,15 @@ func TestReconcileNode(t *testing.T) {
 	defaultMachineWithTaints.Spec.Taints = []clusterv1.MachineTaint{
 		{
 			Key:         "test-always-taint",
-			Value:       ptr.To("test-value1"),
+			Value:       "test-value1",
 			Effect:      corev1.TaintEffectNoSchedule,
-			Propagation: clusterv1.TaintPropagationAlways,
+			Propagation: clusterv1.MachineTaintPropagationAlways,
 		},
 		{
 			Key:         "test-on-initialization-taint",
-			Value:       ptr.To("test-value2"),
+			Value:       "test-value2",
 			Effect:      corev1.TaintEffectNoSchedule,
-			Propagation: clusterv1.TaintPropagationOnInitialization,
+			Propagation: clusterv1.MachineTaintPropagationOnInitialization,
 		},
 	}
 
@@ -1556,32 +1556,32 @@ func Test_shouldNodeHaveOutdatedTaint(t *testing.T) {
 func Test_propagateMachineTaintsToNode(t *testing.T) {
 	alwaysTaint := clusterv1.MachineTaint{
 		Key:         "added-always",
-		Value:       ptr.To("always-value"),
+		Value:       "always-value",
 		Effect:      corev1.TaintEffectNoSchedule,
-		Propagation: clusterv1.TaintPropagationAlways,
+		Propagation: clusterv1.MachineTaintPropagationAlways,
 	}
 	onInitializationTaint := clusterv1.MachineTaint{
 		Key:         "added-on-initialization",
-		Value:       ptr.To("on-initialization-value"),
+		Value:       "on-initialization-value",
 		Effect:      corev1.TaintEffectNoSchedule,
-		Propagation: clusterv1.TaintPropagationOnInitialization,
+		Propagation: clusterv1.MachineTaintPropagationOnInitialization,
 	}
 
 	existingAlwaysTaint := clusterv1.MachineTaint{
 		Key:         "existing-always",
-		Value:       ptr.To("existing-always-value"),
+		Value:       "existing-always-value",
 		Effect:      corev1.TaintEffectNoExecute,
-		Propagation: clusterv1.TaintPropagationAlways,
+		Propagation: clusterv1.MachineTaintPropagationAlways,
 	}
 
 	transitionAlways := clusterv1.MachineTaint{
 		Key:         "transition-taint",
-		Value:       ptr.To("transition-value"),
+		Value:       "transition-value",
 		Effect:      corev1.TaintEffectNoSchedule,
-		Propagation: clusterv1.TaintPropagationAlways,
+		Propagation: clusterv1.MachineTaintPropagationAlways,
 	}
 	transitionOnInitialization := transitionAlways
-	transitionOnInitialization.Propagation = clusterv1.TaintPropagationOnInitialization
+	transitionOnInitialization.Propagation = clusterv1.MachineTaintPropagationOnInitialization
 
 	tests := []struct {
 		name               string
diff --git a/internal/controllers/machinedeployment/machinedeployment_rollout_planner_test.go b/internal/controllers/machinedeployment/machinedeployment_rollout_planner_test.go
@@ -282,6 +282,9 @@ func TestComputeDesiredMS(t *testing.T) {
 						NodeVolumeDetachTimeoutSeconds: duration10s,
 						NodeDeletionTimeoutSeconds:     duration10s,
 					},
+					Taints: []clusterv1.MachineTaint{
+						{Key: "taint-key", Value: "taint-value", Effect: corev1.TaintEffectNoSchedule, Propagation: clusterv1.MachineTaintPropagationAlways},
+					},
 				},
 			},
 		},
@@ -375,6 +378,7 @@ func TestComputeDesiredMS(t *testing.T) {
 							NodeVolumeDetachTimeoutSeconds: nil,
 							NodeDeletionTimeoutSeconds:     nil,
 						},
+						Taints: nil,
 					},
 				},
 			},
@@ -398,6 +402,7 @@ func TestComputeDesiredMS(t *testing.T) {
 		expectedMS.Spec.Template.Spec.Deletion.NodeDrainTimeoutSeconds = deployment.Spec.Template.Spec.Deletion.NodeDrainTimeoutSeconds
 		expectedMS.Spec.Template.Spec.Deletion.NodeDeletionTimeoutSeconds = deployment.Spec.Template.Spec.Deletion.NodeDeletionTimeoutSeconds
 		expectedMS.Spec.Template.Spec.Deletion.NodeVolumeDetachTimeoutSeconds = deployment.Spec.Template.Spec.Deletion.NodeVolumeDetachTimeoutSeconds
+		expectedMS.Spec.Template.Spec.Taints = deployment.Spec.Template.Spec.Taints
 
 		g := NewWithT(t)
 		actualMS, err := computeDesiredMS(ctx, deployment, currentMS)
diff --git a/internal/controllers/machinedeployment/mdutil/util.go b/internal/controllers/machinedeployment/mdutil/util.go
@@ -428,6 +428,7 @@ func MachineTemplateDeepCopyRolloutFields(template *clusterv1.MachineTemplateSpe
 	templateCopy.Spec.Deletion.NodeDrainTimeoutSeconds = nil
 	templateCopy.Spec.Deletion.NodeDeletionTimeoutSeconds = nil
 	templateCopy.Spec.Deletion.NodeVolumeDetachTimeoutSeconds = nil
+	templateCopy.Spec.Taints = nil
 
 	return templateCopy
 }
diff --git a/internal/controllers/machinedeployment/mdutil/util_test.go b/internal/controllers/machinedeployment/mdutil/util_test.go
@@ -202,6 +202,9 @@ func TestMachineTemplateUpToDate(t *testing.T) {
 					APIGroup: clusterv1.GroupVersionBootstrap.Group,
 				},
 			},
+			Taints: []clusterv1.MachineTaint{
+				{Key: "taint-key", Value: "taint-value", Effect: corev1.TaintEffectNoSchedule, Propagation: clusterv1.MachineTaintPropagationAlways},
+			},
 		},
 	}
 
@@ -225,6 +228,10 @@ func TestMachineTemplateUpToDate(t *testing.T) {
 	machineTemplateWithDifferentInPlaceMutableSpecFields.Spec.Deletion.NodeDeletionTimeoutSeconds = ptr.To(int32(20))
 	machineTemplateWithDifferentInPlaceMutableSpecFields.Spec.Deletion.NodeVolumeDetachTimeoutSeconds = ptr.To(int32(20))
 	machineTemplateWithDifferentInPlaceMutableSpecFields.Spec.MinReadySeconds = ptr.To[int32](20)
+	machineTemplateWithDifferentInPlaceMutableSpecFields.Spec.Taints = []clusterv1.MachineTaint{
+		{Key: "taint-key", Value: "taint-value", Effect: corev1.TaintEffectNoSchedule, Propagation: clusterv1.MachineTaintPropagationAlways},
+		{Key: "other-key", Value: "other-value", Effect: corev1.TaintEffectNoExecute, Propagation: clusterv1.MachineTaintPropagationAlways},
+	}
 
 	machineTemplateWithDifferentClusterName := machineTemplate.DeepCopy()
 	machineTemplateWithDifferentClusterName.Spec.ClusterName = "cluster2"
diff --git a/internal/controllers/machineset/machineset_controller_test.go b/internal/controllers/machineset/machineset_controller_test.go
@@ -37,6 +37,7 @@ import (
 	"k8s.io/apimachinery/pkg/util/intstr"
 	"k8s.io/apimachinery/pkg/util/sets"
 	"k8s.io/client-go/tools/record"
+	utilfeature "k8s.io/component-base/featuregate/testing"
 	"k8s.io/utils/ptr"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
@@ -48,6 +49,7 @@ import (
 	clusterv1 "sigs.k8s.io/cluster-api/api/core/v1beta2"
 	runtimev1 "sigs.k8s.io/cluster-api/api/runtime/v1beta2"
 	"sigs.k8s.io/cluster-api/controllers/external"
+	"sigs.k8s.io/cluster-api/feature"
 	"sigs.k8s.io/cluster-api/internal/contract"
 	"sigs.k8s.io/cluster-api/internal/util/ssa"
 	"sigs.k8s.io/cluster-api/util"
@@ -61,6 +63,8 @@ var _ reconcile.Reconciler = &Reconciler{}
 
 func TestMachineSetReconciler(t *testing.T) {
 	setup := func(t *testing.T, g *WithT) (*corev1.Namespace, *clusterv1.Cluster) {
+		utilfeature.SetFeatureGateDuringTest(t, feature.Gates, feature.MachineTaintPropagation, true)
+
 		t.Helper()
 
 		t.Log("Creating the namespace")
@@ -118,6 +122,9 @@ func TestMachineSetReconciler(t *testing.T) {
 
 		duration10m := ptr.To(int32(10 * 60))
 		duration5m := ptr.To(int32(5 * 60))
+		machineTaints := []clusterv1.MachineTaint{
+			{Key: "taint-key", Value: "taint-value", Effect: corev1.TaintEffectNoSchedule, Propagation: clusterv1.MachineTaintPropagationAlways},
+		}
 		replicas := int32(2)
 		version := "v1.14.2"
 		machineTemplateSpec := clusterv1.MachineTemplateSpec{
@@ -152,6 +159,7 @@ func TestMachineSetReconciler(t *testing.T) {
 					NodeVolumeDetachTimeoutSeconds: duration10m,
 				},
 				MinReadySeconds: ptr.To[int32](0),
+				Taints:          machineTaints,
 			},
 		}
 
@@ -1208,6 +1216,8 @@ func TestMachineSetReconciler_updateStatusResizedCondition(t *testing.T) {
 }
 
 func TestMachineSetReconciler_syncMachines(t *testing.T) {
+	utilfeature.SetFeatureGateDuringTest(t, feature.Gates, feature.MachineTaintPropagation, true)
+
 	teardown := func(t *testing.T, g *WithT, ns *corev1.Namespace, cluster *clusterv1.Cluster) {
 		t.Helper()
 
@@ -1563,6 +1573,10 @@ func TestMachineSetReconciler_syncMachines(t *testing.T) {
 	ms.Spec.Template.Spec.Deletion.NodeDeletionTimeoutSeconds = duration10s
 	ms.Spec.Template.Spec.Deletion.NodeVolumeDetachTimeoutSeconds = duration10s
 	ms.Spec.Template.Spec.MinReadySeconds = ptr.To[int32](10)
+	machineTaints := []clusterv1.MachineTaint{
+		{Key: "taint-key", Value: "taint-value", Effect: corev1.TaintEffectNoSchedule, Propagation: clusterv1.MachineTaintPropagationAlways},
+	}
+	ms.Spec.Template.Spec.Taints = machineTaints
 	s = &scope{
 		machineSet: ms,
 		machines:   []*clusterv1.Machine{updatedInPlaceMutatingMachine, deletingMachine},
@@ -1581,6 +1595,7 @@ func TestMachineSetReconciler_syncMachines(t *testing.T) {
 	g.Expect(updatedInPlaceMutatingMachine.Spec.Deletion.NodeVolumeDetachTimeoutSeconds).Should(Equal(ms.Spec.Template.Spec.Deletion.NodeVolumeDetachTimeoutSeconds))
 	g.Expect(updatedInPlaceMutatingMachine.Spec.MinReadySeconds).Should(Equal(ms.Spec.Template.Spec.MinReadySeconds))
 	g.Expect(updatedInPlaceMutatingMachine.Spec.ReadinessGates).Should(Equal(readinessGates))
+	g.Expect(updatedInPlaceMutatingMachine.Spec.Taints).Should(Equal(machineTaints))
 
 	// Verify in-place mutable fields are updated on InfrastructureMachine
 	updatedInfraMachine = infraMachine.DeepCopy()
@@ -1615,7 +1630,7 @@ func TestMachineSetReconciler_syncMachines(t *testing.T) {
 			Manager:    "manager",
 			Operation:  metav1.ManagedFieldsOperationUpdate,
 			APIVersion: clusterv1.GroupVersion.String(),
-			FieldsV1:   "{\"f:spec\":{\"f:deletion\":{\"f:nodeDrainTimeoutSeconds\":{},\"f:nodeVolumeDetachTimeoutSeconds\":{}},\"f:minReadySeconds\":{},\"f:readinessGates\":{\".\":{},\"k:{\\\"conditionType\\\":\\\"foo\\\"}\":{\".\":{},\"f:conditionType\":{}}}}}",
+			FieldsV1:   "{\"f:spec\":{\"f:deletion\":{\"f:nodeDrainTimeoutSeconds\":{},\"f:nodeVolumeDetachTimeoutSeconds\":{}},\"f:minReadySeconds\":{},\"f:readinessGates\":{\".\":{},\"k:{\\\"conditionType\\\":\\\"foo\\\"}\":{\".\":{},\"f:conditionType\":{}}},\"f:taints\":{\".\":{},\"k:{\\\"effect\\\":\\\"NoSchedule\\\",\\\"key\\\":\\\"taint-key\\\"}\":{\".\":{},\"f:effect\":{},\"f:key\":{},\"f:propagation\":{},\"f:value\":{}}}}}",
 		}, {
 			// manager owns status.
 			Manager:    "manager",
@@ -1637,12 +1652,14 @@ func TestMachineSetReconciler_syncMachines(t *testing.T) {
 	g.Expect(updatedDeletingMachine.Spec.Deletion.NodeVolumeDetachTimeoutSeconds).Should(Equal(ms.Spec.Template.Spec.Deletion.NodeVolumeDetachTimeoutSeconds))
 	g.Expect(updatedDeletingMachine.Spec.MinReadySeconds).Should(Equal(ms.Spec.Template.Spec.MinReadySeconds))
 	g.Expect(updatedDeletingMachine.Spec.ReadinessGates).Should(Equal(readinessGates))
+	g.Expect(updatedDeletingMachine.Spec.Taints).Should(Equal(machineTaints))
 	// Verify the machine spec is otherwise unchanged.
 	deletingMachine.Spec.Deletion.NodeDrainTimeoutSeconds = ms.Spec.Template.Spec.Deletion.NodeDrainTimeoutSeconds
 	deletingMachine.Spec.Deletion.NodeDeletionTimeoutSeconds = ms.Spec.Template.Spec.Deletion.NodeDeletionTimeoutSeconds
 	deletingMachine.Spec.Deletion.NodeVolumeDetachTimeoutSeconds = ms.Spec.Template.Spec.Deletion.NodeVolumeDetachTimeoutSeconds
 	deletingMachine.Spec.MinReadySeconds = ms.Spec.Template.Spec.MinReadySeconds
 	deletingMachine.Spec.ReadinessGates = ms.Spec.Template.Spec.ReadinessGates
+	deletingMachine.Spec.Taints = machineTaints
 	g.Expect(updatedDeletingMachine.Spec).Should(BeComparableTo(deletingMachine.Spec))
 }
 
diff --git a/internal/webhooks/machine.go b/internal/webhooks/machine.go
diff --git a/internal/webhooks/machine_test.go b/internal/webhooks/machine_test.go
diff --git a/internal/webhooks/machinepool.go b/internal/webhooks/machinepool.go
diff --git a/internal/webhooks/machineset_test.go b/internal/webhooks/machineset_test.go

Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,6 @@ import (`
`23`	`23`	`"fmt"`
`24`	`24`	`"testing"`
`25`	`25`
`26`		`- "github.com/google/go-cmp/cmp"`
`27`	`26`	`. "github.com/onsi/gomega"`
`28`	`27`	`"github.com/pkg/errors"`
`29`	`28`	`metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"`
`@@ -465,7 +464,7 @@ func Test_canExtensionsUpdateMachine(t *testing.T) {`
`465`	`464`	`g.Expect(err).ToNot(HaveOccurred())`
`466`	`465`	`}`
`467`	`466`	`g.Expect(canUpdateMachine).To(Equal(tt.wantCanUpdateMachine))`
`468`		`- g.Expect(reasons).To(BeEquivalentTo(tt.wantReasons), cmp.Diff(reasons, tt.wantReasons))`
	`467`	`+ g.Expect(reasons).To(BeComparableTo(tt.wantReasons))`
`469`	`468`	`})`
`470`	`469`	`}`
`471`	`470`	`}`
Original file line number	Diff line number	Diff line change
`@@ -428,6 +428,7 @@ func MachineTemplateDeepCopyRolloutFields(template *clusterv1.MachineTemplateSpe`
`428`	`428`	`templateCopy.Spec.Deletion.NodeDrainTimeoutSeconds = nil`
`429`	`429`	`templateCopy.Spec.Deletion.NodeDeletionTimeoutSeconds = nil`
`430`	`430`	`templateCopy.Spec.Deletion.NodeVolumeDetachTimeoutSeconds = nil`
	`431`	`+ templateCopy.Spec.Taints = nil`
`431`	`432`
`432`	`433`	`return templateCopy`
`433`	`434`	`}`