Adjust to CR not setting TypeMeta anymore

sbueringer · sbueringer · commit a3a64bef3b08 · 2025-08-27T13:20:07.000+02:00
diff --git a/cmd/clusterctl/client/cluster/upgrader_info_test.go b/cmd/clusterctl/client/cluster/upgrader_info_test.go
@@ -491,10 +491,6 @@ func toSemanticVersions(versions []string) []version.Version {
 
 func fakeProvider(name string, providerType clusterctlv1.ProviderType, version, targetNamespace string) clusterctlv1.Provider {
 	return clusterctlv1.Provider{
-		TypeMeta: metav1.TypeMeta{
-			APIVersion: clusterctlv1.GroupVersion.String(),
-			Kind:       "Provider",
-		},
 		ObjectMeta: metav1.ObjectMeta{
 			ResourceVersion: "999",
 			Namespace:       targetNamespace,
diff --git a/cmd/clusterctl/client/tree/discovery.go b/cmd/clusterctl/client/tree/discovery.go
@@ -22,6 +22,7 @@ import (
 	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime/schema"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 
 	addonsv1 "sigs.k8s.io/cluster-api/api/addons/v1beta2"
@@ -286,7 +287,7 @@ func addMachineDeploymentToObjectTree(ctx context.Context, c client.Client, clus
 			tree.Add(templateParent, machineTemplateRefObject, ObjectMetaName("MachineInfrastructureTemplate"))
 		}
 
-		machineSets := selectMachinesSetsControlledBy(machineSetList, md)
+		machineSets := selectMachinesSetsControlledBy(machineSetList, md, clusterv1.GroupVersion.WithKind("MachineDeployment").GroupKind())
 		for i := range machineSets {
 			ms := machineSets[i]
 
@@ -296,7 +297,7 @@ func addMachineDeploymentToObjectTree(ctx context.Context, c client.Client, clus
 				parent = ms
 			}
 
-			machines := selectMachinesControlledBy(machinesList, ms)
+			machines := selectMachinesControlledBy(machinesList, ms, clusterv1.GroupVersion.WithKind("MachineSet").GroupKind())
 			for _, w := range machines {
 				addMachineFunc(parent, w)
 			}
@@ -321,7 +322,7 @@ func addMachinePoolsToObjectTree(ctx context.Context, c client.Client, workers *
 			}
 		}
 
-		machines := selectMachinesControlledBy(machinesList, mp)
+		machines := selectMachinesControlledBy(machinesList, mp, clusterv1.GroupVersion.WithKind("MachinePool").GroupKind())
 		for _, m := range machines {
 			addMachineFunc(mp, m)
 		}
@@ -417,22 +418,22 @@ func selectControlPlaneMachines(machineList *clusterv1.MachineList) []*clusterv1
 	return machines
 }
 
-func selectMachinesSetsControlledBy(machineSetList *clusterv1.MachineSetList, controller client.Object) []*clusterv1.MachineSet {
+func selectMachinesSetsControlledBy(machineSetList *clusterv1.MachineSetList, controller client.Object, controllerGK schema.GroupKind) []*clusterv1.MachineSet {
 	machineSets := []*clusterv1.MachineSet{}
 	for i := range machineSetList.Items {
 		m := &machineSetList.Items[i]
-		if util.IsControlledBy(m, controller) {
+		if util.IsControlledBy(m, controller, controllerGK) {
 			machineSets = append(machineSets, m)
 		}
 	}
 	return machineSets
 }
 
-func selectMachinesControlledBy(machineList *clusterv1.MachineList, controller client.Object) []*clusterv1.Machine {
+func selectMachinesControlledBy(machineList *clusterv1.MachineList, controller client.Object, controllerGK schema.GroupKind) []*clusterv1.Machine {
 	machines := []*clusterv1.Machine{}
 	for i := range machineList.Items {
 		m := &machineList.Items[i]
-		if util.IsControlledBy(m, controller) {
+		if util.IsControlledBy(m, controller, controllerGK) {
 			machines = append(machines, m)
 		}
 	}
diff --git a/cmd/clusterctl/client/upgrade_test.go b/cmd/clusterctl/client/upgrade_test.go
@@ -365,10 +365,6 @@ func fakeClientForUpgrade() *fakeClient {
 
 func fakeProvider(name string, providerType clusterctlv1.ProviderType, version, targetNamespace string) clusterctlv1.Provider {
 	return clusterctlv1.Provider{
-		TypeMeta: metav1.TypeMeta{
-			APIVersion: clusterctlv1.GroupVersion.String(),
-			Kind:       "Provider",
-		},
 		ObjectMeta: metav1.ObjectMeta{
 			Namespace: targetNamespace,
 			Name:      clusterctlv1.ManifestLabel(name, providerType),
diff --git a/cmd/clusterctl/internal/test/fake_objects.go b/cmd/clusterctl/internal/test/fake_objects.go
@@ -22,13 +22,13 @@ import (
 
 	corev1 "k8s.io/api/core/v1"
 	apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
-	"k8s.io/apimachinery/pkg/api/meta"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/klog/v2"
 	"k8s.io/utils/ptr"
 	"sigs.k8s.io/controller-runtime/pkg/client"
+	"sigs.k8s.io/controller-runtime/pkg/client/apiutil"
 	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
 
 	addonsv1 "sigs.k8s.io/cluster-api/api/addons/v1beta2"
@@ -1389,12 +1389,12 @@ func SelectClusterObj(objs []client.Object, namespace, name string) *clusterv1.C
 // setUID assigns a UID to the object, so test objects are uniquely identified.
 // NB. In order to make debugging easier we are using a human readable, deterministic string (instead of a random UID).
 func setUID(obj client.Object) {
-	accessor, err := meta.Accessor(obj)
+	gvk, err := apiutil.GVKForObject(obj, FakeScheme)
 	if err != nil {
-		panic(fmt.Sprintf("failed to get accessor for test object: %v", err))
+		panic(fmt.Sprintf("failed to get GVK for test object: %v", err))
 	}
-	uid := fmt.Sprintf("%s, %s", obj.GetObjectKind().GroupVersionKind().String(), klog.KObj(accessor))
-	accessor.SetUID(types.UID(uid))
+	uid := fmt.Sprintf("%s, %s", gvk.String(), klog.KObj(obj))
+	obj.SetUID(types.UID(uid))
 }
 
 // FakeClusterCustomResourceDefinition returns a fake CRD object for the given group/versions/kind.
diff --git a/controlplane/kubeadm/internal/controllers/controller.go b/controlplane/kubeadm/internal/controllers/controller.go
@@ -1387,7 +1387,7 @@ func (r *KubeadmControlPlaneReconciler) adoptOwnedSecrets(ctx context.Context, k
 
 	for i := range secrets.Items {
 		s := secrets.Items[i]
-		if !util.IsOwnedByObject(&s, currentOwner) {
+		if !util.IsOwnedByObject(&s, currentOwner, bootstrapv1.GroupVersion.WithKind("KubeadmConfig").GroupKind()) {
 			continue
 		}
 		// avoid taking ownership of the bootstrap data secret
diff --git a/controlplane/kubeadm/internal/controllers/helpers.go b/controlplane/kubeadm/internal/controllers/helpers.go
@@ -94,7 +94,7 @@ func (r *KubeadmControlPlaneReconciler) reconcileKubeconfig(ctx context.Context,
 	}
 
 	// only do rotation on owned secrets
-	if !util.IsControlledBy(configSecret, controlPlane.KCP) {
+	if !util.IsControlledBy(configSecret, controlPlane.KCP, controlplanev1.GroupVersion.WithKind("KubeadmControlPlane").GroupKind()) {
 		return ctrl.Result{}, nil
 	}
 
diff --git a/controlplane/kubeadm/internal/workload_cluster_coredns_test.go b/controlplane/kubeadm/internal/workload_cluster_coredns_test.go
@@ -1139,10 +1139,6 @@ func (m *fakeMigrator) Migrate(_, _, _ string, _ bool) (string, error) {
 
 func newCoreDNSInfoDeploymentWithimage(image string) *appsv1.Deployment {
 	return &appsv1.Deployment{
-		TypeMeta: metav1.TypeMeta{
-			Kind:       "Deployment",
-			APIVersion: "apps/v1",
-		},
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      coreDNSKey,
 			Namespace: metav1.NamespaceSystem,
diff --git a/internal/controllers/cluster/cluster_controller.go b/internal/controllers/cluster/cluster_controller.go
@@ -631,7 +631,7 @@ func (c *clusterDescendants) filterOwnedDescendants(cluster *clusterv1.Cluster)
 			return nil //nolint:nilerr // We don't want to exit the EachListItem loop, just continue
 		}
 
-		if util.IsOwnedByObject(acc, cluster) {
+		if util.IsOwnedByObject(acc, cluster, clusterv1.GroupVersion.WithKind("Cluster").GroupKind()) {
 			ownedDescendants = append(ownedDescendants, obj)
 		}
 
diff --git a/internal/controllers/cluster/cluster_controller_status.go b/internal/controllers/cluster/cluster_controller_status.go
@@ -246,7 +246,7 @@ func setWorkersReplicas(_ context.Context, cluster *clusterv1.Cluster, machinePo
 	}
 
 	for _, ms := range machineSets.Items {
-		if !util.IsOwnedByObject(&ms, cluster) {
+		if !util.IsOwnedByObject(&ms, cluster, clusterv1.GroupVersion.WithKind("Cluster").GroupKind()) {
 			continue
 		}
 		if ms.Spec.Replicas != nil {
@@ -267,7 +267,7 @@ func setWorkersReplicas(_ context.Context, cluster *clusterv1.Cluster, machinePo
 	}
 
 	for _, m := range workerMachines.UnsortedList() {
-		if !util.IsOwnedByObject(m, cluster) {
+		if !util.IsOwnedByObject(m, cluster, clusterv1.GroupVersion.WithKind("Cluster").GroupKind()) {
 			continue
 		}
 		currentReplicas = ptr.To(ptr.Deref(currentReplicas, 0) + 1)
@@ -973,7 +973,7 @@ func setScalingUpCondition(ctx context.Context, cluster *clusterv1.Cluster, cont
 		ws = append(ws, aggregationWrapper{md: &md})
 	}
 	for _, ms := range machineSets.Items {
-		if !util.IsOwnedByObject(&ms, cluster) {
+		if !util.IsOwnedByObject(&ms, cluster, clusterv1.GroupVersion.WithKind("Cluster").GroupKind()) {
 			continue
 		}
 		ws = append(ws, aggregationWrapper{ms: &ms})
@@ -1050,7 +1050,7 @@ func setScalingDownCondition(ctx context.Context, cluster *clusterv1.Cluster, co
 		ws = append(ws, aggregationWrapper{md: &md})
 	}
 	for _, ms := range machineSets.Items {
-		if !util.IsOwnedByObject(&ms, cluster) {
+		if !util.IsOwnedByObject(&ms, cluster, clusterv1.GroupVersion.WithKind("Cluster").GroupKind()) {
 			continue
 		}
 		ws = append(ws, aggregationWrapper{ms: &ms})
diff --git a/internal/controllers/clusterclass/clusterclass_controller_test.go b/internal/controllers/clusterclass/clusterclass_controller_test.go
@@ -1101,15 +1101,15 @@ func TestReconciler_reconcileVariables(t *testing.T) {
 			wantErrMessage: "failed to discover variables for ClusterClass class1: [" +
 				"patch1.variables[cpu].schema.openAPIV3Schema.properties[nestedField].default: Invalid value: \"integer\": failed rule: self >= 1, " +
 				"patch1.variables[anotherCPU].schema.openAPIV3Schema.x-kubernetes-validations[0].messageExpression: Invalid value: " +
-				"apiextensions.ValidationRule{Rule:\"self >= 1\", Message:\"\", MessageExpression:\"'Expected integer greater or equal to 1, got ' + this does not compile\", " +
-				"Reason:(*apiextensions.FieldValueErrorReason)(nil), FieldPath:\"\", OptionalOldSelf:(*bool)(nil)}: " +
+				"{\"Rule\":\"self \\u003e= 1\",\"Message\":\"\",\"MessageExpression\":\"'Expected integer greater or equal to 1, got ' + this does not compile\"," +
+				"\"Reason\":null,\"FieldPath\":\"\",\"OptionalOldSelf\":null}: " +
 				"messageExpression compilation failed: ERROR: <input>:1:55: Syntax error: mismatched input 'does' expecting <EOF>\n " +
 				"| 'Expected integer greater or equal to 1, got ' + this does not compile\n " +
 				"| ......................................................^]",
 			wantVariableDiscoveryErrorMessage: "VariableDiscovery failed: [patch1.variables[cpu].schema.openAPIV3Schema.properties[nestedField].default: Invalid value: \"integer\": failed rule: self >= 1, " +
 				"patch1.variables[anotherCPU].schema.openAPIV3Schema.x-kubernetes-validations[0].messageExpression: Invalid value: " +
-				"apiextensions.ValidationRule{Rule:\"self >= 1\", Message:\"\", MessageExpression:\"'Expected integer greater or equal to 1, got ' + this does not compile\", " +
-				"Reason:(*apiextensions.FieldValueErrorReason)(nil), FieldPath:\"\", OptionalOldSelf:(*bool)(nil)}: " +
+				"{\"Rule\":\"self \\u003e= 1\",\"Message\":\"\",\"MessageExpression\":\"'Expected integer greater or equal to 1, got ' + this does not compile\"," +
+				"\"Reason\":null,\"FieldPath\":\"\",\"OptionalOldSelf\":null}: " +
 				"messageExpression compilation failed: ERROR: <input>:1:55: Syntax error: mismatched input 'does' expecting <EOF>\n " +
 				"| 'Expected integer greater or equal to 1, got ' + this does not compile\n " +
 				"| ......................................................^]",
@@ -1150,15 +1150,15 @@ func TestReconciler_reconcileVariables(t *testing.T) {
 			},
 			wantErrMessage: "failed to discover variables for ClusterClass class1: " +
 				"patch1.variables[someIP].schema.openAPIV3Schema.x-kubernetes-validations[0].rule: Invalid value: " +
-				"apiextensions.ValidationRule{Rule:\"ip(self).family() == 6\", Message:\"\", MessageExpression:\"\", Reason:(*apiextensions.FieldValueErrorReason)(nil), FieldPath:\"\", OptionalOldSelf:(*bool)(nil)}: compilation failed: " +
+				"{\"Rule\":\"ip(self).family() == 6\",\"Message\":\"\",\"MessageExpression\":\"\",\"Reason\":null,\"FieldPath\":\"\",\"OptionalOldSelf\":null}: compilation failed: " +
 				"ERROR: <input>:1:3: undeclared reference to 'ip' (in container '')\n" +
 				" | ip(self).family() == 6\n" +
 				" | ..^\n" +
 				"ERROR: <input>:1:16: undeclared reference to 'family' (in container '')\n" +
 				" | ip(self).family() == 6\n" +
 				" | ...............^",
 			wantVariableDiscoveryErrorMessage: "VariableDiscovery failed: patch1.variables[someIP].schema.openAPIV3Schema.x-kubernetes-validations[0].rule: Invalid value: " +
-				"apiextensions.ValidationRule{Rule:\"ip(self).family() == 6\", Message:\"\", MessageExpression:\"\", Reason:(*apiextensions.FieldValueErrorReason)(nil), FieldPath:\"\", OptionalOldSelf:(*bool)(nil)}: compilation failed: " +
+				"{\"Rule\":\"ip(self).family() == 6\",\"Message\":\"\",\"MessageExpression\":\"\",\"Reason\":null,\"FieldPath\":\"\",\"OptionalOldSelf\":null}: compilation failed: " +
 				"ERROR: <input>:1:3: undeclared reference to 'ip' (in container '')\n" +
 				" | ip(self).family() == 6\n" +
 				" | ..^\n" +
diff --git a/internal/controllers/clusterresourceset/clusterresourceset_helpers_test.go b/internal/controllers/clusterresourceset/clusterresourceset_helpers_test.go
@@ -117,7 +117,6 @@ func TestGetorCreateClusterResourceSetBinding(t *testing.T) {
 func TestGetSecretFromNamespacedName(t *testing.T) {
 	existingSecretName := types.NamespacedName{Name: "my-secret", Namespace: metav1.NamespaceDefault}
 	existingSecret := &corev1.Secret{
-		TypeMeta: metav1.TypeMeta{Kind: "Secret", APIVersion: "v1"},
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      existingSecretName.Name,
 			Namespace: existingSecretName.Namespace,
@@ -173,7 +172,6 @@ func TestGetConfigMapFromNamespacedName(t *testing.T) {
 
 	existingConfigMapName := types.NamespacedName{Name: "my-configmap", Namespace: metav1.NamespaceDefault}
 	existingConfigMap := &corev1.ConfigMap{
-		TypeMeta: metav1.TypeMeta{Kind: "ConfigMap", APIVersion: "v1"},
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      existingConfigMapName.Name,
 			Namespace: existingConfigMapName.Namespace,
diff --git a/internal/controllers/machine/machine_controller_noderef_test.go b/internal/controllers/machine/machine_controller_noderef_test.go
@@ -1400,15 +1400,15 @@ func Test_shouldNodeHaveOutdatedTaint(t *testing.T) {
 	testMachineDeploymentNew.Annotations = map[string]string{clusterv1.RevisionAnnotation: "2"}
 
 	testMachineSet := builder.MachineSet(namespaceName, "my-ms").
-		WithOwnerReferences([]metav1.OwnerReference{*ownerrefs.OwnerReferenceTo(testMachineDeployment, testMachineDeployment.GroupVersionKind())}).
+		WithOwnerReferences([]metav1.OwnerReference{*ownerrefs.OwnerReferenceTo(testMachineDeployment, clusterv1.GroupVersion.WithKind("MachineDeployment"))}).
 		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())})
+	testMachine.SetOwnerReferences([]metav1.OwnerReference{*ownerrefs.OwnerReferenceTo(testMachineSet, clusterv1.GroupVersion.WithKind("MachineSet"))})
 
 	tests := []struct {
 		name         string
diff --git a/internal/controllers/machinehealthcheck/machinehealthcheck_targets_test.go b/internal/controllers/machinehealthcheck/machinehealthcheck_targets_test.go
@@ -582,10 +582,6 @@ func newTestMachine(name, namespace, clusterName, nodeName string, labels map[st
 
 	bootstrap := "bootstrap"
 	return &clusterv1.Machine{
-		TypeMeta: metav1.TypeMeta{
-			APIVersion: clusterv1.GroupVersion.String(),
-			Kind:       "Machine",
-		},
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      name,
 			Namespace: namespace,
@@ -612,10 +608,6 @@ func newTestMachine(name, namespace, clusterName, nodeName string, labels map[st
 
 func newTestNode(name string) *corev1.Node {
 	return &corev1.Node{
-		TypeMeta: metav1.TypeMeta{
-			APIVersion: "v1",
-			Kind:       "Node",
-		},
 		ObjectMeta: metav1.ObjectMeta{
 			Name: name,
 		},
diff --git a/util/collections/machine_filters.go b/util/collections/machine_filters.go
@@ -23,7 +23,6 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/apimachinery/pkg/selection"
-	"sigs.k8s.io/controller-runtime/pkg/client"
 
 	controlplanev1 "sigs.k8s.io/cluster-api/api/controlplane/kubeadm/v1beta2"
 	clusterv1 "sigs.k8s.io/cluster-api/api/core/v1beta2"
@@ -101,12 +100,12 @@ func InFailureDomains(failureDomains ...string) Func {
 
 // OwnedMachines returns a filter to find all machines owned by specified owner.
 // Usage: GetFilteredMachinesForCluster(ctx, client, cluster, OwnedMachines(controlPlane)).
-func OwnedMachines(owner client.Object) func(machine *clusterv1.Machine) bool {
+func OwnedMachines(owner *controlplanev1.KubeadmControlPlane) func(machine *clusterv1.Machine) bool {
 	return func(machine *clusterv1.Machine) bool {
 		if machine == nil {
 			return false
 		}
-		return util.IsOwnedByObject(machine, owner)
+		return util.IsOwnedByObject(machine, owner, controlplanev1.GroupVersion.WithKind("KubeadmControlPlane").GroupKind())
 	}
 }
 
diff --git a/util/test/builder/builders.go b/util/test/builder/builders.go
@@ -483,10 +483,6 @@ func (c *ClusterClassBuilder) WithWorkerMachinePoolClasses(mpcs ...clusterv1.Mac
 // Build takes the objects and variables in the ClusterClass builder and uses them to create a ClusterClass object.
 func (c *ClusterClassBuilder) Build() *clusterv1.ClusterClass {
 	obj := &clusterv1.ClusterClass{
-		TypeMeta: metav1.TypeMeta{
-			Kind:       "ClusterClass",
-			APIVersion: clusterv1.GroupVersion.String(),
-		},
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      c.name,
 			Namespace: c.namespace,
@@ -1703,10 +1699,6 @@ func (m *MachinePoolBuilder) WithMinReadySeconds(minReadySeconds int32) *Machine
 // Build creates a new MachinePool with the variables and objects passed to the MachinePoolBuilder.
 func (m *MachinePoolBuilder) Build() *clusterv1.MachinePool {
 	obj := &clusterv1.MachinePool{
-		TypeMeta: metav1.TypeMeta{
-			Kind:       "MachinePool",
-			APIVersion: clusterv1.GroupVersion.String(),
-		},
 		ObjectMeta: metav1.ObjectMeta{
 			Name:        m.name,
 			Namespace:   m.namespace,
@@ -1833,10 +1825,6 @@ func (m *MachineDeploymentBuilder) WithMinReadySeconds(minReadySeconds int32) *M
 // Build creates a new MachineDeployment with the variables and objects passed to the MachineDeploymentBuilder.
 func (m *MachineDeploymentBuilder) Build() *clusterv1.MachineDeployment {
 	obj := &clusterv1.MachineDeployment{
-		TypeMeta: metav1.TypeMeta{
-			Kind:       "MachineDeployment",
-			APIVersion: clusterv1.GroupVersion.String(),
-		},
 		ObjectMeta: metav1.ObjectMeta{
 			Name:        m.name,
 			Namespace:   m.namespace,
@@ -1940,10 +1928,6 @@ func (m *MachineSetBuilder) WithOwnerReferences(ownerRefs []metav1.OwnerReferenc
 // Build creates a new MachineSet with the variables and objects passed to the MachineSetBuilder.
 func (m *MachineSetBuilder) Build() *clusterv1.MachineSet {
 	obj := &clusterv1.MachineSet{
-		TypeMeta: metav1.TypeMeta{
-			Kind:       "MachineSet",
-			APIVersion: clusterv1.GroupVersion.String(),
-		},
 		ObjectMeta: metav1.ObjectMeta{
 			Name:            m.name,
 			Namespace:       m.namespace,
@@ -2015,10 +1999,6 @@ func (m *MachineBuilder) WithLabels(labels map[string]string) *MachineBuilder {
 // Build produces a Machine object from the information passed to the MachineBuilder.
 func (m *MachineBuilder) Build() *clusterv1.Machine {
 	machine := &clusterv1.Machine{
-		TypeMeta: metav1.TypeMeta{
-			Kind:       "Machine",
-			APIVersion: clusterv1.GroupVersion.String(),
-		},
 		ObjectMeta: metav1.ObjectMeta{
 			Namespace: m.namespace,
 			Name:      m.name,
@@ -2150,10 +2130,6 @@ func (m *MachineHealthCheckBuilder) WithMaxUnhealthy(maxUnhealthy *intstr.IntOrS
 func (m *MachineHealthCheckBuilder) Build() *clusterv1.MachineHealthCheck {
 	// create a MachineHealthCheck with the spec given in the ClusterClass
 	mhc := &clusterv1.MachineHealthCheck{
-		TypeMeta: metav1.TypeMeta{
-			Kind:       "MachineHealthCheck",
-			APIVersion: clusterv1.GroupVersion.String(),
-		},
 		ObjectMeta: metav1.ObjectMeta{
 			Name:            m.name,
 			Namespace:       m.namespace,
diff --git a/util/util.go b/util/util.go
diff --git a/util/util_test.go b/util/util_test.go

Original file line number	Diff line number	Diff line change
`@@ -22,6 +22,7 @@ import (`
`22`	`22`	`corev1 "k8s.io/api/core/v1"`
`23`	`23`	`metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"`
`24`	`24`	`"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"`
	`25`	`+ "k8s.io/apimachinery/pkg/runtime/schema"`
`25`	`26`	`"sigs.k8s.io/controller-runtime/pkg/client"`
`26`	`27`
`27`	`28`	`addonsv1 "sigs.k8s.io/cluster-api/api/addons/v1beta2"`
`@@ -286,7 +287,7 @@ func addMachineDeploymentToObjectTree(ctx context.Context, c client.Client, clus`
`286`	`287`	`tree.Add(templateParent, machineTemplateRefObject, ObjectMetaName("MachineInfrastructureTemplate"))`
`287`	`288`	`}`
`288`	`289`
`289`		`- machineSets := selectMachinesSetsControlledBy(machineSetList, md)`
	`290`	`+ machineSets := selectMachinesSetsControlledBy(machineSetList, md, clusterv1.GroupVersion.WithKind("MachineDeployment").GroupKind())`
`290`	`291`	`for i := range machineSets {`
`291`	`292`	`ms := machineSets[i]`
`292`	`293`
`@@ -296,7 +297,7 @@ func addMachineDeploymentToObjectTree(ctx context.Context, c client.Client, clus`
`296`	`297`	`parent = ms`
`297`	`298`	`}`
`298`	`299`
`299`		`- machines := selectMachinesControlledBy(machinesList, ms)`
	`300`	`+ machines := selectMachinesControlledBy(machinesList, ms, clusterv1.GroupVersion.WithKind("MachineSet").GroupKind())`
`300`	`301`	`for _, w := range machines {`
`301`	`302`	`addMachineFunc(parent, w)`
`302`	`303`	`}`
`@@ -321,7 +322,7 @@ func addMachinePoolsToObjectTree(ctx context.Context, c client.Client, workers *`
`321`	`322`	`}`
`322`	`323`	`}`
`323`	`324`
`324`		`- machines := selectMachinesControlledBy(machinesList, mp)`
	`325`	`+ machines := selectMachinesControlledBy(machinesList, mp, clusterv1.GroupVersion.WithKind("MachinePool").GroupKind())`
`325`	`326`	`for _, m := range machines {`
`326`	`327`	`addMachineFunc(mp, m)`
`327`	`328`	`}`
`@@ -417,22 +418,22 @@ func selectControlPlaneMachines(machineList clusterv1.MachineList) []clusterv1`
`417`	`418`	`return machines`
`418`	`419`	`}`
`419`	`420`
`420`		`-func selectMachinesSetsControlledBy(machineSetList clusterv1.MachineSetList, controller client.Object) []clusterv1.MachineSet {`
	`421`	`+func selectMachinesSetsControlledBy(machineSetList clusterv1.MachineSetList, controller client.Object, controllerGK schema.GroupKind) []clusterv1.MachineSet {`
`421`	`422`	`machineSets := []*clusterv1.MachineSet{}`
`422`	`423`	`for i := range machineSetList.Items {`
`423`	`424`	`m := &machineSetList.Items[i]`
`424`		`- if util.IsControlledBy(m, controller) {`
	`425`	`+ if util.IsControlledBy(m, controller, controllerGK) {`
`425`	`426`	`machineSets = append(machineSets, m)`
`426`	`427`	`}`
`427`	`428`	`}`
`428`	`429`	`return machineSets`
`429`	`430`	`}`
`430`	`431`
`431`		`-func selectMachinesControlledBy(machineList clusterv1.MachineList, controller client.Object) []clusterv1.Machine {`
	`432`	`+func selectMachinesControlledBy(machineList clusterv1.MachineList, controller client.Object, controllerGK schema.GroupKind) []clusterv1.Machine {`
`432`	`433`	`machines := []*clusterv1.Machine{}`
`433`	`434`	`for i := range machineList.Items {`
`434`	`435`	`m := &machineList.Items[i]`
`435`		`- if util.IsControlledBy(m, controller) {`
	`436`	`+ if util.IsControlledBy(m, controller, controllerGK) {`
`436`	`437`	`machines = append(machines, m)`
`437`	`438`	`}`
`438`	`439`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1387,7 +1387,7 @@ func (r *KubeadmControlPlaneReconciler) adoptOwnedSecrets(ctx context.Context, k`
`1387`	`1387`
`1388`	`1388`	`for i := range secrets.Items {`
`1389`	`1389`	`s := secrets.Items[i]`
`1390`		`- if !util.IsOwnedByObject(&s, currentOwner) {`
	`1390`	`+ if !util.IsOwnedByObject(&s, currentOwner, bootstrapv1.GroupVersion.WithKind("KubeadmConfig").GroupKind()) {`
`1391`	`1391`	`continue`
`1392`	`1392`	`}`
`1393`	`1393`	`// avoid taking ownership of the bootstrap data secret`
Original file line number	Diff line number	Diff line change
`@@ -94,7 +94,7 @@ func (r *KubeadmControlPlaneReconciler) reconcileKubeconfig(ctx context.Context,`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`// only do rotation on owned secrets`
`97`		`- if !util.IsControlledBy(configSecret, controlPlane.KCP) {`
	`97`	`+ if !util.IsControlledBy(configSecret, controlPlane.KCP, controlplanev1.GroupVersion.WithKind("KubeadmControlPlane").GroupKind()) {`
`98`	`98`	`return ctrl.Result{}, nil`
`99`	`99`	`}`
`100`	`100`
Original file line number	Diff line number	Diff line change
`@@ -631,7 +631,7 @@ func (c clusterDescendants) filterOwnedDescendants(cluster clusterv1.Cluster)`
`631`	`631`	`return nil //nolint:nilerr // We don't want to exit the EachListItem loop, just continue`
`632`	`632`	`}`
`633`	`633`
`634`		`- if util.IsOwnedByObject(acc, cluster) {`
	`634`	`+ if util.IsOwnedByObject(acc, cluster, clusterv1.GroupVersion.WithKind("Cluster").GroupKind()) {`
`635`	`635`	`ownedDescendants = append(ownedDescendants, obj)`
`636`	`636`	`}`
`637`	`637`
Original file line number	Diff line number	Diff line change
`@@ -246,7 +246,7 @@ func setWorkersReplicas(_ context.Context, cluster *clusterv1.Cluster, machinePo`
`246`	`246`	`}`
`247`	`247`
`248`	`248`	`for _, ms := range machineSets.Items {`
`249`		`- if !util.IsOwnedByObject(&ms, cluster) {`
	`249`	`+ if !util.IsOwnedByObject(&ms, cluster, clusterv1.GroupVersion.WithKind("Cluster").GroupKind()) {`
`250`	`250`	`continue`
`251`	`251`	`}`
`252`	`252`	`if ms.Spec.Replicas != nil {`
`@@ -267,7 +267,7 @@ func setWorkersReplicas(_ context.Context, cluster *clusterv1.Cluster, machinePo`
`267`	`267`	`}`
`268`	`268`
`269`	`269`	`for _, m := range workerMachines.UnsortedList() {`
`270`		`- if !util.IsOwnedByObject(m, cluster) {`
	`270`	`+ if !util.IsOwnedByObject(m, cluster, clusterv1.GroupVersion.WithKind("Cluster").GroupKind()) {`
`271`	`271`	`continue`
`272`	`272`	`}`
`273`	`273`	`currentReplicas = ptr.To(ptr.Deref(currentReplicas, 0) + 1)`
`@@ -973,7 +973,7 @@ func setScalingUpCondition(ctx context.Context, cluster *clusterv1.Cluster, cont`
`973`	`973`	`ws = append(ws, aggregationWrapper{md: &md})`
`974`	`974`	`}`
`975`	`975`	`for _, ms := range machineSets.Items {`
`976`		`- if !util.IsOwnedByObject(&ms, cluster) {`
	`976`	`+ if !util.IsOwnedByObject(&ms, cluster, clusterv1.GroupVersion.WithKind("Cluster").GroupKind()) {`
`977`	`977`	`continue`
`978`	`978`	`}`
`979`	`979`	`ws = append(ws, aggregationWrapper{ms: &ms})`
`@@ -1050,7 +1050,7 @@ func setScalingDownCondition(ctx context.Context, cluster *clusterv1.Cluster, co`
`1050`	`1050`	`ws = append(ws, aggregationWrapper{md: &md})`
`1051`	`1051`	`}`
`1052`	`1052`	`for _, ms := range machineSets.Items {`
`1053`		`- if !util.IsOwnedByObject(&ms, cluster) {`
	`1053`	`+ if !util.IsOwnedByObject(&ms, cluster, clusterv1.GroupVersion.WithKind("Cluster").GroupKind()) {`
`1054`	`1054`	`continue`
`1055`	`1055`	`}`
`1056`	`1056`	`ws = append(ws, aggregationWrapper{ms: &ms})`