From f74dbfbd330e0f6b15b6a0aa5b9ad18e2474ba43 Mon Sep 17 00:00:00 2001 From: galal-hussein Date: Thu, 7 Dec 2017 02:40:44 +0200 Subject: [PATCH] more unit tests --- addons/addons_test.go | 43 +++++++++++++++++++ pki/pki_test.go | 4 +- services/etcd_test.go | 59 ++++++++++++++++++++++++++ services/kubeapi_test.go | 69 ++++++++++++++++++++++++++++++ services/kubecontroller_test.go | 41 ++++++++++++++++++ services/kubelet_test.go | 74 +++++++++++++++++++++++++++++++++ services/kubeproxy_test.go | 34 +++++++++++++++ services/proxy_test.go | 49 ++++++++++++++++++++++ services/scheduler_test.go | 32 ++++++++++++++ services/services_test.go | 47 +++++++++++++++++++++ 10 files changed, 450 insertions(+), 2 deletions(-) create mode 100644 addons/addons_test.go create mode 100644 services/etcd_test.go create mode 100644 services/kubeapi_test.go create mode 100644 services/kubecontroller_test.go create mode 100644 services/kubelet_test.go create mode 100644 services/kubeproxy_test.go create mode 100644 services/proxy_test.go create mode 100644 services/scheduler_test.go create mode 100644 services/services_test.go diff --git a/addons/addons_test.go b/addons/addons_test.go new file mode 100644 index 00000000..fec53053 --- /dev/null +++ b/addons/addons_test.go @@ -0,0 +1,43 @@ +package addons + +import ( + "bytes" + "fmt" + "testing" + + "k8s.io/api/batch/v1" + yamlutil "k8s.io/apimachinery/pkg/util/yaml" +) + +const ( + AddonSuffix = "-deploy-job" + FakeAddonName = "example-addon" + FakeNodeName = "node1" + FakeAddonImage = "example/example:latest" +) + +func TestJobManifest(t *testing.T) { + jobYaml := GetAddonsExcuteJob(FakeAddonName, FakeNodeName, FakeAddonImage) + job := v1.Job{} + decoder := yamlutil.NewYAMLToJSONDecoder(bytes.NewReader([]byte(jobYaml))) + err := decoder.Decode(&job) + if err != nil { + t.Fatalf("Failed To decode Job yaml: %v", err) + } + assertEqual(t, job.Name, FakeAddonName+AddonSuffix, + fmt.Sprintf("Failed to verify job name [%s]", FakeAddonName+AddonSuffix)) + assertEqual(t, job.Spec.Template.Spec.NodeName, FakeNodeName, + fmt.Sprintf("Failed to verify node name [%s] in the job", FakeNodeName)) + assertEqual(t, job.Spec.Template.Spec.Containers[0].Image, FakeAddonImage, + fmt.Sprintf("Failed to verify container image [%s] in the job", FakeAddonImage)) +} + +func assertEqual(t *testing.T, a interface{}, b interface{}, message string) { + if a == b { + return + } + if len(message) == 0 { + message = fmt.Sprintf("%v != %v", a, b) + } + t.Fatal(message) +} diff --git a/pki/pki_test.go b/pki/pki_test.go index 3a182f38..f819cf4a 100644 --- a/pki/pki_test.go +++ b/pki/pki_test.go @@ -63,7 +63,7 @@ func TestPKI(t *testing.T) { for _, testDNS := range kubeAPIDNSNames { assertEqual( t, - stringInSlice( + isStringInSlice( testDNS, certificateMap[KubeAPICertName].Certificate.DNSNames), true, @@ -92,7 +92,7 @@ func TestPKI(t *testing.T) { } } -func stringInSlice(a string, list []string) bool { +func isStringInSlice(a string, list []string) bool { for _, b := range list { if b == a { return true diff --git a/services/etcd_test.go b/services/etcd_test.go new file mode 100644 index 00000000..28e001b1 --- /dev/null +++ b/services/etcd_test.go @@ -0,0 +1,59 @@ +package services + +import ( + "fmt" + "testing" + + "github.com/rancher/rke/hosts" + "github.com/rancher/types/apis/management.cattle.io/v3" +) + +const ( + TestInitEtcdClusterString = "etcd-etcd1=http://1.1.1.1:2380,etcd-etcd2=http://2.2.2.2:2380" + TestEtcdImage = "etcd/etcdImage:latest" + TestEtcdNamePrefix = "--name=etcd-" + TestEtcdVolumeBind = "/var/lib/etcd:/etcd-data" + TestEtcdExtraArgs = "--foo=bar" +) + +func TestEtcdConfig(t *testing.T) { + etcdHosts := []*hosts.Host{ + &hosts.Host{ + RKEConfigNode: v3.RKEConfigNode{ + Address: "1.1.1.1", + InternalAddress: "1.1.1.1", + Role: []string{"etcd"}, + HostnameOverride: "etcd1", + }, + DClient: nil, + }, + &hosts.Host{ + RKEConfigNode: v3.RKEConfigNode{ + Address: "2.2.2.2", + InternalAddress: "2.2.2.2", + Role: []string{"etcd"}, + HostnameOverride: "etcd2", + }, + DClient: nil, + }, + } + + etcdService := v3.ETCDService{} + etcdService.Image = TestEtcdImage + etcdService.ExtraArgs = map[string]string{"foo": "bar"} + // Test init cluster string + initCluster := getEtcdInitialCluster(etcdHosts) + assertEqual(t, initCluster, TestInitEtcdClusterString, "") + + for _, host := range etcdHosts { + imageCfg, hostCfg := buildEtcdConfig(host, etcdService, TestInitEtcdClusterString) + assertEqual(t, isStringInSlice(TestEtcdNamePrefix+host.HostnameOverride, imageCfg.Cmd), true, + fmt.Sprintf("Failed to find [%s] in Etcd command", TestEtcdNamePrefix+host.HostnameOverride)) + assertEqual(t, TestEtcdImage, imageCfg.Image, + fmt.Sprintf("Failed to verify [%s] as Etcd Image", TestEtcdImage)) + assertEqual(t, isStringInSlice(TestEtcdVolumeBind, hostCfg.Binds), true, + fmt.Sprintf("Failed to find [%s] in volume binds of Etcd Service", TestEtcdVolumeBind)) + assertEqual(t, isStringInSlice(TestEtcdExtraArgs, imageCfg.Entrypoint), true, + fmt.Sprintf("Failed to find [%s] in extra args of Etcd Service", TestEtcdExtraArgs)) + } +} diff --git a/services/kubeapi_test.go b/services/kubeapi_test.go new file mode 100644 index 00000000..03d1a9c4 --- /dev/null +++ b/services/kubeapi_test.go @@ -0,0 +1,69 @@ +package services + +import ( + "fmt" + "testing" + + "github.com/rancher/rke/hosts" + "github.com/rancher/types/apis/management.cattle.io/v3" +) + +const ( + TestEtcdConnString = "http://1.1.1.1:2379,http://2.2.2.2:2379" + TestKubeAPIImage = "rancher/k8s:latest" + TestInsecureBindAddress = "--insecure-bind-address=127.0.0.1" + TestKubeAPIVolumeBind = "/etc/kubernetes:/etc/kubernetes" + TestKubeAPIExtraArgs = "--foo=bar" +) + +func TestKubeAPIConfig(t *testing.T) { + etcdHosts := []*hosts.Host{ + &hosts.Host{ + RKEConfigNode: v3.RKEConfigNode{ + Address: "1.1.1.1", + InternalAddress: "1.1.1.1", + Role: []string{"etcd"}, + HostnameOverride: "etcd1", + }, + DClient: nil, + }, + &hosts.Host{ + RKEConfigNode: v3.RKEConfigNode{ + Address: "2.2.2.2", + InternalAddress: "2.2.2.2", + Role: []string{"etcd"}, + HostnameOverride: "etcd2", + }, + DClient: nil, + }, + } + + cpHost := &hosts.Host{ + RKEConfigNode: v3.RKEConfigNode{ + Address: "3.3.3.3", + InternalAddress: "3.3.3.3", + Role: []string{"controlplane"}, + HostnameOverride: "node1", + }, + DClient: nil, + } + + kubeAPIService := v3.KubeAPIService{} + kubeAPIService.Image = TestKubeAPIImage + kubeAPIService.ServiceClusterIPRange = "10.0.0.0/16" + kubeAPIService.ExtraArgs = map[string]string{"foo": "bar"} + // Test init cluster string + etcdConnString := GetEtcdConnString(etcdHosts) + assertEqual(t, etcdConnString, TestEtcdConnString, "") + + imageCfg, hostCfg := buildKubeAPIConfig(cpHost, kubeAPIService, etcdConnString) + // Test image and host config + assertEqual(t, isStringInSlice(TestInsecureBindAddress, imageCfg.Entrypoint), true, + fmt.Sprintf("Failed to find [%s] in Entrypoint of KubeAPI", TestInsecureBindAddress)) + assertEqual(t, TestKubeAPIImage, imageCfg.Image, + fmt.Sprintf("Failed to find correct image [%s] in KubeAPI Config", TestKubeAPIImage)) + assertEqual(t, isStringInSlice(TestKubeAPIVolumeBind, hostCfg.Binds), true, + fmt.Sprintf("Failed to find [%s] in volume binds of KubeAPI", TestKubeAPIVolumeBind)) + assertEqual(t, isStringInSlice(TestKubeAPIExtraArgs, imageCfg.Entrypoint), true, + fmt.Sprintf("Failed to find [%s] in extra args of KubeAPI", TestKubeAPIExtraArgs)) +} diff --git a/services/kubecontroller_test.go b/services/kubecontroller_test.go new file mode 100644 index 00000000..6894aca4 --- /dev/null +++ b/services/kubecontroller_test.go @@ -0,0 +1,41 @@ +package services + +import ( + "fmt" + "testing" + + "github.com/rancher/types/apis/management.cattle.io/v3" +) + +const ( + TestKubeControllerClusterCidr = "10.0.0.0/16" + TestKubeControllerServiceClusterIPRange = "10.1.0.0/16" + TestKubeControllerImage = "rancher/k8s:latest" + TestKubeControllerVolumeBind = "/etc/kubernetes:/etc/kubernetes" + TestKubeControllerExtraArgs = "--foo=bar" + TestClusterCidrPrefix = "--cluster-cidr=" + TestServiceIPRangePrefix = "--service-cluster-ip-range=" +) + +func TestKubeControllerConfig(t *testing.T) { + + kubeControllerService := v3.KubeControllerService{} + kubeControllerService.Image = TestKubeControllerImage + kubeControllerService.ClusterCIDR = TestKubeControllerClusterCidr + kubeControllerService.ServiceClusterIPRange = TestKubeControllerServiceClusterIPRange + kubeControllerService.ExtraArgs = map[string]string{"foo": "bar"} + + imageCfg, hostCfg := buildKubeControllerConfig(kubeControllerService) + // Test image and host config + assertEqual(t, isStringInSlice(TestClusterCidrPrefix+TestKubeControllerClusterCidr, imageCfg.Entrypoint), true, + fmt.Sprintf("Failed to find [%s] in KubeController Command", TestClusterCidrPrefix+TestKubeControllerClusterCidr)) + assertEqual(t, isStringInSlice(TestServiceIPRangePrefix+TestKubeControllerServiceClusterIPRange, imageCfg.Entrypoint), true, + fmt.Sprintf("Failed to find [%s] in KubeController Command", TestServiceIPRangePrefix+TestKubeControllerServiceClusterIPRange)) + assertEqual(t, TestKubeControllerImage, imageCfg.Image, + fmt.Sprintf("Failed to verify [%s] as KubeController Image", TestKubeControllerImage)) + assertEqual(t, isStringInSlice(TestKubeControllerVolumeBind, hostCfg.Binds), true, + fmt.Sprintf("Failed to find [%s] in volume binds of KubeController", TestKubeControllerVolumeBind)) + assertEqual(t, isStringInSlice(TestKubeControllerExtraArgs, imageCfg.Entrypoint), true, + fmt.Sprintf("Failed to find [%s] in extra args of KubeController", TestKubeControllerExtraArgs)) + assertEqual(t, true, hostCfg.NetworkMode.IsHost(), "") +} diff --git a/services/kubelet_test.go b/services/kubelet_test.go new file mode 100644 index 00000000..544d63e7 --- /dev/null +++ b/services/kubelet_test.go @@ -0,0 +1,74 @@ +package services + +import ( + "fmt" + "testing" + + "github.com/rancher/rke/hosts" + "github.com/rancher/types/apis/management.cattle.io/v3" +) + +const ( + TestKubeletClusterDomain = "cluster.local" + TestKubeletClusterDNSServer = "10.1.0.3" + TestKubeletInfraContainerImage = "test/test:latest" + TestKubeletImage = "rancher/k8s:latest" + TestKubeletVolumeBind = "/etc/kubernetes:/etc/kubernetes" + TestKubeletExtraArgs = "--foo=bar" + TestClusterDomainPrefix = "--cluster-domain=" + TestClusterDNSServerPrefix = "--cluster-dns=" + TestInfraContainerImagePrefix = "--pod-infra-container-image=" + TestHostnameOverridePrefix = "--hostname-override=" + TestKubeletEtcdNodeLabel = "--node-labels=node-role.kubernetes.io/etcd=true" + TestKubeletCPNodeLabel = "--node-labels=node-role.kubernetes.io/master=true" + TestKubeletWorkerNodeLabel = "--node-labels=node-role.kubernetes.io/worker=true" +) + +func TestKubeletConfig(t *testing.T) { + + host := &hosts.Host{ + RKEConfigNode: v3.RKEConfigNode{ + Address: "1.1.1.1", + InternalAddress: "1.1.1.1", + Role: []string{"worker", "controlplane", "etcd"}, + HostnameOverride: "node1", + }, + DClient: nil, + } + + kubeletService := v3.KubeletService{} + kubeletService.Image = TestKubeletImage + kubeletService.ClusterDomain = TestKubeletClusterDomain + kubeletService.ClusterDNSServer = TestKubeletClusterDNSServer + kubeletService.InfraContainerImage = TestKubeletInfraContainerImage + kubeletService.ExtraArgs = map[string]string{"foo": "bar"} + + imageCfg, hostCfg := buildKubeletConfig(host, kubeletService) + // Test image and host config + assertEqual(t, isStringInSlice(TestClusterDomainPrefix+TestKubeletClusterDomain, imageCfg.Entrypoint), true, + fmt.Sprintf("Failed to find [%s] in Kubelet Command", TestClusterDomainPrefix+TestKubeletClusterDomain)) + assertEqual(t, isStringInSlice(TestClusterDNSServerPrefix+TestKubeletClusterDNSServer, imageCfg.Entrypoint), true, + fmt.Sprintf("Failed to find [%s] in Kubelet Command", TestClusterDNSServerPrefix+TestKubeletClusterDNSServer)) + assertEqual(t, isStringInSlice(TestInfraContainerImagePrefix+TestKubeletInfraContainerImage, imageCfg.Entrypoint), true, + fmt.Sprintf("Failed to find [%s] in Kubelet Command", TestInfraContainerImagePrefix+TestKubeletInfraContainerImage)) + assertEqual(t, TestKubeletImage, imageCfg.Image, + fmt.Sprintf("Failed to verify [%s] as Kubelet Image", TestKubeletImage)) + assertEqual(t, isStringInSlice(TestHostnameOverridePrefix+host.HostnameOverride, imageCfg.Entrypoint), true, + fmt.Sprintf("Failed to find [%s] in Kubelet Command", TestHostnameOverridePrefix+host.HostnameOverride)) + assertEqual(t, isStringInSlice(TestKubeletVolumeBind, hostCfg.Binds), true, + fmt.Sprintf("Failed to find [%s] in Kubelet Volume Binds", TestKubeletVolumeBind)) + assertEqual(t, isStringInSlice(TestKubeletExtraArgs, imageCfg.Entrypoint), true, + fmt.Sprintf("Failed to find [%s] in Kubelet extra args", TestKubeletExtraArgs)) + assertEqual(t, true, hostCfg.Privileged, + "Failed to verify that Kubelet is privileged") + assertEqual(t, true, hostCfg.PidMode.IsHost(), + "Failed to verify that Kubelet has host PID mode") + assertEqual(t, true, hostCfg.NetworkMode.IsHost(), + "Failed to verify that Kubelet has host Netowrk mode") + assertEqual(t, isStringInSlice(TestKubeletEtcdNodeLabel, imageCfg.Cmd), true, + fmt.Sprintf("Failed to find [%s] in Kubelet Command", TestKubeletEtcdNodeLabel)) + assertEqual(t, isStringInSlice(TestKubeletCPNodeLabel, imageCfg.Cmd), true, + fmt.Sprintf("Failed to find [%s] in Kubelet Command", TestKubeletCPNodeLabel)) + assertEqual(t, isStringInSlice(TestKubeletWorkerNodeLabel, imageCfg.Cmd), true, + fmt.Sprintf("Failed to find [%s] in Kubelet Command", TestKubeletWorkerNodeLabel)) +} diff --git a/services/kubeproxy_test.go b/services/kubeproxy_test.go new file mode 100644 index 00000000..6605c6a5 --- /dev/null +++ b/services/kubeproxy_test.go @@ -0,0 +1,34 @@ +package services + +import ( + "fmt" + "testing" + + "github.com/rancher/types/apis/management.cattle.io/v3" +) + +const ( + TestKubeproxyImage = "rancher/k8s:latest" + TestKubeproxyVolumeBind = "/etc/kubernetes:/etc/kubernetes" + TestKubeproxyExtraArgs = "--foo=bar" +) + +func TestKubeproxyConfig(t *testing.T) { + + kubeproxyService := v3.KubeproxyService{} + kubeproxyService.Image = TestKubeproxyImage + kubeproxyService.ExtraArgs = map[string]string{"foo": "bar"} + + imageCfg, hostCfg := buildKubeproxyConfig(nil, kubeproxyService) + // Test image and host config + assertEqual(t, TestKubeproxyImage, imageCfg.Image, + fmt.Sprintf("Failed to verify [%s] as KubeProxy Image", TestKubeproxyImage)) + assertEqual(t, isStringInSlice(TestKubeproxyVolumeBind, hostCfg.Binds), true, + fmt.Sprintf("Failed to find [%s] in KubeProxy Volume Binds", TestKubeproxyVolumeBind)) + assertEqual(t, isStringInSlice(TestKubeproxyExtraArgs, imageCfg.Entrypoint), true, + fmt.Sprintf("Failed to find [%s] in KubeProxy extra args", TestKubeproxyExtraArgs)) + assertEqual(t, true, hostCfg.Privileged, + "Failed to verify that KubeProxy is privileged") + assertEqual(t, true, hostCfg.NetworkMode.IsHost(), + "Failed to verify that KubeProxy has host Netowrk mode") +} diff --git a/services/proxy_test.go b/services/proxy_test.go new file mode 100644 index 00000000..1e152233 --- /dev/null +++ b/services/proxy_test.go @@ -0,0 +1,49 @@ +package services + +import ( + "fmt" + "testing" + + "github.com/rancher/rke/hosts" + "github.com/rancher/types/apis/management.cattle.io/v3" +) + +const ( + TestNginxProxyImage = "test/test:latest" + TestNginxProxyConnectionString = "1.1.1.1,2.2.2.2" +) + +func TestNginxProxyConfig(t *testing.T) { + cpHosts := []*hosts.Host{ + &hosts.Host{ + RKEConfigNode: v3.RKEConfigNode{ + Address: "1.1.1.1", + InternalAddress: "1.1.1.1", + Role: []string{"controlplane"}, + HostnameOverride: "cp1", + }, + DClient: nil, + }, + &hosts.Host{ + RKEConfigNode: v3.RKEConfigNode{ + Address: "2.2.2.2", + InternalAddress: "2.2.2.2", + Role: []string{"controlplane"}, + HostnameOverride: "cp1", + }, + DClient: nil, + }, + } + + nginxProxyImage := TestNginxProxyImage + nginxProxyEnv := buildProxyEnv(cpHosts) + assertEqual(t, TestNginxProxyConnectionString, nginxProxyEnv, + fmt.Sprintf("Failed to verify nginx connection string [%s]", TestNginxProxyConnectionString)) + + imageCfg, hostCfg := buildNginxProxyConfig(nil, nginxProxyEnv, nginxProxyImage) + // Test image and host config + assertEqual(t, TestNginxProxyImage, imageCfg.Image, + fmt.Sprintf("Failed to verify [%s] as Nginx Proxy Image", TestNginxProxyImage)) + assertEqual(t, true, hostCfg.NetworkMode.IsHost(), + "Failed to verify that Nginx Proxy has host Netowrk mode") +} diff --git a/services/scheduler_test.go b/services/scheduler_test.go new file mode 100644 index 00000000..cdf45efc --- /dev/null +++ b/services/scheduler_test.go @@ -0,0 +1,32 @@ +package services + +import ( + "fmt" + "testing" + + "github.com/rancher/types/apis/management.cattle.io/v3" +) + +const ( + TestSchedulerImage = "rancher/k8s:latest" + TestSchedulerVolumeBind = "/etc/kubernetes:/etc/kubernetes" + TestSchedulerExtraArgs = "--foo=bar" +) + +func TestSchedulerConfig(t *testing.T) { + + schedulerService := v3.SchedulerService{} + schedulerService.Image = TestSchedulerImage + schedulerService.ExtraArgs = map[string]string{"foo": "bar"} + + imageCfg, hostCfg := buildSchedulerConfig(nil, schedulerService) + // Test image and host config + assertEqual(t, TestSchedulerImage, imageCfg.Image, + fmt.Sprintf("Failed to verify [%s] as Scheduler Image", TestSchedulerImage)) + assertEqual(t, isStringInSlice(TestSchedulerVolumeBind, hostCfg.Binds), true, + fmt.Sprintf("Failed to find [%s] in Scheduler Volume Binds", TestSchedulerVolumeBind)) + assertEqual(t, isStringInSlice(TestSchedulerExtraArgs, imageCfg.Entrypoint), true, + fmt.Sprintf("Failed to find [%s] in Scheduler extra args", TestSchedulerExtraArgs)) + assertEqual(t, true, hostCfg.NetworkMode.IsHost(), + "Failed to verify that Scheduler has host Netowrk mode") +} diff --git a/services/services_test.go b/services/services_test.go new file mode 100644 index 00000000..a871004c --- /dev/null +++ b/services/services_test.go @@ -0,0 +1,47 @@ +package services + +import ( + "fmt" + "testing" +) + +const ( + TestServiceIP = "10.233.0.1" + TestIncorrectClusterServiceIPRange = "#!453.23423.dsf.23" + TestClusterServiceIPRange = "10.233.0.0/18" +) + +func TestKubernetesServiceIP(t *testing.T) { + kubernetesServiceIP, err := GetKubernetesServiceIP(TestClusterServiceIPRange) + if err != nil { + t.Fatal(err) + } + assertEqual(t, kubernetesServiceIP.String(), TestServiceIP, + fmt.Sprintf("Failed to get correct kubernetes service IP [%s] for range [%s]", kubernetesServiceIP.String(), TestClusterServiceIPRange)) +} + +func TestIncorrectKubernetesServiceIP(t *testing.T) { + _, err := GetKubernetesServiceIP(TestIncorrectClusterServiceIPRange) + if err == nil { + t.Fatalf("Failed to catch error when parsing incorrect cluster service ip range") + } +} + +func isStringInSlice(a string, list []string) bool { + for _, b := range list { + if b == a { + return true + } + } + return false +} + +func assertEqual(t *testing.T, a interface{}, b interface{}, message string) { + if a == b { + return + } + if len(message) == 0 { + message = fmt.Sprintf("%v != %v", a, b) + } + t.Fatal(message) +}