Skip to content

Commit

Permalink
controllers/capi2argo_reconciler_test: move to ginkgo/v2
Browse files Browse the repository at this point in the history 
Move the controller test cases from unit tests to controller tests
  • Loading branch information
Felix Wischke (65278) committed Aug 19, 2024
1 parent ccbcef7 commit c3ec600
Show file tree
Hide file tree
Showing 4 changed files with 190 additions and 188 deletions.
187 changes: 49 additions & 138 deletions controllers/capi2argo_reconciler_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2,139 +2,75 @@ package controllers

import (
"context"
"github.com/onsi/ginkgo"
"github.com/onsi/gomega"
"fmt"
. "github.com/onsi/ginkgo/v2"
. "github.com/onsi/gomega"
"github.com/stretchr/testify/assert"
corev1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/api/errors"
"k8s.io/apimachinery/pkg/types"
"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"
logf "sigs.k8s.io/controller-runtime/pkg/log"
"sigs.k8s.io/controller-runtime/pkg/log/zap"
"sigs.k8s.io/controller-runtime/pkg/reconcile"
"testing"
"time"
)

var (
Cfg *rest.Config
K8sClient client.Client
TestEnv *envtest.Environment
Ctx context.Context
Cancel context.CancelFunc
C2A *Capi2Argo
TestLog = ctrl.Log.WithName("test")
TestNamespace = "test"
)
var _ = Describe("Capi2ArgoReconciler", func() {
var ctxm context.Context
BeforeEach(func() {
C2A = &Capi2Argo{
Client: K8sClient,
Log: TestLog,
Scheme: TestEnv.Scheme,
}
ctxm = context.Background()
})
AfterEach(func() {})

func TestControllers(t *testing.T) {
gomega.RegisterFailHandler(ginkgo.Fail)
ginkgo.RunSpecs(t, "Capi2ArgoClusterOperator Controller Suite")
}
Context("Reconcile capi secrets with argocd", func() {
It("should process valid kubeconfig", func() {
argoSecretLookUp := types.NamespacedName{Name: "cluster-valid", Namespace: ArgoNamespace}
argoCluster := &corev1.Secret{}

var _ = ginkgo.BeforeSuite(func() {
ginkgo.By("bootstrapping test environment")
logf.SetLogger(zap.New(zap.WriteTo(ginkgo.GinkgoWriter), zap.UseDevMode(true)))
err := K8sClient.Get(ctxm, argoSecretLookUp, argoCluster)
Expect(errors.IsNotFound(err)).To(BeTrue())

TestEnv = &envtest.Environment{}
Cfg, err := TestEnv.Start()
gomega.Expect(err).NotTo(gomega.HaveOccurred())
gomega.Expect(Cfg).NotTo(gomega.BeNil())
By("Calling Reconcile")
_, err = C2A.Reconcile(ctxm, MockReconcileReq("valid-kubeconfig", TestNamespace))
Expect(err).To(BeNil())

//+kubebuilder:scaffold:scheme
K8sManager, err := ctrl.NewManager(Cfg, ctrl.Options{
// Host: "0.0.0.0",
Scheme: scheme.Scheme,
})
gomega.Expect(err).ToNot(gomega.HaveOccurred())

C2A = &Capi2Argo{
Client: K8sManager.GetClient(),
Log: TestLog,
Scheme: K8sManager.GetScheme(),
}
err = C2A.SetupWithManager(K8sManager)
gomega.Expect(err).ToNot(gomega.HaveOccurred())
err = K8sClient.Get(ctxm, argoSecretLookUp, argoCluster)
Expect(err).To(BeNil())
})

Ctx, Cancel = context.WithCancel(context.TODO())
go func() {
defer ginkgo.GinkgoRecover()
err = K8sManager.Start(Ctx)
gomega.Expect(err).ToNot(gomega.HaveOccurred(), "failed to run manager")
}()
It("should process already existing argo secret", func() {
argoSecretLookUp := types.NamespacedName{Name: "cluster-valid", Namespace: ArgoNamespace}
argoCluster, argoCluster2 := &corev1.Secret{}, &corev1.Secret{}

K8sClient = K8sManager.GetClient()
gomega.Expect(K8sClient).ToNot(gomega.BeNil())
err := K8sClient.Get(ctxm, argoSecretLookUp, argoCluster)
Expect(err).To(BeNil())

}, 60)
By("Calling Reconcile")
_, err = C2A.Reconcile(ctxm, MockReconcileReq("valid-kubeconfig", TestNamespace))
Expect(err).To(BeNil())

var _ = ginkgo.AfterSuite(func() {})
err = K8sClient.Get(ctxm, argoSecretLookUp, argoCluster2)
Expect(err).To(BeNil())

func TestReconcile(t *testing.T) {
t.Parallel()
err := MockReconcileEnv()
assert.Nil(t, err)
Expect(argoCluster.ObjectMeta.ResourceVersion).To(Equal(argoCluster2.ObjectMeta.ResourceVersion))
})

tests := []struct {
testName string
testMock reconcile.Request
testExpectedError bool
testExpectedValues map[string]string
}{
{"process valid secret", MockReconcileReq("valid-kubeconfig", TestNamespace), false,
map[string]string{
"ErrorMsg": "none",
},
},
{"process existing valid secret", MockReconcileReq("cluster-test", ArgoNamespace), false,
map[string]string{
"ErrorMsg": "none",
},
},
{"process secret with wrong Data[key]", MockReconcileReq("err-key-kubeconfig", TestNamespace), true,
map[string]string{
"ErrorMsg": "wrong secret key",
},
},
{"process secret with wrong Type", MockReconcileReq("err-type-kubeconfig", TestNamespace), true,
map[string]string{
"ErrorMsg": "wrong secret type",
},
},
}
for _, tt := range tests {
tt := tt
t.Run(tt.testName, func(t *testing.T) {
t.Parallel()
ctxm := context.Background()
r, err := C2A.Reconcile(ctxm, tt.testMock)
if !tt.testExpectedError {
assert.NotNil(t, r)
assert.Nil(t, err)
if tt.testExpectedValues != nil {
assert.Nil(t, err)
}
} else {
assert.NotNil(t, err)
if assert.Error(t, err) {
assert.Equal(t, tt.testExpectedValues["ErrorMsg"], err.Error())
}
}
It("should not process secret with wrong Data[key]", func() {
By("Calling Reconcile")
_, err := C2A.Reconcile(ctxm, MockReconcileReq("err-key-kubeconfig", TestNamespace))
Expect(fmt.Sprint(err)).To(Equal("wrong secret key"))
})
}

t.Cleanup(func() {
time.Sleep(5 * time.Second)
Cancel()
ginkgo.By("tearing down the test environment")
err = TestEnv.Stop()
gomega.Expect(err).NotTo(gomega.HaveOccurred())
It("should not process secret with wrong Type", func() {
By("Calling Reconcile")
_, err := C2A.Reconcile(ctxm, MockReconcileReq("err-type-kubeconfig", TestNamespace))
Expect(fmt.Sprint(err)).To(Equal("wrong secret type"))
})
})
}
})

func TestValidateObjectOwner(t *testing.T) {
var o corev1.Secret
Expand All @@ -161,28 +97,3 @@ func MockReconcileReq(name string, namespace string) reconcile.Request {
}
return r
}

func MockReconcileEnv() error {
ns := &corev1.Namespace{ObjectMeta: metav1.ObjectMeta{Name: TestNamespace}}
if err := K8sClient.Create(context.Background(), ns); err != nil {
return err
}

ns = &corev1.Namespace{ObjectMeta: metav1.ObjectMeta{Name: ArgoNamespace}}
if err := K8sClient.Create(context.Background(), ns); err != nil {
return err
}

validMock := true
validType := true
validKey := true
if err := K8sClient.Create(context.Background(), MockCapiSecret(validMock, validType, validKey, "valid-kubeconfig", TestNamespace)); err != nil {
return err
}

if err := K8sClient.Create(context.Background(), MockCapiSecret(validMock, !validType, validKey, "err-type-kubeconfig", TestNamespace)); err != nil {
return err
}

return K8sClient.Create(context.Background(), MockCapiSecret(validMock, validType, !validKey, "err-key-kubeconfig", TestNamespace))
}
131 changes: 131 additions & 0 deletions controllers/suite_test.go
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,131 @@
package controllers

import (
"context"
. "github.com/onsi/ginkgo/v2"
. "github.com/onsi/gomega"
"golang.org/x/tools/go/packages"
corev1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime"
utilruntime "k8s.io/apimachinery/pkg/util/runtime"
clientgoscheme "k8s.io/client-go/kubernetes/scheme"
"k8s.io/client-go/rest"
"path/filepath"
clusterv1 "sigs.k8s.io/cluster-api/api/v1beta1"
ctrl "sigs.k8s.io/controller-runtime"
"sigs.k8s.io/controller-runtime/pkg/client"
"sigs.k8s.io/controller-runtime/pkg/envtest"
logf "sigs.k8s.io/controller-runtime/pkg/log"
"sigs.k8s.io/controller-runtime/pkg/log/zap"
"testing"
// "time"
)

var (
Cfg *rest.Config
K8sClient client.Client
TestEnv *envtest.Environment
Ctx context.Context
Cancel context.CancelFunc
C2A *Capi2Argo
TestLog = ctrl.Log.WithName("test")
TestNamespace = "test"
)

func TestControllers(t *testing.T) {
RegisterFailHandler(Fail)
RunSpecs(t, "Capi2ArgoClusterOperator Controller Suite")
}

var _ = BeforeSuite(func() {
By("bootstrapping test environment")
logf.SetLogger(zap.New(zap.WriteTo(GinkgoWriter), zap.UseDevMode(true)))

scheme := runtime.NewScheme()
utilruntime.Must(clusterv1.AddToScheme(scheme))
utilruntime.Must(clientgoscheme.AddToScheme(scheme))
config := &packages.Config{
Mode: packages.NeedModule,
}

clusterAPIPkgs, err := packages.Load(config, "sigs.k8s.io/cluster-api")
Expect(err).NotTo(HaveOccurred())
if clusterAPIPkgs[0].Errors != nil {
packages.PrintErrors(clusterAPIPkgs)
}
clusterAPIDir := clusterAPIPkgs[0].Module.Dir

crdsPaths := []string{
filepath.Join(clusterAPIDir, "config", "crd", "bases"),
filepath.Join("config", "crd", "bases"),
}
TestEnv = &envtest.Environment{
Scheme: scheme,
CRDDirectoryPaths: crdsPaths,
}
Cfg, err := TestEnv.Start()
Expect(err).NotTo(HaveOccurred())
Expect(Cfg).NotTo(BeNil())

//+kubebuilder:scaffold:scheme
K8sManager, err := ctrl.NewManager(Cfg, ctrl.Options{
// Host: "0.0.0.0",
Scheme: scheme,
})
Expect(err).ToNot(HaveOccurred())

C2A = &Capi2Argo{
Client: K8sManager.GetClient(),
Log: TestLog,
Scheme: K8sManager.GetScheme(),
}
err = C2A.SetupWithManager(K8sManager)
Expect(err).ToNot(HaveOccurred())

Ctx, Cancel = context.WithCancel(context.TODO())
go func() {
defer GinkgoRecover()
err = K8sManager.Start(Ctx)
Expect(err).ToNot(HaveOccurred(), "failed to run manager")
}()

K8sClient = K8sManager.GetClient()
Expect(K8sClient).ToNot(BeNil())

err = MockReconcileEnv()
Expect(err).ToNot(HaveOccurred())

})

var _ = AfterSuite(func() {
// Stop the controller context
Cancel()
err := TestEnv.Stop()
Expect(err).ToNot(HaveOccurred())
})

func MockReconcileEnv() error {
ns := &corev1.Namespace{ObjectMeta: metav1.ObjectMeta{Name: TestNamespace}}
if err := K8sClient.Create(context.Background(), ns); err != nil {
return err
}

ns = &corev1.Namespace{ObjectMeta: metav1.ObjectMeta{Name: ArgoNamespace}}
if err := K8sClient.Create(context.Background(), ns); err != nil {
return err
}

validMock := true
validType := true
validKey := true
if err := K8sClient.Create(context.Background(), MockCapiSecret(validMock, validType, validKey, "valid-kubeconfig", TestNamespace)); err != nil {
return err
}

if err := K8sClient.Create(context.Background(), MockCapiSecret(validMock, !validType, validKey, "err-type-kubeconfig", TestNamespace)); err != nil {
return err
}

return K8sClient.Create(context.Background(), MockCapiSecret(validMock, validType, !validKey, "err-key-kubeconfig", TestNamespace))
}
Loading

0 comments on commit c3ec600

Please sign in to comment.