feat(kubernetesDeploy): consume credentials from environment (#3129)

* feat(kubernetesDeploy): consume credentials from environment

* update vault

* update handling of docker config.json

* chore: remove comments

cmd/kubernetesDeploy.go

@@ -5,55 +5,79 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"regexp"
 	"strconv"
 	"strings"
 
+	piperDocker "github.com/SAP/jenkins-library/pkg/docker"
+
 	"github.com/SAP/jenkins-library/pkg/command"
 	"github.com/SAP/jenkins-library/pkg/log"
+	"github.com/SAP/jenkins-library/pkg/piperutils"
 	"github.com/SAP/jenkins-library/pkg/telemetry"
 )
 
-func kubernetesDeploy(config kubernetesDeployOptions, telemetryData *telemetry.CustomData) {
-	c := command.Command{
-		ErrorCategoryMapping: map[string][]string{
-			log.ErrorConfiguration.String(): {
-				"Error: Get * no such host",
-				"Error: path * not found",
-				"Error: rendered manifests contain a resource that already exists.",
-				"Error: unknown flag",
-				"Error: UPGRADE FAILED: * failed to replace object: * is invalid",
-				"Error: UPGRADE FAILED: * failed to create resource: * is invalid",
-				"Error: UPGRADE FAILED: an error occurred * not found",
-				"Error: UPGRADE FAILED: query: failed to query with labels:",
-				"Invalid value: \"\": field is immutable",
-			},
-			log.ErrorCustom.String(): {
-				"Error: release * failed, * timed out waiting for the condition",
+type kubernetesDeployUtils interface {
+	SetEnv(env []string)
+	Stdout(out io.Writer)
+	Stderr(err io.Writer)
+	RunExecutable(e string, p ...string) error
+
+	piperutils.FileUtils
+}
+
+type kubernetesDeployUtilsBundle struct {
+	*command.Command
+	*piperutils.Files
+}
+
+func newKubernetesDeployUtilsBundle() kubernetesDeployUtils {
+	utils := kubernetesDeployUtilsBundle{
+		Command: &command.Command{
+			ErrorCategoryMapping: map[string][]string{
+				log.ErrorConfiguration.String(): {
+					"Error: Get * no such host",
+					"Error: path * not found",
+					"Error: rendered manifests contain a resource that already exists.",
+					"Error: unknown flag",
+					"Error: UPGRADE FAILED: * failed to replace object: * is invalid",
+					"Error: UPGRADE FAILED: * failed to create resource: * is invalid",
+					"Error: UPGRADE FAILED: an error occurred * not found",
+					"Error: UPGRADE FAILED: query: failed to query with labels:",
+					"Invalid value: \"\": field is immutable",
+				},
+				log.ErrorCustom.String(): {
+					"Error: release * failed, * timed out waiting for the condition",
+				},
 			},
 		},
+		Files: &piperutils.Files{},
 	}
 	// reroute stderr output to logging framework, stdout will be used for command interactions
-	c.Stderr(log.Writer())
+	utils.Stderr(log.Writer())
+	return &utils
+}
+
+func kubernetesDeploy(config kubernetesDeployOptions, telemetryData *telemetry.CustomData) {
+	utils := newKubernetesDeployUtilsBundle()
 
 	// error situations should stop execution through log.Entry().Fatal() call which leads to an os.Exit(1) in the end
-	err := runKubernetesDeploy(config, &c, log.Writer())
+	err := runKubernetesDeploy(config, utils, log.Writer())
 	if err != nil {
 		log.Entry().WithError(err).Fatal("step execution failed")
 	}
 }
 
-func runKubernetesDeploy(config kubernetesDeployOptions, command command.ExecRunner, stdout io.Writer) error {
+func runKubernetesDeploy(config kubernetesDeployOptions, utils kubernetesDeployUtils, stdout io.Writer) error {
 	if config.DeployTool == "helm" || config.DeployTool == "helm3" {
-		return runHelmDeploy(config, command, stdout)
+		return runHelmDeploy(config, utils, stdout)
 	} else if config.DeployTool == "kubectl" {
-		return runKubectlDeploy(config, command)
+		return runKubectlDeploy(config, utils)
 	}
 	return fmt.Errorf("Failed to execute deployments")
 }
 
-func runHelmDeploy(config kubernetesDeployOptions, command command.ExecRunner, stdout io.Writer) error {
+func runHelmDeploy(config kubernetesDeployOptions, utils kubernetesDeployUtils, stdout io.Writer) error {
 	if len(config.ChartPath) <= 0 {
 		return fmt.Errorf("chart path has not been set, please configure chartPath parameter")
 	}
@@ -92,29 +116,29 @@ func runHelmDeploy(config kubernetesDeployOptions, command command.ExecRunner, s
 		helmEnv = append(helmEnv, fmt.Sprintf("TILLER_NAMESPACE=%v", config.TillerNamespace))
 	}
 	log.Entry().Debugf("Helm SetEnv: %v", helmEnv)
-	command.SetEnv(helmEnv)
-	command.Stdout(stdout)
+	utils.SetEnv(helmEnv)
+	utils.Stdout(stdout)
 
 	if config.DeployTool == "helm" {
 		initParams := []string{"init", "--client-only"}
-		if err := command.RunExecutable("helm", initParams...); err != nil {
+		if err := utils.RunExecutable("helm", initParams...); err != nil {
 			log.Entry().WithError(err).Fatal("Helm init call failed")
 		}
 	}
 
 	var secretsData string
 	if len(config.DockerConfigJSON) == 0 && (len(config.ContainerRegistryUser) == 0 || len(config.ContainerRegistryPassword) == 0) {
-		log.Entry().Info("No container registry credentials or docker config.json file provided or credentials incomplete: skipping secret creation")
+		log.Entry().Info("No/incomplete container registry credentials and no docker config.json file provided: skipping secret creation")
 		if len(config.ContainerRegistrySecret) > 0 {
 			secretsData = fmt.Sprintf(",imagePullSecrets[0].name=%v", config.ContainerRegistrySecret)
 		}
 	} else {
 		var dockerRegistrySecret bytes.Buffer
-		command.Stdout(&dockerRegistrySecret)
-		kubeSecretParams := defineKubeSecretParams(config, containerRegistry)
+		utils.Stdout(&dockerRegistrySecret)
+		kubeSecretParams := defineKubeSecretParams(config, containerRegistry, utils)
 		log.Entry().Infof("Calling kubectl create secret --dry-run=true ...")
 		log.Entry().Debugf("kubectl parameters %v", kubeSecretParams)
-		if err := command.RunExecutable("kubectl", kubeSecretParams...); err != nil {
+		if err := utils.RunExecutable("kubectl", kubeSecretParams...); err != nil {
 			log.Entry().WithError(err).Fatal("Retrieving Docker config via kubectl failed")
 		}
 
@@ -190,16 +214,16 @@ func runHelmDeploy(config kubernetesDeployOptions, command command.ExecRunner, s
 		upgradeParams = append(upgradeParams, config.AdditionalParameters...)
 	}
 
-	command.Stdout(stdout)
+	utils.Stdout(stdout)
 	log.Entry().Info("Calling helm upgrade ...")
 	log.Entry().Debugf("Helm parameters %v", upgradeParams)
-	if err := command.RunExecutable("helm", upgradeParams...); err != nil {
+	if err := utils.RunExecutable("helm", upgradeParams...); err != nil {
 		log.Entry().WithError(err).Fatal("Helm upgrade call failed")
 	}
 	return nil
 }
 
-func runKubectlDeploy(config kubernetesDeployOptions, command command.ExecRunner) error {
+func runKubectlDeploy(config kubernetesDeployOptions, utils kubernetesDeployUtils) error {
 	_, containerRegistry, err := splitRegistryURL(config.ContainerRegistryURL)
 	if err != nil {
 		log.Entry().WithError(err).Fatalf("Container registry url '%v' incorrect", config.ContainerRegistryURL)
@@ -213,7 +237,7 @@ func runKubectlDeploy(config kubernetesDeployOptions, command command.ExecRunner
 	if len(config.KubeConfig) > 0 {
 		log.Entry().Info("Using KUBECONFIG environment for authentication.")
 		kubeEnv := []string{fmt.Sprintf("KUBECONFIG=%v", config.KubeConfig)}
-		command.SetEnv(kubeEnv)
+		utils.SetEnv(kubeEnv)
 		if len(config.KubeContext) > 0 {
 			kubeParams = append(kubeParams, fmt.Sprintf("--context=%v", config.KubeContext))
 		}
@@ -231,19 +255,21 @@ func runKubectlDeploy(config kubernetesDeployOptions, command command.ExecRunner
 
 		// first check if secret already exists
 		kubeCheckParams := append(kubeParams, "get", "secret", config.ContainerRegistrySecret)
-		if err := command.RunExecutable("kubectl", kubeCheckParams...); err != nil {
+
+		// ToDo: always update the secret using a yaml definition
+		if err := utils.RunExecutable("kubectl", kubeCheckParams...); err != nil {
 			log.Entry().Infof("Registry secret '%v' does not exist, let's create it ...", config.ContainerRegistrySecret)
-			kubeSecretParams := defineKubeSecretParams(config, containerRegistry)
+			kubeSecretParams := defineKubeSecretParams(config, containerRegistry, utils)
 			kubeSecretParams = append(kubeParams, kubeSecretParams...)
 			log.Entry().Infof("Creating container registry secret '%v'", config.ContainerRegistrySecret)
 			log.Entry().Debugf("Running kubectl with following parameters: %v", kubeSecretParams)
-			if err := command.RunExecutable("kubectl", kubeSecretParams...); err != nil {
+			if err := utils.RunExecutable("kubectl", kubeSecretParams...); err != nil {
 				log.Entry().WithError(err).Fatal("Creating container registry secret failed")
 			}
 		}
 	}
 
-	appTemplate, err := ioutil.ReadFile(config.AppTemplate)
+	appTemplate, err := utils.FileRead(config.AppTemplate)
 	if err != nil {
 		log.Entry().WithError(err).Fatalf("Error when reading appTemplate '%v'", config.AppTemplate)
 	}
@@ -263,7 +289,7 @@ func runKubectlDeploy(config kubernetesDeployOptions, command command.ExecRunner
 	re := regexp.MustCompile(`image:[ ]*<image-name>`)
 	appTemplate = []byte(re.ReplaceAllString(string(appTemplate), fmt.Sprintf("image: %v/%v", containerRegistry, fullImage)))
 
-	err = ioutil.WriteFile(config.AppTemplate, appTemplate, 0700)
+	err = utils.FileWrite(config.AppTemplate, appTemplate, 0700)
 	if err != nil {
 		log.Entry().WithError(err).Fatalf("Error when updating appTemplate '%v'", config.AppTemplate)
 	}
@@ -276,8 +302,7 @@ func runKubectlDeploy(config kubernetesDeployOptions, command command.ExecRunner
 	if len(config.AdditionalParameters) > 0 {
 		kubeParams = append(kubeParams, config.AdditionalParameters...)
 	}
-
-	if err := command.RunExecutable("kubectl", kubeParams...); err != nil {
+	if err := utils.RunExecutable("kubectl", kubeParams...); err != nil {
 		log.Entry().Debugf("Running kubectl with following parameters: %v", kubeParams)
 		log.Entry().WithError(err).Fatal("Deployment with kubectl failed.")
 	}
@@ -308,7 +333,7 @@ func splitFullImageName(image string) (imageName, tag string, err error) {
 	return "", "", fmt.Errorf("Failed to split image name '%v'", image)
 }
 
-func defineKubeSecretParams(config kubernetesDeployOptions, containerRegistry string) []string {
+func defineKubeSecretParams(config kubernetesDeployOptions, containerRegistry string, utils kubernetesDeployUtils) []string {
 	kubeSecretParams := []string{
 		"create",
 		"secret",
@@ -323,6 +348,15 @@ func defineKubeSecretParams(config kubernetesDeployOptions, containerRegistry st
 	}
 
 	if len(config.DockerConfigJSON) > 0 {
+		// first enhance config.json with additional pipeline-related credentials if they have been provided
+		if len(containerRegistry) > 0 && len(config.ContainerRegistryUser) > 0 && len(config.ContainerRegistryPassword) > 0 {
+			var err error
+			_, err = piperDocker.CreateDockerConfigJSON(containerRegistry, config.ContainerRegistryUser, config.ContainerRegistryPassword, "", config.DockerConfigJSON, utils)
+			if err != nil {
+				log.Entry().Warningf("failed to update Docker config.json: %v", err)
+			}
+		}
+
 		return append(
 			kubeSecretParams,
 			"generic",

cmd/kubernetesDeploy_generated.go

@@ -251,6 +251,11 @@ func kubernetesDeployMetadata() config.StepData {
 								Param: "password",
 								Type:  "secret",
 							},
+
+							{
+								Name:  "commonPipelineEnvironment",
+								Param: "custom/repositoryPassword",
+							},
 						},
 						Scope:     []string{"PARAMETERS", "STAGES", "STEPS"},
 						Type:      "string",
@@ -303,6 +308,11 @@ func kubernetesDeployMetadata() config.StepData {
 								Param: "username",
 								Type:  "secret",
 							},
+
+							{
+								Name:  "commonPipelineEnvironment",
+								Param: "custom/repositoryUsername",
+							},
 						},
 						Scope:     []string{"PARAMETERS", "STAGES", "STEPS"},
 						Type:      "string",
@@ -414,7 +424,7 @@ func kubernetesDeployMetadata() config.StepData {
 							},
 
 							{
-								Name:    "kubeConfigFileSecretName",
+								Name:    "kubeConfigFileVaultSecretName",
 								Type:    "vaultSecretFile",
 								Default: "kube-config",
 							},
@@ -469,11 +479,6 @@ func kubernetesDeployMetadata() config.StepData {
 					{
 						Name: "dockerConfigJSON",
 						ResourceRef: []config.ResourceReference{
-							{
-								Name:  "commonPipelineEnvironment",
-								Param: "custom/dockerConfigJSON",
-							},
-
 							{
 								Name: "dockerConfigJsonCredentialsId",
 								Type: "secret",

cmd/kubernetesDeploy_test.go

@@ -3,9 +3,6 @@ package cmd
 import (
 	"bytes"
 	"fmt"
-	"io/ioutil"
-	"os"
-	"path/filepath"
 	"testing"
 
 	"github.com/SAP/jenkins-library/pkg/mock"
@@ -13,6 +10,23 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
+type kubernetesDeployMockUtils struct {
+	shouldFail     bool
+	requestedUrls  []string
+	requestedFiles []string
+	*mock.FilesMock
+	*mock.ExecMockRunner
+}
+
+func newKubernetesDeployMockUtils() kubernetesDeployMockUtils {
+	utils := kubernetesDeployMockUtils{
+		shouldFail:     false,
+		FilesMock:      &mock.FilesMock{},
+		ExecMockRunner: &mock.ExecMockRunner{},
+	}
+	return utils
+}
+
 func TestRunKubernetesDeploy(t *testing.T) {
 
 	t.Run("test helm", func(t *testing.T) {
@@ -35,23 +49,22 @@ func TestRunKubernetesDeploy(t *testing.T) {
 
 		dockerConfigJSON := `{"kind": "Secret","data":{".dockerconfigjson": "ThisIsOurBase64EncodedSecret=="}}`
 
-		e := mock.ExecMockRunner{
-			StdoutReturn: map[string]string{
-				`kubectl create secret --insecure-skip-tls-verify=true --dry-run=true --output=json docker-registry testSecret --docker-server=my.registry:55555 --docker-username=registryUser --docker-password=\*\*\*\*\*\*\*\*`: dockerConfigJSON,
-			},
+		mockUtils := newKubernetesDeployMockUtils()
+		mockUtils.StdoutReturn = map[string]string{
+			`kubectl create secret --insecure-skip-tls-verify=true --dry-run=true --output=json docker-registry testSecret --docker-server=my.registry:55555 --docker-username=registryUser --docker-password=\*\*\*\*\*\*\*\*`: dockerConfigJSON,
 		}
 
 		var stdout bytes.Buffer
 
-		runKubernetesDeploy(opts, &e, &stdout)
+		runKubernetesDeploy(opts, mockUtils, &stdout)
 
-		assert.Equal(t, "helm", e.Calls[0].Exec, "Wrong init command")
-		assert.Equal(t, []string{"init", "--client-only"}, e.Calls[0].Params, "Wrong init parameters")
+		assert.Equal(t, "helm", mockUtils.Calls[0].Exec, "Wrong init command")
+		assert.Equal(t, []string{"init", "--client-only"}, mockUtils.Calls[0].Params, "Wrong init parameters")
 
-		assert.Equal(t, "kubectl", e.Calls[1].Exec, "Wrong secret creation command")
-		assert.Equal(t, []string{"create", "secret", "--insecure-skip-tls-verify=true", "--dry-run=true", "--output=json", "docker-registry", "testSecret", "--docker-server=my.registry:55555", "--docker-username=registryUser", "--docker-password=********"}, e.Calls[1].Params, "Wrong secret creation parameters")
+		assert.Equal(t, "kubectl", mockUtils.Calls[1].Exec, "Wrong secret creation command")
+		assert.Equal(t, []string{"create", "secret", "--insecure-skip-tls-verify=true", "--dry-run=true", "--output=json", "docker-registry", "testSecret", "--docker-server=my.registry:55555", "--docker-username=registryUser", "--docker-password=********"}, mockUtils.Calls[1].Params, "Wrong secret creation parameters")
 
-		assert.Equal(t, "helm", e.Calls[2].Exec, "Wrong upgrade command")
+		assert.Equal(t, "helm", mockUtils.Calls[2].Exec, "Wrong upgrade command")
 		assert.Equal(t, []string{
 			"upgrade",
 			"deploymentName",
@@ -70,7 +83,7 @@ func TestRunKubernetesDeploy(t *testing.T) {
 			"testCluster",
 			"--testParam",
 			"testValue",
-		}, e.Calls[2].Params, "Wrong upgrade parameters")
+		}, mockUtils.Calls[2].Params, "Wrong upgrade parameters")
 	})
 
 	t.Run("test helm - with containerImageName and containerImageTag instead of image", func(t *testing.T) {
@@ -94,25 +107,24 @@ func TestRunKubernetesDeploy(t *testing.T) {
 
 		dockerConfigJSON := `{"kind": "Secret","data":{".dockerconfigjson": "ThisIsOurBase64EncodedSecret=="}}`
 
-		e := mock.ExecMockRunner{
-			StdoutReturn: map[string]string{
-				`kubectl create secret --insecure-skip-tls-verify=true --dry-run=true --output=json docker-registry testSecret --docker-server=my.registry:55555 --docker-username=registryUser --docker-password=\*\*\*\*\*\*\*\*`: dockerConfigJSON,
-			},
+		mockUtils := newKubernetesDeployMockUtils()
+		mockUtils.StdoutReturn = map[string]string{
+			`kubectl create secret --insecure-skip-tls-verify=true --dry-run=true --output=json docker-registry testSecret --docker-server=my.registry:55555 --docker-username=registryUser --docker-password=\*\*\*\*\*\*\*\*`: dockerConfigJSON,
 		}
 
 		var stdout bytes.Buffer
 
-		runKubernetesDeploy(opts, &e, &stdout)
+		runKubernetesDeploy(opts, mockUtils, &stdout)
 
-		assert.Equal(t, "helm", e.Calls[0].Exec, "Wrong init command")
-		assert.Equal(t, []string{"init", "--client-only"}, e.Calls[0].Params, "Wrong init parameters")
+		assert.Equal(t, "helm", mockUtils.Calls[0].Exec, "Wrong init command")
+		assert.Equal(t, []string{"init", "--client-only"}, mockUtils.Calls[0].Params, "Wrong init parameters")
 
-		assert.Equal(t, "kubectl", e.Calls[1].Exec, "Wrong secret creation command")
-		assert.Equal(t, []string{"create", "secret", "--insecure-skip-tls-verify=true", "--dry-run=true", "--output=json", "docker-registry", "testSecret", "--docker-server=my.registry:55555", "--docker-username=registryUser", "--docker-password=********"}, e.Calls[1].Params, "Wrong secret creation parameters")
+		assert.Equal(t, "kubectl", mockUtils.Calls[1].Exec, "Wrong secret creation command")
+		assert.Equal(t, []string{"create", "secret", "--insecure-skip-tls-verify=true", "--dry-run=true", "--output=json", "docker-registry", "testSecret", "--docker-server=my.registry:55555", "--docker-username=registryUser", "--docker-password=********"}, mockUtils.Calls[1].Params, "Wrong secret creation parameters")
 
-		assert.Equal(t, "helm", e.Calls[2].Exec, "Wrong upgrade command")
+		assert.Equal(t, "helm", mockUtils.Calls[2].Exec, "Wrong upgrade command")
 
-		assert.Contains(t, e.Calls[2].Params, "image.repository=my.registry:55555/path/to/Image,image.tag=latest,secret.name=testSecret,secret.dockerconfigjson=ThisIsOurBase64EncodedSecret==,imagePullSecrets[0].name=testSecret,ingress.hosts[0]=ingress.host1,ingress.hosts[1]=ingress.host2", "Wrong upgrade parameters")
+		assert.Contains(t, mockUtils.Calls[2].Params, "image.repository=my.registry:55555/path/to/Image,image.tag=latest,secret.name=testSecret,secret.dockerconfigjson=ThisIsOurBase64EncodedSecret==,imagePullSecrets[0].name=testSecret,ingress.hosts[0]=ingress.host1,ingress.hosts[1]=ingress.host2", "Wrong upgrade parameters")
 	})
 
 	t.Run("test helm - docker config.json path passed as parameter", func(t *testing.T) {
@@ -133,21 +145,22 @@ func TestRunKubernetesDeploy(t *testing.T) {
 		}
 
 		k8sSecretSpec := `{"kind": "Secret","data":{".dockerconfigjson": "ThisIsOurBase64EncodedSecret=="}}`
-		e := mock.ExecMockRunner{
-			StdoutReturn: map[string]string{
-				`kubectl create secret --insecure-skip-tls-verify=true --dry-run=true --output=json generic testSecret --from-file=.dockerconfigjson=/path/to/.docker/config.json --type=kubernetes.io/dockerconfigjson`: k8sSecretSpec,
-			},
+
+		mockUtils := newKubernetesDeployMockUtils()
+		mockUtils.AddFile("/path/to/.docker/config.json", []byte("ThisIsOurBase64EncodedSecret=="))
+		mockUtils.StdoutReturn = map[string]string{
+			`kubectl create secret --insecure-skip-tls-verify=true --dry-run=true --output=json generic testSecret --from-file=.dockerconfigjson=/path/to/.docker/config.json --type=kubernetes.io/dockerconfigjson`: k8sSecretSpec,
 		}
 
 		var stdout bytes.Buffer
 
-		err := runKubernetesDeploy(opts, &e, &stdout)
+		err := runKubernetesDeploy(opts, mockUtils, &stdout)
 		assert.NoError(t, err)
 
-		assert.Equal(t, "helm", e.Calls[0].Exec, "Wrong init command")
-		assert.Equal(t, []string{"init", "--client-only"}, e.Calls[0].Params, "Wrong init parameters")
+		assert.Equal(t, "helm", mockUtils.Calls[0].Exec, "Wrong init command")
+		assert.Equal(t, []string{"init", "--client-only"}, mockUtils.Calls[0].Params, "Wrong init parameters")
 
-		assert.Equal(t, "kubectl", e.Calls[1].Exec, "Wrong secret creation command")
+		assert.Equal(t, "kubectl", mockUtils.Calls[1].Exec, "Wrong secret creation command")
 		assert.Equal(t, []string{
 			"create",
 			"secret",
@@ -158,9 +171,9 @@ func TestRunKubernetesDeploy(t *testing.T) {
 			"testSecret",
 			"--from-file=.dockerconfigjson=/path/to/.docker/config.json",
 			`--type=kubernetes.io/dockerconfigjson`,
-		}, e.Calls[1].Params, "Wrong secret creation parameters")
+		}, mockUtils.Calls[1].Params, "Wrong secret creation parameters")
 
-		assert.Equal(t, "helm", e.Calls[2].Exec, "Wrong upgrade command")
+		assert.Equal(t, "helm", mockUtils.Calls[2].Exec, "Wrong upgrade command")
 		assert.Equal(t, []string{
 			"upgrade",
 			"deploymentName",
@@ -179,7 +192,7 @@ func TestRunKubernetesDeploy(t *testing.T) {
 			"testCluster",
 			"--testParam",
 			"testValue",
-		}, e.Calls[2].Params, "Wrong upgrade parameters")
+		}, mockUtils.Calls[2].Params, "Wrong upgrade parameters")
 	})
 
 	t.Run("test helm -- keep failed deployment", func(t *testing.T) {
@@ -203,23 +216,22 @@ func TestRunKubernetesDeploy(t *testing.T) {
 
 		k8sSecretSpec := `{"kind": "Secret","data":{".dockerconfigjson": "ThisIsOurBase64EncodedSecret=="}}`
 
-		e := mock.ExecMockRunner{
-			StdoutReturn: map[string]string{
-				`kubectl create secret --insecure-skip-tls-verify=true --dry-run=true --output=json docker-registry testSecret --docker-server=my.registry:55555 --docker-username=registryUser --docker-password=\*\*\*\*\*\*\*\*`: k8sSecretSpec,
-			},
+		mockUtils := newKubernetesDeployMockUtils()
+		mockUtils.StdoutReturn = map[string]string{
+			`kubectl create secret --insecure-skip-tls-verify=true --dry-run=true --output=json docker-registry testSecret --docker-server=my.registry:55555 --docker-username=registryUser --docker-password=\*\*\*\*\*\*\*\*`: k8sSecretSpec,
 		}
 
 		var stdout bytes.Buffer
 
-		runKubernetesDeploy(opts, &e, &stdout)
+		runKubernetesDeploy(opts, mockUtils, &stdout)
 
-		assert.Equal(t, "helm", e.Calls[0].Exec, "Wrong init command")
-		assert.Equal(t, []string{"init", "--client-only"}, e.Calls[0].Params, "Wrong init parameters")
+		assert.Equal(t, "helm", mockUtils.Calls[0].Exec, "Wrong init command")
+		assert.Equal(t, []string{"init", "--client-only"}, mockUtils.Calls[0].Params, "Wrong init parameters")
 
-		assert.Equal(t, "kubectl", e.Calls[1].Exec, "Wrong secret creation command")
-		assert.Equal(t, []string{"create", "secret", "--insecure-skip-tls-verify=true", "--dry-run=true", "--output=json", "docker-registry", "testSecret", "--docker-server=my.registry:55555", "--docker-username=registryUser", "--docker-password=********"}, e.Calls[1].Params, "Wrong secret creation parameters")
+		assert.Equal(t, "kubectl", mockUtils.Calls[1].Exec, "Wrong secret creation command")
+		assert.Equal(t, []string{"create", "secret", "--insecure-skip-tls-verify=true", "--dry-run=true", "--output=json", "docker-registry", "testSecret", "--docker-server=my.registry:55555", "--docker-username=registryUser", "--docker-password=********"}, mockUtils.Calls[1].Params, "Wrong secret creation parameters")
 
-		assert.Equal(t, "helm", e.Calls[2].Exec, "Wrong upgrade command")
+		assert.Equal(t, "helm", mockUtils.Calls[2].Exec, "Wrong upgrade command")
 		assert.Equal(t, []string{
 			"upgrade",
 			"deploymentName",
@@ -237,7 +249,7 @@ func TestRunKubernetesDeploy(t *testing.T) {
 			"testCluster",
 			"--testParam",
 			"testValue",
-		}, e.Calls[2].Params, "Wrong upgrade parameters")
+		}, mockUtils.Calls[2].Params, "Wrong upgrade parameters")
 	})
 
 	t.Run("test helm - fails without image information", func(t *testing.T) {
@@ -254,11 +266,11 @@ func TestRunKubernetesDeploy(t *testing.T) {
 			KubeContext:             "testCluster",
 			Namespace:               "deploymentNamespace",
 		}
-		e := mock.ExecMockRunner{}
+		mockUtils := newKubernetesDeployMockUtils()
 
 		var stdout bytes.Buffer
 
-		err := runKubernetesDeploy(opts, &e, &stdout)
+		err := runKubernetesDeploy(opts, mockUtils, &stdout)
 		assert.EqualError(t, err, "image information not given - please either set image or containerImageName and containerImageTag")
 	})
 
@@ -282,20 +294,19 @@ func TestRunKubernetesDeploy(t *testing.T) {
 
 		dockerConfigJSON := `{"kind": "Secret","data":{".dockerconfigjson": "ThisIsOurBase64EncodedSecret=="}}`
 
-		e := mock.ExecMockRunner{
-			StdoutReturn: map[string]string{
-				`kubectl create secret --insecure-skip-tls-verify=true --dry-run=true --output=json docker-registry testSecret --docker-server=my.registry:55555 --docker-username=registryUser --docker-password=\*\*\*\*\*\*\*\*`: dockerConfigJSON,
-			},
+		mockUtils := newKubernetesDeployMockUtils()
+		mockUtils.StdoutReturn = map[string]string{
+			`kubectl create secret --insecure-skip-tls-verify=true --dry-run=true --output=json docker-registry testSecret --docker-server=my.registry:55555 --docker-username=registryUser --docker-password=\*\*\*\*\*\*\*\*`: dockerConfigJSON,
 		}
 
 		var stdout bytes.Buffer
 
-		runKubernetesDeploy(opts, &e, &stdout)
+		runKubernetesDeploy(opts, mockUtils, &stdout)
 
-		assert.Equal(t, "kubectl", e.Calls[0].Exec, "Wrong secret creation command")
-		assert.Equal(t, []string{"create", "secret", "--insecure-skip-tls-verify=true", "--dry-run=true", "--output=json", "docker-registry", "testSecret", "--docker-server=my.registry:55555", "--docker-username=registryUser", "--docker-password=********"}, e.Calls[0].Params, "Wrong secret creation parameters")
+		assert.Equal(t, "kubectl", mockUtils.Calls[0].Exec, "Wrong secret creation command")
+		assert.Equal(t, []string{"create", "secret", "--insecure-skip-tls-verify=true", "--dry-run=true", "--output=json", "docker-registry", "testSecret", "--docker-server=my.registry:55555", "--docker-username=registryUser", "--docker-password=********"}, mockUtils.Calls[0].Params, "Wrong secret creation parameters")
 
-		assert.Equal(t, "helm", e.Calls[1].Exec, "Wrong upgrade command")
+		assert.Equal(t, "helm", mockUtils.Calls[1].Exec, "Wrong upgrade command")
 		assert.Equal(t, []string{
 			"upgrade",
 			"deploymentName",
@@ -318,7 +329,7 @@ func TestRunKubernetesDeploy(t *testing.T) {
 			"testCluster",
 			"--testParam",
 			"testValue",
-		}, e.Calls[1].Params, "Wrong upgrade parameters")
+		}, mockUtils.Calls[1].Params, "Wrong upgrade parameters")
 	})
 
 	t.Run("test helm v3 - with containerImageName and containerImageTag instead of image", func(t *testing.T) {
@@ -342,22 +353,21 @@ func TestRunKubernetesDeploy(t *testing.T) {
 
 		dockerConfigJSON := `{"kind": "Secret","data":{".dockerconfigjson": "ThisIsOurBase64EncodedSecret=="}}`
 
-		e := mock.ExecMockRunner{
-			StdoutReturn: map[string]string{
-				`kubectl create secret --insecure-skip-tls-verify=true --dry-run=true --output=json docker-registry testSecret --docker-server=my.registry:55555 --docker-username=registryUser --docker-password=\*\*\*\*\*\*\*\*`: dockerConfigJSON,
-			},
+		mockUtils := newKubernetesDeployMockUtils()
+		mockUtils.StdoutReturn = map[string]string{
+			`kubectl create secret --insecure-skip-tls-verify=true --dry-run=true --output=json docker-registry testSecret --docker-server=my.registry:55555 --docker-username=registryUser --docker-password=\*\*\*\*\*\*\*\*`: dockerConfigJSON,
 		}
 
 		var stdout bytes.Buffer
 
-		runKubernetesDeploy(opts, &e, &stdout)
+		runKubernetesDeploy(opts, mockUtils, &stdout)
 
-		assert.Equal(t, "kubectl", e.Calls[0].Exec, "Wrong secret creation command")
-		assert.Equal(t, []string{"create", "secret", "--insecure-skip-tls-verify=true", "--dry-run=true", "--output=json", "docker-registry", "testSecret", "--docker-server=my.registry:55555", "--docker-username=registryUser", "--docker-password=********"}, e.Calls[0].Params, "Wrong secret creation parameters")
+		assert.Equal(t, "kubectl", mockUtils.Calls[0].Exec, "Wrong secret creation command")
+		assert.Equal(t, []string{"create", "secret", "--insecure-skip-tls-verify=true", "--dry-run=true", "--output=json", "docker-registry", "testSecret", "--docker-server=my.registry:55555", "--docker-username=registryUser", "--docker-password=********"}, mockUtils.Calls[0].Params, "Wrong secret creation parameters")
 
-		assert.Equal(t, "helm", e.Calls[1].Exec, "Wrong upgrade command")
+		assert.Equal(t, "helm", mockUtils.Calls[1].Exec, "Wrong upgrade command")
 
-		assert.Contains(t, e.Calls[1].Params, "image.repository=my.registry:55555/path/to/Image,image.tag=latest,secret.name=testSecret,secret.dockerconfigjson=ThisIsOurBase64EncodedSecret==,imagePullSecrets[0].name=testSecret", "Wrong upgrade parameters")
+		assert.Contains(t, mockUtils.Calls[1].Params, "image.repository=my.registry:55555/path/to/Image,image.tag=latest,secret.name=testSecret,secret.dockerconfigjson=ThisIsOurBase64EncodedSecret==,imagePullSecrets[0].name=testSecret", "Wrong upgrade parameters")
 
 	})
 
@@ -375,11 +385,11 @@ func TestRunKubernetesDeploy(t *testing.T) {
 			KubeContext:             "testCluster",
 			Namespace:               "deploymentNamespace",
 		}
-		e := mock.ExecMockRunner{}
+		mockUtils := newKubernetesDeployMockUtils()
 
 		var stdout bytes.Buffer
 
-		err := runKubernetesDeploy(opts, &e, &stdout)
+		err := runKubernetesDeploy(opts, mockUtils, &stdout)
 		assert.EqualError(t, err, "image information not given - please either set image or containerImageName and containerImageTag")
 	})
 
@@ -404,20 +414,19 @@ func TestRunKubernetesDeploy(t *testing.T) {
 
 		dockerConfigJSON := `{"kind": "Secret","data":{".dockerconfigjson": "ThisIsOurBase64EncodedSecret=="}}`
 
-		e := mock.ExecMockRunner{
-			StdoutReturn: map[string]string{
-				`kubectl create secret --insecure-skip-tls-verify=true --dry-run=true --output=json docker-registry testSecret --docker-server=my.registry:55555 --docker-username=registryUser --docker-password=\*\*\*\*\*\*\*\*`: dockerConfigJSON,
-			},
+		mockUtils := newKubernetesDeployMockUtils()
+		mockUtils.StdoutReturn = map[string]string{
+			`kubectl create secret --insecure-skip-tls-verify=true --dry-run=true --output=json docker-registry testSecret --docker-server=my.registry:55555 --docker-username=registryUser --docker-password=\*\*\*\*\*\*\*\*`: dockerConfigJSON,
 		}
 
 		var stdout bytes.Buffer
 
-		runKubernetesDeploy(opts, &e, &stdout)
+		runKubernetesDeploy(opts, mockUtils, &stdout)
 
-		assert.Equal(t, "kubectl", e.Calls[0].Exec, "Wrong secret creation command")
-		assert.Equal(t, []string{"create", "secret", "--insecure-skip-tls-verify=true", "--dry-run=true", "--output=json", "docker-registry", "testSecret", "--docker-server=my.registry:55555", "--docker-username=registryUser", "--docker-password=********"}, e.Calls[0].Params, "Wrong secret creation parameters")
+		assert.Equal(t, "kubectl", mockUtils.Calls[0].Exec, "Wrong secret creation command")
+		assert.Equal(t, []string{"create", "secret", "--insecure-skip-tls-verify=true", "--dry-run=true", "--output=json", "docker-registry", "testSecret", "--docker-server=my.registry:55555", "--docker-username=registryUser", "--docker-password=********"}, mockUtils.Calls[0].Params, "Wrong secret creation parameters")
 
-		assert.Equal(t, "helm", e.Calls[1].Exec, "Wrong upgrade command")
+		assert.Equal(t, "helm", mockUtils.Calls[1].Exec, "Wrong upgrade command")
 		assert.Equal(t, []string{
 			"upgrade",
 			"deploymentName",
@@ -439,7 +448,7 @@ func TestRunKubernetesDeploy(t *testing.T) {
 			"testCluster",
 			"--testParam",
 			"testValue",
-		}, e.Calls[1].Params, "Wrong upgrade parameters")
+		}, mockUtils.Calls[1].Params, "Wrong upgrade parameters")
 	})
 
 	t.Run("test helm v3 - no container credentials", func(t *testing.T) {
@@ -457,14 +466,14 @@ func TestRunKubernetesDeploy(t *testing.T) {
 			KubeContext:             "testCluster",
 			Namespace:               "deploymentNamespace",
 		}
-		e := mock.ExecMockRunner{}
+		mockUtils := newKubernetesDeployMockUtils()
 
 		var stdout bytes.Buffer
 
-		runKubernetesDeploy(opts, &e, &stdout)
+		runKubernetesDeploy(opts, mockUtils, &stdout)
 
-		assert.Equal(t, 1, len(e.Calls), "Wrong number of upgrade commands")
-		assert.Equal(t, "helm", e.Calls[0].Exec, "Wrong upgrade command")
+		assert.Equal(t, 1, len(mockUtils.Calls), "Wrong number of upgrade commands")
+		assert.Equal(t, "helm", mockUtils.Calls[0].Exec, "Wrong upgrade command")
 		assert.Equal(t, []string{
 			"upgrade",
 			"deploymentName",
@@ -483,7 +492,7 @@ func TestRunKubernetesDeploy(t *testing.T) {
 			"testCluster",
 			"--testParam",
 			"testValue",
-		}, e.Calls[0].Params, "Wrong upgrade parameters")
+		}, mockUtils.Calls[0].Params, "Wrong upgrade parameters")
 	})
 
 	t.Run("test helm v3 - fails without chart path", func(t *testing.T) {
@@ -500,11 +509,11 @@ func TestRunKubernetesDeploy(t *testing.T) {
 			KubeContext:             "testCluster",
 			Namespace:               "deploymentNamespace",
 		}
-		e := mock.ExecMockRunner{}
+		mockUtils := newKubernetesDeployMockUtils()
 
 		var stdout bytes.Buffer
 
-		err := runKubernetesDeploy(opts, &e, &stdout)
+		err := runKubernetesDeploy(opts, mockUtils, &stdout)
 		assert.EqualError(t, err, "chart path has not been set, please configure chartPath parameter")
 	})
 
@@ -522,11 +531,11 @@ func TestRunKubernetesDeploy(t *testing.T) {
 			KubeContext:             "testCluster",
 			Namespace:               "deploymentNamespace",
 		}
-		e := mock.ExecMockRunner{}
+		mockUtils := newKubernetesDeployMockUtils()
 
 		var stdout bytes.Buffer
 
-		err := runKubernetesDeploy(opts, &e, &stdout)
+		err := runKubernetesDeploy(opts, mockUtils, &stdout)
 		assert.EqualError(t, err, "deployment name has not been set, please configure deploymentName parameter")
 	})
 
@@ -544,11 +553,11 @@ func TestRunKubernetesDeploy(t *testing.T) {
 			KubeContext:             "testCluster",
 			Namespace:               "deploymentNamespace",
 		}
-		e := mock.ExecMockRunner{}
+		mockUtils := newKubernetesDeployMockUtils()
 
 		var stdout bytes.Buffer
 
-		runKubernetesDeploy(opts, &e, &stdout)
+		runKubernetesDeploy(opts, mockUtils, &stdout)
 		assert.Equal(t, []string{
 			"upgrade",
 			"deploymentName",
@@ -566,16 +575,13 @@ func TestRunKubernetesDeploy(t *testing.T) {
 			"testCluster",
 			"--testParam",
 			"testValue",
-		}, e.Calls[0].Params, "Wrong upgrade parameters")
+		}, mockUtils.Calls[0].Params, "Wrong upgrade parameters")
 	})
 
 	t.Run("test kubectl - create secret/kubeconfig", func(t *testing.T) {
-		dir, err := ioutil.TempDir("", "")
-		defer os.RemoveAll(dir) // clean up
-		assert.NoError(t, err, "Error when creating temp dir")
 
 		opts := kubernetesDeployOptions{
-			AppTemplate:                filepath.Join(dir, "test.yaml"),
+			AppTemplate:                "path/to/test.yaml",
 			ContainerRegistryURL:       "https://my.registry:55555",
 			ContainerRegistryUser:      "registryUser",
 			ContainerRegistryPassword:  "********",
@@ -596,19 +602,18 @@ spec:
   spec:
     image: <image-name>`
 
-		ioutil.WriteFile(opts.AppTemplate, []byte(kubeYaml), 0755)
+		mockUtils := newKubernetesDeployMockUtils()
+		mockUtils.AddFile(opts.AppTemplate, []byte(kubeYaml))
 
-		e := mock.ExecMockRunner{
-			ShouldFailOnCommand: map[string]error{
-				"kubectl --insecure-skip-tls-verify=true --namespace=deploymentNamespace --context=testCluster get secret regSecret": fmt.Errorf("secret not found"),
-			},
+		mockUtils.ShouldFailOnCommand = map[string]error{
+			"kubectl --insecure-skip-tls-verify=true --namespace=deploymentNamespace --context=testCluster get secret regSecret": fmt.Errorf("secret not found"),
 		}
 		var stdout bytes.Buffer
-		runKubernetesDeploy(opts, &e, &stdout)
+		runKubernetesDeploy(opts, mockUtils, &stdout)
 
-		assert.Equal(t, e.Env, []string{"KUBECONFIG=This is my kubeconfig"})
+		assert.Equal(t, mockUtils.Env, []string{"KUBECONFIG=This is my kubeconfig"})
 
-		assert.Equal(t, "kubectl", e.Calls[0].Exec, "Wrong secret lookup command")
+		assert.Equal(t, "kubectl", mockUtils.Calls[0].Exec, "Wrong secret lookup command")
 		assert.Equal(t, []string{
 			"--insecure-skip-tls-verify=true",
 			fmt.Sprintf("--namespace=%v", opts.Namespace),
@@ -616,9 +621,9 @@ spec:
 			"get",
 			"secret",
 			opts.ContainerRegistrySecret,
-		}, e.Calls[0].Params, "kubectl parameters incorrect")
+		}, mockUtils.Calls[0].Params, "kubectl parameters incorrect")
 
-		assert.Equal(t, "kubectl", e.Calls[1].Exec, "Wrong secret create command")
+		assert.Equal(t, "kubectl", mockUtils.Calls[1].Exec, "Wrong secret create command")
 		assert.Equal(t, []string{
 			"--insecure-skip-tls-verify=true",
 			fmt.Sprintf("--namespace=%v", opts.Namespace),
@@ -630,9 +635,9 @@ spec:
 			"--docker-server=my.registry:55555",
 			fmt.Sprintf("--docker-username=%v", opts.ContainerRegistryUser),
 			fmt.Sprintf("--docker-password=%v", opts.ContainerRegistryPassword),
-		}, e.Calls[1].Params, "kubectl parameters incorrect")
+		}, mockUtils.Calls[1].Params, "kubectl parameters incorrect")
 
-		assert.Equal(t, "kubectl", e.Calls[2].Exec, "Wrong apply command")
+		assert.Equal(t, "kubectl", mockUtils.Calls[2].Exec, "Wrong apply command")
 		assert.Equal(t, []string{
 			"--insecure-skip-tls-verify=true",
 			fmt.Sprintf("--namespace=%v", opts.Namespace),
@@ -642,19 +647,16 @@ spec:
 			opts.AppTemplate,
 			"--testParam",
 			"testValue",
-		}, e.Calls[2].Params, "kubectl parameters incorrect")
+		}, mockUtils.Calls[2].Params, "kubectl parameters incorrect")
 
-		appTemplate, err := ioutil.ReadFile(opts.AppTemplate)
+		appTemplate, _ := mockUtils.FileRead(opts.AppTemplate)
 		assert.Contains(t, string(appTemplate), "my.registry:55555/path/to/Image:latest")
 	})
 
 	t.Run("test kubectl - create secret from docker config.json", func(t *testing.T) {
-		dir, err := ioutil.TempDir("", "")
-		defer os.RemoveAll(dir) // clean up
-		assert.NoError(t, err, "Error when creating temp dir")
 
 		opts := kubernetesDeployOptions{
-			AppTemplate:                filepath.Join(dir, "test.yaml"),
+			AppTemplate:                "path/to/test.yaml",
 			DockerConfigJSON:           "/path/to/.docker/config.json",
 			ContainerRegistryURL:       "https://my.registry:55555",
 			ContainerRegistryUser:      "registryUser",
@@ -676,17 +678,15 @@ spec:
   spec:
     image: <image-name>`
 
-		ioutil.WriteFile(opts.AppTemplate, []byte(kubeYaml), 0755)
-
-		e := mock.ExecMockRunner{
-			ShouldFailOnCommand: map[string]error{
-				"kubectl --insecure-skip-tls-verify=true --namespace=deploymentNamespace --context=testCluster get secret regSecret": fmt.Errorf("secret not found"),
-			},
+		mockUtils := newKubernetesDeployMockUtils()
+		mockUtils.AddFile(opts.AppTemplate, []byte(kubeYaml))
+		mockUtils.ShouldFailOnCommand = map[string]error{
+			"kubectl --insecure-skip-tls-verify=true --namespace=deploymentNamespace --context=testCluster get secret regSecret": fmt.Errorf("secret not found"),
 		}
 		var stdout bytes.Buffer
-		runKubernetesDeploy(opts, &e, &stdout)
+		runKubernetesDeploy(opts, mockUtils, &stdout)
 
-		assert.Equal(t, e.Env, []string{"KUBECONFIG=This is my kubeconfig"})
+		assert.Equal(t, mockUtils.Env, []string{"KUBECONFIG=This is my kubeconfig"})
 
 		assert.Equal(t, []string{
 			"--insecure-skip-tls-verify=true",
@@ -698,16 +698,13 @@ spec:
 			opts.ContainerRegistrySecret,
 			fmt.Sprintf("--from-file=.dockerconfigjson=%v", opts.DockerConfigJSON),
 			`--type=kubernetes.io/dockerconfigjson`,
-		}, e.Calls[1].Params, "kubectl parameters incorrect")
+		}, mockUtils.Calls[1].Params, "kubectl parameters incorrect")
 	})
 
 	t.Run("test kubectl - lookup secret/kubeconfig", func(t *testing.T) {
-		dir, err := ioutil.TempDir("", "")
-		defer os.RemoveAll(dir) // clean up
-		assert.NoError(t, err, "Error when creating temp dir")
 
 		opts := kubernetesDeployOptions{
-			AppTemplate:                filepath.Join(dir, "test.yaml"),
+			AppTemplate:                "path/to/test.yaml",
 			ContainerRegistryURL:       "https://my.registry:55555",
 			ContainerRegistryUser:      "registryUser",
 			ContainerRegistryPassword:  "********",
@@ -720,40 +717,36 @@ spec:
 			DeployCommand:              "apply",
 		}
 
-		ioutil.WriteFile(opts.AppTemplate, []byte("testYaml"), 0755)
-
-		e := mock.ExecMockRunner{}
+		mockUtils := newKubernetesDeployMockUtils()
+		mockUtils.AddFile(opts.AppTemplate, []byte("testYaml"))
 
 		var stdout bytes.Buffer
-		runKubernetesDeploy(opts, &e, &stdout)
+		runKubernetesDeploy(opts, mockUtils, &stdout)
 
-		assert.Equal(t, "kubectl", e.Calls[0].Exec, "Wrong secret lookup command")
+		assert.Equal(t, "kubectl", mockUtils.Calls[0].Exec, "Wrong secret lookup command")
 		assert.Equal(t, []string{
 			"--insecure-skip-tls-verify=true",
 			fmt.Sprintf("--namespace=%v", opts.Namespace),
 			"get",
 			"secret",
 			opts.ContainerRegistrySecret,
-		}, e.Calls[0].Params, "kubectl parameters incorrect")
+		}, mockUtils.Calls[0].Params, "kubectl parameters incorrect")
 
-		assert.Equal(t, "kubectl", e.Calls[1].Exec, "Wrong apply command")
+		assert.Equal(t, "kubectl", mockUtils.Calls[1].Exec, "Wrong apply command")
 		assert.Equal(t, []string{
 			"--insecure-skip-tls-verify=true",
 			fmt.Sprintf("--namespace=%v", opts.Namespace),
 			"apply",
 			"--filename",
 			opts.AppTemplate,
-		}, e.Calls[1].Params, "kubectl parameters incorrect")
+		}, mockUtils.Calls[1].Params, "kubectl parameters incorrect")
 	})
 
 	t.Run("test kubectl - token only", func(t *testing.T) {
-		dir, err := ioutil.TempDir("", "")
-		defer os.RemoveAll(dir) // clean up
-		assert.NoError(t, err, "Error when creating temp dir")
 
 		opts := kubernetesDeployOptions{
 			APIServer:                 "https://my.api.server",
-			AppTemplate:               filepath.Join(dir, "test.yaml"),
+			AppTemplate:               "path/to/test.yaml",
 			ContainerRegistryURL:      "https://my.registry:55555",
 			ContainerRegistryUser:     "registryUser",
 			ContainerRegistryPassword: "********",
@@ -765,15 +758,14 @@ spec:
 			DeployCommand:             "apply",
 		}
 
-		ioutil.WriteFile(opts.AppTemplate, []byte("testYaml"), 0755)
+		mockUtils := newKubernetesDeployMockUtils()
+		mockUtils.AddFile(opts.AppTemplate, []byte("testYaml"))
+		mockUtils.ShouldFailOnCommand = map[string]error{}
 
-		e := mock.ExecMockRunner{
-			ShouldFailOnCommand: map[string]error{},
-		}
 		var stdout bytes.Buffer
-		runKubernetesDeploy(opts, &e, &stdout)
+		runKubernetesDeploy(opts, mockUtils, &stdout)
 
-		assert.Equal(t, "kubectl", e.Calls[0].Exec, "Wrong apply command")
+		assert.Equal(t, "kubectl", mockUtils.Calls[0].Exec, "Wrong apply command")
 		assert.Equal(t, []string{
 			"--insecure-skip-tls-verify=true",
 			fmt.Sprintf("--namespace=%v", opts.Namespace),
@@ -782,17 +774,13 @@ spec:
 			"apply",
 			"--filename",
 			opts.AppTemplate,
-		}, e.Calls[0].Params, "kubectl parameters incorrect")
+		}, mockUtils.Calls[0].Params, "kubectl parameters incorrect")
 	})
 
 	t.Run("test kubectl - with containerImageName and containerImageTag instead of image", func(t *testing.T) {
-		dir, err := ioutil.TempDir("", "")
-		defer os.RemoveAll(dir) // clean up
-		assert.NoError(t, err, "Error when creating temp dir")
-
 		opts := kubernetesDeployOptions{
 			APIServer:                 "https://my.api.server",
-			AppTemplate:               filepath.Join(dir, "test.yaml"),
+			AppTemplate:               "test.yaml",
 			ContainerRegistryURL:      "https://my.registry:55555",
 			ContainerRegistryUser:     "registryUser",
 			ContainerRegistryPassword: "********",
@@ -805,28 +793,23 @@ spec:
 			DeployCommand:             "apply",
 		}
 
-		ioutil.WriteFile(opts.AppTemplate, []byte("image: <image-name>"), 0755)
+		mockUtils := newKubernetesDeployMockUtils()
+		mockUtils.AddFile("test.yaml", []byte("image: <image-name>"))
 
-		e := mock.ExecMockRunner{
-			ShouldFailOnCommand: map[string]error{},
-		}
 		var stdout bytes.Buffer
-		runKubernetesDeploy(opts, &e, &stdout)
+		runKubernetesDeploy(opts, mockUtils, &stdout)
 
-		assert.Equal(t, "kubectl", e.Calls[0].Exec, "Wrong apply command")
+		assert.Equal(t, "kubectl", mockUtils.Calls[0].Exec, "Wrong apply command")
 
-		appTemplateFileContents, err := ioutil.ReadFile(opts.AppTemplate)
+		appTemplateFileContents, err := mockUtils.FileRead(opts.AppTemplate)
+		assert.NoError(t, err)
 		assert.Contains(t, string(appTemplateFileContents), "image: my.registry:55555/path/to/Image:latest", "kubectl parameters incorrect")
 	})
 
 	t.Run("test kubectl - fails without image information", func(t *testing.T) {
-		dir, err := ioutil.TempDir("", "")
-		defer os.RemoveAll(dir) // clean up
-		assert.NoError(t, err, "Error when creating temp dir")
-
 		opts := kubernetesDeployOptions{
 			APIServer:                 "https://my.api.server",
-			AppTemplate:               filepath.Join(dir, "test.yaml"),
+			AppTemplate:               "test.yaml",
 			ContainerRegistryURL:      "https://my.registry:55555",
 			ContainerRegistryUser:     "registryUser",
 			ContainerRegistryPassword: "********",
@@ -837,22 +820,18 @@ spec:
 			DeployCommand:             "apply",
 		}
 
-		ioutil.WriteFile(opts.AppTemplate, []byte("testYaml"), 0755)
-		e := mock.ExecMockRunner{}
+		mockUtils := newKubernetesDeployMockUtils()
+		mockUtils.AddFile("test.yaml", []byte("testYaml"))
 
 		var stdout bytes.Buffer
 
-		err = runKubernetesDeploy(opts, &e, &stdout)
+		err := runKubernetesDeploy(opts, mockUtils, &stdout)
 		assert.EqualError(t, err, "image information not given - please either set image or containerImageName and containerImageTag")
 	})
 
 	t.Run("test kubectl - use replace deploy command", func(t *testing.T) {
-		dir, err := ioutil.TempDir("", "")
-		defer os.RemoveAll(dir) // clean up
-		assert.NoError(t, err, "Error when creating temp dir")
-
 		opts := kubernetesDeployOptions{
-			AppTemplate:                filepath.Join(dir, "test.yaml"),
+			AppTemplate:                "test.yaml",
 			ContainerRegistryURL:       "https://my.registry:55555",
 			ContainerRegistryUser:      "registryUser",
 			ContainerRegistryPassword:  "********",
@@ -873,17 +852,16 @@ spec:
   spec:
     image: <image-name>`
 
-		err = ioutil.WriteFile(opts.AppTemplate, []byte(kubeYaml), 0755)
-		assert.NoError(t, err, "Error when writing app template file")
+		mockUtils := newKubernetesDeployMockUtils()
+		mockUtils.AddFile("test.yaml", []byte(kubeYaml))
 
-		e := mock.ExecMockRunner{}
 		var stdout bytes.Buffer
-		err = runKubernetesDeploy(opts, &e, &stdout)
+		err := runKubernetesDeploy(opts, mockUtils, &stdout)
 		assert.NoError(t, err, "Command should not fail")
 
-		assert.Equal(t, e.Env, []string{"KUBECONFIG=This is my kubeconfig"})
+		assert.Equal(t, mockUtils.Env, []string{"KUBECONFIG=This is my kubeconfig"})
 
-		assert.Equal(t, "kubectl", e.Calls[1].Exec, "Wrong replace command")
+		assert.Equal(t, "kubectl", mockUtils.Calls[1].Exec, "Wrong replace command")
 		assert.Equal(t, []string{
 			"--insecure-skip-tls-verify=true",
 			fmt.Sprintf("--namespace=%v", opts.Namespace),
@@ -893,19 +871,15 @@ spec:
 			opts.AppTemplate,
 			"--testParam",
 			"testValue",
-		}, e.Calls[1].Params, "kubectl parameters incorrect")
+		}, mockUtils.Calls[1].Params, "kubectl parameters incorrect")
 
-		appTemplate, err := ioutil.ReadFile(opts.AppTemplate)
+		appTemplate, err := mockUtils.FileRead(opts.AppTemplate)
 		assert.Contains(t, string(appTemplate), "my.registry:55555/path/to/Image:latest")
 	})
 
 	t.Run("test kubectl - use replace --force deploy command", func(t *testing.T) {
-		dir, err := ioutil.TempDir("", "")
-		defer os.RemoveAll(dir) // clean up
-		assert.NoError(t, err, "Error when creating temp dir")
-
 		opts := kubernetesDeployOptions{
-			AppTemplate:                filepath.Join(dir, "test.yaml"),
+			AppTemplate:                "test.yaml",
 			ContainerRegistryURL:       "https://my.registry:55555",
 			ContainerRegistryUser:      "registryUser",
 			ContainerRegistryPassword:  "********",
@@ -927,17 +901,16 @@ spec:
   spec:
     image: <image-name>`
 
-		err = ioutil.WriteFile(opts.AppTemplate, []byte(kubeYaml), 0755)
-		assert.NoError(t, err, "Error when writing app template file")
+		mockUtils := newKubernetesDeployMockUtils()
+		mockUtils.AddFile("test.yaml", []byte(kubeYaml))
 
-		e := mock.ExecMockRunner{}
 		var stdout bytes.Buffer
-		err = runKubernetesDeploy(opts, &e, &stdout)
+		err := runKubernetesDeploy(opts, mockUtils, &stdout)
 		assert.NoError(t, err, "Command should not fail")
 
-		assert.Equal(t, e.Env, []string{"KUBECONFIG=This is my kubeconfig"})
+		assert.Equal(t, mockUtils.Env, []string{"KUBECONFIG=This is my kubeconfig"})
 
-		assert.Equal(t, "kubectl", e.Calls[1].Exec, "Wrong replace command")
+		assert.Equal(t, "kubectl", mockUtils.Calls[1].Exec, "Wrong replace command")
 		assert.Equal(t, []string{
 			"--insecure-skip-tls-verify=true",
 			fmt.Sprintf("--namespace=%v", opts.Namespace),
@@ -948,9 +921,9 @@ spec:
 			"--force",
 			"--testParam",
 			"testValue",
-		}, e.Calls[1].Params, "kubectl parameters incorrect")
+		}, mockUtils.Calls[1].Params, "kubectl parameters incorrect")
 
-		appTemplate, err := ioutil.ReadFile(opts.AppTemplate)
+		appTemplate, err := mockUtils.FileRead(opts.AppTemplate)
 		assert.Contains(t, string(appTemplate), "my.registry:55555/path/to/Image:latest")
 	})
 

resources/metadata/kubernetesDeploy.yaml

@@ -96,6 +96,8 @@ spec:
           - name: dockerCredentialsId
             type: secret
             param: password
+          - name: commonPipelineEnvironment
+            param: custom/repositoryPassword
       - name: containerImageName
         aliases:
           - name: dockerImageName
@@ -145,6 +147,8 @@ spec:
           - name: dockerCredentialsId
             type: secret
             param: username
+          - name: commonPipelineEnvironment
+            param: custom/repositoryUsername
       - name: containerRegistrySecret
         description: Name of the container registry secret used for pulling containers from the registry.
         longDescription: |-
@@ -152,7 +156,6 @@ spec:
 
           **For `deployTool: helm/helm3`:**<br />
           If `containerRegistryUser` and `containerRegistryPassword` are provided, a secret is created on the fly and the information is passed to the helm template.<br />
-          Note: the secret will not be persisted in the Kubernetes cluster.
 
           If neither `containerRegistryUser` nor `containerRegistryPassword` are provided, it is expected that a secret with the configured name exists in the target Kubernetes cluster.<br />
 
@@ -270,7 +273,7 @@ spec:
           - name: kubeConfigFileCredentialsId
             type: secret
           - type: vaultSecretFile
-            name: kubeConfigFileSecretName
+            name: kubeConfigFileVaultSecretName
             default: kube-config
       - name: kubeContext
         type: string
@@ -320,8 +323,6 @@ spec:
           - STEPS
         secret: true
         resourceRef:
-          - name: commonPipelineEnvironment
-            param: custom/dockerConfigJSON
           - name: dockerConfigJsonCredentialsId
             type: secret
           - type: vaultSecretFile