Added E2M UT Improvemnet TestCases

Change-Id: I1cb7270c27dca140327f409002ecc8dfccc68263
Signed-off-by: dhirajverma <dhiraj.verma@nokia.com>

diff --git a/E2Manager/handlers/httpmsghandlers/add_enb_request_handler_test.go b/E2Manager/handlers/httpmsghandlers/add_enb_request_handler_test.go
new file mode 100644 (file)
index 0000000..a7bfab3
--- /dev/null
+++ b/E2Manager/handlers/httpmsghandlers/add_enb_request_handler_test.go
@@ -0,0 +1,80 @@
+package httpmsghandlers
+
+import (
+    "e2mgr/configuration"
+    "e2mgr/managers"
+    "e2mgr/mocks"
+    "e2mgr/models"
+    "e2mgr/services"
+    "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
+    "github.com/stretchr/testify/assert"
+    "testing"
+)
+
+func setupAddEnbRequestHandlerTest(t *testing.T) (*AddEnbRequestHandler, *mocks.RnibReaderMock, *mocks.RnibWriterMock) {
+    log := initLog(t)
+    config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3}
+    readerMock := &mocks.RnibReaderMock{}
+    writerMock := &mocks.RnibWriterMock{}
+    rnibDataService := services.NewRnibDataService(log, config, readerMock, writerMock)
+    ranListManager := managers.NewRanListManager(log, rnibDataService)
+    nodebValidator := managers.NewNodebValidator()
+    handler := NewAddEnbRequestHandler(log,rnibDataService,nodebValidator, ranListManager)
+    return handler, readerMock, writerMock
+}
+
+func CreateNodebInfoTest(t *testing.T,RanName string,  connectionStatus entities.ConnectionStatus) *entities.NodebInfo{
+
+        setupRequest := &models.E2SetupRequestMessage{}
+        nodebInfo := &entities.NodebInfo{
+                RanName:                      RanName,
+                SetupFromNetwork:             true,
+                NodeType:                     entities.Node_GNB,
+                ConnectionStatus:                         connectionStatus,
+                Configuration: &entities.NodebInfo_Gnb{
+                        Gnb: &entities.Gnb{
+                                GnbType:      entities.GnbType_GNB,
+                                RanFunctions: setupRequest.ExtractRanFunctionsList(),
+                        },
+                },
+                GlobalNbId: &entities.GlobalNbId{
+                        PlmnId: setupRequest.GetPlmnId(),
+                        NbId:   setupRequest.GetNbId(),
+                },
+        }
+        return nodebInfo
+}
+
+func TestGlobalNbIdValid(t *testing.T){
+        globalNbId := &entities.GlobalNbId{}
+        res :=  isGlobalNbIdValid(globalNbId)
+        assert.NotNil(t,res)
+
+}
+
+func TestHandleAddEnbSuccess(t *testing.T) {
+        handler, readerMock, writerMock := setupAddEnbRequestHandlerTest(t)
+        ranName := "ran1"
+        var rnibError error
+        nodebInfo := &entities.NodebInfo{RanName: ranName, NodeType: entities.Node_ENB}
+        readerMock.On("GetNodeb", ranName).Return(nodebInfo, rnibError)
+        //writerMock.On("AddNbIdentity", entities.Node_ENB, nbIdentity).Return(nil)
+        writerMock.On("AddEnb", nodebInfo).Return(nil)
+        writerMock.On("AddNbIdentity", entities.Node_ENB, &entities.NbIdentity{InventoryName: "ran1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}).Return(nil)
+        addEnbRequest := &models.AddEnbRequest{RanName: ranName}
+        result, err := handler.Handle(addEnbRequest)
+        assert.NotNil(t, err)
+        assert.Nil(t, result)
+}
+
+func TestValidateRequestBody(t *testing.T){
+     handler, _,_  := setupAddEnbRequestHandlerTest(t)
+     
+     ranName := "ran1"
+     addEnbRequest := &models.AddEnbRequest{RanName: ranName}
+     err := handler.validateRequestBody(addEnbRequest)
+     assert.NotNil(t,err)
+     }
+
+
+

diff --git a/E2Manager/handlers/httpmsghandlers/update_nodeb_request_handler_test.go b/E2Manager/handlers/httpmsghandlers/update_nodeb_request_handler_test.go
new file mode 100644 (file)
index 0000000..26bf3a6
--- /dev/null
+++ b/E2Manager/handlers/httpmsghandlers/update_nodeb_request_handler_test.go
@@ -0,0 +1,37 @@
+package httpmsghandlers
+
+import (
+    "e2mgr/configuration"
+    "e2mgr/managers"
+    "e2mgr/mocks"
+    "e2mgr/logger"
+    "e2mgr/models"
+    "e2mgr/services"
+ //   "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
+    "github.com/stretchr/testify/assert"
+    "testing"
+)
+
+func setupUpdateNodebRequestHandlerTest(t *testing.T) ( *UpdateNodebRequestHandler,  *mocks.RnibReaderMock, *mocks.RnibWriterMock){
+        logger, err := logger.InitLogger(logger.DebugLevel)
+        if err != nil {
+                t.Errorf("#... - failed to initialize logger, error: %s", err)
+        }
+        config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3}
+        readerMock := &mocks.RnibReaderMock{}
+        writerMock := &mocks.RnibWriterMock{}
+        rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock)
+        updateNodebManager := managers.IUpdateNodebManager(nil)
+        handler := NewUpdateNodebRequestHandler(logger,rnibDataService,updateNodebManager)
+        return handler,readerMock, writerMock
+
+}
+
+func TestGetRanName(t *testing.T) {
+        handler,_,_ := setupUpdateNodebRequestHandlerTest(t)
+        updateEnbRequest := models.UpdateEnbRequest{}
+        ret := handler.getRanName(updateEnbRequest)
+        assert.Equal(t, "", ret )
+}
+
+

