Introduce a condtions package with a light weight manager to help enable coordinated condition updates

Signed-off-by: Scott Nichols <[email protected]>

Author: n3wscott

apis/common/v1/zz_generated.deepcopy.go

@@ -1,5 +1,5 @@
 /*
-Copyright 2019 The Crossplane Authors.
+Copyright 2025 The Crossplane Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

hack/boilerplate.go.txt

@@ -0,0 +1,79 @@
+/*
+Copyright 2025 The Crossplane Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Package conditions enables consistent interactions with an object's status conditions.
+package conditions
+
+import (
+	xpv1 "github.com/crossplane/crossplane-runtime/apis/common/v1"
+	"github.com/crossplane/crossplane-runtime/pkg/resource"
+)
+
+// ObjectWithConditions is the interface definition that allows.
+type ObjectWithConditions interface {
+	resource.Object
+	resource.Conditioned
+}
+
+// Manager is an interface for a stateless factory-like object that produces ConditionSet objects.
+type Manager interface {
+	// For returns an implementation of a ConditionSet to operate on a specific ObjectWithConditions.
+	For(o ObjectWithConditions) ConditionSet
+}
+
+// ConditionSet holds operations for interacting with an object's conditions.
+type ConditionSet interface {
+	// Mark adds or updates the conditions onto the managed resource object. Unlike a "Set" method, this also can add
+	// contextual updates to the condition such as propagating the correct observedGeneration to the conditions being
+	// changed.
+	Mark(condition ...xpv1.Condition)
+}
+
+// New returns an implementation of a Manager.
+func New() Manager {
+	return &managerImpl{}
+}
+
+// Check that conditionsImpl implements ConditionManager.
+var _ Manager = (*managerImpl)(nil)
+
+// managerImpl is the top level factor for producing a ConditionSet on behalf of a ObjectWithConditions resource.
+// managerImpl implements Manager.
+type managerImpl struct{}
+
+// For implements Manager.For.
+func (m managerImpl) For(o ObjectWithConditions) ConditionSet {
+	return &conditionSet{o: o}
+}
+
+// Check that conditionSet implements ConditionSet.
+var _ ConditionSet = (*conditionSet)(nil)
+
+type conditionSet struct {
+	o ObjectWithConditions
+}
+
+// Mark implements ConditionSet.Mark.
+func (c *conditionSet) Mark(condition ...xpv1.Condition) {
+	if c == nil || c.o == nil {
+		return
+	}
+	// Foreach condition we have been sent to mark, update the observed generation.
+	for i := range condition {
+		condition[i].ObservedGeneration = c.o.GetGeneration()
+	}
+	c.o.SetConditions(condition...)
+}

pkg/conditions/manager.go

@@ -0,0 +1,136 @@
+/*
+Copyright 2025 The Crossplane Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package conditions
+
+import (
+	"reflect"
+	"testing"
+	"time"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/google/go-cmp/cmp/cmpopts"
+
+	xpv1 "github.com/crossplane/crossplane-runtime/apis/common/v1"
+	"github.com/crossplane/crossplane-runtime/pkg/resource/fake"
+	"github.com/crossplane/crossplane-runtime/pkg/test"
+)
+
+func TestNew(t *testing.T) {
+	tests := []struct {
+		name string
+		want Manager
+	}{{
+		name: "New returns a non-nil manager.",
+		want: &managerImpl{},
+	}}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := New(); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("New() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func Test_conditionSet_Mark(t *testing.T) {
+	manager := New()
+
+	tests := []struct {
+		name  string
+		start []xpv1.Condition
+		mark  []xpv1.Condition
+		want  []xpv1.Condition
+	}{{
+		name:  "provide no conditions",
+		start: nil,
+		mark:  nil,
+		want:  nil,
+	}, {
+		name:  "empty status, a new condition is appended",
+		start: nil,
+		mark:  []xpv1.Condition{xpv1.ReconcileSuccess()},
+		want:  []xpv1.Condition{xpv1.ReconcileSuccess().WithObservedGeneration(42)},
+	}, {
+		name:  "existing status, attempt to mark nothing",
+		start: []xpv1.Condition{xpv1.Available().WithObservedGeneration(1)},
+		mark:  nil,
+		want:  []xpv1.Condition{xpv1.Available().WithObservedGeneration(1)},
+	}, {
+		name:  "existing status, an existing condition is updated",
+		start: []xpv1.Condition{xpv1.ReconcileSuccess().WithObservedGeneration(1)},
+		mark:  []xpv1.Condition{xpv1.ReconcileSuccess()},
+		want:  []xpv1.Condition{xpv1.ReconcileSuccess().WithObservedGeneration(42)},
+	}, {
+		name:  "existing status, a new condition is appended",
+		start: []xpv1.Condition{xpv1.Available().WithObservedGeneration(1)},
+		mark:  []xpv1.Condition{xpv1.ReconcileSuccess()},
+		want:  []xpv1.Condition{xpv1.Available().WithObservedGeneration(1), xpv1.ReconcileSuccess().WithObservedGeneration(42)},
+	}}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ut := newManaged(42, tt.start...)
+			c := manager.For(ut)
+			c.Mark(tt.mark...)
+			if diff := cmp.Diff(tt.want, ut.Conditions, test.EquateConditions(), cmpopts.EquateApproxTime(1*time.Second)); diff != "" {
+				reason := "Failed to update conditions."
+				t.Errorf("\nReason: %s\n-want, +got:\n%s", reason, diff)
+			}
+		})
+	}
+
+	t.Run("Manage a nil object", func(t *testing.T) {
+		c := manager.For(nil)
+		if c == nil {
+			t.Errorf("manager.For(nil) = %v, want non-nil", c)
+		}
+		// Test that Marking on a Manager that has a nil object does not end up panicking.
+		c.Mark(xpv1.ReconcileSuccess())
+		// Success!
+	})
+}
+
+func Test_managerImpl_For(t *testing.T) {
+	tests := []struct {
+		name string
+		o    ObjectWithConditions
+		want ConditionSet
+	}{{
+		name: "Nil object returns a non-nil manager.",
+		want: &conditionSet{},
+	}, {
+		name: "Object propagates into manager.",
+		o:    &fake.Managed{},
+		want: &conditionSet{
+			o: &fake.Managed{},
+		},
+	}}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			m := managerImpl{}
+			if got := m.For(tt.o); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("For() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func newManaged(generation int64, conditions ...xpv1.Condition) *fake.Managed {
+	mg := &fake.Managed{}
+	mg.Generation = generation
+	mg.SetConditions(conditions...)
+	return mg
+}