test: refactoring for unittests

Author: nexus49

controller/lifecycle/api/api.go

@@ -30,12 +30,10 @@ type Config struct {
 }
 
 type ConditionManager interface {
-	MustToRuntimeObjectConditionsInterface(instance runtimeobject.RuntimeObject, log *logger.Logger) RuntimeObjectConditions
 	SetInstanceConditionUnknownIfNotSet(conditions *[]metav1.Condition) bool
 	SetSubroutineConditionToUnknownIfNotSet(conditions *[]metav1.Condition, subroutine subroutine.Subroutine, isFinalize bool, log *logger.Logger) bool
 	SetSubroutineCondition(conditions *[]metav1.Condition, subroutine subroutine.Subroutine, subroutineResult ctrl.Result, subroutineErr error, isFinalize bool, log *logger.Logger) bool
 	SetInstanceConditionReady(conditions *[]metav1.Condition, status metav1.ConditionStatus) bool
-	ToRuntimeObjectConditionsInterface(instance runtimeobject.RuntimeObject, log *logger.Logger) (RuntimeObjectConditions, error)
 }
 
 type RuntimeObjectConditions interface {

controller/lifecycle/conditions/conditions.go

@@ -7,11 +7,8 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	ctrl "sigs.k8s.io/controller-runtime"
 
-	"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/subroutine"
 	"github.com/platform-mesh/golang-commons/logger"
-	"github.com/platform-mesh/golang-commons/sentry"
 )
 
 const (
@@ -118,22 +115,3 @@ func (c *ConditionManager) SetSubroutineCondition(conditions *[]metav1.Condition
 	}
 	return changed
 }
-
-func (c *ConditionManager) ToRuntimeObjectConditionsInterface(instance runtimeobject.RuntimeObject, log *logger.Logger) (api.RuntimeObjectConditions, error) {
-	if obj, ok := instance.(api.RuntimeObjectConditions); ok {
-		return obj, nil
-	}
-	err := fmt.Errorf("ManageConditions is enabled, but instance does not implement RuntimeObjectConditions interface. This is a programming error")
-	log.Error().Err(err).Msg("instance does not implement RuntimeObjectConditions interface")
-	sentry.CaptureError(err, nil)
-	return nil, err
-}
-
-func (c *ConditionManager) MustToRuntimeObjectConditionsInterface(instance runtimeobject.RuntimeObject, log *logger.Logger) api.RuntimeObjectConditions {
-	obj, err := c.ToRuntimeObjectConditionsInterface(instance, log)
-	if err == nil {
-		return obj
-	}
-	log.Panic().Err(err).Msg("instance does not implement RuntimeObjectConditions interface")
-	return nil
-}

controller/lifecycle/conditions/conditions_test.go

@@ -240,44 +240,3 @@ func TestSubroutineCondition(t *testing.T) {
 		assert.Equal(t, metav1.ConditionFalse, condition[0].Status)
 	})
 }
-
-// Dummy types for testing interface conversion
-
-func TestToRuntimeObjectConditionsInterface(t *testing.T) {
-	log, err := logger.New(logger.DefaultConfig())
-	require.NoError(t, err)
-	cm := NewConditionManager()
-
-	t.Run("Implements interface", func(t *testing.T) {
-		obj := pmtesting.DummyRuntimeObjectWithConditions{}
-		res, err := cm.ToRuntimeObjectConditionsInterface(obj, log)
-		assert.NoError(t, err)
-		assert.NotNil(t, res)
-	})
-
-	t.Run("Does not implement interface", func(t *testing.T) {
-		obj := pmtesting.DummyRuntimeObject{}
-		res, err := cm.ToRuntimeObjectConditionsInterface(obj, log)
-		assert.Error(t, err)
-		assert.Nil(t, res)
-	})
-}
-
-func TestMustToRuntimeObjectConditionsInterface(t *testing.T) {
-	log, err := logger.New(logger.DefaultConfig())
-	require.NoError(t, err)
-	cm := NewConditionManager()
-
-	t.Run("Implements interface", func(t *testing.T) {
-		obj := pmtesting.DummyRuntimeObjectWithConditions{}
-		res := cm.MustToRuntimeObjectConditionsInterface(obj, log)
-		assert.NotNil(t, res)
-	})
-
-	t.Run("Does not implement interface panics", func(t *testing.T) {
-		obj := pmtesting.DummyRuntimeObject{}
-		assert.Panics(t, func() {
-			cm.MustToRuntimeObjectConditionsInterface(obj, log)
-		})
-	})
-}

controller/lifecycle/lifecycle.go

@@ -71,7 +71,8 @@ func Reconcile(ctx context.Context, nName types.NamespacedName, instance runtime
 
 	var condArr []v1.Condition
 	if l.ConditionsManager() != nil {
-		condArr = l.ConditionsManager().MustToRuntimeObjectConditionsInterface(instance, log).GetConditions()
+		roc := util.MustToInterface[api.RuntimeObjectConditions](instance, log)
+		condArr = roc.GetConditions()
 		l.ConditionsManager().SetInstanceConditionUnknownIfNotSet(&condArr)
 	}
 
@@ -98,18 +99,18 @@ func Reconcile(ctx context.Context, nName types.NamespacedName, instance runtime
 
 		// Set current condArr before reconciling the s
 		if l.ConditionsManager() != nil {
-			l.ConditionsManager().MustToRuntimeObjectConditionsInterface(instance, log).SetConditions(condArr)
+			util.MustToInterface[api.RuntimeObjectConditions](instance, log).SetConditions(condArr)
 		}
 		subResult, retry, err := reconcileSubroutine(ctx, instance, s, cl, l, log, generationChanged, sentryTags)
 		// Update condArr with any changes the s did
 		if l.ConditionsManager() != nil {
-			condArr = l.ConditionsManager().MustToRuntimeObjectConditionsInterface(instance, log).GetConditions()
+			condArr = util.MustToInterface[api.RuntimeObjectConditions](instance, log).GetConditions()
 		}
 		if err != nil {
 			if l.ConditionsManager() != nil {
 				l.ConditionsManager().SetSubroutineCondition(&condArr, s, result, err, inDeletion, log)
 				l.ConditionsManager().SetInstanceConditionReady(&condArr, v1.ConditionFalse)
-				l.ConditionsManager().MustToRuntimeObjectConditionsInterface(instance, log).SetConditions(condArr)
+				util.MustToInterface[api.RuntimeObjectConditions](instance, log).SetConditions(condArr)
 			}
 			if !retry {
 				MarkResourceAsFinal(instance, log, condArr, v1.ConditionFalse, l)
@@ -144,7 +145,7 @@ func Reconcile(ctx context.Context, nName types.NamespacedName, instance runtime
 	}
 
 	if l.ConditionsManager() != nil {
-		l.ConditionsManager().MustToRuntimeObjectConditionsInterface(instance, log).SetConditions(condArr)
+		util.MustToInterface[api.RuntimeObjectConditions](instance, log).SetConditions(condArr)
 	}
 
 	if !l.Config().ReadOnly {
@@ -369,7 +370,8 @@ func ValidateInterfaces(instance runtimeobject.RuntimeObject, log *logger.Logger
 		}
 	}
 	if l.ConditionsManager() != nil {
-		_, err := l.ConditionsManager().ToRuntimeObjectConditionsInterface(instance, log)
+		util.ToInterface[api.RuntimeObjectConditions](instance, log)
+		_, err := util.ToInterface[api.RuntimeObjectConditions](instance, log)
 		if err != nil {
 			return err
 		}