diff --git a/E2Manager/managers/nodeb_validator_test.go b/E2Manager/managers/nodeb_validator_test.go
new file mode 100644 (file)
index 0000000..4bc84a2
--- /dev/null
+++ b/E2Manager/managers/nodeb_validator_test.go
@@ -0,0 +1,95 @@
+package managers
+
+import (
+       /* "e2mgr/configuration"
+        "e2mgr/logger"
+        "e2mgr/mocks"
+        "e2mgr/services"
+        "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
+       */
+        "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
+        //"github.com/pkg/errors"
+        "github.com/stretchr/testify/assert"
+        "testing"
+)
+
+func initNodebValidatorTest(t *testing.T)(*NodebValidator){
+      nodebValidator := NewNodebValidator()
+      return nodebValidator
+}
+
+func TestIsGnbValid(t *testing.T){
+     nodebValidator := initNodebValidatorTest(t)
+     gnb := entities.Gnb{}
+     res := nodebValidator.IsGnbValid(&gnb)
+     assert.NotNil(t,res)
+}
+
+
+func TestIsEnbValid(t *testing.T){
+     nodebValidator := initNodebValidatorTest(t)
+     enb := entities.Enb{}
+     res := nodebValidator.IsEnbValid(&enb)
+     assert.NotNil(t,res)
+}
+
+func TestIsServedNrCellInformationValid(t *testing.T){
+        servedNrCellInformation :=  entities.ServedNRCellInformation{}
+        err := isServedNrCellInformationValid(&servedNrCellInformation)
+        assert.NotNil(t,err)
+}
+
+func TestIsServedNrCellInfoTddValid(t *testing.T){
+        tdd := entities.ServedNRCellInformation_ChoiceNRMode_TddInfo{}
+        err := isServedNrCellInfoTddValid(&tdd)
+        assert.Nil(t,err)
+}
+
+func TestIsServedNrCellInfoFddValid(t *testing.T){
+        fdd := entities.ServedNRCellInformation_ChoiceNRMode_TddInfo{}
+        err := isServedNrCellInfoTddValid(&fdd)
+        assert.Nil(t,err)
+}
+
+func TestIsNrNeighbourInfoTddValid(t *testing.T){
+        tdd := entities.NrNeighbourInformation_ChoiceNRMode_TddInfo{}
+        err := isNrNeighbourInfoTddValid(&tdd)
+        assert.Nil(t,err)
+}
+
+func TestIsNrNeighbourInfoFddValid(t *testing.T){
+        fdd := entities.NrNeighbourInformation_ChoiceNRMode_FddInfo{}
+        err := isNrNeighbourInfoFddValid(&fdd)
+        assert.Nil(t,err)
+}
+
+func TestIsTddInfoValid(t *testing.T){
+        tdd := entities.TddInfo{}
+        err := isTddInfoValid(&tdd)
+        assert.Nil(t,err)
+}
+
+func TestIsFddInfoValid(t *testing.T){
+        fdd := entities.FddInfo{}
+        err := isFddInfoValid(&fdd)
+        assert.Nil(t,err)
+}
+
+func TestIsServedNrCellInfoChoiceNrModeValid(t *testing.T){
+        choiceNrMode := entities.ServedNRCellInformation_ChoiceNRMode{}
+        res := isServedNrCellInfoChoiceNrModeValid(&choiceNrMode)
+        assert.NotNil(t,res)
+}
+
+func  TestIsNrNeighbourInformationValid(t *testing.T){
+        nrNeighbourInformation := entities.NrNeighbourInformation{}
+        res := isNrNeighbourInformationValid(&nrNeighbourInformation)
+        assert.NotNil(t,res)
+}
+
+func TestIsNrNeighbourInfoChoiceNrModeValid(t *testing.T){
+        choiceNrMode := entities.NrNeighbourInformation_ChoiceNRMode{}
+        res := isNrNeighbourInfoChoiceNrModeValid(&choiceNrMode)
+        assert.NotNil(t,res)
+}
+

