Merge pull request #1615 from NeerajNagure/NeerajNagure/unit-test-coverage-improvement-#1574

🌱Added unit tests for baremetalHostTypes and bmceventSubscriptionController

Author: metal3-io-bot

apis/metal3.io/v1alpha1/baremetalhost_types_test.go

@@ -510,3 +510,159 @@ func TestBootMode(t *testing.T) {
 		})
 	}
 }
+
+func TestSetOperationalStatus(t *testing.T) {
+	for _, tc := range []struct {
+		Scenario  string
+		Host      BareMetalHost
+		StatusArg OperationalStatus
+		Expected  bool
+	}{
+		{
+			Scenario: "Host is partially configured and operationalStatus is ok",
+			Host: BareMetalHost{
+				Status: BareMetalHostStatus{
+					OperationalStatus: "OK",
+				},
+			},
+			StatusArg: "discovered",
+			Expected:  true,
+		},
+		{
+			Scenario: "Host is detached and operationalStatus is also detached",
+			Host: BareMetalHost{
+				Status: BareMetalHostStatus{
+					OperationalStatus: "detached",
+				},
+			},
+			StatusArg: "detached",
+			Expected:  false,
+		},
+		{
+			Scenario: "Host has an error and operationalStatus also has an error",
+			Host: BareMetalHost{
+				Status: BareMetalHostStatus{
+					OperationalStatus: "error",
+				},
+			},
+			StatusArg: "error",
+			Expected:  false,
+		},
+		{
+			Scenario: "Host is delayed and operationalStatus is not defined",
+			Host: BareMetalHost{
+				Status: BareMetalHostStatus{},
+			},
+			StatusArg: "delayed",
+			Expected:  true,
+		},
+	} {
+		t.Run(tc.Scenario, func(t *testing.T) {
+			actual := tc.Host.SetOperationalStatus(tc.StatusArg)
+			if tc.Expected && !actual {
+				t.Error("Expected a change in operational status")
+			}
+			if !tc.Expected && actual {
+				t.Error("Did not expect a change in operational status")
+			}
+		})
+	}
+}
+
+func TestSetHardwareProfile(t *testing.T) {
+	for _, tc := range []struct {
+		Scenario string
+		Host     BareMetalHost
+		name     string
+		Expected bool
+	}{
+		{
+			Scenario: "Host hardware profile and name is same",
+			Host: BareMetalHost{
+				Status: BareMetalHostStatus{
+					HardwareProfile: "test",
+				},
+			},
+			name:     "test",
+			Expected: false,
+		},
+		{
+			Scenario: "Host hardware profile and name are different",
+			Host: BareMetalHost{
+				Status: BareMetalHostStatus{
+					HardwareProfile: "test",
+				},
+			},
+			name:     "newtest",
+			Expected: true,
+		},
+		{
+			Scenario: "Host hardware profile is not defined",
+			Host: BareMetalHost{
+				Status: BareMetalHostStatus{},
+			},
+			name:     "test",
+			Expected: true,
+		},
+	} {
+		t.Run(tc.Scenario, func(t *testing.T) {
+			actual := tc.Host.SetHardwareProfile(tc.name)
+			if tc.Expected && !actual {
+				t.Error("Expected a change in hardware profile")
+			}
+			if !tc.Expected && actual {
+				t.Error("Did not expect a change in hardware profile")
+			}
+		})
+	}
+}
+
+func TestHasBMCDetails(t *testing.T) {
+	for _, tc := range []struct {
+		Scenario string
+		Host     BareMetalHost
+		Expected bool
+	}{
+		{
+			Scenario: "Only host bmc address is set",
+			Host: BareMetalHost{
+				Spec: BareMetalHostSpec{
+					BMC: BMCDetails{
+						Address: "http://127.0.0.1/",
+					},
+				},
+			},
+			Expected: true,
+		},
+		{
+			Scenario: "Only host credentialsName is set",
+			Host: BareMetalHost{
+				Spec: BareMetalHostSpec{
+					BMC: BMCDetails{
+						CredentialsName: "test",
+					},
+				},
+			},
+			Expected: true,
+		},
+		{
+			Scenario: "Neither host credentialsName nor address is set",
+			Host: BareMetalHost{
+				Spec: BareMetalHostSpec{
+					BMC: BMCDetails{},
+				},
+			},
+			Expected: false,
+		},
+	} {
+		t.Run(tc.Scenario, func(t *testing.T) {
+			actual := tc.Host.HasBMCDetails()
+			if tc.Expected && !actual {
+				t.Error("Expected BMC details exist")
+			}
+			if !tc.Expected && actual {
+				t.Error("Did not expect that BMC details exist")
+			}
+		})
+	}
+}

controllers/metal3.io/bmceventsubscription_controller_test.go

