add a test to ensure that exactly one control plane machine initializes if there are multiple control plane machines defined

Author: SataQiu

controllers/kubeadmconfig_controller_test.go

@@ -79,13 +79,13 @@ func TestKubeadmConfigReconciler_Reconcile_ReturnEarlyIfKubeadmConfigIsReady(t *
 	}
 	result, err := k.Reconcile(request)
 	if err != nil {
-		t.Fatal(fmt.Sprintf("Failed to reconcile:\n %+v", err))
+		t.Fatalf("Failed to reconcile:\n %+v", err)
 	}
 	if result.Requeue == true {
-		t.Fatal("did not expected to requeue")
+		t.Fatal("did not expect to requeue")
 	}
 	if result.RequeueAfter != time.Duration(0) {
-		t.Fatal("did not expected to requeue after")
+		t.Fatal("did not expect to requeue after")
 	}
 }
 
@@ -142,13 +142,13 @@ func TestKubeadmConfigReconciler_Reconcile_ReturnEarlyIfMachineHasBootstrapData(
 	}
 	result, err := k.Reconcile(request)
 	if err != nil {
-		t.Fatal(fmt.Sprintf("Failed to reconcile:\n %+v", err))
+		t.Fatalf("Failed to reconcile:\n %+v", err)
 	}
 	if result.Requeue == true {
-		t.Fatal("did not expected to requeue")
+		t.Fatal("did not expect to requeue")
 	}
 	if result.RequeueAfter != time.Duration(0) {
-		t.Fatal("did not expected to requeue after")
+		t.Fatal("did not expect to requeue after")
 	}
 }
 
@@ -218,7 +218,7 @@ func TestKubeadmConfigReconciler_Reconcile_RequeueJoiningNodesIfControlPlaneNotI
 	workerMachine := newWorkerMachine(cluster)
 	workerJoinConfig := newWorkerJoinKubeadmConfig(workerMachine)
 
