Merge pull request #125 from pnguyen44/HYPERFLEET-841/validate-condition-status

HYPERFLEET-841 - fix: filter invalid condition status from GET responses

Author: openshift-merge-bot[bot]

pkg/api/presenters/adapter_status.go

@@ -82,16 +82,20 @@ func PresentAdapterStatus(adapterStatus *api.AdapterStatus) (openapi.AdapterStat
 		}
 	}
 
-	// Convert domain AdapterConditions to openapi format
-	openapiConditions := make([]openapi.AdapterCondition, len(conditions))
-	for i, cond := range conditions {
-		openapiConditions[i] = openapi.AdapterCondition{
+	// Convert domain AdapterConditions to openapi format, filtering out
+	// conditions with empty/invalid status (legacy data before validation was added).
+	openapiConditions := make([]openapi.AdapterCondition, 0, len(conditions))
+	for _, cond := range conditions {
+		if !cond.Status.IsValid() {
+			continue
+		}
+		openapiConditions = append(openapiConditions, openapi.AdapterCondition{
 			Type:               cond.Type,
 			Status:             openapi.AdapterConditionStatus(cond.Status),
 			Reason:             cond.Reason,
 			Message:            cond.Message,
 			LastTransitionTime: cond.LastTransitionTime,
-		}
+		})
 	}
 
 	// Unmarshal Data

pkg/api/presenters/adapter_status_test.go

@@ -457,6 +457,48 @@ func TestConvertAndPresent_RoundTrip(t *testing.T) {
 	Expect(*result.Metadata.JobName).To(Equal(*originalReq.Metadata.JobName))
 }
 
+// TestPresentAdapterStatus_FiltersInvalidConditionStatus verifies that conditions with
+// empty or invalid status values (legacy data) are excluded from GET responses.
+func TestPresentAdapterStatus_FiltersInvalidConditionStatus(t *testing.T) {
+	RegisterTestingT(t)
+
+	now := time.Now()
+	reason := "Healthy"
+	message := "All good"
+
+	conditions := []api.AdapterCondition{
+		// Valid — should be kept
+		{Type: "Health", Status: api.AdapterConditionTrue, Reason: &reason, Message: &message, LastTransitionTime: now},
+		{Type: "Available", Status: api.AdapterConditionFalse, LastTransitionTime: now},
+		{Type: "Ready", Status: api.AdapterConditionUnknown, LastTransitionTime: now},
+
+		// Invalid — should be filtered out (legacy data)
+		{Type: "Applied", Status: "", LastTransitionTime: now},
+		{Type: "Reconciled", Status: "garbage", LastTransitionTime: now},
+	}
+	conditionsJSON, _ := json.Marshal(conditions)
+
+	adapterStatus := &api.AdapterStatus{
+		ResourceType:       "Cluster",
+		ResourceID:         "cluster-legacy",
+		Adapter:            "test-adapter",
+		ObservedGeneration: 1,
+		Conditions:         conditionsJSON,
+		Data:               []byte("{}"),
+		CreatedTime:        now,
+		LastReportTime:     now,
+	}
+
+	result, err := PresentAdapterStatus(adapterStatus)
+	Expect(err).To(BeNil())
+
+	Expect(result.Conditions).To(HaveLen(3))
+	for _, cond := range result.Conditions {
+		Expect(cond.Type).ToNot(Equal("Applied"))
+		Expect(cond.Type).ToNot(Equal("Reconciled"))
+	}
+}
+
 // TestPresentAdapterStatus_MalformedConditions tests error handling for malformed Conditions JSON
 func TestPresentAdapterStatus_MalformedConditions(t *testing.T) {
 	RegisterTestingT(t)

pkg/api/status_types.go

@@ -21,6 +21,11 @@ const (
 	AdapterConditionUnknown AdapterConditionStatus = "Unknown"
 )
 
+// IsValid returns true if the status is one of the accepted enum values (True, False, Unknown).
+func (s AdapterConditionStatus) IsValid() bool {
+	return s == AdapterConditionTrue || s == AdapterConditionFalse || s == AdapterConditionUnknown
+}
+
 // Condition type constants
 const (
 	ConditionTypeAvailable  = "Available"

pkg/api/status_types_test.go

@@ -33,6 +33,19 @@ func TestAdapterConditionStatus_Constants(t *testing.T) {
 	// which has "True", "False", and "Unknown" values
 }
 
+// TestAdapterConditionStatus_IsValid verifies that IsValid accepts valid statuses and rejects invalid ones
+func TestAdapterConditionStatus_IsValid(t *testing.T) {
+	RegisterTestingT(t)
+
+	Expect(AdapterConditionTrue.IsValid()).To(BeTrue())
+	Expect(AdapterConditionFalse.IsValid()).To(BeTrue())
+	Expect(AdapterConditionUnknown.IsValid()).To(BeTrue())
+
+	Expect(AdapterConditionStatus("").IsValid()).To(BeFalse())
+	Expect(AdapterConditionStatus("garbage").IsValid()).To(BeFalse())
+	Expect(AdapterConditionStatus("true").IsValid()).To(BeFalse())
+}
+
 // TestAdapterConditionStatus_StringConversion tests type casting to/from string
 func TestAdapterConditionStatus_StringConversion(t *testing.T) {
 	RegisterTestingT(t)