🌱 Update conditions.Set function to set LastTransitionTime only when status of condition changes (#11176)

* Update set conditions to set LastTrasition time only when status changes

* Add new test to ignore last transition time even if set

* Create seperate function for Set condition

Author: Karthik-K-N

util/conditions/setter.go

@@ -77,6 +77,54 @@ func Set(to Setter, condition *clusterv1.Condition) {
 	to.SetConditions(conditions)
 }
 
+// SetWithCustomLastTransitionTime is similar to Set function which sets the given condition but following changes for LastTransitionTime.
+//
+//  1. if the condition of the specified type already exists (all fields of the existing condition are updated to
+//     new condition, LastTransitionTime is set to current time if unset and new status differs from the old status)
+//  2. if a condition of the specified type does not exist (LastTransitionTime is set to current time if unset, and newCondition is appended)
+func SetWithCustomLastTransitionTime(to Setter, condition *clusterv1.Condition) {
+	if to == nil || condition == nil {
+		return
+	}
+
+	// Check if the new conditions already exists, and change it only if there is a status
+	// transition (otherwise we should preserve the current last transition time)-
+	conditions := to.GetConditions()
+	exists := false
+	for i := range conditions {
+		existingCondition := conditions[i]
+		if existingCondition.Type == condition.Type {
+			exists = true
+			if !HasSameState(&existingCondition, condition) {
+				if existingCondition.Status != condition.Status {
+					if condition.LastTransitionTime.IsZero() {
+						condition.LastTransitionTime = metav1.NewTime(time.Now().UTC().Truncate(time.Second))
+					}
+				} else {
+					condition.LastTransitionTime = existingCondition.LastTransitionTime
+				}
+				conditions[i] = *condition
+			}
+			break
+		}
+	}
+
+	// If the condition does not exist, add it, setting the transition time only if not already set
+	if !exists {
+		if condition.LastTransitionTime.IsZero() {
+			condition.LastTransitionTime = metav1.NewTime(time.Now().UTC().Truncate(time.Second))
+		}
+		conditions = append(conditions, *condition)
+	}
+
+	// Sorts conditions for convenience of the consumer, i.e. kubectl.
+	sort.Slice(conditions, func(i, j int) bool {
+		return lexicographicLess(&conditions[i], &conditions[j])
+	})
+
+	to.SetConditions(conditions)
+}
+
 // TrueCondition returns a condition with Status=True and the given type.
 func TrueCondition(t clusterv1.ConditionType) *clusterv1.Condition {
 	return &clusterv1.Condition{

util/conditions/setter_test.go

@@ -209,6 +209,96 @@ func TestSetLastTransitionTime(t *testing.T) {
 	}
 }
 
+func TestSetWithCustomLastTransitionTime(t *testing.T) {
+	x := metav1.Date(2012, time.January, 1, 12, 15, 30, 5e8, time.UTC)
+	y := metav1.Date(2012, time.January, 2, 12, 15, 30, 5e8, time.UTC)
+
+	foo := FalseCondition("foo", "reason foo", clusterv1.ConditionSeverityInfo, "message foo")
+	fooWithBarMessage := FalseCondition("foo", "reason foo", clusterv1.ConditionSeverityInfo, "message bar")
+	fooWithLastTransitionTime := FalseCondition("foo", "reason foo", clusterv1.ConditionSeverityInfo, "message foo")
+	fooWithLastTransitionTime.LastTransitionTime = x
+	fooWithLastTransitionTimeWithBarMessage := FalseCondition("foo", "reason foo", clusterv1.ConditionSeverityInfo, "message bar")
+	fooWithLastTransitionTimeWithBarMessage.LastTransitionTime = y
+
+	fooWithAnotherState := TrueCondition("foo")
+	fooWithAnotherStateWithLastTransitionTime := TrueCondition("foo")
+	fooWithAnotherStateWithLastTransitionTime.LastTransitionTime = y
+
+	tests := []struct {
+		name                    string
+		to                      Setter
+		new                     *clusterv1.Condition
+		LastTransitionTimeCheck func(*WithT, metav1.Time)
+	}{
+		{
+			name: "Set a condition that does not exists should set the last transition time if not defined",
+			to:   setterWithConditions(),
+			new:  foo,
+			LastTransitionTimeCheck: func(g *WithT, lastTransitionTime metav1.Time) {
+				g.Expect(lastTransitionTime).ToNot(BeZero())
+			},
+		},
+		{
+			name: "Set a condition that does not exists should preserve the last transition time if defined",
+			to:   setterWithConditions(),
+			new:  fooWithLastTransitionTime,
+			LastTransitionTimeCheck: func(g *WithT, lastTransitionTime metav1.Time) {
+				g.Expect(lastTransitionTime).To(Equal(x))
+			},
+		},
+		{
+			name: "Set a condition that already exists with the same state should preserves the last transition time",
+			to:   setterWithConditions(fooWithLastTransitionTime),
+			new:  foo,
+			LastTransitionTimeCheck: func(g *WithT, lastTransitionTime metav1.Time) {
+				g.Expect(lastTransitionTime).To(Equal(x))
+			},
+		},
+		{
+			name: "Set a condition that already exists but with different state should changes the last transition time",
+			to:   setterWithConditions(fooWithLastTransitionTime),
+			new:  fooWithAnotherState,
+			LastTransitionTimeCheck: func(g *WithT, lastTransitionTime metav1.Time) {
+				g.Expect(lastTransitionTime).ToNot(Equal(x))
+			},
+		},
+		{
+			name: "Set a condition that already exists but with different state should preserve the last transition time if defined",
+			to:   setterWithConditions(fooWithLastTransitionTime),
+			new:  fooWithAnotherStateWithLastTransitionTime,
+			LastTransitionTimeCheck: func(g *WithT, lastTransitionTime metav1.Time) {
+				g.Expect(lastTransitionTime).To(Equal(y))
+			},
+		},
+		{
+			name: "Set a condition that already exists but with different Message should preserve the last transition time",
+			to:   setterWithConditions(fooWithLastTransitionTime),
+			new:  fooWithBarMessage,
+			LastTransitionTimeCheck: func(g *WithT, lastTransitionTime metav1.Time) {
+				g.Expect(lastTransitionTime).To(Equal(x))
+			},
+		},
+		{
+			name: "Set a condition that already exists, with different state but same Status should ignore the last transition even if defined",
+			to:   setterWithConditions(fooWithLastTransitionTime),
+			new:  fooWithLastTransitionTimeWithBarMessage,
+			LastTransitionTimeCheck: func(g *WithT, lastTransitionTime metav1.Time) {
+				g.Expect(lastTransitionTime).To(Equal(x))
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			g := NewWithT(t)
+
+			SetWithCustomLastTransitionTime(tt.to, tt.new)
+
+			tt.LastTransitionTimeCheck(g, Get(tt.to, "foo").LastTransitionTime)
+		})
+	}
+}
+
 func TestMarkMethods(t *testing.T) {
 	g := NewWithT(t)