Adding Unit Test cases

Signed-off-by: wahidw <abdulwahid.w@nokia.com>
Change-Id: I59bbfd0bb503a3cdaa472f22febfc4d635b66701

diff --git a/pkg/cm/cm_test.go b/pkg/cm/cm_test.go
index 6c98645..44a0c83 100755 (executable)
--- a/pkg/cm/cm_test.go
+++ b/pkg/cm/cm_test.go
@@ -498,6 +498,7 @@ func TestGetNamesFromHelmRepoFailure(t *testing.T) {
        helmExecRetOut = helmSearchOutput
        helmExecRetErr = errors.New("Command failed!")
 
+       EnvHelmVersion = "3"
        names := NewCM().GetNamesFromHelmRepo()
        if names != nil {
                t.Errorf("GetNamesFromHelmRepo failed: expected %v, got %v", expectedResult, names)

diff --git a/pkg/helm/helm_test.go b/pkg/helm/helm_test.go
index 1f54c29..48462c9 100755 (executable)
--- a/pkg/helm/helm_test.go
+++ b/pkg/helm/helm_test.go
@@ -27,6 +27,7 @@ import (
         "strconv"
         "strings"
         "testing"
+       "github.com/stretchr/testify/assert"
         "gerrit.o-ran-sc.org/r/ric-plt/appmgr/pkg/cm"
         "gerrit.o-ran-sc.org/r/ric-plt/appmgr/pkg/appmgr"
         "gerrit.o-ran-sc.org/r/ric-plt/appmgr/pkg/models"
@@ -141,11 +142,12 @@ var kubeServiceOutput = `{
     }
 }`
 
+
 // Test cases
 func TestMain(m *testing.M) {
         appmgr.Init()
         appmgr.Logger.SetLevel(0)
-
+       
         code := m.Run()
         os.Exit(code)
 }
@@ -156,7 +158,6 @@ func TestInit(t *testing.T) {
         helmExec = mockedHelmExec
 
         NewHelm().Init()
-
         if cm.EnvHelmVersion == cm.HELM_VERSION_2{
                 expectedHelmCommand = "init -c --skip-refresh"
                 if caughtHelmExecArgs != expectedHelmCommand {
@@ -189,6 +190,45 @@ func TestAddRepoSuccess(t *testing.T) {
         if !strings.Contains(caughtHelmExecArgs, "repo add") {
                 t.Errorf("AddRepo failed: expected %v, got %v", "repo add", caughtHelmExecArgs)
         }
+       NewHelm().initDone = true
+       NewHelm().Initialize()
+}
+
+func TestFuncsWithHelmv3(t *testing.T){
+       var err error
+       name := "dymmy-xapp"
+
+       if err = os.Setenv("HELMVERSION", "3"); err != nil { 
+               t.Logf("Tiller Env Setting Failed: %v", err.Error())      
+       }           
+       helm := NewHelm()
+       
+        xapp, err := helm.Status(name)
+        if err == nil {
+                t.Logf("Status returned: %v", err)
+        }
+        xapp2, err := helm.Delete(name)
+        if err != nil {
+               assert.NotEqual(t, err, "Error: release: not found")            
+        }else{
+               t.Logf("xapp : %+v, Xapp2 : %+v",xapp,xapp2)
+       }
+       helm.Init()
+       
+       if version := helm.GetVersion(name); version != "" {
+                t.Logf("GetVersion expected to return empty string, got %v", version)
+        }
+       
+       x := models.XappDescriptor{XappName: &name, Namespace: "ricxapp"}
+       x.OverrideFile = "../../test/dummy-xapp_values.json"
+        if args := helm.GetInstallArgs(x, false); args == "" {
+                t.Logf("GetInstallArgs failed: got %v", args)
+        }
+
+       if err = os.Setenv("HELMVERSION", "2"); err != nil { 
+               t.Logf("after set Tiller Env Setting Failed: %v", err.Error())      
+       }
+ 
 }
 
 func TestAddRepoReturnsErrorIfNoUsernameFile(t *testing.T) {
@@ -258,14 +298,16 @@ func TestStatusSuccess(t *testing.T) {
 
 func TestStatusReturnsErrorIfHelmStatusFails(t *testing.T) {
         name := "dummy-xapp"
-
+       
         defer func() { resetHelmExecMock() }()
         helmExec = mockedHelmExec
         helmExecRetErr = errors.New("some helm command error")
 
         if _, err := NewHelm().Status(name); err == nil {
                 t.Errorf("Status expected to fail but it didn't")
-        }
+        }else{
+               assert.Equal(t, err, helmExecRetErr)            
+       }
 }
 
 func TestParseStatusSuccess(t *testing.T) {
@@ -282,7 +324,7 @@ func TestParseStatusSuccess(t *testing.T) {
         if err != nil {
                 t.Errorf("ParseStatus failed: %v", err)
         }
-
+       
         validateXappModel(t, xapp)
 
         if cm.EnvHelmVersion == cm.HELM_VERSION_2 {
@@ -312,6 +354,14 @@ func TestListSuccess(t *testing.T) {
         if caughtHelmExecArgs != expectedHelmCommand {
                 t.Errorf("List: expected %v, got %v", expectedHelmCommand, caughtHelmExecArgs)
         }
+       
+       var str models.AllDeployableXapps
+       str = NewHelm().SearchAll()     
+       if str != nil {
+               t.Logf("Search end..str : %s\n",str)    
+       }else{
+               assert.Nil(t,str)               
+       }
 }
 
 func TestListReturnsErrorIfHelmListFails(t *testing.T) {
@@ -322,6 +372,7 @@ func TestListReturnsErrorIfHelmListFails(t *testing.T) {
         if _, err := NewHelm().List(); err == nil {
                 t.Errorf("List expected to fail but it didn't")
         }
+
 }
 
 func TestDeleteSuccess(t *testing.T) {
@@ -366,7 +417,7 @@ func TestDeleteReturnsErrorIfHelmStatusFails(t *testing.T) {
 }
 
 func TestFetchSuccessIfCmdArgHasTestSuffix(t *testing.T) {
-        if err := NewHelm().Fetch("kissa", "koira"); err != nil {
+        if err := NewHelm().Fetch("lsfuis", "../../helm_chart/appmgr/values.yaml"); err != nil {
                 t.Errorf("Fetch failed: %v", err)
         }
 }
@@ -417,6 +468,7 @@ func TestGetEndpointInfoSuccess(t *testing.T) {
         kubeExecRetOut = kubeServiceOutput
 
         svc, port := NewHelm().GetEndpointInfo("dummy-xapp")
+       
         expectedSvc := "service-ricxapp-dummy-xapp-rmr.ricxapp"
         if svc != expectedSvc {
                 t.Errorf("GetEndpointInfo failed: expected %v, got %v", expectedSvc, svc)
@@ -491,8 +543,17 @@ func TestGetNamesSuccess(t *testing.T) {
         }
 }
 
+func TestGetNamesFail(t *testing.T) {
+        names, err := NewHelm().GetNames("helListAll")
+        if err != nil {
+                t.Errorf("GetNames failed: %v", err)
+        }
+        if reflect.DeepEqual(names, []string{"dummy-xapp", "dummy-xapp2"}) {
+                t.Errorf("GetNames succ")
+        }
+}
 func TestAddTillerEnv(t *testing.T) {
-        if NewHelm().AddTillerEnv() != nil {
+        if err := NewHelm().AddTillerEnv(); err != nil {
                 t.Errorf("AddTillerEnv failed!")
         }
 }

diff --git a/pkg/resthooks/resthooks_test.go b/pkg/resthooks/resthooks_test.go
index e9ab68a..d2120c2 100755 (executable)
--- a/pkg/resthooks/resthooks_test.go
+++ b/pkg/resthooks/resthooks_test.go
@@ -30,7 +30,6 @@ import (
        "net/http/httptest"
        "os"
        "time"
-
        "strconv"
        "testing"
 
@@ -50,6 +49,7 @@ func TestMain(m *testing.M) {
 
        mockedSdl = new(SdlMock)
        mockedSdl2 = new(SdlMock)
+       NewResthook(false)
        rh = createResthook(false, mockedSdl,mockedSdl2)
        code := m.Run()
        os.Exit(code)
@@ -269,6 +269,211 @@ func TestTeardown(t *testing.T) {
        rh.FlushSubscriptions()
 }
 
+func TestUpdateAppDataFail1(t *testing.T) {
+       var reg models.RegisterRequest
+       var tEndpoint string = "10.104.237.59"
+       reg.HTTPEndpoint = &tEndpoint
+       rh.UpdateAppData(reg, false)
+}
+
+func TestUpdateAppDataFail2(t *testing.T) {
+       var mockSdlRetOk error
+       var params models.RegisterRequest
+
+       mSdl := new(SdlMock)
+       mSdl2 := new(SdlMock)
+       mockSdlRetNok := errors.New("some SDL error")
+       var tEndpoint1 string = "10.104.237.59:8087"
+       params.HTTPEndpoint = &tEndpoint1
+       serializedSubsReq2, err := json.Marshal(params)
+       if err != nil {
+               t.Logf("error in marshal .. %v", err)
+       }
+
+       subsReq := createSubscription(models.EventTypeCreated, int64(5), int64(10), "http://localhost:8087/xapps_hook")
+       serializedSubsReq, err := json.Marshal(subsReq)
+       assert.Nil(t, err)
+
+       key := "key-1"
+       value := "endpoints"
+       mockSdlGetRetVal := make(map[string]interface{})
+       mockSdlGetRetVal[key] = serializedSubsReq
+
+       mockSdlGetRetVal2 := make(map[string]interface{})
+       mockSdlGetRetVal2[value] = serializedSubsReq2
+       mSdl.On("GetAll").Return([]string{key}, mockSdlRetOk).Twice()
+       mSdl.On("Get", []string{key}).Return(mockSdlGetRetVal, mockSdlRetNok).Once()
+       mSdl2.On("Get", []string{value}).Return(mockSdlGetRetVal2, mockSdlRetOk).Once()
+
+       restHook := createResthook(false, mSdl,mSdl2)
+
+       mSdl2.On("Get", []string{value}).Return(mockSdlGetRetVal2, mockSdlRetOk).Once()
+
+       ret := restHook.GetAppsInSDL()
+       if ret == nil {
+               assert.Nil(t, ret)
+       }
+}
+
+func TestGetAppsInSDLFail3(t *testing.T) {
+       var mockSdlRetOk error
+       var params models.RegisterRequest
+
+       mSdl := new(SdlMock)
+       mSdl2 := new(SdlMock)
+       mockSdlRetNok := errors.New("some SDL error")
+
+       serializedSubsReq1, err := json.Marshal(params)
+       if err != nil {
+               t.Logf("error in marshal .. %v", err)
+       }
+
+       subsReq := createSubscription(models.EventTypeCreated, int64(5), int64(10), "http://localhost:8087/xapps_hook")
+       serializedSubsReq, err := json.Marshal(subsReq)
+       assert.Nil(t, err)
+
+       key := "key-1"
+       value := "endpoints"
+       mockSdlGetRetVal := make(map[string]interface{})
+       mockSdlGetRetVal[key] = serializedSubsReq
+
+       mockSdlGetRetVal1 := make(map[string]interface{})
+       mockSdlGetRetVal1[key] = serializedSubsReq1
+
+       mSdl.On("GetAll").Return([]string{key}, mockSdlRetOk).Twice()
+       mSdl.On("Get", []string{key}).Return(mockSdlGetRetVal, mockSdlRetNok).Once()
+       mSdl2.On("Get", []string{value}).Return(mockSdlGetRetVal1, mockSdlRetOk).Once()
+
+       restHook := createResthook(false, mSdl,mSdl2)
+
+       mSdl2.On("Get", []string{value}).Return(mockSdlGetRetVal1, mockSdlRetOk).Once()
+       ret2 := restHook.GetAppsInSDL()
+       if ret2 != nil {
+               t.Logf("SDL Returning: %s \n",*ret2)
+       }else{
+               assert.Nil(t, ret2)
+       }
+}
+
+func TestUpdateAppDataSucc(t *testing.T) {
+       var mockSdlRetOk error
+       var params models.RegisterRequest
+
+       mSdl := new(SdlMock)
+       mSdl2 := new(SdlMock)
+       mockSdlRetNok := errors.New("some SDL error")
+
+       var tEndpoint1 string = "10.104.237.59:8087"
+       params.HTTPEndpoint = &tEndpoint1
+       serializedSubsReq1, err := json.Marshal(params)
+       if err != nil {
+               t.Logf("error in marshal .. %v", err)
+       }
+       subsReq := createSubscription(models.EventTypeCreated, int64(5), int64(10), "http://localhost:8087/xapps_hook")
+       serializedSubsReq, err := json.Marshal(subsReq)
+       assert.Nil(t, err)
+
+       key := "key-1"
+       value := "endpoints"
+       mockSdlGetRetVal := make(map[string]interface{})
+       mockSdlGetRetVal[key] = serializedSubsReq
+
+       mockSdlGetRetVal1 := make(map[string]interface{})
+       mockSdlGetRetVal1[key] = serializedSubsReq1
+
+       mSdl.On("GetAll").Return([]string{key}, mockSdlRetOk).Twice()
+       mSdl.On("Get", []string{key}).Return(mockSdlGetRetVal, mockSdlRetNok).Once()
+       mSdl2.On("Get", []string{value}).Return(mockSdlGetRetVal1, mockSdlRetOk).Once()
+
+       restHook := createResthook(false, mSdl,mSdl2)
+
+       mSdl2.On("Get", []string{value}).Return(mockSdlGetRetVal1, mockSdlRetOk).Once()
+       mSdl2.On("Set", mock.Anything).Return(mockSdlRetOk)
+       restHook.UpdateAppData(params, true)
+}
+
+func TestUpdateAppDataSucc1(t *testing.T) {
+       var mockSdlRetOk error
+       var params models.RegisterRequest
+
+       mSdl := new(SdlMock)
+       mSdl2 := new(SdlMock)
+       mockSdlRetNok := errors.New("some SDL error")
+
+       var tEndpoint1 string = "10.104.237.59:8087"
+       params.HTTPEndpoint = &tEndpoint1
+       appsindb := []string{ "10.104.237.59:8088 " , " ", " "," 10.104.237.59:8087"}
+       serializedSubsReq1, err := json.Marshal(appsindb)
+       if err != nil {
+               t.Logf("error in marshal .. %v", err)
+       }
+       subsReq := createSubscription(models.EventTypeCreated, int64(5), int64(10), "http://localhost:8087/xapps_hook")
+       serializedSubsReq, err := json.Marshal(subsReq)
+       assert.Nil(t, err)
+
+       key := "key-1"
+       value := "endpoints"
+       mockSdlGetRetVal := make(map[string]interface{})
+       mockSdlGetRetVal[key] = serializedSubsReq
+
+       mockSdlGetRetVal1 := make(map[string]interface{})
+       mockSdlGetRetVal1[value] = serializedSubsReq1
+
+       mSdl.On("GetAll").Return([]string{key}, mockSdlRetOk).Twice()
+       mSdl.On("Get", []string{key}).Return(mockSdlGetRetVal, mockSdlRetNok).Once()
+       mSdl2.On("Get", []string{value}).Return(mockSdlGetRetVal1, mockSdlRetOk).Once()
+
+       restHook := createResthook(false, mSdl,mSdl2)
+
+       mSdl2.On("Get", []string{value}).Return(mockSdlGetRetVal1, mockSdlRetOk).Once()
+       mSdl2.On("Set", []string{value}).Return(mockSdlRetOk).Twice()
+
+       mSdl2.On("Remove").Return(mockSdlRetOk)
+       mSdl2.On("Set", mock.Anything).Return(mockSdlRetOk)
+       restHook.UpdateAppData(params, true)
+}
+
+
+func TestUpdateAppDataSucc2(t *testing.T) {
+       var mockSdlRetOk error
+       var params models.RegisterRequest
+
+       mSdl := new(SdlMock)
+       mSdl2 := new(SdlMock)
+       mockSdlRetNok := errors.New("some SDL error")
+
+       var tEndpoint1 string = "10.104.237.59:8087"
+       params.Config = "/temp/config.yaml"
+       params.HTTPEndpoint = &tEndpoint1
+       serializedSubsReq1, err := json.Marshal(tEndpoint1)
+       if err != nil {
+               t.Logf("error in marshal .. %v", err)
+       }
+       subsReq := createSubscription(models.EventTypeCreated, int64(5), int64(10), "http://localhost:8087/xapps_hook")
+       serializedSubsReq, err := json.Marshal(subsReq)
+       assert.Nil(t, err)
+
+       key := "key-1"
+       value := "endpoints"
+       mockSdlGetRetVal := make(map[string]interface{})
+       mockSdlGetRetVal[key] = serializedSubsReq
+
+       mockSdlGetRetVal1 := make(map[string]interface{})
+       mockSdlGetRetVal1[value] = serializedSubsReq1
+
+       mSdl.On("GetAll").Return([]string{key}, mockSdlRetOk).Twice()
+       mSdl.On("Get", []string{key}).Return(mockSdlGetRetVal, mockSdlRetNok).Once()
+       mSdl2.On("Get", []string{value}).Return(mockSdlGetRetVal1, mockSdlRetOk).Once()
+
+       restHook := createResthook(false, mSdl,mSdl2)
+
+       mSdl2.On("Get", []string{value}).Return(mockSdlGetRetVal1, mockSdlRetOk).Once()
+       mSdl2.On("Set", []string{value}).Return(mockSdlRetOk).Twice()
+
+       mSdl2.On("Remove").Return(mockSdlRetOk)
+       mSdl2.On("Set", mock.Anything).Return(mockSdlRetOk)
+       restHook.UpdateAppData(params, true)
+}
 func createSubscription(et models.EventType, maxRetries, retryTimer int64, targetUrl string) models.SubscriptionRequest {
        return models.SubscriptionRequest{&models.SubscriptionData{et, &maxRetries, &retryTimer, &targetUrl}}
 }
@@ -334,6 +539,20 @@ func (m *SdlMock) expectDbSet(t *testing.T, subsReq models.SubscriptionRequest,
                }).Return(mockRet).Once()
 }
 
+func TestPublishSubscription(t *testing.T) {
+       sub := createSubscription(models.EventTypeCreated, int64(2), int64(1), "http://localhost:8087/xapps_hook")
+       resp := rh.AddSubscription(sub)
+
+       xapp := getDummyXapp()
+
+       v, ok := rh.subscriptions.Get(resp.ID)
+       assert.True(t, ok)
+       if v == nil {
+               t.Logf("value : %+v",v) 
+       }
+       rh.PublishSubscription(xapp,models.EventTypeUndeployed)
+}
+
 type SdlMock struct {
        mock.Mock
 }