Commit 28262978 authored by Hordur Freyr Yngvason's avatar Hordur Freyr Yngvason
Browse files

Merge branch 'Split-up-template_test.go' into 'master' 

Decomposing individual template tests into separate test files

See merge request gitlab-org/cluster-integration/auto-deploy-image!157
parents 4101111b e13b4a79

assets/auto-deploy-app/test/deploymenttemplate_test.go

0 → 100644
+270 −0
Original line number Diff line number Diff line 
package main



import (

	"regexp"

	"strings"

	"testing"



	"github.com/gruntwork-io/terratest/modules/helm"

	"github.com/gruntwork-io/terratest/modules/k8s"

	"github.com/gruntwork-io/terratest/modules/random"

	"github.com/stretchr/testify/require"

	appsV1 "k8s.io/api/apps/v1"

	coreV1 "k8s.io/api/core/v1"

	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"

)



func TestDeploymentTemplate(t *testing.T) {

	for _, tc := range []struct {

		CaseName string

		Release  string

		Values   map[string]string



		ExpectedErrorRegexp *regexp.Regexp



		ExpectedName         string

		ExpectedRelease      string

		ExpectedStrategyType appsV1.DeploymentStrategyType

	}{

		{

			CaseName: "happy",

			Release:  "production",

			Values: map[string]string{

				"releaseOverride": "productionOverridden",

			},

			ExpectedName:         "productionOverridden",

			ExpectedRelease:      "production",

			ExpectedStrategyType: appsV1.DeploymentStrategyType(""),

		}, {

			// See https://github.com/helm/helm/issues/6006

			CaseName: "long release name",

			Release:  strings.Repeat("r", 80),



			ExpectedErrorRegexp: regexp.MustCompile("Error: release name .* exceeds max length of 53"),

		},

		{

			CaseName: "strategyType",

			Release:  "production",

			Values: map[string]string{

				"strategyType": "Recreate",

			},

			ExpectedName:         "production",

			ExpectedRelease:      "production",

			ExpectedStrategyType: appsV1.RecreateDeploymentStrategyType,

		},

	} {

		t.Run(tc.CaseName, func(t *testing.T) {

			namespaceName := "minimal-ruby-app-" + strings.ToLower(random.UniqueId())



			values := map[string]string{

				"gitlab.app": "auto-devops-examples/minimal-ruby-app",

				"gitlab.env": "prod",

			}



			mergeStringMap(values, tc.Values)



			options := &helm.Options{

				SetValues:      values,

				KubectlOptions: k8s.NewKubectlOptions("", "", namespaceName),

			}



			output, err := helm.RenderTemplateE(t, options, helmChartPath, tc.Release, []string{"templates/deployment.yaml"})



			if tc.ExpectedErrorRegexp != nil {

				require.Regexp(t, tc.ExpectedErrorRegexp, err.Error())

				return

			}

			if err != nil {

				t.Error(err)

				return

			}



			var deployment appsV1.Deployment

			helm.UnmarshalK8SYaml(t, output, &deployment)



			require.Equal(t, tc.ExpectedName, deployment.Name)

			require.Equal(t, tc.ExpectedStrategyType, deployment.Spec.Strategy.Type)



			require.Equal(t, map[string]string{

				"app.gitlab.com/app": "auto-devops-examples/minimal-ruby-app",

				"app.gitlab.com/env": "prod",

			}, deployment.Annotations)

			require.Equal(t, map[string]string{

				"app":      tc.ExpectedName,

				"chart":    chartName,

				"heritage": "Helm",

				"release":  tc.ExpectedRelease,

				"tier":     "web",

				"track":    "stable",

			}, deployment.Labels)



			require.Equal(t, map[string]string{

				"app.gitlab.com/app":           "auto-devops-examples/minimal-ruby-app",

				"app.gitlab.com/env":           "prod",

				"checksum/application-secrets": "",

			}, deployment.Spec.Template.Annotations)

			require.Equal(t, map[string]string{

				"app":     tc.ExpectedName,

				"release": tc.ExpectedRelease,

				"tier":    "web",

				"track":   "stable",

			}, deployment.Spec.Template.Labels)

		})

	}



	for _, tc := range []struct {

		CaseName                string

		Release                 string

		Values                  map[string]string

		ExpectedImageRepository string

	}{

		{

			CaseName: "skaffold",

			Release:  "production",

			Values: map[string]string{

				"image.repository": "skaffold",

				"image.tag":        "",

			},

			ExpectedImageRepository: "skaffold",

		},

		{

			CaseName: "skaffold",

			Release:  "production",

			Values: map[string]string{

				"image.repository": "skaffold",

				"image.tag":        "stable",

			},

			ExpectedImageRepository: "skaffold:stable",

		},

	} {

		t.Run(tc.CaseName, func(t *testing.T) {

			namespaceName := "minimal-ruby-app-" + strings.ToLower(random.UniqueId())



			values := map[string]string{

				"gitlab.app": "auto-devops-examples/minimal-ruby-app",

				"gitlab.env": "prod",

			}



			mergeStringMap(values, tc.Values)



			options := &helm.Options{

				SetValues:      values,

				KubectlOptions: k8s.NewKubectlOptions("", "", namespaceName),

			}



			output := helm.RenderTemplate(t, options, helmChartPath, tc.Release, []string{"templates/deployment.yaml"})



			var deployment appsV1.Deployment

			helm.UnmarshalK8SYaml(t, output, &deployment)



			require.Equal(t, tc.ExpectedImageRepository, deployment.Spec.Template.Spec.Containers[0].Image)

		})

	}



	// deployment livenessProbe, and readinessProbe tests

	for _, tc := range []struct {

		CaseName string

		Release  string

		Values   map[string]string



		ExpectedLivenessProbe  *coreV1.Probe

		ExpectedReadinessProbe *coreV1.Probe

	}{

		{

			CaseName:               "defaults",

			Release:                "production",

			ExpectedLivenessProbe:  defaultLivenessProbe(),

			ExpectedReadinessProbe: defaultReadinessProbe(),

		},

	} {

		t.Run(tc.CaseName, func(t *testing.T) {

			namespaceName := "minimal-ruby-app-" + strings.ToLower(random.UniqueId())



			values := map[string]string{

				"gitlab.app": "auto-devops-examples/minimal-ruby-app",

				"gitlab.env": "prod",

			}



			mergeStringMap(values, tc.Values)



			options := &helm.Options{

				SetValues:      values,

				KubectlOptions: k8s.NewKubectlOptions("", "", namespaceName),

			}



			output := helm.RenderTemplate(t, options, helmChartPath, tc.Release, []string{"templates/deployment.yaml"})



			var deployment appsV1.Deployment

			helm.UnmarshalK8SYaml(t, output, &deployment)



			require.Equal(t, tc.ExpectedLivenessProbe, deployment.Spec.Template.Spec.Containers[0].LivenessProbe)

			require.Equal(t, tc.ExpectedReadinessProbe, deployment.Spec.Template.Spec.Containers[0].ReadinessProbe)

		})

	}



	// Test Deployment selector

	for _, tc := range []struct {

		CaseName string

		Release  string

		Values   map[string]string



		ExpectedName     string

		ExpectedRelease  string

		ExpectedSelector *metav1.LabelSelector

	}{

		{

			CaseName:        "selector",

			Release:         "production",

			ExpectedName:    "production",

			ExpectedRelease: "production",

			ExpectedSelector: &metav1.LabelSelector{

				MatchLabels: map[string]string{

					"app":     "production",

					"release": "production",

					"tier":    "web",

					"track":   "stable",

				},

			},

		},

	} {

		t.Run(tc.CaseName, func(t *testing.T) {

			namespaceName := "minimal-ruby-app-" + strings.ToLower(random.UniqueId())



			values := map[string]string{

				"gitlab.app": "auto-devops-examples/minimal-ruby-app",

				"gitlab.env": "prod",

			}



			mergeStringMap(values, tc.Values)



			options := &helm.Options{

				SetValues:      values,

				KubectlOptions: k8s.NewKubectlOptions("", "", namespaceName),

			}



			output := helm.RenderTemplate(t, options, helmChartPath, tc.Release, []string{"templates/deployment.yaml"})



			var deployment appsV1.Deployment

			helm.UnmarshalK8SYaml(t, output, &deployment)



			require.Equal(t, tc.ExpectedName, deployment.Name)

			require.Equal(t, map[string]string{

				"app":      tc.ExpectedName,

				"chart":    chartName,

				"heritage": "Helm",

				"release":  tc.ExpectedRelease,

				"tier":     "web",

				"track":    "stable",

			}, deployment.Labels)



			require.Equal(t, tc.ExpectedSelector, deployment.Spec.Selector)



			require.Equal(t, map[string]string{

				"app":     tc.ExpectedName,

				"release": tc.ExpectedRelease,

				"tier":    "web",

				"track":   "stable",

			}, deployment.Spec.Template.Labels)

		})

	}

}

