parameter_test.go

package parameters_test

import (
	. "github.com/onsi/ginkgo"
	. "github.com/onsi/gomega"

	. "k8s.libre.sh/application/settings/parameters"

	corev1 "k8s.io/api/core/v1"
)

var _ = Describe("Parameter", func() {
	BeforeEach(func() {

		/* 		paramTemplateLiteral = Parameter{
			Key:       "TEMPLATE_PARAMETER",
			Value:     "{{ .LITERAL_PARAMETER }}",
			Type:      ConfigParameter,
			Generate:  GenerateTemplate,
			MountType: MountLiteral,
		} */

		/* 		paramTemplateFrom = Parameter{
			Key:       "TEMPLATE_PARAMETER_FROM",
			Value:     "{{ .LITERAL_PARAMETER }}",
			Type:      ConfigParameter,
			Generate:  GenerateTemplate,
			MountType: MountEnvFile,
		} */

	})

	Describe("Generating Environment Variables for containers from parameter", func() {
		Context("MountType is Literal", func() {
			It("should generate envVar", func() {

				paramEnvVar := Parameter{
					Key:       "LITERAL_PARAMETER",
					Value:     "LiteralParameter",
					Type:      ConfigParameter,
					MountType: MountLiteral,
				}

				expectedObj := corev1.EnvVar{
					Name:  "LITERAL_PARAMETER",
					Value: "LiteralParameter",
				}

				res, err := paramEnvVar.GetEnvVar()

				Expect(res).To(Equal(expectedObj))
				Expect(err).NotTo(HaveOccurred())
			})
		})

		Context("MountType is From", func() {
			It("should generate envVar with valueFrom ConfigMap", func() {

				valueFrom := ValueFrom{
					FromKey: "FROM_KEY_CONFIG_PARAMETER",
					Ref:     "configRef",
					RefType: "configmap",
				}

				paramEnvVarFrom := Parameter{
					Key:       "VALUE_FROM_CONFIG_PARAMETER",
					ValueFrom: valueFrom,
					Type:      ConfigParameter,
					MountType: MountFrom,
				}

				expectedObj := corev1.EnvVar{
					Name: "VALUE_FROM_CONFIG_PARAMETER",
					ValueFrom: &corev1.EnvVarSource{
						ConfigMapKeyRef: &corev1.ConfigMapKeySelector{
							LocalObjectReference: corev1.LocalObjectReference{
								Name: "configRef",
							},
							Key: "FROM_KEY_CONFIG_PARAMETER",
						},
					},
				}

				res, err := paramEnvVarFrom.GetEnvVar()

				Expect(res).To(Equal(expectedObj))
				Expect(err).NotTo(HaveOccurred())
			})
			It("should generate envVar with valueFrom Secret", func() {
				valueFromSecret := ValueFrom{
					FromKey: "FROM_KEY_SECRET_PARAMETER",
					Ref:     "secretRef",
					RefType: "secret",
				}

				paramEnvVarFromSecret := Parameter{
					Key:       "VALUE_FROM_SECRET_PARAMETER",
					ValueFrom: valueFromSecret,
					Type:      SecretParameter,
					MountType: MountFrom,
				}

				expectedObj := corev1.EnvVar{
					Name: "VALUE_FROM_SECRET_PARAMETER",
					ValueFrom: &corev1.EnvVarSource{
						SecretKeyRef: &corev1.SecretKeySelector{
							LocalObjectReference: corev1.LocalObjectReference{
								Name: "secretRef",
							},
							Key: "FROM_KEY_SECRET_PARAMETER",
						},
					},
				}

				res, err := paramEnvVarFromSecret.GetEnvVar()

				Expect(res).To(Equal(expectedObj))
				Expect(err).NotTo(HaveOccurred())
			})
		})

		Context("MountType is ObjectField", func() {
			It("should generate envVar with valueFrom", func() {

				valueFromObject := ValueFrom{
					FromKey: "status.podIP",
					Ref:     "v1",
				}

				paramEnvVarFromObject := Parameter{
					Key:       "PARAMETER_FROM_OBJECT",
					Type:      ObjectFieldParameter,
					ValueFrom: valueFromObject,
					MountType: MountFrom,
				}

				expectedObj := corev1.EnvVar{
					Name: "PARAMETER_FROM_OBJECT",
					ValueFrom: &corev1.EnvVarSource{
						FieldRef: &corev1.ObjectFieldSelector{
							APIVersion: "v1",
							FieldPath:  "status.podIP",
						},
					},
				}

				res, err := paramEnvVarFromObject.GetEnvVar()

				Expect(res).To(Equal(expectedObj))
				Expect(err).NotTo(HaveOccurred())
			})
		})
	})

	Describe("Generating mount files", func() {

		var paramMountFile Parameter

		BeforeEach(func() {
			paramMountFile = Parameter{
				Key: "nginx-conf",
				ValueFrom: ValueFrom{
					Ref: "mountfile-source",
				},
				Type:      ConfigParameter,
				Value:     "example",
				MountType: MountFile,
				MountPath: MountPath{
					Path:    "/ect/nginx/nginx.conf",
					SubPath: "nginx.conf",
				},
			}
		})

		Context("Generating volumes & volume mount", func() {
			It("should generate volume for pod from configmap", func() {

				expectedObj := corev1.Volume{
					Name: "nginx-conf",
					VolumeSource: corev1.VolumeSource{
						ConfigMap: &corev1.ConfigMapVolumeSource{
							LocalObjectReference: corev1.LocalObjectReference{
								Name: "mountfile-source",
							},
							Items: []corev1.KeyToPath{
								{
									Key:  "nginx-conf",
									Path: "nginx.conf",
								},
							},
						},
					},
				}
				Expect(paramMountFile.GetPodVolume()).To(Equal(expectedObj))
			})

			It("should generate volume for pod from secret", func() {

				paramMountFile.Type = SecretParameter

				expectedObj := corev1.Volume{
					Name: "nginx-conf",
					VolumeSource: corev1.VolumeSource{
						Secret: &corev1.SecretVolumeSource{
							SecretName: "mountfile-source",
							Items: []corev1.KeyToPath{
								{
									Key:  "nginx-conf",
									Path: "nginx.conf",
								},
							},
						},
					},
				}
				Expect(paramMountFile.GetPodVolume()).To(Equal(expectedObj))
			})

			It("should generate volumeMount for container from configmap", func() {

				expectedObj := corev1.VolumeMount{
					Name:      "nginx-conf",
					ReadOnly:  true,
					MountPath: "/ect/nginx/nginx.conf",
					SubPath:   "nginx.conf",
				}

				Expect(paramMountFile.GetVolumeMount()).To(Equal(expectedObj))
			})
		})
	})

	/* 	Describe("Generating Env for containers with EnvFrom", func() {
		Context("Generating env", func() {
			It("should generate envFrom", func() {

				expectedObj := []corev1.EnvFromSource{
					{
						ConfigMapRef: &corev1.ConfigMapEnvSource{
							LocalObjectReference: corev1.LocalObjectReference{
								Name: "myconfigmap",
							},
						},
					},
					{
						SecretRef: &corev1.SecretEnvSource{
							LocalObjectReference: corev1.LocalObjectReference{
								Name: "mysecret",
							},
						},
					},
					{
						SecretRef: &corev1.SecretEnvSource{
							LocalObjectReference: corev1.LocalObjectReference{
								Name: "myothersecret",
							},
						},
					},
				}

				res := settings.GetEnvFrom()

				Expect(res).To(Equal(expectedObj))
				//	Expect(err).NotTo(HaveOccurred())
			})
		})
	}) */

})