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

2 files changed, 67 insertions, 31 deletions

diff --git a/src/k8splugin/plugins/namespace/plugin.go b/src/k8splugin/plugins/namespace/plugin.go
index e29ff43d..de2f4f8b 100644
--- 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 fe60404d..8a9fc5ac 100644
--- 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)
+				}
 			}
 		})
 	}