test: refactoring for unittests

Author: nexus49

controller/lifecycle/api/api.go

@@ -44,9 +44,8 @@ type RuntimeObjectConditions interface {
 }
 
 type SpreadManager interface {
-	ToRuntimeObjectSpreadReconcileStatusInterface(instance runtimeobject.RuntimeObject, log *logger.Logger) (RuntimeObjectSpreadReconcileStatus, error)
-	MustToRuntimeObjectSpreadReconcileStatusInterface(instance runtimeobject.RuntimeObject, log *logger.Logger) RuntimeObjectSpreadReconcileStatus
-	OnNextReconcile(instanceStatusObj RuntimeObjectSpreadReconcileStatus, log *logger.Logger) (ctrl.Result, error)
+	ReconcileRequired(instance runtimeobject.RuntimeObject, log *logger.Logger) bool
+	OnNextReconcile(instance runtimeobject.RuntimeObject, log *logger.Logger) (ctrl.Result, error)
 	RemoveRefreshLabelIfExists(instance runtimeobject.RuntimeObject) bool
 	SetNextReconcileTime(instanceStatusObj RuntimeObjectSpreadReconcileStatus, log *logger.Logger)
 	UpdateObservedGeneration(instanceStatusObj RuntimeObjectSpreadReconcileStatus, log *logger.Logger)

controller/lifecycle/controllerruntime/lifecycle.go

@@ -63,19 +63,16 @@ func (l *LifecycleManager) ConditionsManager() api.ConditionManager {
 	}
 	return l.conditionsManager
 }
-
 func (l *LifecycleManager) Spreader() api.SpreadManager {
 	// it is important to return nil unsted of a nil pointer to the interface to avoid misbehaving nil checks
 	if l.spreader == nil {
 		return nil
 	}
 	return l.spreader
 }
-
 func (l *LifecycleManager) Reconcile(ctx context.Context, req ctrl.Request, instance runtimeobject.RuntimeObject) (ctrl.Result, error) {
 	return lifecycle.Reconcile(ctx, req.NamespacedName, instance, l.client, l)
 }
