From 63830bfb4858350aedecffef0e40d942f1427229 Mon Sep 17 00:00:00 2001 From: Christian Schlotter Date: Fri, 6 Sep 2024 18:11:35 +0200 Subject: [PATCH 1/6] machine: add test coverage for shouldNodeHaveOutdatedTaint --- .../machine_controller_noderef_test.go | 103 +++++++++++++++++- 1 file changed, 98 insertions(+), 5 deletions(-) diff --git a/internal/controllers/machine/machine_controller_noderef_test.go b/internal/controllers/machine/machine_controller_noderef_test.go index 52dfc42331f4..9b97585b555e 100644 --- a/internal/controllers/machine/machine_controller_noderef_test.go +++ b/internal/controllers/machine/machine_controller_noderef_test.go @@ -27,15 +27,17 @@ import ( metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" "k8s.io/utils/ptr" - ctrl "sigs.k8s.io/controller-runtime" - "sigs.k8s.io/controller-runtime/pkg/client" - "sigs.k8s.io/controller-runtime/pkg/handler" - "sigs.k8s.io/controller-runtime/pkg/reconcile" - clusterv1 "sigs.k8s.io/cluster-api/api/v1beta1" "sigs.k8s.io/cluster-api/controllers/remote" + "sigs.k8s.io/cluster-api/internal/test/builder" + "sigs.k8s.io/cluster-api/internal/topology/ownerrefs" "sigs.k8s.io/cluster-api/util" "sigs.k8s.io/cluster-api/util/kubeconfig" + ctrl "sigs.k8s.io/controller-runtime" + "sigs.k8s.io/controller-runtime/pkg/client" + "sigs.k8s.io/controller-runtime/pkg/client/fake" + "sigs.k8s.io/controller-runtime/pkg/handler" + "sigs.k8s.io/controller-runtime/pkg/reconcile" ) func TestGetNode(t *testing.T) { @@ -994,3 +996,94 @@ func newFakeMachineDeployment(namespace, clusterName string) *clusterv1.MachineD }, } } + +func Test_shouldNodeHaveOutdatedTaint(t *testing.T) { + namespaceName := "test" + namespace := &corev1.Namespace{ObjectMeta: metav1.ObjectMeta{Name: namespaceName}} + + testMachineDeployment := builder.MachineDeployment(namespaceName, "my-md"). + WithAnnotations(map[string]string{clusterv1.RevisionAnnotation: "1"}). + Build() + testMachineDeploymentNew := testMachineDeployment.DeepCopy() + testMachineDeploymentNew.Annotations = map[string]string{clusterv1.RevisionAnnotation: "2"} + + testMachineSet := builder.MachineSet(namespaceName, "my-ms"). + WithOwnerReferences([]metav1.OwnerReference{*ownerrefs.OwnerReferenceTo(testMachineDeployment, testMachineDeployment.GroupVersionKind())}). + Build() + testMachineSet.Annotations = map[string]string{clusterv1.RevisionAnnotation: "1"} + + labels := map[string]string{ + clusterv1.MachineDeploymentNameLabel: "my-md", + } + testMachine := builder.Machine(namespaceName, "my-machine").WithLabels(labels).Build() + testMachine.SetOwnerReferences([]metav1.OwnerReference{*ownerrefs.OwnerReferenceTo(testMachineSet, testMachineSet.GroupVersionKind())}) + + tests := []struct { + name string + machine *clusterv1.Machine + objects []client.Object + want bool + wantErr bool + }{ + { + name: "Machine without MachineDeployment label", + machine: builder.Machine(namespaceName, "no-deploy").Build(), + objects: nil, + want: false, + wantErr: false, + }, + { + name: "Machine without OwnerReference", + machine: builder.Machine(namespaceName, "no-ownerref").WithLabels(labels).Build(), + objects: nil, + want: false, + wantErr: true, + }, + { + name: "Machine without existing MachineSet", + machine: testMachine, + objects: []client.Object{testMachineSet}, + want: false, + wantErr: true, + }, + { + name: "Machine without existing MachineDeployment", + machine: testMachine, + objects: []client.Object{testMachineSet}, + want: false, + wantErr: true, + }, + { + name: "Machineset not outdated", + machine: testMachine, + objects: []client.Object{testMachineSet, testMachineDeployment}, + want: false, + wantErr: false, + }, + { + name: "Machineset outdated", + machine: testMachine, + objects: []client.Object{testMachineSet, testMachineDeploymentNew}, + want: true, + wantErr: false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + objects := []client.Object{namespace} + objects = append(objects, tt.machine) + objects = append(objects, tt.objects...) + c := fake.NewClientBuilder(). + WithObjects(objects...).Build() + + got, err := shouldNodeHaveOutdatedTaint(ctx, c, tt.machine) + if (err != nil) != tt.wantErr { + t.Errorf("shouldNodeHaveOutdatedTaint() error = %v, wantErr %v", err, tt.wantErr) + return + } + if got != tt.want { + t.Errorf("shouldNodeHaveOutdatedTaint() = %v, want %v", got, tt.want) + } + }) + } +} From ca1cd5ccfe5088b09d4d36b6aa206a9b5a535aaf Mon Sep 17 00:00:00 2001 From: Christian Schlotter Date: Fri, 6 Sep 2024 18:24:25 +0200 Subject: [PATCH 2/6] machine: prevent error spamming for NodeOutdatedTaint if objects are not found --- .../machine/machine_controller_noderef.go | 49 +++++++---- .../machine_controller_noderef_test.go | 86 +++++++++++-------- 2 files changed, 81 insertions(+), 54 deletions(-) diff --git a/internal/controllers/machine/machine_controller_noderef.go b/internal/controllers/machine/machine_controller_noderef.go index 091a1121044d..551d16f00457 100644 --- a/internal/controllers/machine/machine_controller_noderef.go +++ b/internal/controllers/machine/machine_controller_noderef.go @@ -23,6 +23,7 @@ import ( "github.com/pkg/errors" corev1 "k8s.io/api/core/v1" + apierrors "k8s.io/apimachinery/pkg/api/errors" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" "k8s.io/apimachinery/pkg/runtime/schema" @@ -296,10 +297,17 @@ func (r *Reconciler) patchNode(ctx context.Context, remoteClient client.Client, hasTaintChanges := taints.RemoveNodeTaint(newNode, clusterv1.NodeUninitializedTaint) // Set Taint to a node in an old MachineSet and unset Taint from a node in a new MachineSet - isOutdated, err := shouldNodeHaveOutdatedTaint(ctx, r.Client, m) + isOutdated, notFound, err := shouldNodeHaveOutdatedTaint(ctx, r.Client, m) if err != nil { return errors.Wrapf(err, "failed to check if Node %s is outdated", klog.KRef("", node.Name)) } + + // It is not possible to identify if we have to set the NodeOutdatedRevisionTaint if there is + // no OwnerReference or the owning MachineSet or MachineDeployment was not found. + // Note: This could happen e.g. during background deletion of objects. + if notFound { + return nil + } if isOutdated { hasTaintChanges = taints.EnsureNodeTaint(newNode, clusterv1.NodeOutdatedRevisionTaint) || hasTaintChanges } else { @@ -313,20 +321,26 @@ func (r *Reconciler) patchNode(ctx context.Context, remoteClient client.Client, return remoteClient.Patch(ctx, newNode, client.StrategicMergeFrom(node)) } -func shouldNodeHaveOutdatedTaint(ctx context.Context, c client.Client, m *clusterv1.Machine) (bool, error) { +// shouldNodeHaveOutdatedTaint tries to compare the revision of the owning MachineSet to the MachineDeployment. +// It returns notFound = true if the OwnerReference is not set or the APIServer returns NotFound for the MachineSet or MachineDeployment. +// Note: This three cases could happen during background deletion of objects. +func shouldNodeHaveOutdatedTaint(ctx context.Context, c client.Client, m *clusterv1.Machine) (outdated bool, notFound bool, err error) { if _, hasLabel := m.Labels[clusterv1.MachineDeploymentNameLabel]; !hasLabel { - return false, nil + return false, false, nil } // Resolve the MachineSet name via owner references because the label value // could also be a hash. - objKey, err := getOwnerMachineSetObjectKey(m.ObjectMeta) - if err != nil { - return false, err + objKey, notFound, err := getOwnerMachineSetObjectKey(m.ObjectMeta) + if err != nil || notFound { + return false, notFound, err } ms := &clusterv1.MachineSet{} if err := c.Get(ctx, *objKey, ms); err != nil { - return false, err + if apierrors.IsNotFound(err) { + return false, true, nil + } + return false, false, err } md := &clusterv1.MachineDeployment{} objKey = &client.ObjectKey{ @@ -334,31 +348,34 @@ func shouldNodeHaveOutdatedTaint(ctx context.Context, c client.Client, m *cluste Name: m.Labels[clusterv1.MachineDeploymentNameLabel], } if err := c.Get(ctx, *objKey, md); err != nil { - return false, err + if apierrors.IsNotFound(err) { + return false, true, nil + } + return false, false, err } msRev, err := mdutil.Revision(ms) if err != nil { - return false, err + return false, false, err } mdRev, err := mdutil.Revision(md) if err != nil { - return false, err + return false, false, err } if msRev < mdRev { - return true, nil + return true, false, nil } - return false, nil + return false, false, nil } -func getOwnerMachineSetObjectKey(obj metav1.ObjectMeta) (*client.ObjectKey, error) { +func getOwnerMachineSetObjectKey(obj metav1.ObjectMeta) (*client.ObjectKey, bool, error) { for _, ref := range obj.GetOwnerReferences() { gv, err := schema.ParseGroupVersion(ref.APIVersion) if err != nil { - return nil, err + return nil, false, err } if ref.Kind == "MachineSet" && gv.Group == clusterv1.GroupVersion.Group { - return &client.ObjectKey{Namespace: obj.Namespace, Name: ref.Name}, nil + return &client.ObjectKey{Namespace: obj.Namespace, Name: ref.Name}, false, nil } } - return nil, errors.Errorf("failed to find MachineSet owner reference for Machine %s", klog.KRef(obj.GetNamespace(), obj.GetName())) + return nil, true, nil } diff --git a/internal/controllers/machine/machine_controller_noderef_test.go b/internal/controllers/machine/machine_controller_noderef_test.go index 9b97585b555e..7007dd5c036b 100644 --- a/internal/controllers/machine/machine_controller_noderef_test.go +++ b/internal/controllers/machine/machine_controller_noderef_test.go @@ -1019,53 +1019,60 @@ func Test_shouldNodeHaveOutdatedTaint(t *testing.T) { testMachine.SetOwnerReferences([]metav1.OwnerReference{*ownerrefs.OwnerReferenceTo(testMachineSet, testMachineSet.GroupVersionKind())}) tests := []struct { - name string - machine *clusterv1.Machine - objects []client.Object - want bool - wantErr bool + name string + machine *clusterv1.Machine + objects []client.Object + wantOutdated bool + wantNotFound bool + wantErr bool }{ { - name: "Machine without MachineDeployment label", - machine: builder.Machine(namespaceName, "no-deploy").Build(), - objects: nil, - want: false, - wantErr: false, + name: "Machineset not outdated", + machine: testMachine, + objects: []client.Object{testMachineSet, testMachineDeployment}, + wantOutdated: false, + wantNotFound: false, + wantErr: false, }, { - name: "Machine without OwnerReference", - machine: builder.Machine(namespaceName, "no-ownerref").WithLabels(labels).Build(), - objects: nil, - want: false, - wantErr: true, + name: "Machineset outdated", + machine: testMachine, + objects: []client.Object{testMachineSet, testMachineDeploymentNew}, + wantOutdated: true, + wantNotFound: false, + wantErr: false, }, { - name: "Machine without existing MachineSet", - machine: testMachine, - objects: []client.Object{testMachineSet}, - want: false, - wantErr: true, + name: "Machine without MachineDeployment label", + machine: builder.Machine(namespaceName, "no-deploy").Build(), + objects: nil, + wantOutdated: false, + wantNotFound: false, + wantErr: false, }, { - name: "Machine without existing MachineDeployment", - machine: testMachine, - objects: []client.Object{testMachineSet}, - want: false, - wantErr: true, + name: "Machine without OwnerReference", + machine: builder.Machine(namespaceName, "no-ownerref").WithLabels(labels).Build(), + objects: nil, + wantOutdated: false, + wantNotFound: true, + wantErr: false, }, { - name: "Machineset not outdated", - machine: testMachine, - objects: []client.Object{testMachineSet, testMachineDeployment}, - want: false, - wantErr: false, + name: "Machine without existing MachineSet", + machine: testMachine, + objects: nil, + wantOutdated: false, + wantNotFound: true, + wantErr: false, }, { - name: "Machineset outdated", - machine: testMachine, - objects: []client.Object{testMachineSet, testMachineDeploymentNew}, - want: true, - wantErr: false, + name: "Machine without existing MachineDeployment", + machine: testMachine, + objects: []client.Object{testMachineSet}, + wantOutdated: false, + wantNotFound: true, + wantErr: false, }, } for _, tt := range tests { @@ -1076,13 +1083,16 @@ func Test_shouldNodeHaveOutdatedTaint(t *testing.T) { c := fake.NewClientBuilder(). WithObjects(objects...).Build() - got, err := shouldNodeHaveOutdatedTaint(ctx, c, tt.machine) + gotOutdated, gotNotFound, err := shouldNodeHaveOutdatedTaint(ctx, c, tt.machine) if (err != nil) != tt.wantErr { t.Errorf("shouldNodeHaveOutdatedTaint() error = %v, wantErr %v", err, tt.wantErr) return } - if got != tt.want { - t.Errorf("shouldNodeHaveOutdatedTaint() = %v, want %v", got, tt.want) + if gotOutdated != tt.wantOutdated { + t.Errorf("shouldNodeHaveOutdatedTaint() = %v, want %v", gotOutdated, tt.wantOutdated) + } + if gotNotFound != tt.wantNotFound { + t.Errorf("shouldNodeHaveOutdatedTaint() = %v, want %v", gotNotFound, tt.wantNotFound) } }) } From 1db208a4d93f6afccc9eab1bb69e0c0bb4db69db Mon Sep 17 00:00:00 2001 From: Christian Schlotter Date: Mon, 9 Sep 2024 08:50:20 +0200 Subject: [PATCH 3/6] lint fix --- .../machine/machine_controller_noderef_test.go | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/internal/controllers/machine/machine_controller_noderef_test.go b/internal/controllers/machine/machine_controller_noderef_test.go index 7007dd5c036b..fb02f591f861 100644 --- a/internal/controllers/machine/machine_controller_noderef_test.go +++ b/internal/controllers/machine/machine_controller_noderef_test.go @@ -27,17 +27,18 @@ import ( metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" "k8s.io/utils/ptr" + ctrl "sigs.k8s.io/controller-runtime" + "sigs.k8s.io/controller-runtime/pkg/client" + "sigs.k8s.io/controller-runtime/pkg/client/fake" + "sigs.k8s.io/controller-runtime/pkg/handler" + "sigs.k8s.io/controller-runtime/pkg/reconcile" + clusterv1 "sigs.k8s.io/cluster-api/api/v1beta1" "sigs.k8s.io/cluster-api/controllers/remote" "sigs.k8s.io/cluster-api/internal/test/builder" "sigs.k8s.io/cluster-api/internal/topology/ownerrefs" "sigs.k8s.io/cluster-api/util" "sigs.k8s.io/cluster-api/util/kubeconfig" - ctrl "sigs.k8s.io/controller-runtime" - "sigs.k8s.io/controller-runtime/pkg/client" - "sigs.k8s.io/controller-runtime/pkg/client/fake" - "sigs.k8s.io/controller-runtime/pkg/handler" - "sigs.k8s.io/controller-runtime/pkg/reconcile" ) func TestGetNode(t *testing.T) { From 81c02960ed2ac07b7ab7e21e16a3729d8c81f047 Mon Sep 17 00:00:00 2001 From: Christian Schlotter Date: Tue, 10 Sep 2024 15:03:29 +0200 Subject: [PATCH 4/6] review fixes --- .../machine/machine_controller_noderef.go | 25 +++++---- .../machine_controller_noderef_test.go | 51 ++++++++++++++++++- 2 files changed, 62 insertions(+), 14 deletions(-) diff --git a/internal/controllers/machine/machine_controller_noderef.go b/internal/controllers/machine/machine_controller_noderef.go index 551d16f00457..03f5a968f810 100644 --- a/internal/controllers/machine/machine_controller_noderef.go +++ b/internal/controllers/machine/machine_controller_noderef.go @@ -302,20 +302,19 @@ func (r *Reconciler) patchNode(ctx context.Context, remoteClient client.Client, return errors.Wrapf(err, "failed to check if Node %s is outdated", klog.KRef("", node.Name)) } - // It is not possible to identify if we have to set the NodeOutdatedRevisionTaint if there is - // no OwnerReference or the owning MachineSet or MachineDeployment was not found. - // Note: This could happen e.g. during background deletion of objects. - if notFound { - return nil - } - if isOutdated { - hasTaintChanges = taints.EnsureNodeTaint(newNode, clusterv1.NodeOutdatedRevisionTaint) || hasTaintChanges - } else { - hasTaintChanges = taints.RemoveNodeTaint(newNode, clusterv1.NodeOutdatedRevisionTaint) || hasTaintChanges - } + // It is only possible to identify if we have to set or remove the NodeOutdatedRevisionTaint if shouldNodeHaveOutdatedTaint + // found all relevant objects. + // Example: when the MachineDeployment or Machineset can't be found due to a background deletion of objects. + if !notFound { + if isOutdated { + hasTaintChanges = taints.EnsureNodeTaint(newNode, clusterv1.NodeOutdatedRevisionTaint) || hasTaintChanges + } else { + hasTaintChanges = taints.RemoveNodeTaint(newNode, clusterv1.NodeOutdatedRevisionTaint) || hasTaintChanges + } - if !hasAnnotationChanges && !hasLabelChanges && !hasTaintChanges { - return nil + if !hasAnnotationChanges && !hasLabelChanges && !hasTaintChanges { + return nil + } } return remoteClient.Patch(ctx, newNode, client.StrategicMergeFrom(node)) diff --git a/internal/controllers/machine/machine_controller_noderef_test.go b/internal/controllers/machine/machine_controller_noderef_test.go index fb02f591f861..717e8f35ef7b 100644 --- a/internal/controllers/machine/machine_controller_noderef_test.go +++ b/internal/controllers/machine/machine_controller_noderef_test.go @@ -773,6 +773,53 @@ func TestPatchNode(t *testing.T) { ms: newFakeMachineSet(metav1.NamespaceDefault, clusterName), md: newFakeMachineDeployment(metav1.NamespaceDefault, clusterName), }, + { + name: "Ensure Labels and Annotations still get patched if MachineSet cannot be found", + oldNode: &corev1.Node{ + ObjectMeta: metav1.ObjectMeta{ + Name: fmt.Sprintf("node-%s", util.RandomString(6)), + }, + }, + expectedAnnotations: map[string]string{ + clusterv1.LabelsFromMachineAnnotation: "", + }, + expectedTaints: []corev1.Taint{ + {Key: "node.kubernetes.io/not-ready", Effect: "NoSchedule"}, // Added by the API server + }, + machine: &clusterv1.Machine{ + ObjectMeta: metav1.ObjectMeta{ + Name: fmt.Sprintf("ma-%s", util.RandomString(6)), + Namespace: metav1.NamespaceDefault, + Labels: map[string]string{ + clusterv1.MachineSetNameLabel: "test-ms-missing", + clusterv1.MachineDeploymentNameLabel: "test-md", + }, + OwnerReferences: []metav1.OwnerReference{{ + Kind: "MachineSet", + Name: "test-ms-missing", + APIVersion: clusterv1.GroupVersion.String(), + UID: "uid", + }}, + }, + Spec: newFakeMachineSpec(metav1.NamespaceDefault, clusterName), + }, + ms: nil, + md: &clusterv1.MachineDeployment{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test-md", + Namespace: metav1.NamespaceDefault, + Annotations: map[string]string{ + clusterv1.RevisionAnnotation: "1", + }, + }, + Spec: clusterv1.MachineDeploymentSpec{ + ClusterName: clusterName, + Template: clusterv1.MachineTemplateSpec{ + Spec: newFakeMachineSpec(metav1.NamespaceDefault, clusterName), + }, + }, + }, + }, { name: "Ensure NodeOutdatedRevisionTaint to be set if a node is associated to an outdated machineset", oldNode: &corev1.Node{ @@ -916,7 +963,9 @@ func TestPatchNode(t *testing.T) { g.Expect(env.CreateAndWait(ctx, oldNode)).To(Succeed()) g.Expect(env.CreateAndWait(ctx, machine)).To(Succeed()) - g.Expect(env.CreateAndWait(ctx, ms)).To(Succeed()) + if ms != nil { + g.Expect(env.CreateAndWait(ctx, ms)).To(Succeed()) + } g.Expect(env.CreateAndWait(ctx, md)).To(Succeed()) t.Cleanup(func() { _ = env.CleanupAndWait(ctx, oldNode, machine, ms, md) From 1bfe0b47456fe456629ae3af300587a2d3ec3a1e Mon Sep 17 00:00:00 2001 From: Christian Schlotter Date: Wed, 11 Sep 2024 13:39:36 +0200 Subject: [PATCH 5/6] review fixes --- .../machine/machine_controller_noderef.go | 6 +++--- .../machine/machine_controller_noderef_test.go | 12 +++++++++++- 2 files changed, 14 insertions(+), 4 deletions(-) diff --git a/internal/controllers/machine/machine_controller_noderef.go b/internal/controllers/machine/machine_controller_noderef.go index 03f5a968f810..67a4d028e599 100644 --- a/internal/controllers/machine/machine_controller_noderef.go +++ b/internal/controllers/machine/machine_controller_noderef.go @@ -311,10 +311,10 @@ func (r *Reconciler) patchNode(ctx context.Context, remoteClient client.Client, } else { hasTaintChanges = taints.RemoveNodeTaint(newNode, clusterv1.NodeOutdatedRevisionTaint) || hasTaintChanges } + } - if !hasAnnotationChanges && !hasLabelChanges && !hasTaintChanges { - return nil - } + if !hasAnnotationChanges && !hasLabelChanges && !hasTaintChanges { + return nil } return remoteClient.Patch(ctx, newNode, client.StrategicMergeFrom(node)) diff --git a/internal/controllers/machine/machine_controller_noderef_test.go b/internal/controllers/machine/machine_controller_noderef_test.go index 717e8f35ef7b..74e1a591d90a 100644 --- a/internal/controllers/machine/machine_controller_noderef_test.go +++ b/internal/controllers/machine/machine_controller_noderef_test.go @@ -780,8 +780,18 @@ func TestPatchNode(t *testing.T) { Name: fmt.Sprintf("node-%s", util.RandomString(6)), }, }, + newLabels: map[string]string{ + "label-from-machine": "foo", + }, + newAnnotations: map[string]string{ + "annotation-from-machine": "foo", + }, + expectedLabels: map[string]string{ + "label-from-machine": "foo", + }, expectedAnnotations: map[string]string{ - clusterv1.LabelsFromMachineAnnotation: "", + "annotation-from-machine": "foo", + clusterv1.LabelsFromMachineAnnotation: "label-from-machine", }, expectedTaints: []corev1.Taint{ {Key: "node.kubernetes.io/not-ready", Effect: "NoSchedule"}, // Added by the API server From 2992541bafe81b170726a31cc78eacc2b6562dff Mon Sep 17 00:00:00 2001 From: Christian Schlotter Date: Thu, 12 Sep 2024 13:19:26 +0200 Subject: [PATCH 6/6] review fix --- .../machine_controller_noderef_test.go | 22 +++++-------------- 1 file changed, 5 insertions(+), 17 deletions(-) diff --git a/internal/controllers/machine/machine_controller_noderef_test.go b/internal/controllers/machine/machine_controller_noderef_test.go index 74e1a591d90a..40d64b9f0a6f 100644 --- a/internal/controllers/machine/machine_controller_noderef_test.go +++ b/internal/controllers/machine/machine_controller_noderef_test.go @@ -774,7 +774,7 @@ func TestPatchNode(t *testing.T) { md: newFakeMachineDeployment(metav1.NamespaceDefault, clusterName), }, { - name: "Ensure Labels and Annotations still get patched if MachineSet cannot be found", + name: "Ensure Labels and Annotations still get patched if MachineSet and Machinedeployment cannot be found", oldNode: &corev1.Node{ ObjectMeta: metav1.ObjectMeta{ Name: fmt.Sprintf("node-%s", util.RandomString(6)), @@ -814,21 +814,7 @@ func TestPatchNode(t *testing.T) { Spec: newFakeMachineSpec(metav1.NamespaceDefault, clusterName), }, ms: nil, - md: &clusterv1.MachineDeployment{ - ObjectMeta: metav1.ObjectMeta{ - Name: "test-md", - Namespace: metav1.NamespaceDefault, - Annotations: map[string]string{ - clusterv1.RevisionAnnotation: "1", - }, - }, - Spec: clusterv1.MachineDeploymentSpec{ - ClusterName: clusterName, - Template: clusterv1.MachineTemplateSpec{ - Spec: newFakeMachineSpec(metav1.NamespaceDefault, clusterName), - }, - }, - }, + md: nil, }, { name: "Ensure NodeOutdatedRevisionTaint to be set if a node is associated to an outdated machineset", @@ -976,7 +962,9 @@ func TestPatchNode(t *testing.T) { if ms != nil { g.Expect(env.CreateAndWait(ctx, ms)).To(Succeed()) } - g.Expect(env.CreateAndWait(ctx, md)).To(Succeed()) + if md != nil { + g.Expect(env.CreateAndWait(ctx, md)).To(Succeed()) + } t.Cleanup(func() { _ = env.CleanupAndWait(ctx, oldNode, machine, ms, md) })