fake_objects.go

/*
Copyright 2019 The Kubernetes Authors.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package test

import (
	"fmt"
	"strings"

	corev1 "k8s.io/api/core/v1"
	apiextensionslv1 "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/runtime"
	"k8s.io/apimachinery/pkg/types"
	clusterv1 "sigs.k8s.io/cluster-api/api/v1alpha3"
	clusterctlv1 "sigs.k8s.io/cluster-api/cmd/clusterctl/api/v1alpha3"
	fakebootstrap "sigs.k8s.io/cluster-api/cmd/clusterctl/internal/test/providers/bootstrap"
	fakecontrolplane "sigs.k8s.io/cluster-api/cmd/clusterctl/internal/test/providers/controlplane"
	fakeinfrastructure "sigs.k8s.io/cluster-api/cmd/clusterctl/internal/test/providers/infrastructure"
	expv1 "sigs.k8s.io/cluster-api/exp/api/v1alpha3"
)

type FakeCluster struct {
	namespace          string
	name               string
	controlPlane       *FakeControlPlane
	machinePools       []*FakeMachinePool
	machineDeployments []*FakeMachineDeployment
	machineSets        []*FakeMachineSet
	machines           []*FakeMachine
}

// NewFakeCluster return a FakeCluster that can generate a cluster object, all its own ancillary objects:
// - the clusterInfrastructure object
// - the kubeconfig secret object (if there is no a control plane object)
// - a user defined ca secret
// and all the objects for the defined FakeControlPlane, FakeMachinePools, FakeMachineDeployments, FakeMachineSets, FakeMachines
// Nb. if there is no a control plane object, the first FakeMachine gets a generated sa secret
func NewFakeCluster(namespace, name string) *FakeCluster {
	return &FakeCluster{
		namespace: namespace,
		name:      name,
	}
}

func (f *FakeCluster) WithControlPlane(fakeControlPlane *FakeControlPlane) *FakeCluster {
	f.controlPlane = fakeControlPlane
	return f
}

func (f *FakeCluster) WithMachinePools(fakeMachinePool ...*FakeMachinePool) *FakeCluster {
	f.machinePools = append(f.machinePools, fakeMachinePool...)
	return f
}

func (f *FakeCluster) WithMachineDeployments(fakeMachineDeployment ...*FakeMachineDeployment) *FakeCluster {
	f.machineDeployments = append(f.machineDeployments, fakeMachineDeployment...)
	return f
}

func (f *FakeCluster) WithMachineSets(fakeMachineSet ...*FakeMachineSet) *FakeCluster {
	f.machineSets = append(f.machineSets, fakeMachineSet...)
	return f
}

func (f *FakeCluster) WithMachines(fakeMachine ...*FakeMachine) *FakeCluster {
	f.machines = append(f.machines, fakeMachine...)
	return f
}

func (f *FakeCluster) Objs() []runtime.Object {
	clusterInfrastructure := &fakeinfrastructure.DummyInfrastructureCluster{
		TypeMeta: metav1.TypeMeta{
			APIVersion: fakeinfrastructure.GroupVersion.String(),
			Kind:       "DummyInfrastructureCluster",
		},
		ObjectMeta: metav1.ObjectMeta{
			Name:      f.name,
			Namespace: f.namespace,
			// OwnerReferences: cluster, Added by the cluster controller (see below) -- RECONCILED
			// Labels: cluster.x-k8s.io/cluster-name=cluster, Added by the cluster controller (see below) -- RECONCILED
		},
	}

	cluster := &clusterv1.Cluster{
		TypeMeta: metav1.TypeMeta{
			Kind:       "Cluster",
			APIVersion: clusterv1.GroupVersion.String(),
		},
		ObjectMeta: metav1.ObjectMeta{
			Name:      f.name,
			Namespace: f.namespace,
			// Labels: cluster.x-k8s.io/cluster-name=cluster MISSING??
		},
		Spec: clusterv1.ClusterSpec{
			InfrastructureRef: &corev1.ObjectReference{
				APIVersion: clusterInfrastructure.APIVersion,
				Kind:       clusterInfrastructure.Kind,
				Name:       clusterInfrastructure.Name,
				Namespace:  clusterInfrastructure.Namespace,
			},
		},
	}

	// Ensure the cluster gets a UID to be used by dependant objects for creating OwnerReferences.
	setUID(cluster)

	clusterInfrastructure.SetOwnerReferences([]metav1.OwnerReference{
		{
			APIVersion: cluster.APIVersion,
			Kind:       cluster.Kind,
			Name:       cluster.Name,
			UID:        cluster.UID,
		},
	})
	clusterInfrastructure.SetLabels(map[string]string{
		clusterv1.ClusterLabelName: cluster.Name,
	})

	caSecret := &corev1.Secret{ // provided by the user -- ** NOT RECONCILED **
		TypeMeta: metav1.TypeMeta{
			Kind:       "Secret",
			APIVersion: "v1",
		},
		ObjectMeta: metav1.ObjectMeta{
			Name:      f.name + "-ca",
			Namespace: f.namespace,
		},
	}

	objs := []runtime.Object{
		cluster,
		clusterInfrastructure,
		caSecret,
	}

	// if the cluster has a control plane object
	if f.controlPlane != nil {
		// Adds the objects for the controlPlane
		objs = append(objs, f.controlPlane.Objs(cluster)...)
	} else {
		// Adds the kubeconfig object generated by the cluster controller -- ** NOT RECONCILED **
		kubeconfigSecret := &corev1.Secret{
			TypeMeta: metav1.TypeMeta{
				Kind:       "Secret",
				APIVersion: "v1",
			},
			ObjectMeta: metav1.ObjectMeta{
				Name:      f.name + "-kubeconfig",
				Namespace: f.namespace,
				OwnerReferences: []metav1.OwnerReference{
					{
						APIVersion: cluster.APIVersion,
						Kind:       cluster.Kind,
						Name:       cluster.Name,
						UID:        cluster.UID,
					},
				},
				// Labels: cluster.x-k8s.io/cluster-name=cluster MISSING??
			},
		}
		objs = append(objs, kubeconfigSecret)
	}

	// Adds the objects for the machinePools
	for _, machinePool := range f.machinePools {
		objs = append(objs, machinePool.Objs(cluster)...)
	}

	// Adds the objects for the machineDeployments
	for _, machineDeployment := range f.machineDeployments {
		objs = append(objs, machineDeployment.Objs(cluster)...)
	}

	// Adds the objects for the machineSets directly attached to the cluster
	for _, machineSet := range f.machineSets {
		objs = append(objs, machineSet.Objs(cluster, nil)...)
	}

	// Adds the objects for the machines directly attached to the cluster
	// Nb. In case there is no control plane, the first machine is arbitrarily used to simulate the generation of certificates Secrets implemented by the bootstrap controller.
	for i, machine := range f.machines {
		generateCerts := false
		if f.controlPlane == nil && i == 0 {
			generateCerts = true
		}
		objs = append(objs, machine.Objs(cluster, generateCerts, nil, nil)...)
	}

	// Ensure all the objects gets UID.
	// Nb. This adds UID to all the objects; it does not change the UID explicitly sets in advance for the objects involved in the object graphs.
	for _, o := range objs {
		setUID(o)
	}

	return objs
}

type FakeControlPlane struct {
	name     string
	machines []*FakeMachine
}

// NewFakeControlPlane return a FakeControlPlane that can generate a controlPlane object, all its own ancillary objects:
// - the controlPlaneInfrastructure template object
// - the kubeconfig secret object
// - a generated sa secret
// and all the objects for the defined FakeMachines
func NewFakeControlPlane(name string) *FakeControlPlane {
	return &FakeControlPlane{
		name: name,
	}
}

func (f *FakeControlPlane) WithMachines(fakeMachine ...*FakeMachine) *FakeControlPlane {
	f.machines = append(f.machines, fakeMachine...)
	return f
}

func (f *FakeControlPlane) Objs(cluster *clusterv1.Cluster) []runtime.Object {

	controlPlaneInfrastructure := &fakeinfrastructure.DummyInfrastructureMachineTemplate{
		TypeMeta: metav1.TypeMeta{
			APIVersion: fakeinfrastructure.GroupVersion.String(),
			Kind:       "DummyInfrastructureMachineTemplate",
		},
		ObjectMeta: metav1.ObjectMeta{
			Name:      f.name,
			Namespace: cluster.Namespace,
			OwnerReferences: []metav1.OwnerReference{ // Added by the control plane  controller (see below) -- RECONCILED
				{
					APIVersion: clusterv1.GroupVersion.String(),
					Kind:       "Cluster",
					Name:       cluster.Name,
					UID:        cluster.UID,
				},
			},
			// Labels: MISSING
		},
	}

	controlPlane := &fakecontrolplane.DummyControlPlane{
		TypeMeta: metav1.TypeMeta{
			APIVersion: fakecontrolplane.GroupVersion.String(),
			Kind:       "DummyControlPlane",
		},
		ObjectMeta: metav1.ObjectMeta{
			Name:      f.name,
			Namespace: cluster.Namespace,
			OwnerReferences: []metav1.OwnerReference{ // Added by the control plane  controller (see below) -- RECONCILED
				{
					APIVersion: clusterv1.GroupVersion.String(),
					Kind:       "Cluster",
					Name:       cluster.Name,
					UID:        cluster.UID,
				},
			},
			Labels: map[string]string{ // cluster.x-k8s.io/cluster-name=cluster, Added by the control plane controller (see below) -- RECONCILED
				clusterv1.ClusterLabelName: cluster.Name,
			},
		},
		Spec: fakecontrolplane.DummyControlPlaneSpec{
			InfrastructureTemplate: corev1.ObjectReference{
				APIVersion: controlPlaneInfrastructure.APIVersion,
				Kind:       controlPlaneInfrastructure.Kind,
				Namespace:  controlPlaneInfrastructure.Namespace,
				Name:       controlPlaneInfrastructure.Name,
			},
		},
	}

	// Ensure the controlPlane gets a UID to be used by dependant objects for creating OwnerReferences.
	setUID(controlPlane)

	// sets the reference from the cluster to the plane object
	cluster.Spec.ControlPlaneRef = &corev1.ObjectReference{
		APIVersion: controlPlane.APIVersion,
		Kind:       controlPlane.Kind,
		Namespace:  controlPlane.Namespace,
		Name:       controlPlane.Name,
	}

	// Adds the kubeconfig object generated by the control plane  controller -- ** NOT RECONCILED **
	kubeconfigSecret := &corev1.Secret{
		TypeMeta: metav1.TypeMeta{
			Kind:       "Secret",
			APIVersion: "v1",
		},
		ObjectMeta: metav1.ObjectMeta{
			Name:      cluster.GetName() + "-kubeconfig",
			Namespace: cluster.GetNamespace(),
			// Labels: cluster.x-k8s.io/cluster-name=cluster MISSING??
		},
	}
	kubeconfigSecret.SetOwnerReferences([]metav1.OwnerReference{*metav1.NewControllerRef(controlPlane, controlPlane.GroupVersionKind())})

	// Adds one of the certificate secret object generated by the control plane controller -- ** NOT RECONCILED **
	saSecret := &corev1.Secret{
		TypeMeta: metav1.TypeMeta{
			Kind:       "Secret",
			APIVersion: "v1",
		},
		ObjectMeta: metav1.ObjectMeta{
			Name:      cluster.GetName() + "-sa",
			Namespace: cluster.GetNamespace(),
			// Labels: cluster.x-k8s.io/cluster-name=cluster MISSING??
		},
	}
	saSecret.SetOwnerReferences([]metav1.OwnerReference{*metav1.NewControllerRef(controlPlane, controlPlane.GroupVersionKind())})

	objs := []runtime.Object{
		controlPlane,
		controlPlaneInfrastructure,
		kubeconfigSecret,
		saSecret,
	}

	// Adds the objects for the machines controlled by the controlPlane
	for _, machine := range f.machines {
		objs = append(objs, machine.Objs(cluster, false, nil, controlPlane)...)
	}

	return objs
}

type FakeMachinePool struct {
	name string
}

// NewFakeMachinePool return a FakeMachinePool that can generate a MachinePool object, all its own ancillary objects:
// - the machinePoolInfrastructure object
// - the machinePoolBootstrap object
func NewFakeMachinePool(name string) *FakeMachinePool {
	return &FakeMachinePool{
		name: name,
	}
}

func (f *FakeMachinePool) Objs(cluster *clusterv1.Cluster) []runtime.Object {
	machinePoolInfrastructure := &fakeinfrastructure.DummyInfrastructureMachineTemplate{
		TypeMeta: metav1.TypeMeta{
			APIVersion: fakeinfrastructure.GroupVersion.String(),
			Kind:       "DummyInfrastructureMachineTemplate",
		},
		ObjectMeta: metav1.ObjectMeta{
			Name:      f.name,
			Namespace: cluster.Namespace,
			OwnerReferences: []metav1.OwnerReference{ // Added by the machinePool controller (mirrors machinePool.spec.ClusterName) -- RECONCILED
				{
					APIVersion: clusterv1.GroupVersion.String(),
					Kind:       "Cluster",
					Name:       cluster.Name,
					UID:        cluster.UID,
				},
			},
			// Labels: MISSING
		},
	}

	machinePoolBootstrap := &fakebootstrap.DummyBootstrapConfigTemplate{
		TypeMeta: metav1.TypeMeta{
			APIVersion: fakebootstrap.GroupVersion.String(),
			Kind:       "DummyBootstrapConfigTemplate",
		},
		ObjectMeta: metav1.ObjectMeta{
			Name:      f.name,
			Namespace: cluster.Namespace,
			OwnerReferences: []metav1.OwnerReference{ // Added by the machinePool controller (mirrors machinePool.spec.ClusterName) -- RECONCILED
				{
					APIVersion: clusterv1.GroupVersion.String(),
					Kind:       "Cluster",
					Name:       cluster.Name,
					UID:        cluster.UID,
				},
			},
			// Labels: MISSING
		},
	}

	machinePool := &expv1.MachinePool{
		TypeMeta: metav1.TypeMeta{
			Kind:       "MachinePool",
			APIVersion: expv1.GroupVersion.String(),
		},
		ObjectMeta: metav1.ObjectMeta{
			Name:      f.name,
			Namespace: cluster.Namespace,
			OwnerReferences: []metav1.OwnerReference{ // Added by the machinePool controller (mirrors machinePool.spec.ClusterName) -- RECONCILED
				{
					APIVersion: clusterv1.GroupVersion.String(),
					Kind:       "Cluster",
					Name:       cluster.Name,
					UID:        cluster.UID,
				},
			},
			Labels: map[string]string{
				clusterv1.ClusterLabelName: cluster.Name, // Added by the machinePool controller (mirrors machinePoolt.spec.ClusterName) -- RECONCILED
			},
		},
		Spec: expv1.MachinePoolSpec{
			Template: clusterv1.MachineTemplateSpec{
				Spec: clusterv1.MachineSpec{
					InfrastructureRef: corev1.ObjectReference{
						APIVersion: machinePoolInfrastructure.APIVersion,
						Kind:       machinePoolInfrastructure.Kind,
						Name:       machinePoolInfrastructure.Name,
						Namespace:  machinePoolInfrastructure.Namespace,
					},
					Bootstrap: clusterv1.Bootstrap{
						ConfigRef: &corev1.ObjectReference{
							APIVersion: machinePoolBootstrap.APIVersion,
							Kind:       machinePoolBootstrap.Kind,
							Name:       machinePoolBootstrap.Name,
							Namespace:  machinePoolBootstrap.Namespace,
						},
					},
				},
			},
			ClusterName: cluster.Name,
		},
	}

	// Ensure the machinePool gets a UID to be used by dependant objects for creating OwnerReferences.
	setUID(machinePool)

	objs := []runtime.Object{
		machinePool,
		machinePoolInfrastructure,
		machinePoolBootstrap,
	}

	return objs
}

func NewFakeInfrastructureTemplate(name string) *fakeinfrastructure.DummyInfrastructureMachineTemplate {
	return &fakeinfrastructure.DummyInfrastructureMachineTemplate{
		TypeMeta: metav1.TypeMeta{
			APIVersion: fakeinfrastructure.GroupVersion.String(),
			Kind:       "DummyInfrastructureMachineTemplate",
		},
		ObjectMeta: metav1.ObjectMeta{
			Name: name,
			// OwnerReference Added by the machine set controller -- RECONCILED
			// Labels: MISSING
		},
	}
}

type FakeMachineDeployment struct {
	name                         string
	machineSets                  []*FakeMachineSet
	sharedInfrastructureTemplate *fakeinfrastructure.DummyInfrastructureMachineTemplate
}

// NewFakeMachineDeployment return a FakeMachineDeployment that can generate a MachineDeployment object, all its own ancillary objects:
// - the machineDeploymentInfrastructure template object
// - the machineDeploymentBootstrap template object
// and all the objects for the defined FakeMachineSet
func NewFakeMachineDeployment(name string) *FakeMachineDeployment {
	return &FakeMachineDeployment{
		name: name,
	}
}

func (f *FakeMachineDeployment) WithMachineSets(fakeMachineSet ...*FakeMachineSet) *FakeMachineDeployment {
	f.machineSets = append(f.machineSets, fakeMachineSet...)
	return f
}

func (f *FakeMachineDeployment) WithInfrastructureTemplate(infrastructureTemplate *fakeinfrastructure.DummyInfrastructureMachineTemplate) *FakeMachineDeployment {
	f.sharedInfrastructureTemplate = infrastructureTemplate
	return f
}

func (f *FakeMachineDeployment) Objs(cluster *clusterv1.Cluster) []runtime.Object {
	// infra template can be either shared or specific to the machine deployment
	machineDeploymentInfrastructure := f.sharedInfrastructureTemplate
	if machineDeploymentInfrastructure == nil {
		machineDeploymentInfrastructure = NewFakeInfrastructureTemplate(f.name)
	}
	machineDeploymentInfrastructure.Namespace = cluster.Namespace
	machineDeploymentInfrastructure.OwnerReferences = append(machineDeploymentInfrastructure.OwnerReferences, // Added by the machine set controller -- RECONCILED
		metav1.OwnerReference{
			APIVersion: clusterv1.GroupVersion.String(),
			Kind:       "Cluster",
			Name:       cluster.Name,
			UID:        cluster.UID,
		},
	)
	setUID(machineDeploymentInfrastructure)

	machineDeploymentBootstrap := &fakebootstrap.DummyBootstrapConfigTemplate{
		TypeMeta: metav1.TypeMeta{
			APIVersion: fakebootstrap.GroupVersion.String(),
			Kind:       "DummyBootstrapConfigTemplate",
		},
		ObjectMeta: metav1.ObjectMeta{
			Name:      f.name,
			Namespace: cluster.Namespace,
			OwnerReferences: []metav1.OwnerReference{ // Added by the machine set controller -- RECONCILED
				{
					APIVersion: clusterv1.GroupVersion.String(),
					Kind:       "Cluster",
					Name:       cluster.Name,
					UID:        cluster.UID,
				},
			},
			// Labels: MISSING
		},
	}

	machineDeployment := &clusterv1.MachineDeployment{
		TypeMeta: metav1.TypeMeta{
			Kind:       "MachineDeployment",
			APIVersion: clusterv1.GroupVersion.String(),
		},
		ObjectMeta: metav1.ObjectMeta{
			Name:      f.name,
			Namespace: cluster.Namespace,
			OwnerReferences: []metav1.OwnerReference{ // Added by the machineDeployment controller (mirrors machineDeployment.spec.ClusterName) -- RECONCILED
				{
					APIVersion: clusterv1.GroupVersion.String(),
					Kind:       "Cluster",
					Name:       cluster.Name,
					UID:        cluster.UID,
				},
			},
			Labels: map[string]string{
				clusterv1.ClusterLabelName: cluster.Name, // Added by the machineDeployment controller (mirrors machineDeployment.spec.ClusterName) -- RECONCILED
			},
		},
		Spec: clusterv1.MachineDeploymentSpec{
			Template: clusterv1.MachineTemplateSpec{
				Spec: clusterv1.MachineSpec{
					InfrastructureRef: corev1.ObjectReference{
						APIVersion: machineDeploymentInfrastructure.APIVersion,
						Kind:       machineDeploymentInfrastructure.Kind,
						Name:       machineDeploymentInfrastructure.Name,
						Namespace:  machineDeploymentInfrastructure.Namespace,
					},
					Bootstrap: clusterv1.Bootstrap{
						ConfigRef: &corev1.ObjectReference{
							APIVersion: machineDeploymentBootstrap.APIVersion,
							Kind:       machineDeploymentBootstrap.Kind,
							Name:       machineDeploymentBootstrap.Name,
							Namespace:  machineDeploymentBootstrap.Namespace,
						},
					},
				},
			},
			ClusterName: cluster.Name,
		},
	}

	// Ensure the machineDeployment gets a UID to be used by dependant objects for creating OwnerReferences.
	setUID(machineDeployment)

	objs := []runtime.Object{
		machineDeployment,
		machineDeploymentBootstrap,
	}
	// if the infra template is specific to the machine deployment, add it to the object list
	if f.sharedInfrastructureTemplate == nil {
		objs = append(objs, machineDeploymentInfrastructure)
	}

	// Adds the objects for the machineSets
	for _, machineSet := range f.machineSets {
		objs = append(objs, machineSet.Objs(cluster, machineDeployment)...)
	}

	return objs
}

type FakeMachineSet struct {
	name                         string
	machines                     []*FakeMachine
	sharedInfrastructureTemplate *fakeinfrastructure.DummyInfrastructureMachineTemplate
}

// NewFakeMachineSet return a FakeMachineSet that can generate a MachineSet object, all its own ancillary objects:
// - the machineSetInfrastructure template object (only if not controlled by a MachineDeployment)
// - the machineSetBootstrap template object (only if not controlled by a MachineDeployment)
// and all the objects for the defined FakeMachine
func NewFakeMachineSet(name string) *FakeMachineSet {
	return &FakeMachineSet{
		name: name,
	}
}

func (f *FakeMachineSet) WithMachines(fakeMachine ...*FakeMachine) *FakeMachineSet {
	f.machines = append(f.machines, fakeMachine...)
	return f
}

func (f *FakeMachineSet) WithInfrastructureTemplate(infrastructureTemplate *fakeinfrastructure.DummyInfrastructureMachineTemplate) *FakeMachineSet {
	f.sharedInfrastructureTemplate = infrastructureTemplate
	return f
}

func (f *FakeMachineSet) Objs(cluster *clusterv1.Cluster, machineDeployment *clusterv1.MachineDeployment) []runtime.Object {
	machineSet := &clusterv1.MachineSet{ // Created by machineDeployment controller
		TypeMeta: metav1.TypeMeta{
			Kind:       "MachineSet",
			APIVersion: clusterv1.GroupVersion.String(),
		},
		ObjectMeta: metav1.ObjectMeta{
			Name:      f.name,
			Namespace: cluster.Namespace,
			// Owner reference set by machineSet controller or by machineDeployment controller (see below)
			Labels: map[string]string{
				clusterv1.ClusterLabelName: cluster.Name, // Added by the machineSet controller (mirrors machineSet.spec.ClusterName) -- RECONCILED
			},
		},
		Spec: clusterv1.MachineSetSpec{
			ClusterName: cluster.Name,
		},
	}

	// Ensure the machineSet gets a UID to be used by dependant objects for creating OwnerReferences.
	setUID(machineSet)

	objs := make([]runtime.Object, 0)

	if machineDeployment != nil {
		// If this machineSet belong to a machineDeployment, it is controlled by it / ownership set by the machineDeployment controller  -- ** NOT RECONCILED **
		machineSet.SetOwnerReferences([]metav1.OwnerReference{*metav1.NewControllerRef(machineDeployment, machineDeployment.GroupVersionKind())})

		// additionally the machine has ref to the same infra and bootstrap templates defined in the MachineDeployment
		machineSet.Spec.Template.Spec.InfrastructureRef = *machineDeployment.Spec.Template.Spec.InfrastructureRef.DeepCopy()
		machineSet.Spec.Template.Spec.Bootstrap.ConfigRef = machineDeployment.Spec.Template.Spec.Bootstrap.ConfigRef.DeepCopy()

		objs = append(objs, machineSet)
	} else {

		// If this machineSet does not belong to a machineDeployment, it is owned by the cluster / ownership set by the machineSet controller -- RECONCILED
		machineSet.SetOwnerReferences([]metav1.OwnerReference{{
			APIVersion: cluster.APIVersion,
			Kind:       cluster.Kind,
			Name:       cluster.Name,
			UID:        cluster.UID,
		}})

		// additionally the machineSet has ref to dedicated infra and bootstrap templates

		// infra template can be either shared or specific to the machine set
		machineSetInfrastructure := f.sharedInfrastructureTemplate
		if machineSetInfrastructure == nil {
			machineSetInfrastructure = NewFakeInfrastructureTemplate(f.name)
		}
		machineSetInfrastructure.Namespace = cluster.Namespace
		machineSetInfrastructure.OwnerReferences = append(machineSetInfrastructure.OwnerReferences, // Added by the machine set controller -- RECONCILED
			metav1.OwnerReference{
				APIVersion: clusterv1.GroupVersion.String(),
				Kind:       "Cluster",
				Name:       cluster.Name,
				UID:        cluster.UID,
			},
		)
		setUID(machineSetInfrastructure)

		machineSet.Spec.Template.Spec.InfrastructureRef = corev1.ObjectReference{
			APIVersion: machineSetInfrastructure.APIVersion,
			Kind:       machineSetInfrastructure.Kind,
			Name:       machineSetInfrastructure.Name,
			Namespace:  machineSetInfrastructure.Namespace,
		}

		machineSetBootstrap := &fakebootstrap.DummyBootstrapConfigTemplate{
			TypeMeta: metav1.TypeMeta{
				APIVersion: fakebootstrap.GroupVersion.String(),
				Kind:       "DummyBootstrapConfigTemplate",
			},
			ObjectMeta: metav1.ObjectMeta{
				Name:      f.name,
				Namespace: cluster.Namespace,
				OwnerReferences: []metav1.OwnerReference{ // Added by the machine set controller -- RECONCILED
					{
						APIVersion: clusterv1.GroupVersion.String(),
						Kind:       "Cluster",
						Name:       cluster.Name,
						UID:        cluster.UID,
					},
				},
				// Labels: MISSING
			},
		}

		machineSet.Spec.Template.Spec.Bootstrap = clusterv1.Bootstrap{
			ConfigRef: &corev1.ObjectReference{
				APIVersion: machineSetBootstrap.APIVersion,
				Kind:       machineSetBootstrap.Kind,
				Name:       machineSetBootstrap.Name,
				Namespace:  machineSetBootstrap.Namespace,
			},
		}

		objs = append(objs, machineSet, machineSetBootstrap)
		// if the infra template is specific to the machine set, add it to the object list
		if f.sharedInfrastructureTemplate == nil {
			objs = append(objs, machineSetInfrastructure)
		}
	}

	// Adds the objects for the machines controlled by the machineSet
	for _, machine := range f.machines {
		objs = append(objs, machine.Objs(cluster, false, machineSet, nil)...)
	}

	return objs
}

type FakeMachine struct {
	name string
}

// NewFakeMachine return a FakeMachine that can generate a Machine object, all its own ancillary objects:
// - the machineInfrastructure object
// - the machineBootstrap object and the related bootstrapDataSecret
// If there is no a control plane object in the cluster, the first FakeMachine gets a generated sa secret
func NewFakeMachine(name string) *FakeMachine {
	return &FakeMachine{
		name: name,
	}
}

func (f *FakeMachine) Objs(cluster *clusterv1.Cluster, generateCerts bool, machineSet *clusterv1.MachineSet, controlPlane *fakecontrolplane.DummyControlPlane) []runtime.Object {

	machineInfrastructure := &fakeinfrastructure.DummyInfrastructureMachine{
		TypeMeta: metav1.TypeMeta{
			APIVersion: fakeinfrastructure.GroupVersion.String(),
			Kind:       "DummyInfrastructureMachine",
		},
		ObjectMeta: metav1.ObjectMeta{
			Name:      f.name,
			Namespace: cluster.Namespace,
			// OwnerReferences: machine, Added by the machine controller (see below) -- RECONCILED
			// Labels: cluster.x-k8s.io/cluster-name=cluster, Added by the machine controller (see  below) -- RECONCILED
		},
	}

	bootstrapDataSecretName := f.name

	machineBootstrap := &fakebootstrap.DummyBootstrapConfig{
		TypeMeta: metav1.TypeMeta{
			APIVersion: fakebootstrap.GroupVersion.String(),
			Kind:       "DummyBootstrapConfig",
		},
		ObjectMeta: metav1.ObjectMeta{
			Name:      f.name,
			Namespace: cluster.Namespace,
			// OwnerReferences: machine, Added by the machine controller (see below) -- RECONCILED
			// Labels: cluster.x-k8s.io/cluster-name=cluster, Added by the machine controller (see below) -- RECONCILED
		},
		Status: fakebootstrap.DummyBootstrapConfigStatus{
			DataSecretName: &bootstrapDataSecretName,
		},
	}

	// Ensure the machineBootstrap gets a UID to be used by dependant objects for creating OwnerReferences.
	setUID(machineBootstrap)

	bootstrapDataSecret := &corev1.Secret{ // generated by the bootstrap controller -- ** NOT RECONCILED **
		TypeMeta: metav1.TypeMeta{
			Kind:       "Secret",
			APIVersion: "v1",
		},
		ObjectMeta: metav1.ObjectMeta{
			Name:      bootstrapDataSecretName,
			Namespace: cluster.Namespace,
			OwnerReferences: []metav1.OwnerReference{
				*metav1.NewControllerRef(machineBootstrap, machineBootstrap.GroupVersionKind()),
			},
			Labels: map[string]string{
				clusterv1.ClusterLabelName: cluster.Name, // derives from Config -(ownerRef)-> machine.spec.ClusterName
			},
		},
	}

	machine := &clusterv1.Machine{
		TypeMeta: metav1.TypeMeta{
			Kind:       "Machine",
			APIVersion: clusterv1.GroupVersion.String(),
		},
		ObjectMeta: metav1.ObjectMeta{
			Name:      f.name,
			Namespace: cluster.Namespace,
			// Owner reference set by machine controller or by machineSet controller (see below)
			Labels: map[string]string{
				clusterv1.ClusterLabelName: cluster.Name, // Added by the machine controller (mirrors machine.spec.ClusterName) -- RECONCILED
			},
		},
		Spec: clusterv1.MachineSpec{
			InfrastructureRef: corev1.ObjectReference{
				APIVersion: machineInfrastructure.APIVersion,
				Kind:       machineInfrastructure.Kind,
				Name:       machineInfrastructure.Name,
				Namespace:  cluster.Namespace,
			},
			Bootstrap: clusterv1.Bootstrap{
				ConfigRef: &corev1.ObjectReference{
					APIVersion: machineBootstrap.APIVersion,
					Kind:       machineBootstrap.Kind,
					Name:       machineBootstrap.Name,
					Namespace:  cluster.Namespace,
				},
				DataSecretName: &bootstrapDataSecretName,
			},
			ClusterName: cluster.Name,
		},
	}

	// Ensure the machine gets a UID to be used by dependant objects for creating OwnerReferences.
	setUID(machine)

	var additionalObjs []runtime.Object

	switch {
	case machineSet != nil:
		// If this machine belong to a machineSet, it is controlled by it / ownership set by the machineSet controller -- ** NOT RECONCILED ?? **
		machine.SetOwnerReferences([]metav1.OwnerReference{*metav1.NewControllerRef(machineSet, machineSet.GroupVersionKind())})
	case controlPlane != nil:
		// If this machine belong to a controlPlane, it is controlled by it / ownership set by the controlPlane controller -- ** NOT RECONCILED ?? **
		machine.SetOwnerReferences([]metav1.OwnerReference{*metav1.NewControllerRef(controlPlane, controlPlane.GroupVersionKind())})
		// Sets the MachineControlPlane Label
		machine.Labels[clusterv1.MachineControlPlaneLabelName] = ""
	default:
		// If this machine does not belong to a machineSet or to a control plane, it is owned by the cluster / ownership set by the machine controller -- RECONCILED
		machine.SetOwnerReferences([]metav1.OwnerReference{{
			APIVersion: cluster.APIVersion,
			Kind:       cluster.Kind,
			Name:       cluster.Name,
			UID:        cluster.UID,
		}})

		// Adds one of the certificate secret object generated by the bootstrap config controller -- ** NOT RECONCILED **
		if generateCerts {
			saSecret := &corev1.Secret{
				TypeMeta: metav1.TypeMeta{
					Kind:       "Secret",
					APIVersion: "v1",
				},
				ObjectMeta: metav1.ObjectMeta{
					Name:      cluster.GetName() + "-sa",
					Namespace: cluster.GetNamespace(),
					// Labels: cluster.x-k8s.io/cluster-name=cluster MISSING??
				},
			}
			// Set controlled by the machineBootstrap / ownership set by the bootstrap config controller -- ** NOT RECONCILED ?? **
			saSecret.SetOwnerReferences([]metav1.OwnerReference{*metav1.NewControllerRef(machineBootstrap, machineBootstrap.GroupVersionKind())})

			additionalObjs = append(additionalObjs, saSecret)
		}
	}

	machineInfrastructure.SetOwnerReferences([]metav1.OwnerReference{
		{
			APIVersion: machine.APIVersion,
			Kind:       machine.Kind,
			Name:       machine.Name,
			UID:        machine.UID,
		},
	})
	machineInfrastructure.SetLabels(map[string]string{
		clusterv1.ClusterLabelName: machine.Spec.ClusterName,
	})

	machineBootstrap.SetOwnerReferences([]metav1.OwnerReference{
		{
			APIVersion: machine.APIVersion,
			Kind:       machine.Kind,
			Name:       machine.Name,
			UID:        machine.UID,
		},
	})
	machineBootstrap.SetLabels(map[string]string{
		clusterv1.ClusterLabelName: machine.Spec.ClusterName,
	})

	objs := []runtime.Object{
		machine,
		machineInfrastructure,
		machineBootstrap,
		bootstrapDataSecret,
	}

	objs = append(objs, additionalObjs...)

	return objs
}

// 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 runtime.Object) {
	accessor, err := meta.Accessor(obj)
	if err != nil {
		panic(fmt.Sprintf("failde to get accessor for test object: %v", err))
	}
	uid := fmt.Sprintf("%s, %s/%s", obj.GetObjectKind().GroupVersionKind().String(), accessor.GetNamespace(), accessor.GetName())
	accessor.SetUID(types.UID(uid))
}

// FakeCustomResourceDefinition returns a fake CRD object for the given group/versions/kind.
func FakeCustomResourceDefinition(group string, kind string, versions ...string) *apiextensionslv1.CustomResourceDefinition {
	crd := &apiextensionslv1.CustomResourceDefinition{
		TypeMeta: metav1.TypeMeta{
			Kind:       apiextensionslv1.SchemeGroupVersion.String(),
			APIVersion: "CustomResourceDefinition",
		},
		ObjectMeta: metav1.ObjectMeta{
			Name: fmt.Sprintf("%s.%s", strings.ToLower(kind), group), //NB. this technically should use plural(kind), but for the sake of test what really matters is to generate a unique name
			Labels: map[string]string{
				clusterctlv1.ClusterctlLabelName: "",
			},
		},
		Spec: apiextensionslv1.CustomResourceDefinitionSpec{ //NB. the spec contains only what is strictly required by the move test
			Group: group,
			Names: apiextensionslv1.CustomResourceDefinitionNames{
				Kind: kind,
			},
		},
	}

	for i, version := range versions {
		// set the first version as a storage version
		versionObj := apiextensionslv1.CustomResourceDefinitionVersion{Name: version}
		if i == 0 {
			versionObj.Storage = true
		}
		crd.Spec.Versions = append(crd.Spec.Versions, versionObj)
	}

	return crd
}

// FakeCRDList returns FakeCustomResourceDefinitions for all the Types used in the test object graph
func FakeCRDList() []*apiextensionslv1.CustomResourceDefinition {
	version := "v1alpha3"

	return []*apiextensionslv1.CustomResourceDefinition{
		FakeCustomResourceDefinition(clusterv1.GroupVersion.Group, "Cluster", version),
		FakeCustomResourceDefinition(clusterv1.GroupVersion.Group, "Machine", version),
		FakeCustomResourceDefinition(clusterv1.GroupVersion.Group, "MachineDeployment", version),
		FakeCustomResourceDefinition(clusterv1.GroupVersion.Group, "MachineSet", version),
		FakeCustomResourceDefinition(expv1.GroupVersion.Group, "MachinePool", version),
		FakeCustomResourceDefinition(fakecontrolplane.GroupVersion.Group, "DummyControlPlane", version),
		FakeCustomResourceDefinition(fakeinfrastructure.GroupVersion.Group, "DummyInfrastructureCluster", version),
		FakeCustomResourceDefinition(fakeinfrastructure.GroupVersion.Group, "DummyInfrastructureMachine", version),
		FakeCustomResourceDefinition(fakeinfrastructure.GroupVersion.Group, "DummyInfrastructureMachineTemplate", version),
		FakeCustomResourceDefinition(fakebootstrap.GroupVersion.Group, "DummyBootstrapConfig", version),
		FakeCustomResourceDefinition(fakebootstrap.GroupVersion.Group, "DummyBootstrapConfigTemplate", version),
	}
}