controllers/backupconfiguration_controller_test.go

@@ -2,174 +2,20 @@ package controllers
 
 import (
 	"context"
-	//"k8s.io/apimachinery/pkg/types"
+	"reflect"
-	//"reflect"
+	"time"
-	//"fmt"
-	//"time"
 
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
-	//batchv1 "k8s.io/api/batch/v1"
+	batchv1 "k8s.io/api/batch/v1"
-	formolv1alpha1 "github.com/desmo999r/formol/api/v1alpha1"
-	appsv1 "k8s.io/api/apps/v1"
 	batchv1beta1 "k8s.io/api/batch/v1beta1"
-	corev1 "k8s.io/api/core/v1"
+	v1 "k8s.io/api/core/v1"
-	//"k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/types"
+
+	formolv1alpha1 "github.com/desmo999r/formol/api/v1alpha1"
 )
 
-var _ = Describe("Testing BackupConf controller", func() {
+var _ = Describe("BackupConfiguration controller", func() {
-	const (
-		BackupConfName = "test-backupconf"
-	)
-	var (
-		key = types.NamespacedName{
-			Name:      BackupConfName,
-			Namespace: TestNamespace,
-		}
-		ctx        = context.Background()
-		backupConf = &formolv1alpha1.BackupConfiguration{}
-	)
-
-	BeforeEach(func() {
-		backupConf = &formolv1alpha1.BackupConfiguration{
-			ObjectMeta: metav1.ObjectMeta{
-				Name:      BackupConfName,
-				Namespace: TestNamespace,
-			},
-			Spec: formolv1alpha1.BackupConfigurationSpec{
-				Repository: RepoName,
-				Schedule:   "1 * * * *",
-				Targets: []formolv1alpha1.Target{
-					formolv1alpha1.Target{
-						Kind: "Deployment",
-						Name: DeploymentName,
-					},
-					formolv1alpha1.Target{
-						Kind: "Task",
-						Name: BackupFuncName,
-						Steps: []formolv1alpha1.Step{
-							formolv1alpha1.Step{
-								Name:      BackupFuncName,
-								Namespace: TestNamespace,
-								Env: []corev1.EnvVar{
-									corev1.EnvVar{
-										Name:  "foo",
-										Value: "bar",
-									},
-								},
-							},
-						},
-					},
-				},
-			},
-		}
-	})
-	Context("There is a backupconf", func() {
-		JustBeforeEach(func() {
-			Eventually(func() error {
-				return k8sClient.Create(ctx, backupConf)
-			}, timeout, interval).Should(Succeed())
-		})
-		AfterEach(func() {
-			Expect(k8sClient.Delete(ctx, backupConf)).Should(Succeed())
-		})
-		It("Has a schedule", func() {
-			realBackupConf := &formolv1alpha1.BackupConfiguration{}
-			Eventually(func() bool {
-				err := k8sClient.Get(ctx, key, realBackupConf)
-				if err != nil {
-					return false
-				}
-				return true
-			}, timeout, interval).Should(BeTrue())
-			Expect(realBackupConf.Spec.Schedule).Should(Equal("1 * * * *"))
-		})
-		It("Should also create a CronJob", func() {
-			cronJob := &batchv1beta1.CronJob{}
-			Eventually(func() bool {
-				err := k8sClient.Get(ctx, types.NamespacedName{
-					Name:      "backup-" + BackupConfName,
-					Namespace: TestNamespace,
-				}, cronJob)
-				if err != nil {
-					return false
-				}
-				return true
-			}, timeout, interval).Should(BeTrue())
-			Expect(cronJob.Spec.Schedule).Should(Equal("1 * * * *"))
-		})
-		It("Should also create a sidecar container", func() {
-			realDeployment := &appsv1.Deployment{}
-			Eventually(func() (int, error) {
-				err := k8sClient.Get(ctx, types.NamespacedName{
-					Name:      DeploymentName,
-					Namespace: TestNamespace,
-				}, realDeployment)
-				if err != nil {
-					return 0, err
-				}
-				return len(realDeployment.Spec.Template.Spec.Containers), nil
-			}, timeout, interval).Should(Equal(2))
-		})
-		It("Should also update the CronJob", func() {
-			realBackupConf := &formolv1alpha1.BackupConfiguration{}
-			Eventually(func() bool {
-				err := k8sClient.Get(ctx, key, realBackupConf)
-				if err != nil {
-					return false
-				}
-				return true
-			}, timeout, interval).Should(BeTrue())
-			realBackupConf.Spec.Schedule = "1 0 * * *"
-			suspend := true
-			realBackupConf.Spec.Suspend = &suspend
-			Expect(k8sClient.Update(ctx, realBackupConf)).Should(Succeed())
-			cronJob := &batchv1beta1.CronJob{}
-			Eventually(func() (string, error) {
-				err := k8sClient.Get(ctx, types.NamespacedName{
-					Name:      "backup-" + BackupConfName,
-					Namespace: TestNamespace,
-				}, cronJob)
-				if err != nil {
-					return "", err
-				}
-				return cronJob.Spec.Schedule, nil
-			}, timeout, interval).Should(Equal("1 0 * * *"))
-			Eventually(func() (bool, error) {
-				err := k8sClient.Get(ctx, types.NamespacedName{
-					Name:      "backup-" + BackupConfName,
-					Namespace: TestNamespace,
-				}, cronJob)
-				if err != nil {
-					return false, err
-				}
-				return *cronJob.Spec.Suspend == true, nil
-			}, timeout, interval).Should(BeTrue())
-		})
-	})
-	Context("Deleting a backupconf", func() {
-		JustBeforeEach(func() {
-			Eventually(func() error {
-				return k8sClient.Create(ctx, backupConf)
-			}, timeout, interval).Should(Succeed())
-		})
-		It("Should also delete the sidecar container", func() {
-			Expect(k8sClient.Delete(ctx, backupConf)).Should(Succeed())
-			realDeployment := &appsv1.Deployment{}
-			Eventually(func() (int, error) {
-				err := k8sClient.Get(ctx, types.NamespacedName{
-					Name:      DeploymentName,
-					Namespace: TestNamespace,
-				}, realDeployment)
-				if err != nil {
-					return 0, err
-				}
-				return len(realDeployment.Spec.Template.Spec.Containers), nil
-			}, timeout, interval).Should(Equal(1))
-
-		})
-	})
 
 })

controllers/suite_test.go

@@ -17,120 +17,31 @@ limitations under the License.
 package controllers
 
 import (
-	"context"
-	"fmt"
 	"path/filepath"
 	"testing"
-	"time"
 
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
-	appsv1 "k8s.io/api/apps/v1"
-	corev1 "k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/client-go/kubernetes/scheme"
 	"k8s.io/client-go/rest"
-	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/envtest"
 	"sigs.k8s.io/controller-runtime/pkg/envtest/printer"
 	logf "sigs.k8s.io/controller-runtime/pkg/log"
 	"sigs.k8s.io/controller-runtime/pkg/log/zap"
 
+	formoldesmojimfrv1alpha1 "github.com/desmo999r/formol/api/v1alpha1"
 	formolv1alpha1 "github.com/desmo999r/formol/api/v1alpha1"
 	// +kubebuilder:scaffold:imports
 )
 
 // These tests use Ginkgo (BDD-style Go testing framework). Refer to
 // http://onsi.github.io/ginkgo/ to learn more about Ginkgo.
-const (
-	BackupFuncName = "test-backup-func"
-	TestNamespace  = "test-namespace"
-	RepoName       = "test-repo"
-	DeploymentName = "test-deployment"
-	timeout        = time.Second * 10
-	interval       = time.Millisecond * 250
-)
 
 var cfg *rest.Config
 var k8sClient client.Client
 var testEnv *envtest.Environment
 
-var (
-	namespace = &corev1.Namespace{
-		ObjectMeta: metav1.ObjectMeta{
-			Name: TestNamespace,
-		},
-	}
-	deployment = &appsv1.Deployment{
-		ObjectMeta: metav1.ObjectMeta{
-			Name:      DeploymentName,
-			Namespace: TestNamespace,
-		},
-		Spec: appsv1.DeploymentSpec{
-			Selector: &metav1.LabelSelector{
-				MatchLabels: map[string]string{"app": "test-deployment"},
-			},
-			Template: corev1.PodTemplateSpec{
-				ObjectMeta: metav1.ObjectMeta{
-					Labels: map[string]string{"app": "test-deployment"},
-				},
-				Spec: corev1.PodSpec{
-					Containers: []corev1.Container{
-						corev1.Container{
-							Name:  "test-container",
-							Image: "test-image",
-						},
-					},
-				},
-			},
-		},
-	}
-	sa = &corev1.ServiceAccount{
-		ObjectMeta: metav1.ObjectMeta{
-			Name:      "default",
-			Namespace: TestNamespace,
-		},
-	}
-	secret = &corev1.Secret{
-		ObjectMeta: metav1.ObjectMeta{
-			Name:      "test-secret",
-			Namespace: TestNamespace,
-		},
-		Data: map[string][]byte{
-			"RESTIC_PASSWORD":       []byte("toto"),
-			"AWS_ACCESS_KEY_ID":     []byte("titi"),
-			"AWS_SECRET_ACCESS_KEY": []byte("tata"),
-		},
-	}
-	repo = &formolv1alpha1.Repo{
-		ObjectMeta: metav1.ObjectMeta{
-			Name:      RepoName,
-			Namespace: TestNamespace,
-		},
-		Spec: formolv1alpha1.RepoSpec{
-			Backend: formolv1alpha1.Backend{
-				S3: formolv1alpha1.S3{
-					Server: "raid5.desmojim.fr:9000",
-					Bucket: "testbucket2",
-				},
-			},
-			RepositorySecrets: "test-secret",
-		},
-	}
-	function = &formolv1alpha1.Function{
-		ObjectMeta: metav1.ObjectMeta{
-			Name:      BackupFuncName,
-			Namespace: TestNamespace,
-		},
-		Spec: corev1.Container{
-			Name:  "backup-func",
-			Image: "myimage",
-			Args:  []string{"a", "set", "of", "args"},
-		},
-	}
-)
-
 func TestAPIs(t *testing.T) {
 	RegisterFailHandler(Fail)
 
@@ -139,54 +50,39 @@ func TestAPIs(t *testing.T) {
 		[]Reporter{printer.NewlineReporter{}})
 }
 
-var _ = BeforeSuite(func() {
+var _ = BeforeSuite(func(done Done) {
-	logf.SetLogger(zap.New(zap.WriteTo(GinkgoWriter), zap.UseDevMode(true)))
+	logf.SetLogger(zap.LoggerTo(GinkgoWriter, true))
 
 	By("bootstrapping test environment")
 	testEnv = &envtest.Environment{
 		CRDDirectoryPaths: []string{filepath.Join("..", "config", "crd", "bases")},
 	}
 
-	cfg, err := testEnv.Start()
+	var err error
+	cfg, err = testEnv.Start()
 	Expect(err).ToNot(HaveOccurred())
 	Expect(cfg).ToNot(BeNil())
 
 	err = formolv1alpha1.AddToScheme(scheme.Scheme)
 	Expect(err).NotTo(HaveOccurred())
 
+	err = formolv1alpha1.AddToScheme(scheme.Scheme)
+	Expect(err).NotTo(HaveOccurred())
+
+	err = formoldesmojimfrv1alpha1.AddToScheme(scheme.Scheme)
+	Expect(err).NotTo(HaveOccurred())
+
 	// +kubebuilder:scaffold:scheme
 
-	k8sManager, err := ctrl.NewManager(cfg, ctrl.Options{
+	k8sClient, err = client.New(cfg, client.Options{Scheme: scheme.Scheme})
-		Scheme: scheme.Scheme,
-	})
 	Expect(err).ToNot(HaveOccurred())
-
-	err = (&BackupConfigurationReconciler{
-		Client: k8sManager.GetClient(),
-		Scheme: k8sManager.GetScheme(),
-		Log:    ctrl.Log.WithName("controllers").WithName("BackupConfiguration"),
-	}).SetupWithManager(k8sManager)
-	Expect(err).ToNot(HaveOccurred())
-
-	go func() {
-		err = k8sManager.Start(ctrl.SetupSignalHandler())
-		Expect(err).ToNot(HaveOccurred())
-	}()
-
-	k8sClient = k8sManager.GetClient()
-	ctx := context.Background()
 	Expect(k8sClient).ToNot(BeNil())
-	Expect(k8sClient.Create(ctx, namespace)).Should(Succeed())
+
-	Expect(k8sClient.Create(ctx, sa)).Should(Succeed())
+	close(done)
-	Expect(k8sClient.Create(ctx, secret)).Should(Succeed())
-	Expect(k8sClient.Create(ctx, repo)).Should(Succeed())
-	Expect(k8sClient.Create(ctx, deployment)).Should(Succeed())
-	Expect(k8sClient.Create(ctx, function)).Should(Succeed())
 }, 60)
 
 var _ = AfterSuite(func() {
 	By("tearing down the test environment")
 	err := testEnv.Stop()
 	Expect(err).ToNot(HaveOccurred())
-	fmt.Println("coucou")
 })