add --dev flag for k8s init and uninstall

Signed-off-by: Mukundan Sundararajan <65565396+mukundansundar@users.noreply.github.com>

cmd/init.go

@@ -33,6 +33,7 @@ var (
 	wait              bool
 	timeout           uint
 	slimMode          bool
+	devMode           bool
 	runtimeVersion    string
 	dashboardVersion  string
 	allNamespaces     bool
@@ -127,6 +128,7 @@ dapr init --runtime-path <path-to-install-directory>
 				DashboardVersion:          dashboardVersion,
 				EnableMTLS:                enableMTLS,
 				EnableHA:                  enableHA,
+				EnableDev:                 devMode,
 				Args:                      values,
 				Wait:                      wait,
 				Timeout:                   timeout,
@@ -202,6 +204,7 @@ func init() {
 	defaultContainerRuntime := string(utils.DOCKER)
 
 	InitCmd.Flags().BoolVarP(&kubernetesMode, "kubernetes", "k", false, "Deploy Dapr to a Kubernetes cluster")
+	InitCmd.Flags().BoolVarP(&devMode, "dev", "", false, "Use Dev mode. Deploy Redis, Zipkin alson in the Kubernetes cluster")
 	InitCmd.Flags().BoolVarP(&wait, "wait", "", false, "Wait for Kubernetes initialization to complete")
 	InitCmd.Flags().UintVarP(&timeout, "timeout", "", 300, "The wait timeout for the Kubernetes installation")
 	InitCmd.Flags().BoolVarP(&slimMode, "slim", "s", false, "Exclude placement service, Redis and Zipkin containers from self-hosted installation")

cmd/uninstall.go

@@ -30,6 +30,7 @@ import (
 var (
 	uninstallNamespace        string
 	uninstallKubernetes       bool
+	uninstallDev              bool
 	uninstallAll              bool
 	uninstallContainerRuntime string
 )
@@ -66,7 +67,7 @@ dapr uninstall --runtime-path <path-to-install-directory>
 			}
 
 			print.InfoStatusEvent(os.Stdout, "Removing Dapr from your cluster...")
-			err = kubernetes.Uninstall(uninstallNamespace, uninstallAll, timeout)
+			err = kubernetes.Uninstall(uninstallNamespace, uninstallAll, uninstallDev, timeout)
 		} else {
 			if !utils.IsValidContainerRuntime(uninstallContainerRuntime) {
 				print.FailureStatusEvent(os.Stdout, "Invalid container runtime. Supported values are docker and podman.")
@@ -87,6 +88,7 @@ dapr uninstall --runtime-path <path-to-install-directory>
 
 func init() {
 	UninstallCmd.Flags().BoolVarP(&uninstallKubernetes, "kubernetes", "k", false, "Uninstall Dapr from a Kubernetes cluster")
+	UninstallCmd.Flags().BoolVarP(&uninstallDev, "dev", "", false, "Uninstall Dapr Redis and Zipking installations from Kubernetes cluster")
 	UninstallCmd.Flags().UintVarP(&timeout, "timeout", "", 300, "The timeout for the Kubernetes uninstall")
 	UninstallCmd.Flags().BoolVar(&uninstallAll, "all", false, "Remove .dapr directory, Redis, Placement and Zipkin containers on local machine, and CRDs on a Kubernetes cluster")
 	UninstallCmd.Flags().String("network", "", "The Docker network from which to remove the Dapr runtime")

pkg/kubernetes/kubernetes.go

@@ -36,10 +36,18 @@ import (
 )
 
 const (
-	daprReleaseName      = "dapr"
+	daprReleaseName        = "dapr"
-	dashboardReleaseName = "dapr-dashboard"
+	dashboardReleaseName   = "dapr-dashboard"
-	daprHelmRepo         = "https://dapr.github.io/helm-charts"
+	thirdPartyDevNamespace = "default"
-	latestVersion        = "latest"
+	zipkinChartName        = "zipkin"
+	redisChartName         = "redis"
+	zipkinReleaseName      = "dapr-dev-zipkin"
+	redisReleaseName       = "dapr-dev-redis"
+	redisVersion           = "6.2"
+	bitnamiHelmRepo        = "https://charts.bitnami.com/bitnami"
+	daprHelmRepo           = "https://dapr.github.io/helm-charts"
+	zipkinHelmRepo         = "https://openzipkin.github.io/zipkin"
+	latestVersion          = "latest"
 )
 
 type InitConfiguration struct {
@@ -48,6 +56,7 @@ type InitConfiguration struct {
 	Namespace                 string
 	EnableMTLS                bool
 	EnableHA                  bool
+	EnableDev                 bool
 	Args                      []string
 	Wait                      bool
 	Timeout                   uint
@@ -60,7 +69,8 @@ type InitConfiguration struct {
 
 // Init deploys the Dapr operator using the supplied runtime version.
 func Init(config InitConfiguration) error {
-	err := installWithConsole(daprReleaseName, config.Version, "Dapr control plane", config)
+	helmRepoDapr := utils.GetEnv("DAPR_HELM_REPO_URL", daprHelmRepo)
+	err := installWithConsole(daprReleaseName, config.Version, helmRepoDapr, "Dapr control plane", config)
 	if err != nil {
 		return err
 	}
@@ -75,19 +85,53 @@ func Init(config InitConfiguration) error {
 		}
 	}
 
-	err = installWithConsole(dashboardReleaseName, config.DashboardVersion, "Dapr dashboard", config)
+	err = installWithConsole(dashboardReleaseName, config.DashboardVersion, helmRepoDapr, "Dapr dashboard", config)
 	if err != nil {
 		return err
 	}
 
+	if config.EnableDev {
+		redisChartVals := []string{
+			"image.tag=" + redisVersion,
+		}
+
+		err = installThirdPartyWithConsole(redisReleaseName, redisChartName, latestVersion, bitnamiHelmRepo, "Dapr Redis", redisChartVals, config)
+		if err != nil {
+			return err
+		}
+
+		err = installThirdPartyWithConsole(zipkinReleaseName, zipkinChartName, latestVersion, zipkinHelmRepo, "Dapr Zipkin", []string{}, config)
+		if err != nil {
+			return err
+		}
+
+		err = initDevConfigs()
+		if err != nil {
+			return err
+		}
+	}
 	return nil
 }
 
-func installWithConsole(releaseName string, releaseVersion string, prettyName string, config InitConfiguration) error {
+func installThirdPartyWithConsole(releaseName, chartName, releaseVersion, helmRepo string, prettyName string, chartValues []string, config InitConfiguration) error {
 	installSpinning := print.Spinner(os.Stdout, "Deploying the "+prettyName+" with "+releaseVersion+" version to your cluster...")
 	defer installSpinning(print.Failure)
 
-	err := install(releaseName, releaseVersion, config)
+	// releaseVersion of chart will always be latest version.
+	err := installThirdParty(releaseName, chartName, latestVersion, helmRepo, chartValues, config)
+	if err != nil {
+		return err
+	}
+	installSpinning(print.Success)
+
+	return nil
+}
+
+func installWithConsole(releaseName, releaseVersion, helmRepo string, prettyName string, config InitConfiguration) error {
+	installSpinning := print.Spinner(os.Stdout, "Deploying the "+prettyName+" with "+releaseVersion+" version to your cluster...")
+	defer installSpinning(print.Failure)
+
+	err := install(releaseName, releaseVersion, helmRepo, config)
 	if err != nil {
 		return err
 	}
@@ -156,9 +200,9 @@ func locateChartFile(dirPath string) (string, error) {
 	return filepath.Join(dirPath, files[0].Name()), nil
 }
 
-func daprChart(version string, releaseName string, config *helm.Configuration) (*chart.Chart, error) {
+func getHelmChart(version, releaseName, helmRepo string, config *helm.Configuration) (*chart.Chart, error) {
 	pull := helm.NewPullWithOpts(helm.WithConfig(config))
-	pull.RepoURL = utils.GetEnv("DAPR_HELM_REPO_URL", daprHelmRepo)
+	pull.RepoURL = helmRepo
 	pull.Username = utils.GetEnv("DAPR_HELM_REPO_USERNAME", "")
 	pull.Password = utils.GetEnv("DAPR_HELM_REPO_PASSWORD", "")
 
@@ -188,7 +232,7 @@ func daprChart(version string, releaseName string, config *helm.Configuration) (
 	return loader.Load(chartPath)
 }
 
-func chartValues(config InitConfiguration, version string) (map[string]interface{}, error) {
+func daprChartValues(config InitConfiguration, version string) (map[string]interface{}, error) {
 	chartVals := map[string]interface{}{}
 	err := utils.ValidateImageVariant(config.ImageVariant)
 	if err != nil {
@@ -227,7 +271,7 @@ func chartValues(config InitConfiguration, version string) (map[string]interface
 	return chartVals, nil
 }
 
-func install(releaseName string, releaseVersion string, config InitConfiguration) error {
+func install(releaseName, releaseVersion, helmRepo string, config InitConfiguration) error {
 	err := createNamespace(config.Namespace)
 	if err != nil {
 		return err
@@ -238,7 +282,7 @@ func install(releaseName string, releaseVersion string, config InitConfiguration
 		return err
 	}
 
-	daprChart, err := daprChart(releaseVersion, releaseName, helmConf)
+	daprChart, err := getHelmChart(releaseVersion, releaseName, helmRepo, helmConf)
 	if err != nil {
 		return err
 	}
@@ -261,7 +305,7 @@ func install(releaseName string, releaseVersion string, config InitConfiguration
 	installClient.Wait = config.Wait
 	installClient.Timeout = time.Duration(config.Timeout) * time.Second
 
-	values, err := chartValues(config, version)
+	values, err := daprChartValues(config, version)
 	if err != nil {
 		return err
 	}
@@ -273,6 +317,38 @@ func install(releaseName string, releaseVersion string, config InitConfiguration
 	return nil
 }
 
+func installThirdParty(releaseName, chartName, releaseVersion, helmRepo string, chartVals []string, config InitConfiguration) error {
+	helmConf, err := helmConfig(thirdPartyDevNamespace)
+	if err != nil {
+		return err
+	}
+
+	helmChart, err := getHelmChart(releaseVersion, chartName, helmRepo, helmConf)
+	if err != nil {
+		return err
+	}
+
+	installClient := helm.NewInstall(helmConf)
+	installClient.ReleaseName = releaseName
+	installClient.Namespace = thirdPartyDevNamespace
+	installClient.Wait = config.Wait
+	installClient.Timeout = time.Duration(config.Timeout) * time.Second
+
+	values := map[string]interface{}{}
+
+	for _, val := range chartVals {
+		if err = strvals.ParseInto(val, values); err != nil {
+			return err
+		}
+	}
+
+	if _, err = installClient.Run(helmChart, values); err != nil {
+		return err
+	}
+
+	return nil
+}
+
 func debugLogf(format string, v ...interface{}) {
 }
 
@@ -290,3 +366,78 @@ func confirmExist(cfg *helm.Configuration, releaseName string) (bool, error) {
 
 	return true, nil
 }
+
+func checkAndOverWriteFile(filePath string, b []byte) error {
+	_, err := os.Stat(filePath)
+	if os.IsNotExist(err) {
+		// #nosec G306
+		if err = os.WriteFile(filePath, b, 0o644); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func initDevConfigs() error {
+	redisStatestore := `
+apiVersion: dapr.io/v1alpha1
+kind: Component
+metadata:
+  name: daprdevstatestore
+spec:
+  type: state.redis
+  version: v1
+  metadata:
+  # These settings will work out of the box if you use helm install
+  # bitnami/redis.  If you have your own setup, replace
+  # redis-master:6379 with your own Redis master address, and the
+  # Redis password with your own Secret's name. For more information,
+  # see https://docs.dapr.io/operations/components/component-secrets .
+  - name: redisHost
+    value: dapr-dev-redis-master:6379
+  - name: redisPassword
+    secretKeyRef:
+      name: dapr-dev-redis
+      key: redis-password
+auth:
+  secretStore: kubernetes
+`
+
+	zipkinConfig := `
+apiVersion: dapr.io/v1alpha1
+kind: Configuration
+metadata:
+  name: daprdevzipkinconfig
+spec:
+  tracing:
+    samplingRate: "1"
+    zipkin:
+      endpointAddress: "http://dapr-dev-zipkin.default.svc.cluster.local:9411/api/v2/spans"
+`
+	tempDirPath, err := createTempDir()
+	defer os.RemoveAll(tempDirPath)
+	if err != nil {
+		return err
+	}
+	redisPath := filepath.Join(tempDirPath, "redis-statestore.yaml")
+	err = checkAndOverWriteFile(redisPath, []byte(redisStatestore))
+	if err != nil {
+		return err
+	}
+	_, err = utils.RunCmdAndWait("kubectl", "apply", "-f", redisPath)
+	if err != nil {
+		return err
+	}
+
+	zipkinPath := filepath.Join(tempDirPath, "zipkin-config.yaml")
+	err = checkAndOverWriteFile(zipkinPath, []byte(zipkinConfig))
+	if err != nil {
+		return err
+	}
+	_, err = utils.RunCmdAndWait("kubectl", "apply", "-f", zipkinPath)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

pkg/kubernetes/renew_certificate.go

@@ -112,7 +112,8 @@ func renewCertificate(rootCert, issuerCert, issuerKey []byte, timeout uint, imag
 		return err
 	}
 
-	daprChart, err := daprChart(daprVersion, "dapr", helmConf)
+	helmRepo := utils.GetEnv("DAPR_HELM_REPO_URL", daprHelmRepo)
+	daprChart, err := getHelmChart(daprVersion, "dapr", helmRepo, helmConf)
 	if err != nil {
 		return err
 	}

pkg/kubernetes/uninstall.go

@@ -24,7 +24,7 @@ import (
 )
 
 // Uninstall removes Dapr from a Kubernetes cluster.
-func Uninstall(namespace string, uninstallAll bool, timeout uint) error {
+func Uninstall(namespace string, uninstallAll bool, uninstallDev bool, timeout uint) error {
 	config, err := helmConfig(namespace)
 	if err != nil {
 		return err
@@ -48,6 +48,11 @@ func Uninstall(namespace string, uninstallAll bool, timeout uint) error {
 	// Deleting Dashboard here is for versions >= 1.11.
 	uninstallClient.Run(dashboardReleaseName)
 
+	if uninstallDev {
+		// uninstall dapr-dev-zipkin and dapr-dev-redis as best effort.
+		uninstallThirdParty()
+	}
+
 	_, err = uninstallClient.Run(daprReleaseName)
 
 	if err != nil {
@@ -65,3 +70,14 @@ func Uninstall(namespace string, uninstallAll bool, timeout uint) error {
 
 	return nil
 }
+
+func uninstallThirdParty() {
+	print.InfoStatusEvent(os.Stdout, "Removing dapr-dev-redis and dapr-dev-zipkin from the cluster...")
+	// Uninstall dapr-dev-redis and dapr-dev-zipkin from k8s as best effort.
+	config, _ := helmConfig(thirdPartyDevNamespace)
+
+	uninstallClient := helm.NewUninstall(config)
+
+	uninstallClient.Run(redisReleaseName)
+	uninstallClient.Run(zipkinReleaseName)
+}

pkg/kubernetes/upgrade.go

@@ -57,6 +57,7 @@ type UpgradeConfig struct {
 }
 
 func Upgrade(conf UpgradeConfig) error {
+	helmRepo := utils.GetEnv("DAPR_HELM_REPO_URL", daprHelmRepo)
 	status, err := GetDaprResourcesStatus()
 	if err != nil {
 		return err
@@ -75,7 +76,7 @@ func Upgrade(conf UpgradeConfig) error {
 		return err
 	}
 
-	controlPlaneChart, err := daprChart(conf.RuntimeVersion, "dapr", helmConf)
+	controlPlaneChart, err := getHelmChart(conf.RuntimeVersion, "dapr", helmRepo, helmConf)
 	if err != nil {
 		return err
 	}
@@ -109,7 +110,7 @@ func Upgrade(conf UpgradeConfig) error {
 
 	var dashboardChart *chart.Chart
 	if conf.DashboardVersion != "" {
-		dashboardChart, err = daprChart(conf.DashboardVersion, dashboardReleaseName, helmConf)
+		dashboardChart, err = getHelmChart(conf.DashboardVersion, dashboardReleaseName, helmRepo, helmConf)
 		if err != nil {
 			return err
 		}
@@ -176,7 +177,7 @@ func Upgrade(conf UpgradeConfig) error {
 			}
 		} else {
 			// We need to install Dashboard since it does not exist yet.
-			err = install(dashboardReleaseName, conf.DashboardVersion, InitConfiguration{
+			err = install(dashboardReleaseName, conf.DashboardVersion, helmRepo, InitConfiguration{
 				DashboardVersion: conf.DashboardVersion,
 				Namespace:        upgradeClient.Namespace,
 				Wait:             upgradeClient.Wait,

tests/e2e/common/common.go

@@ -48,6 +48,10 @@ const (
 
 	numHAPods    = 13
 	numNonHAPods = 5
+
+	thirdPartyDevNamespace = "default"
+	devRedisReleaseName    = "dapr-dev-redis"
+	devZipkinReleaseName   = "dapr-dev-zipkin"
 )
 
 type VersionDetails struct {
@@ -61,6 +65,7 @@ type VersionDetails struct {
 }
 
 type TestOptions struct {
+	DevEnabled               bool
 	HAEnabled                bool
 	MTLSEnabled              bool
 	ApplyComponentChanges    bool
@@ -189,7 +194,7 @@ func GetTestsOnInstall(details VersionDetails, opts TestOptions) []TestCase {
 
 func GetTestsOnUninstall(details VersionDetails, opts TestOptions) []TestCase {
 	return []TestCase{
-		{"uninstall " + details.RuntimeVersion, uninstallTest(opts.UninstallAll)}, // waits for pod deletion.
+		{"uninstall " + details.RuntimeVersion, uninstallTest(opts.UninstallAll, opts.DevEnabled)}, // waits for pod deletion.
 		{"cluster not exist", kubernetesTestOnUninstall()},
 		{"crds exist on uninstall " + details.RuntimeVersion, CRDTest(details, opts)},
 		{"clusterroles not exist " + details.RuntimeVersion, ClusterRolesTest(details, opts)},
@@ -747,6 +752,10 @@ func installTest(details VersionDetails, opts TestOptions) func(t *testing.T) {
 			"-n", DaprTestNamespace,
 			"--log-as-json",
 		}
+		if opts.DevEnabled {
+			t.Log("install dev mode")
+			args = append(args, "--dev")
+		}
 		if !details.UseDaprLatestVersion {
 			// TODO: Pass dashboard-version also when charts are released.
 			args = append(args, "--runtime-version", details.RuntimeVersion)
@@ -776,10 +785,13 @@ func installTest(details VersionDetails, opts TestOptions) func(t *testing.T) {
 		require.NoError(t, err, "init failed")
 
 		validatePodsOnInstallUpgrade(t, details)
+		if opts.DevEnabled {
+			validateThirdpartyPodsOnInit(t)
+		}
 	}
 }
 
-func uninstallTest(all bool) func(t *testing.T) {
+func uninstallTest(all bool, devEnabled bool) func(t *testing.T) {
 	return func(t *testing.T) {
 		output, err := EnsureUninstall(all)
 		t.Log(output)
@@ -792,11 +804,23 @@ func uninstallTest(all bool) func(t *testing.T) {
 		go waitPodDeletion(t, done, podsDeleted)
 		select {
 		case <-podsDeleted:
-			t.Log("pods were deleted as expected on uninstall")
+			t.Log("dapr pods were deleted as expected on uninstall")
-			return
 		case <-time.After(2 * time.Minute):
 			done <- struct{}{}
-			t.Error("timeout verifying pods were deleted as expectedx")
+			t.Error("timeout verifying pods were deleted as expected")
+			return
+		}
+		if devEnabled {
+			t.Log("waiting for dapr dev pods to be deleted")
+			go waitPodDeletionDev(t, done, podsDeleted)
+			select {
+			case <-podsDeleted:
+				t.Log("dapr dev pods were deleted as expected on uninstall dev")
+				return
+			case <-time.After(2 * time.Minute):
+				done <- struct{}{}
+				t.Error("timeout verifying pods were deleted as expected")
+			}
 		}
 	}
 }
@@ -943,6 +967,41 @@ func httpEndpointOutputCheck(t *testing.T, output string) {
 	assert.Contains(t, output, "httpendpoint")
 }
 
+func validateThirdpartyPodsOnInit(t *testing.T) {
+	ctx := context.Background()
+	ctxt, cancel := context.WithTimeout(ctx, 10*time.Second)
+	defer cancel()
+	k8sClient, err := getClient()
+	require.NoError(t, err)
+	list, err := k8sClient.CoreV1().Pods(thirdPartyDevNamespace).List(ctxt, v1.ListOptions{
+		Limit: 100,
+	})
+	require.NoError(t, err)
+	notFound := map[string]struct{}{
+		devRedisReleaseName:  {},
+		devZipkinReleaseName: {},
+	}
+	prefixes := map[string]string{
+		devRedisReleaseName:  "dapr-dev-redis-master-",
+		devZipkinReleaseName: "dapr-dev-zipkin-",
+	}
+	for _, pod := range list.Items {
+		t.Log(pod.ObjectMeta.Name)
+		for component, prefix := range prefixes {
+			if pod.Status.Phase != core_v1.PodRunning {
+				continue
+			}
+			if !pod.Status.ContainerStatuses[0].Ready {
+				continue
+			}
+			if strings.HasPrefix(pod.ObjectMeta.Name, prefix) {
+				delete(notFound, component)
+			}
+		}
+	}
+	assert.Empty(t, notFound)
+}
+
 func validatePodsOnInstallUpgrade(t *testing.T, details VersionDetails) {
 	ctx := context.Background()
 	ctxt, cancel := context.WithTimeout(ctx, 10*time.Second)
@@ -1010,6 +1069,52 @@ func validatePodsOnInstallUpgrade(t *testing.T, details VersionDetails) {
 	assert.Empty(t, notFound)
 }
 
+func waitPodDeletionDev(t *testing.T, done, podsDeleted chan struct{}) {
+	for {
+		select {
+		case <-done: // if timeout was reached.
+			return
+		default:
+			break
+		}
+		ctx := context.Background()
+		ctxt, cancel := context.WithTimeout(ctx, 10*time.Second)
+		defer cancel()
+		k8sClient, err := getClient()
+		require.NoError(t, err, "error getting k8s client for pods check")
+		list, err := k8sClient.CoreV1().Pods(thirdPartyDevNamespace).List(ctxt, v1.ListOptions{
+			Limit: 100,
+		})
+		require.NoError(t, err)
+		found := map[string]struct{}{
+			devRedisReleaseName:  {},
+			devZipkinReleaseName: {},
+		}
+		prefixes := map[string]string{
+			devRedisReleaseName:  "dapr-dev-redis-master-",
+			devZipkinReleaseName: "dapr-dev-zipkin-",
+		}
+		for _, pod := range list.Items {
+			t.Log(pod.ObjectMeta.Name)
+			for component, prefix := range prefixes {
+				if pod.Status.Phase != core_v1.PodRunning {
+					continue
+				}
+				if !pod.Status.ContainerStatuses[0].Ready {
+					continue
+				}
+				if strings.HasPrefix(pod.ObjectMeta.Name, prefix) {
+					delete(found, component)
+				}
+			}
+		}
+		if len(found) == 2 {
+			podsDeleted <- struct{}{}
+		}
+		time.Sleep(15 * time.Second)
+	}
+}
+
 func waitPodDeletion(t *testing.T, done, podsDeleted chan struct{}) {
 	for {
 		select {

tests/e2e/kubernetes/kubernetes_test.go

@@ -118,6 +118,39 @@ func TestKubernetesHAModeMTLSDisabled(t *testing.T) {
 	}
 }
 
+func TestKubernetesDev(t *testing.T) {
+	// ensure clean env for test
+	ensureCleanEnv(t, false)
+
+	// setup tests
+	tests := []common.TestCase{}
+	tests = append(tests, common.GetTestsOnInstall(currentVersionDetails, common.TestOptions{
+		DevEnabled:            true,
+		HAEnabled:             false,
+		MTLSEnabled:           true,
+		ApplyComponentChanges: true,
+		CheckResourceExists: map[common.Resource]bool{
+			common.CustomResourceDefs:  true,
+			common.ClusterRoles:        true,
+			common.ClusterRoleBindings: true,
+		},
+	})...)
+
+	tests = append(tests, common.GetTestsOnUninstall(currentVersionDetails, common.TestOptions{
+		DevEnabled: true,
+		CheckResourceExists: map[common.Resource]bool{
+			common.CustomResourceDefs:  true,
+			common.ClusterRoles:        false,
+			common.ClusterRoleBindings: false,
+		},
+	})...)
+
+	// execute tests
+	for _, tc := range tests {
+		t.Run(tc.Name, tc.Callable)
+	}
+}
+
 func TestKubernetesNonHAModeMTLSEnabled(t *testing.T) {
 	// ensure clean env for test
 	ensureCleanEnv(t, false)