diff --git a/E2Manager/managers/ran_list_manager_test.go b/E2Manager/managers/ran_list_manager_test.go
index 87eb8a7..a729f06 100644 (file)
--- a/E2Manager/managers/ran_list_manager_test.go
+++ b/E2Manager/managers/ran_list_manager_test.go
@@ -59,4 +59,52 @@ func TestRanListManagerInstance_InitNbIdentityMapFailure(t *testing.T) {
        readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{}, common.NewInternalError(errors.New("#reader.GetListNodebIds - Internal Error")))
        err := ranListManager.InitNbIdentityMap()
        assert.NotNil(t, err)
-}
\ No newline at end of file
+}
+
+func TestRanListManagerInstance_AddNbIdentitySuccess(t *testing.T) {
+        _,writerMock, ranListManager := initRanListManagerTest(t)
+        //readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{{InventoryName: RanName, GlobalNbId: &entities.GlobalNbId{NbId: "asd", PlmnId: "efg"}, ConnectionStatus: entities.ConnectionStatus_CONNECTED}}, nil)
+        nbIdentity :=  &entities.NbIdentity{}
+        writerMock.On("AddNbIdentity", entities.Node_ENB, nbIdentity).Return(nil)
+        nodetype := entities.Node_ENB
+        err := ranListManager.AddNbIdentity(nodetype,nbIdentity)
+        assert.Nil(t, err)
+}
+
+
+func TestRanListManagerInstance_RemoveNbIdentitySuccess(t *testing.T) {
+        _,writerMock, ranListManager := initRanListManagerTest(t)
+        ranName := "ran1"
+        writerMock.On("RemoveNbIdentity", entities.Node_ENB,"ran1" ).Return(nil)
+        nodetype := entities.Node_ENB
+        err := ranListManager.RemoveNbIdentity(nodetype,ranName)
+        assert.Nil(t, err)
+}
+
+func TestRanListManagerInstance_GetNbIdentity(t *testing.T) {
+       _,writerMock,ranListManager := initRanListManagerTest(t)
+       ranName := "ran1"
+       nbIdentity := &entities.NbIdentity{}
+       writerMock.On("GetNbIdentity", entities.Node_ENB, nbIdentity).Return(nil)
+       err,nb := ranListManager.GetNbIdentity(ranName)
+       assert.NotNil(t, nb)
+       assert.Nil(t,err)
+}
+
+func TestRanListManagerInstance_GetNbIdentityList(t *testing.T) {
+       _,writerMock,ranListManager := initRanListManagerTest(t)
+       writerMock.On("GetNbIdentityList").Return(nil)
+       Ids := ranListManager.GetNbIdentityList()
+       assert.NotNil(t, Ids)
+}
+
+
+func TestRanListManagerInstance_UpdateNbIdentities(t *testing.T) {
+        _,writerMock,ranListManager := initRanListManagerTest(t)
+        nodeType := entities.Node_ENB
+        oldNbIdentities := []*entities.NbIdentity{}
+        newNbIdentities := []*entities.NbIdentity{}
+        writerMock.On("UpdateNbIdentities",entities.Node_ENB,oldNbIdentities,newNbIdentities).Return(nil)
+        res := ranListManager.UpdateNbIdentities(nodeType, oldNbIdentities, newNbIdentities)
+        assert.Nil(t, res)
+}

