deep-stack/kompose
7
0
Fork 0
forked from LaconicNetwork/kompose
Code Pull Requests Activity
1ff8edfaf0
kompose/pkg/transformer/kubernetes/k8sutils_test.go
robertaistleitner 1b29e031e3
Fix ConfigMap name clash if env_file name is equal (#2001) 
* Fix ConfigMap name clash if env_file name is equal #2000

* Generate envFrom instead of single env entries from env_file entries #1999

* Fix failing test fixture outputs
2025-04-15 11:39:45 -04:00

4013 lines
107 KiB
Go
Raw Blame History

/*
Copyright 2017 The Kubernetes Authors All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package kubernetes
import (
"fmt"
"os"
"path/filepath"
"reflect"
"sort"
"testing"
"github.com/compose-spec/compose-go/v2/types"
"github.com/kubernetes/kompose/pkg/kobject"
"github.com/kubernetes/kompose/pkg/loader/compose"
"github.com/kubernetes/kompose/pkg/testutils"
"github.com/pkg/errors"
appsv1 "k8s.io/api/apps/v1"
hpa "k8s.io/api/autoscaling/v2beta2"
api "k8s.io/api/core/v1"
corev1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/api/resource"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime"
)
/*
Test the creation of a service
*/
func TestCreateService(t *testing.T) {
// An example service
service := kobject.ServiceConfig{
ContainerName: "name",
Image: "image",
Environment: []kobject.EnvVar{{Name: "env", Value: "value"}},
Port: []kobject.Ports{{HostPort: 123, ContainerPort: 456, Protocol: string(corev1.ProtocolTCP)}},
Command: []string{"cmd"},
WorkingDir: "dir",
Args: []string{"arg1", "arg2"},
VolList: []string{"/tmp/volume"},
Network: []string{"network1", "network2"}, // not supported
Labels: nil,
Annotations: map[string]string{"abc": "def"},
CPUQuota: 1, // not supported
CapAdd: []string{"cap_add"}, // not supported
CapDrop: []string{"cap_drop"}, // not supported
Expose: []string{"expose"}, // not supported
Privileged: true,
Restart: "always",
}
// An example object generated via k8s runtime.Objects()
komposeObject := kobject.KomposeObject{
ServiceConfigs: map[string]kobject.ServiceConfig{"app": service},
}
k := Kubernetes{}
_, err := k.Transform(komposeObject, kobject.ConvertOptions{CreateD: true, Replicas: 3})
if err != nil {
t.Error(errors.Wrap(err, "k.Transform failed"))
}
// Test the creation of the service
svc := k.CreateService("foo", service)
if svc.Spec.Ports[0].Port != 123 {
t.Errorf("Expected port 123 upon conversion, actual %d", svc.Spec.Ports[0].Port)
}
}
/*
Test the creation of a service with a memory limit and reservation
*/
func TestCreateServiceWithMemLimit(t *testing.T) {
// An example service
service := kobject.ServiceConfig{
ContainerName: "name",
Image: "image",
Environment: []kobject.EnvVar{{Name: "env", Value: "value"}},
Port: []kobject.Ports{{HostPort: 123, ContainerPort: 456, Protocol: string(corev1.ProtocolTCP)}},
Command: []string{"cmd"},
WorkingDir: "dir",
Args: []string{"arg1", "arg2"},
VolList: []string{"/tmp/volume"},
Network: []string{"network1", "network2"}, // not supported
Labels: nil,
Annotations: map[string]string{"abc": "def"},
CPUQuota: 1, // not supported
CapAdd: []string{"cap_add"}, // not supported
CapDrop: []string{"cap_drop"}, // not supported
Expose: []string{"expose"}, // not supported
Privileged: true,
Restart: "always",
MemLimit: 1337,
MemReservation: 1338,
}
// An example object generated via k8s runtime.Objects()
komposeObject := kobject.KomposeObject{
ServiceConfigs: map[string]kobject.ServiceConfig{"app": service},
}
k := Kubernetes{}
objects, err := k.Transform(komposeObject, kobject.ConvertOptions{CreateD: true, Replicas: 3})
if err != nil {
t.Error(errors.Wrap(err, "k.Transform failed"))
}
// Retrieve the deployment object and test that it matches the mem value
for _, obj := range objects {
if deploy, ok := obj.(*appsv1.Deployment); ok {
memLimit, _ := deploy.Spec.Template.Spec.Containers[0].Resources.Limits.Memory().AsInt64()
if memLimit != 1337 {
t.Errorf("Expected 1337 for memory limit check, got %v", memLimit)
}
memReservation, _ := deploy.Spec.Template.Spec.Containers[0].Resources.Requests.Memory().AsInt64()
if memReservation != 1338 {
t.Errorf("Expected 1338 for memory reservation check, got %v", memReservation)
}
}
}
}
/*
Test the creation of a service with a cpu limit and reservation
*/
func TestCreateServiceWithCPULimit(t *testing.T) {
// An example service
service := kobject.ServiceConfig{
ContainerName: "name",
Image: "image",
Environment: []kobject.EnvVar{{Name: "env", Value: "value"}},
Port: []kobject.Ports{{HostPort: 123, ContainerPort: 456, Protocol: string(corev1.ProtocolTCP)}},
Command: []string{"cmd"},
WorkingDir: "dir",
Args: []string{"arg1", "arg2"},
VolList: []string{"/tmp/volume"},
Network: []string{"network1", "network2"}, // not supported
Labels: nil,
Annotations: map[string]string{"abc": "def"},
CPUQuota: 1, // not supported
CapAdd: []string{"cap_add"}, // not supported
CapDrop: []string{"cap_drop"}, // not supported
Expose: []string{"expose"}, // not supported
Privileged: true,
Restart: "always",
CPULimit: 10,
CPUReservation: 1,
}
// An example object generated via k8s runtime.Objects()
komposeObject := kobject.KomposeObject{
ServiceConfigs: map[string]kobject.ServiceConfig{"app": service},
}
k := Kubernetes{}
objects, err := k.Transform(komposeObject, kobject.ConvertOptions{CreateD: true, Replicas: 3})
if err != nil {
t.Error(errors.Wrap(err, "k.Transform failed"))
}
// Retrieve the deployment object and test that it matches the cpu value
for _, obj := range objects {
if deploy, ok := obj.(*appsv1.Deployment); ok {
cpuLimit := deploy.Spec.Template.Spec.Containers[0].Resources.Limits.Cpu().MilliValue()
if cpuLimit != 10 {
t.Errorf("Expected 10 for cpu limit check, got %v", cpuLimit)
}
cpuReservation := deploy.Spec.Template.Spec.Containers[0].Resources.Requests.Cpu().MilliValue()
if cpuReservation != 1 {
t.Errorf("Expected 1 for cpu reservation check, got %v", cpuReservation)
}
}
}
}
/*
Test the creation of a service with ephemeral storage limit
*/
func TestDeployLabelsEphemeralStorageLimit(t *testing.T) {
// An example service
service := kobject.ServiceConfig{
ContainerName: "name",
Image: "image",
Environment: []kobject.EnvVar{{Name: "env", Value: "value"}},
Port: []kobject.Ports{{HostPort: 123, ContainerPort: 456, Protocol: string(corev1.ProtocolTCP)}},
Command: []string{"cmd"},
WorkingDir: "dir",
Args: []string{"arg1", "arg2"},
VolList: []string{"/tmp/volume"},
Network: []string{"network1", "network2"},
Labels: nil,
Annotations: map[string]string{"abc": "def"},
CPUQuota: 1,
CapAdd: []string{"cap_add"},
CapDrop: []string{"cap_drop"},
Expose: []string{"expose"},
Privileged: true,
Restart: "always",
DeployLabels: map[string]string{"kompose.ephemeral-storage.limit": "1Gi"},
}
// An example object generated via k8s runtime.Objects()
komposeObject := kobject.KomposeObject{
ServiceConfigs: map[string]kobject.ServiceConfig{"app": service},
}
k := Kubernetes{}
objects, err := k.Transform(komposeObject, kobject.ConvertOptions{CreateD: true, Replicas: 3})
if err != nil {
t.Error(errors.Wrap(err, "k.Transform failed"))
}
// Retrieve the deployment object and test that it matches the ephemeral storage limit value
for _, obj := range objects {
if deploy, ok := obj.(*appsv1.Deployment); ok {
storageLimit := deploy.Spec.Template.Spec.Containers[0].Resources.Limits.StorageEphemeral()
expectedLimit := resource.MustParse("1Gi")
if *storageLimit != expectedLimit {
t.Errorf("Expected %v for ephemeral storage limit check, got %v", expectedLimit, storageLimit)
}
}
}
}
/*
Test the creation of a service with ephemeral storage request
*/
func TestDeployLabelsEphemeralStorageRequest(t *testing.T) {
// An example service
service := kobject.ServiceConfig{
ContainerName: "name",
Image: "image",
Environment: []kobject.EnvVar{{Name: "env", Value: "value"}},
Port: []kobject.Ports{{HostPort: 123, ContainerPort: 456, Protocol: string(corev1.ProtocolTCP)}},
Command: []string{"cmd"},
WorkingDir: "dir",
Args: []string{"arg1", "arg2"},
VolList: []string{"/tmp/volume"},
Network: []string{"network1", "network2"},
Labels: nil,
Annotations: map[string]string{"abc": "def"},
CPUQuota: 1,
CapAdd: []string{"cap_add"},
CapDrop: []string{"cap_drop"},
Expose: []string{"expose"},
Privileged: true,
Restart: "always",
DeployLabels: map[string]string{"kompose.ephemeral-storage.request": "1Gi"},
}
// An example object generated via k8s runtime.Objects()
komposeObject := kobject.KomposeObject{
ServiceConfigs: map[string]kobject.ServiceConfig{"app": service},
}
k := Kubernetes{}
objects, err := k.Transform(komposeObject, kobject.ConvertOptions{CreateD: true, Replicas: 3})
if err != nil {
t.Error(errors.Wrap(err, "k.Transform failed"))
}
// Retrieve the deployment object and test that it matches the ephemeral storage request value
for _, obj := range objects {
if deploy, ok := obj.(*appsv1.Deployment); ok {
storageRequest := deploy.Spec.Template.Spec.Containers[0].Resources.Requests.StorageEphemeral()
expectedRequest := resource.MustParse("1Gi")
if *storageRequest != expectedRequest {
t.Errorf("Expected %v for ephemeral storage request check, got %v", expectedRequest, storageRequest)
}
}
}
}
/*
Test the creation of a service with a specified user.
The expected result is that Kompose will set user in PodSpec
*/
func TestCreateServiceWithServiceUser(t *testing.T) {
// An example service
service := kobject.ServiceConfig{
ContainerName: "name",
Image: "image",
Environment: []kobject.EnvVar{{Name: "env", Value: "value"}},
Port: []kobject.Ports{{HostPort: 123, ContainerPort: 456, Protocol: string(corev1.ProtocolTCP)}},
Command: []string{"cmd"},
WorkingDir: "dir",
Args: []string{"arg1", "arg2"},
VolList: []string{"/tmp/volume"},
Network: []string{"network1", "network2"}, // not supported
Labels: nil,
Annotations: map[string]string{"kompose.service.type": "nodeport"},
CPUQuota: 1, // not supported
CapAdd: []string{"cap_add"}, // not supported
CapDrop: []string{"cap_drop"}, // not supported
Expose: []string{"expose"}, // not supported
Privileged: true,
Restart: "always",
User: "1234:5678",
}
komposeObject := kobject.KomposeObject{
ServiceConfigs: map[string]kobject.ServiceConfig{"app": service},
}
k := Kubernetes{}
objects, err := k.Transform(komposeObject, kobject.ConvertOptions{CreateD: true, Replicas: 1})
if err != nil {
t.Error(errors.Wrap(err, "k.Transform failed"))
}
for _, obj := range objects {
if deploy, ok := obj.(*appsv1.Deployment); ok {
uid := *deploy.Spec.Template.Spec.Containers[0].SecurityContext.RunAsUser
gid := *deploy.Spec.Template.Spec.Containers[0].SecurityContext.RunAsGroup
if fmt.Sprintf("%d:%d", uid, gid) != service.User {
t.Errorf("User and group in ServiceConfig is not matching user in PodSpec")
}
}
}
}
func TestCreateServiceWithConfigLongSyntax(t *testing.T) {
content := "setting: true"
target := "/etc/config.yaml"
// An example service
service := kobject.ServiceConfig{
ContainerName: "name",
Image: "image",
Environment: []kobject.EnvVar{{Name: "env", Value: "value"}},
Port: []kobject.Ports{{HostPort: 123, ContainerPort: 456, Protocol: string(corev1.ProtocolTCP)}},
Command: []string{"cmd"},
Configs: []types.ServiceConfigObjConfig{{Source: "configmap", Target: target}},
ConfigsMetaData: map[string]types.ConfigObjConfig{"configmap": {Content: content}},
}
komposeObject := kobject.KomposeObject{
ServiceConfigs: map[string]kobject.ServiceConfig{
"app": service,
},
}
k := Kubernetes{}
objects, err := k.Transform(komposeObject, kobject.ConvertOptions{CreateD: true, Replicas: 1})
if err != nil {
t.Error(errors.Wrap(err, "k.Transform failed"))
}
for _, obj := range objects {
t.Log(obj)
if configMap, ok := obj.(*api.ConfigMap); ok {
fileContent := configMap.Data["config.yaml"]
if fileContent != content {
t.Errorf("Config map content not equal")
}
}
if deployment, ok := obj.(*appsv1.Deployment); ok {
spec := deployment.Spec.Template.Spec
if spec.Containers[0].VolumeMounts[0].MountPath != target {
t.Errorf("Config map mountPath not found")
}
}
}
}
func TestCreateServiceWithConfigShortSyntax(t *testing.T) {
content := "setting: true"
source := "configmap"
target := "/" + source
// An example service
service := kobject.ServiceConfig{
ContainerName: "name",
Image: "image",
Environment: []kobject.EnvVar{{Name: "env", Value: "value"}},
Port: []kobject.Ports{{HostPort: 123, ContainerPort: 456, Protocol: string(corev1.ProtocolTCP)}},
Command: []string{"cmd"},
Configs: []types.ServiceConfigObjConfig{{Source: source}},
ConfigsMetaData: map[string]types.ConfigObjConfig{source: {Content: content}},
}
komposeObject := kobject.KomposeObject{
ServiceConfigs: map[string]kobject.ServiceConfig{
"app": service,
},
}
k := Kubernetes{}
objects, err := k.Transform(komposeObject, kobject.ConvertOptions{CreateD: true, Replicas: 1})
if err != nil {
t.Error(errors.Wrap(err, "k.Transform failed"))
}
for _, obj := range objects {
t.Log(obj)
if configMap, ok := obj.(*api.ConfigMap); ok {
fileContent := configMap.Data[source]
if fileContent != content {
t.Errorf("Config map content not equal")
}
}
if deployment, ok := obj.(*appsv1.Deployment); ok {
spec := deployment.Spec.Template.Spec
if spec.Containers[0].VolumeMounts[0].MountPath != target {
t.Errorf("Config map mountPath not found")
}
}
}
}
func TestTransformWithPid(t *testing.T) {
// An example service
service := kobject.ServiceConfig{
ContainerName: "name",
Image: "image",
Environment: []kobject.EnvVar{{Name: "env", Value: "value"}},
Port: []kobject.Ports{{HostPort: 123, ContainerPort: 456, Protocol: string(corev1.ProtocolTCP)}},
Command: []string{"cmd"},
WorkingDir: "dir",
Args: []string{"arg1", "arg2"},
VolList: []string{"/tmp/volume"},
Network: []string{"network1", "network2"},
Restart: "always",
Pid: "host",
}
// An example object generated via k8s runtime.Objects()
komposeObject := kobject.KomposeObject{
ServiceConfigs: map[string]kobject.ServiceConfig{"app": service},
}
k := Kubernetes{}
_, err := k.Transform(komposeObject, kobject.ConvertOptions{CreateD: true, Replicas: 3})
if err != nil {
t.Error(errors.Wrap(err, "k.Transform failed"))
}
//for _, obj := range objects {
// if deploy, ok := obj.(*appsv1.Deployment); ok {
// hostPid := deploy.Spec.Template.Spec.SecurityContext.HostPID
// if !hostPid {
// t.Errorf("Pid in ServiceConfig is not matching HostPID in PodSpec")
// }
// }
//}
}
func TestTransformWithInvalidPid(t *testing.T) {
// An example service
service := kobject.ServiceConfig{
ContainerName: "name",
Image: "image",
Environment: []kobject.EnvVar{{Name: "env", Value: "value"}},
Port: []kobject.Ports{{HostPort: 123, ContainerPort: 456, Protocol: string(corev1.ProtocolTCP)}},
Command: []string{"cmd"},
WorkingDir: "dir",
Args: []string{"arg1", "arg2"},
VolList: []string{"/tmp/volume"},
Network: []string{"network1", "network2"},
Restart: "always",
Pid: "badvalue",
}
// An example object generated via k8s runtime.Objects()
komposeObject := kobject.KomposeObject{
ServiceConfigs: map[string]kobject.ServiceConfig{"app": service},
}
k := Kubernetes{}
_, err := k.Transform(komposeObject, kobject.ConvertOptions{CreateD: true, Replicas: 3})
if err != nil {
t.Error(errors.Wrap(err, "k.Transform failed"))
}
//for _, obj := range objects {
// if deploy, ok := obj.(*appsv1.Deployment); ok {
// if deploy.Spec.Template.Spec.SecurityContext != nil {
// hostPid := deploy.Spec.Template.Spec.SecurityContext.HostPID
// if hostPid {
// t.Errorf("Pid in ServiceConfig is not matching HostPID in PodSpec")
// }
// }
// }
//}
}
func TestIsDir(t *testing.T) {
tempPath := "/tmp/kompose_unit"
tempDir := filepath.Join(tempPath, "i_am_dir")
tempFile := filepath.Join(tempPath, "i_am_file")
tempAbsentDirPath := filepath.Join(tempPath, "i_do_not_exist")
// create directory
err := os.MkdirAll(tempDir, 0744)
if err != nil {
t.Errorf("Unable to create directory: %v", err)
}
// create empty file
f, err := os.Create(tempFile)
if err != nil {
t.Errorf("Unable to create empty file: %v", err)
}
f.Close()
// Check output if directory exists
output, err := isDir(tempDir)
if err != nil {
t.Error(errors.Wrap(err, "isDir failed"))
}
if !output {
t.Errorf("directory %v exists but isDir() returned %v", tempDir, output)
}
// Check output if file is provided
output, err = isDir(tempFile)
if err != nil {
t.Error(errors.Wrap(err, "isDir failed"))
}
if output {
t.Errorf("%v is a file but isDir() returned %v", tempDir, output)
}
// Check output if path does not exist
output, err = isDir(tempAbsentDirPath)
if err != nil {
t.Error(errors.Wrap(err, "isDir failed"))
}
if output {
t.Errorf("Directory %v does not exist, but isDir() returned %v", tempAbsentDirPath, output)
}
// delete temporary directory
err = os.RemoveAll(tempPath)
if err != nil {
t.Errorf("Error removing the temporary directory during cleanup: %v", err)
}
}
// TestServiceWithHealthCheck this tests if Headless Service is created for services with HealthCheck.
func TestServiceWithHealthCheck(t *testing.T) {
testCases := map[string]struct {
service kobject.ServiceConfig
}{
"Exec": {
service: kobject.ServiceConfig{
ContainerName: "name",
Image: "image",
ServiceType: "Headless",
HealthChecks: kobject.HealthChecks{
Readiness: kobject.HealthCheck{
Test: []string{"arg1", "arg2"},
Timeout: 10,
Interval: 5,
Retries: 3,
StartPeriod: 60,
},
Liveness: kobject.HealthCheck{
Test: []string{"arg1", "arg2"},
Timeout: 11,
Interval: 6,
Retries: 4,
StartPeriod: 61,
},
},
},
},
"HTTPGet": {
service: kobject.ServiceConfig{
ContainerName: "name",
Image: "image",
ServiceType: "Headless",
HealthChecks: kobject.HealthChecks{
Readiness: kobject.HealthCheck{
HTTPPath: "/health",
HTTPPort: 8080,
Timeout: 10,
Interval: 5,
Retries: 3,
StartPeriod: 60,
},
Liveness: kobject.HealthCheck{
HTTPPath: "/ready",
HTTPPort: 8080,
Timeout: 11,
Interval: 6,
Retries: 4,
StartPeriod: 61,
},
},
},
},
"TCPSocket": {
service: kobject.ServiceConfig{
ContainerName: "name",
Image: "image",
ServiceType: "Headless",
HealthChecks: kobject.HealthChecks{
Readiness: kobject.HealthCheck{
TCPPort: 8080,
Timeout: 10,
Interval: 5,
Retries: 3,
StartPeriod: 60,
},
Liveness: kobject.HealthCheck{
TCPPort: 8080,
Timeout: 11,
Interval: 6,
Retries: 4,
StartPeriod: 61,
},
},
},
},
}
for _, testCase := range testCases {
k := Kubernetes{}
komposeObject := kobject.KomposeObject{
ServiceConfigs: map[string]kobject.ServiceConfig{"app": testCase.service},
}
objects, err := k.Transform(komposeObject, kobject.ConvertOptions{CreateD: true, Replicas: 1})
if err != nil {
t.Error(errors.Wrap(err, "k.Transform failed"))
}
if err := testutils.CheckForHealthCheckLivenessAndReadiness(objects); err != nil {
t.Error(err)
}
}
}
// TestServiceWithoutPort this tests if Headless Service is created for services without Port.
func TestServiceWithoutPort(t *testing.T) {
service := kobject.ServiceConfig{
ContainerName: "name",
Image: "image",
ServiceType: "Headless",
}
komposeObject := kobject.KomposeObject{
ServiceConfigs: map[string]kobject.ServiceConfig{"app": service},
}
k := Kubernetes{}
objects, err := k.Transform(komposeObject, kobject.ConvertOptions{CreateD: true, Replicas: 1})
if err != nil {
t.Error(errors.Wrap(err, "k.Transform failed"))
}
if err := testutils.CheckForHeadless(objects); err != nil {
t.Error(err)
}
}
// Tests if deployment strategy is being set to Recreate when volumes are
// present
func TestRecreateStrategyWithVolumesPresent(t *testing.T) {
service := kobject.ServiceConfig{
ContainerName: "name",
Image: "image",
VolList: []string{"/tmp/volume"},
Volumes: []kobject.Volumes{{SvcName: "app", MountPath: "/tmp/volume", PVCName: "app-claim0"}},
}
komposeObject := kobject.KomposeObject{
ServiceConfigs: map[string]kobject.ServiceConfig{"app": service},
}
k := Kubernetes{}
objects, err := k.Transform(komposeObject, kobject.ConvertOptions{CreateD: true, Replicas: 1})
if err != nil {
t.Error(errors.Wrap(err, "k.Transform failed"))
}
for _, obj := range objects {
if deployment, ok := obj.(*appsv1.Deployment); ok {
if deployment.Spec.Strategy.Type != appsv1.RecreateDeploymentStrategyType {
t.Errorf("Expected %v as Strategy Type, got %v",
appsv1.RecreateDeploymentStrategyType,
deployment.Spec.Strategy.Type)
}
}
}
}
func TestSortedKeys(t *testing.T) {
service := kobject.ServiceConfig{
ContainerName: "name",
Image: "image",
}
service1 := kobject.ServiceConfig{
ContainerName: "name",
Image: "image",
}
c := []string{"a", "b"}
komposeObject := kobject.KomposeObject{
ServiceConfigs: map[string]kobject.ServiceConfig{"b": service, "a": service1},
}
a := SortedKeys(komposeObject.ServiceConfigs)
if !reflect.DeepEqual(a, c) {
t.Logf("Test Fail output should be %s", c)
}
}
// test conversion from duration string to seconds *int64
func TestDurationStrToSecondsInt(t *testing.T) {
testCases := map[string]struct {
in string
out *int64
}{
"5s": {in: "5s", out: &[]int64{5}[0]},
"1m30s": {in: "1m30s", out: &[]int64{90}[0]},
"empty": {in: "", out: nil},
"onlynumber": {in: "2", out: nil},
"illegal": {in: "abc", out: nil},
}
for name, test := range testCases {
result, _ := DurationStrToSecondsInt(test.in)
if test.out == nil && result != nil {
t.Errorf("Case '%v' for TestDurationStrToSecondsInt fail, Expected 'nil' , got '%v'", name, *result)
}
if test.out != nil && result == nil {
t.Errorf("Case '%v' for TestDurationStrToSecondsInt fail, Expected '%v' , got 'nil'", name, *test.out)
}
if test.out != nil && result != nil && *test.out != *result {
t.Errorf("Case '%v' for TestDurationStrToSecondsInt fail, Expected '%v' , got '%v'", name, *test.out, *result)
}
}
}
func TestServiceWithServiceAccount(t *testing.T) {
assertServiceAccountName := "my-service"
service := kobject.ServiceConfig{
ContainerName: "name",
Image: "image",
Port: []kobject.Ports{{HostPort: 55555}},
Labels: map[string]string{compose.LabelServiceAccountName: assertServiceAccountName},
}
komposeObject := kobject.KomposeObject{
ServiceConfigs: map[string]kobject.ServiceConfig{"app": service},
}
k := Kubernetes{}
objects, err := k.Transform(komposeObject, kobject.ConvertOptions{CreateD: true})
if err != nil {
t.Error(errors.Wrap(err, "k.Transform failed"))
}
for _, obj := range objects {
if deployment, ok := obj.(*appsv1.Deployment); ok {
if deployment.Spec.Template.Spec.ServiceAccountName != assertServiceAccountName {
t.Errorf("Expected %v returned, got %v", assertServiceAccountName, deployment.Spec.Template.Spec.ServiceAccountName)
}
}
}
}
func TestCreateServiceWithSpecialName(t *testing.T) {
service := kobject.ServiceConfig{
ContainerName: "front_end",
Image: "nginx",
}
// An example object generated via k8s runtime.Objects()
komposeObject := kobject.KomposeObject{
ServiceConfigs: map[string]kobject.ServiceConfig{"app": service},
}
k := Kubernetes{}
objects, err := k.Transform(komposeObject, kobject.ConvertOptions{CreateD: true, Replicas: 3})
if err != nil {
t.Error(errors.Wrap(err, "k.Transform failed"))
}
expectedContainerName := "front-end"
for _, obj := range objects {
if deploy, ok := obj.(*appsv1.Deployment); ok {
containerName := deploy.Spec.Template.Spec.Containers[0].Name
if containerName != "front-end" {
t.Errorf("Error while transforming container name. Expected %s Got %s", expectedContainerName, containerName)
}
}
}
}
func TestArgsInterpolation(t *testing.T) {
// An example service
service := kobject.ServiceConfig{
ContainerName: "name",
Image: "image",
Environment: []kobject.EnvVar{{Name: "PROTOCOL", Value: "https"}, {Name: "DOMAIN", Value: "google.com"}},
Port: []kobject.Ports{{HostPort: 123, ContainerPort: 456, Protocol: string(corev1.ProtocolTCP)}},
Command: []string{"curl"},
Args: []string{"$PROTOCOL://$DOMAIN/"},
}
// An example object generated via k8s runtime.Objects()
komposeObject := kobject.KomposeObject{
ServiceConfigs: map[string]kobject.ServiceConfig{"app": service},
}
k := Kubernetes{}
objects, err := k.Transform(komposeObject, kobject.ConvertOptions{CreateD: true, Replicas: 3})
if err != nil {
t.Error(errors.Wrap(err, "k.Transform failed"))
}
expectedArgs := []string{"$(PROTOCOL)://$(DOMAIN)/"}
for _, obj := range objects {
if deployment, ok := obj.(*appsv1.Deployment); ok {
args := deployment.Spec.Template.Spec.Containers[0].Args[0]
if args != expectedArgs[0] {
t.Errorf("Expected args %v upon conversion, actual %v", expectedArgs, args)
}
}
}
}
func TestReadOnlyRootFS(t *testing.T) {
// An example service
service := kobject.ServiceConfig{
ContainerName: "name",
Image: "image",
ReadOnly: true,
}
// An example object generated via k8s runtime.Objects()
komposeObject := kobject.KomposeObject{
ServiceConfigs: map[string]kobject.ServiceConfig{"app": service},
}
k := Kubernetes{}
objects, err := k.Transform(komposeObject, kobject.ConvertOptions{CreateD: true})
if err != nil {
t.Error(errors.Wrap(err, "k.Transform failed"))
}
for _, obj := range objects {
if deployment, ok := obj.(*appsv1.Deployment); ok {
readOnlyFS := deployment.Spec.Template.Spec.Containers[0].SecurityContext.ReadOnlyRootFilesystem
if *readOnlyFS != true {
t.Errorf("Expected ReadOnlyRootFileSystem %v upon conversion, actual %v", true, readOnlyFS)
}
}
}
}
func TestFormatEnvName(t *testing.T) {
type args struct {
name string
serviceName string
}
tests := []struct {
name string
args args
want string
}{
{
name: "check dot conversion",
args: args{
name: "random.test",
},
want: "random-test",
},
{
name: "check that path is shortened",
args: args{
name: "random/test/v1",
},
want: "random-test-v1",
},
{
name: "check that ./ is removed",
args: args{
name: "./random",
},
want: "random",
},
{
name: "check that everything after $ is removed",
args: args{
name: "abcdefghijklnmopqrstuvxyzabcdefghijklmnopqrstuvwxyzabcdejghijkl$Hereisadditional",
},
want: "abcdefghijklnmopqrstuvxyzabcdefghijklmnopqrstuvwxyzabcdejghijkl",
},
{
name: "check that not begins with -",
args: args{
name: "src/app/.env",
serviceName: "app",
},
want: "src-app--env",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := FormatEnvName(tt.args.name, tt.args.serviceName); got != tt.want {
t.Errorf("FormatEnvName() = %v, want %v", got, tt.want)
}
})
}
}
// Test empty interfaces removal
func TestRemoveEmptyInterfaces(t *testing.T) {
type Obj = map[string]interface{}
var testCases = []struct {
input interface{}
output interface{}
}{
{Obj{"useless": Obj{}}, Obj{}},
{Obj{"usefull": Obj{"usefull": "usefull"}}, Obj{"usefull": Obj{"usefull": "usefull"}}},
{Obj{"usefull": Obj{"usefull": "usefull", "uselessdeep": Obj{}, "uselessnil": nil}}, Obj{"usefull": Obj{"usefull": "usefull"}}},
{Obj{"uselessdeep": Obj{"uselessdeep": Obj{}, "uselessnil": nil}}, Obj{}},
{Obj{"uselessempty": []interface{}{nil}}, Obj{}},
{"test", "test"},
}
for _, tc := range testCases {
t.Run(fmt.Sprintf("Test removeEmptyInterfaces(%s)", tc.input), func(t *testing.T) {
result := removeEmptyInterfaces(tc.input)
if !reflect.DeepEqual(result, tc.output) {
t.Errorf("Expected %v, got %v", tc.output, result)
}
})
}
}
func Test_parseContainerCommandsFromStr(t *testing.T) {
tests := []struct {
name string
line string
want []string
}{
{
name: "line command without spaces in between",
line: `[ "bundle", "exec", "thin", "-p", "3000" ]`,
want: []string{
"bundle", "exec", "thin", "-p", "3000",
},
},
{
name: `line command spaces inside ""`,
line: `[ " bundle ", " exec ", " thin ", " -p ", "3000" ]`,
want: []string{
"bundle", "exec", "thin", "-p", "3000",
},
},
{
name: `more use cases for line command spaces inside ""`,
line: `[ " bundle ", "exec ", " thin ", " -p ", "3000 " ]`,
want: []string{
"bundle", "exec", "thin", "-p", "3000",
},
},
{
name: `line command without [] and ""`,
line: `bundle exec thin -p 3000`,
want: []string{
"bundle exec thin -p 3000",
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := parseContainerCommandsFromStr(tt.line); !reflect.DeepEqual(got, tt.want) {
t.Errorf("parseContainerCommandsFromStr() = %v, want %v", got, tt.want)
}
})
}
}
func Test_fillInitContainers(t *testing.T) {
type args struct {
template *api.PodTemplateSpec
service kobject.ServiceConfig
}
tests := []struct {
name string
args args
want []corev1.Container
}{
{
name: "Testing init container are generated from labels with ,",
args: args{
template: &api.PodTemplateSpec{},
service: kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelInitContainerName: "name",
compose.LabelInitContainerImage: "image",
compose.LabelInitContainerCommand: `[ "bundle", "exec", "thin", "-p", "3000" ]`,
},
},
},
want: []corev1.Container{
{
Name: "name",
Image: "image",
Command: []string{
"bundle", "exec", "thin", "-p", "3000",
},
},
},
},
{
name: "Testing init container are generated from labels without ,",
args: args{
template: &api.PodTemplateSpec{},
service: kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelInitContainerName: "name",
compose.LabelInitContainerImage: "image",
compose.LabelInitContainerCommand: `bundle exec thin -p 3000`,
},
},
},
want: []corev1.Container{
{
Name: "name",
Image: "image",
Command: []string{
`bundle exec thin -p 3000`,
},
},
},
},
{
name: `Testing init container with long command with vars inside and ''`,
args: args{
template: &api.PodTemplateSpec{},
service: kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelInitContainerName: "init-myservice",
compose.LabelInitContainerImage: "busybox:1.28",
compose.LabelInitContainerCommand: `['sh', '-c', "until nslookup myservice.$(cat /var/run/secrets/kubernetes.io/serviceaccount/namespace).svc.cluster.local; do echo waiting for myservice; sleep 2; done"]`,
},
},
},
want: []corev1.Container{
{
Name: "init-myservice",
Image: "busybox:1.28",
Command: []string{
"sh", "-c", `until nslookup myservice.$(cat /var/run/secrets/kubernetes.io/serviceaccount/namespace).svc.cluster.local; do echo waiting for myservice; sleep 2; done`,
},
},
},
},
{
name: `without image`,
args: args{
template: &api.PodTemplateSpec{},
service: kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelInitContainerName: "init-myservice",
compose.LabelInitContainerImage: "",
compose.LabelInitContainerCommand: `['sh', '-c', "until nslookup myservice.$(cat /var/run/secrets/kubernetes.io/serviceaccount/namespace).svc.cluster.local; do echo waiting for myservice; sleep 2; done"]`,
},
},
},
want: nil,
},
{
name: `Testing init container without name`,
args: args{
template: &api.PodTemplateSpec{},
service: kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelInitContainerName: "",
compose.LabelInitContainerImage: "busybox:1.28",
compose.LabelInitContainerCommand: `['sh', '-c', "until nslookup myservice.$(cat /var/run/secrets/kubernetes.io/serviceaccount/namespace).svc.cluster.local; do echo waiting for myservice; sleep 2; done"]`,
},
},
},
want: []corev1.Container{
{
Name: "init-service",
Image: "busybox:1.28",
Command: []string{
"sh", "-c", `until nslookup myservice.$(cat /var/run/secrets/kubernetes.io/serviceaccount/namespace).svc.cluster.local; do echo waiting for myservice; sleep 2; done`,
},
},
},
},
{
name: `Testing init container without command`,
args: args{
template: &api.PodTemplateSpec{},
service: kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelInitContainerName: "init-service",
compose.LabelInitContainerImage: "busybox:1.28",
compose.LabelInitContainerCommand: ``,
},
},
},
want: []corev1.Container{
{
Name: "init-service",
Image: "busybox:1.28",
Command: []string{},
},
},
},
{
name: `Testing init container without command`,
args: args{
template: &api.PodTemplateSpec{},
service: kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelInitContainerName: "init-service",
compose.LabelInitContainerImage: "busybox:1.28",
},
},
},
want: []corev1.Container{
{
Name: "init-service",
Image: "busybox:1.28",
Command: []string{},
},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
fillInitContainers(tt.args.template, tt.args.service)
if !reflect.DeepEqual(tt.args.template.Spec.InitContainers, tt.want) {
t.Errorf("Test_fillInitContainers Fail got %v, want %v", tt.args.template.Spec.InitContainers, tt.want)
}
})
}
}
func Test_getHpaValue(t *testing.T) {
type args struct {
service *kobject.ServiceConfig
label string
defaultValue int32
}
tests := []struct {
name string
args args
want int32
}{
// LabelHpaMinReplicas
{
name: "LabelHpaMinReplicas with 1 value",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMinReplicas: "1",
compose.LabelHpaMaxReplicas: "10",
compose.LabelHpaCPU: "50",
compose.LabelHpaMemory: "70",
},
},
label: compose.LabelHpaMinReplicas,
defaultValue: 1,
},
want: 1,
},
{
name: "LabelHpaMinReplicas with 0 value",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMinReplicas: "0",
compose.LabelHpaMaxReplicas: "10",
compose.LabelHpaCPU: "50",
compose.LabelHpaMemory: "70",
},
},
label: compose.LabelHpaMinReplicas,
defaultValue: 1,
},
want: 0,
},
{
name: "LabelHpaMinReplicas with error value",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMinReplicas: "cannot transform",
compose.LabelHpaMaxReplicas: "10",
compose.LabelHpaCPU: "50",
compose.LabelHpaMemory: "70",
},
},
label: compose.LabelHpaMinReplicas,
defaultValue: 1,
},
want: 1,
},
// LabelHpaMaxReplicas
{
name: "LabelHpaMaxReplicas with 10 value",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMinReplicas: "1",
compose.LabelHpaMaxReplicas: "10",
compose.LabelHpaCPU: "50",
compose.LabelHpaMemory: "70",
},
},
label: compose.LabelHpaMaxReplicas,
defaultValue: 30,
},
want: 10,
},
{
name: "LabelHpaMaxReplicas with 0 value",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMinReplicas: "1",
compose.LabelHpaMaxReplicas: "0",
compose.LabelHpaCPU: "50",
compose.LabelHpaMemory: "70",
},
},
label: compose.LabelHpaMaxReplicas,
defaultValue: DefaultMaxReplicas,
},
want: 0,
},
{
name: "LabelHpaMaxReplicas with error value",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMinReplicas: "1",
compose.LabelHpaMaxReplicas: "cannot transform",
compose.LabelHpaCPU: "50",
compose.LabelHpaMemory: "70",
},
},
label: compose.LabelHpaMaxReplicas,
defaultValue: DefaultMaxReplicas,
},
want: DefaultMaxReplicas,
},
// LabelHpaCPU
{
name: "LabelHpaCPU with 50 value",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMinReplicas: "1",
compose.LabelHpaMaxReplicas: "10",
compose.LabelHpaCPU: "50",
compose.LabelHpaMemory: "70",
},
},
label: compose.LabelHpaCPU,
defaultValue: 30,
},
want: 50,
},
{
name: "LabelHpaCPU with 0 value",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMinReplicas: "1",
compose.LabelHpaMaxReplicas: "10",
compose.LabelHpaCPU: "0",
compose.LabelHpaMemory: "70",
},
},
label: compose.LabelHpaCPU,
defaultValue: DefaultCPUUtilization,
},
want: 0,
},
{
name: "LabelHpaCPU with error value",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMinReplicas: "1",
compose.LabelHpaMaxReplicas: "10",
compose.LabelHpaCPU: "cannot transform",
compose.LabelHpaMemory: "70",
},
},
label: compose.LabelHpaCPU,
defaultValue: DefaultCPUUtilization,
},
want: DefaultCPUUtilization,
},
// LabelHpaMemory
{
name: "LabelHpaMemory with 70 value",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMinReplicas: "1",
compose.LabelHpaMaxReplicas: "10",
compose.LabelHpaCPU: "50",
compose.LabelHpaMemory: "70",
},
},
label: compose.LabelHpaMemory,
defaultValue: 30,
},
want: 70,
},
{
name: "LabelHpaMemory with 0 value",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMinReplicas: "1",
compose.LabelHpaMaxReplicas: "10",
compose.LabelHpaCPU: "50",
compose.LabelHpaMemory: "0",
},
},
label: compose.LabelHpaMemory,
defaultValue: DefaultMemoryUtilization,
},
want: 0,
},
{
name: "LabelHpaMemory with error value",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMinReplicas: "1",
compose.LabelHpaMaxReplicas: "10",
compose.LabelHpaCPU: "50",
compose.LabelHpaMemory: "cannot transform",
},
},
label: compose.LabelHpaMemory,
defaultValue: DefaultMemoryUtilization,
},
want: DefaultMemoryUtilization,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := getHpaValue(tt.args.service, tt.args.label, tt.args.defaultValue); got != tt.want {
t.Errorf("getHpaValue() = %v, want %v", got, tt.want)
}
})
}
}
func Test_getResourceHpaValues(t *testing.T) {
type args struct {
service *kobject.ServiceConfig
}
tests := []struct {
name string
args args
want HpaValues
}{
{
name: "check default values",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMinReplicas: "1",
compose.LabelHpaMaxReplicas: "3",
compose.LabelHpaCPU: "50",
compose.LabelHpaMemory: "70",
},
},
},
want: HpaValues{
MinReplicas: 1,
MaxReplicas: 3,
CPUtilization: 50,
MemoryUtilization: 70,
},
},
{
name: "check if max replicas are less than min replicas, and max replicas set to min replicas",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMinReplicas: "5",
compose.LabelHpaMaxReplicas: "3",
compose.LabelHpaCPU: "50",
compose.LabelHpaMemory: "70",
},
},
},
want: HpaValues{
MinReplicas: 5,
MaxReplicas: 5, // same as min replicas
CPUtilization: 50,
MemoryUtilization: 70,
},
},
{
name: "with error values and use default values from LabelHpaMinReplicas",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMinReplicas: "cannot transform",
compose.LabelHpaMaxReplicas: "3",
compose.LabelHpaCPU: "50",
compose.LabelHpaMemory: "70",
},
},
},
want: HpaValues{
MinReplicas: DefaultMinReplicas,
MaxReplicas: 3,
CPUtilization: 50,
MemoryUtilization: 70,
},
},
{
name: "LabelHpaMaxReplicas is minor to LabelHpaMinReplicas",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMinReplicas: "6",
compose.LabelHpaMaxReplicas: "5",
compose.LabelHpaCPU: "50",
compose.LabelHpaMemory: "70",
},
},
},
want: HpaValues{
MinReplicas: 6,
MaxReplicas: 6, // set min replicas number
CPUtilization: 50,
MemoryUtilization: 70,
},
},
{
name: "error label and LabelHpaMaxReplicas is minor to LabelHpaMinReplicas",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMinReplicas: "6",
compose.LabelHpaMaxReplicas: "5",
compose.LabelHpaCPU: "cannot transform",
compose.LabelHpaMemory: "70",
},
},
},
want: HpaValues{
MinReplicas: 6,
MaxReplicas: 6, // same as min replicas number
CPUtilization: DefaultCPUUtilization,
MemoryUtilization: 70,
},
},
{
name: "error label and LabelHpaMaxReplicas is minor to LabelHpaMinReplicas and cannot transform hpa mmemor utilization",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMinReplicas: "6",
compose.LabelHpaMaxReplicas: "5",
compose.LabelHpaCPU: "50",
compose.LabelHpaMemory: "cannot transform",
},
},
},
want: HpaValues{
MinReplicas: 6,
MaxReplicas: 6,
CPUtilization: 50,
MemoryUtilization: DefaultMemoryUtilization,
},
},
{
name: "all error label, set all default values",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMinReplicas: "cannot transform",
compose.LabelHpaMaxReplicas: "cannot transform",
compose.LabelHpaCPU: "cannot transform",
compose.LabelHpaMemory: "cannot transform",
},
},
},
want: HpaValues{
MinReplicas: DefaultMinReplicas,
MaxReplicas: DefaultMaxReplicas,
CPUtilization: DefaultCPUUtilization,
MemoryUtilization: DefaultMemoryUtilization,
},
},
{
name: "error label without some labels, missing labels set to default",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMinReplicas: "cannot transform",
compose.LabelHpaMaxReplicas: "cannot transform",
},
},
},
want: HpaValues{
MinReplicas: DefaultMinReplicas,
MaxReplicas: DefaultMaxReplicas,
CPUtilization: DefaultCPUUtilization,
MemoryUtilization: DefaultMemoryUtilization,
},
},
{
name: "without labels, should return default values",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{},
},
},
want: HpaValues{
MinReplicas: DefaultMinReplicas,
MaxReplicas: DefaultMaxReplicas,
CPUtilization: DefaultCPUUtilization,
MemoryUtilization: DefaultMemoryUtilization,
},
},
{
name: "only min replicas label is provided",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMinReplicas: "3",
},
},
},
want: HpaValues{
MinReplicas: 3,
MaxReplicas: DefaultMaxReplicas,
CPUtilization: DefaultCPUUtilization,
MemoryUtilization: DefaultMemoryUtilization,
},
},
{
name: "only max replicas label is provided",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMaxReplicas: "5",
},
},
},
want: HpaValues{
MinReplicas: DefaultMinReplicas,
MaxReplicas: 5,
CPUtilization: DefaultCPUUtilization,
MemoryUtilization: DefaultMemoryUtilization,
},
},
{
name: "check default values when all labels contain invalid values",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMinReplicas: "cannot transform",
compose.LabelHpaMaxReplicas: "cannot transform",
compose.LabelHpaCPU: "cannot transform",
compose.LabelHpaMemory: "cannot transform",
},
},
},
want: HpaValues{
MinReplicas: DefaultMinReplicas,
MaxReplicas: DefaultMaxReplicas,
CPUtilization: DefaultCPUUtilization,
MemoryUtilization: DefaultMemoryUtilization,
},
},
{
name: "only cpu utilization label is provided",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaCPU: "80",
},
},
},
want: HpaValues{
MinReplicas: DefaultMinReplicas,
MaxReplicas: DefaultMaxReplicas,
CPUtilization: 80,
MemoryUtilization: DefaultMemoryUtilization,
},
},
{
name: "only memory utilization label is provided",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMemory: "90",
},
},
},
want: HpaValues{
MinReplicas: DefaultMinReplicas,
MaxReplicas: DefaultMaxReplicas,
CPUtilization: DefaultCPUUtilization,
MemoryUtilization: 90,
},
},
{
name: "only cpu and memory utilization labels are provided",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaCPU: "80",
compose.LabelHpaMemory: "90",
},
},
},
want: HpaValues{
MinReplicas: DefaultMinReplicas,
MaxReplicas: DefaultMaxReplicas,
CPUtilization: 80,
MemoryUtilization: 90,
},
},
{
name: "check default values when labels are empty strings",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMinReplicas: "",
compose.LabelHpaMaxReplicas: "",
compose.LabelHpaCPU: "",
compose.LabelHpaMemory: "",
},
},
},
want: HpaValues{
MinReplicas: DefaultMinReplicas,
MaxReplicas: DefaultMaxReplicas,
CPUtilization: DefaultCPUUtilization,
MemoryUtilization: DefaultMemoryUtilization,
},
},
{
name: "check default values when labels contain invalid characters",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMinReplicas: "abc",
compose.LabelHpaMaxReplicas: "xyz",
compose.LabelHpaCPU: "-100",
compose.LabelHpaMemory: "invalid",
},
},
},
want: HpaValues{
MinReplicas: DefaultMinReplicas,
MaxReplicas: DefaultMaxReplicas,
CPUtilization: DefaultCPUUtilization,
MemoryUtilization: DefaultMemoryUtilization,
},
},
{
name: "check default values when labels are set to zero",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMinReplicas: "0",
compose.LabelHpaMaxReplicas: "0",
compose.LabelHpaCPU: "0",
compose.LabelHpaMemory: "0",
},
},
},
want: HpaValues{
MinReplicas: 0,
MaxReplicas: 0,
CPUtilization: 50,
MemoryUtilization: 70,
},
},
{
name: "check default values when all labels are negative",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMinReplicas: "-5",
compose.LabelHpaMaxReplicas: "-10",
compose.LabelHpaCPU: "-20",
compose.LabelHpaMemory: "-30",
},
},
},
want: HpaValues{
MinReplicas: DefaultMinReplicas,
MaxReplicas: DefaultMaxReplicas,
CPUtilization: DefaultCPUUtilization,
MemoryUtilization: DefaultMemoryUtilization,
},
},
{
name: "check default values when labels cpu and memory are over",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMinReplicas: "-2",
compose.LabelHpaMaxReplicas: "-2",
compose.LabelHpaCPU: "120",
compose.LabelHpaMemory: "120",
},
},
},
want: HpaValues{
MinReplicas: DefaultMinReplicas,
MaxReplicas: DefaultMaxReplicas,
CPUtilization: DefaultCPUUtilization,
MemoryUtilization: DefaultMemoryUtilization,
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := getResourceHpaValues(tt.args.service); !reflect.DeepEqual(got, tt.want) {
t.Errorf("getResourceHpaValues() = %v, want %v", got, tt.want)
}
})
}
}
func Test_validatePercentageMetric(t *testing.T) {
type args struct {
service *kobject.ServiceConfig
metricLabel string
defaultValue int32
}
tests := []struct {
name string
args args
want int32
}{
{
name: "0 cpu utilization",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaCPU: "0",
},
},
metricLabel: compose.LabelHpaCPU,
defaultValue: DefaultCPUUtilization,
},
want: 50,
},
{
name: "default cpu valid range",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaCPU: "120",
},
},
metricLabel: compose.LabelHpaCPU,
defaultValue: DefaultCPUUtilization,
},
want: DefaultCPUUtilization,
},
{
name: "cpu invalid range",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaCPU: "-120",
},
},
metricLabel: compose.LabelHpaCPU,
defaultValue: DefaultCPUUtilization,
},
want: DefaultCPUUtilization,
},
{
name: "cpu utilization set to 100",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaCPU: "100",
},
},
metricLabel: compose.LabelHpaCPU,
defaultValue: DefaultCPUUtilization,
},
want: 100,
},
{
name: "cpu utlization set to 101",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaCPU: "101",
},
},
metricLabel: compose.LabelHpaCPU,
defaultValue: DefaultCPUUtilization,
},
want: DefaultCPUUtilization,
},
{
name: "cannot convert value in cpu label",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaCPU: "not converted",
},
},
metricLabel: compose.LabelHpaCPU,
defaultValue: DefaultCPUUtilization,
},
want: DefaultCPUUtilization,
},
{
name: "0 memory utilization",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMemory: "0",
},
},
metricLabel: compose.LabelHpaMemory,
defaultValue: DefaultMemoryUtilization,
},
want: 70,
},
{
name: "memory over 100 utilization",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMemory: "120",
},
},
metricLabel: compose.LabelHpaMemory,
defaultValue: DefaultMemoryUtilization,
},
want: DefaultMemoryUtilization,
},
{
name: "-120 utilization memory wrong range",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMemory: "-120",
},
},
metricLabel: compose.LabelHpaMemory,
defaultValue: DefaultMemoryUtilization,
},
want: DefaultMemoryUtilization,
},
{
name: "memory 100 usage",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMemory: "100",
},
},
metricLabel: compose.LabelHpaMemory,
defaultValue: DefaultMemoryUtilization,
},
want: 100,
},
{
name: "101 memory utilization",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMemory: "101",
},
},
metricLabel: compose.LabelHpaMemory,
defaultValue: DefaultMemoryUtilization,
},
want: DefaultMemoryUtilization,
},
{
name: "cannot convert memory from label",
args: args{
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMemory: "not converted",
},
},
metricLabel: compose.LabelHpaMemory,
defaultValue: DefaultMemoryUtilization,
},
want: DefaultMemoryUtilization,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := validatePercentageMetric(tt.args.service, tt.args.metricLabel, tt.args.defaultValue); got != tt.want {
t.Errorf("validatePercentageMetric() = %v, want %v", got, tt.want)
}
})
}
}
func Test_getHpaMetricSpec(t *testing.T) {
valueCPUFixed := int32(50)
valueMemoryFixed := int32(70)
valueOver100 := int32(120)
valueUnderZero := int32(-120)
// valueZero := int32(0)
type args struct {
hpaValues HpaValues
}
tests := []struct {
name string
args args
want []hpa.MetricSpec
}{
{
name: "no values",
args: args{
hpaValues: HpaValues{}, // set all values to 0
},
want: nil,
},
{
name: "only cpu",
args: args{
hpaValues: HpaValues{
CPUtilization: valueCPUFixed,
},
},
want: []hpa.MetricSpec{
{
Type: hpa.ResourceMetricSourceType,
Resource: &hpa.ResourceMetricSource{
Name: "cpu",
Target: hpa.MetricTarget{
Type: hpa.UtilizationMetricType,
AverageUtilization: &valueCPUFixed,
},
},
},
},
},
{
name: "only memory",
args: args{
hpaValues: HpaValues{
MemoryUtilization: 70,
},
},
want: []hpa.MetricSpec{
{
Type: hpa.ResourceMetricSourceType,
Resource: &hpa.ResourceMetricSource{
Name: "memory",
Target: hpa.MetricTarget{
Type: hpa.UtilizationMetricType,
AverageUtilization: &valueMemoryFixed,
},
},
},
},
},
{
name: "cpu and memory",
args: args{
hpaValues: HpaValues{
CPUtilization: valueCPUFixed,
MemoryUtilization: valueMemoryFixed,
},
},
want: []hpa.MetricSpec{
{
Type: hpa.ResourceMetricSourceType,
Resource: &hpa.ResourceMetricSource{
Name: "cpu",
Target: hpa.MetricTarget{
Type: hpa.UtilizationMetricType,
AverageUtilization: &valueCPUFixed,
},
},
},
{
Type: hpa.ResourceMetricSourceType,
Resource: &hpa.ResourceMetricSource{
Name: "memory",
Target: hpa.MetricTarget{
Type: hpa.UtilizationMetricType,
AverageUtilization: &valueMemoryFixed,
},
},
},
},
},
{
name: "memory over 100",
args: args{
hpaValues: HpaValues{
MemoryUtilization: valueOver100,
},
},
want: []hpa.MetricSpec{
{
Type: hpa.ResourceMetricSourceType,
Resource: &hpa.ResourceMetricSource{
Name: "memory",
Target: hpa.MetricTarget{
Type: hpa.UtilizationMetricType,
AverageUtilization: &valueOver100,
},
},
},
},
},
{
name: "cpu and memory over 100",
args: args{
hpaValues: HpaValues{
CPUtilization: valueOver100,
MemoryUtilization: valueOver100,
},
},
want: []hpa.MetricSpec{
{
Type: hpa.ResourceMetricSourceType,
Resource: &hpa.ResourceMetricSource{
Name: "cpu",
Target: hpa.MetricTarget{
Type: hpa.UtilizationMetricType,
AverageUtilization: &valueOver100,
},
},
},
{
Type: hpa.ResourceMetricSourceType,
Resource: &hpa.ResourceMetricSource{
Name: "memory",
Target: hpa.MetricTarget{
Type: hpa.UtilizationMetricType,
AverageUtilization: &valueOver100,
},
},
},
},
},
{
name: "cpu and memory under 0",
args: args{
hpaValues: HpaValues{
CPUtilization: valueUnderZero,
MemoryUtilization: valueUnderZero,
},
},
want: nil,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := getHpaMetricSpec(tt.args.hpaValues); !reflect.DeepEqual(got, tt.want) {
t.Errorf("getHpaMetricSpec() = %v, want %v", got, tt.want)
}
})
}
}
func Test_createHPAResources(t *testing.T) {
valueCPUFixed := int32(50)
valueMemoryFixed := int32(70)
fixedMinReplicas := int32(1)
type args struct {
name string
service *kobject.ServiceConfig
}
tests := []struct {
name string
args args
want hpa.HorizontalPodAutoscaler
}{
{
name: "all labels",
args: args{
name: "web",
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMinReplicas: "1",
compose.LabelHpaMaxReplicas: "10",
compose.LabelHpaCPU: "50",
compose.LabelHpaMemory: "70",
},
},
},
want: hpa.HorizontalPodAutoscaler{
TypeMeta: metav1.TypeMeta{
Kind: "HorizontalPodAutoscaler",
APIVersion: "autoscaling/v2",
},
ObjectMeta: metav1.ObjectMeta{
Name: "web",
},
Spec: hpa.HorizontalPodAutoscalerSpec{
ScaleTargetRef: hpa.CrossVersionObjectReference{
Kind: "Deployment",
Name: "web",
APIVersion: "apps/v1",
},
MinReplicas: &fixedMinReplicas,
MaxReplicas: 10,
Metrics: []hpa.MetricSpec{
{
Type: hpa.ResourceMetricSourceType,
Resource: &hpa.ResourceMetricSource{
Name: "cpu",
Target: hpa.MetricTarget{
Type: hpa.UtilizationMetricType,
AverageUtilization: &valueCPUFixed,
},
},
},
{
Type: hpa.ResourceMetricSourceType,
Resource: &hpa.ResourceMetricSource{
Name: "memory",
Target: hpa.MetricTarget{
Type: hpa.UtilizationMetricType,
AverageUtilization: &valueMemoryFixed,
},
},
},
},
},
},
},
{
name: "minimum labels",
args: args{
name: "api",
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMinReplicas: "1",
compose.LabelHpaCPU: "50",
},
},
},
want: hpa.HorizontalPodAutoscaler{
TypeMeta: metav1.TypeMeta{
Kind: "HorizontalPodAutoscaler",
APIVersion: "autoscaling/v2",
},
ObjectMeta: metav1.ObjectMeta{
Name: "api",
},
Spec: hpa.HorizontalPodAutoscalerSpec{
ScaleTargetRef: hpa.CrossVersionObjectReference{
Kind: "Deployment",
Name: "api",
APIVersion: "apps/v1",
},
MinReplicas: &fixedMinReplicas,
MaxReplicas: DefaultMaxReplicas,
Metrics: []hpa.MetricSpec{
{
Type: hpa.ResourceMetricSourceType,
Resource: &hpa.ResourceMetricSource{
Name: "cpu",
Target: hpa.MetricTarget{
Type: hpa.UtilizationMetricType,
AverageUtilization: &valueCPUFixed,
},
},
},
{
Type: hpa.ResourceMetricSourceType,
Resource: &hpa.ResourceMetricSource{
Name: "memory",
Target: hpa.MetricTarget{
Type: hpa.UtilizationMetricType,
AverageUtilization: &valueMemoryFixed,
},
},
},
},
},
},
},
{
name: "missing CPU utilization label",
args: args{
name: "app",
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMinReplicas: "1",
compose.LabelHpaMaxReplicas: "5",
compose.LabelHpaMemory: "70",
},
},
},
want: hpa.HorizontalPodAutoscaler{
TypeMeta: metav1.TypeMeta{
Kind: "HorizontalPodAutoscaler",
APIVersion: "autoscaling/v2",
},
ObjectMeta: metav1.ObjectMeta{
Name: "app",
},
Spec: hpa.HorizontalPodAutoscalerSpec{
ScaleTargetRef: hpa.CrossVersionObjectReference{
Kind: "Deployment",
Name: "app",
APIVersion: "apps/v1",
},
MinReplicas: &fixedMinReplicas,
MaxReplicas: 5,
Metrics: []hpa.MetricSpec{
{
Type: hpa.ResourceMetricSourceType,
Resource: &hpa.ResourceMetricSource{
Name: "cpu",
Target: hpa.MetricTarget{
Type: hpa.UtilizationMetricType,
AverageUtilization: &valueCPUFixed,
},
},
},
{
Type: hpa.ResourceMetricSourceType,
Resource: &hpa.ResourceMetricSource{
Name: "memory",
Target: hpa.MetricTarget{
Type: hpa.UtilizationMetricType,
AverageUtilization: &valueMemoryFixed,
},
},
},
},
},
},
},
{
name: "missing memory utilization label",
args: args{
name: "db",
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMinReplicas: "1",
compose.LabelHpaMaxReplicas: "8",
compose.LabelHpaCPU: "50",
},
},
},
want: hpa.HorizontalPodAutoscaler{
TypeMeta: metav1.TypeMeta{
Kind: "HorizontalPodAutoscaler",
APIVersion: "autoscaling/v2",
},
ObjectMeta: metav1.ObjectMeta{
Name: "db",
},
Spec: hpa.HorizontalPodAutoscalerSpec{
ScaleTargetRef: hpa.CrossVersionObjectReference{
Kind: "Deployment",
Name: "db",
APIVersion: "apps/v1",
},
MinReplicas: &fixedMinReplicas,
MaxReplicas: 8,
Metrics: []hpa.MetricSpec{
{
Type: hpa.ResourceMetricSourceType,
Resource: &hpa.ResourceMetricSource{
Name: "cpu",
Target: hpa.MetricTarget{
Type: hpa.UtilizationMetricType,
AverageUtilization: &valueCPUFixed,
},
},
},
{
Type: hpa.ResourceMetricSourceType,
Resource: &hpa.ResourceMetricSource{
Name: "memory",
Target: hpa.MetricTarget{
Type: hpa.UtilizationMetricType,
AverageUtilization: &valueMemoryFixed,
},
},
},
},
},
},
},
{
name: "wrong labels",
args: args{
name: "db",
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMinReplicas: "not converted",
compose.LabelHpaMaxReplicas: "not converted",
},
},
},
want: hpa.HorizontalPodAutoscaler{
TypeMeta: metav1.TypeMeta{
Kind: "HorizontalPodAutoscaler",
APIVersion: "autoscaling/v2",
},
ObjectMeta: metav1.ObjectMeta{
Name: "db",
},
Spec: hpa.HorizontalPodAutoscalerSpec{
ScaleTargetRef: hpa.CrossVersionObjectReference{
Kind: "Deployment",
Name: "db",
APIVersion: "apps/v1",
},
MinReplicas: &fixedMinReplicas,
MaxReplicas: DefaultMaxReplicas,
Metrics: []hpa.MetricSpec{
{
Type: hpa.ResourceMetricSourceType,
Resource: &hpa.ResourceMetricSource{
Name: "cpu",
Target: hpa.MetricTarget{
Type: hpa.UtilizationMetricType,
AverageUtilization: &valueCPUFixed,
},
},
},
{
Type: hpa.ResourceMetricSourceType,
Resource: &hpa.ResourceMetricSource{
Name: "memory",
Target: hpa.MetricTarget{
Type: hpa.UtilizationMetricType,
AverageUtilization: &valueMemoryFixed,
},
},
},
},
},
},
},
{
name: "missing both CPU and memory utilization labels",
args: args{
name: "db",
service: &kobject.ServiceConfig{
Labels: map[string]string{
compose.LabelHpaMinReplicas: "1",
compose.LabelHpaMaxReplicas: "5",
},
},
},
want: hpa.HorizontalPodAutoscaler{
TypeMeta: metav1.TypeMeta{
Kind: "HorizontalPodAutoscaler",
APIVersion: "autoscaling/v2",
},
ObjectMeta: metav1.ObjectMeta{
Name: "db",
},
Spec: hpa.HorizontalPodAutoscalerSpec{
ScaleTargetRef: hpa.CrossVersionObjectReference{
Kind: "Deployment",
Name: "db",
APIVersion: "apps/v1",
},
MinReplicas: &fixedMinReplicas,
MaxReplicas: 5,
Metrics: []hpa.MetricSpec{
{
Type: hpa.ResourceMetricSourceType,
Resource: &hpa.ResourceMetricSource{
Name: "cpu",
Target: hpa.MetricTarget{
Type: hpa.UtilizationMetricType,
AverageUtilization: &valueCPUFixed,
},
},
},
{
Type: hpa.ResourceMetricSourceType,
Resource: &hpa.ResourceMetricSource{
Name: "memory",
Target: hpa.MetricTarget{
Type: hpa.UtilizationMetricType,
AverageUtilization: &valueMemoryFixed,
},
},
},
},
},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := createHPAResources(tt.args.name, tt.args.service); !reflect.DeepEqual(got, tt.want) {
t.Errorf("createHPAResources() = %v, want %v", got, tt.want)
}
})
}
}
func Test_setVolumeAccessMode(t *testing.T) {
type args struct {
mode string
volumeAccesMode []api.PersistentVolumeAccessMode
}
tests := []struct {
name string
args args
want []api.PersistentVolumeAccessMode
}{
{
name: "readonly",
args: args{
mode: "ro",
volumeAccesMode: []api.PersistentVolumeAccessMode{},
},
want: []api.PersistentVolumeAccessMode{api.ReadOnlyMany},
},
{
name: "not acceptable",
args: args{
mode: "wrong",
volumeAccesMode: []api.PersistentVolumeAccessMode{},
},
want: []api.PersistentVolumeAccessMode{api.ReadWriteOnce},
},
{
name: "readonly many",
args: args{
mode: "rox",
volumeAccesMode: []api.PersistentVolumeAccessMode{},
},
want: []api.PersistentVolumeAccessMode{api.ReadOnlyMany},
},
{
name: "readwrite many",
args: args{
mode: "rwx",
volumeAccesMode: []api.PersistentVolumeAccessMode{},
},
want: []api.PersistentVolumeAccessMode{api.ReadWriteMany},
},
{
name: "readwrite once in pod",
args: args{
mode: "rwop",
volumeAccesMode: []api.PersistentVolumeAccessMode{},
},
want: []api.PersistentVolumeAccessMode{api.ReadWriteOncePod},
},
{
name: "readwrite once",
args: args{
mode: "rwo",
volumeAccesMode: []api.PersistentVolumeAccessMode{},
},
want: []api.PersistentVolumeAccessMode{api.ReadWriteOnce},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := setVolumeAccessMode(tt.args.mode, tt.args.volumeAccesMode); !reflect.DeepEqual(got, tt.want) {
t.Errorf("setVolumeAccessMode() = %v, want %v", got, tt.want)
}
})
}
}
func Test_isConfigFile(t *testing.T) {
type args struct {
filePath string
}
tests := []struct {
name string
args args
wantUseConfigMap bool
wantReadonly bool
wantSkip bool
}{
{
name: "dir not empty",
args: args{
filePath: "../../../script/test/fixtures/configmap-file-configs/certs",
},
wantUseConfigMap: true,
wantReadonly: true,
wantSkip: false,
},
{
name: "sock",
args: args{
filePath: "./docker.sock",
},
wantUseConfigMap: false,
wantReadonly: false,
wantSkip: true,
},
{
name: "cannot resolve filepath",
args: args{
filePath: "./certs/cert1.pem",
},
wantUseConfigMap: false,
wantReadonly: false,
wantSkip: false,
},
{
name: "file cert",
args: args{
filePath: "../../../script/test/fixtures/configmap-file-configs/certs/cert1.pem",
},
wantUseConfigMap: true,
wantReadonly: true,
wantSkip: false,
},
{
name: "docker sock",
args: args{
filePath: "/var/run/docker.sock",
},
wantUseConfigMap: false,
wantReadonly: false,
wantSkip: true,
},
{
name: "file from 3 levels",
args: args{
filePath: "../../../script/test/fixtures/configmap-file-configs/certs-level1/certs-level2/certs-level3/cert2.pem",
},
wantUseConfigMap: true,
wantReadonly: true,
wantSkip: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
gotUseConfigMap, gotReadonly, gotSkip := isConfigFile(tt.args.filePath)
if gotUseConfigMap != tt.wantUseConfigMap {
t.Errorf("isConfigFile() gotUseConfigMap = %v, want %v", gotUseConfigMap, tt.wantUseConfigMap)
}
if gotReadonly != tt.wantReadonly {
t.Errorf("isConfigFile() gotReadonly = %v, want %v", gotReadonly, tt.wantReadonly)
}
if gotSkip != tt.wantSkip {
t.Errorf("isConfigFile() gotSkip = %v, want %v", gotSkip, tt.wantSkip)
}
})
}
}
func Test_checkIsEmptyDir(t *testing.T) {
type args struct {
filePath string
}
tests := []struct {
name string
args args
want bool
wantErr bool
}{
{
name: "dir not found",
args: args{
filePath: "../../../script/test/fixtures/configmap-file-configs/notfound",
},
want: false,
wantErr: true,
},
{
name: "dir not empty",
args: args{
filePath: "../../../script/test/fixtures/configmap-file-configs/certs",
},
want: false,
wantErr: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := checkIsEmptyDir(tt.args.filePath)
if (err != nil) != tt.wantErr {
t.Errorf("checkIsEmptyDir() error = %v, wantErr %v", err, tt.wantErr)
return
}
if got != tt.want {
t.Errorf("checkIsEmptyDir() = %v, want %v", got, tt.want)
}
})
}
}
func Test_removeFromSlice(t *testing.T) {
type args struct {
objects []runtime.Object
objectToRemove runtime.Object
}
tests := []struct {
name string
args args
want []runtime.Object
}{
{
name: "remove object in the middle",
args: args{
objects: []runtime.Object{
&corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "app"}},
&corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "remove"}},
&corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "remove"}},
&corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "db"}},
},
objectToRemove: &corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "remove"}},
},
want: []runtime.Object{
&corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "app"}},
&corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "remove"}},
&corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "db"}},
},
},
{
name: "remove objects in the middle and last object",
args: args{
objects: []runtime.Object{
&corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "app"}},
&corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "remove"}},
&corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "remove"}},
&corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "db"}},
&corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "remove"}},
},
objectToRemove: &corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "remove"}},
},
want: []runtime.Object{
&corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "app"}},
&corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "remove"}},
&corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "db"}},
&corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "remove"}},
},
},
{
name: "remove 1 object",
args: args{
objects: []runtime.Object{
&corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "app"}},
&corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "remove"}},
&corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "db"}},
},
objectToRemove: &corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "remove"}},
},
want: []runtime.Object{
&corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "app"}},
&corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "db"}},
},
},
{
name: "remove object at the beginning",
args: args{
objects: []runtime.Object{
&corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "remove"}},
&corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "app"}},
&corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "db"}},
},
objectToRemove: &corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "remove"}},
},
want: []runtime.Object{
&corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "app"}},
&corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "db"}},
},
},
{
name: "remove object at the end",
args: args{
objects: []runtime.Object{
&corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "app"}},
&corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "db"}},
&corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "remove"}},
},
objectToRemove: &corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "remove"}},
},
want: []runtime.Object{
&corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "app"}},
&corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "db"}},
},
},
{
name: "remove object that doesn't exist",
args: args{
objects: []runtime.Object{
&corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "app"}},
&corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "db"}},
},
objectToRemove: &corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "missing"}},
},
want: []runtime.Object{
&corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "app"}},
&corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "db"}},
},
},
{
name: "remove object from empty slice",
args: args{
objects: []runtime.Object{},
objectToRemove: &corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "remove"}},
},
want: []runtime.Object{},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := removeFromSlice(tt.args.objects, tt.args.objectToRemove); !reflect.DeepEqual(got, tt.want) {
t.Errorf("removeFromSlice() = %v, want %v", got, tt.want)
}
})
}
}
func Test_removeTargetDeployment(t *testing.T) {
type args struct {
objects *[]runtime.Object
targetDeploymentName string
}
tests := []struct {
name string
args args
want *[]runtime.Object
}{
{
name: "remove middle object",
args: args{
objects: &[]runtime.Object{
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "app"}},
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "remove"}},
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "db"}},
},
targetDeploymentName: "remove",
},
want: &[]runtime.Object{
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "app"}},
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "db"}},
},
},
{
name: "remove 2 objects from slice",
args: args{
objects: &[]runtime.Object{
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "app"}},
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "remove"}},
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "remove"}},
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "db"}},
},
targetDeploymentName: "remove",
},
want: &[]runtime.Object{
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "app"}},
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "db"}},
},
},
{
name: "remove 2 object from slice, only persist last one",
args: args{
objects: &[]runtime.Object{
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "remove"}},
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "remove"}},
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "db"}},
},
targetDeploymentName: "remove",
},
want: &[]runtime.Object{
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "db"}},
},
},
{
name: "remove target deployment from an empty slice",
args: args{
objects: &[]runtime.Object{},
targetDeploymentName: "remove",
},
want: &[]runtime.Object{},
},
{
name: "remove target deployment that does not exist",
args: args{
objects: &[]runtime.Object{
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "app"}},
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "db"}},
},
targetDeploymentName: "missing",
},
want: &[]runtime.Object{
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "app"}},
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "db"}},
},
},
{
name: "remove target deployment from a slice with only the target deployment",
args: args{
objects: &[]runtime.Object{
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "remove"}},
},
targetDeploymentName: "remove",
},
want: &[]runtime.Object{},
},
{
name: "remove all targets",
args: args{
objects: &[]runtime.Object{
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "remove"}},
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "app"}},
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "remove"}},
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "remove"}},
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "remove"}},
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "db"}},
},
targetDeploymentName: "remove",
},
want: &[]runtime.Object{
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "app"}},
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "db"}},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
removeTargetDeployment(tt.args.objects, tt.args.targetDeploymentName)
if !reflect.DeepEqual(tt.args.objects, tt.want) {
t.Errorf("removeFromSlice() = %v, want %v", tt.args.objects, tt.want)
}
})
}
}
func Test_removeDeploymentTransfered(t *testing.T) {
type args struct {
deploymentMappings []DeploymentMapping
objects *[]runtime.Object
}
tests := []struct {
name string
args args
want *[]runtime.Object
}{
{
name: "remove deployment already transferred",
args: args{
deploymentMappings: []DeploymentMapping{
{
TargetDeploymentName: "app",
SourceDeploymentName: "db",
},
},
objects: &[]runtime.Object{
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "app"}},
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "db"}},
},
},
want: &[]runtime.Object{
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "app"}},
},
},
{
name: "remove multiple deployments already transferred",
args: args{
deploymentMappings: []DeploymentMapping{
{
TargetDeploymentName: "app",
SourceDeploymentName: "db",
},
{
TargetDeploymentName: "web",
SourceDeploymentName: "cache",
},
},
objects: &[]runtime.Object{
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "app"}},
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "web"}},
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "db"}},
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "cache"}},
},
},
want: &[]runtime.Object{
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "app"}},
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "web"}},
},
},
{
name: "remove deployment transferred with multiple containers",
args: args{
deploymentMappings: []DeploymentMapping{
{
TargetDeploymentName: "app",
SourceDeploymentName: "db",
},
},
objects: &[]runtime.Object{
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "app"}},
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "db"}},
},
},
want: &[]runtime.Object{
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "app"}},
},
},
{
name: "remove deployment transferred with different container names",
args: args{
deploymentMappings: []DeploymentMapping{
{
TargetDeploymentName: "app",
SourceDeploymentName: "db",
},
},
objects: &[]runtime.Object{
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "app"}},
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "db"}},
},
},
want: &[]runtime.Object{
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "app"}},
},
},
{
name: "remove deployment transferred when no matching source deployment",
args: args{
deploymentMappings: []DeploymentMapping{
{
TargetDeploymentName: "app",
SourceDeploymentName: "db",
},
},
objects: &[]runtime.Object{
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "app"}},
},
},
want: &[]runtime.Object{
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "app"}},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
removeDeploymentTransfered(tt.args.deploymentMappings, tt.args.objects)
if !reflect.DeepEqual(tt.args.objects, tt.want) {
t.Errorf("removeFromSlice() = %v, want %v", tt.args.objects, tt.want)
}
})
}
}
func Test_searchNetworkModeToService(t *testing.T) {
tests := []struct {
name string
services map[string]kobject.ServiceConfig
want []DeploymentMapping
}{
{
name: "search network mode to service",
services: map[string]kobject.ServiceConfig{
"app": {
Name: "app",
},
"db": {
Name: "db",
NetworkMode: "service:app",
},
},
want: []DeploymentMapping{
{
SourceDeploymentName: "db",
TargetDeploymentName: "app",
},
},
},
{
name: "error and not set service:app",
services: map[string]kobject.ServiceConfig{
"app": {
Name: "app",
},
"db": {
Name: "db",
},
},
want: []DeploymentMapping{},
},
{
name: "search network mode to service with multiple source deployments",
services: map[string]kobject.ServiceConfig{
"app": {
Name: "app",
},
"db1": {
Name: "db1",
NetworkMode: "service:app",
},
"db2": {
Name: "db2",
NetworkMode: "service:app",
},
},
want: []DeploymentMapping{
{
SourceDeploymentName: "db1",
TargetDeploymentName: "app",
},
{
SourceDeploymentName: "db2",
TargetDeploymentName: "app",
},
},
},
{
name: "search network mode to service with multiple target deployments",
services: map[string]kobject.ServiceConfig{
"app1": {
Name: "app1",
},
"app2": {
Name: "app2",
},
"db": {
Name: "db",
NetworkMode: "service:app1",
},
},
want: []DeploymentMapping{
{
SourceDeploymentName: "db",
TargetDeploymentName: "app1",
},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
gotDeploymentMappings := searchNetworkModeToService(tt.services)
sort.Slice(gotDeploymentMappings, func(i, j int) bool {
if gotDeploymentMappings[i].SourceDeploymentName != gotDeploymentMappings[j].SourceDeploymentName {
return gotDeploymentMappings[i].SourceDeploymentName < gotDeploymentMappings[j].SourceDeploymentName
}
return gotDeploymentMappings[i].TargetDeploymentName < gotDeploymentMappings[j].TargetDeploymentName
})
sort.Slice(tt.want, func(i, j int) bool {
if tt.want[i].SourceDeploymentName != tt.want[j].SourceDeploymentName {
return tt.want[i].SourceDeploymentName < tt.want[j].SourceDeploymentName
}
return tt.want[i].TargetDeploymentName < tt.want[j].TargetDeploymentName
})
if !reflect.DeepEqual(gotDeploymentMappings, tt.want) {
t.Errorf("searchNetworkModeToService() = %v, want %v", gotDeploymentMappings, tt.want)
}
})
}
}
func Test_addContainersToTargetDeployment(t *testing.T) {
k := Kubernetes{}
appK, err := k.Transform(
kobject.KomposeObject{
ServiceConfigs: map[string]kobject.ServiceConfig{"app": {
ContainerName: "app",
Image: "image",
},
},
}, kobject.ConvertOptions{CreateD: true, Replicas: 3})
if err != nil {
t.Error(errors.Wrap(err, "k.Transform failed"))
}
dbK, err := k.Transform(
kobject.KomposeObject{
ServiceConfigs: map[string]kobject.ServiceConfig{"db": {
ContainerName: "db",
Image: "image",
NetworkMode: "service:app",
},
},
}, kobject.ConvertOptions{CreateD: true, Replicas: 3})
if err != nil {
t.Error(errors.Wrap(err, "k.Transform failed"))
}
type args struct {
objects []runtime.Object
containersToAppend []api.Container
nameDeploymentToTransfer string
}
const (
FirstObject = 0
SecondObject = 1
)
tests := []struct {
name string
args args
wantAfter int
wantBefore int
targetObject int
}{
{
name: "no containers to add, appk target transfer",
args: args{
objects: []runtime.Object{appK[0]},
containersToAppend: []api.Container{},
nameDeploymentToTransfer: "app",
},
wantBefore: 1,
wantAfter: 1,
targetObject: FirstObject,
},
{
name: "no match in the deployment names, no target found",
args: args{
objects: []runtime.Object{dbK[0]},
containersToAppend: []api.Container{},
nameDeploymentToTransfer: "app",
},
wantBefore: 1,
wantAfter: 1,
targetObject: FirstObject,
},
{
name: "1 container more, appk target transfer",
args: args{
objects: []runtime.Object{appK[0]},
containersToAppend: []api.Container{{Name: "new-1"}},
nameDeploymentToTransfer: "app",
},
wantBefore: 1,
wantAfter: 2,
targetObject: FirstObject,
},
{
name: "1 containers and 2 more, appk target transfer",
args: args{
objects: []runtime.Object{appK[0], dbK[0]},
containersToAppend: []api.Container{{Name: "new-1"}, {Name: "new-2"}},
nameDeploymentToTransfer: "app",
},
wantBefore: 1,
wantAfter: 3,
targetObject: FirstObject,
},
{
name: "one containers to transfer, appk target transfer",
args: args{
objects: []runtime.Object{appK[0]},
containersToAppend: []api.Container{{Name: "new-1"}},
nameDeploymentToTransfer: "app",
},
wantBefore: 1,
wantAfter: 2,
targetObject: FirstObject,
},
{
name: "1 container in appk and add 2 container in dbK, db target transfer",
args: args{
objects: []runtime.Object{appK[0], dbK[0]},
containersToAppend: []api.Container{{Name: "new-1"}, {Name: "new-2"}},
nameDeploymentToTransfer: "db",
},
wantBefore: 1,
wantAfter: 3,
targetObject: SecondObject,
},
{
name: "1 container in appk, cannot add 2 container in dbK, app target transfer",
args: args{
objects: []runtime.Object{appK[0], dbK[0]},
containersToAppend: []api.Container{{Name: "new-1"}, {Name: "new-2"}},
nameDeploymentToTransfer: "app",
},
wantBefore: 1,
wantAfter: 1,
targetObject: SecondObject,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
beforeContainers := (tt.args.objects)[tt.targetObject].(*appsv1.Deployment).Spec.Template.Spec.Containers
if len(beforeContainers) != tt.wantBefore {
t.Errorf("Before Expected %d containers, got %d", tt.wantBefore, len(beforeContainers))
}
addContainersToTargetDeployment(&tt.args.objects, tt.args.containersToAppend, tt.args.nameDeploymentToTransfer)
afterContainers := (tt.args.objects)[tt.targetObject].(*appsv1.Deployment).Spec.Template.Spec.Containers
if len(afterContainers) != tt.wantAfter {
t.Errorf("After Expected %d containers, got %d", tt.wantAfter, len(afterContainers))
}
// reset containers
newContainer := appK[0].(*appsv1.Deployment).Spec.Template.Spec.Containers[0]
appK[0].(*appsv1.Deployment).Spec.Template.Spec.Containers = nil
appK[0].(*appsv1.Deployment).Spec.Template.Spec.Containers = append(appK[0].(*appsv1.Deployment).Spec.Template.Spec.Containers, newContainer)
newContainer = dbK[0].(*appsv1.Deployment).Spec.Template.Spec.Containers[0]
dbK[0].(*appsv1.Deployment).Spec.Template.Spec.Containers = nil
dbK[0].(*appsv1.Deployment).Spec.Template.Spec.Containers = append(dbK[0].(*appsv1.Deployment).Spec.Template.Spec.Containers, newContainer)
})
}
}
func Test_addContainersFromSourceToTargetDeployment(t *testing.T) {
type args struct {
objects *[]runtime.Object
currentDeploymentMap DeploymentMapping
}
const (
FirstObject = 0
SecondObject = 1
)
tests := []struct {
name string
args args
wantBefore int
wantAfter int
targetDeployment int
}{
{
name: "add one container more to target deployment",
args: args{
objects: &[]runtime.Object{
&appsv1.Deployment{
ObjectMeta: metav1.ObjectMeta{Name: "app"},
Spec: appsv1.DeploymentSpec{
Template: corev1.PodTemplateSpec{
Spec: corev1.PodSpec{
Containers: []corev1.Container{
{
Name: "app",
Image: "image",
},
},
},
},
},
},
&appsv1.Deployment{
ObjectMeta: metav1.ObjectMeta{Name: "db"},
Spec: appsv1.DeploymentSpec{
Template: corev1.PodTemplateSpec{
Spec: corev1.PodSpec{
Containers: []corev1.Container{
{
Name: "db",
Image: "image",
},
},
},
},
},
},
},
currentDeploymentMap: DeploymentMapping{
SourceDeploymentName: "db",
TargetDeploymentName: "app",
},
},
wantBefore: 1,
wantAfter: 2,
targetDeployment: FirstObject,
},
{
name: "no containers to transfer",
args: args{
objects: &[]runtime.Object{
&appsv1.Deployment{
ObjectMeta: metav1.ObjectMeta{Name: "app"},
Spec: appsv1.DeploymentSpec{
Template: corev1.PodTemplateSpec{
Spec: corev1.PodSpec{
Containers: []corev1.Container{
{
Name: "new-1",
Image: "image",
},
},
},
},
},
},
&appsv1.Deployment{
ObjectMeta: metav1.ObjectMeta{Name: "db"},
Spec: appsv1.DeploymentSpec{
Template: corev1.PodTemplateSpec{
Spec: corev1.PodSpec{
Containers: []corev1.Container{
{
Name: "db",
Image: "image",
},
},
},
},
},
},
},
currentDeploymentMap: DeploymentMapping{},
},
wantBefore: 1,
wantAfter: 1,
targetDeployment: FirstObject,
},
{
name: "no containers to transfer",
args: args{
objects: &[]runtime.Object{
&appsv1.Deployment{
ObjectMeta: metav1.ObjectMeta{Name: "app"},
Spec: appsv1.DeploymentSpec{
Template: corev1.PodTemplateSpec{
Spec: corev1.PodSpec{
Containers: []corev1.Container{
{
Name: "new-1",
Image: "image",
},
},
},
},
},
},
&appsv1.Deployment{
ObjectMeta: metav1.ObjectMeta{Name: "db"},
Spec: appsv1.DeploymentSpec{
Template: corev1.PodTemplateSpec{
Spec: corev1.PodSpec{
Containers: []corev1.Container{
{
Name: "db",
Image: "image",
},
},
},
},
},
},
},
currentDeploymentMap: DeploymentMapping{
SourceDeploymentName: "app",
TargetDeploymentName: "db",
},
},
wantBefore: 1,
wantAfter: 2,
targetDeployment: SecondObject,
},
{
name: "target deployment not found",
args: args{
objects: &[]runtime.Object{
&appsv1.Deployment{
ObjectMeta: metav1.ObjectMeta{Name: "app"},
Spec: appsv1.DeploymentSpec{
Template: corev1.PodTemplateSpec{
Spec: corev1.PodSpec{
Containers: []corev1.Container{
{
Name: "new-1",
Image: "image",
},
},
},
},
},
},
&appsv1.Deployment{
ObjectMeta: metav1.ObjectMeta{Name: "db"},
Spec: appsv1.DeploymentSpec{
Template: corev1.PodTemplateSpec{
Spec: corev1.PodSpec{
Containers: []corev1.Container{
{
Name: "db",
Image: "image",
},
},
},
},
},
},
},
currentDeploymentMap: DeploymentMapping{
SourceDeploymentName: "no-exist-deployment",
TargetDeploymentName: "target-no-exist",
},
},
wantBefore: 1,
wantAfter: 1,
targetDeployment: FirstObject,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
beforeContainers := (*tt.args.objects)[tt.targetDeployment].(*appsv1.Deployment).Spec.Template.Spec.Containers
if len(beforeContainers) != tt.wantBefore {
t.Errorf("Before expected %d containers, got %d", tt.wantBefore, len(beforeContainers))
}
addContainersFromSourceToTargetDeployment(tt.args.objects, tt.args.currentDeploymentMap)
afterContainers := (*tt.args.objects)[tt.targetDeployment].(*appsv1.Deployment).Spec.Template.Spec.Containers
if len(afterContainers) != tt.wantAfter {
t.Errorf("After expected %d containers, got %d", tt.wantAfter, len(afterContainers))
}
})
}
}
func Test_mergeContainersIntoDestinationDeployment(t *testing.T) {
type args struct {
deploymentMappings []DeploymentMapping
objects *[]runtime.Object
}
const (
FirstObject = 0
SecondObject = 1
)
tests := []struct {
name string
args args
wantBefore int
wantAfter int
targetDeployment int
}{
{
name: "merge containers into db",
args: args{
objects: &[]runtime.Object{
&appsv1.Deployment{
ObjectMeta: metav1.ObjectMeta{Name: "app"},
Spec: appsv1.DeploymentSpec{
Template: corev1.PodTemplateSpec{
Spec: corev1.PodSpec{
Containers: []corev1.Container{
{
Name: "app",
Image: "image",
},
},
},
},
},
},
&appsv1.Deployment{
ObjectMeta: metav1.ObjectMeta{Name: "db"},
Spec: appsv1.DeploymentSpec{
Template: corev1.PodTemplateSpec{
Spec: corev1.PodSpec{
Containers: []corev1.Container{},
},
},
},
},
},
deploymentMappings: []DeploymentMapping{
{
SourceDeploymentName: "app",
TargetDeploymentName: "db",
},
},
},
wantBefore: 0,
wantAfter: 1,
targetDeployment: SecondObject,
},
{
name: "merge containers into destination deployment",
args: args{
objects: &[]runtime.Object{
&appsv1.Deployment{
ObjectMeta: metav1.ObjectMeta{Name: "app"},
Spec: appsv1.DeploymentSpec{
Template: corev1.PodTemplateSpec{
Spec: corev1.PodSpec{
Containers: []corev1.Container{
{
Name: "app",
Image: "image",
},
},
},
},
},
},
&appsv1.Deployment{
ObjectMeta: metav1.ObjectMeta{Name: "db"},
Spec: appsv1.DeploymentSpec{
Template: corev1.PodTemplateSpec{
Spec: corev1.PodSpec{
Containers: []corev1.Container{
{
Name: "db-1",
Image: "image",
},
{
Name: "db-2",
Image: "image",
},
{
Name: "db-3",
Image: "image",
},
},
},
},
},
},
},
deploymentMappings: []DeploymentMapping{
{
SourceDeploymentName: "db",
TargetDeploymentName: "app",
},
},
},
wantBefore: 1,
wantAfter: 4,
targetDeployment: FirstObject,
},
{
name: "no containers to transfer",
args: args{
objects: &[]runtime.Object{
&appsv1.Deployment{
ObjectMeta: metav1.ObjectMeta{Name: "app"},
Spec: appsv1.DeploymentSpec{
Template: corev1.PodTemplateSpec{
Spec: corev1.PodSpec{
Containers: []corev1.Container{
{
Name: "app",
Image: "image",
},
},
},
},
},
},
&appsv1.Deployment{
ObjectMeta: metav1.ObjectMeta{Name: "db"},
Spec: appsv1.DeploymentSpec{
Template: corev1.PodTemplateSpec{
Spec: corev1.PodSpec{
Containers: []corev1.Container{
{
Name: "db",
Image: "image",
},
},
},
},
},
},
},
deploymentMappings: []DeploymentMapping{},
},
wantBefore: 1,
wantAfter: 1,
targetDeployment: FirstObject,
},
{
name: "merge 2 containers db deployment into app deployment",
args: args{
objects: &[]runtime.Object{
&appsv1.Deployment{
ObjectMeta: metav1.ObjectMeta{Name: "app"},
Spec: appsv1.DeploymentSpec{
Template: corev1.PodTemplateSpec{
Spec: corev1.PodSpec{
Containers: []corev1.Container{
{
Name: "app",
Image: "image",
},
},
},
},
},
},
&appsv1.Deployment{
ObjectMeta: metav1.ObjectMeta{Name: "db"},
Spec: appsv1.DeploymentSpec{
Template: corev1.PodTemplateSpec{
Spec: corev1.PodSpec{
Containers: []corev1.Container{
{
Name: "db",
Image: "image",
},
{
Name: "db-2",
Image: "image",
},
},
},
},
},
},
},
deploymentMappings: []DeploymentMapping{
{
SourceDeploymentName: "db",
TargetDeploymentName: "app",
},
},
},
wantBefore: 1,
wantAfter: 3,
targetDeployment: FirstObject,
},
{
name: "merge containers in app deployment into db deployment",
args: args{
objects: &[]runtime.Object{
&appsv1.Deployment{
ObjectMeta: metav1.ObjectMeta{Name: "app"},
Spec: appsv1.DeploymentSpec{
Template: corev1.PodTemplateSpec{
Spec: corev1.PodSpec{
Containers: []corev1.Container{
{
Name: "app",
Image: "image",
},
},
},
},
},
},
&appsv1.Deployment{
ObjectMeta: metav1.ObjectMeta{Name: "db"},
Spec: appsv1.DeploymentSpec{
Template: corev1.PodTemplateSpec{
Spec: corev1.PodSpec{
Containers: []corev1.Container{
{
Name: "db",
Image: "image",
},
},
},
},
},
},
},
deploymentMappings: []DeploymentMapping{
{
SourceDeploymentName: "app",
TargetDeploymentName: "db",
},
},
},
wantBefore: 1,
wantAfter: 2,
targetDeployment: SecondObject,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
beforeContainers := (*tt.args.objects)[tt.targetDeployment].(*appsv1.Deployment).Spec.Template.Spec.Containers
if len(beforeContainers) != tt.wantBefore {
t.Errorf("Before expected %d containers, got %d", tt.wantBefore, len(beforeContainers))
}
mergeContainersIntoDestinationDeployment(tt.args.deploymentMappings, tt.args.objects)
afterContainers := (*tt.args.objects)[tt.targetDeployment].(*appsv1.Deployment).Spec.Template.Spec.Containers
if len(afterContainers) != tt.wantAfter {
t.Errorf("After expected %d containers, got %d", tt.wantAfter, len(afterContainers))
}
})
}
}
func TestKubernetes_fixNetworkModeToService(t *testing.T) {
type args struct {
objects *[]runtime.Object
services map[string]kobject.ServiceConfig
}
const (
FirstObject = 0
SecondObject = 1
)
tests := []struct {
name string
args args
wantBefore int
wantAfter int
targetDeployment int
wantDeployments int
}{
{
name: "fix network mode to service with transfer",
args: args{
objects: &[]runtime.Object{
&appsv1.Deployment{
ObjectMeta: metav1.ObjectMeta{Name: "app"},
Spec: appsv1.DeploymentSpec{
Template: corev1.PodTemplateSpec{
Spec: corev1.PodSpec{
Containers: []corev1.Container{
{
Name: "app",
Image: "image",
},
},
},
},
},
},
&appsv1.Deployment{
ObjectMeta: metav1.ObjectMeta{Name: "db"},
Spec: appsv1.DeploymentSpec{
Template: corev1.PodTemplateSpec{
Spec: corev1.PodSpec{
Containers: []corev1.Container{
{
Name: "db",
Image: "image",
},
},
},
},
},
},
&appsv1.Deployment{
ObjectMeta: metav1.ObjectMeta{Name: "nginx"},
Spec: appsv1.DeploymentSpec{
Template: corev1.PodTemplateSpec{
Spec: corev1.PodSpec{
Containers: []corev1.Container{
{
Name: "nginx",
Image: "image",
},
},
},
},
},
},
},
services: map[string]kobject.ServiceConfig{
"nginx": {
Name: "nginx",
Image: "image",
},
"app": {
Name: "app",
Image: "image",
NetworkMode: "service:db",
},
"db": {
Name: "db",
Image: "image",
},
},
},
wantBefore: 1,
wantAfter: 2,
targetDeployment: FirstObject,
wantDeployments: 2,
},
{
name: "not transfer because wronge service name",
args: args{
objects: &[]runtime.Object{
&appsv1.Deployment{
ObjectMeta: metav1.ObjectMeta{Name: "app"},
Spec: appsv1.DeploymentSpec{
Template: corev1.PodTemplateSpec{
Spec: corev1.PodSpec{
Containers: []corev1.Container{
{
Name: "app",
Image: "image",
},
},
},
},
},
},
&appsv1.Deployment{
ObjectMeta: metav1.ObjectMeta{Name: "db"},
Spec: appsv1.DeploymentSpec{
Template: corev1.PodTemplateSpec{
Spec: corev1.PodSpec{
Containers: []corev1.Container{
{
Name: "db",
Image: "image",
},
},
},
},
},
},
},
services: map[string]kobject.ServiceConfig{
"app": {
Name: "app",
Image: "image",
},
"db": {
Name: "db",
Image: "image",
NetworkMode: "service:wrong",
},
},
},
wantBefore: 1,
wantAfter: 1,
targetDeployment: FirstObject,
wantDeployments: 1,
},
{
name: "deployment db removed",
args: args{
objects: &[]runtime.Object{
&appsv1.Deployment{
ObjectMeta: metav1.ObjectMeta{Name: "app"},
Spec: appsv1.DeploymentSpec{
Template: corev1.PodTemplateSpec{
Spec: corev1.PodSpec{
Containers: []corev1.Container{
{
Name: "app",
Image: "image",
},
},
},
},
},
},
&appsv1.Deployment{
ObjectMeta: metav1.ObjectMeta{Name: "db"},
Spec: appsv1.DeploymentSpec{
Template: corev1.PodTemplateSpec{
Spec: corev1.PodSpec{
Containers: []corev1.Container{
{
Name: "db",
Image: "image",
},
},
},
},
},
},
},
services: map[string]kobject.ServiceConfig{
"app": {
Name: "app",
Image: "image",
NetworkMode: "service:db",
},
"db": {
Name: "db",
Image: "image",
},
},
},
wantBefore: 1,
wantAfter: 2,
targetDeployment: FirstObject, // db deployment removed
wantDeployments: 1,
},
{
name: "deployment app removed and added 1 container",
args: args{
objects: &[]runtime.Object{
&appsv1.Deployment{
ObjectMeta: metav1.ObjectMeta{Name: "app"},
Spec: appsv1.DeploymentSpec{
Template: corev1.PodTemplateSpec{
Spec: corev1.PodSpec{
Containers: []corev1.Container{
{
Name: "app",
Image: "image",
},
},
},
},
},
},
&appsv1.Deployment{
ObjectMeta: metav1.ObjectMeta{Name: "db"},
Spec: appsv1.DeploymentSpec{
Template: corev1.PodTemplateSpec{
Spec: corev1.PodSpec{
Containers: []corev1.Container{
{
Name: "db",
Image: "image",
},
},
},
},
},
},
},
services: map[string]kobject.ServiceConfig{
"app": {
Name: "app",
Image: "image",
NetworkMode: "service:db",
},
"db": {
Name: "db",
Image: "image",
},
},
},
wantBefore: 1,
wantAfter: 2,
targetDeployment: FirstObject,
wantDeployments: 1,
},
{
name: "deployment db removed and added 3 containers",
args: args{
objects: &[]runtime.Object{
&appsv1.Deployment{
ObjectMeta: metav1.ObjectMeta{Name: "app"},
Spec: appsv1.DeploymentSpec{
Template: corev1.PodTemplateSpec{
Spec: corev1.PodSpec{
Containers: []corev1.Container{
{
Name: "app",
Image: "image",
},
},
},
},
},
},
&appsv1.Deployment{
ObjectMeta: metav1.ObjectMeta{Name: "db"},
Spec: appsv1.DeploymentSpec{
Template: corev1.PodTemplateSpec{
Spec: corev1.PodSpec{
Containers: []corev1.Container{
{
Name: "db-1",
Image: "image",
},
{
Name: "db-2",
Image: "image",
},
{
Name: "db-3",
Image: "image",
},
},
},
},
},
},
},
services: map[string]kobject.ServiceConfig{
"app": {
Name: "app",
Image: "image",
NetworkMode: "service:db",
},
"db": {
Name: "db",
Image: "image",
},
},
},
wantBefore: 1,
wantAfter: 4,
targetDeployment: FirstObject, // db deployment removed
wantDeployments: 1,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
k := &Kubernetes{}
beforeContainers := (*tt.args.objects)[tt.targetDeployment].(*appsv1.Deployment).Spec.Template.Spec.Containers
if len(beforeContainers) != tt.wantBefore {
t.Errorf("Expected %d containers, got %d", tt.wantBefore, len(beforeContainers))
}
k.fixNetworkModeToService(tt.args.objects, tt.args.services)
afterContainers := (*tt.args.objects)[tt.targetDeployment].(*appsv1.Deployment).Spec.Template.Spec.Containers
if len(afterContainers) != tt.wantAfter {
t.Errorf("Expected %d containers, got %d", tt.wantAfter, len(afterContainers))
}
if len(*tt.args.objects) != tt.wantDeployments {
t.Errorf("Expected %d deployments, got %d", tt.wantDeployments, len(*tt.args.objects))
}
})
}
}
View Git Blame Copy Permalink