@@ -0,0 +1,142 @@
+package controllers
+
+import (
+	"context"
+	"testing"
+
+	corev1 "k8s.io/api/core/v1"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/types"
+
+	ctrl "sigs.k8s.io/controller-runtime"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+	fakeclient "sigs.k8s.io/controller-runtime/pkg/client/fake"
+	"sigs.k8s.io/controller-runtime/pkg/reconcile"
+
+	metal3api "github.com/metal3-io/baremetal-operator/apis/metal3.io/v1alpha1"
+	"github.com/metal3-io/baremetal-operator/pkg/provisioner/fixture"
+	"github.com/metal3-io/baremetal-operator/pkg/utils"
+)
+
+func newBMCTestReconcilerWithFixture(fix *fixture.Fixture, initObjs ...runtime.Object) *BMCEventSubscriptionReconciler {
+	clientBuilder := fakeclient.NewClientBuilder().WithRuntimeObjects(initObjs...)
+	for _, v := range initObjs {
+		clientBuilder = clientBuilder.WithStatusSubresource(v.(client.Object))
+	}
+	c := clientBuilder.Build()
+	// Add a default secret that can be used by most subscriptions.
+	bmcSecret := newBMCCredsSecret(defaultSecretName, "User", "Pass")
+	c.Create(context.TODO(), bmcSecret)
+
+	return &BMCEventSubscriptionReconciler{
+		Client:             c,
+		ProvisionerFactory: fix,
+		Log:                ctrl.Log.WithName("controllers").WithName("BMCEventSubscription"),
+		APIReader:          c,
+	}
+}
+
+type BMCDoneFunc func(subscription *metal3api.BMCEventSubscription, result reconcile.Result) bool
+
+func newBMCTestReconciler(initObjs ...runtime.Object) *BMCEventSubscriptionReconciler {
+	fix := fixture.Fixture{}
+	return newBMCTestReconcilerWithFixture(&fix, initObjs...)
+}
+
+func newBMCRequest(subscription *metal3api.BMCEventSubscription) ctrl.Request {
+	namespacedName := types.NamespacedName{
+		Namespace: subscription.ObjectMeta.Namespace,
+		Name:      subscription.ObjectMeta.Name,
+	}
+	return ctrl.Request{NamespacedName: namespacedName}
+}
+
+func newSubscription(name string, spec *metal3api.BMCEventSubscriptionSpec) *metal3api.BMCEventSubscription {
+	return &metal3api.BMCEventSubscription{
+		TypeMeta: metav1.TypeMeta{
+			Kind:       "BareMetalHost",
+			APIVersion: "metal3.io/v1alpha1",
+		}, ObjectMeta: metav1.ObjectMeta{
+			Name:      name,
+			Namespace: namespace,
+		},
+		Spec: *spec,
+	}
+}
+
+func newDefaultNamedSubscription(t *testing.T, name string) *metal3api.BMCEventSubscription {
+	t.Helper()
+	spec := &metal3api.BMCEventSubscriptionSpec{
+		HostName:    t.Name(),
+		Destination: "user destination",
+		Context:     "user context",
+		HTTPHeadersRef: &corev1.SecretReference{
+			Name:      defaultSecretName,
+			Namespace: namespace,
+		},
+	}
+	t.Logf("newNamedSubscription(%s)", name)
+	subscription := newSubscription(name, spec)
+	return subscription
+}
+
+func newDefaultSubscription(t *testing.T) *metal3api.BMCEventSubscription {
+	t.Helper()
+	return newDefaultNamedSubscription(t, t.Name())
+}
+
+func HostWithProvisioningID(t *testing.T, host *metal3api.BareMetalHost) *metal3api.BareMetalHost {
+	t.Helper()
+	host.Status.Provisioning.ID = "made-up-id"
+	return host
+}
+
+func TestBMCAddFinalizers(t *testing.T) {
+	host := newDefaultHost(t)
+	subscription := newDefaultSubscription(t)
+	r := newBMCTestReconciler(subscription, host)
+	err := r.addFinalizer(context.Background(), subscription)
+	if err != nil {
+		t.Error(err)
+	}
+	t.Logf("subscription finalizers: %v", subscription.Finalizers)
+	if !utils.StringInList(subscription.Finalizers, metal3api.BMCEventSubscriptionFinalizer) {
+		t.Error("Expected finalizers to be added")
+	}
+}
+
+func TestBMCGetProvisioner(t *testing.T) {
+	host := newDefaultHost(t)
+	subscription := newDefaultSubscription(t)
+	request := newBMCRequest(subscription)
+	r := newBMCTestReconciler(subscription, host)
+	for _, tc := range []struct {
+		Scenario string
+		Host     *metal3api.BareMetalHost
+		Expected bool
+	}{
+		{
+			Scenario: "No provisioning id is provided",
+			Host:     host,
+			Expected: true,
+		},
+		{
+			Scenario: "Provisioning id is provided",
+			Host:     HostWithProvisioningID(t, host),
+			Expected: true,
+		},
+	} {
+		t.Run(tc.Scenario, func(t *testing.T) {
+			prov, actual, err := r.getProvisioner(context.Background(), request, tc.Host)
+			if err != nil {
+				t.Error(err)
+			}
+			t.Log("Provisioner Details:", prov)
+			if tc.Expected && !actual {
+				t.Error("Expected a ready provisioner")
+			}
+		})
+	}
+}