diff --git a/E2Manager/managers/update_enb_manager_test.go b/E2Manager/managers/update_enb_manager_test.go
new file mode 100644 (file)
index 0000000..1932cb3
--- /dev/null
+++ b/E2Manager/managers/update_enb_manager_test.go
@@ -0,0 +1,72 @@
+package managers
+
+import (
+        "e2mgr/configuration"
+        "e2mgr/logger"
+        "e2mgr/services"
+        "e2mgr/mocks"
+        "e2mgr/models"
+        "testing"
+        "github.com/stretchr/testify/assert"
+        "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
+)
+func initUpdateEnbManagerTest(t *testing.T) (*UpdateEnbManager, *logger.Logger, services.RNibDataService, *NodebValidator) {
+        logger, err := logger.InitLogger(logger.DebugLevel)
+        if err != nil {
+                t.Errorf("#... - failed to initialize logger, error: %s", err)
+        }
+        config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3}
+        //rmrMessengerMock := &mocks.RmrMessengerMock{}
+        readerMock := &mocks.RnibReaderMock{}
+        writerMock := &mocks.RnibWriterMock{}
+        nodebValidator := NewNodebValidator()
+        rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock)
+        UpdateEnbManager := NewUpdateEnbManager(logger, rnibDataService, nodebValidator)
+        return UpdateEnbManager, logger, rnibDataService, nodebValidator
+}
+
+func TestSuccessfulSetNodeb(t *testing.T) {
+        UpdateEnbManager,_,_, _ := initUpdateEnbManagerTest(t)
+        nodebInfo := &entities.NodebInfo{}
+        writerMock := &mocks.RnibWriterMock{}
+        writerMock.On("SetNodeb", nodebInfo).Return(nil)
+        updateEnbRequest := &models.UpdateEnbRequest{}
+        UpdateEnbManager.SetNodeb(nodebInfo,updateEnbRequest)
+        //writerMock.AssertNumberOfCalls(t, "SaveNodeb", 1)
+}
+
+func TestValidateRequestBody(t *testing.T) {
+        UpdateEnbManager,_,_, _ := initUpdateEnbManagerTest(t)
+        //nodebInfo := &entities.NodebInfo{}
+        //writerMock := &mocks.RnibWriterMock{}
+        //writerMock.On("UpdateNodeb", nodebInfo).Return(nil)
+        updateEnbRequest := &models.UpdateEnbRequest{}
+        res := UpdateEnbManager.validateRequestBody(updateEnbRequest)
+        assert.NotNil(t, res)
+}
+
+
+func TestValidateNodeb(t *testing.T) {
+      UpdateEnbManager,_,_, _ := initUpdateEnbManagerTest(t)
+      nodebInfo := &entities.NodebInfo{}
+      res := UpdateEnbManager.ValidateNodeb(nodebInfo)
+      assert.Nil(t, res) 
+}
+
+func TestValidate(t *testing.T) {
+      UpdateEnbManager,_,_, _ := initUpdateEnbManagerTest(t)
+      //nodebInfo := &entities.NodebInfo{}
+      updateEnbRequest := &models.UpdateEnbRequest{}
+      res :=UpdateEnbManager.Validate(updateEnbRequest)
+      assert.NotNil(t, res)
+}
+
+func TestRemoveNodebCells(t *testing.T) {
+      UpdateEnbManager,_,_, _ := initUpdateEnbManagerTest(t)
+      nodebInfo := &entities.NodebInfo{}
+      //updateEnbRequest := &models.UpdateEnbRequest{}
+      res :=UpdateEnbManager.RemoveNodebCells(nodebInfo)
+      assert.NotNil(t, res)
+     
+}
+