-	controlPlaneMachine := newControlPlaneMachine(cluster)
+	controlPlaneMachine := newControlPlaneMachine(cluster, "control-plane-machine")
 	controlPlaneJoinConfig := newControlPlaneJoinKubeadmConfig(controlPlaneMachine, "control-plane-join-cfg")
 
 	testcases := []struct {
@@ -284,7 +284,7 @@ func TestKubeadmConfigReconciler_Reconcile_GenerateCloudConfigData(t *testing.T)
 	cluster := newCluster("cluster")
 	cluster.Status.InfrastructureReady = true
 
-	controlPlaneMachine := newControlPlaneMachine(cluster)
+	controlPlaneMachine := newControlPlaneMachine(cluster, "control-plane-machine")
 	controlPlaneInitConfig := newControlPlaneInitKubeadmConfig(controlPlaneMachine, "control-plane-init-cfg")
 
 	objects := []runtime.Object{
@@ -313,10 +313,10 @@ func TestKubeadmConfigReconciler_Reconcile_GenerateCloudConfigData(t *testing.T)
 		t.Fatalf("Failed to reconcile:\n %+v", err)
 	}
 	if result.Requeue != false {
-		t.Fatal("did not expected to requeue")
+		t.Fatal("did not expect to requeue")
 	}
 	if result.RequeueAfter != time.Duration(0) {
-		t.Fatal("did not expected to requeue after")
+		t.Fatal("did not expect to requeue after")
 	}
 
 	cfg, err := getKubeadmConfig(myclient, "control-plane-init-cfg")
@@ -382,7 +382,7 @@ func TestKubeadmConfigReconciler_Reconcile_ErrorIfJoiningControlPlaneHasInvalidC
 	cluster.Status.ControlPlaneInitialized = true
 	cluster.Status.APIEndpoints = []clusterv1.APIEndpoint{{Host: "100.105.150.1", Port: 6443}}
 
-	controlPlaneMachine := newControlPlaneMachine(cluster)
+	controlPlaneMachine := newControlPlaneMachine(cluster, "control-plane-machine")
 	controlPlaneJoinConfig := newControlPlaneJoinKubeadmConfig(controlPlaneMachine, "control-plane-join-cfg")
 	controlPlaneJoinConfig.Spec.JoinConfiguration.ControlPlane = nil // Makes controlPlaneJoinConfig invalid for a control plane machine
 
@@ -442,10 +442,10 @@ func TestKubeadmConfigReconciler_Reconcile_RequeueIfControlPlaneIsMissingAPIEndp
 	}
 	result, err := k.Reconcile(request)
 	if err != nil {
-		t.Fatal(fmt.Sprintf("Failed to reconcile:\n %+v", err))
+		t.Fatalf("Failed to reconcile:\n %+v", err)
 	}
 	if result.Requeue == true {
-		t.Fatal("did not expected to requeue")
+		t.Fatal("did not expect to requeue")
 	}
 	if result.RequeueAfter != 10*time.Second {
 		t.Fatal("expected to requeue after 10s")
@@ -461,7 +461,7 @@ func TestReconcileIfJoinNodesAndControlPlaneIsReady(t *testing.T) {
 	workerMachine := newWorkerMachine(cluster)
 	workerJoinConfig := newWorkerJoinKubeadmConfig(workerMachine)
 
-	controlPlaneMachine := newControlPlaneMachine(cluster)
+	controlPlaneMachine := newControlPlaneMachine(cluster, "control-plane-machine")
 	controlPlaneJoinConfig := newControlPlaneJoinKubeadmConfig(controlPlaneMachine, "control-plane-join-cfg")
 
 	objects := []runtime.Object{
@@ -488,18 +488,18 @@ func TestReconcileIfJoinNodesAndControlPlaneIsReady(t *testing.T) {
 	}
 	result, err := k.Reconcile(request)
 	if err != nil {
-		t.Fatal(fmt.Sprintf("Failed to reconcile:\n %+v", err))
+		t.Fatalf("Failed to reconcile:\n %+v", err)
 	}
 	if result.Requeue == true {
-		t.Fatal("did not expected to requeue")
+		t.Fatal("did not expect to requeue")
 	}
 	if result.RequeueAfter != time.Duration(0) {
-		t.Fatal("did not expected to requeue after")
+		t.Fatal("did not expect to requeue after")
 	}
 
 	cfg, err := getKubeadmConfig(myclient, "worker-join-cfg")
 	if err != nil {
-		t.Fatal(fmt.Sprintf("Failed to reconcile:\n %+v", err))
+		t.Fatalf("Failed to reconcile:\n %+v", err)
 	}
 
 	if cfg.Status.Ready != true {
@@ -518,18 +518,18 @@ func TestReconcileIfJoinNodesAndControlPlaneIsReady(t *testing.T) {
 	}
 	result, err = k.Reconcile(request)
 	if err != nil {
-		t.Fatal(fmt.Sprintf("Failed to reconcile:\n %+v", err))
+		t.Fatalf("Failed to reconcile:\n %+v", err)
 	}
 	if result.Requeue == true {
-		t.Fatal("did not expected to requeue")
+		t.Fatal("did not expect to requeue")
 	}
 	if result.RequeueAfter != time.Duration(0) {
-		t.Fatal("did not expected to requeue after")
+		t.Fatal("did not expect to requeue after")
 	}
 
 	cfg, err = getKubeadmConfig(myclient, "control-plane-join-cfg")
 	if err != nil {
-		t.Fatal(fmt.Sprintf("Failed to reconcile:\n %+v", err))
+		t.Fatalf("Failed to reconcile:\n %+v", err)
 	}
 
 	if cfg.Status.Ready != true {
@@ -543,11 +543,11 @@ func TestReconcileIfJoinNodesAndControlPlaneIsReady(t *testing.T) {
 	myremoteclient, _ := k.SecretsClientFactory.NewSecretsClient(nil, nil)
 	l, err := myremoteclient.List(metav1.ListOptions{})
 	if err != nil {
-		t.Fatal(fmt.Sprintf("Failed to reconcile:\n %+v", err))
+		t.Fatalf("Failed to reconcile:\n %+v", err)
 	}
 
 	if len(l.Items) != 2 {
-		t.Fatal(fmt.Sprintf("Failed to reconcile:\n %+v", err))
+		t.Fatalf("Failed to reconcile:\n %+v", err)
 	}
 }
 
@@ -968,6 +968,67 @@ func TestKubeadmConfigReconciler_ClusterToKubeadmConfigs(t *testing.T) {
 	}
 }
 
+// Exactly one control plane machine initializes if there are multiple control plane machines defined
+func TestKubeadmConfigReconciler_Reconcile_ExactlyOneControlPlaneMachineInitializes(t *testing.T) {
+	cluster := newCluster("cluster")
+	cluster.Status.InfrastructureReady = true
+
+	controlPlaneInitMachineFirst := newControlPlaneMachine(cluster, "control-plane-init-machine-first")
+	controlPlaneInitConfigFirst := newControlPlaneInitKubeadmConfig(controlPlaneInitMachineFirst, "control-plane-init-cfg-first")
+
+	controlPlaneInitMachineSecond := newControlPlaneMachine(cluster, "control-plane-init-machine-second")
+	controlPlaneInitConfigSecond := newControlPlaneInitKubeadmConfig(controlPlaneInitMachineSecond, "control-plane-init-cfg-second")
+
+	objects := []runtime.Object{
+		cluster,
+		controlPlaneInitMachineFirst,
+		controlPlaneInitConfigFirst,
+		controlPlaneInitMachineSecond,
+		controlPlaneInitConfigSecond,
+	}
+	myclient := fake.NewFakeClientWithScheme(setupScheme(), objects...)
+	k := &KubeadmConfigReconciler{
+		Log:                  log.Log,
+		Client:               myclient,
+		SecretsClientFactory: newFakeSecretFactory(),
+		KubeadmInitLock:      &myInitLocker{},
+	}
+
+	request := ctrl.Request{
+		NamespacedName: types.NamespacedName{
+			Namespace: "default",
+			Name:      "control-plane-init-cfg-first",
+		},
+	}
+	result, err := k.Reconcile(request)
+	if err != nil {
+		t.Fatalf("Failed to reconcile:\n %+v", err)
+	}
+	if result.Requeue == true {
+		t.Fatal("did not expect to requeue")
+	}
+	if result.RequeueAfter != time.Duration(0) {
+		t.Fatal("did not expect to requeue after")
+	}
+
+	request = ctrl.Request{
+		NamespacedName: types.NamespacedName{
+			Namespace: "default",
+			Name:      "control-plane-init-cfg-second",
+		},
+	}
+	result, err = k.Reconcile(request)
+	if err != nil {
+		t.Fatalf("Failed to reconcile:\n %+v", err)
+	}
+	if result.Requeue == true {
+		t.Fatal("did not expect to requeue")
+	}
+	if result.RequeueAfter != 30*time.Second {
+		t.Fatal("expected to requeue after 30s")
+	}
+}
+
 // test utils
 
 // newCluster return a CAPI cluster object
@@ -1016,8 +1077,8 @@ func newWorkerMachine(cluster *clusterv1.Cluster) *clusterv1.Machine {
 	return newMachine(cluster, "worker-machine") // machine by default is a worker node (not the bootstrapNode)
 }
 
-func newControlPlaneMachine(cluster *clusterv1.Cluster) *clusterv1.Machine {
-	m := newMachine(cluster, "control-plane-machine")
+func newControlPlaneMachine(cluster *clusterv1.Cluster, name string) *clusterv1.Machine {
+	m := newMachine(cluster, name)
 	m.Labels[clusterv1.MachineControlPlaneLabelName] = "true"
 	return m
 }
@@ -1104,9 +1165,21 @@ func (f FakeSecretFactory) NewSecretsClient(client client.Client, cluster *clust
 	return f.client, nil
 }
 
-type myInitLocker struct{}
+type myInitLocker struct {
+	locked bool
+}
 
 func (m *myInitLocker) Lock(_ context.Context, _ *clusterv1.Cluster, _ *clusterv1.Machine) bool {
+	if !m.locked {
+		m.locked = true
+		return true
+	}
+	return false
+}
+
+func (m *myInitLocker) Unlock(_ context.Context, _ *clusterv1.Cluster) bool {
+	if m.locked {
+		m.locked = false
+	}
 	return true
 }
-func (m *myInitLocker) Unlock(_ context.Context, _ *clusterv1.Cluster) bool { return true }