Migrate Helm Chart to OSDK v1.3.0 (#551)

Migrate Helm Chart to OSDK v1.3.0

test/e2e/configuration_test.go

@@ -35,7 +35,7 @@ func createUserConfigurationSecret(namespace string, stringData map[string]strin
 	}
 
 	_, _ = fmt.Fprintf(GinkgoWriter, "User configuration secret %+v\n", *userConfiguration)
-	Expect(k8sClient.Create(context.TODO(), userConfiguration)).Should(Succeed())
+	Expect(K8sClient.Create(context.TODO(), userConfiguration)).Should(Succeed())
 }
 
 func createUserConfigurationConfigMap(namespace string, numberOfExecutorsSecretKeyName string, systemMessage string) {
@@ -63,7 +63,7 @@ unclassified:
 	}
 
 	_, _ = fmt.Fprintf(GinkgoWriter, "User configuration %+v\n", *userConfiguration)
-	Expect(k8sClient.Create(context.TODO(), userConfiguration)).Should(Succeed())
+	Expect(K8sClient.Create(context.TODO(), userConfiguration)).Should(Succeed())
 }
 
 func createDefaultLimitsForContainersInNamespace(namespace string) {
@@ -92,7 +92,7 @@ func createDefaultLimitsForContainersInNamespace(namespace string) {
 	}
 
 	_, _ = fmt.Fprintf(GinkgoWriter, "LimitRange %+v\n", *limitRange)
-	Expect(k8sClient.Create(context.TODO(), limitRange)).Should(Succeed())
+	Expect(K8sClient.Create(context.TODO(), limitRange)).Should(Succeed())
 }
 
 func verifyJenkinsMasterPodAttributes(jenkins *v1alpha2.Jenkins) {

test/e2e/helm_test.go

@@ -1,71 +0,0 @@
-// +build Helm
-
-package e2e
-
-// TODO
-/*
-import (
-	"fmt"
-	"os/exec"
-	"testing"
-
-	"github.com/jenkinsci/kubernetes-operator/pkg/apis"
-	"github.com/jenkinsci/kubernetes-operator/pkg/apis/jenkins/v1alpha2"
-
-	framework "github.com/operator-framework/operator-sdk/pkg/test"
-	"github.com/stretchr/testify/require"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-)
-
-func TestLintHelmChart(t *testing.T) {
-	t.Parallel()
-
-	cmd := exec.Command("helm", "lint", "./chart/jenkins-operator")
-	output, err := cmd.CombinedOutput()
-	require.NoError(t, err, string(output))
-}
-
-func TestDeployHelmChart(t *testing.T) {
-	// Given
-	t.Parallel()
-	ctx := framework.NewContext(t)
-	defer ctx.Cleanup()
-
-	namespace, err := ctx.GetNamespace()
-	require.NoError(t, err)
-
-	jenkinsServiceList := &v1alpha2.JenkinsList{
-		TypeMeta: metav1.TypeMeta{
-			Kind:       v1alpha2.Kind,
-			APIVersion: v1alpha2.SchemeGroupVersion.String(),
-		},
-	}
-	err = framework.AddToFrameworkScheme(apis.AddToScheme, jenkinsServiceList)
-	require.NoError(t, err)
-
-	jenkins := &v1alpha2.Jenkins{
-		TypeMeta: v1alpha2.JenkinsTypeMeta(),
-		ObjectMeta: metav1.ObjectMeta{
-			Name:      "jenkins",
-			Namespace: namespace,
-		},
-	}
-
-	cmd := exec.Command("helm", "upgrade", "jenkins", "./chart/jenkins-operator", "--namespace", namespace, "--debug",
-		"--set-string", fmt.Sprintf("jenkins.namespace=%s", namespace), "--install")
-	output, err := cmd.CombinedOutput()
-	require.NoError(t, err, string(output))
-
-	waitForJenkinsBaseConfigurationToComplete(t, jenkins)
-	waitForJenkinsUserConfigurationToComplete(t, jenkins)
-
-	cmd = exec.Command("helm", "upgrade", "jenkins", "./chart/jenkins-operator", "--namespace", namespace, "--debug",
-		"--set-string", fmt.Sprintf("jenkins.namespace=%s", namespace), "--install")
-	output, err = cmd.CombinedOutput()
-	require.NoError(t, err, string(output))
-
-	// Then
-	waitForJenkinsBaseConfigurationToComplete(t, jenkins)
-	waitForJenkinsUserConfigurationToComplete(t, jenkins)
-}
-*/

test/e2e/jenkins_configuration_test.go

@@ -73,7 +73,7 @@ var _ = Describe("Jenkins controller configuration", func() {
 	)
 
 	BeforeEach(func() {
-		namespace = createNamespace()
+		namespace = CreateNamespace()
 
 		createUserConfigurationSecret(namespace.Name, userConfigurationSecretData)
 		createUserConfigurationConfigMap(namespace.Name, numberOfExecutorsEnvName, fmt.Sprintf("${%s}", systemMessageEnvName))
@@ -83,18 +83,18 @@ var _ = Describe("Jenkins controller configuration", func() {
 	})
 
 	AfterEach(func() {
-		destroyNamespace(namespace)
+		DestroyNamespace(namespace)
 	})
 
 	Context("when deploying CR to cluster", func() {
 		It("creates Jenkins instance and configures it", func() {
-			waitForJenkinsBaseConfigurationToComplete(jenkins)
+			WaitForJenkinsBaseConfigurationToComplete(jenkins)
 			verifyJenkinsMasterPodAttributes(jenkins)
 			verifyServices(jenkins)
 			jenkinsClient, cleanUpFunc := verifyJenkinsAPIConnection(jenkins, namespace.Name)
 			defer cleanUpFunc()
 			verifyPlugins(jenkinsClient, jenkins)
-			waitForJenkinsUserConfigurationToComplete(jenkins)
+			WaitForJenkinsUserConfigurationToComplete(jenkins)
 			verifyUserConfiguration(jenkinsClient, numberOfExecutors, systemMessage)
 			verifyJenkinsSeedJobs(jenkinsClient, []seedJobConfig{mySeedJob})
 		})
@@ -124,17 +124,17 @@ var _ = Describe("Jenkins controller priority class", func() {
 	)
 
 	BeforeEach(func() {
-		namespace = createNamespace()
+		namespace = CreateNamespace()
 		jenkins = createJenkinsCR(jenkinsCRName, namespace.Name, nil, groovyScripts, casc, priorityClassName)
 	})
 
 	AfterEach(func() {
-		destroyNamespace(namespace)
+		DestroyNamespace(namespace)
 	})
 
 	Context("when deploying CR with priority class to cluster", func() {
 		It("creates Jenkins instance and configures it", func() {
-			waitForJenkinsBaseConfigurationToComplete(jenkins)
+			WaitForJenkinsBaseConfigurationToComplete(jenkins)
 			verifyJenkinsMasterPodAttributes(jenkins)
 		})
 	})
@@ -175,17 +175,17 @@ var _ = Describe("Jenkins controller plugins test", func() {
 	)
 
 	BeforeEach(func() {
-		namespace = createNamespace()
+		namespace = CreateNamespace()
 		jenkins = createJenkinsCR(jenkinsCRName, namespace.Name, &[]v1alpha2.SeedJob{mySeedJob.SeedJob}, groovyScripts, casc, priorityClassName)
 	})
 
 	AfterEach(func() {
-		destroyNamespace(namespace)
+		DestroyNamespace(namespace)
 	})
 
 	Context("when deploying CR with a SeedJob to cluster", func() {
 		It("runs kubernetes plugin job successfully", func() {
-			waitForJenkinsUserConfigurationToComplete(jenkins)
+			WaitForJenkinsUserConfigurationToComplete(jenkins)
 			jenkinsClient, cleanUpFunc := verifyJenkinsAPIConnection(jenkins, namespace.Name)
 			defer cleanUpFunc()
 			waitForJobCreation(jenkinsClient, jobID)

test/e2e/jenkins_pod_restart_test.go

@@ -32,23 +32,23 @@ var _ = Describe("Jenkins controller", func() {
 	)
 
 	BeforeEach(func() {
-		namespace = createNamespace()
+		namespace = CreateNamespace()
 
 		configureAuthorizationToUnSecure(namespace.Name, userConfigurationConfigMapName)
 		jenkins = createJenkinsCR(jenkinsCRName, namespace.Name, nil, groovyScripts, casc, priorityClassName)
 	})
 
 	AfterEach(func() {
-		destroyNamespace(namespace)
+		DestroyNamespace(namespace)
 	})
 
 	Context("when restarting Jenkins master pod", func() {
 		It("new Jenkins Master pod should be created", func() {
-			waitForJenkinsBaseConfigurationToComplete(jenkins)
+			WaitForJenkinsBaseConfigurationToComplete(jenkins)
 			restartJenkinsMasterPod(jenkins)
 			waitForRecreateJenkinsMasterPod(jenkins)
 			checkBaseConfigurationCompleteTimeIsNotSet(jenkins)
-			waitForJenkinsBaseConfigurationToComplete(jenkins)
+			WaitForJenkinsBaseConfigurationToComplete(jenkins)
 		})
 	})
 })
@@ -80,20 +80,20 @@ var _ = Describe("Jenkins controller", func() {
 	)
 
 	BeforeEach(func() {
-		namespace = createNamespace()
+		namespace = CreateNamespace()
 
 		configureAuthorizationToUnSecure(namespace.Name, userConfigurationConfigMapName)
 		jenkins = createJenkinsCRSafeRestart(jenkinsCRName, namespace.Name, nil, groovyScripts, casc, priorityClassName)
 	})
 
 	AfterEach(func() {
-		destroyNamespace(namespace)
+		DestroyNamespace(namespace)
 	})
 
 	Context("when running Jenkins safe restart", func() {
 		It("authorization strategy is not overwritten", func() {
-			waitForJenkinsBaseConfigurationToComplete(jenkins)
-			waitForJenkinsUserConfigurationToComplete(jenkins)
+			WaitForJenkinsBaseConfigurationToComplete(jenkins)
+			WaitForJenkinsUserConfigurationToComplete(jenkins)
 			jenkinsClient, cleanUpFunc := verifyJenkinsAPIConnection(jenkins, namespace.Name)
 			defer cleanUpFunc()
 			checkIfAuthorizationStrategyUnsecuredIsSet(jenkinsClient)

test/e2e/jenkins_restore_backup_test.go

@@ -21,19 +21,19 @@ var _ = Describe("Jenkins controller backup and restore", func() {
 	)
 
 	BeforeEach(func() {
-		namespace = createNamespace()
+		namespace = CreateNamespace()
 
 		createPVC(namespace.Name)
 		jenkins = createJenkinsWithBackupAndRestoreConfigured(jenkinsCRName, namespace.Name)
 	})
 
 	AfterEach(func() {
-		destroyNamespace(namespace)
+		DestroyNamespace(namespace)
 	})
 
 	Context("when deploying CR with backup enabled to cluster", func() {
 		It("performs backups before pod deletion and restores them even Jenkins status is restarted", func() {
-			waitForJenkinsUserConfigurationToComplete(jenkins)
+			WaitForJenkinsUserConfigurationToComplete(jenkins)
 			jenkinsClient, cleanUpFunc := verifyJenkinsAPIConnection(jenkins, namespace.Name)
 			defer cleanUpFunc()
 			waitForJobCreation(jenkinsClient, jobID)
@@ -42,7 +42,7 @@ var _ = Describe("Jenkins controller backup and restore", func() {
 			jenkins = getJenkins(jenkins.Namespace, jenkins.Name)
 			restartJenkinsMasterPod(jenkins)
 			waitForRecreateJenkinsMasterPod(jenkins)
-			waitForJenkinsUserConfigurationToComplete(jenkins)
+			WaitForJenkinsUserConfigurationToComplete(jenkins)
 			jenkinsClient2, cleanUpFunc2 := verifyJenkinsAPIConnection(jenkins, namespace.Name)
 			defer cleanUpFunc2()
 			waitForJobCreation(jenkinsClient2, jobID)
@@ -51,7 +51,7 @@ var _ = Describe("Jenkins controller backup and restore", func() {
 			resetJenkinsStatus(jenkins)
 			jenkins = getJenkins(jenkins.Namespace, jenkins.Name)
 			checkBaseConfigurationCompleteTimeIsNotSet(jenkins)
-			waitForJenkinsUserConfigurationToComplete(jenkins)
+			WaitForJenkinsUserConfigurationToComplete(jenkins)
 			jenkinsClient3, cleanUpFunc3 := verifyJenkinsAPIConnection(jenkins, namespace.Name)
 			defer cleanUpFunc3()
 			waitForJobCreation(jenkinsClient3, jobID)

test/e2e/jenkins_test.go

@@ -31,7 +31,7 @@ const (
 func getJenkins(namespace, name string) *v1alpha2.Jenkins {
 	jenkins := &v1alpha2.Jenkins{}
 	namespaceName := types.NamespacedName{Namespace: namespace, Name: name}
-	Expect(k8sClient.Get(context.TODO(), namespaceName, jenkins)).Should(Succeed())
+	Expect(K8sClient.Get(context.TODO(), namespaceName, jenkins)).Should(Succeed())
 	return jenkins
 }
 
@@ -41,7 +41,7 @@ func getJenkinsMasterPod(jenkins *v1alpha2.Jenkins) *corev1.Pod {
 		Namespace:     jenkins.Namespace,
 	}
 	pods := &corev1.PodList{}
-	Expect(k8sClient.List(context.TODO(), pods, lo)).Should(Succeed())
+	Expect(K8sClient.List(context.TODO(), pods, lo)).Should(Succeed())
 	Expect(pods.Items).Should(HaveLen(1), fmt.Sprintf("Jenkins pod not found, pod list: %+v", pods.Items))
 	return &pods.Items[0]
 }
@@ -147,7 +147,7 @@ func createJenkinsCR(name, namespace string, seedJob *[]v1alpha2.SeedJob, groovy
 
 	_, _ = fmt.Fprintf(GinkgoWriter, "Jenkins CR %+v\n", *jenkins)
 
-	Expect(k8sClient.Create(context.TODO(), jenkins)).Should(Succeed())
+	Expect(K8sClient.Create(context.TODO(), jenkins)).Should(Succeed())
 
 	return jenkins
 }
@@ -253,7 +253,7 @@ func createJenkinsCRSafeRestart(name, namespace string, seedJob *[]v1alpha2.Seed
 
 	_, _ = fmt.Fprintf(GinkgoWriter, "Jenkins CR %+v\n", *jenkins)
 
-	Expect(k8sClient.Create(context.TODO(), jenkins)).Should(Succeed())
+	Expect(K8sClient.Create(context.TODO(), jenkins)).Should(Succeed())
 
 	return jenkins
 }
@@ -261,11 +261,11 @@ func createJenkinsCRSafeRestart(name, namespace string, seedJob *[]v1alpha2.Seed
 func createJenkinsAPIClientFromServiceAccount(jenkins *v1alpha2.Jenkins, jenkinsAPIURL string) (jenkinsclient.Jenkins, error) {
 	podName := resources.GetJenkinsMasterPodName(jenkins)
 
-	clientSet, err := kubernetes.NewForConfig(cfg)
+	clientSet, err := kubernetes.NewForConfig(Cfg)
 	if err != nil {
 		return nil, err
 	}
-	config := configuration.Configuration{Jenkins: jenkins, ClientSet: *clientSet, Config: cfg}
+	config := configuration.Configuration{Jenkins: jenkins, ClientSet: *clientSet, Config: Cfg}
 	r := base.New(config, jenkinsclient.JenkinsAPIConnectionSettings{})
 
 	token, _, err := r.Configuration.Exec(podName, resources.JenkinsMasterContainerName, []string{"cat", "/var/run/secrets/kubernetes.io/serviceaccount/token"})
@@ -281,7 +281,7 @@ func createJenkinsAPIClientFromSecret(jenkins *v1alpha2.Jenkins, jenkinsAPIURL s
 
 	adminSecret := &corev1.Secret{}
 	namespaceName := types.NamespacedName{Namespace: jenkins.Namespace, Name: resources.GetOperatorCredentialsSecretName(jenkins)}
-	if err := k8sClient.Get(context.TODO(), namespaceName, adminSecret); err != nil {
+	if err := K8sClient.Get(context.TODO(), namespaceName, adminSecret); err != nil {
 		return nil, err
 	}
 
@@ -296,7 +296,7 @@ func verifyJenkinsAPIConnection(jenkins *v1alpha2.Jenkins, namespace string) (je
 	By("establishing Jenkins API connection")
 
 	var service corev1.Service
-	err := k8sClient.Get(context.TODO(), types.NamespacedName{
+	err := K8sClient.Get(context.TODO(), types.NamespacedName{
 		Namespace: jenkins.Namespace,
 		Name:      resources.GetJenkinsHTTPServiceName(jenkins),
 	}, &service)
@@ -333,7 +333,7 @@ func verifyJenkinsAPIConnection(jenkins *v1alpha2.Jenkins, namespace string) (je
 func restartJenkinsMasterPod(jenkins *v1alpha2.Jenkins) {
 	_, _ = fmt.Fprintf(GinkgoWriter, "Restarting Jenkins master pod\n")
 	jenkinsPod := getJenkinsMasterPod(jenkins)
-	Expect(k8sClient.Delete(context.TODO(), jenkinsPod)).Should(Succeed())
+	Expect(K8sClient.Delete(context.TODO(), jenkinsPod)).Should(Succeed())
 
 	Eventually(func() (bool, error) {
 		jenkinsPod = getJenkinsMasterPod(jenkins)
@@ -346,7 +346,7 @@ func restartJenkinsMasterPod(jenkins *v1alpha2.Jenkins) {
 func getJenkinsService(jenkins *v1alpha2.Jenkins, serviceKind string) *corev1.Service {
 	service := &corev1.Service{}
 	serviceName := constants.OperatorName + "-" + serviceKind + "-" + jenkins.ObjectMeta.Name
-	Expect(k8sClient.Get(context.TODO(), client.ObjectKey{Name: serviceName, Namespace: jenkins.Namespace}, service)).Should(Succeed())
+	Expect(K8sClient.Get(context.TODO(), client.ObjectKey{Name: serviceName, Namespace: jenkins.Namespace}, service)).Should(Succeed())
 
 	return service
 }

test/e2e/port_forward_test.go

@@ -66,7 +66,7 @@ func setupPortForwardToPod(namespace, podName string, podPort int) (port int, cl
 	readyCh := make(chan struct{})
 
 	req := portForwardToPodRequest{
-		config: cfg,
+		config: Cfg,
 		pod: v1.Pod{
 			ObjectMeta: metav1.ObjectMeta{
 				Name:      podName,

test/e2e/restart_test.go

@@ -33,7 +33,7 @@ jenkins.save()
 		},
 	}
 
-	Expect(k8sClient.Create(context.TODO(), limitRange)).Should(Succeed())
+	Expect(K8sClient.Create(context.TODO(), limitRange)).Should(Succeed())
 }
 
 func checkIfAuthorizationStrategyUnsecuredIsSet(jenkinsClient jenkinsclient.Jenkins) {
@@ -56,7 +56,7 @@ func checkBaseConfigurationCompleteTimeIsNotSet(jenkins *v1alpha2.Jenkins) {
 
 	Eventually(func() (bool, error) {
 		actualJenkins := &v1alpha2.Jenkins{}
-		err := k8sClient.Get(context.TODO(), types.NamespacedName{Name: jenkins.Name, Namespace: jenkins.Namespace}, actualJenkins)
+		err := K8sClient.Get(context.TODO(), types.NamespacedName{Name: jenkins.Name, Namespace: jenkins.Namespace}, actualJenkins)
 		if err != nil {
 			return false, err
 		}

test/e2e/restorebackup_test.go

@@ -61,7 +61,7 @@ func createPVC(namespace string) {
 		},
 	}
 
-	Expect(k8sClient.Create(context.TODO(), pvc)).Should(Succeed())
+	Expect(K8sClient.Create(context.TODO(), pvc)).Should(Succeed())
 }
 
 func createJenkinsWithBackupAndRestoreConfigured(name, namespace string) *v1alpha2.Jenkins {
@@ -180,7 +180,7 @@ func createJenkinsWithBackupAndRestoreConfigured(name, namespace string) *v1alph
 
 	_, _ = fmt.Fprintf(GinkgoWriter, "Jenkins CR %+v\n", *jenkins)
 
-	Expect(k8sClient.Create(context.TODO(), jenkins)).Should(Succeed())
+	Expect(K8sClient.Create(context.TODO(), jenkins)).Should(Succeed())
 
 	return jenkins
 }
@@ -190,5 +190,5 @@ func resetJenkinsStatus(jenkins *v1alpha2.Jenkins) {
 
 	jenkins = getJenkins(jenkins.Namespace, jenkins.Name)
 	jenkins.Status = v1alpha2.JenkinsStatus{}
-	Expect(k8sClient.Status().Update(context.TODO(), jenkins)).Should(Succeed())
+	Expect(K8sClient.Status().Update(context.TODO(), jenkins)).Should(Succeed())
 }

test/e2e/seedjobs_test.go

@@ -104,7 +104,7 @@ func createKubernetesCredentialsProviderSecret(namespace string, config seedJobC
 		},
 	}
 
-	Expect(k8sClient.Create(context.TODO(), secret)).Should(Succeed())
+	Expect(K8sClient.Create(context.TODO(), secret)).Should(Succeed())
 }
 
 func verifyJenkinsSeedJobs(jenkinsClient jenkinsclient.Jenkins, seedJobs []seedJobConfig) {

test/e2e/suite_test.go

@@ -1,12 +1,9 @@
 package e2e
 
 import (
-	"context"
 	"flag"
-	"fmt"
 	"path/filepath"
 	"testing"
-	"time"
 
 	"github.com/jenkinsci/kubernetes-operator/api/v1alpha2"
 	"github.com/jenkinsci/kubernetes-operator/controllers"
@@ -18,13 +15,9 @@ import (
 
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
-	corev1 "k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/client-go/kubernetes"
 	"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"
@@ -32,16 +25,6 @@ import (
 	// +kubebuilder:scaffold:imports
 )
 
-var (
-	cfg       *rest.Config
-	k8sClient client.Client
-	testEnv   *envtest.Environment
-
-	hostname    *string
-	port        *int
-	useNodePort *bool
-)
-
 func init() {
 	hostname = flag.String("jenkins-api-hostname", "", "Hostname or IP of Jenkins API. It can be service name, node IP or localhost.")
 	port = flag.Int("jenkins-api-port", 0, "The port on which Jenkins API is running. Note: If you want to use nodePort don't set this setting and --jenkins-api-use-nodeport must be true.")
@@ -68,9 +51,9 @@ var _ = BeforeSuite(func(done Done) {
 	}
 
 	var err error
-	cfg, err = testEnv.Start()
+	Cfg, err = testEnv.Start()
 	Expect(err).NotTo(HaveOccurred())
-	Expect(cfg).NotTo(BeNil())
+	Expect(Cfg).NotTo(BeNil())
 
 	err = v1alpha2.AddToScheme(scheme.Scheme)
 	Expect(err).NotTo(HaveOccurred())
@@ -78,20 +61,20 @@ var _ = BeforeSuite(func(done Done) {
 	// +kubebuilder:scaffold:scheme
 
 	// setup manager
-	k8sManager, err := ctrl.NewManager(cfg, ctrl.Options{
+	k8sManager, err := ctrl.NewManager(Cfg, ctrl.Options{
 		Scheme: scheme.Scheme,
 	})
 	Expect(err).NotTo(HaveOccurred())
 
 	// setup controller
-	clientSet, err := kubernetes.NewForConfig(cfg)
+	clientSet, err := kubernetes.NewForConfig(Cfg)
 	Expect(err).NotTo(HaveOccurred())
 
 	// setup events
-	events, err := event.New(cfg, constants.OperatorName)
+	events, err := event.New(Cfg, constants.OperatorName)
 	Expect(err).NotTo(HaveOccurred())
 	notificationEvents := make(chan e.Event)
-	go notifications.Listen(notificationEvents, events, k8sClient)
+	go notifications.Listen(notificationEvents, events, K8sClient)
 
 	jenkinsAPIConnectionSettings := jenkinsClient.JenkinsAPIConnectionSettings{
 		Hostname:    *hostname,
@@ -104,7 +87,7 @@ var _ = BeforeSuite(func(done Done) {
 		Scheme:                       k8sManager.GetScheme(),
 		JenkinsAPIConnectionSettings: jenkinsAPIConnectionSettings,
 		ClientSet:                    *clientSet,
-		Config:                       *cfg,
+		Config:                       *Cfg,
 		NotificationEvents:           &notificationEvents,
 		KubernetesClusterDomain:      "cluster.local",
 	}).SetupWithManager(k8sManager)
@@ -115,8 +98,8 @@ var _ = BeforeSuite(func(done Done) {
 		Expect(err).NotTo(HaveOccurred())
 	}()
 
-	k8sClient = k8sManager.GetClient()
-	Expect(k8sClient).NotTo(BeNil())
+	K8sClient = k8sManager.GetClient()
+	Expect(K8sClient).NotTo(BeNil())
 	close(done)
 }, 60)
 
@@ -125,39 +108,3 @@ var _ = AfterSuite(func() {
 	err := testEnv.Stop()
 	Expect(err).NotTo(HaveOccurred())
 })
-
-func createNamespace() *corev1.Namespace {
-	By("creating temporary namespace")
-
-	namespace := &corev1.Namespace{
-		ObjectMeta: metav1.ObjectMeta{
-			Name: fmt.Sprintf("%d", time.Now().Unix()),
-		},
-	}
-	Expect(k8sClient.Create(context.TODO(), namespace)).Should(Succeed())
-	return namespace
-}
-
-func destroyNamespace(namespace *corev1.Namespace) {
-	By("deleting temporary namespace")
-
-	Expect(k8sClient.Delete(context.TODO(), namespace)).Should(Succeed())
-
-	Eventually(func() (bool, error) {
-		namespaces := &corev1.NamespaceList{}
-		err := k8sClient.List(context.TODO(), namespaces)
-		if err != nil {
-			return false, err
-		}
-
-		exists := false
-		for _, namespaceItem := range namespaces.Items {
-			if namespaceItem.Name == namespace.Name {
-				exists = true
-				break
-			}
-		}
-
-		return !exists, nil
-	}, time.Second*120, time.Second).Should(BeTrue())
-}

test/e2e/test_utility.go

@@ -0,0 +1,61 @@
+package e2e
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/onsi/ginkgo"
+	"github.com/onsi/gomega"
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/client-go/rest"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+	"sigs.k8s.io/controller-runtime/pkg/envtest"
+)
+
+var (
+	Cfg       *rest.Config
+	K8sClient client.Client
+	testEnv   *envtest.Environment
+
+	hostname    *string
+	port        *int
+	useNodePort *bool
+)
+
+func CreateNamespace() *corev1.Namespace {
+	ginkgo.By("creating temporary namespace")
+
+	namespace := &corev1.Namespace{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: fmt.Sprintf("ns%d", time.Now().Unix()),
+		},
+	}
+	gomega.Expect(K8sClient.Create(context.TODO(), namespace)).Should(gomega.Succeed())
+	return namespace
+}
+
+func DestroyNamespace(namespace *corev1.Namespace) {
+	ginkgo.By("deleting temporary namespace")
+
+	gomega.Expect(K8sClient.Delete(context.TODO(), namespace)).Should(gomega.Succeed())
+
+	gomega.Eventually(func() (bool, error) {
+		namespaces := &corev1.NamespaceList{}
+		err := K8sClient.List(context.TODO(), namespaces)
+		if err != nil {
+			return false, err
+		}
+
+		exists := false
+		for _, namespaceItem := range namespaces.Items {
+			if namespaceItem.Name == namespace.Name {
+				exists = true
+				break
+			}
+		}
+
+		return !exists, nil
+	}, time.Second*120, time.Second).Should(gomega.BeTrue())
+}

test/e2e/wait.go

@@ -10,8 +10,8 @@ import (
 	jenkinsclient "github.com/jenkinsci/kubernetes-operator/pkg/client"
 	"github.com/jenkinsci/kubernetes-operator/pkg/configuration/base/resources"
 
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
+	"github.com/onsi/ginkgo"
+	"github.com/onsi/gomega"
 	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/labels"
@@ -23,36 +23,36 @@ var (
 	retryInterval = time.Second * 5
 )
 
-func waitForJenkinsBaseConfigurationToComplete(jenkins *v1alpha2.Jenkins) {
-	By("waiting for Jenkins base configuration phase to complete")
+func WaitForJenkinsBaseConfigurationToComplete(jenkins *v1alpha2.Jenkins) {
+	ginkgo.By("waiting for Jenkins base configuration phase to complete")
 
-	Eventually(func() (*metav1.Time, error) {
+	gomega.Eventually(func() (*metav1.Time, error) {
 		actualJenkins := &v1alpha2.Jenkins{}
-		err := k8sClient.Get(context.TODO(), types.NamespacedName{Name: jenkins.Name, Namespace: jenkins.Namespace}, actualJenkins)
+		err := K8sClient.Get(context.TODO(), types.NamespacedName{Name: jenkins.Name, Namespace: jenkins.Namespace}, actualJenkins)
 		if err != nil {
 			return nil, err
 		}
 
 		return actualJenkins.Status.BaseConfigurationCompletedTime, nil
-	}, time.Duration(170)*retryInterval, retryInterval).Should(Not(BeNil()))
+	}, time.Duration(170)*retryInterval, retryInterval).Should(gomega.Not(gomega.BeNil()))
 
-	_, _ = fmt.Fprintf(GinkgoWriter, "Jenkins pod is running\n")
+	_, _ = fmt.Fprintf(ginkgo.GinkgoWriter, "Jenkins pod is running\n")
 
 	// update jenkins CR because Operator sets default values
 	namespacedName := types.NamespacedName{Namespace: jenkins.Namespace, Name: jenkins.Name}
-	Expect(k8sClient.Get(context.TODO(), namespacedName, jenkins)).Should(Succeed())
+	gomega.Expect(K8sClient.Get(context.TODO(), namespacedName, jenkins)).Should(gomega.Succeed())
 }
 
 func waitForRecreateJenkinsMasterPod(jenkins *v1alpha2.Jenkins) {
-	By("waiting for Jenkins Master Pod recreation")
+	ginkgo.By("waiting for Jenkins Master Pod recreation")
 
-	Eventually(func() (bool, error) {
+	gomega.Eventually(func() (bool, error) {
 		lo := &client.ListOptions{
 			LabelSelector: labels.SelectorFromSet(resources.GetJenkinsMasterPodLabels(*jenkins)),
 			Namespace:     jenkins.Namespace,
 		}
 		pods := &corev1.PodList{}
-		err := k8sClient.List(context.TODO(), pods, lo)
+		err := K8sClient.List(context.TODO(), pods, lo)
 		if err != nil {
 			return false, err
 		}
@@ -61,31 +61,31 @@ func waitForRecreateJenkinsMasterPod(jenkins *v1alpha2.Jenkins) {
 		}
 
 		return pods.Items[0].DeletionTimestamp == nil, nil
-	}, 30*retryInterval, retryInterval).Should(BeTrue())
+	}, 30*retryInterval, retryInterval).Should(gomega.BeTrue())
 
-	_, _ = fmt.Fprintf(GinkgoWriter, "Jenkins pod has been recreated\n")
+	_, _ = fmt.Fprintf(ginkgo.GinkgoWriter, "Jenkins pod has been recreated\n")
 }
 
-func waitForJenkinsUserConfigurationToComplete(jenkins *v1alpha2.Jenkins) {
-	By("waiting for Jenkins user configuration phase to complete")
+func WaitForJenkinsUserConfigurationToComplete(jenkins *v1alpha2.Jenkins) {
+	ginkgo.By("waiting for Jenkins user configuration phase to complete")
 
-	Eventually(func() (*metav1.Time, error) {
+	gomega.Eventually(func() (*metav1.Time, error) {
 		actualJenkins := &v1alpha2.Jenkins{}
-		err := k8sClient.Get(context.TODO(), types.NamespacedName{Name: jenkins.Name, Namespace: jenkins.Namespace}, actualJenkins)
+		err := K8sClient.Get(context.TODO(), types.NamespacedName{Name: jenkins.Name, Namespace: jenkins.Namespace}, actualJenkins)
 		if err != nil {
 			return nil, err
 		}
 		return actualJenkins.Status.UserConfigurationCompletedTime, nil
-	}, time.Duration(110)*retryInterval, retryInterval).Should(Not(BeNil()))
-	_, _ = fmt.Fprintf(GinkgoWriter, "Jenkins instance is up and ready\n")
+	}, time.Duration(110)*retryInterval, retryInterval).Should(gomega.Not(gomega.BeNil()))
+	_, _ = fmt.Fprintf(ginkgo.GinkgoWriter, "Jenkins instance is up and ready\n")
 }
 
 func waitForJenkinsSafeRestart(jenkinsClient jenkinsclient.Jenkins) {
-	By("waiting for Jenkins safe restart")
+	ginkgo.By("waiting for Jenkins safe restart")
 
-	Eventually(func() (bool, error) {
+	gomega.Eventually(func() (bool, error) {
 		status, err := jenkinsClient.Poll()
-		_, _ = fmt.Fprintf(GinkgoWriter, "Safe restart status: %+v, err: %s\n", status, err)
+		_, _ = fmt.Fprintf(ginkgo.GinkgoWriter, "Safe restart status: %+v, err: %s\n", status, err)
 		if err != nil {
 			return false, err
 		}
@@ -93,5 +93,5 @@ func waitForJenkinsSafeRestart(jenkinsClient jenkinsclient.Jenkins) {
 			return false, err
 		}
 		return true, nil
-	}, time.Second*200, time.Second*5).Should(BeTrue())
+	}, time.Second*200, time.Second*5).Should(gomega.BeTrue())
 }

test/helm/helm_test.go

@@ -0,0 +1,60 @@
+package helm
+
+import (
+	"fmt"
+	"os/exec"
+
+	"github.com/jenkinsci/kubernetes-operator/api/v1alpha2"
+	"github.com/jenkinsci/kubernetes-operator/test/e2e"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	// +kubebuilder:scaffold:imports
+)
+
+var _ = Describe("Jenkins controller", func() {
+	var (
+		namespace *corev1.Namespace
+	)
+
+	BeforeEach(func() {
+		namespace = e2e.CreateNamespace()
+	})
+	AfterEach(func() {
+		showLogsIfTestHasFailed(CurrentGinkgoTestDescription().Failed, namespace.Name)
+		e2e.DestroyNamespace(namespace)
+	})
+	Context("when deploying Helm Chart to cluster", func() {
+		It("creates Jenkins instance and configures it", func() {
+
+			jenkins := &v1alpha2.Jenkins{
+				TypeMeta: v1alpha2.JenkinsTypeMeta(),
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      "jenkins",
+					Namespace: namespace.Name,
+				},
+			}
+
+			cmd := exec.Command("../../bin/helm", "upgrade", "jenkins", "../../chart/jenkins-operator", "--namespace", namespace.Name, "--debug",
+				"--set-string", fmt.Sprintf("jenkins.namespace=%s", namespace.Name),
+				"--set-string", fmt.Sprintf("operator.image=%s", *imageName), "--install")
+			output, err := cmd.CombinedOutput()
+			Expect(err).NotTo(HaveOccurred(), string(output))
+
+			e2e.WaitForJenkinsBaseConfigurationToComplete(jenkins)
+			e2e.WaitForJenkinsUserConfigurationToComplete(jenkins)
+
+			cmd = exec.Command("../../bin/helm", "upgrade", "jenkins", "../../chart/jenkins-operator", "--namespace", namespace.Name, "--debug",
+				"--set-string", fmt.Sprintf("jenkins.namespace=%s", namespace.Name),
+				"--set-string", fmt.Sprintf("operator.image=%s", *imageName), "--install")
+			output, err = cmd.CombinedOutput()
+
+			Expect(err).NotTo(HaveOccurred(), string(output))
+
+			e2e.WaitForJenkinsBaseConfigurationToComplete(jenkins)
+			e2e.WaitForJenkinsUserConfigurationToComplete(jenkins)
+		})
+	})
+})

test/helm/logging_test.go

@@ -0,0 +1,135 @@
+package helm
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"sort"
+
+	"github.com/jenkinsci/kubernetes-operator/test/e2e"
+	"github.com/onsi/ginkgo"
+
+	corev1 "k8s.io/api/core/v1"
+	"k8s.io/api/events/v1beta1"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/client-go/kubernetes"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+)
+
+var (
+	podLogTailLimit       int64 = 15
+	kubernetesEventsLimit int64 = 15
+	// MUST match the labels in the deployment manifest: deploy/operator.yaml
+	operatorPodLabels = map[string]string{
+		"name": "jenkins-operator",
+	}
+)
+
+func getOperatorPod(namespace string) (*corev1.Pod, error) {
+	lo := &client.ListOptions{
+		LabelSelector: labels.SelectorFromSet(operatorPodLabels),
+		Namespace:     namespace,
+	}
+	pods := &corev1.PodList{}
+	err := e2e.K8sClient.List(context.TODO(), pods, lo)
+	if err != nil {
+		return nil, err
+	}
+	return &pods.Items[0], nil
+}
+
+func getOperatorLogs(namespace string) (string, error) {
+	pod, err := getOperatorPod(namespace)
+	if err != nil {
+		return "Operator pod doesn't exist", err
+	}
+	logOptions := corev1.PodLogOptions{TailLines: &podLogTailLimit}
+
+	// creates the clientset
+	clientset, err := kubernetes.NewForConfig(e2e.Cfg)
+	if err != nil {
+		return "", err
+	}
+	req := clientset.CoreV1().Pods(pod.Namespace).GetLogs(pod.Name, &logOptions)
+	podLogs, err := req.Stream(context.TODO())
+	if err != nil {
+		return "", err
+	}
+
+	defer func() {
+		if podLogs != nil {
+			_ = podLogs.Close()
+		}
+	}()
+
+	buf := new(bytes.Buffer)
+	_, err = io.Copy(buf, podLogs)
+	if err != nil {
+		return "", err
+	}
+
+	logs := buf.String()
+	return logs, nil
+}
+
+func printOperatorLogs(namespace string) {
+	_, _ = fmt.Fprintf(ginkgo.GinkgoWriter, "Operator logs in '%s' namespace:\n", namespace)
+	logs, err := getOperatorLogs(namespace)
+	if err != nil {
+		_, _ = fmt.Fprintf(ginkgo.GinkgoWriter, "Couldn't get the operator pod logs: %s", err)
+	} else {
+		_, _ = fmt.Fprintf(ginkgo.GinkgoWriter, "Last %d lines of log from operator:\n %s", podLogTailLimit, logs)
+	}
+}
+
+func getKubernetesEvents(namespace string) ([]v1beta1.Event, error) {
+	listOptions := &client.ListOptions{
+		Limit:     kubernetesEventsLimit,
+		Namespace: namespace,
+	}
+
+	events := &v1beta1.EventList{}
+	err := e2e.K8sClient.List(context.TODO(), events, listOptions)
+	if err != nil {
+		return nil, err
+	}
+	sort.SliceStable(events.Items, func(i, j int) bool {
+		return events.Items[i].CreationTimestamp.Unix() < events.Items[j].CreationTimestamp.Unix()
+	})
+
+	return events.Items, nil
+}
+
+func printKubernetesEvents(namespace string) {
+	_, _ = fmt.Fprintf(ginkgo.GinkgoWriter, "Kubernetes events in '%s' namespace:\n", namespace)
+	events, err := getKubernetesEvents(namespace)
+	if err != nil {
+		_, _ = fmt.Fprintf(ginkgo.GinkgoWriter, "Couldn't get kubernetes events: %s", err)
+	} else {
+		_, _ = fmt.Fprintf(ginkgo.GinkgoWriter, "Last %d events from kubernetes:\n", kubernetesEventsLimit)
+
+		for _, event := range events {
+			_, _ = fmt.Fprintf(ginkgo.GinkgoWriter, "%+v\n\n", event)
+		}
+	}
+}
+
+func printKubernetesPods(namespace string) {
+	_, _ = fmt.Fprintf(ginkgo.GinkgoWriter, "All pods in '%s' namespace:\n", namespace)
+
+	pod, err := getOperatorPod(namespace)
+	if err == nil {
+		_, _ = fmt.Fprintf(ginkgo.GinkgoWriter, "%+v\n\n", pod)
+	}
+}
+
+func showLogsIfTestHasFailed(failed bool, namespace string) {
+	if failed {
+		_, _ = fmt.Fprintf(ginkgo.GinkgoWriter, "Test failed. Bellow here you can check logs:")
+
+		printKubernetesEvents(namespace)
+		printKubernetesPods(namespace)
+		printOperatorLogs(namespace)
+	}
+}

test/helm/suite_test.go

@@ -0,0 +1,76 @@
+package helm
+
+import (
+	"flag"
+	"testing"
+
+	"github.com/jenkinsci/kubernetes-operator/api/v1alpha2"
+	"github.com/jenkinsci/kubernetes-operator/test/e2e"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	"k8s.io/client-go/kubernetes/scheme"
+	ctrl "sigs.k8s.io/controller-runtime"
+	"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"
+	// +kubebuilder:scaffold:imports
+)
+
+var (
+	testEnv   *envtest.Environment
+	imageName *string
+)
+
+func init() {
+	imageName = flag.String("image-name", "", "Name of the locally built for testing Jenkins Operator Image.")
+}
+
+func TestHelm(t *testing.T) {
+	RegisterFailHandler(Fail)
+
+	RunSpecsWithDefaultAndCustomReporters(t,
+		"Controller Suite",
+		[]Reporter{printer.NewlineReporter{}})
+}
+
+var _ = BeforeSuite(func(done Done) {
+	logf.SetLogger(zap.New(zap.WriteTo(GinkgoWriter), zap.UseDevMode(false)))
+
+	By("bootstrapping test environment")
+	useExistingCluster := true
+	testEnv = &envtest.Environment{
+		UseExistingCluster: &useExistingCluster,
+	}
+
+	cfg, err := testEnv.Start()
+	Expect(err).NotTo(HaveOccurred())
+	Expect(cfg).NotTo(BeNil())
+
+	err = v1alpha2.AddToScheme(scheme.Scheme)
+	Expect(err).NotTo(HaveOccurred())
+
+	// +kubebuilder:scaffold:scheme
+
+	// setup manager
+	k8sManager, err := ctrl.NewManager(cfg, ctrl.Options{
+		Scheme: scheme.Scheme,
+	})
+	Expect(err).NotTo(HaveOccurred())
+
+	go func() {
+		err = k8sManager.Start(ctrl.SetupSignalHandler())
+		Expect(err).NotTo(HaveOccurred())
+	}()
+
+	e2e.K8sClient = k8sManager.GetClient()
+	Expect(e2e.K8sClient).NotTo(BeNil())
+	close(done)
+}, 60)
+
+var _ = AfterSuite(func() {
+	By("tearing down the test environment")
+	err := testEnv.Stop()
+	Expect(err).NotTo(HaveOccurred())
+})