diff --git a/E2Manager/managers/update_gnb_manager_test.go b/E2Manager/managers/update_gnb_manager_test.go
new file mode 100644 (file)
index 0000000..56c02d4
--- /dev/null
+++ b/E2Manager/managers/update_gnb_manager_test.go
@@ -0,0 +1,44 @@
+package managers
+
+import (
+        "e2mgr/configuration"
+        "e2mgr/logger"
+        "e2mgr/services"
+        "e2mgr/mocks"
+        //"e2mgr/models"
+        "testing"
+        "github.com/stretchr/testify/assert"
+        "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
+)
+func initUpdateGnbManagerTest(t *testing.T) (*UpdateGnbManager, *logger.Logger, services.RNibDataService, *NodebValidator) {
+        logger, err := logger.InitLogger(logger.DebugLevel)
+        if err != nil {
+                t.Errorf("#... - failed to initialize logger, error: %s", err)
+        }
+        config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3}
+        //rmrMessengerMock := &mocks.RmrMessengerMock{}
+        readerMock := &mocks.RnibReaderMock{}
+        writerMock := &mocks.RnibWriterMock{}
+        nodebValidator := NewNodebValidator()
+        rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock)
+        UpdateGnbManager := NewUpdateGnbManager(logger, rnibDataService, nodebValidator)
+        return UpdateGnbManager, logger, rnibDataService, nodebValidator
+}
+
+func TestRemoveNodebCellsGnb(t *testing.T) {
+      UpdateGnbManager,_,_, _ := initUpdateGnbManagerTest(t)
+      nodebInfo := &entities.NodebInfo{}
+      //updateEnbRequest := &models.UpdateEnbRequest{}
+      res :=UpdateGnbManager.RemoveNodebCells(nodebInfo)
+      assert.NotNil(t, res)
+}
+
+func TestValidateNodebGnb(t *testing.T) {
+      UpdateGnbManager,_,_, _ := initUpdateGnbManagerTest(t)
+      nodebInfo := &entities.NodebInfo{}
+      res := UpdateGnbManager.ValidateNodeb(nodebInfo)
+      assert.Nil(t, res)
+}
+
+
+

