add StatusUpdater

Author: Diaphteiros

pkg/conditions/updater.go

@@ -11,11 +11,11 @@ import (
 // conditionUpdater is a helper struct for updating a list of Conditions.
 // Use the ConditionUpdater constructor for initializing.
 type conditionUpdater[T comparable] struct {
-	Now         time.Time
-	conditions  map[string]Condition[T]
-	updated     sets.Set[string]
-	constructor func() Condition[T]
-	changed     bool
+	Now        time.Time
+	conditions map[string]Condition[T]
+	updated    sets.Set[string]
+	construct  func() Condition[T]
+	changed    bool
 }
 
 // ConditionUpdater creates a builder-like helper struct for updating a list of Conditions.
@@ -30,12 +30,12 @@ type conditionUpdater[T comparable] struct {
 //
 // Usage example:
 // status.conditions = ConditionUpdater(status.conditions, true).UpdateCondition(...).UpdateCondition(...).Conditions()
-func ConditionUpdater[T comparable](constructor func() Condition[T], conditions []Condition[T], removeUntouched bool) *conditionUpdater[T] {
+func ConditionUpdater[T comparable](construct func() Condition[T], conditions []Condition[T], removeUntouched bool) *conditionUpdater[T] {
 	res := &conditionUpdater[T]{
-		Now:         time.Now(),
-		conditions:  make(map[string]Condition[T], len(conditions)),
-		constructor: constructor,
-		changed:     false,
+		Now:        time.Now(),
+		conditions: make(map[string]Condition[T], len(conditions)),
+		construct:  construct,
+		changed:    false,
 	}
 	for _, con := range conditions {
 		res.conditions[con.GetType()] = con
@@ -50,7 +50,7 @@ func ConditionUpdater[T comparable](constructor func() Condition[T], conditions
 // All fields of the condition are updated with the values given in the arguments, but the condition's LastTransitionTime is only updated (with the timestamp contained in the receiver struct) if the status changed.
 // Returns the receiver for easy chaining.
 func (c *conditionUpdater[T]) UpdateCondition(conType string, status T, reason, message string) *conditionUpdater[T] {
-	con := c.constructor()
+	con := c.construct()
 	con.SetType(conType)
 	con.SetStatus(status)
 	con.SetReason(reason)
@@ -103,6 +103,7 @@ func (c *conditionUpdater[T]) RemoveCondition(conType string) *conditionUpdater[
 // If the condition updater was initialized with removeUntouched=true, this list will only contain the conditions which have been updated
 // in between the condition updater creation and this method call. Otherwise, it will potentially also contain old conditions.
 // The conditions are returned sorted by their type.
+// The second return value indicates whether the condition list has actually changed.
 func (c *conditionUpdater[T]) Conditions() ([]Condition[T], bool) {
 	res := make([]Condition[T], 0, len(c.conditions))
 	for _, con := range c.conditions {

pkg/conditions/updater_test.go

@@ -7,76 +7,17 @@ import (
 
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
+	. "github.com/openmcp-project/controller-utils/pkg/testing/matchers"
 
 	"github.com/openmcp-project/controller-utils/pkg/conditions"
 )
 
-type conImpl struct {
-	status             bool
-	conType            string
-	reason             string
-	message            string
-	lastTransitionTime time.Time
-}
-
-func newConImplWithValues(conType string, status bool, reason, message string, lastTransitionTime time.Time) *conImpl {
-	return &conImpl{
-		conType:            conType,
-		status:             status,
-		reason:             reason,
-		message:            message,
-		lastTransitionTime: lastTransitionTime,
-	}
-}
-
-var _ conditions.Condition[bool] = &conImpl{}
-
-func (c *conImpl) GetLastTransitionTime() time.Time {
-	return c.lastTransitionTime
-}
-
-func (c *conImpl) GetType() string {
-	return c.conType
-}
-
-func (c *conImpl) GetStatus() bool {
-	return c.status
-}
-
-func (c *conImpl) GetReason() string {
-	return c.reason
-}
-
-func (c *conImpl) GetMessage() string {
-	return c.message
-}
-
-func (c *conImpl) SetStatus(status bool) {
-	c.status = status
-}
-
-func (c *conImpl) SetType(conType string) {
-	c.conType = conType
-}
-
-func (c *conImpl) SetLastTransitionTime(timestamp time.Time) {
-	c.lastTransitionTime = timestamp
-}
-
-func (c *conImpl) SetReason(reason string) {
-	c.reason = reason
-}
-
-func (c *conImpl) SetMessage(message string) {
-	c.message = message
-}
-
 func testConditionSet() []conditions.Condition[bool] {
 	now := time.Now().Add((-24) * time.Hour)
 	return []conditions.Condition[bool]{
-		newConImplWithValues("true", true, "reason", "message", now),
-		newConImplWithValues("false", false, "reason", "message", now),
-		newConImplWithValues("alsoTrue", true, "alsoReason", "alsoMessage", now),
+		NewConditionImplFromValues("true", true, "reason", "message", now),
+		NewConditionImplFromValues("false", false, "reason", "message", now),
+		NewConditionImplFromValues("alsoTrue", true, "alsoReason", "alsoMessage", now),
 	}
 }
 
@@ -134,7 +75,7 @@ var _ = Describe("Conditions", func() {
 		It("should update the condition (same value, keep other cons)", func() {
 			cons := testConditionSet()
 			oldCon := conditions.GetCondition(cons, "true")
-			updated, changed := conditions.ConditionUpdater(func() conditions.Condition[bool] { return &conImpl{} }, cons, false).UpdateCondition(oldCon.GetType(), oldCon.GetStatus(), "newReason", "newMessage").Conditions()
+			updated, changed := conditions.ConditionUpdater(NewCondition[bool], cons, false).UpdateCondition(oldCon.GetType(), oldCon.GetStatus(), "newReason", "newMessage").Conditions()
 			Expect(changed).To(BeTrue())
 			newCon := conditions.GetCondition(updated, "true")
 			Expect(updated).To(HaveLen(len(cons)))
@@ -151,7 +92,7 @@ var _ = Describe("Conditions", func() {
 		It("should update the condition (different value, keep other cons)", func() {
 			cons := testConditionSet()
 			oldCon := conditions.GetCondition(cons, "true")
-			updated, changed := conditions.ConditionUpdater(func() conditions.Condition[bool] { return &conImpl{} }, cons, false).UpdateCondition(oldCon.GetType(), !oldCon.GetStatus(), "newReason", "newMessage").Conditions()
+			updated, changed := conditions.ConditionUpdater(NewCondition[bool], cons, false).UpdateCondition(oldCon.GetType(), !oldCon.GetStatus(), "newReason", "newMessage").Conditions()
 			Expect(changed).To(BeTrue())
 			newCon := conditions.GetCondition(updated, "true")
 			Expect(updated).To(HaveLen(len(cons)))
@@ -169,7 +110,7 @@ var _ = Describe("Conditions", func() {
 		It("should update the condition (same value, discard other cons)", func() {
 			cons := testConditionSet()
 			oldCon := conditions.GetCondition(cons, "true")
-			updated, changed := conditions.ConditionUpdater(func() conditions.Condition[bool] { return &conImpl{} }, cons, true).UpdateCondition(oldCon.GetType(), oldCon.GetStatus(), "newReason", "newMessage").Conditions()
+			updated, changed := conditions.ConditionUpdater(NewCondition[bool], cons, true).UpdateCondition(oldCon.GetType(), oldCon.GetStatus(), "newReason", "newMessage").Conditions()
 			Expect(changed).To(BeTrue())
 			newCon := conditions.GetCondition(updated, "true")
 			Expect(updated).To(HaveLen(1))
@@ -186,7 +127,7 @@ var _ = Describe("Conditions", func() {
 		It("should update the condition (different value, discard other cons)", func() {
 			cons := testConditionSet()
 			oldCon := conditions.GetCondition(cons, "true")
-			updated, changed := conditions.ConditionUpdater(func() conditions.Condition[bool] { return &conImpl{} }, cons, true).UpdateCondition(oldCon.GetType(), !oldCon.GetStatus(), "newReason", "newMessage").Conditions()
+			updated, changed := conditions.ConditionUpdater(NewCondition[bool], cons, true).UpdateCondition(oldCon.GetType(), !oldCon.GetStatus(), "newReason", "newMessage").Conditions()
 			Expect(changed).To(BeTrue())
 			newCon := conditions.GetCondition(updated, "true")
 			Expect(updated).To(HaveLen(1))
@@ -203,16 +144,16 @@ var _ = Describe("Conditions", func() {
 
 		It("should sort the conditions by type", func() {
 			cons := []conditions.Condition[bool]{
-				newConImplWithValues("c", true, "reason", "message", time.Now()),
-				newConImplWithValues("d", true, "reason", "message", time.Now()),
-				newConImplWithValues("a", true, "reason", "message", time.Now()),
-				newConImplWithValues("b", true, "reason", "message", time.Now()),
+				NewConditionImplFromValues("c", true, "reason", "message", time.Now()),
+				NewConditionImplFromValues("d", true, "reason", "message", time.Now()),
+				NewConditionImplFromValues("a", true, "reason", "message", time.Now()),
+				NewConditionImplFromValues("b", true, "reason", "message", time.Now()),
 			}
 			compareConditions := func(a, b conditions.Condition[bool]) int {
 				return strings.Compare(a.GetType(), b.GetType())
 			}
 			Expect(slices.IsSortedFunc(cons, compareConditions)).To(BeFalse(), "conditions in the test object are already sorted, unable to test sorting")
-			updated, changed := conditions.ConditionUpdater(func() conditions.Condition[bool] { return &conImpl{} }, cons, false).Conditions()
+			updated, changed := conditions.ConditionUpdater(NewCondition[bool], cons, false).Conditions()
 			Expect(changed).To(BeFalse())
 			Expect(len(updated)).To(BeNumerically(">", 1), "test object does not contain enough conditions to test sorting")
 			Expect(len(updated)).To(Equal(len(cons)))
@@ -221,32 +162,32 @@ var _ = Describe("Conditions", func() {
 
 		It("should remove a condition", func() {
 			cons := testConditionSet()
-			updated, changed := conditions.ConditionUpdater(func() conditions.Condition[bool] { return &conImpl{} }, cons, false).RemoveCondition("true").Conditions()
+			updated, changed := conditions.ConditionUpdater(NewCondition[bool], cons, false).RemoveCondition("true").Conditions()
 			Expect(changed).To(BeTrue())
 			Expect(updated).To(HaveLen(len(cons) - 1))
 			con := conditions.GetCondition(updated, "true")
 			Expect(con).To(BeNil())
 
 			// removing a condition that does not exist should not change anything
-			updated, changed = conditions.ConditionUpdater(func() conditions.Condition[bool] { return &conImpl{} }, cons, false).RemoveCondition("doesNotExist").Conditions()
+			updated, changed = conditions.ConditionUpdater(NewCondition[bool], cons, false).RemoveCondition("doesNotExist").Conditions()
 			Expect(changed).To(BeFalse())
 			Expect(updated).To(HaveLen(len(cons)))
 		})
 
 		It("should not mark a condition as changed if it has the same values as before", func() {
 			cons := testConditionSet()
 			con := conditions.GetCondition(cons, "true")
-			updated, changed := conditions.ConditionUpdater(func() conditions.Condition[bool] { return &conImpl{} }, cons, false).UpdateCondition(con.GetType(), con.GetStatus(), con.GetReason(), con.GetMessage()).Conditions()
+			updated, changed := conditions.ConditionUpdater(NewCondition[bool], cons, false).UpdateCondition(con.GetType(), con.GetStatus(), con.GetReason(), con.GetMessage()).Conditions()
 			Expect(changed).To(BeFalse())
 			Expect(updated).To(HaveLen(len(cons)))
 		})
 
 		It("should return that a condition exists only if it will be contained in the returned list", func() {
 			cons := testConditionSet()
-			updater := conditions.ConditionUpdater(func() conditions.Condition[bool] { return &conImpl{} }, cons, false)
+			updater := conditions.ConditionUpdater(NewCondition[bool], cons, false)
 			Expect(updater.HasCondition("true")).To(BeTrue())
 			Expect(updater.HasCondition("doesNotExist")).To(BeFalse())
-			updater = conditions.ConditionUpdater(func() conditions.Condition[bool] { return &conImpl{} }, cons, true)
+			updater = conditions.ConditionUpdater(NewCondition[bool], cons, true)
 			Expect(updater.HasCondition("true")).To(BeFalse())
 			Expect(updater.HasCondition("doesNotExist")).To(BeFalse())
 			updater.UpdateCondition("true", true, "reason", "message")

pkg/controller/predicates.go

@@ -152,23 +152,10 @@ type StatusChangedPredicate struct {
 }
 
 func (p StatusChangedPredicate) Update(e event.UpdateEvent) bool {
-	oldStatus := getStatus(e.ObjectOld)
-	newStatus := getStatus(e.ObjectNew)
+	oldStatus := GetField(e.ObjectOld, "Status", false)
+	newStatus := GetField(e.ObjectNew, "Status", false)
 	if oldStatus == nil || newStatus == nil {
 		return true
 	}
 	return !reflect.DeepEqual(oldStatus, newStatus)
 }
-
-func getStatus(obj any) any {
-	if obj == nil {
-		return nil
-	}
-	val := reflect.ValueOf(obj).Elem()
-	for i := 0; i < val.NumField(); i++ {
-		if val.Type().Field(i).Name == "Status" {
-			return val.Field(i).Interface()
-		}
-	}
-	return nil
-}