-
 func (l *LifecycleManager) SetupWithManagerBuilder(mgr ctrl.Manager, maxReconciles int, reconcilerName string, instance runtimeobject.RuntimeObject, debugLabelValue string, log *logger.Logger, eventPredicates ...predicate.Predicate) (*builder.Builder, error) {
 	if err := lifecycle.ValidateInterfaces(instance, log, l); err != nil {
 		return nil, err
@@ -92,7 +89,6 @@ func (l *LifecycleManager) SetupWithManagerBuilder(mgr ctrl.Manager, maxReconcil
 		WithOptions(controller.Options{MaxConcurrentReconciles: maxReconciles}).
 		WithEventFilter(predicate.And(eventPredicates...)), nil
 }
-
 func (l *LifecycleManager) SetupWithManager(mgr ctrl.Manager, maxReconciles int, reconcilerName string, instance runtimeobject.RuntimeObject, debugLabelValue string, r reconcile.Reconciler, log *logger.Logger, eventPredicates ...predicate.Predicate) error {
 	b, err := l.SetupWithManagerBuilder(mgr, maxReconciles, reconcilerName, instance, debugLabelValue, log, eventPredicates...)
 	if err != nil {

controller/lifecycle/controllerruntime/lifecycle_test.go

@@ -47,25 +47,6 @@ func TestLifecycle(t *testing.T) {
 	}
 	ctx := context.Background()
 
-	t.Run("Lifecycle with a not found object", func(t *testing.T) {
-		// Arrange
-		fakeClient := pmtesting.CreateFakeClient(t, &pmtesting.TestApiObject{})
-
-		mgr, log := createLifecycleManager([]subroutine.Subroutine{}, fakeClient)
-
-		// Act
-		result, err := mgr.Reconcile(ctx, request, &pmtesting.TestApiObject{})
-
-		// Assert
-		assert.NoError(t, err)
-		assert.NotNil(t, result)
-		logMessages, err := log.GetLogMessages()
-		assert.NoError(t, err)
-		assert.Equal(t, len(logMessages), 2)
-		assert.Equal(t, logMessages[0].Message, "start reconcile")
-		assert.Contains(t, logMessages[1].Message, "instance not found")
-	})
-
 	t.Run("Lifecycle with a finalizer - add finalizer", func(t *testing.T) {
 		// Arrange
 		instance := &pmtesting.TestApiObject{

controller/lifecycle/lifecycle.go

@@ -7,7 +7,6 @@ import (
 
 	"github.com/google/uuid"
 	"go.opentelemetry.io/otel"
-	"golang.org/x/exp/maps"
 	"k8s.io/apimachinery/pkg/api/equality"
 	kerrors "k8s.io/apimachinery/pkg/api/errors"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -20,8 +19,8 @@ import (
 
 	"github.com/platform-mesh/golang-commons/controller/lifecycle/api"
 	"github.com/platform-mesh/golang-commons/controller/lifecycle/runtimeobject"
-	"github.com/platform-mesh/golang-commons/controller/lifecycle/spread"
 	"github.com/platform-mesh/golang-commons/controller/lifecycle/subroutine"
+	"github.com/platform-mesh/golang-commons/controller/lifecycle/util"
 	"github.com/platform-mesh/golang-commons/errors"
 	"github.com/platform-mesh/golang-commons/logger"
 	"github.com/platform-mesh/golang-commons/sentry"
@@ -57,15 +56,10 @@ func Reconcile(ctx context.Context, nName types.NamespacedName, instance runtime
 	generationChanged := true
 
 	if l.Spreader() != nil && instance.GetDeletionTimestamp().IsZero() {
-		instanceStatusObj := l.Spreader().MustToRuntimeObjectSpreadReconcileStatusInterface(instance, log)
-		generationChanged = instance.GetGeneration() != instanceStatusObj.GetObservedGeneration()
-		isAfterNextReconcileTime := v1.Now().UTC().After(instanceStatusObj.GetNextReconcileTime().UTC())
-		refreshRequested := slices.Contains(maps.Keys(instance.GetLabels()), spread.ReconcileRefreshLabel)
-
-		reconcileRequired := generationChanged || isAfterNextReconcileTime || refreshRequested
+		reconcileRequired := l.Spreader().ReconcileRequired(instance, log)
 		if !reconcileRequired {
 			log.Info().Msg("skipping reconciliation, spread reconcile is active. No processing needed")
-			return l.Spreader().OnNextReconcile(instanceStatusObj, log)
+			return l.Spreader().OnNextReconcile(instance, log)
 		}
 	}
 
@@ -305,7 +299,7 @@ func HandleClientError(msg string, log *logger.Logger, err error, generationChan
 
 func MarkResourceAsFinal(instance runtimeobject.RuntimeObject, log *logger.Logger, conditions []v1.Condition, status v1.ConditionStatus, l api.Lifecycle) {
 	if l.Spreader() != nil && instance.GetDeletionTimestamp().IsZero() {
-		instanceStatusObj := l.Spreader().MustToRuntimeObjectSpreadReconcileStatusInterface(instance, log)
+		instanceStatusObj := util.MustToInterface[api.RuntimeObjectSpreadReconcileStatus](instance, log)
 		l.Spreader().SetNextReconcileTime(instanceStatusObj, log)
 		l.Spreader().UpdateObservedGeneration(instanceStatusObj, log)
 	}
@@ -369,7 +363,7 @@ func HandleOperatorError(ctx context.Context, operatorError errors.OperatorError
 
 func ValidateInterfaces(instance runtimeobject.RuntimeObject, log *logger.Logger, l api.Lifecycle) error {
 	if l.Spreader() != nil {
-		_, err := l.Spreader().ToRuntimeObjectSpreadReconcileStatusInterface(instance, log)
+		_, err := util.ToInterface[api.RuntimeObjectSpreadReconcileStatus](instance, log)
 		if err != nil {
 			return err
 		}