assets/auto-deploy-app/test/template_test.go

+2 −257
Original line number Diff line number Diff line
@@ -22,261 +22,6 @@ const ( 
	helmChartPath = ".."

)



func TestDeploymentTemplate(t *testing.T) {

	for _, tc := range []struct {

		CaseName string

		Release  string

		Values   map[string]string



		ExpectedErrorRegexp *regexp.Regexp



		ExpectedName         string

		ExpectedRelease      string

		ExpectedStrategyType appsV1.DeploymentStrategyType

	}{

		{

			CaseName: "happy",

			Release:  "production",

			Values: map[string]string{

				"releaseOverride": "productionOverridden",

			},

			ExpectedName:         "productionOverridden",

			ExpectedRelease:      "production",

			ExpectedStrategyType: appsV1.DeploymentStrategyType(""),

		}, {

			// See https://github.com/helm/helm/issues/6006

			CaseName: "long release name",

			Release:  strings.Repeat("r", 80),



			ExpectedErrorRegexp: regexp.MustCompile("Error: release name .* exceeds max length of 53"),

		},

		{

			CaseName: "strategyType",

			Release:  "production",

			Values: map[string]string{

				"strategyType": "Recreate",

			},

			ExpectedName:         "production",

			ExpectedRelease:      "production",

			ExpectedStrategyType: appsV1.RecreateDeploymentStrategyType,

		},

	} {

		t.Run(tc.CaseName, func(t *testing.T) {

			namespaceName := "minimal-ruby-app-" + strings.ToLower(random.UniqueId())



			values := map[string]string{

				"gitlab.app": "auto-devops-examples/minimal-ruby-app",

				"gitlab.env": "prod",

			}



			mergeStringMap(values, tc.Values)



			options := &helm.Options{

				SetValues:      values,

				KubectlOptions: k8s.NewKubectlOptions("", "", namespaceName),

			}



			output, err := helm.RenderTemplateE(t, options, helmChartPath, tc.Release, []string{"templates/deployment.yaml"})



			if tc.ExpectedErrorRegexp != nil {

				require.Regexp(t, tc.ExpectedErrorRegexp, err.Error())

				return

			}

			if err != nil {

				t.Error(err)

				return

			}



			var deployment appsV1.Deployment

			helm.UnmarshalK8SYaml(t, output, &deployment)



			require.Equal(t, tc.ExpectedName, deployment.Name)

			require.Equal(t, tc.ExpectedStrategyType, deployment.Spec.Strategy.Type)



			require.Equal(t, map[string]string{

				"app.gitlab.com/app": "auto-devops-examples/minimal-ruby-app",

				"app.gitlab.com/env": "prod",

			}, deployment.Annotations)

			require.Equal(t, map[string]string{

				"app":      tc.ExpectedName,

				"chart":    chartName,

				"heritage": "Helm",

				"release":  tc.ExpectedRelease,

				"tier":     "web",

				"track":    "stable",

			}, deployment.Labels)



			require.Equal(t, map[string]string{

				"app.gitlab.com/app":           "auto-devops-examples/minimal-ruby-app",

				"app.gitlab.com/env":           "prod",

				"checksum/application-secrets": "",

			}, deployment.Spec.Template.Annotations)

			require.Equal(t, map[string]string{

				"app":     tc.ExpectedName,

				"release": tc.ExpectedRelease,

				"tier":    "web",

				"track":   "stable",

			}, deployment.Spec.Template.Labels)

		})

	}



	for _, tc := range []struct {

		CaseName                string

		Release                 string

		Values                  map[string]string

		ExpectedImageRepository string

	}{

		{

			CaseName: "skaffold",

			Release:  "production",

			Values: map[string]string{

				"image.repository": "skaffold",

				"image.tag":        "",

			},

			ExpectedImageRepository: "skaffold",

		},

		{

			CaseName: "skaffold",

			Release:  "production",

			Values: map[string]string{

				"image.repository": "skaffold",

				"image.tag":        "stable",

			},

			ExpectedImageRepository: "skaffold:stable",

		},

	} {

		t.Run(tc.CaseName, func(t *testing.T) {

			namespaceName := "minimal-ruby-app-" + strings.ToLower(random.UniqueId())



			values := map[string]string{

				"gitlab.app": "auto-devops-examples/minimal-ruby-app",

				"gitlab.env": "prod",

			}



			mergeStringMap(values, tc.Values)



			options := &helm.Options{

				SetValues:      values,

				KubectlOptions: k8s.NewKubectlOptions("", "", namespaceName),

			}



			output := helm.RenderTemplate(t, options, helmChartPath, tc.Release, []string{"templates/deployment.yaml"})



			var deployment appsV1.Deployment

			helm.UnmarshalK8SYaml(t, output, &deployment)



			require.Equal(t, tc.ExpectedImageRepository, deployment.Spec.Template.Spec.Containers[0].Image)

		})

	}



	// deployment livenessProbe, and readinessProbe tests

	for _, tc := range []struct {

		CaseName string

		Release  string

		Values   map[string]string



		ExpectedLivenessProbe  *coreV1.Probe

		ExpectedReadinessProbe *coreV1.Probe

	}{

		{

			CaseName:               "defaults",

			Release:                "production",

			ExpectedLivenessProbe:  defaultLivenessProbe(),

			ExpectedReadinessProbe: defaultReadinessProbe(),

		},

	} {

		t.Run(tc.CaseName, func(t *testing.T) {

			namespaceName := "minimal-ruby-app-" + strings.ToLower(random.UniqueId())



			values := map[string]string{

				"gitlab.app": "auto-devops-examples/minimal-ruby-app",

				"gitlab.env": "prod",

			}



			mergeStringMap(values, tc.Values)



			options := &helm.Options{

				SetValues:      values,

				KubectlOptions: k8s.NewKubectlOptions("", "", namespaceName),

			}



			output := helm.RenderTemplate(t, options, helmChartPath, tc.Release, []string{"templates/deployment.yaml"})



			var deployment appsV1.Deployment

			helm.UnmarshalK8SYaml(t, output, &deployment)



			require.Equal(t, tc.ExpectedLivenessProbe, deployment.Spec.Template.Spec.Containers[0].LivenessProbe)

			require.Equal(t, tc.ExpectedReadinessProbe, deployment.Spec.Template.Spec.Containers[0].ReadinessProbe)

		})

	}



	// Test Deployment selector

	for _, tc := range []struct {

		CaseName string

		Release  string

		Values   map[string]string



		ExpectedName     string

		ExpectedRelease  string

		ExpectedSelector *metav1.LabelSelector

	}{

		{

			CaseName:        "selector",

			Release:         "production",

			ExpectedName:    "production",

			ExpectedRelease: "production",

			ExpectedSelector: &metav1.LabelSelector{

				MatchLabels: map[string]string{

					"app":     "production",

					"release": "production",

					"tier":    "web",

					"track":   "stable",

				},

			},

		},

	} {

		t.Run(tc.CaseName, func(t *testing.T) {

			namespaceName := "minimal-ruby-app-" + strings.ToLower(random.UniqueId())



			values := map[string]string{

				"gitlab.app": "auto-devops-examples/minimal-ruby-app",

				"gitlab.env": "prod",

			}



			mergeStringMap(values, tc.Values)



			options := &helm.Options{

				SetValues:      values,

				KubectlOptions: k8s.NewKubectlOptions("", "", namespaceName),

			}



			output := helm.RenderTemplate(t, options, helmChartPath, tc.Release, []string{"templates/deployment.yaml"})



			var deployment appsV1.Deployment

			helm.UnmarshalK8SYaml(t, output, &deployment)



			require.Equal(t, tc.ExpectedName, deployment.Name)

			require.Equal(t, map[string]string{

				"app":      tc.ExpectedName,

				"chart":    chartName,

				"heritage": "Helm",

				"release":  tc.ExpectedRelease,

				"tier":     "web",

				"track":    "stable",

			}, deployment.Labels)



			require.Equal(t, tc.ExpectedSelector, deployment.Spec.Selector)



			require.Equal(t, map[string]string{

				"app":     tc.ExpectedName,

				"release": tc.ExpectedRelease,

				"tier":    "web",

				"track":   "stable",

			}, deployment.Spec.Template.Labels)

		})

	}

}



func TestWorkerDeploymentTemplate(t *testing.T) {

	for _, tc := range []struct {

		CaseName string