AutoEnroll feature tests

operators/pkg/tenant-controller/autoenroll_test.go

@@ -0,0 +1,130 @@
+// Copyright 2020-2024 Politecnico di Torino
+//
+// 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 tenant_controller_test
+
+import (
+	"context"
+	"time"
+
+	"github.com/go-logr/logr"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+	gomegaTypes "github.com/onsi/gomega/types"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/client-go/kubernetes/scheme"
+	ctrl "sigs.k8s.io/controller-runtime"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+	"sigs.k8s.io/controller-runtime/pkg/client/fake"
+	"sigs.k8s.io/controller-runtime/pkg/reconcile"
+
+	clv1alpha1 "github.com/netgroup-polito/CrownLabs/operators/api/v1alpha1"
+	clv1alpha2 "github.com/netgroup-polito/CrownLabs/operators/api/v1alpha2"
+	tntctrl "github.com/netgroup-polito/CrownLabs/operators/pkg/tenant-controller"
+)
+
+var _ = Describe("Workspace AutoEnroll Update", func() {
+	var (
+		ctx          context.Context
+		builder      fake.ClientBuilder
+		cl           client.Client
+		tnReconciler tntctrl.TenantReconciler
+		wsReconciler tntctrl.WorkspaceReconciler
+		tenant       clv1alpha2.Tenant
+		workspace    clv1alpha1.Workspace
+	)
+
+	const (
+		tenantName    = "tester"
+		workspaceName = "foo"
+
+		labelkey   = "crownlabs.polito.it/operator-selector"
+		labelvalue = "autoenroll-test"
+	)
+
+	BeforeEach(func() {
+		ctx = ctrl.LoggerInto(context.Background(), logr.Discard())
+		builder = *fake.NewClientBuilder().WithScheme(scheme.Scheme)
+
+		workspace = clv1alpha1.Workspace{ObjectMeta: metav1.ObjectMeta{Name: workspaceName}}
+		workspace.Spec.AutoEnroll = clv1alpha1.AutoenrollWithApproval
+		tenant = clv1alpha2.Tenant{
+			ObjectMeta: metav1.ObjectMeta{Name: tenantName},
+			Spec: clv1alpha2.TenantSpec{
+				FirstName: "mario",
+				LastName:  "rossi",
+				Email:     "[email protected]",
+			},
+		}
+		tenant.Labels = map[string]string{labelkey: labelvalue}
+		workspace.Labels = map[string]string{labelkey: labelvalue}
+		tenant.Spec.Workspaces = []clv1alpha2.TenantWorkspaceEntry{{Name: workspaceName, Role: clv1alpha2.Candidate}}
+	})
+
+	JustBeforeEach(func() {
+		cl = builder.WithObjects(&tenant, &workspace).Build()
+		tnReconciler = tntctrl.TenantReconciler{
+			Client: cl, Scheme: scheme.Scheme,
+			TargetLabelKey: labelkey, TargetLabelValue: labelvalue,
+		}
+		wsReconciler = tntctrl.WorkspaceReconciler{
+			Client: cl, Scheme: scheme.Scheme,
+			TargetLabelKey: labelkey, TargetLabelValue: labelvalue,
+		}
+		_, err := tnReconciler.Reconcile(ctx, reconcile.Request{NamespacedName: types.NamespacedName{Name: tenant.Name}})
+		Expect(err).ToNot(HaveOccurred())
+
+	})
+
+	When("the AutoEnroll has been set to Immediate", func() {
+		It("should update candidate tenants to user", func() {
+			By("Updating the workspace")
+			workspace.Spec.AutoEnroll = clv1alpha1.AutoenrollImmediate
+			err := cl.Update(ctx, &workspace)
+			Expect(err).ToNot(HaveOccurred())
+			_, err = wsReconciler.Reconcile(ctx, reconcile.Request{NamespacedName: types.NamespacedName{Name: workspace.Name}})
+			Expect(err).ToNot(HaveOccurred())
+
+			By("Checking that the tenant has been updated")
+			tn := clv1alpha2.Tenant{}
+			doesEventuallyExists(ctx, cl, client.ObjectKey{Name: tenantName}, &tn, BeTrue(), time.Second*10, time.Millisecond*250)
+
+			Expect(tn.Spec.Workspaces[0].Role).To(Equal(clv1alpha2.User))
+		})
+	})
+
+	When("the AutoEnroll has been set to None", func() {
+		It("should update user and remove workspace", func() {
+			By("Updating the workspace")
+			workspace.Spec.AutoEnroll = clv1alpha1.AutoenrollNone
+			err := cl.Update(ctx, &workspace)
+			Expect(err).ToNot(HaveOccurred())
+			_, err = wsReconciler.Reconcile(ctx, reconcile.Request{NamespacedName: types.NamespacedName{Name: workspace.Name}})
+			Expect(err).ToNot(HaveOccurred())
+
+			By("Checking that the tenant has been updated")
+			tn := clv1alpha2.Tenant{}
+			doesEventuallyExists(ctx, cl, client.ObjectKey{Name: tenantName}, &tn, BeTrue(), time.Second*10, time.Millisecond*250)
+			Expect(tn.Spec.Workspaces).To(BeEmpty())
+		})
+	})
+})
+
+func doesEventuallyExists(ctx context.Context, cl client.Client, objLookupKey client.ObjectKey, targetObj client.Object, expectedStatus gomegaTypes.GomegaMatcher, timeout, interval time.Duration) {
+	Eventually(func() bool {
+		err := cl.Get(ctx, objLookupKey, targetObj)
+		return err == nil
+	}, timeout, interval).Should(expectedStatus)
+}

