parameters_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("Parameters", func() {
	var (
		paramEnvVar     Parameter
		paramEnvVarFrom Parameter
		//	paramEnvFrom          Parameter
		//	paramEnvFromSecret    Parameter
		paramEnvVarFromSecret Parameter
		paramEnvVarFromObject Parameter
		paramTemplateLiteral  Parameter
		paramTemplateFrom     Parameter
		paramMountFile        Parameter
		valueFrom             ValueFrom
		valueFromSecret       ValueFrom
		valueFromObject       ValueFrom
		parameters            *Parameters
	//	settings              *Settings
	//	envFrom               *EnvFrom
	)

	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,
		}

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

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

		valueFromSecret = ValueFrom{
			FromKey: "FROM_KEY_SECRET_PARAMETER",
			Ref:     "secretRef",
		}

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

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

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

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

		paramMountFile = Parameter{
			Key:       "nginx.conf",
			Type:      ConfigParameter,
			Value:     "example",
			MountType: MountFile,
			MountPath: MountPath{
				Path:    "/ect/nginx/nginx.conf",
				SubPath: "nginx.conf",
			},
		}

		parameters = &Parameters{
			&paramEnvVar,
			&paramEnvVarFrom,
			&paramEnvVarFromSecret,
			//	&paramEnvFrom,
			//	&paramEnvFromSecret,
			&paramEnvVarFromObject,
			&paramTemplateLiteral,
			&paramTemplateFrom,
			&paramMountFile,
		}

		/* 		envFrom = &EnvFrom{
		   			SecretRefs: []string{
		   				"mysecret",
		   				"myothersecret",
		   			},
		   			ConfigRefs: []string{
		   				"myconfigmap",
		   			},
		   		}

		   		settings = &Settings{
		   			EnvFrom:    envFrom,
		   			Parameters: parameters,
		   		} */

	})

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

				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", func() {
				expectedObj := corev1.EnvVar{
					Name: "VALUE_FROM_CONFIG_PARAMETER",
					ValueFrom: &corev1.EnvVarSource{
						ConfigMapKeyRef: &corev1.ConfigMapKeySelector{
							LocalObjectReference: corev1.LocalObjectReference{
								Name: "configRef",
							},
							Key: "FROM_KEY_CONFIG_PARAMETER",
						},
					},
				}

				// TODO ADD SECRET

				res, err := paramEnvVarFrom.GetEnvVar()

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

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

				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 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())
			})
		})
	}) */

	Describe("Generating Env for containers with Parameters", func() {
		Context("Generating envFrom", func() {
			It("should generate envVar", func() {

				expectedObj := []corev1.EnvVar{
					{
						Name:  "LITERAL_PARAMETER",
						Value: "LiteralParameter",
					},
					{
						Name: "VALUE_FROM_CONFIG_PARAMETER",
						ValueFrom: &corev1.EnvVarSource{
							ConfigMapKeyRef: &corev1.ConfigMapKeySelector{
								LocalObjectReference: corev1.LocalObjectReference{
									Name: "configRef",
								},
								Key: "FROM_KEY_CONFIG_PARAMETER",
							},
						},
					},
					{
						Name: "VALUE_FROM_SECRET_PARAMETER",
						ValueFrom: &corev1.EnvVarSource{
							SecretKeyRef: &corev1.SecretKeySelector{
								LocalObjectReference: corev1.LocalObjectReference{
									Name: "secretRef",
								},
								Key: "FROM_KEY_SECRET_PARAMETER",
							},
						},
					},
					{
						Name: "PARAMETER_FROM_OBJECT",
						ValueFrom: &corev1.EnvVarSource{
							FieldRef: &corev1.ObjectFieldSelector{
								APIVersion: "v1",
								FieldPath:  "status.podIP",
							},
						},
					},
					{
						Name:  "TEMPLATE_PARAMETER",
						Value: "LiteralParameter",
					},
				}

				parameters.InitValues()
				res := parameters.GetEnvVar()

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

	Describe("Generating data for configmap and secret with Parameters", func() {
		Context("Generating data", func() {
			It("should generate data", func() {
				parameters.InitValues()

				expectedObj := map[string]string{
					"TEMPLATE_PARAMETER_FROM": "LiteralParameter",
				}

				Expect(parameters.GetData()).To(Equal(expectedObj))
				//	Expect(err).NotTo(HaveOccurred())
			})
		})
	})
	/*
		Describe("Generating mount files", func() {
			Context("Generating volumes & volume mount", func() {
				It("should generate volume for pod", func() {

					expectedObj := corev1.Volume{
						Name: "nginx-conf",
						VolumeSource: corev1.VolumeSource{
							ConfigMap: &corev1.ConfigMapVolumeSource{
								LocalObjectReference: corev1.LocalObjectReference{
									Name: "",
								},
							},
						},
					}
					Expect(paramMountFile.GetPodVolume()).To(Equal(expectedObj))
					//	Expect(err).NotTo(HaveOccurred())
				})
				It("should generate volumeMount for container", func() {
					expectedObj := corev1.VolumeMount{
						Name:      "nginx-conf",
						ReadOnly:  true,
						MountPath: "",
						SubPath:   "",
					}

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

})