Improve Namespaces UTs

The current implementation of Unit Tests for Namespaces wasn't
validating sucessful cases properly. This change fix that gap and
increase the coverage number.

Change-Id: Iddc0aca3b52ea8ffebca7dccfc94d4d99e052b06
Signed-off-by: Victor Morales <victor.morales@intel.com>
Issue-ID: MULTICLOUD-301

diff --git a/src/k8splugin/plugins/namespace/plugin.go b/src/k8splugin/plugins/namespace/plugin.go
index e29ff43..de2f4f8 100644 (file)
--- a/src/k8splugin/plugins/namespace/plugin.go
+++ b/src/k8splugin/plugins/namespace/plugin.go
@@ -37,25 +37,23 @@ func Create(data *krd.ResourceData, client kubernetes.Interface) (string, error)
        if err != nil {
                return "", pkgerrors.Wrap(err, "Create Namespace error")
        }
+       log.Printf("Namespace (%s) created", data.Namespace)
+
        return data.Namespace, nil
 }
 
 // Get an existing namespace hosted in a specific Kubernetes cluster
 func Get(name string, namespace string, client kubernetes.Interface) (string, error) {
-       opts := metaV1.ListOptions{}
+       opts := metaV1.GetOptions{}
+       opts.APIVersion = "apps/v1"
+       opts.Kind = "Deployment"
 
-       list, err := client.CoreV1().Namespaces().List(opts)
+       ns, err := client.CoreV1().Namespaces().Get(name, opts)
        if err != nil {
-               return "", pkgerrors.Wrap(err, "Get Namespace list error")
-       }
-
-       for _, ns := range list.Items {
-               if namespace == ns.Name {
-                       return ns.Name, nil
-               }
+               return "", pkgerrors.Wrap(err, "Get Namespace error")
        }
 
-       return "", nil
+       return ns.Name, nil
 }
 
 // Delete an existing namespace hosted in a specific Kubernetes cluster

diff --git a/src/k8splugin/plugins/namespace/plugin_test.go b/src/k8splugin/plugins/namespace/plugin_test.go
index fe60404..8a9fc5a 100644 (file)
--- a/src/k8splugin/plugins/namespace/plugin_test.go
+++ b/src/k8splugin/plugins/namespace/plugin_test.go
@@ -51,12 +51,23 @@ func TestCreateNamespace(t *testing.T) {
                t.Run(testCase.label, func(t *testing.T) {
                        result, err := Create(testCase.input, client)
                        if err != nil {
+                               if testCase.expectedError == "" {
+                                       t.Fatalf("Create method return an un-expected (%s)", err)
+                               }
                                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)
+                       } else {
+                               if testCase.expectedError != "" && testCase.expectedResult == "" {
+                                       t.Fatalf("Create method was expecting \"%s\" error message", testCase.expectedError)
+                               }
+                               if result == "" {
+                                       t.Fatal("Create method returned nil result")
+                               }
+                               if !reflect.DeepEqual(testCase.expectedResult, result) {
+
+                                       t.Fatalf("Create method returned: \n%v\n and it was expected: \n%v", result, testCase.expectedResult)
+                               }
                        }
                })
        }
@@ -98,27 +109,31 @@ func TestListNamespace(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)
+                       } else {
+                               if result == nil {
+                                       t.Fatal("List method returned nil result")
+                               }
+                               if !reflect.DeepEqual(testCase.expectedResult, result) {
+
+                                       t.Fatalf("List method returned: \n%v\n and it was expected: \n%v", result, testCase.expectedResult)
+                               }
                        }
                })
        }
 }
 
 func TestDeleteNamespace(t *testing.T) {
-       namespace := "test1"
        testCases := []struct {
                label        string
-               input        string
+               input        map[string]string
                clientOutput *coreV1.Namespace
        }{
                {
                        label: "Sucessfully to delete an existing namespace",
-                       input: namespace,
+                       input: map[string]string{"name": "test-name", "namespace": "test-namespace"},
                        clientOutput: &coreV1.Namespace{
                                ObjectMeta: metaV1.ObjectMeta{
-                                       Name: namespace,
+                                       Name: "test-name",
                                },
                        },
                },
@@ -127,7 +142,7 @@ func TestDeleteNamespace(t *testing.T) {
        for _, testCase := range testCases {
                client := testclient.NewSimpleClientset(testCase.clientOutput)
                t.Run(testCase.label, func(t *testing.T) {
-                       err := Delete(testCase.input, namespace, client)
+                       err := Delete(testCase.input["name"], testCase.input["namespace"], client)
                        if err != nil {
                                t.Fatalf("Delete method returned an error (%s)", err)
                        }
@@ -136,34 +151,57 @@ func TestDeleteNamespace(t *testing.T) {
 }
 
 func TestGetNamespace(t *testing.T) {
-       namespace := "test1"
        testCases := []struct {
                label          string
-               input          string
+               input          map[string]string
                clientOutput   *coreV1.Namespace
                expectedResult string
+               expectedError  string
        }{
                {
                        label: "Sucessfully to get an existing namespace",
-                       input: namespace,
+                       input: map[string]string{"name": "test-name", "namespace": "test-namespace"},
                        clientOutput: &coreV1.Namespace{
                                ObjectMeta: metaV1.ObjectMeta{
-                                       Name: namespace,
+                                       Name: "test-name",
                                },
                        },
-                       expectedResult: namespace,
+                       expectedResult: "test-name",
+               },
+               {
+                       label: "Fail to get an non-existing namespace",
+                       input: map[string]string{"name": "test-name", "namespace": "test-namespace"},
+                       clientOutput: &coreV1.Namespace{
+                               ObjectMeta: metaV1.ObjectMeta{
+                                       Name: "test-name2",
+                               },
+                       },
+                       expectedError: "not found",
                },
        }
 
        for _, testCase := range testCases {
                client := testclient.NewSimpleClientset(testCase.clientOutput)
                t.Run(testCase.label, func(t *testing.T) {
-                       result, err := Get(testCase.input, namespace, client)
+                       result, err := Get(testCase.input["name"], 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)
+                               if testCase.expectedError == "" {
+                                       t.Fatalf("Get method return an un-expected (%s)", err)
+                               }
+                               if !strings.Contains(string(err.Error()), testCase.expectedError) {
+                                       t.Fatalf("Get method returned an error (%s)", err)
+                               }
+                       } else {
+                               if testCase.expectedError != "" && testCase.expectedResult == "" {
+                                       t.Fatalf("Get method was expecting \"%s\" error message", testCase.expectedError)
+                               }
+                               if result == "" {
+                                       t.Fatal("Get method returned nil result")
+                               }
+                               if !reflect.DeepEqual(testCase.expectedResult, result) {
+
+                                       t.Fatalf("Get method returned: \n%v\n and it was expected: \n%v", result, testCase.expectedResult)
+                               }
                        }
                })
        }