Commit e13b4a79 authored by Daniel Croft's avatar Daniel Croft Committed by Hordur Freyr Yngvason
Browse files

Decomposing individual template tests into separate test files. Still need to... 

Decomposing individual template tests into separate test files. Still need to work out sharing functions/variables across the package and whether a shared package is actually a good idea or not.
parent 4101111b

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