unit test

Author: robertgraeff

cmd/openmcp-operator/app/run.go

@@ -312,9 +312,8 @@ func (o *RunOptions) Run(ctx context.Context) error {
 	if slices.Contains(o.Controllers, strings.ToLower(provider.ControllerName)) {
 		utilruntime.Must(clientgoscheme.AddToScheme(mgr.GetScheme()))
 		utilruntime.Must(api.AddToScheme(mgr.GetScheme()))
-
-		if err = provider.NewDeploymentController().SetupWithManager(mgr, o.ProviderGVKList, o.Environment); err != nil {
-			return fmt.Errorf("unable to setup provider controllers: %w", err)
+		if err = provider.NewDeploymentController().SetupWithManager(&setupLog, mgr, o.ProviderGVKList, o.Environment); err != nil {
+			return fmt.Errorf("unable to setup deployment controllers: %w", err)
 		}
 	}
 

internal/controllers/provider/controller.go

@@ -11,28 +11,33 @@ import (
 	"github.com/openmcp-project/controller-utils/pkg/logging"
 	apimeta "k8s.io/apimachinery/pkg/api/meta"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
-	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 
+	"github.com/openmcp-project/openmcp-operator/api/constants"
 	"github.com/openmcp-project/openmcp-operator/api/provider/v1alpha1"
 	"github.com/openmcp-project/openmcp-operator/internal/controllers/provider/install"
 )
 
 const (
-	openmcpDomain              = "openmcp.cloud"
-	openmcpFinalizer           = openmcpDomain + "/finalizer"
-	openmcpOperationAnnotation = openmcpDomain + "/operation"
-	operationReconcile         = "reconcile"
+	openmcpFinalizer = constants.OpenMCPGroupName + "/finalizer"
 
 	phaseProgressing = "Progressing"
 	phaseTerminating = "Terminating"
 	phaseReady       = "Ready"
 )
 
+func NewProviderReconciler(gvk schema.GroupVersionKind, client client.Client, environment string) *ProviderReconciler {
+	return &ProviderReconciler{
+		GroupVersionKind: gvk,
+		PlatformClient:   client,
+		Environment:      environment,
+	}
+}
+
 type ProviderReconciler struct {
 	schema.GroupVersionKind
 	PlatformClient client.Client
@@ -55,6 +60,11 @@ func (r *ProviderReconciler) Reconcile(ctx context.Context, req ctrl.Request) (r
 		return ctrl.Result{}, fmt.Errorf("failed to get provider resource: %w", err)
 	}
 
+	if controller.HasAnnotationWithValue(provider, constants.OperationAnnotation, constants.OperationAnnotationValueIgnore) {
+		log.Info("Ignoring resource due to ignore operation annotation")
+		return ctrl.Result{}, nil
+	}
+
 	providerOrig := provider.DeepCopy()
 
 	if provider.GetDeletionTimestamp().IsZero() {
@@ -73,42 +83,19 @@ func (r *ProviderReconciler) Reconcile(ctx context.Context, req ctrl.Request) (r
 	return res, err
 }
 
-// HandleJob - the ProviderReconciler reconciles the provider resources (ClusterProviders, ServiceProviders, PlatformServices).
-// During a reconcile, the ProviderReconciler creates the init job of the provider and must wait for it to complete.
-// Therefore, the ProviderReconciler watches also jobs. The present method handles the job events and creates a reconcile request.
-func (r *ProviderReconciler) HandleJob(_ context.Context, job client.Object) []reconcile.Request {
-	providerKind, found := job.GetLabels()[install.ProviderKindLabel]
-	if !found || providerKind != r.Kind {
-		return nil
-	}
-
-	providerName, found := job.GetLabels()[install.ProviderNameLabel]
-	if !found {
-		return nil
-	}
-
-	return []reconcile.Request{
-		{
-			NamespacedName: client.ObjectKey{
-				Name: providerName,
-			},
-		},
-	}
-}
-
 func (r *ProviderReconciler) handleCreateUpdateOperation(ctx context.Context, provider *unstructured.Unstructured) (ctrl.Result, error) {
 	log := logging.FromContextOrPanic(ctx)
 
 	if err := r.ensureFinalizer(ctx, provider); err != nil {
 		return reconcile.Result{}, err
 	}
 
-	deploymentSpec, err := r.deploymentSpecFromUnstructured(provider)
+	deploymentSpec, err := DeploymentSpecFromUnstructured(provider)
 	if err != nil {
 		return reconcile.Result{}, err
 	}
 
-	deploymentStatus, err := r.deploymentStatusFromUnstructured(provider)
+	deploymentStatus, err := DeploymentStatusFromUnstructured(provider)
 	if err != nil {
 		return reconcile.Result{}, err
 	}
@@ -128,7 +115,7 @@ func (r *ProviderReconciler) handleCreateUpdateOperation(ctx context.Context, pr
 
 	res, err := r.install(ctx, provider, deploymentSpec, deploymentStatus)
 
-	conversionErr := r.deploymentStatusIntoUnstructured(deploymentStatus, provider)
+	conversionErr := DeploymentStatusIntoUnstructured(deploymentStatus, provider)
 	err = errors.Join(err, conversionErr)
 
 	return res, err
@@ -192,7 +179,7 @@ func (r *ProviderReconciler) install(
 
 func (r *ProviderReconciler) handleDeleteOperation(ctx context.Context, provider *unstructured.Unstructured) (deleted bool, res ctrl.Result, err error) {
 
-	deploymentStatus, err := r.deploymentStatusFromUnstructured(provider)
+	deploymentStatus, err := DeploymentStatusFromUnstructured(provider)
 	if err != nil {
 		return false, reconcile.Result{}, err
 	}
@@ -208,7 +195,7 @@ func (r *ProviderReconciler) handleDeleteOperation(ctx context.Context, provider
 
 	deleted, err = installer.UninstallProvider(ctx)
 	if err != nil {
-		conversionErr := r.deploymentStatusIntoUnstructured(deploymentStatus, provider)
+		conversionErr := DeploymentStatusIntoUnstructured(deploymentStatus, provider)
 		err = errors.Join(err, conversionErr)
 		return false, reconcile.Result{}, err
 
@@ -230,11 +217,11 @@ func (r *ProviderReconciler) checkReconcileAnnotation(
 	provider *unstructured.Unstructured,
 	deploymentStatus *v1alpha1.DeploymentStatus,
 ) error {
-	if controller.HasAnnotationWithValue(provider, openmcpOperationAnnotation, operationReconcile) && deploymentStatus.Phase == phaseReady {
+	if controller.HasAnnotationWithValue(provider, constants.OperationAnnotation, constants.OperationAnnotationValueReconcile) && deploymentStatus.Phase == phaseReady {
 		log := logging.FromContextOrPanic(ctx)
 		deploymentStatus.Phase = phaseProgressing
 
-		if err := r.deploymentStatusIntoUnstructured(deploymentStatus, provider); err != nil {
+		if err := DeploymentStatusIntoUnstructured(deploymentStatus, provider); err != nil {
 			log.Error(err, "failed to handle reconcile annotation")
 			return fmt.Errorf("failed to handle reconcile annotation: %w", err)
 		}
@@ -244,7 +231,7 @@ func (r *ProviderReconciler) checkReconcileAnnotation(
 			return fmt.Errorf("failed to handle reconcile annotation: unable to change phase of provider %s/%s to progressing: %w", provider.GetNamespace(), provider.GetName(), err)
 		}
 
-		if err := controller.EnsureAnnotation(ctx, r.PlatformClient, provider, openmcpOperationAnnotation, operationReconcile, true, controller.DELETE); err != nil {
+		if err := controller.EnsureAnnotation(ctx, r.PlatformClient, provider, constants.OperationAnnotation, constants.OperationAnnotationValueReconcile, true, controller.DELETE); err != nil {
 			log.Error(err, "failed to remove reconcile annotation from provider")
 			return fmt.Errorf("failed to remove reconcile annotation from provider %s/%s: %w", provider.GetNamespace(), provider.GetName(), err)
 		}
@@ -284,42 +271,3 @@ func (r *ProviderReconciler) observeGeneration(provider *unstructured.Unstructur
 		resetConditions(provider, status)
 	}
 }
-
-func (r *ProviderReconciler) deploymentSpecFromUnstructured(provider *unstructured.Unstructured) (*v1alpha1.DeploymentSpec, error) {
-	deploymentSpec := v1alpha1.DeploymentSpec{}
-	deploymentSpecRaw, found, err := unstructured.NestedFieldNoCopy(provider.Object, "spec")
-	if !found {
-		return nil, fmt.Errorf("provider spec not found")
-	}
-	if err != nil {
-		return nil, fmt.Errorf("failed to get provider spec: %w", err)
-	}
-
-	if err = runtime.DefaultUnstructuredConverter.FromUnstructured(deploymentSpecRaw.(map[string]interface{}), &deploymentSpec); err != nil {
-		return nil, fmt.Errorf("failed to convert provider spec: %w", err)
-	}
-	return &deploymentSpec, nil
-}
-
-func (r *ProviderReconciler) deploymentStatusFromUnstructured(provider *unstructured.Unstructured) (*v1alpha1.DeploymentStatus, error) {
-	status := v1alpha1.DeploymentStatus{}
-	statusRaw, found, _ := unstructured.NestedFieldNoCopy(provider.Object, "status")
-	if found {
-		if err := runtime.DefaultUnstructuredConverter.FromUnstructured(statusRaw.(map[string]interface{}), &status); err != nil {
-			return nil, fmt.Errorf("failed to convert provider status from unstructured: %w", err)
-		}
-	}
-	return &status, nil
-}
-
-func (r *ProviderReconciler) deploymentStatusIntoUnstructured(status *v1alpha1.DeploymentStatus, provider *unstructured.Unstructured) error {
-	statusRaw, err := runtime.DefaultUnstructuredConverter.ToUnstructured(status)
-	if err != nil {
-		return fmt.Errorf("failed to convert provider status to unstructured: %w", err)
-	}
-
-	if err = unstructured.SetNestedField(provider.Object, statusRaw, "status"); err != nil {
-		return fmt.Errorf("failed to set provider status: %w", err)
-	}
-	return nil
-}

internal/controllers/provider/controller_test.go

@@ -3,29 +3,169 @@ package provider
 import (
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
+	testutils "github.com/openmcp-project/controller-utils/pkg/testing"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
+	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 
+	apiinstall "github.com/openmcp-project/openmcp-operator/api/install"
 	"github.com/openmcp-project/openmcp-operator/api/provider/v1alpha1"
+	"github.com/openmcp-project/openmcp-operator/internal/controllers/provider/install"
 )
 
 var _ = Describe("Deployment Controller", func() {
 
+	Context("Reconcile", func() {
+
+		var (
+			scheme      = apiinstall.InstallOperatorAPIs(runtime.NewScheme())
+			environment = "test-environment"
+		)
+
+		buildTestEnvironment := func(testdataDir string, gvk schema.GroupVersionKind) *testutils.Environment {
+			return testutils.NewEnvironmentBuilder().
+				WithFakeClient(scheme).
+				WithInitObjectPath("testdata", testdataDir).
+				WithReconcilerConstructor(func(c client.Client) reconcile.Reconciler {
+					return NewProviderReconciler(gvk, c, environment)
+				}).
+				Build()
+		}
+
+		getProvider := func(env *testutils.Environment, provider *unstructured.Unstructured) (*v1alpha1.DeploymentSpec, *v1alpha1.DeploymentStatus) {
+			Expect(env.Client().Get(env.Ctx, client.ObjectKeyFromObject(provider), provider)).To(Succeed())
+			deploymentSpec, err := DeploymentSpecFromUnstructured(provider)
+			Expect(err).NotTo(HaveOccurred(), "DeploymentSpec should be retrievable from provider")
+			deploymentStatus, err := DeploymentStatusFromUnstructured(provider)
+			Expect(err).NotTo(HaveOccurred(), "DeploymentStatus should be retrievable from provider")
+			return deploymentSpec, deploymentStatus
+		}
+
+		reconcileProvider := func(env *testutils.Environment, req reconcile.Request, gvk schema.GroupVersionKind) {
+			provider := &unstructured.Unstructured{}
+			provider.SetGroupVersionKind(gvk)
+			provider.SetName(req.Name)
+
+			env.ShouldReconcile(req, "Reconcile should not return an error")
+			deploymentSpec, deploymentStatus := getProvider(env, provider)
+			Expect(deploymentStatus).NotTo(BeNil(), "Status should not be nil")
+			Expect(controllerutil.ContainsFinalizer(provider, openmcpFinalizer)).To(BeTrue(), "Finalizer should be present")
+			Expect(deploymentStatus.ObservedGeneration).To(Equal(provider.GetGeneration()), "ObservedGeneration should be set")
+			Expect(deploymentStatus.Phase).To(Equal(phaseProgressing), "Phase should be progressing")
+			Expect(isInitialized(deploymentStatus)).To(BeFalse(), "Provider should not yet be initialized")
+			Expect(isProviderInstalledAndReady(deploymentStatus)).To(BeFalse(), "Provider should not yet be ready")
+			values := install.NewValues(provider, deploymentSpec, environment)
+			job := install.NewJobMutator(values, deploymentSpec, nil).Empty()
+			Expect(env.Client().Get(env.Ctx, client.ObjectKeyFromObject(job), job)).To(Succeed())
+			Expect(job.Spec.Template.Spec.Containers[0].Image).To(Equal("test-image:v0.1.0"), "Job container image should match the provider spec")
+			Expect(job.Spec.Template.Spec.Containers[0].Args).To(ContainElement("init"), "Job container args should contain the init command")
+			Expect(job.Spec.Template.Spec.Containers[0].Args).To(ContainElement("--environment=test-environment"), "Job container args should contain the environment")
+			Expect(job.Spec.Template.Spec.Containers[0].Args).To(ContainElement("--verbosity=DEBUG"), "Job container args should contain the verbosity")
+			Expect(job.Spec.Template.Spec.Containers[0].Env).To(HaveLen(1), "Job container should have an environment variables")
+			Expect(job.Spec.Template.Spec.Containers[0].Env[0].Name).To(Equal("NAME"), "Job container environment variable name should match the provider spec")
+			Expect(job.Spec.Template.Spec.Containers[0].Env[0].Value).To(Equal("test-name"), "Job container environment variable value should match the provider spec")
+
+			// 2nd reconcile (after init job is completed)
+			job.Status.Succeeded = 1
+			Expect(env.Client().Status().Update(env.Ctx, job)).To(Succeed(), "Status update of init job should succeed")
+			env.ShouldReconcile(req, "2nd reconcile should not return an error")
+			deploymentSpec, deploymentStatus = getProvider(env, provider)
+			Expect(deploymentStatus.Phase).To(Equal(phaseProgressing), "Phase should be progressing")
+			Expect(isInitialized(deploymentStatus)).To(BeTrue(), "Provider should be initialized")
+			Expect(isProviderInstalledAndReady(deploymentStatus)).To(BeFalse(), "Provider should not yet be ready")
+			deploy := install.NewDeploymentMutator(values).Empty()
+			Expect(env.Client().Get(env.Ctx, client.ObjectKeyFromObject(deploy), deploy)).To(Succeed())
+			Expect(deploy.Spec.Template.Spec.Containers[0].Image).To(Equal("test-image:v0.1.0"), "Deployment container image should match the provider spec")
+			Expect(deploy.Spec.Template.Spec.Containers[0].Args).To(ContainElement("run"), "Deployment container args should contain the run command")
+			Expect(deploy.Spec.Template.Spec.Containers[0].Args).To(ContainElement("--environment=test-environment"), "Deployment container args should contain the environment")
+			Expect(deploy.Spec.Template.Spec.Containers[0].Args).To(ContainElement("--verbosity=DEBUG"), "Deployment container args should contain the verbosity")
+			Expect(deploy.Spec.Template.Spec.Containers[0].Env).To(HaveLen(1), "Deployment container should have an environment variables")
+			Expect(deploy.Spec.Template.Spec.Containers[0].Env[0].Name).To(Equal("NAME"), "Deployment container environment variable name should match the provider spec")
+			Expect(deploy.Spec.Template.Spec.Containers[0].Env[0].Value).To(Equal("test-name"), "Deployment container environment variable value should match the provider spec")
+
+			// 3rd reconcile (after deployment is ready)
+			deploy.Status.Replicas = 1
+			deploy.Status.UpdatedReplicas = 1
+			deploy.Status.AvailableReplicas = 1
+			Expect(env.Client().Status().Update(env.Ctx, deploy)).To(Succeed(), "Status update of deployment should succeed")
+			env.ShouldReconcile(req, "3rd reconcile should not return an error")
+			deploymentSpec, deploymentStatus = getProvider(env, provider)
+			Expect(deploymentStatus.Phase).To(Equal(phaseReady), "Phase should be ready")
+			Expect(isInitialized(deploymentStatus)).To(BeTrue(), "Provider should be initialized")
+			Expect(isProviderInstalledAndReady(deploymentStatus)).To(BeTrue(), "Provider should be ready")
+
+			// delete the provider
+			Expect(env.Client().Delete(env.Ctx, provider)).To(Succeed(), "Provider deletion should succeed")
+			env.ShouldReconcile(req, "Reconcile after provider deletion should not return an error")
+		}
+
+		It("should reconcile a cluster provider", func() {
+			env := buildTestEnvironment("test-01", v1alpha1.ClusterProviderGKV())
+			req := testutils.RequestFromStrings("cluster-provider-test-01")
+			reconcileProvider(env, req, v1alpha1.ClusterProviderGKV())
+		})
+
+		It("should reconcile a service provider", func() {
+			env := buildTestEnvironment("test-02", v1alpha1.ServiceProviderGKV())
+			req := testutils.RequestFromStrings("service-provider-test-02")
+			reconcileProvider(env, req, v1alpha1.ServiceProviderGKV())
+		})
+
+		It("should reconcile a platform service", func() {
+			env := buildTestEnvironment("test-03", v1alpha1.PlatformServiceGKV())
+			req := testutils.RequestFromStrings("platform-service-test-03")
+			reconcileProvider(env, req, v1alpha1.PlatformServiceGKV())
+		})
+
+	})
+
 	Context("Converter", func() {
 
+		It("should convert a deploymentSpec into an unstructured and back", func() {
+			spec := &v1alpha1.DeploymentSpec{
+				Image: "test-image:v0.1.0",
+				ImagePullSecrets: []v1alpha1.ObjectReference{
+					{Name: "test-secret-1"},
+					{Name: "test-secret-2"},
+				},
+			}
+
+			provider := &unstructured.Unstructured{}
+			provider.Object = map[string]interface{}{}
+			Expect(DeploymentSpecIntoUnstructured(spec, provider)).To(Succeed())
+
+			spec2, err := DeploymentSpecFromUnstructured(provider)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(spec2).To(Equal(spec2))
+
+			provider2 := &unstructured.Unstructured{}
+			provider2.Object = map[string]interface{}{}
+			Expect(DeploymentSpecIntoUnstructured(spec2, provider2)).To(Succeed())
+			Expect(provider2.Object).To(Equal(provider.Object))
+		})
+
 		It("should convert a deploymentStatus into an unstructured and back", func() {
-			originalStatus := &v1alpha1.DeploymentStatus{
+			status := &v1alpha1.DeploymentStatus{
 				Conditions:         nil,
 				ObservedGeneration: 6,
 				Phase:              phaseProgressing,
 			}
-			r := &ProviderReconciler{}
+
 			provider := &unstructured.Unstructured{}
 			provider.Object = map[string]interface{}{}
-			err := r.deploymentStatusIntoUnstructured(originalStatus, provider)
-			Expect(err).NotTo(HaveOccurred())
-			status, err := r.deploymentStatusFromUnstructured(provider)
+			Expect(DeploymentStatusIntoUnstructured(status, provider)).To(Succeed())
+
+			status2, err := DeploymentStatusFromUnstructured(provider)
 			Expect(err).NotTo(HaveOccurred())
-			Expect(status).To(Equal(originalStatus))
+			Expect(status2).To(Equal(status))
+
+			provider2 := &unstructured.Unstructured{}
+			provider2.Object = map[string]interface{}{}
+			Expect(DeploymentStatusIntoUnstructured(status2, provider2)).To(Succeed())
+			Expect(provider2.Object).To(Equal(provider.Object))
 		})
 	})
 })