parameters_test.go

package parameters_test

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

	. "k8s.libre.sh/parameters"

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

var _ = Describe("Parameters", func() {
	var (
		paramEnvVar           Parameter
		paramEnvVarFrom       Parameter
		paramEnvFrom          Parameter
		paramEnvFromSecret    Parameter
		paramEnvVarFromSecret Parameter
		valueFrom             ValueFrom
		valueFromSecret       ValueFrom
		parameters            *Parameters
	)

	BeforeEach(func() {
		paramEnvVar = Parameter{
			//	Name:  "Parameter",
			Key:   "MY_PARAMETER",
			Value: "Parameter",
			//	Destination: "",
			//	Generate: "",
			Type: "ConfigMap",
		}

		valueFrom = ValueFrom{
			FromKey: "FROM_PARAMETER",
			Source:  "source",
		}

		valueFromSecret = ValueFrom{
			FromKey: "FROM_SECRET_PARAMETER",
			Source:  "secret_source",
		}

		paramEnvVarFrom = Parameter{
			//	Name:      "Parameter",
			Key:       "MY_PARAMETER",
			ValueFrom: valueFrom,
			//	Value:   "Parameter",
			//	Destination: "",
			//	Generate: "",
			Type: "ConfigMap",
		}

		paramEnvVarFromSecret = Parameter{
			//	Name:      "Parameter",
			Key:       "MY_SECRET_PARAMETER",
			ValueFrom: valueFromSecret,
			//	Value:   "Parameter",
			//	Destination: "",
			//	Generate: "",
			Type: "Secret",
		}

		paramEnvFrom = Parameter{
			//	Name:   "Parameter",
			ValueFrom: ValueFrom{
				Source: "source",
			},
			//	Source: "source",
			//	Destination: "",
			//	Generate: "",
			Type: "ConfigMap",
		}

		paramEnvFromSecret = Parameter{
			//	Name:   "Parameter",
			ValueFrom: ValueFrom{
				Source: "secret_source",
			},
			//	Source: "source",
			//	Destination: "",
			//	Generate: "",
			Type: "Secret",
		}

		parameters = &Parameters{
			paramEnvVar,
			paramEnvVarFrom,
			paramEnvVarFromSecret,
			paramEnvFrom,
			paramEnvFromSecret,
		}

	})

	Describe("Generating EnvVar", func() {
		Context("With key value", func() {
			It("should generate env var", func() {

				expectedObj := corev1.EnvVar{
					Name:  "MY_PARAMETER",
					Value: "Parameter",
				}

				res, err := paramEnvVar.GetEnvVar()

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

		Context("With from key", func() {
			It("should generate env var from", func() {

				expectedObj := corev1.EnvVar{
					Name: "MY_PARAMETER",
					ValueFrom: &corev1.EnvVarSource{
						ConfigMapKeyRef: &corev1.ConfigMapKeySelector{
							LocalObjectReference: corev1.LocalObjectReference{
								Name: "source",
							},
							Key: "FROM_PARAMETER",
						},
					},
				}

				res, err := paramEnvVarFrom.GetEnvVar()

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

		Context("With from key", func() {
			It("should generate envFrom", func() {

				expectedObj := corev1.EnvFromSource{
					ConfigMapRef: &corev1.ConfigMapEnvSource{
						LocalObjectReference: corev1.LocalObjectReference{
							Name: "source",
						},
					},
				}

				res, err := paramEnvFrom.GetEnvFrom()

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

	Describe("Generating Env for containers with Paramters", func() {
		Context("Generating env", func() {
			It("should generate env", func() {

				expectedObj := []corev1.EnvVar{
					{
						Name:  "MY_PARAMETER",
						Value: "Parameter",
					},
					{
						Name: "MY_PARAMETER",
						ValueFrom: &corev1.EnvVarSource{
							ConfigMapKeyRef: &corev1.ConfigMapKeySelector{
								LocalObjectReference: corev1.LocalObjectReference{
									Name: "source",
								},
								Key: "FROM_PARAMETER",
							},
						},
					},
					{
						Name: "MY_SECRET_PARAMETER",
						ValueFrom: &corev1.EnvVarSource{
							SecretKeyRef: &corev1.SecretKeySelector{
								LocalObjectReference: corev1.LocalObjectReference{
									Name: "secret_source",
								},
								Key: "FROM_SECRET_PARAMETER",
							},
						},
					},
				}

				res := parameters.GetEnv()

				Expect(res).To(Equal(expectedObj))
				//	Expect(err).NotTo(HaveOccurred())
			})
			It("should generate envFrom", func() {

				expectedObj := []corev1.EnvFromSource{
					{
						ConfigMapRef: &corev1.ConfigMapEnvSource{
							LocalObjectReference: corev1.LocalObjectReference{
								Name: "source",
							},
						},
					},
					{
						SecretRef: &corev1.SecretEnvSource{
							LocalObjectReference: corev1.LocalObjectReference{
								Name: "secret_source",
							},
						},
					},
				}

				res := parameters.GetEnvFrom()

				Expect(res).To(Equal(expectedObj))
				//	Expect(err).NotTo(HaveOccurred())
			})
		})
		Context("Generating data", func() {
			It("should generate data", func() {

				expectedObj := map[string]string{
					"MY_PARAMETER": "Parameter",
				}

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

		})
	})
})