bmh: add wait until annotation exists and tests (rh-ecosystem-edge#588)

This adds a method to wait until an annotation exists on the BMH along with unit tests for it.

Author: klaskosk

pkg/bmh/baremetalhost.go

@@ -649,6 +649,51 @@ func (builder *BmhBuilder) WaitUntilDeleted(timeout time.Duration) error {
 	return err
 }
 
+// WaitUntilAnnotationExists waits up to the specified timeout until the annotation exists.
+func (builder *BmhBuilder) WaitUntilAnnotationExists(annotation string, timeout time.Duration) (*BmhBuilder, error) {
+	if valid, err := builder.validate(); !valid {
+		return nil, err
+	}
+
+	if annotation == "" {
+		glog.V(100).Info("BMH annotation key cannot be empty")
+
+		return nil, fmt.Errorf("bmh annotation key cannot be empty")
+	}
+
+	glog.V(100).Infof(
+		"Waiting until BMH %s in namespace %s has annotation %s",
+		builder.Definition.Name, builder.Definition.Namespace, annotation)
+
+	if !builder.Exists() {
+		return nil, fmt.Errorf(
+			"baremetalhost object %s does not exist in namespace %s", builder.Definition.Name, builder.Definition.Namespace)
+	}
+
+	var err error
+	err = wait.PollUntilContextTimeout(
+		context.TODO(), time.Second, timeout, true, func(ctx context.Context) (bool, error) {
+			builder.Object, err = builder.Get()
+			if err != nil {
+				glog.V(100).Infof("failed to get bmh %s/%s: %v", builder.Definition.Namespace, builder.Definition.Name, err)
+
+				return false, nil
+			}
+
+			if _, ok := builder.Object.Annotations[annotation]; !ok {
+				return false, nil
+			}
+
+			return true, nil
+		})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return builder, nil
+}
+
 // validate will check that the builder and builder definition are properly initialized before
 // accessing any member fields.
 func (builder *BmhBuilder) validate() (bool, error) {

pkg/bmh/baremetalhost_test.go

@@ -20,6 +20,7 @@ var (
 	defaultBmHostSecretName = "testsecret"
 	defaultBmHostMacAddress = "AA:BB:CC:11:22:33"
 	defaultBmHostBootMode   = "UEFISecureBoot"
+	defaultBmHostAnnotation = "annotation.openshift.io/test-annotation"
 	testSchemes             = []clients.SchemeAttacher{
 		bmhv1alpha1.AddToScheme,
 	}
@@ -966,6 +967,86 @@ func TestBareMetalHostDeleteAndWaitUntilDeleted(t *testing.T) {
 	}
 }
 
+func TestBareMetalHostWaitUntilAnnotationExists(t *testing.T) {
+	testCases := []struct {
+		annotation    string
+		exists        bool
+		valid         bool
+		annotated     bool
+		expectedError error
+	}{
+		{
+			annotation:    defaultBmHostAnnotation,
+			exists:        true,
+			valid:         true,
+			annotated:     true,
+			expectedError: nil,
+		},
+		{
+			annotation:    "",
+			exists:        true,
+			valid:         true,
+			annotated:     true,
+			expectedError: fmt.Errorf("bmh annotation key cannot be empty"),
+		},
+		{
+			annotation: defaultBmHostAnnotation,
+			exists:     false,
+			valid:      true,
+			annotated:  true,
+			expectedError: fmt.Errorf(
+				"baremetalhost object %s does not exist in namespace %s", defaultBmHostName, defaultBmHostNsName),
+		},
+		{
+			annotation:    defaultBmHostAnnotation,
+			exists:        true,
+			valid:         false,
+			annotated:     true,
+			expectedError: fmt.Errorf("not acceptable 'bootMode' value"),
+		},
+		{
+			annotation:    defaultBmHostAnnotation,
+			exists:        true,
+			valid:         true,
+			annotated:     false,
+			expectedError: context.DeadlineExceeded,
+		},
+	}
+
+	for _, testCase := range testCases {
+		var (
+			runtimeObjects []runtime.Object
+			builder        *BmhBuilder
+		)
+
+		if testCase.exists {
+			bmh := buildDummyBmHost(bmhv1alpha1.StateProvisioned, bmhv1alpha1.OperationalStatusOK)
+
+			if testCase.annotated {
+				bmh.Annotations = map[string]string{
+					defaultBmHostAnnotation: "",
+				}
+			}
+
+			runtimeObjects = append(runtimeObjects, bmh)
+		}
+
+		testSettings := clients.GetTestClients(clients.TestClientParams{
+			K8sMockObjects:  runtimeObjects,
+			SchemeAttachers: testSchemes,
+		})
+
+		if testCase.valid {
+			builder = buildValidBmHostBuilder(testSettings)
+		} else {
+			builder = buildInValidBmHostBuilder(testSettings)
+		}
+
+		_, err := builder.WaitUntilAnnotationExists(testCase.annotation, time.Second)
+		assert.Equal(t, testCase.expectedError, err)
+	}
+}
+
 func TestBareMetalHostWaitUntilDeleted(t *testing.T) {
 	testCases := []struct {
 		testBmHost    *BmhBuilder
@@ -1026,19 +1107,14 @@ func buildBareMetalHostTestClientWithDummyObject(state ...bmhv1alpha1.Provisioni
 	}
 
 	return clients.GetTestClients(clients.TestClientParams{
-		K8sMockObjects:  buildDummyBmHost(provisionState),
+		K8sMockObjects:  buildDummyBmHostObject(provisionState),
 		SchemeAttachers: testSchemes,
 	})
 }
 
 func buildDummyBmHost(
-	state bmhv1alpha1.ProvisioningState, operationalStatus ...bmhv1alpha1.OperationalStatus) []runtime.Object {
-	operState := bmhv1alpha1.OperationalStatusOK
-	if len(operationalStatus) > 0 {
-		operState = operationalStatus[0]
-	}
-
-	return append([]runtime.Object{}, &bmhv1alpha1.BareMetalHost{
+	state bmhv1alpha1.ProvisioningState, operState bmhv1alpha1.OperationalStatus) *bmhv1alpha1.BareMetalHost {
+	return &bmhv1alpha1.BareMetalHost{
 		Spec: bmhv1alpha1.BareMetalHostSpec{
 			BMC: bmhv1alpha1.BMCDetails{
 				Address:                        defaultBmHostAddress,
@@ -1061,5 +1137,15 @@ func buildDummyBmHost(
 				State: state,
 			},
 		},
-	})
+	}
+}
+
+func buildDummyBmHostObject(
+	state bmhv1alpha1.ProvisioningState, operationalStatus ...bmhv1alpha1.OperationalStatus) []runtime.Object {
+	operState := bmhv1alpha1.OperationalStatusOK
+	if len(operationalStatus) > 0 {
+		operState = operationalStatus[0]
+	}
+
+	return append([]runtime.Object{}, buildDummyBmHost(state, operState))
 }

pkg/bmh/list_test.go

@@ -60,7 +60,7 @@ func TestBareMetalHostList(t *testing.T) {
 
 		if testCase.client {
 			testSettings = clients.GetTestClients(clients.TestClientParams{
-				K8sMockObjects:  buildDummyBmHost(bmhv1alpha1.StateProvisioned),
+				K8sMockObjects:  buildDummyBmHostObject(bmhv1alpha1.StateProvisioned),
 				SchemeAttachers: testSchemes,
 			})
 		}
@@ -194,7 +194,7 @@ func TestBareMetalWaitForAllBareMetalHostsInGoodOperationalState(t *testing.T) {
 
 		if testCase.client {
 			testSettings = clients.GetTestClients(clients.TestClientParams{
-				K8sMockObjects:  buildDummyBmHost(bmhv1alpha1.StateProvisioned, testCase.operationalState),
+				K8sMockObjects:  buildDummyBmHostObject(bmhv1alpha1.StateProvisioned, testCase.operationalState),
 				SchemeAttachers: testSchemes,
 			})
 		}