operators/pkg/tenantwh/tenantwh_suite_test.go

@@ -25,6 +25,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	"sigs.k8s.io/controller-runtime/pkg/webhook/admission"
 
+	clv1alpha1 "github.com/netgroup-polito/CrownLabs/operators/api/v1alpha1"
 	clv1alpha2 "github.com/netgroup-polito/CrownLabs/operators/api/v1alpha2"
 )
 
@@ -40,6 +41,7 @@ var (
 
 var _ = BeforeSuite(func() {
 	scheme = runtime.NewScheme()
+	Expect(clv1alpha1.AddToScheme(scheme)).To(Succeed())
 	Expect(clv1alpha2.AddToScheme(scheme)).To(Succeed())
 	var err error
 	decoder, err = admission.NewDecoder(scheme)

operators/pkg/tenantwh/validating_test.go

@@ -25,27 +25,39 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/client/fake"
 	"sigs.k8s.io/controller-runtime/pkg/webhook/admission"
 
+	clv1alpha1 "github.com/netgroup-polito/CrownLabs/operators/api/v1alpha1"
 	clv1alpha2 "github.com/netgroup-polito/CrownLabs/operators/api/v1alpha2"
 	"github.com/netgroup-polito/CrownLabs/operators/pkg/tenantwh"
 )
 
 var _ = Describe("Validating webhook", func() {
-	forgeTenantWithWorkspaceUser := func(wsName string) *clv1alpha2.Tenant {
+	forgeTenantWithWorkspace := func(ws clv1alpha2.TenantWorkspaceEntry) *clv1alpha2.Tenant {
 		return &clv1alpha2.Tenant{
 			Spec: clv1alpha2.TenantSpec{
-				Workspaces: []clv1alpha2.TenantWorkspaceEntry{{
-					Name: wsName,
-					Role: clv1alpha2.User,
-				}},
+				Workspaces: []clv1alpha2.TenantWorkspaceEntry{ws},
 			},
 		}
 	}
 
+	forgeTenantWithWorkspaceUser := func(wsName string) *clv1alpha2.Tenant {
+		return forgeTenantWithWorkspace(clv1alpha2.TenantWorkspaceEntry{
+			Name: wsName,
+			Role: clv1alpha2.User,
+		})
+	}
+
 	var (
 		validatingWH *tenantwh.TenantValidator
 		request      admission.Request
 		response     admission.Response
 		manager      *clv1alpha2.Tenant
+
+		workspaceWA     *clv1alpha1.Workspace
+		workspaceWAName = "test-workspace-withApproval"
+		workspaceNA     *clv1alpha1.Workspace
+		workspaceNAName = "test-workspace-noAutoenroll"
+		workspaceIM     *clv1alpha1.Workspace
+		workspaceIMName = "test-workspace-immediate"
 	)
 
 	BeforeEach(func() {
@@ -60,7 +72,44 @@ var _ = Describe("Validating webhook", func() {
 			},
 		}
 
-		fakeClient := fake.NewClientBuilder().WithScheme(scheme).WithObjects(manager).Build()
+		workspaceWA = &clv1alpha1.Workspace{
+			ObjectMeta: metav1.ObjectMeta{Name: workspaceWAName},
+			Spec: clv1alpha1.WorkspaceSpec{
+				PrettyName: "test-workspace",
+				Quota: clv1alpha1.WorkspaceResourceQuota{
+					Instances: 1,
+				},
+				AutoEnroll: clv1alpha1.AutoenrollWithApproval,
+			},
+		}
+
+		workspaceNA = &clv1alpha1.Workspace{
+			ObjectMeta: metav1.ObjectMeta{Name: workspaceNAName},
+			Spec: clv1alpha1.WorkspaceSpec{
+				PrettyName: "test-workspace",
+				Quota: clv1alpha1.WorkspaceResourceQuota{
+					Instances: 1,
+				},
+			},
+		}
+
+		workspaceIM = &clv1alpha1.Workspace{
+			ObjectMeta: metav1.ObjectMeta{Name: workspaceIMName},
+			Spec: clv1alpha1.WorkspaceSpec{
+				PrettyName: "test-workspace",
+				Quota: clv1alpha1.WorkspaceResourceQuota{
+					Instances: 1,
+				},
+				AutoEnroll: clv1alpha1.AutoenrollImmediate,
+			},
+		}
+
+		fakeClient := fake.NewClientBuilder().WithScheme(scheme).WithObjects(
+			manager,
+			workspaceWA,
+			workspaceNA,
+			workspaceIM,
+		).Build()
 
 		validatingWH = tenantwh.MakeTenantValidator(fakeClient, bypassGroups).Handler.(*tenantwh.TenantValidator)
 		Expect(validatingWH.InjectDecoder(decoder)).To(Succeed())
@@ -160,6 +209,68 @@ var _ = Describe("Validating webhook", func() {
 			})
 		})
 
+		Describe("a workspace is added", func() {
+			WhenBody := func(nt *clv1alpha2.Tenant, shouldSucceed bool) func() {
+				return func() {
+					BeforeEach(func() {
+						oldTenant = &clv1alpha2.Tenant{}
+						newTenant = nt
+					})
+
+					if shouldSucceed {
+						It("should allow the change", func() {
+							Expect(response.Allowed).To(BeTrue())
+						})
+					} else {
+						It("should deny the change", func() {
+							Expect(response.Allowed).To(BeFalse())
+							Expect(response.Result.Code).To(BeNumerically("==", http.StatusForbidden))
+							Expect(response.Result.Reason).ToNot(BeEmpty())
+						})
+					}
+				}
+			}
+
+			When("no autoenroll and user role", WhenBody(
+				forgeTenantWithWorkspaceUser(workspaceNAName),
+				false,
+			))
+
+			When("no autoenroll and candidate role", WhenBody(
+				forgeTenantWithWorkspace(clv1alpha2.TenantWorkspaceEntry{
+					Name: workspaceNAName,
+					Role: clv1alpha2.Candidate,
+				}),
+				false,
+			))
+
+			When("autoenroll withApproval and user role", WhenBody(
+				forgeTenantWithWorkspaceUser(workspaceWAName),
+				false,
+			))
+
+			When("autoenroll withApproval and candidate role", WhenBody(
+				forgeTenantWithWorkspace(clv1alpha2.TenantWorkspaceEntry{
+					Name: workspaceWAName,
+					Role: clv1alpha2.Candidate,
+				}),
+				true,
+			))
+
+			When("autoenroll immediate and user role", WhenBody(
+				forgeTenantWithWorkspaceUser(workspaceIMName),
+				true,
+			))
+
+			When("autoenroll immediate and candidate role", WhenBody(
+				forgeTenantWithWorkspace(clv1alpha2.TenantWorkspaceEntry{
+					Name: workspaceIMName,
+					Role: clv1alpha2.Candidate,
+				}),
+				false,
+			))
+		})
+
 		When("other fields are changed", func() {
 			BeforeEach(func() {
 				oldTenant = &clv1alpha2.Tenant{Spec: clv1alpha2.TenantSpec{LastName: "test"}}