From 228eb01db37d900ee32a122f70c02dfaf9eb086a Mon Sep 17 00:00:00 2001 From: Julien Cabillot Date: Wed, 29 Dec 2021 17:08:12 -0500 Subject: [PATCH] don t care --- charts/cv/Chart.yaml | 2 +- .../tests/addon_codeserver_test.go | 136 ------ .../tests/addon_netshoot_test.go | 64 --- .../tests/addon_vpn_test.go | 129 ------ .../tests/configmap_test.go | 98 ----- .../tests/container_test.go | 304 -------------- .../tests/controller_test.go | 59 --- .../tests/horizontal_pod_autoscaler_test.go | 107 ----- .../helm-library-common/tests/ingress_test.go | 222 ---------- .../tests/persistentvolumeclaim_test.go | 166 -------- .../helm-library-common/tests/pod_test.go | 386 ------------------ .../helm-library-common/tests/service_test.go | 138 ------- charts/cv/values.yaml | 15 +- 13 files changed, 15 insertions(+), 1811 deletions(-) delete mode 100644 charts/cv/charts/helm-library-common/tests/addon_codeserver_test.go delete mode 100644 charts/cv/charts/helm-library-common/tests/addon_netshoot_test.go delete mode 100644 charts/cv/charts/helm-library-common/tests/addon_vpn_test.go delete mode 100644 charts/cv/charts/helm-library-common/tests/configmap_test.go delete mode 100644 charts/cv/charts/helm-library-common/tests/container_test.go delete mode 100644 charts/cv/charts/helm-library-common/tests/controller_test.go delete mode 100644 charts/cv/charts/helm-library-common/tests/horizontal_pod_autoscaler_test.go delete mode 100644 charts/cv/charts/helm-library-common/tests/ingress_test.go delete mode 100644 charts/cv/charts/helm-library-common/tests/persistentvolumeclaim_test.go delete mode 100644 charts/cv/charts/helm-library-common/tests/pod_test.go delete mode 100644 charts/cv/charts/helm-library-common/tests/service_test.go diff --git a/charts/cv/Chart.yaml b/charts/cv/Chart.yaml index 2f56916..a136473 100644 --- a/charts/cv/Chart.yaml +++ b/charts/cv/Chart.yaml @@ -9,7 +9,7 @@ appVersion: "latest" description: Helm chart for cv name: cv -version: 0.0.1 +version: 0.0.2 kubeVersion: ">=1.16.0-0" keywords: - cv diff --git a/charts/cv/charts/helm-library-common/tests/addon_codeserver_test.go b/charts/cv/charts/helm-library-common/tests/addon_codeserver_test.go deleted file mode 100644 index e6ac4c3..0000000 --- a/charts/cv/charts/helm-library-common/tests/addon_codeserver_test.go +++ /dev/null @@ -1,136 +0,0 @@ -package common - -import ( - "testing" - - "github.com/Jeffail/gabs/v2" - "github.com/k8s-at-home/library-charts/test/helmunit" - "github.com/stretchr/testify/suite" -) - -type AddonCodeserverTestSuite struct { - suite.Suite - Chart helmunit.HelmChart - baseValues string -} - -func (suite *AddonCodeserverTestSuite) SetupSuite() { - suite.Chart = helmunit.New("common-test", "../../../../helper-charts/common-test") - suite.Chart.UpdateDependencies() - suite.baseValues = ` - addons: - codeserver: - enabled: true - volumeMounts: - - name: "config" - mountPath: "/data/config" - ` -} - -// We need this function to kick off the test suite, otherwise -// "go test" won't know about our tests -func TestAddonCodeserver(t *testing.T) { - suite.Run(t, new(AddonCodeserverTestSuite)) -} - -func (suite *AddonCodeserverTestSuite) TestContainer() { - tests := map[string]struct { - values *string - expectedCodeserverContainer bool - }{ - "Default": {values: nil, expectedCodeserverContainer: false}, - "AddonEnabled": {values: &suite.baseValues, expectedCodeserverContainer: true}, - } - for name, tc := range tests { - suite.Suite.Run(name, func() { - err := suite.Chart.Render(nil, nil, tc.values) - if err != nil { - suite.FailNow(err.Error()) - } - - deploymentManifest := suite.Chart.Manifests.Get("Deployment", "common-test") - suite.Assertions.NotEmpty(deploymentManifest) - containers := deploymentManifest.Path("spec.template.spec.containers").Children() - - var codeserverContainer *gabs.Container - for _, container := range containers { - containerName := container.Path("name").Data().(string) - if containerName == "codeserver" { - codeserverContainer = container - break - } - } - - if tc.expectedCodeserverContainer { - suite.Assertions.NotEmpty(codeserverContainer) - } else { - suite.Assertions.Empty(codeserverContainer) - } - }) - } -} - -func (suite *AddonCodeserverTestSuite) TestDeployKey() { - tests := map[string]struct { - values []string - expectSecret bool - expectedSecretName string - }{ - "Inline": {values: []string{"addons.codeserver.git.deployKey=test"}, expectSecret: true, expectedSecretName: "common-test-deploykey"}, - "InlineBase64": {values: []string{"addons.codeserver.git.deployKeyBase64=dGVzdEtleQ=="}, expectSecret: true, expectedSecretName: "common-test-deploykey"}, - "ExistingSecret": {values: []string{"addons.codeserver.git.deployKeySecret=test-secret"}, expectSecret: false, expectedSecretName: "test-secret"}, - } - for name, tc := range tests { - suite.Suite.Run(name, func() { - err := suite.Chart.Render(nil, tc.values, &suite.baseValues) - if err != nil { - suite.FailNow(err.Error()) - } - - secretManifest := suite.Chart.Manifests.Get("Secret", tc.expectedSecretName) - if tc.expectSecret { - suite.Assertions.NotEmpty(secretManifest) - } else { - suite.Assertions.Empty(secretManifest) - } - - deploymentManifest := suite.Chart.Manifests.Get("Deployment", "common-test") - suite.Assertions.NotEmpty(deploymentManifest) - - containers := deploymentManifest.Path("spec.template.spec.containers").Children() - var codeserverContainer *gabs.Container - for _, container := range containers { - containerName := container.Path("name").Data().(string) - if containerName == "codeserver" { - codeserverContainer = container - break - } - } - suite.Assertions.NotEmpty(codeserverContainer) - - volumeMounts := codeserverContainer.Path("volumeMounts").Children() - var gitDeploykeyVolumeMount *gabs.Container - for _, volumeMount := range volumeMounts { - volumeMountName := volumeMount.Path("name").Data().(string) - if volumeMountName == "deploykey" { - gitDeploykeyVolumeMount = volumeMount - break - } - } - suite.Assertions.NotEmpty(gitDeploykeyVolumeMount) - suite.Assertions.EqualValues("/root/.ssh/id_rsa", gitDeploykeyVolumeMount.Path("mountPath").Data()) - suite.Assertions.EqualValues("id_rsa", gitDeploykeyVolumeMount.Path("subPath").Data()) - - volumes := deploymentManifest.Path("spec.template.spec.volumes").Children() - var gitDeploykeyVolume *gabs.Container - for _, volume := range volumes { - volumeName := volume.Path("name").Data().(string) - if volumeName == "deploykey" { - gitDeploykeyVolume = volume - break - } - } - suite.Assertions.NotEmpty(gitDeploykeyVolume) - }) - } -} diff --git a/charts/cv/charts/helm-library-common/tests/addon_netshoot_test.go b/charts/cv/charts/helm-library-common/tests/addon_netshoot_test.go deleted file mode 100644 index 3b82ea8..0000000 --- a/charts/cv/charts/helm-library-common/tests/addon_netshoot_test.go +++ /dev/null @@ -1,64 +0,0 @@ -package common - -import ( - "testing" - - "github.com/Jeffail/gabs/v2" - "github.com/k8s-at-home/library-charts/test/helmunit" - "github.com/stretchr/testify/suite" -) - -type AddonNetshootTestSuite struct { - suite.Suite - Chart helmunit.HelmChart - baseValues []string -} - -func (suite *AddonNetshootTestSuite) SetupSuite() { - suite.Chart = helmunit.New("common-test", "../../../../helper-charts/common-test") - suite.Chart.UpdateDependencies() - suite.baseValues = []string{"addons.netshoot.enabled=true"} -} - -// We need this function to kick off the test suite, otherwise -// "go test" won't know about our tests -func TestAddonNetshoot(t *testing.T) { - suite.Run(t, new(AddonNetshootTestSuite)) -} - -func (suite *AddonNetshootTestSuite) TestContainer() { - tests := map[string]struct { - values []string - expectedNetshootContainer bool - }{ - "Default": {values: nil, expectedNetshootContainer: false}, - "AddonEnabled": {values: suite.baseValues, expectedNetshootContainer: true}, - } - for name, tc := range tests { - suite.Suite.Run(name, func() { - err := suite.Chart.Render(nil, tc.values, nil) - if err != nil { - suite.FailNow(err.Error()) - } - - deploymentManifest := suite.Chart.Manifests.Get("Deployment", "common-test") - suite.Assertions.NotEmpty(deploymentManifest) - containers := deploymentManifest.Path("spec.template.spec.containers").Children() - - var netshootContainer *gabs.Container - for _, container := range containers { - containerName := container.Path("name").Data().(string) - if containerName == "netshoot" { - netshootContainer = container - break - } - } - - if tc.expectedNetshootContainer { - suite.Assertions.NotEmpty(netshootContainer) - } else { - suite.Assertions.Empty(netshootContainer) - } - }) - } -} diff --git a/charts/cv/charts/helm-library-common/tests/addon_vpn_test.go b/charts/cv/charts/helm-library-common/tests/addon_vpn_test.go deleted file mode 100644 index 864ced0..0000000 --- a/charts/cv/charts/helm-library-common/tests/addon_vpn_test.go +++ /dev/null @@ -1,129 +0,0 @@ -package common - -import ( - "testing" - - "github.com/Jeffail/gabs/v2" - "github.com/k8s-at-home/library-charts/test/helmunit" - "github.com/stretchr/testify/suite" -) - -type AddonVpnTestSuite struct { - suite.Suite - Chart helmunit.HelmChart - baseValues []string -} - -func (suite *AddonVpnTestSuite) SetupSuite() { - suite.Chart = helmunit.New("common-test", "../../../../helper-charts/common-test") - suite.Chart.UpdateDependencies() - suite.baseValues = []string{"addons.vpn.enabled=true"} -} - -// We need this function to kick off the test suite, otherwise -// "go test" won't know about our tests -func TestAddonVpn(t *testing.T) { - suite.Run(t, new(AddonVpnTestSuite)) -} - -func (suite *AddonVpnTestSuite) TestContainer() { - tests := map[string]struct { - values []string - expectedVpnContainer bool - }{ - "Default": {values: nil, expectedVpnContainer: false}, - "AddonEnabled": {values: suite.baseValues, expectedVpnContainer: true}, - } - for name, tc := range tests { - suite.Suite.Run(name, func() { - err := suite.Chart.Render(nil, tc.values, nil) - if err != nil { - suite.FailNow(err.Error()) - } - - deploymentManifest := suite.Chart.Manifests.Get("Deployment", "common-test") - suite.Assertions.NotEmpty(deploymentManifest) - containers := deploymentManifest.Path("spec.template.spec.containers").Children() - - var vpnContainer *gabs.Container - for _, container := range containers { - containerName := container.Path("name").Data().(string) - if containerName == "openvpn" { - vpnContainer = container - break - } - } - - if tc.expectedVpnContainer { - suite.Assertions.NotEmpty(vpnContainer) - } else { - suite.Assertions.Empty(vpnContainer) - } - }) - } -} - -func (suite *AddonVpnTestSuite) TestConfiguration() { - tests := map[string]struct { - values []string - expectSecret bool - expectedSecretName string - }{ - "InlineConfig": {values: append(suite.baseValues, "addons.vpn.configFile=test"), expectSecret: true, expectedSecretName: "common-test-vpnconfig"}, - "ExistingSecret": {values: append(suite.baseValues, "addons.vpn.configFileSecret=test-secret"), expectSecret: false, expectedSecretName: "test-secret"}, - } - for name, tc := range tests { - suite.Suite.Run(name, func() { - err := suite.Chart.Render(nil, tc.values, nil) - if err != nil { - suite.FailNow(err.Error()) - } - - secretManifest := suite.Chart.Manifests.Get("Secret", tc.expectedSecretName) - if tc.expectSecret { - suite.Assertions.NotEmpty(secretManifest) - } else { - suite.Assertions.Empty(secretManifest) - } - - deploymentManifest := suite.Chart.Manifests.Get("Deployment", "common-test") - suite.Assertions.NotEmpty(deploymentManifest) - - containers := deploymentManifest.Path("spec.template.spec.containers").Children() - var vpnContainer *gabs.Container - for _, container := range containers { - containerName := container.Path("name").Data().(string) - if containerName == "openvpn" { - vpnContainer = container - break - } - } - suite.Assertions.NotEmpty(vpnContainer) - - volumeMounts := vpnContainer.Path("volumeMounts").Children() - var vpnConfigVolumeMount *gabs.Container - for _, volumeMount := range volumeMounts { - volumeMountName := volumeMount.Path("name").Data().(string) - if volumeMountName == "vpnconfig" { - vpnConfigVolumeMount = volumeMount - break - } - } - suite.Assertions.NotEmpty(vpnConfigVolumeMount) - suite.Assertions.EqualValues("/vpn/vpn.conf", vpnConfigVolumeMount.Path("mountPath").Data()) - suite.Assertions.EqualValues("vpnConfigfile", vpnConfigVolumeMount.Path("subPath").Data()) - - volumes := deploymentManifest.Path("spec.template.spec.volumes").Children() - var vpnConfigVolume *gabs.Container - for _, volume := range volumes { - volumeName := volume.Path("name").Data().(string) - if volumeName == "vpnconfig" { - vpnConfigVolume = volume - break - } - } - suite.Assertions.NotEmpty(vpnConfigVolume) - - }) - } -} diff --git a/charts/cv/charts/helm-library-common/tests/configmap_test.go b/charts/cv/charts/helm-library-common/tests/configmap_test.go deleted file mode 100644 index 5641ba4..0000000 --- a/charts/cv/charts/helm-library-common/tests/configmap_test.go +++ /dev/null @@ -1,98 +0,0 @@ -package common - -import ( - // "fmt" - "testing" - - "github.com/k8s-at-home/library-charts/test/helmunit" - "github.com/stretchr/testify/suite" -) - -type ConfigmapTestSuite struct { - suite.Suite - Chart helmunit.HelmChart -} - -func (suite *ConfigmapTestSuite) SetupSuite() { - suite.Chart = helmunit.New("common-test", "../../../../helper-charts/common-test") - suite.Chart.UpdateDependencies() -} - -// We need this function to kick off the test suite, otherwise -// "go test" won't know about our tests -func TestConfigmap(t *testing.T) { - suite.Run(t, new(ConfigmapTestSuite)) -} - -func (suite *ConfigmapTestSuite) TestValues() { - tests := map[string]struct { - values []string - expectedConfigmap bool - }{ - "Default": { - values: nil, - expectedConfigmap: false, - }, - "Disabled": { - values: []string{"configmap.config.enabled=false"}, - expectedConfigmap: false, - }, - "Multiple": { - values: []string{ - "configmap.config.enabled=true", - "configmap.config.data.foo=bar", - "configmap.secondary.enabled=true", - }, - expectedConfigmap: true, - }, - } - for name, tc := range tests { - suite.Suite.Run(name, func() { - err := suite.Chart.Render(nil, tc.values, nil) - if err != nil { - suite.FailNow(err.Error()) - } - - configmapManifest := suite.Chart.Manifests.Get("ConfigMap", "common-test-config") - if tc.expectedConfigmap { - suite.Assertions.NotEmpty(configmapManifest) - } else { - suite.Assertions.Empty(configmapManifest) - } - }) - } -} - -func (suite *ConfigmapTestSuite) TestConfigmapName() { - tests := map[string]struct { - values []string - expectedName string - }{ - "Default": { - values: []string{ - "configmap.config.enabled=true", - "configmap.config.data.foo=bar", - }, - expectedName: "common-test-config", - }, - "CustomName": { - values: []string{ - "configmap.config.enabled=true", - "configmap.config.data.foo=bar", - "configmap.config.nameOverride=http", - }, - expectedName: "common-test-http", - }, - } - for name, tc := range tests { - suite.Suite.Run(name, func() { - err := suite.Chart.Render(nil, tc.values, nil) - if err != nil { - suite.FailNow(err.Error()) - } - - configmapManifest := suite.Chart.Manifests.Get("ConfigMap", tc.expectedName) - suite.Assertions.NotEmpty(configmapManifest) - }) - } -} diff --git a/charts/cv/charts/helm-library-common/tests/container_test.go b/charts/cv/charts/helm-library-common/tests/container_test.go deleted file mode 100644 index 2e1ca11..0000000 --- a/charts/cv/charts/helm-library-common/tests/container_test.go +++ /dev/null @@ -1,304 +0,0 @@ -package common - -import ( - "testing" - - "github.com/k8s-at-home/library-charts/test/helmunit" - "github.com/stretchr/testify/suite" -) - -type ContainerTestSuite struct { - suite.Suite - Chart helmunit.HelmChart -} - -func (suite *ContainerTestSuite) SetupSuite() { - suite.Chart = helmunit.New("common-test", "../../../../helper-charts/common-test") - suite.Chart.UpdateDependencies() -} - -// We need this function to kick off the test suite, otherwise -// "go test" won't know about our tests -func TestContainer(t *testing.T) { - suite.Run(t, new(ContainerTestSuite)) -} - -func (suite *ContainerTestSuite) TestCommand() { - tests := map[string]struct { - values []string - expectedCommand []string - }{ - "Default": {values: nil, expectedCommand: nil}, - "SingleString": {values: []string{"command=/bin/sh"}, expectedCommand: []string{"/bin/sh"}}, - "StringList": {values: []string{"command={/bin/sh,-c}"}, expectedCommand: []string{"/bin/sh", "-c"}}, - } - for name, tc := range tests { - suite.Suite.Run(name, func() { - err := suite.Chart.Render(nil, tc.values, nil) - if err != nil { - suite.FailNow(err.Error()) - } - - deploymentManifest := suite.Chart.Manifests.Get("Deployment", "common-test") - suite.Assertions.NotEmpty(deploymentManifest) - containers := deploymentManifest.Path("spec.template.spec.containers").Children() - containerCommand := containers[0].Path("command") - - if tc.expectedCommand == nil { - suite.Assertions.Empty(containerCommand) - } else { - var actualDataList []string - actualData := containerCommand.Children() - for _, key := range actualData { - actualDataList = append(actualDataList, key.Data().(string)) - } - suite.Assertions.EqualValues(tc.expectedCommand, actualDataList) - } - }) - } -} - -func (suite *ContainerTestSuite) TestArgs() { - tests := map[string]struct { - values []string - expectedArgs []string - }{ - "Default": {values: nil, expectedArgs: nil}, - "SingleString": {values: []string{"args=sleep infinity"}, expectedArgs: []string{"sleep infinity"}}, - "StringList": {values: []string{"args={sleep,infinity}"}, expectedArgs: []string{"sleep", "infinity"}}, - } - for name, tc := range tests { - suite.Suite.Run(name, func() { - err := suite.Chart.Render(nil, tc.values, nil) - if err != nil { - suite.FailNow(err.Error()) - } - - deploymentManifest := suite.Chart.Manifests.Get("Deployment", "common-test") - suite.Assertions.NotEmpty(deploymentManifest) - containers := deploymentManifest.Path("spec.template.spec.containers").Children() - containerArgs := containers[0].Path("args") - - if tc.expectedArgs == nil { - suite.Assertions.Empty(containerArgs) - } else { - var actualDataList []string - actualData := containerArgs.Children() - for _, key := range actualData { - actualDataList = append(actualDataList, key.Data().(string)) - } - suite.Assertions.EqualValues(tc.expectedArgs, actualDataList) - } - }) - } -} - -func (suite *ContainerTestSuite) TestEnv() { - tests := map[string]struct { - values []string - expectedEnv map[string]string - }{ - "Default": {values: nil, expectedEnv: nil}, - "KeyValueString": {values: []string{"env.string=value_of_env"}, expectedEnv: map[string]string{"string": "value_of_env"}}, - "KeyValueFloat": {values: []string{"env.float=4.2"}, expectedEnv: map[string]string{"float": "4.2"}}, - "KeyValueBool": {values: []string{"env.bool=false"}, expectedEnv: map[string]string{"bool": "false"}}, - "KeyValueInt": {values: []string{"env.int=42"}, expectedEnv: map[string]string{"int": "42"}}, - "List": {values: []string{"env[0].name=STATIC_ENV_FROM_LIST", "env[0].value=STATIC_ENV_VALUE_FROM_LIST"}, expectedEnv: map[string]string{"STATIC_ENV_FROM_LIST": "STATIC_ENV_VALUE_FROM_LIST"}}, - "ValueFrom": {values: []string{"env[0].name=STATIC_ENV_FROM_LIST", "env[0].valueFrom.fieldRef.fieldPath=spec.nodeName"}, expectedEnv: map[string]string{"STATIC_ENV_FROM_LIST": "spec.nodeName"}}, - "KeyValue+ExplicitValueFrom": {values: []string{"env.STATIC_ENV=value_of_env", "env.STATIC_ENV_FROM.valueFrom.fieldRef.fieldPath=spec.nodeName"}, expectedEnv: map[string]string{"STATIC_ENV": "value_of_env", "STATIC_ENV_FROM": "spec.nodeName"}}, - "ImplicitValueFrom": {values: []string{"env.NODE_NAME.fieldRef.fieldPath=spec.nodeName"}, expectedEnv: map[string]string{"NODE_NAME": "spec.nodeName"}}, - "Templated": {values: []string{`env.DYN_ENV=\{\{ .Release.Name \}\}-admin`}, expectedEnv: map[string]string{"DYN_ENV": "common-test-admin"}}, - "Mixed": { - values: []string{ - `env.DYN_ENV=\{\{ .Release.Name \}\}-admin`, - "env.STATIC_ENV=value_of_env", - "env.STATIC_EXPLICIT_ENV_FROM.valueFrom.fieldRef.fieldPath=spec.nodeName", - "env.STATIC_IMPLICIT_ENV_FROM.fieldRef.fieldPath=spec.nodeName", - }, - expectedEnv: map[string]string{ - "DYN_ENV": "common-test-admin", - "STATIC_ENV": "value_of_env", - "STATIC_EXPLICIT_ENV_FROM": "spec.nodeName", - "STATIC_IMPLICIT_ENV_FROM": "spec.nodeName", - }, - }, - } - for name, tc := range tests { - suite.Suite.Run(name, func() { - err := suite.Chart.Render(nil, tc.values, nil) - if err != nil { - suite.FailNow(err.Error()) - } - - deploymentManifest := suite.Chart.Manifests.Get("Deployment", "common-test") - suite.Assertions.NotEmpty(deploymentManifest) - containers := deploymentManifest.Path("spec.template.spec.containers").Children() - containerEnv := containers[0].Path("env") - - if tc.expectedEnv == nil { - suite.Assertions.Empty(containerEnv) - } else { - actualDataMap := make(map[string]string) - actualData := containerEnv.Children() - for _, value := range actualData { - envVar := value.ChildrenMap() - envName := envVar["name"].Data().(string) - var envValue string - if _, ok := envVar["valueFrom"]; ok { - envValue = value.Path("valueFrom.fieldRef.fieldPath").Data().(string) - } else { - envValue = value.Path("value").Data().(string) - } - actualDataMap[envName] = envValue - } - suite.Assertions.EqualValues(tc.expectedEnv, actualDataMap) - } - }) - } -} - -func (suite *ContainerTestSuite) TestEnvFrom() { - tests := map[string]struct { - values []string - expectSecret bool - expectedSecretName string - }{ - "Default": {values: nil, expectSecret: false, expectedSecretName: ""}, - "FromSecret": {values: []string{"secret.STATIC_SECRET=value_of_secret"}, expectSecret: true, expectedSecretName: "common-test"}, - } - for name, tc := range tests { - suite.Suite.Run(name, func() { - err := suite.Chart.Render(nil, tc.values, nil) - if err != nil { - suite.FailNow(err.Error()) - } - - secretManifest := suite.Chart.Manifests.Get("Secret", tc.expectedSecretName) - if tc.expectSecret { - suite.Assertions.NotEmpty(secretManifest) - } else { - suite.Assertions.Empty(secretManifest) - } - - deploymentManifest := suite.Chart.Manifests.Get("Deployment", "common-test") - suite.Assertions.NotEmpty(deploymentManifest) - - containers := deploymentManifest.Path("spec.template.spec.containers").Children() - containerEnvFrom := containers[0].Path("envFrom").Children() - - if !tc.expectSecret { - suite.Assertions.Empty(containerEnvFrom) - } else { - suite.Assertions.EqualValues(tc.expectedSecretName, containerEnvFrom[0].Path("secretRef.name").Data().(string)) - } - }) - } -} - -func (suite *ContainerTestSuite) TestPorts() { - tests := map[string]struct { - values []string - expectedPortName string - expectedPort int - expectedProtocol string - }{ - "Default": {values: nil, expectedPortName: "http", expectedPort: 0, expectedProtocol: "TCP"}, - "CustomName": {values: []string{"service.main.ports.http.enabled=false", "service.main.ports.server.enabled=true", "service.main.ports.server.port=8080"}, expectedPortName: "server", expectedPort: 8080, expectedProtocol: "TCP"}, - "ProtocolHTTP": {values: []string{"service.main.ports.http.protocol=HTTP"}, expectedPortName: "http", expectedPort: 0, expectedProtocol: "TCP"}, - "ProtocolHTTPS": {values: []string{"service.main.ports.http.protocol=HTTP"}, expectedPortName: "http", expectedPort: 0, expectedProtocol: "TCP"}, - "ProtocolUDP": {values: []string{"service.main.ports.http.protocol=UDP"}, expectedPortName: "http", expectedPort: 0, expectedProtocol: "UDP"}, - } - for name, tc := range tests { - suite.Suite.Run(name, func() { - err := suite.Chart.Render(nil, tc.values, nil) - if err != nil { - suite.FailNow(err.Error()) - } - - deploymentManifest := suite.Chart.Manifests.Get("Deployment", "common-test") - suite.Assertions.NotEmpty(deploymentManifest) - containers := deploymentManifest.Path("spec.template.spec.containers").Children() - containerPorts := containers[0].Path("ports").Children() - suite.Assertions.NotEmpty(containerPorts[0]) - suite.Assertions.EqualValues(tc.expectedPortName, containerPorts[0].Path("name").Data()) - suite.Assertions.EqualValues(tc.expectedProtocol, containerPorts[0].Path("protocol").Data()) - - if tc.expectedPort == 0 { - suite.Assertions.Empty(containerPorts[0].Path("containerPort").Data()) - } else { - suite.Assertions.EqualValues(tc.expectedPort, containerPorts[0].Path("containerPort").Data()) - } - }) - } -} - -func (suite *ContainerTestSuite) TestPersistenceVolumeMounts() { - values := ` - persistence: - config: - enabled: true - cache: - enabled: true - type: emptyDir - claimWithCustomMountPath: - enabled: true - mountPath: /custom - accessMode: ReadWriteMany - size: 1G - claimWithSubPath: - enabled: true - existingClaim: myClaim - subPath: "mySubPath" - hostpath-data: - enabled: true - type: hostPath - mountPath: /data - hostPath: /tmp - hostpath-dev: - enabled: true - type: hostPath - hostPath: /dev - subPath: mySubPath - ` - tests := map[string]struct { - values *string - volumeToTest string - expectedMountPath string - expectedSubPath string - }{ - "MountWithoutMountPath": {values: &values, volumeToTest: "config", expectedMountPath: "/config"}, - "EmptyDir": {values: &values, volumeToTest: "cache", expectedMountPath: "/cache"}, - "MountWithCustomMountPath": {values: &values, volumeToTest: "claimWithCustomMountPath", expectedMountPath: "/custom"}, - "MountWithSubPath": {values: &values, volumeToTest: "claimWithSubPath", expectedMountPath: "/claimWithSubPath", expectedSubPath: "mySubPath"}, - "HostPathMount": {values: &values, volumeToTest: "hostpath-data", expectedMountPath: "/data"}, - "HostPathMountWithSubPath": {values: &values, volumeToTest: "hostpath-dev", expectedMountPath: "/dev", expectedSubPath: "mySubPath"}, - } - for name, tc := range tests { - suite.Suite.Run(name, func() { - err := suite.Chart.Render(nil, nil, tc.values) - if err != nil { - suite.FailNow(err.Error()) - } - - deploymentManifest := suite.Chart.Manifests.Get("Deployment", "common-test") - suite.Assertions.NotEmpty(deploymentManifest) - containers := deploymentManifest.Path("spec.template.spec.containers").Children() - containerVolumeMounts := containers[0].Path("volumeMounts").Children() - suite.Assertions.NotEmpty(containerVolumeMounts) - - for _, volumeMount := range containerVolumeMounts { - volumeMountName := volumeMount.Path("name").Data().(string) - if volumeMountName == tc.volumeToTest { - suite.Assertions.EqualValues(tc.expectedMountPath, volumeMount.Path("mountPath").Data()) - - if tc.expectedSubPath == "" { - suite.Assertions.Empty(volumeMount.Path("subPath").Data()) - } else { - suite.Assertions.EqualValues(tc.expectedSubPath, volumeMount.Path("subPath").Data()) - } - break - } - } - }) - } -} diff --git a/charts/cv/charts/helm-library-common/tests/controller_test.go b/charts/cv/charts/helm-library-common/tests/controller_test.go deleted file mode 100644 index 2963216..0000000 --- a/charts/cv/charts/helm-library-common/tests/controller_test.go +++ /dev/null @@ -1,59 +0,0 @@ -package common - -import ( - "testing" - - "github.com/k8s-at-home/library-charts/test/helmunit" - "github.com/stretchr/testify/suite" -) - -type ControllerTestSuite struct { - suite.Suite - Chart helmunit.HelmChart -} - -func (suite *ControllerTestSuite) SetupSuite() { - suite.Chart = helmunit.New("common-test", "../../../../helper-charts/common-test") - suite.Chart.UpdateDependencies() -} - -// We need this function to kick off the test suite, otherwise -// "go test" won't know about our tests -func TestController(t *testing.T) { - suite.Run(t, new(ControllerTestSuite)) -} - -func (suite *ControllerTestSuite) TestTypes() { - tests := map[string]struct { - values []string - expectedRenderFailure bool - expectedController string - }{ - "Default": {values: nil, expectedRenderFailure: false, expectedController: "deployment"}, - "DaemonSet": {values: []string{"controller.type=daemonset"}, expectedRenderFailure: false, expectedController: "daemonset"}, - "Deployment": {values: []string{"controller.type=deployment"}, expectedRenderFailure: false, expectedController: "deployment"}, - "StatefulSet": {values: []string{"controller.type=statefulset"}, expectedRenderFailure: false, expectedController: "statefulset"}, - "Custom": {values: []string{"controller.type=custom"}, expectedRenderFailure: true, expectedController: ""}, - } - for name, tc := range tests { - suite.Suite.Run(name, func() { - err := suite.Chart.Render(nil, tc.values, nil) - if tc.expectedRenderFailure { - suite.Assertions.Error(err) - return - } - if err != nil { - suite.FailNow(err.Error()) - } - - manifest := suite.Chart.Manifests.Get(tc.expectedController, "common-test") - suite.Assertions.NotEmpty(manifest) - - types := map[string]interface{}{"deployment": nil, "statefulset": nil, "daemonset": nil} - delete(types, tc.expectedController) - for k := range types { - suite.Assertions.Empty(suite.Chart.Manifests.Get(k, "common-test")) - } - }) - } -} diff --git a/charts/cv/charts/helm-library-common/tests/horizontal_pod_autoscaler_test.go b/charts/cv/charts/helm-library-common/tests/horizontal_pod_autoscaler_test.go deleted file mode 100644 index 7c28858..0000000 --- a/charts/cv/charts/helm-library-common/tests/horizontal_pod_autoscaler_test.go +++ /dev/null @@ -1,107 +0,0 @@ -package common - -import ( - "testing" - - "github.com/k8s-at-home/library-charts/test/helmunit" - "github.com/stretchr/testify/suite" -) - -type HorizontalPodAutoscalerTestSuite struct { - suite.Suite - Chart helmunit.HelmChart -} - -func (suite *HorizontalPodAutoscalerTestSuite) SetupSuite() { - suite.Chart = helmunit.New("common-test", "../../../../helper-charts/common-test") - suite.Chart.UpdateDependencies() -} - -// We need this function to kick off the test suite, otherwise -// "go test" won't know about our tests -func TestHorizontalPodAutoscaler(t *testing.T) { - suite.Run(t, new(HorizontalPodAutoscalerTestSuite)) -} - -func (suite *HorizontalPodAutoscalerTestSuite) TestValues() { - baseValues := []string{"autoscaling.enabled=true"} - tests := map[string]struct { - values []string - expectedHorizontalPodAutoscaler bool - expectedTarget string - expectedMinReplicas int - expectedMaxReplicas int - }{ - "Default": { - values: nil, - expectedHorizontalPodAutoscaler: false, - }, - "Enabled": { - values: baseValues, - expectedHorizontalPodAutoscaler: true, expectedTarget: "common-test", expectedMinReplicas: 1, expectedMaxReplicas: 3, - }, - "CustomSettings": { - values: append(baseValues, "autoscaling.target=common-custom", "autoscaling.minReplicas=4", "autoscaling.maxReplicas=8"), - expectedHorizontalPodAutoscaler: true, expectedTarget: "common-custom", expectedMinReplicas: 4, expectedMaxReplicas: 8, - }, - } - for name, tc := range tests { - suite.Suite.Run(name, func() { - err := suite.Chart.Render(nil, tc.values, nil) - if err != nil { - suite.FailNow(err.Error()) - } - - manifest := suite.Chart.Manifests.Get("HorizontalPodAutoscaler", "common-test") - if tc.expectedHorizontalPodAutoscaler { - suite.Assertions.NotEmpty(manifest) - suite.Assertions.EqualValues(tc.expectedTarget, manifest.Path("spec.scaleTargetRef.name").Data()) - suite.Assertions.EqualValues(tc.expectedMinReplicas, manifest.Path("spec.minReplicas").Data()) - suite.Assertions.EqualValues(tc.expectedMaxReplicas, manifest.Path("spec.maxReplicas").Data()) - } else { - suite.Assertions.Empty(manifest) - } - }) - } -} - -func (suite *HorizontalPodAutoscalerTestSuite) TestMetrics() { - baseValues := []string{"autoscaling.enabled=true"} - tests := map[string]struct { - values []string - expectedResources map[string]int - }{ - "targetCPUUtilizationPercentage": { - values: append(baseValues, "autoscaling.targetCPUUtilizationPercentage=60"), - expectedResources: map[string]int{"cpu": 60}, - }, - "targetMemoryUtilizationPercentage": { - values: append(baseValues, "autoscaling.targetMemoryUtilizationPercentage=70"), - expectedResources: map[string]int{"memory": 70}, - }, - "Combined": { - values: append(baseValues, "autoscaling.targetCPUUtilizationPercentage=60", "autoscaling.targetMemoryUtilizationPercentage=70"), - expectedResources: map[string]int{"cpu": 60, "memory": 70}, - }, - } - for name, tc := range tests { - suite.Suite.Run(name, func() { - err := suite.Chart.Render(nil, tc.values, nil) - if err != nil { - suite.FailNow(err.Error()) - } - - manifest := suite.Chart.Manifests.Get("HorizontalPodAutoscaler", "common-test") - suite.Assertions.NotEmpty(manifest) - - manifestMetrics := manifest.Path("spec.metrics").Children() - - metricsMap := make(map[string]int) - for _, manifestMetric := range manifestMetrics { - metricsMap[manifestMetric.Path("resource.name").Data().(string)] = int(manifestMetric.Path("resource.targetAverageUtilization").Data().(float64)) - } - - suite.Assertions.EqualValues(tc.expectedResources, metricsMap) - }) - } -} diff --git a/charts/cv/charts/helm-library-common/tests/ingress_test.go b/charts/cv/charts/helm-library-common/tests/ingress_test.go deleted file mode 100644 index f92f502..0000000 --- a/charts/cv/charts/helm-library-common/tests/ingress_test.go +++ /dev/null @@ -1,222 +0,0 @@ -package common - -import ( - "testing" - - "github.com/k8s-at-home/library-charts/test/helmunit" - "github.com/stretchr/testify/suite" -) - -type IngressTestSuite struct { - suite.Suite - Chart helmunit.HelmChart -} - -func (suite *IngressTestSuite) SetupSuite() { - suite.Chart = helmunit.New("common-test", "../../../../helper-charts/common-test") - suite.Chart.UpdateDependencies() -} - -// We need this function to kick off the test suite, otherwise -// "go test" won't know about our tests -func TestIngress(t *testing.T) { - suite.Run(t, new(IngressTestSuite)) -} - -func (suite *IngressTestSuite) TestValues() { - tests := map[string]struct { - values []string - expectedIngress bool - expectedHostName string - expectedPath string - }{ - "Default": { - values: nil, - expectedIngress: false, - }, - "Disabled": { - values: []string{"ingress.main.enabled=false"}, - expectedIngress: false, - }, - "CustomHostAndPath": { - values: []string{ - "ingress.main.enabled=true", - "ingress.main.hosts[0].host=chart-test.local", - "ingress.main.hosts[0].paths[0].path=/test", - }, - expectedIngress: true, - expectedHostName: "chart-test.local", - expectedPath: "/test", - }, - "Multiple": { - values: []string{ - "ingress.main.enabled=true", - "ingress.secondary.enabled=true", - }, - expectedIngress: true, - }, - "PathTemplate": { - values: []string{ - "ingress.main.enabled=true", - "ingress.main.hosts[0].host=chart-example.local", - `ingress.main.hosts[0].paths[0].path=\{\{ .Release.Name \}\}.path`, - }, - expectedIngress: true, - expectedPath: "common-test.path", - }, - "HostTemplate": { - values: []string{ - "ingress.main.enabled=true", - `ingress.main.hosts[0].host=\{\{ .Release.Name \}\}.hostname`, - "ingress.main.hosts[0].paths[0].path=/", - }, - expectedIngress: true, - expectedHostName: "common-test.hostname", - }, - } - for name, tc := range tests { - suite.Suite.Run(name, func() { - err := suite.Chart.Render(nil, tc.values, nil) - if err != nil { - suite.FailNow(err.Error()) - } - - ingressManifest := suite.Chart.Manifests.Get("Ingress", "common-test") - if tc.expectedIngress { - suite.Assertions.NotEmpty(ingressManifest) - - ingressRules := ingressManifest.Path("spec.rules").Children() - if tc.expectedHostName != "" { - suite.Assertions.EqualValues(tc.expectedHostName, ingressRules[0].Path("host").Data()) - } - - if tc.expectedPath != "" { - paths := ingressRules[0].Path("http.paths").Children() - suite.Assertions.EqualValues(tc.expectedPath, paths[0].Path("path").Data()) - } - } else { - suite.Assertions.Empty(ingressManifest) - } - }) - } -} - -func (suite *IngressTestSuite) TestPathServices() { - tests := map[string]struct { - values []string - expectedServiceName string - expectedServicePort int - }{ - "Default": { - values: []string{"ingress.main.enabled=true"}, - expectedServiceName: "common-test", - }, - "CustomService": { - values: []string{ - "service.main.ports.http.targetPort=80", - "ingress.main.enabled=true", - "ingress.main.hosts[0].host=test.local", - "ingress.main.hosts[0].paths[0].path=/second/", - "ingress.main.hosts[0].paths[0].service.name=pathService", - "ingress.main.hosts[0].paths[0].service.port=1234", - }, - expectedServiceName: "pathService", - expectedServicePort: 1234, - }, - } - for name, tc := range tests { - suite.Suite.Run(name, func() { - err := suite.Chart.Render(nil, tc.values, nil) - if err != nil { - suite.FailNow(err.Error()) - } - - ingressManifest := suite.Chart.Manifests.Get("Ingress", "common-test") - suite.Assertions.NotEmpty(ingressManifest) - - ingressRules := ingressManifest.Path("spec.rules").Children() - paths := ingressRules[0].Path("http.paths").Children() - primaryPath := paths[0] - - if tc.expectedServiceName == "" { - suite.Assertions.Empty(primaryPath.Path("backend.service.name").Data()) - } else { - suite.Assertions.EqualValues(tc.expectedServiceName, primaryPath.Path("backend.service.name").Data()) - } - - if tc.expectedServicePort == 0 { - suite.Assertions.Empty(primaryPath.Path("backend.service.port.number").Data()) - } else { - suite.Assertions.EqualValues(tc.expectedServicePort, primaryPath.Path("backend.service.port.number").Data()) - } - }) - } -} - -func (suite *IngressTestSuite) TestTLS() { - tests := map[string]struct { - values []string - expectedTLS bool - expectedHostName string - expectedSecretName string - }{ - "Default": { - values: nil, - expectedTLS: false, - }, - "Provided": { - values: []string{ - "ingress.main.enabled=true", - "ingress.main.tls[0].hosts[0]=hostname", - "ingress.main.tls[0].secretName=secret-name", - }, - expectedTLS: true, - expectedHostName: "hostname", - expectedSecretName: "secret-name", - }, - "NoSecret": { - values: []string{ - "ingress.main.enabled=true", - "ingress.main.tls[0].hosts[0]=hostname", - }, - expectedTLS: true, - expectedHostName: "hostname", - expectedSecretName: "", - }, - "SecretTemplate": { - values: []string{ - "ingress.main.enabled=true", - "ingress.main.tls[0].hosts[0]=hostname", - `ingress.main.tls[0].secretName=\{\{ .Release.Name \}\}-secret`, - }, - expectedTLS: true, - expectedHostName: "hostname", - expectedSecretName: "common-test-secret", - }, - } - for name, tc := range tests { - suite.Suite.Run(name, func() { - err := suite.Chart.Render(nil, tc.values, nil) - if err != nil { - suite.FailNow(err.Error()) - } - - ingressManifest := suite.Chart.Manifests.Get("Ingress", "common-test") - - if tc.expectedTLS { - suite.Assertions.NotEmpty(ingressManifest.Path("spec.tls").Data()) - tlsSpec := ingressManifest.Path("spec.tls").Children() - tlsHostsSpec := tlsSpec[0].Path("hosts").Children() - suite.Assertions.EqualValues(tc.expectedHostName, tlsHostsSpec[0].Data()) - - if tc.expectedSecretName == "" { - suite.Assertions.Empty(tlsSpec[0].Path("secretName").Data()) - } else { - suite.Assertions.EqualValues(tc.expectedSecretName, tlsSpec[0].Path("secretName").Data()) - } - } else { - suite.Assertions.Empty(ingressManifest.Path("spec.tls").Data()) - } - }) - } -} diff --git a/charts/cv/charts/helm-library-common/tests/persistentvolumeclaim_test.go b/charts/cv/charts/helm-library-common/tests/persistentvolumeclaim_test.go deleted file mode 100644 index 9cf1225..0000000 --- a/charts/cv/charts/helm-library-common/tests/persistentvolumeclaim_test.go +++ /dev/null @@ -1,166 +0,0 @@ -package common - -import ( - "testing" - - "github.com/k8s-at-home/library-charts/test/helmunit" - "github.com/stretchr/testify/suite" -) - -type PersistenceVolumeClaimTestSuite struct { - suite.Suite - Chart helmunit.HelmChart -} - -func (suite *PersistenceVolumeClaimTestSuite) SetupSuite() { - suite.Chart = helmunit.New("common-test", "../../../../helper-charts/common-test") - suite.Chart.UpdateDependencies() -} - -// We need this function to kick off the test suite, otherwise -// "go test" won't know about our tests -func TestPersistenceVolumeClaim(t *testing.T) { - suite.Run(t, new(PersistenceVolumeClaimTestSuite)) -} - -func (suite *PersistenceVolumeClaimTestSuite) TestName() { - tests := map[string]struct { - values []string - expectedName string - }{ - "Default": {values: []string{"persistence.config.enabled=true"}, expectedName: "common-test-config"}, - "WithoutSuffix": {values: []string{"persistence.config.enabled=true", "persistence.config.nameOverride=-"}, expectedName: "common-test"}, - "WithNameOverride": {values: []string{"persistence.config.enabled=true", "persistence.config.nameOverride=custom"}, expectedName: "common-test-custom"}, - } - for name, tc := range tests { - suite.Suite.Run(name, func() { - err := suite.Chart.Render(nil, tc.values, nil) - if err != nil { - suite.FailNow(err.Error()) - } - - pvcManifest := suite.Chart.Manifests.Get("PersistentVolumeClaim", tc.expectedName) - suite.Assertions.NotEmpty(pvcManifest) - }) - } -} - -func (suite *PersistenceVolumeClaimTestSuite) TestStorageClass() { - tests := map[string]struct { - values []string - expectedStorageClass string - }{ - "Default": {values: []string{"persistence.config.enabled=true"}, expectedStorageClass: "-"}, - "CustomClass": {values: []string{"persistence.config.enabled=true", "persistence.config.storageClass=custom"}, expectedStorageClass: "custom"}, - "Empty": {values: []string{"persistence.config.enabled=true", "persistence.config.storageClass=-"}, expectedStorageClass: ""}, - } - for name, tc := range tests { - suite.Suite.Run(name, func() { - err := suite.Chart.Render(nil, tc.values, nil) - if err != nil { - suite.FailNow(err.Error()) - } - - pvcManifest := suite.Chart.Manifests.Get("PersistentVolumeClaim", "common-test-config") - suite.Assertions.NotEmpty(pvcManifest) - - if tc.expectedStorageClass == "-" { - suite.Assertions.Empty(pvcManifest.Path("spec.storageClassName").Data()) - } else { - suite.Assertions.EqualValues(tc.expectedStorageClass, pvcManifest.Path("spec.storageClassName").Data()) - } - }) - } -} - -func (suite *PersistenceVolumeClaimTestSuite) TestMetaData() { - defaultChartAnnotations := make(map[string]interface{}) - defaultChartLabels := map[string]interface{}{ - "app.kubernetes.io/instance": "common-test", - "app.kubernetes.io/managed-by": "Helm", - "app.kubernetes.io/name": "common-test", - "helm.sh/chart": "common-test-0.1.0", - } - - tests := map[string]struct { - values []string - expectedAnnotations map[string]interface{} - expectedLabels map[string]interface{} - }{ - "Default": { - values: []string{ - "persistence.config.enabled=true", - }, - expectedAnnotations: nil, - expectedLabels: nil, - }, - "NoRetain": { - values: []string{ - "persistence.config.enabled=true", - "persistence.config.labels.test_label=test", - "persistence.config.annotations.test_annotation=test", - }, - expectedAnnotations: map[string]interface{}{ - "test_annotation": "test", - }, - expectedLabels: map[string]interface{}{ - "test_label": "test", - }, - }, - "Retain": { - values: []string{ - "persistence.config.enabled=true", - "persistence.config.retain=true", - "persistence.config.labels.test_label=test", - "persistence.config.annotations.test_annotation=test", - }, - expectedAnnotations: map[string]interface{}{ - "helm.sh/resource-policy": "keep", - "test_annotation": "test", - }, - expectedLabels: map[string]interface{}{ - "test_label": "test", - }, - }, - } - for name, tc := range tests { - suite.Suite.Run(name, func() { - err := suite.Chart.Render(nil, tc.values, nil) - if err != nil { - suite.FailNow(err.Error()) - } - - pvcManifest := suite.Chart.Manifests.Get("PersistentVolumeClaim", "common-test-config") - suite.Assertions.NotEmpty(pvcManifest) - - pvcAnnotations := pvcManifest.Path("metadata.annotations").Data() - testAnnotations := make(map[string]interface{}) - for index, element := range defaultChartAnnotations { - testAnnotations[index] = element - } - for index, element := range tc.expectedAnnotations { - testAnnotations[index] = element - } - - if len(testAnnotations) == 0 { - suite.Assertions.Equal(nil, pvcAnnotations) - } else { - suite.Assertions.EqualValues(testAnnotations, pvcAnnotations) - } - - pvcLabels := pvcManifest.Path("metadata.labels").Data() - testLabels := make(map[string]interface{}) - for index, element := range defaultChartLabels { - testLabels[index] = element - } - for index, element := range tc.expectedLabels { - testLabels[index] = element - } - if len(testLabels) == 0 { - suite.Assertions.Equal(nil, pvcLabels) - } else { - suite.Assertions.EqualValues(testLabels, pvcLabels) - } - }) - } -} diff --git a/charts/cv/charts/helm-library-common/tests/pod_test.go b/charts/cv/charts/helm-library-common/tests/pod_test.go deleted file mode 100644 index 31c2265..0000000 --- a/charts/cv/charts/helm-library-common/tests/pod_test.go +++ /dev/null @@ -1,386 +0,0 @@ -package common - -import ( - "testing" - - "github.com/k8s-at-home/library-charts/test/helmunit" - "github.com/stretchr/testify/suite" -) - -type PodTestSuite struct { - suite.Suite - Chart helmunit.HelmChart -} - -func (suite *PodTestSuite) SetupSuite() { - suite.Chart = helmunit.New("common-test", "../../../../helper-charts/common-test") - suite.Chart.UpdateDependencies() -} - -// We need this function to kick off the test suite, otherwise -// "go test" won't know about our tests -func TestPod(t *testing.T) { - suite.Run(t, new(PodTestSuite)) -} - -func (suite *PodTestSuite) TestReplicas() { - tests := map[string]struct { - values []string - expectedValue interface{} - }{ - "Default": {values: nil, expectedValue: 1}, - "Specified": {values: []string{"controller.replicas=3"}, expectedValue: 3}, - } - for name, tc := range tests { - suite.Suite.Run(name, func() { - err := suite.Chart.Render(nil, tc.values, nil) - if err != nil { - suite.FailNow(err.Error()) - } - - deploymentManifest := suite.Chart.Manifests.Get("Deployment", "common-test") - suite.Assertions.NotEmpty(deploymentManifest) - suite.Assertions.EqualValues(tc.expectedValue, deploymentManifest.Path("spec.replicas").Data()) - }) - } -} - -func (suite *PodTestSuite) TestHostNetwork() { - tests := map[string]struct { - values []string - expectedValue interface{} - }{ - "Default": {values: nil, expectedValue: nil}, - "SpecifiedTrue": {values: []string{"hostNetwork=true"}, expectedValue: true}, - "SpecifiedFalse": {values: []string{"hostNetwork=false"}, expectedValue: nil}, - } - for name, tc := range tests { - suite.Suite.Run(name, func() { - err := suite.Chart.Render(nil, tc.values, nil) - if err != nil { - suite.FailNow(err.Error()) - } - - deploymentManifest := suite.Chart.Manifests.Get("Deployment", "common-test") - suite.Assertions.NotEmpty(deploymentManifest) - suite.Assertions.EqualValues(tc.expectedValue, deploymentManifest.Path("spec.template.spec.hostNetwork").Data()) - }) - } -} - -func (suite *PodTestSuite) TestDnsPolicy() { - tests := map[string]struct { - values []string - expectedValue interface{} - }{ - "Default": {values: nil, expectedValue: "ClusterFirst"}, - "HostnetworkFalse": {values: []string{"hostNetwork=false"}, expectedValue: "ClusterFirst"}, - "HostnetworkTrue": {values: []string{"hostNetwork=true"}, expectedValue: "ClusterFirstWithHostNet"}, - "ManualOverride": {values: []string{"dnsPolicy=None"}, expectedValue: "None"}, - } - for name, tc := range tests { - suite.Suite.Run(name, func() { - err := suite.Chart.Render(nil, tc.values, nil) - if err != nil { - suite.FailNow(err.Error()) - } - - deploymentManifest := suite.Chart.Manifests.Get("Deployment", "common-test") - suite.Assertions.NotEmpty(deploymentManifest) - suite.Assertions.EqualValues(tc.expectedValue, deploymentManifest.Path("spec.template.spec.dnsPolicy").Data()) - }) - } -} - -func (suite *PodTestSuite) TestInitContainers() { - tests := map[string]struct { - values []string - expectedContainer interface{} - }{ - "StaticWithName": {values: []string{"initContainers.init1.name=template-test"}, expectedContainer: "template-test"}, - "StaticWithoutName": {values: []string{"initContainers.init1.image=template-test"}, expectedContainer: "init1"}, - "DynamicTemplate": {values: []string{`initContainers.init1.name=\{\{ .Release.Name \}\}-container`}, expectedContainer: "common-test-container"}, - } - for name, tc := range tests { - suite.Suite.Run(name, func() { - err := suite.Chart.Render(nil, tc.values, nil) - if err != nil { - suite.FailNow(err.Error()) - } - - deploymentManifest := suite.Chart.Manifests.Get("Deployment", "common-test") - initcontainers := deploymentManifest.Path("spec.template.spec.initContainers") - suite.Assertions.Contains(initcontainers.Search("*", "name").Data(), tc.expectedContainer) - }) - } -} - -func (suite *PodTestSuite) TestAdditionalContainers() { - tests := map[string]struct { - values []string - expectedContainer interface{} - }{ - "StaticWithName": {values: []string{"additionalContainers.additional1.name=template-test"}, expectedContainer: "template-test"}, - "StaticWithoutName": {values: []string{"additionalContainers.additional1.image=template-test"}, expectedContainer: "additional1"}, - "DynamicTemplate": {values: []string{`additionalContainers.additional1.name=\{\{ .Release.Name \}\}-container`}, expectedContainer: "common-test-container"}, - } - for name, tc := range tests { - suite.Suite.Run(name, func() { - err := suite.Chart.Render(nil, tc.values, nil) - if err != nil { - suite.FailNow(err.Error()) - } - - deploymentManifest := suite.Chart.Manifests.Get("Deployment", "common-test") - containers := deploymentManifest.Path("spec.template.spec.containers") - suite.Assertions.Contains(containers.Search("*", "name").Data(), tc.expectedContainer) - }) - } -} -func (suite *PodTestSuite) TestPersistenceItems() { - values := ` - persistence: - cache: - enabled: true - type: emptyDir - config: - enabled: true - data: - enabled: true - existingClaim: dataClaim - custom-mount: - enabled: true - type: custom - volumeSpec: - downwardAPI: - items: - - path: "labels" - fieldRef: - fieldPath: metadata.labels - ` - tests := map[string]struct { - values *string - expectedVolumes []string - }{ - "Default": {values: nil, expectedVolumes: nil}, - "MultipleItems": {values: &values, expectedVolumes: []string{"config", "cache", "data", "custom-mount"}}, - } - for name, tc := range tests { - suite.Suite.Run(name, func() { - err := suite.Chart.Render(nil, nil, tc.values) - if err != nil { - suite.FailNow(err.Error()) - } - - deploymentManifest := suite.Chart.Manifests.Get("Deployment", "common-test") - volumes := deploymentManifest.Path("spec.template.spec.volumes") - - if tc.expectedVolumes == nil { - suite.Assertions.EqualValues(nil, volumes.Data()) - } else { - suite.Assertions.NotEmpty(volumes) - searchVolumes := volumes.Search("*", "name").Data() - for _, expectedVolume := range tc.expectedVolumes { - suite.Assertions.Contains(searchVolumes, expectedVolume) - } - } - }) - } -} - -func (suite *PodTestSuite) TestPersistenceClaimNames() { - values := ` - persistence: - config: - enabled: true - existingClaim: - enabled: true - existingClaim: myClaim - claimWithoutSuffix: - enabled: true - nameOverride: "-" - accessMode: ReadWriteMany - size: 1G - claimWithNameOverride: - enabled: true - nameOverride: suffix - accessMode: ReadWriteMany - size: 1G - ` - tests := map[string]struct { - values *string - volumeToTest string - expectedClaimName string - }{ - "DefaultClaimName": {values: &values, volumeToTest: "config", expectedClaimName: "common-test-config"}, - "ClaimNameWithoutSuffix": {values: &values, volumeToTest: "claimWithoutSuffix", expectedClaimName: "common-test"}, - "ClaimNameWithNameOverride": {values: &values, volumeToTest: "claimWithNameOverride", expectedClaimName: "common-test-suffix"}, - "ExistingClaim": {values: &values, volumeToTest: "existingClaim", expectedClaimName: "myClaim"}, - } - for name, tc := range tests { - suite.Suite.Run(name, func() { - err := suite.Chart.Render(nil, nil, tc.values) - if err != nil { - suite.FailNow(err.Error()) - } - - deploymentManifest := suite.Chart.Manifests.Get("Deployment", "common-test") - volumes := deploymentManifest.Path("spec.template.spec.volumes").Children() - - for _, volume := range volumes { - volumeName := volume.Path("name").Data().(string) - if volumeName == tc.volumeToTest { - suite.Assertions.EqualValues(tc.expectedClaimName, volume.Path("persistentVolumeClaim.claimName").Data()) - break - } - } - }) - } -} - -func (suite *PodTestSuite) TestPersistenceEmptyDir() { - baseValues := ` - persistence: - config: - enabled: true - type: emptyDir - ` - tests := map[string]struct { - values []string - expectedMedium string - expectedSizeLimit string - }{ - "Enabled": {values: nil, expectedMedium: "", expectedSizeLimit: ""}, - "WithMedium": {values: []string{"persistence.config.medium=memory"}, expectedMedium: "memory", expectedSizeLimit: ""}, - "WithSizeLimit": {values: []string{"persistence.config.medium=memory", "persistence.config.sizeLimit=1Gi"}, expectedMedium: "memory", expectedSizeLimit: "1Gi"}, - } - for name, tc := range tests { - suite.Suite.Run(name, func() { - err := suite.Chart.Render(nil, tc.values, &baseValues) - if err != nil { - suite.FailNow(err.Error()) - } - - deploymentManifest := suite.Chart.Manifests.Get("Deployment", "common-test") - volumes := deploymentManifest.Path("spec.template.spec.volumes").Children() - volume := volumes[0] - suite.Assertions.NotEmpty(volume.Data()) - - if tc.expectedMedium == "" { - suite.Assertions.Nil(volume.Path("emptyDir.medium")) - } else { - suite.Assertions.EqualValues(tc.expectedMedium, volume.Path("emptyDir.medium").Data()) - } - - if tc.expectedSizeLimit == "" { - suite.Assertions.Nil(volume.Path("emptyDir.sizeLimit")) - } else { - suite.Assertions.EqualValues(tc.expectedSizeLimit, volume.Path("emptyDir.sizeLimit").Data()) - } - - }) - } -} - -func (suite *PodTestSuite) TestHostPathVolumes() { - values := ` - persistence: - hostpathmounts-data: - enabled: true - type: hostPath - hostPath: "/tmp1" - mountPath: "/data" - hostpathmounts-with-type: - enabled: true - type: hostPath - hostPath: "/tmp2" - hostPathType: "Directory" - mountPath: "/data2" - ` - tests := map[string]struct { - values *string - expectedVolumes []string - }{ - "Default": {values: nil, expectedVolumes: nil}, - "MultipleItems": {values: &values, expectedVolumes: []string{"hostpathmounts-data", "hostpathmounts-with-type"}}, - } - for name, tc := range tests { - suite.Suite.Run(name, func() { - err := suite.Chart.Render(nil, nil, tc.values) - if err != nil { - suite.FailNow(err.Error()) - } - - deploymentManifest := suite.Chart.Manifests.Get("Deployment", "common-test") - volumes := deploymentManifest.Path("spec.template.spec.volumes") - - if tc.expectedVolumes == nil { - suite.Assertions.EqualValues(nil, volumes.Data()) - } else { - suite.Assertions.NotEmpty(volumes) - searchVolumes := volumes.Search("*", "name").Data() - for _, expectedVolume := range tc.expectedVolumes { - suite.Assertions.Contains(searchVolumes, expectedVolume) - } - } - }) - } -} - -func (suite *PodTestSuite) TestVolumeClaimTemplates() { - values := ` - volumeClaimTemplates: - - name: 'storage' - accessMode: 'ReadWriteOnce' - size: '10Gi' - storageClass: 'storage' - ` - tests := map[string]struct { - values []string - volumeClaimToTest string - expectedAccessMode string - expectedSize string - expectedStorageClassName string - }{ - "StatefulSet": {values: []string{"controller.type=statefulset"}, volumeClaimToTest: "storage", expectedAccessMode: "ReadWriteOnce", expectedSize: "10Gi", expectedStorageClassName: "storage"}, - } - for name, tc := range tests { - suite.Suite.Run(name, func() { - err := suite.Chart.Render(nil, tc.values, &values) - if err != nil { - suite.FailNow(err.Error()) - } - - controllerManifest := suite.Chart.Manifests.Get("StatefulSet", "common-test") - suite.Assertions.NotEmpty(controllerManifest) - - volumeClaimTemplates := controllerManifest.Path("spec.volumeClaimTemplates").Children() - suite.Assertions.NotEmpty(volumeClaimTemplates) - - for _, volumeClaimTemplate := range volumeClaimTemplates { - volumeClaimName := volumeClaimTemplate.Path("metadata.name").Data() - if volumeClaimName == tc.volumeClaimToTest { - if tc.expectedAccessMode == "" { - suite.Assertions.Empty(controllerManifest) - } else { - accessModes := volumeClaimTemplate.Path("spec.accessModes").Children() - suite.Assertions.EqualValues(tc.expectedAccessMode, accessModes[0].Data()) - } - - if tc.expectedSize == "" { - suite.Assertions.Empty(controllerManifest) - } else { - suite.Assertions.EqualValues(tc.expectedSize, volumeClaimTemplate.Path("spec.resources.requests.storage").Data()) - } - - if tc.expectedStorageClassName == "" { - suite.Assertions.Empty(controllerManifest) - } else { - suite.Assertions.EqualValues(tc.expectedStorageClassName, volumeClaimTemplate.Path("spec.storageClassName").Data()) - } - break - } - } - }) - } -} diff --git a/charts/cv/charts/helm-library-common/tests/service_test.go b/charts/cv/charts/helm-library-common/tests/service_test.go deleted file mode 100644 index 06d1e34..0000000 --- a/charts/cv/charts/helm-library-common/tests/service_test.go +++ /dev/null @@ -1,138 +0,0 @@ -package common - -import ( - "fmt" - "testing" - - "github.com/k8s-at-home/library-charts/test/helmunit" - "github.com/stretchr/testify/suite" -) - -type ServiceTestSuite struct { - suite.Suite - Chart helmunit.HelmChart -} - -func (suite *ServiceTestSuite) SetupSuite() { - suite.Chart = helmunit.New("common-test", "../../../../helper-charts/common-test") - suite.Chart.UpdateDependencies() -} - -// We need this function to kick off the test suite, otherwise -// "go test" won't know about our tests -func TestService(t *testing.T) { - suite.Run(t, new(ServiceTestSuite)) -} - -func (suite *ServiceTestSuite) TestServiceName() { - tests := map[string]struct { - values []string - expectedName string - }{ - "Default": {values: nil, expectedName: "common-test"}, - "CustomName": {values: []string{"service.main.nameOverride=http"}, expectedName: "common-test-http"}, - } - for name, tc := range tests { - suite.Suite.Run(name, func() { - err := suite.Chart.Render(nil, tc.values, nil) - if err != nil { - suite.FailNow(err.Error()) - } - - serviceManifest := suite.Chart.Manifests.Get("Service", tc.expectedName) - suite.Assertions.NotEmpty(serviceManifest) - }) - } -} - -func (suite *ServiceTestSuite) TestPortNames() { - tests := map[string]struct { - values []string - expectedRenderFailure bool - expectedName string - expectedTargetPort interface{} - }{ - "Default": {values: nil, expectedRenderFailure: false, expectedName: "http", expectedTargetPort: "http"}, - "CustomName": {values: []string{"service.main.ports.http.enabled=false", "service.main.ports.server.enabled=true", "service.main.ports.server.port=8080"}, expectedRenderFailure: false, expectedName: "server", expectedTargetPort: "server"}, - "CustomTargetPort": {values: []string{"service.main.ports.http.targetPort=80"}, expectedRenderFailure: false, expectedName: "http", expectedTargetPort: 80}, - "NamedTargetPort": {values: []string{"service.main.ports.http.targetPort=name"}, expectedRenderFailure: true, expectedName: "", expectedTargetPort: nil}, - } - for name, tc := range tests { - suite.Suite.Run(name, func() { - err := suite.Chart.Render(nil, tc.values, nil) - if tc.expectedRenderFailure { - suite.Assertions.Error(err) - return - } - if err != nil { - suite.FailNow(err.Error()) - } - - serviceManifest := suite.Chart.Manifests.Get("Service", "common-test") - suite.Assertions.NotEmpty(serviceManifest) - servicePorts := serviceManifest.Path("spec.ports").Children() - suite.Assertions.EqualValues(tc.expectedName, servicePorts[0].Path("name").Data()) - suite.Assertions.EqualValues(tc.expectedTargetPort, servicePorts[0].Path("targetPort").Data()) - }) - } -} - -func (suite *ServiceTestSuite) TestPortProtocol() { - tests := map[string]struct { - values []string - expectedProtocol string - }{ - "Default": {values: nil, expectedProtocol: "TCP"}, - "ExplicitTCP": {values: []string{"service.main.ports.http.protocol=TCP"}, expectedProtocol: "TCP"}, - "ExplicitHTTP": {values: []string{"service.main.ports.http.protocol=HTTP"}, expectedProtocol: "TCP"}, - "ExplicitHTTPS": {values: []string{"service.main.ports.http.protocol=HTTPS"}, expectedProtocol: "TCP"}, - "ExplicitUDP": {values: []string{"service.main.ports.http.protocol=UDP"}, expectedProtocol: "UDP"}, - } - for name, tc := range tests { - suite.Suite.Run(name, func() { - err := suite.Chart.Render(nil, tc.values, nil) - if err != nil { - suite.FailNow(err.Error()) - } - - serviceManifest := suite.Chart.Manifests.Get("Service", "common-test") - suite.Assertions.NotEmpty(serviceManifest) - servicePorts := serviceManifest.Path("spec.ports").Children() - suite.Assertions.EqualValues(tc.expectedProtocol, servicePorts[0].Path("protocol").Data()) - }) - } -} - -func (suite *ServiceTestSuite) TestAnnotations() { - tests := map[string]struct { - values []string - expectedAnnotations map[string]string - }{ - "Default": {values: nil, expectedAnnotations: nil}, - "ExplicitTCP": {values: []string{"service.main.ports.http.protocol=TCP"}, expectedAnnotations: nil}, - "ExplicitHTTP": {values: []string{"service.main.ports.http.protocol=HTTP"}, expectedAnnotations: nil}, - "ExplicitHTTPS": {values: []string{"service.main.ports.http.protocol=HTTPS"}, expectedAnnotations: map[string]string{"traefik.ingress.kubernetes.io/service.serversscheme": "https"}}, - "ExplicitUDP": {values: []string{"service.main.ports.http.protocol=UDP"}, expectedAnnotations: nil}, - } - for name, tc := range tests { - suite.Suite.Run(name, func() { - err := suite.Chart.Render(nil, tc.values, nil) - if err != nil { - suite.FailNow(err.Error()) - } - - serviceManifest := suite.Chart.Manifests.Get("Service", "common-test") - suite.Assertions.NotEmpty(serviceManifest) - serviceAnnotations := serviceManifest.Path("metadata.annotations").Children() - if tc.expectedAnnotations == nil { - suite.Assertions.Empty(serviceAnnotations) - } else { - for annotation, value := range tc.expectedAnnotations { - serviceAnnotation := serviceManifest.Path("metadata.annotations").Search(annotation) - suite.Assertions.NotEmpty(serviceAnnotation, fmt.Sprintf("Annotation %s not found", annotation)) - suite.Assertions.EqualValues(value, serviceAnnotation.Data(), fmt.Sprintf("Invalid value for annotation %s", annotation)) - } - } - }) - } -} diff --git a/charts/cv/values.yaml b/charts/cv/values.yaml index 030f1be..85143a6 100644 --- a/charts/cv/values.yaml +++ b/charts/cv/values.yaml @@ -25,16 +25,29 @@ service: main: ports: http: - port: 80 + port: 8080 ingress: # -- Enable and configure ingress settings for the chart under this key. # @default -- See values.yaml main: enabled: false +# hosts: +# - host: "cv.opti.cabillot.eu" +# paths: +# - path: "/" +# tls: +# - hosts: +# - "cv.opti.cabillot.eu" # -- Configures the probes for the main Pod. # @default -- See values.yaml probes: liveness: enabled: false + readiness: + enabled: false + startup: + enabled: false + +automountServiceAccountToken: false