diff --git a/E2Manager/managers/x2_setup_response_manager_test.go b/E2Manager/managers/x2_setup_response_manager_test.go
new file mode 100644 (file)
index 0000000..e7c515f
--- /dev/null
+++ b/E2Manager/managers/x2_setup_response_manager_test.go
@@ -0,0 +1,39 @@
+package managers
+
+import (
+        "e2mgr/converters"
+        "e2mgr/tests"
+        "fmt"
+        "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
+        "github.com/stretchr/testify/assert"
+        "testing"
+)
+
+func TestPopulateX2NodebPduSuccess(t *testing.T) {
+        logger := tests.InitLog(t)
+        nodebInfo := &entities.NodebInfo{}
+        nodebIdentity := &entities.NbIdentity{}
+        handler := NewX2SetupResponseManager(converters.NewX2SetupResponseConverter(logger))
+        err := handler.PopulateNodebByPdu(logger, nodebIdentity, nodebInfo, createRandomPayload())
+        assert.NotNil(t, err)
+}
+
+func TestPopulateX2NodebPduFailure(t *testing.T) {
+        logger := tests.InitLog(t)
+        nodebInfo := &entities.NodebInfo{}
+        nodebIdentity := &entities.NbIdentity{}
+        handler := NewX2SetupResponseManager(converters.NewX2SetupResponseConverter(logger))
+        err := handler.PopulateNodebByPdu(logger, nodebIdentity, nodebInfo, createX2SetupResponsePayload(t))
+        assert.Nil(t, err)
+}
+func createX2SetupResponsePayload(t *testing.T) []byte {
+        packedPdu := "4006001a0000030005400200000016400100001140087821a00000008040"
+        var payload []byte
+        _, err := fmt.Sscanf(packedPdu, "%x", &payload)
+        if err != nil {
+                t.Errorf("convert inputPayloadAsStr to payloadAsByte. Error: %v\n", err)
+        }
+        return payload
+}
+
+

diff --git a/E2Manager/rmrCgo/rmrCgoApi_test.go b/E2Manager/rmrCgo/rmrCgoApi_test.go
index 77ccb33..b68aef6 100644 (file)
--- a/E2Manager/rmrCgo/rmrCgoApi_test.go
+++ b/E2Manager/rmrCgo/rmrCgoApi_test.go
@@ -136,3 +136,21 @@ func initLog(t *testing.T) *logger.Logger {
        }
        return log
 }
+
+func TestString(t *testing.T){
+      var msgSrc unsafe.Pointer
+      msg := rmrCgo.NewMBuf(tests.MessageType, len(tests.DummyPayload), "RanName", &tests.DummyPayload, &tests.DummyXAction, msgSrc)
+      ret := msg.String()
+      assert.NotNil(t,ret)
+}
+
+
+func TestGetMsgSrc(t *testing.T){
+      var msgSrc unsafe.Pointer
+      msg := rmrCgo.NewMBuf(tests.MessageType, len(tests.DummyPayload), "RanName", &tests.DummyPayload, &tests.DummyXAction, msgSrc)
+      ret := msg.GetMsgSrc()
+      assert.NotNil(t,ret)
+}
+
+
+

diff --git a/E2Manager/services/ran_alarm_service_test.go b/E2Manager/services/ran_alarm_service_test.go
new file mode 100644 (file)
index 0000000..b3d6274
--- /dev/null
+++ b/E2Manager/services/ran_alarm_service_test.go
@@ -0,0 +1,30 @@
+package services
+
+import (
+        "e2mgr/configuration"
+        "e2mgr/logger"
+        "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
+        "testing"
+        "github.com/stretchr/testify/assert"
+)
+
+
+func RanAlarmServiceTest(t *testing.T) (RanAlarmService, *logger.Logger, *configuration.Configuration) {
+
+    logger, err := logger.InitLogger(logger.DebugLevel)
+        if err != nil {
+                t.Errorf("#... - failed to initialize logger, error: %s", err)
+        }
+    config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3}
+    ranAlarmServiceInstance := NewRanAlarmService(logger , config)
+    return ranAlarmServiceInstance,logger, config
+}
+
+
+func TestSetConnectivityChangeAlarmTest(t *testing.T){
+     ranAlarmServiceInstance,_,_ := RanAlarmServiceTest(t)
+     nodebInfo := &entities.NodebInfo{}
+     err := ranAlarmServiceInstance.SetConnectivityChangeAlarm(nodebInfo)
+     assert.Nil(t,err)
+}
+