Improve Deployments UTs

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

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

diff --git a/src/k8splugin/plugins/deployment/plugin_test.go b/src/k8splugin/plugins/deployment/plugin_test.go
index 636629a..c8dcb29 100644 (file)
--- a/src/k8splugin/plugins/deployment/plugin_test.go
+++ b/src/k8splugin/plugins/deployment/plugin_test.go
@@ -38,14 +38,6 @@ func TestCreateDeployment(t *testing.T) {
                expectedResult string
                expectedError  string
        }{
-               {
-                       label: "Fail to create a deployment with non-existing file",
-                       input: &krd.ResourceData{
-                               YamlFilePath: "non-existing_test_file.yaml",
-                       },
-                       clientOutput:  &appsV1.Deployment{},
-                       expectedError: "not found",
-               },
                {
                        label: "Fail to create a deployment with invalid type",
                        input: &krd.ResourceData{
@@ -75,19 +67,30 @@ func TestCreateDeployment(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)
+                               }
                        }
                })
        }
 }
 
 func TestListDeployment(t *testing.T) {
-       namespace := "test1"
+       namespace := "test"
        testCases := []struct {
                label          string
                input          string
@@ -115,6 +118,27 @@ func TestListDeployment(t *testing.T) {
                        },
                        expectedResult: []string{"test"},
                },
+               {
+                       label: "Sucessfully display a list of existing deployments in default namespace",
+                       input: "",
+                       clientOutput: &appsV1.DeploymentList{
+                               Items: []appsV1.Deployment{
+                                       appsV1.Deployment{
+                                               ObjectMeta: metaV1.ObjectMeta{
+                                                       Name:      "test",
+                                                       Namespace: "default",
+                                               },
+                                       },
+                                       appsV1.Deployment{
+                                               ObjectMeta: metaV1.ObjectMeta{
+                                                       Name:      "test2",
+                                                       Namespace: namespace,
+                                               },
+                                       },
+                               },
+                       },
+                       expectedResult: []string{"test"},
+               },
        }
 
        for _, testCase := range testCases {
@@ -123,29 +147,42 @@ func TestListDeployment(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 TestDeleteDeployment(t *testing.T) {
-       namespace := "test1"
-       name := "mock-deployment"
        testCases := []struct {
                label        string
-               input        string
+               input        map[string]string
                clientOutput *appsV1.Deployment
        }{
                {
                        label: "Sucessfully delete an existing deployment",
-                       input: name,
+                       input: map[string]string{"name": "test-deployment", "namespace": "test-namespace"},
                        clientOutput: &appsV1.Deployment{
                                ObjectMeta: metaV1.ObjectMeta{
-                                       Name:      name,
-                                       Namespace: namespace,
+                                       Name:      "test-deployment",
+                                       Namespace: "test-namespace",
+                               },
+                       },
+               },
+               {
+                       label: "Sucessfully delete an existing deployment in default namespace",
+                       input: map[string]string{"name": "test-deployment", "namespace": ""},
+                       clientOutput: &appsV1.Deployment{
+                               ObjectMeta: metaV1.ObjectMeta{
+                                       Name:      "test-deployment",
+                                       Namespace: "default",
                                },
                        },
                },
@@ -154,7 +191,7 @@ func TestDeleteDeployment(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)
                        }
@@ -163,36 +200,70 @@ func TestDeleteDeployment(t *testing.T) {
 }
 
 func TestGetDeployment(t *testing.T) {
-       namespace := "test1"
-       name := "mock-deployment"
        testCases := []struct {
                label          string
-               input          string
+               input          map[string]string
                clientOutput   *appsV1.Deployment
                expectedResult string
+               expectedError  string
        }{
                {
                        label: "Sucessfully get an existing deployment",
-                       input: name,
+                       input: map[string]string{"name": "test-deployment", "namespace": "test-namespace"},
                        clientOutput: &appsV1.Deployment{
                                ObjectMeta: metaV1.ObjectMeta{
-                                       Name:      name,
-                                       Namespace: namespace,
+                                       Name:      "test-deployment",
+                                       Namespace: "test-namespace",
                                },
                        },
-                       expectedResult: name,
+                       expectedResult: "test-deployment",
+               },
+               {
+                       label: "Sucessfully get an existing deployment from default namespaces",
+                       input: map[string]string{"name": "test-deployment", "namespace": ""},
+                       clientOutput: &appsV1.Deployment{
+                               ObjectMeta: metaV1.ObjectMeta{
+                                       Name:      "test-deployment",
+                                       Namespace: "default",
+                               },
+                       },
+                       expectedResult: "test-deployment",
+               },
+               {
+                       label: "Fail to get an non-existing namespace",
+                       input: map[string]string{"name": "test-name", "namespace": "test-namespace"},
+                       clientOutput: &appsV1.Deployment{
+                               ObjectMeta: metaV1.ObjectMeta{
+                                       Name:      "test-deployment",
+                                       Namespace: "default",
+                               },
+                       },
+                       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)
+                               }
                        }
                })
        }