From 05274b1b149139d91445ca10a73defe41f14824a Mon Sep 17 00:00:00 2001 From: Victor Morales Date: Tue, 18 Sep 2018 17:19:00 -0700 Subject: Add UTs to plugins Deployment, service and namespace are plugins which offers CRUD operations to manage their resources. They haven't implemented Unit Tests which makes fragile to change/refactor the source code. This change adds their corresponding Unit Tests and defines a standard interface. Change-Id: I1e1eb40f1a18ba33c74069a117462c8df17767ac Signed-off-by: Victor Morales Issue-ID: MULTICLOUD-301 --- src/k8splugin/plugins/namespace/plugin.go | 74 +++++++---- src/k8splugin/plugins/namespace/plugin_test.go | 170 +++++++++++++++++++++++++ 2 files changed, 222 insertions(+), 22 deletions(-) create mode 100644 src/k8splugin/plugins/namespace/plugin_test.go (limited to 'src/k8splugin/plugins/namespace') diff --git a/src/k8splugin/plugins/namespace/plugin.go b/src/k8splugin/plugins/namespace/plugin.go index 986de863..e29ff43d 100644 --- a/src/k8splugin/plugins/namespace/plugin.go +++ b/src/k8splugin/plugins/namespace/plugin.go @@ -14,55 +14,85 @@ limitations under the License. package main import ( + "log" + + "k8s.io/client-go/kubernetes" + pkgerrors "github.com/pkg/errors" coreV1 "k8s.io/api/core/v1" metaV1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "k8s.io/client-go/kubernetes" + + "k8splugin/krd" ) -// CreateResource is used to create a new Namespace -func CreateResource(namespace string, client *kubernetes.Clientset) error { - namespaceStruct := &coreV1.Namespace{ +// Create a namespace object in a specific Kubernetes cluster +func Create(data *krd.ResourceData, client kubernetes.Interface) (string, error) { + namespace := &coreV1.Namespace{ ObjectMeta: metaV1.ObjectMeta{ - Name: namespace, + Name: data.Namespace, }, } - _, err := client.CoreV1().Namespaces().Create(namespaceStruct) + _, err := client.CoreV1().Namespaces().Create(namespace) if err != nil { - return pkgerrors.Wrap(err, "Create Namespace error") + return "", pkgerrors.Wrap(err, "Create Namespace error") } - return nil + return data.Namespace, nil } -// GetResource is used to check if a given namespace actually exists in Kubernetes -func GetResource(namespace string, client *kubernetes.Clientset) (bool, error) { +// Get an existing namespace hosted in a specific Kubernetes cluster +func Get(name string, namespace string, client kubernetes.Interface) (string, error) { opts := metaV1.ListOptions{} - namespaceList, err := client.CoreV1().Namespaces().List(opts) + list, err := client.CoreV1().Namespaces().List(opts) if err != nil { - return false, pkgerrors.Wrap(err, "Get Namespace list error") + return "", pkgerrors.Wrap(err, "Get Namespace list error") } - for _, ns := range namespaceList.Items { + for _, ns := range list.Items { if namespace == ns.Name { - return true, nil + return ns.Name, nil } } - return false, nil + return "", nil } -// DeleteResource is used to delete a namespace -func DeleteResource(namespace string, client *kubernetes.Clientset) error { +// Delete an existing namespace hosted in a specific Kubernetes cluster +func Delete(name string, namespace string, client kubernetes.Interface) error { deletePolicy := metaV1.DeletePropagationForeground - - err := client.CoreV1().Namespaces().Delete(namespace, &metaV1.DeleteOptions{ + opts := &metaV1.DeleteOptions{ PropagationPolicy: &deletePolicy, - }) + } - if err != nil { - return pkgerrors.Wrap(err, "Delete Namespace error") + log.Println("Deleting namespace: " + name) + if err := client.CoreV1().Namespaces().Delete(name, opts); err != nil { + return pkgerrors.Wrap(err, "Delete namespace error") } + return nil } + +// List of existing namespaces hosted in a specific Kubernetes cluster +func List(namespace string, client kubernetes.Interface) ([]string, error) { + opts := metaV1.ListOptions{ + Limit: krd.ResourcesListLimit, + } + opts.APIVersion = "apps/v1" + opts.Kind = "Namespace" + + list, err := client.CoreV1().Namespaces().List(opts) + if err != nil { + return nil, pkgerrors.Wrap(err, "Get Namespace list error") + } + + result := make([]string, 0, krd.ResourcesListLimit) + if list != nil { + for _, deployment := range list.Items { + log.Printf("%v", deployment.Name) + result = append(result, deployment.Name) + } + } + + return result, nil +} diff --git a/src/k8splugin/plugins/namespace/plugin_test.go b/src/k8splugin/plugins/namespace/plugin_test.go new file mode 100644 index 00000000..fe60404d --- /dev/null +++ b/src/k8splugin/plugins/namespace/plugin_test.go @@ -0,0 +1,170 @@ +// +build unit + +/* +Copyright 2018 Intel Corporation. +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 main + +import ( + "reflect" + "strings" + "testing" + + "k8splugin/krd" + + coreV1 "k8s.io/api/core/v1" + metaV1 "k8s.io/apimachinery/pkg/apis/meta/v1" + testclient "k8s.io/client-go/kubernetes/fake" +) + +func TestCreateNamespace(t *testing.T) { + namespace := "test1" + testCases := []struct { + label string + input *krd.ResourceData + clientOutput *coreV1.Namespace + expectedResult string + expectedError string + }{ + { + label: "Successfully create a namespace", + input: &krd.ResourceData{ + Namespace: namespace, + }, + clientOutput: &coreV1.Namespace{}, + expectedResult: namespace, + }, + } + + for _, testCase := range testCases { + client := testclient.NewSimpleClientset(testCase.clientOutput) + t.Run(testCase.label, func(t *testing.T) { + result, err := Create(testCase.input, client) + if err != nil { + if !strings.Contains(string(err.Error()), testCase.expectedError) { + t.Fatalf("Create method returned an error (%s)", err) + } + } + if !reflect.DeepEqual(testCase.expectedResult, result) { + t.Fatalf("Create method returned %v and it was expected (%v)", result, testCase.expectedResult) + } + }) + } +} + +func TestListNamespace(t *testing.T) { + namespace := "test1" + testCases := []struct { + label string + input string + clientOutput *coreV1.NamespaceList + expectedResult []string + }{ + { + label: "Sucessfully to display an empty namespace list", + input: namespace, + clientOutput: &coreV1.NamespaceList{}, + expectedResult: []string{}, + }, + { + label: "Sucessfully to display a list of existing namespaces", + input: namespace, + clientOutput: &coreV1.NamespaceList{ + Items: []coreV1.Namespace{ + coreV1.Namespace{ + ObjectMeta: metaV1.ObjectMeta{ + Name: namespace, + }, + }, + }, + }, + expectedResult: []string{namespace}, + }, + } + + for _, testCase := range testCases { + client := testclient.NewSimpleClientset(testCase.clientOutput) + t.Run(testCase.label, func(t *testing.T) { + result, err := List(testCase.input, client) + if err != nil { + t.Fatalf("List method returned an error (%s)", err) + } + if !reflect.DeepEqual(testCase.expectedResult, result) { + t.Fatalf("List method returned %v and it was expected (%v)", result, testCase.expectedResult) + } + }) + } +} + +func TestDeleteNamespace(t *testing.T) { + namespace := "test1" + testCases := []struct { + label string + input string + clientOutput *coreV1.Namespace + }{ + { + label: "Sucessfully to delete an existing namespace", + input: namespace, + clientOutput: &coreV1.Namespace{ + ObjectMeta: metaV1.ObjectMeta{ + Name: namespace, + }, + }, + }, + } + + for _, testCase := range testCases { + client := testclient.NewSimpleClientset(testCase.clientOutput) + t.Run(testCase.label, func(t *testing.T) { + err := Delete(testCase.input, namespace, client) + if err != nil { + t.Fatalf("Delete method returned an error (%s)", err) + } + }) + } +} + +func TestGetNamespace(t *testing.T) { + namespace := "test1" + testCases := []struct { + label string + input string + clientOutput *coreV1.Namespace + expectedResult string + }{ + { + label: "Sucessfully to get an existing namespace", + input: namespace, + clientOutput: &coreV1.Namespace{ + ObjectMeta: metaV1.ObjectMeta{ + Name: namespace, + }, + }, + expectedResult: namespace, + }, + } + + for _, testCase := range testCases { + client := testclient.NewSimpleClientset(testCase.clientOutput) + t.Run(testCase.label, func(t *testing.T) { + result, err := Get(testCase.input, namespace, client) + if err != nil { + t.Fatalf("Get method returned an error (%s)", err) + } + if !reflect.DeepEqual(testCase.expectedResult, result) { + t.Fatalf("Get method returned %v and it was expected (%v)", result, testCase.expectedResult) + } + }) + } +} -- cgit 1.2.3-korg