Replace deprecated SDL APIs

[ric-plt/e2mgr.git] / E2Manager / rNibWriter / rNibWriter_test.go

diff --git a/E2Manager/rNibWriter/rNibWriter_test.go b/E2Manager/rNibWriter/rNibWriter_test.go
index 1eef51b..81183b7 100644 (file)
--- a/E2Manager/rNibWriter/rNibWriter_test.go
+++ b/E2Manager/rNibWriter/rNibWriter_test.go
@@ -33,17 +33,17 @@ import (
        "time"
 )
 
-var namespace = "namespace"
+var namespace = common.GetRNibNamespace()
 
 const (
        RanName = "test"
-       PlmnId = "02f829"
-       NbId = "4a952a0a"
+       PlmnId  = "02f829"
+       NbId    = "4a952a0a"
 )
 
-func initSdlInstanceMock(namespace string) (w RNibWriter, sdlInstanceMock *mocks.MockSdlInstance) {
-       sdlInstanceMock = new(mocks.MockSdlInstance)
-       w = GetRNibWriter(sdlInstanceMock, configuration.RnibWriterConfig{StateChangeMessageChannel: "RAN_CONNECTION_STATUS_CHANGE", RanManipulationMessageChannel: "RAN_MANIPULATION"})
+func initSdlMock() (w RNibWriter, sdlMock *mocks.MockSdlSyncStorage) {
+       sdlMock = new(mocks.MockSdlSyncStorage)
+       w = GetRNibWriter(sdlMock, configuration.RnibWriterConfig{StateChangeMessageChannel: "RAN_CONNECTION_STATUS_CHANGE", RanManipulationMessageChannel: "RAN_MANIPULATION"})
        return
 }
 
@@ -76,9 +76,7 @@ func generateServedNrCells(cellIds ...string) []*entities.ServedNRCell {
                servedNrCells = append(servedNrCells, &entities.ServedNRCell{ServedNrCellInformation: &entities.ServedNRCellInformation{
                        CellId: v,
                        ChoiceNrMode: &entities.ServedNRCellInformation_ChoiceNRMode{
-                               Fdd: &entities.ServedNRCellInformation_ChoiceNRMode_FddInfo{
-
-                               },
+                               Fdd: &entities.ServedNRCellInformation_ChoiceNRMode_FddInfo{},
                        },
                        NrMode:      entities.Nr_FDD,
                        NrPci:       uint32(i + 1),
@@ -122,55 +120,63 @@ func generateServedCellInfos(cellIds ...string) []*entities.ServedCellInfo {
 }
 
 func TestRemoveServedNrCellsSuccess(t *testing.T) {
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
        servedNrCellsToRemove := generateServedNrCells("whatever1", "whatever2")
-       sdlInstanceMock.On("Remove", buildServedNRCellKeysToRemove(RanName, servedNrCellsToRemove)).Return(nil)
+       sdlMock.On("Remove", namespace, buildServedNRCellKeysToRemove(RanName, servedNrCellsToRemove)).Return(nil)
        err := w.RemoveServedNrCells(RanName, servedNrCellsToRemove)
        assert.Nil(t, err)
 }
 
 func TestRemoveServedNrCellsFailure(t *testing.T) {
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
        servedNrCellsToRemove := generateServedNrCells("whatever1", "whatever2")
-       sdlInstanceMock.On("Remove", buildServedNRCellKeysToRemove(RanName, servedNrCellsToRemove)).Return(errors.New("expected error"))
+       sdlMock.On("Remove", namespace, buildServedNRCellKeysToRemove(RanName, servedNrCellsToRemove)).Return(errors.New("expected error"))
        err := w.RemoveServedNrCells(RanName, servedNrCellsToRemove)
        assert.IsType(t, &common.InternalError{}, err)
 }
 
 func TestUpdateGnbCellsInvalidNodebInfoFailure(t *testing.T) {
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
        servedNrCells := generateServedNrCells("test1", "test2")
        nodebInfo := &entities.NodebInfo{}
-       sdlInstanceMock.AssertNotCalled(t, "SetAndPublish")
+       sdlMock.AssertNotCalled(t, "SetAndPublish")
        rNibErr := w.UpdateGnbCells(nodebInfo, servedNrCells)
        assert.IsType(t, &common.ValidationError{}, rNibErr)
 }
 
 func TestAddNbIdentitySuccess(t *testing.T) {
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
 
-       nbIdentity :=  &entities.NbIdentity{InventoryName: RanName, GlobalNbId: &entities.GlobalNbId{PlmnId: PlmnId, NbId: NbId}}
+       nbIdentity := &entities.NbIdentity{InventoryName: RanName, GlobalNbId: &entities.GlobalNbId{PlmnId: PlmnId, NbId: NbId}}
        nbIdData, err := proto.Marshal(nbIdentity)
        if err != nil {
                t.Fatalf("#rNibWriter_test.TestAddNbIdentitySuccess - Failed to marshal NodeB Identity entity. Error: %v", err)
        }
 
-       sdlInstanceMock.On("AddMember", "ENB", []interface{}{nbIdData}).Return(nil)
-       rNibErr := w.AddNbIdentity(entities.Node_ENB,nbIdentity)
+       sdlMock.On("AddMember", namespace, "ENB", []interface{}{nbIdData}).Return(nil)
+       rNibErr := w.AddNbIdentity(entities.Node_ENB, nbIdentity)
        assert.Nil(t, rNibErr)
 }
 
+func TestAddNbIdentityMarshalNilFailure(t *testing.T) {
+       w, _ := initSdlMock()
+
+       rNibErr := w.AddNbIdentity(entities.Node_ENB, nil)
+       expectedErr := common.NewInternalError(errors.New("proto: Marshal called with nil"))
+       assert.Equal(t, expectedErr, rNibErr)
+}
+
 func TestAddNbIdentitySdlFailure(t *testing.T) {
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
 
-       nbIdentity :=  &entities.NbIdentity{InventoryName: RanName, GlobalNbId: &entities.GlobalNbId{PlmnId: PlmnId, NbId: NbId}}
+       nbIdentity := &entities.NbIdentity{InventoryName: RanName, GlobalNbId: &entities.GlobalNbId{PlmnId: PlmnId, NbId: NbId}}
        nbIdData, err := proto.Marshal(nbIdentity)
        if err != nil {
                t.Fatalf("#rNibWriter_test.TestAddNbIdentitySdlFailure - Failed to marshal NodeB Identity entity. Error: %v", err)
        }
 
-       sdlInstanceMock.On("AddMember", "ENB", []interface{}{nbIdData}).Return(errors.New("expected error"))
-       rNibErr := w.AddNbIdentity(entities.Node_ENB,nbIdentity)
+       sdlMock.On("AddMember", namespace, "ENB", []interface{}{nbIdData}).Return(errors.New("expected error"))
+       rNibErr := w.AddNbIdentity(entities.Node_ENB, nbIdentity)
        assert.IsType(t, &common.InternalError{}, rNibErr)
 }
 
@@ -178,11 +184,11 @@ func TestUpdateGnbCellsInvalidCellFailure(t *testing.T) {
        inventoryName := "name"
        plmnId := "02f829"
        nbId := "4a952a0a"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
        servedNrCells := []*entities.ServedNRCell{{ServedNrCellInformation: &entities.ServedNRCellInformation{}}}
        nodebInfo := generateNodebInfo(inventoryName, entities.Node_GNB, plmnId, nbId)
        nodebInfo.GetGnb().ServedNrCells = servedNrCells
-       sdlInstanceMock.AssertNotCalled(t, "SetAndPublish")
+       sdlMock.AssertNotCalled(t, "SetAndPublish")
        rNibErr := w.UpdateGnbCells(nodebInfo, servedNrCells)
        assert.IsType(t, &common.ValidationError{}, rNibErr)
 }
@@ -247,27 +253,41 @@ func TestUpdateGnbCellsSdlFailure(t *testing.T) {
        inventoryName := "name"
        plmnId := "02f829"
        nbId := "4a952a0a"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
        servedNrCells := generateServedNrCells("test1", "test2")
        nodebInfo := generateNodebInfo(inventoryName, entities.Node_GNB, plmnId, nbId)
        nodebInfo.GetGnb().ServedNrCells = servedNrCells
        setExpected := getUpdateGnbCellsSetExpected(t, nodebInfo, servedNrCells)
-       sdlInstanceMock.On("SetAndPublish", []string{"RAN_MANIPULATION", inventoryName + "_" + RanUpdatedEvent}, []interface{}{setExpected}).Return(errors.New("expected error"))
+       sdlMock.On("SetAndPublish", namespace, []string{"RAN_MANIPULATION", inventoryName + "_" + RanUpdatedEvent}, []interface{}{setExpected}).Return(errors.New("expected error"))
        rNibErr := w.UpdateGnbCells(nodebInfo, servedNrCells)
        assert.IsType(t, &common.InternalError{}, rNibErr)
 }
 
+func TestUpdateGnbCellsRnibKeyValidationError(t *testing.T) {
+       //Empty RAN name fails RNIB validation
+       inventoryName := ""
+       plmnId := "02f829"
+       nbId := "4a952a0a"
+       w, _ := initSdlMock()
+       servedNrCells := generateServedNrCells("test1", "test2")
+       nodebInfo := generateNodebInfo(inventoryName, entities.Node_GNB, plmnId, nbId)
+       nodebInfo.GetGnb().ServedNrCells = servedNrCells
+
+       rNibErr := w.UpdateGnbCells(nodebInfo, servedNrCells)
+       assert.IsType(t, &common.ValidationError{}, rNibErr)
+}
+
 func TestUpdateGnbCellsSuccess(t *testing.T) {
        inventoryName := "name"
        plmnId := "02f829"
        nbId := "4a952a0a"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
        servedNrCells := generateServedNrCells("test1", "test2")
        nodebInfo := generateNodebInfo(inventoryName, entities.Node_GNB, plmnId, nbId)
        nodebInfo.GetGnb().ServedNrCells = servedNrCells
        setExpected := getUpdateGnbCellsSetExpected(t, nodebInfo, servedNrCells)
        var e error
-       sdlInstanceMock.On("SetAndPublish",[]string{"RAN_MANIPULATION", inventoryName + "_" + RanUpdatedEvent}, []interface{}{setExpected}).Return(e)
+       sdlMock.On("SetAndPublish", namespace, []string{"RAN_MANIPULATION", inventoryName + "_" + RanUpdatedEvent}, []interface{}{setExpected}).Return(e)
        rNibErr := w.UpdateGnbCells(nodebInfo, servedNrCells)
        assert.Nil(t, rNibErr)
 }
@@ -276,7 +296,7 @@ func TestUpdateNodebInfoSuccess(t *testing.T) {
        inventoryName := "name"
        plmnId := "02f829"
        nbId := "4a952a0a"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
        nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
        data, err := proto.Marshal(nodebInfo)
        if err != nil {
@@ -290,18 +310,18 @@ func TestUpdateNodebInfoSuccess(t *testing.T) {
        setExpected = append(setExpected, nodebNameKey, data)
        setExpected = append(setExpected, nodebIdKey, data)
 
-       sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
+       sdlMock.On("Set", namespace, []interface{}{setExpected}).Return(e)
 
        rNibErr := w.UpdateNodebInfo(nodebInfo)
        assert.Nil(t, rNibErr)
-       sdlInstanceMock.AssertExpectations(t)
+       sdlMock.AssertExpectations(t)
 }
 
 func TestUpdateNodebInfoAndPublishSuccess(t *testing.T) {
        inventoryName := "name"
        plmnId := "02f829"
        nbId := "4a952a0a"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
        nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
        data, err := proto.Marshal(nodebInfo)
        if err != nil {
@@ -315,19 +335,18 @@ func TestUpdateNodebInfoAndPublishSuccess(t *testing.T) {
        setExpected = append(setExpected, nodebNameKey, data)
        setExpected = append(setExpected, nodebIdKey, data)
 
-       sdlInstanceMock.On("SetAndPublish",[]string{"RAN_MANIPULATION", inventoryName + "_" + RanUpdatedEvent}, []interface{}{setExpected}).Return(e)
+       sdlMock.On("SetAndPublish", namespace, []string{"RAN_MANIPULATION", inventoryName + "_" + RanUpdatedEvent}, []interface{}{setExpected}).Return(e)
 
        rNibErr := w.UpdateNodebInfoAndPublish(nodebInfo)
        assert.Nil(t, rNibErr)
-       sdlInstanceMock.AssertExpectations(t)
+       sdlMock.AssertExpectations(t)
 }
 
-
 func TestUpdateNodebInfoMissingInventoryNameFailure(t *testing.T) {
        inventoryName := "name"
        plmnId := "02f829"
        nbId := "4a952a0a"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
        nodebInfo := &entities.NodebInfo{}
        data, err := proto.Marshal(nodebInfo)
        if err != nil {
@@ -341,7 +360,7 @@ func TestUpdateNodebInfoMissingInventoryNameFailure(t *testing.T) {
        setExpected = append(setExpected, nodebNameKey, data)
        setExpected = append(setExpected, nodebIdKey, data)
 
-       sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
+       sdlMock.On("Set", namespace, []interface{}{setExpected}).Return(e)
 
        rNibErr := w.UpdateNodebInfo(nodebInfo)
 
@@ -351,7 +370,7 @@ func TestUpdateNodebInfoMissingInventoryNameFailure(t *testing.T) {
 
 func TestUpdateNodebInfoMissingGlobalNbId(t *testing.T) {
        inventoryName := "name"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
        nodebInfo := &entities.NodebInfo{}
        nodebInfo.RanName = inventoryName
        data, err := proto.Marshal(nodebInfo)
@@ -363,16 +382,42 @@ func TestUpdateNodebInfoMissingGlobalNbId(t *testing.T) {
 
        nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
        setExpected = append(setExpected, nodebNameKey, data)
-       sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
+       sdlMock.On("Set", namespace, []interface{}{setExpected}).Return(e)
 
        rNibErr := w.UpdateNodebInfo(nodebInfo)
 
        assert.Nil(t, rNibErr)
 }
 
+func TestUpdateNodebInfoSdlSetFailure(t *testing.T) {
+       inventoryName := "name"
+       plmnId := "02f829"
+       nbId := "4a952a0a"
+       w, sdlMock := initSdlMock()
+       nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
+       data, err := proto.Marshal(nodebInfo)
+       if err != nil {
+               t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal NodeB entity. Error: %v", err)
+       }
+       e := errors.New("expected error")
+       var setExpected []interface{}
+
+       nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
+       nodebIdKey := fmt.Sprintf("ENB:%s:%s", plmnId, nbId)
+       setExpected = append(setExpected, nodebNameKey, data)
+       setExpected = append(setExpected, nodebIdKey, data)
+
+       sdlMock.On("Set", namespace, []interface{}{setExpected}).Return(e)
+
+       rNibErr := w.UpdateNodebInfo(nodebInfo)
+       assert.NotNil(t, rNibErr)
+       assert.IsType(t, &common.InternalError{}, rNibErr)
+       sdlMock.AssertExpectations(t)
+}
+
 func TestSaveEnb(t *testing.T) {
        ranName := "RAN:" + RanName
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
        nb := entities.NodebInfo{
                RanName:          RanName,
                NodeType:         entities.Node_ENB,
@@ -406,13 +451,13 @@ func TestSaveEnb(t *testing.T) {
        setExpected = append(setExpected, fmt.Sprintf("CELL:%s", cell.GetCellId()), cellData)
        setExpected = append(setExpected, fmt.Sprintf("PCI:%s:%02x", RanName, cell.GetPci()), cellData)
 
-       sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
+       sdlMock.On("Set", namespace, []interface{}{setExpected}).Return(e)
        rNibErr := w.SaveNodeb(&nb)
        assert.Nil(t, rNibErr)
 }
 
 func TestSaveEnbCellIdValidationFailure(t *testing.T) {
-       w, _ := initSdlInstanceMock(namespace)
+       w, _ := initSdlMock()
        nb := entities.NodebInfo{}
        nb.RanName = "name"
        nb.NodeType = entities.Node_ENB
@@ -430,7 +475,7 @@ func TestSaveEnbCellIdValidationFailure(t *testing.T) {
 }
 
 func TestSaveEnbInventoryNameValidationFailure(t *testing.T) {
-       w, _ := initSdlInstanceMock(namespace)
+       w, _ := initSdlMock()
        nb := entities.NodebInfo{
                NodeType:         entities.Node_ENB,
                ConnectionStatus: entities.ConnectionStatus_CONNECTED,
@@ -451,8 +496,32 @@ func TestSaveEnbInventoryNameValidationFailure(t *testing.T) {
        assert.Equal(t, "#utils.ValidateAndBuildNodeBNameKey - an empty inventory name received", rNibErr.Error())
 }
 
+func TestSaveEnbGlobalNbIdPlmnValidationFailure(t *testing.T) {
+       w, _ := initSdlMock()
+       nb := entities.NodebInfo{
+               RanName:          RanName,
+               NodeType:         entities.Node_ENB,
+               ConnectionStatus: entities.ConnectionStatus_CONNECTED,
+               Ip:               "localhost",
+               Port:             5656,
+               GlobalNbId: &entities.GlobalNbId{
+                       NbId: "4a952a0a",
+                       //Empty PLMNID fails RNIB validation
+                       PlmnId: "",
+               },
+       }
+       enb := entities.Enb{}
+       cell := &entities.ServedCellInfo{CellId: "aaa", Pci: 3}
+       enb.ServedCells = []*entities.ServedCellInfo{cell}
+       nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
+       rNibErr := w.SaveNodeb(&nb)
+       assert.NotNil(t, rNibErr)
+       assert.IsType(t, &common.ValidationError{}, rNibErr)
+       assert.Equal(t, "#utils.ValidateAndBuildNodeBIdKey - an empty plmnId received", rNibErr.Error())
+}
+
 func TestSaveGnbCellIdValidationFailure(t *testing.T) {
-       w, _ := initSdlInstanceMock(namespace)
+       w, _ := initSdlMock()
        nb := entities.NodebInfo{}
        nb.RanName = "name"
        nb.NodeType = entities.Node_GNB
@@ -473,9 +542,9 @@ func TestSaveGnbCellIdValidationFailure(t *testing.T) {
 
 func TestSaveGnb(t *testing.T) {
        ranName := "RAN:" + RanName
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
        nb := entities.NodebInfo{
-               RanName: RanName,
+               RanName:          RanName,
                NodeType:         entities.Node_GNB,
                ConnectionStatus: 1,
                GlobalNbId: &entities.GlobalNbId{
@@ -508,7 +577,7 @@ func TestSaveGnb(t *testing.T) {
        setExpected = append(setExpected, fmt.Sprintf("NRCELL:%s", cell.GetServedNrCellInformation().GetCellId()), cellData)
        setExpected = append(setExpected, fmt.Sprintf("PCI:%s:%02x", RanName, cell.GetServedNrCellInformation().GetNrPci()), cellData)
 
-       sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
+       sdlMock.On("Set", namespace, []interface{}{setExpected}).Return(e)
        rNibErr := w.SaveNodeb(&nb)
        assert.Nil(t, rNibErr)
 }
@@ -521,7 +590,7 @@ func TestSaveRanLoadInformationSuccess(t *testing.T) {
                t.Errorf("#rNibWriter_test.TestSaveRanLoadInformationSuccess - Failed to build ran load infromation key. Error: %v", validationErr)
        }
 
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
 
        ranLoadInformation := generateRanLoadInformation()
        data, err := proto.Marshal(ranLoadInformation)
@@ -533,7 +602,7 @@ func TestSaveRanLoadInformationSuccess(t *testing.T) {
        var e error
        var setExpected []interface{}
        setExpected = append(setExpected, loadKey, data)
-       sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
+       sdlMock.On("Set", namespace, []interface{}{setExpected}).Return(e)
 
        rNibErr := w.SaveRanLoadInformation(inventoryName, ranLoadInformation)
        assert.Nil(t, rNibErr)
@@ -541,7 +610,7 @@ func TestSaveRanLoadInformationSuccess(t *testing.T) {
 
 func TestSaveRanLoadInformationMarshalNilFailure(t *testing.T) {
        inventoryName := "name2"
-       w, _ := initSdlInstanceMock(namespace)
+       w, _ := initSdlMock()
 
        expectedErr := common.NewInternalError(errors.New("proto: Marshal called with nil"))
        err := w.SaveRanLoadInformation(inventoryName, nil)
@@ -550,7 +619,7 @@ func TestSaveRanLoadInformationMarshalNilFailure(t *testing.T) {
 
 func TestSaveRanLoadInformationEmptyInventoryNameFailure(t *testing.T) {
        inventoryName := ""
-       w, _ := initSdlInstanceMock(namespace)
+       w, _ := initSdlMock()
 
        err := w.SaveRanLoadInformation(inventoryName, nil)
        assert.NotNil(t, err)
@@ -566,7 +635,7 @@ func TestSaveRanLoadInformationSdlFailure(t *testing.T) {
                t.Errorf("#rNibWriter_test.TestSaveRanLoadInformationSuccess - Failed to build ran load infromation key. Error: %v", validationErr)
        }
 
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
 
        ranLoadInformation := generateRanLoadInformation()
        data, err := proto.Marshal(ranLoadInformation)
@@ -578,7 +647,7 @@ func TestSaveRanLoadInformationSdlFailure(t *testing.T) {
        expectedErr := errors.New("expected error")
        var setExpected []interface{}
        setExpected = append(setExpected, loadKey, data)
-       sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(expectedErr)
+       sdlMock.On("Set", namespace, []interface{}{setExpected}).Return(expectedErr)
 
        rNibErr := w.SaveRanLoadInformation(inventoryName, ranLoadInformation)
        assert.NotNil(t, rNibErr)
@@ -659,14 +728,14 @@ func generateRanLoadInformation() *entities.RanLoadInformation {
 }
 
 func TestSaveNilEntityFailure(t *testing.T) {
-       w, _ := initSdlInstanceMock(namespace)
+       w, _ := initSdlMock()
        expectedErr := common.NewInternalError(errors.New("proto: Marshal called with nil"))
        actualErr := w.SaveNodeb(nil)
        assert.Equal(t, expectedErr, actualErr)
 }
 
 func TestSaveUnknownTypeEntityFailure(t *testing.T) {
-       w, _ := initSdlInstanceMock(namespace)
+       w, _ := initSdlMock()
        nb := &entities.NodebInfo{}
        nb.Port = 5656
        nb.Ip = "localhost"
@@ -679,9 +748,9 @@ func TestSaveEntitySetFailure(t *testing.T) {
        plmnId := "02f829"
        nbId := "4a952a0a"
 
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
        gnb := entities.NodebInfo{
-               RanName: name,
+               RanName:          name,
                NodeType:         entities.Node_GNB,
                ConnectionStatus: 1,
                GlobalNbId: &entities.GlobalNbId{
@@ -698,7 +767,7 @@ func TestSaveEntitySetFailure(t *testing.T) {
        setExpected := []interface{}{"RAN:" + name, data}
        setExpected = append(setExpected, "GNB:"+plmnId+":"+nbId, data)
        expectedErr := errors.New("expected error")
-       sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(expectedErr)
+       sdlMock.On("Set", namespace, []interface{}{setExpected}).Return(expectedErr)
        rNibErr := w.SaveNodeb(&gnb)
        assert.NotEmpty(t, rNibErr)
 }
@@ -708,9 +777,9 @@ func TestSaveEntitySetAndPublishFailure(t *testing.T) {
        plmnId := "02f829"
        nbId := "4a952a0a"
 
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
        enb := entities.NodebInfo{
-               RanName: name,
+               RanName:          name,
                NodeType:         entities.Node_ENB,
                ConnectionStatus: 1,
                GlobalNbId: &entities.GlobalNbId{
@@ -727,13 +796,13 @@ func TestSaveEntitySetAndPublishFailure(t *testing.T) {
        setExpected := []interface{}{"RAN:" + name, data}
        setExpected = append(setExpected, "ENB:"+plmnId+":"+nbId, data)
        expectedErr := errors.New("expected error")
-       sdlInstanceMock.On("SetAndPublish", []string{"RAN_MANIPULATION", name + "_" + RanAddedEvent}, []interface{}{setExpected}).Return(expectedErr)
+       sdlMock.On("SetAndPublish", namespace, []string{"RAN_MANIPULATION", name + "_" + RanAddedEvent}, []interface{}{setExpected}).Return(expectedErr)
        rNibErr := w.AddEnb(&enb)
        assert.NotEmpty(t, rNibErr)
 }
 
 func TestGetRNibWriter(t *testing.T) {
-       received, _ := initSdlInstanceMock(namespace)
+       received, _ := initSdlMock()
        assert.NotEmpty(t, received)
 }
 
@@ -745,7 +814,7 @@ func TestSaveE2TInstanceSuccess(t *testing.T) {
                t.Errorf("#rNibWriter_test.TestSaveE2TInstanceSuccess - Failed to build E2T Instance key. Error: %v", validationErr)
        }
 
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
 
        e2tInstance := generateE2tInstance(address)
        data, err := json.Marshal(e2tInstance)
@@ -757,14 +826,14 @@ func TestSaveE2TInstanceSuccess(t *testing.T) {
        var e error
        var setExpected []interface{}
        setExpected = append(setExpected, loadKey, data)
-       sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
+       sdlMock.On("Set", namespace, []interface{}{setExpected}).Return(e)
 
        rNibErr := w.SaveE2TInstance(e2tInstance)
        assert.Nil(t, rNibErr)
 }
 
 func TestSaveE2TInstanceNullE2tInstanceFailure(t *testing.T) {
-       w, _ := initSdlInstanceMock(namespace)
+       w, _ := initSdlMock()
        var address string
        e2tInstance := entities.NewE2TInstance(address, "test")
        err := w.SaveE2TInstance(e2tInstance)
@@ -780,7 +849,7 @@ func TestSaveE2TInstanceSdlFailure(t *testing.T) {
                t.Errorf("#rNibWriter_test.TestSaveE2TInstanceSdlFailure - Failed to build E2T Instance key. Error: %v", validationErr)
        }
 
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
 
        e2tInstance := generateE2tInstance(address)
        data, err := json.Marshal(e2tInstance)
@@ -792,7 +861,7 @@ func TestSaveE2TInstanceSdlFailure(t *testing.T) {
        expectedErr := errors.New("expected error")
        var setExpected []interface{}
        setExpected = append(setExpected, loadKey, data)
-       sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(expectedErr)
+       sdlMock.On("Set", namespace, []interface{}{setExpected}).Return(expectedErr)
 
        rNibErr := w.SaveE2TInstance(e2tInstance)
        assert.NotNil(t, rNibErr)
@@ -809,7 +878,7 @@ func generateE2tInstance(address string) *entities.E2TInstance {
 
 func TestSaveE2TAddressesSuccess(t *testing.T) {
        address := "10.10.2.15:9800"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
 
        e2tAddresses := []string{address}
        data, err := json.Marshal(e2tAddresses)
@@ -821,7 +890,7 @@ func TestSaveE2TAddressesSuccess(t *testing.T) {
        var e error
        var setExpected []interface{}
        setExpected = append(setExpected, E2TAddressesKey, data)
-       sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
+       sdlMock.On("Set", namespace, []interface{}{setExpected}).Return(e)
 
        rNibErr := w.SaveE2TAddresses(e2tAddresses)
        assert.Nil(t, rNibErr)
@@ -829,7 +898,7 @@ func TestSaveE2TAddressesSuccess(t *testing.T) {
 
 func TestSaveE2TAddressesSdlFailure(t *testing.T) {
        address := "10.10.2.15:9800"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
 
        e2tAddresses := []string{address}
        data, err := json.Marshal(e2tAddresses)
@@ -841,7 +910,7 @@ func TestSaveE2TAddressesSdlFailure(t *testing.T) {
        expectedErr := errors.New("expected error")
        var setExpected []interface{}
        setExpected = append(setExpected, E2TAddressesKey, data)
-       sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(expectedErr)
+       sdlMock.On("Set", namespace, []interface{}{setExpected}).Return(expectedErr)
 
        rNibErr := w.SaveE2TAddresses(e2tAddresses)
        assert.NotNil(t, rNibErr)
@@ -850,35 +919,35 @@ func TestSaveE2TAddressesSdlFailure(t *testing.T) {
 
 func TestRemoveE2TInstanceSuccess(t *testing.T) {
        address := "10.10.2.15:9800"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
 
        e2tAddresses := []string{fmt.Sprintf("E2TInstance:%s", address)}
        var e error
-       sdlInstanceMock.On("Remove", e2tAddresses).Return(e)
+       sdlMock.On("Remove", namespace, e2tAddresses).Return(e)
 
        rNibErr := w.RemoveE2TInstance(address)
        assert.Nil(t, rNibErr)
-       sdlInstanceMock.AssertExpectations(t)
+       sdlMock.AssertExpectations(t)
 }
 
 func TestRemoveE2TInstanceSdlFailure(t *testing.T) {
        address := "10.10.2.15:9800"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
 
        e2tAddresses := []string{fmt.Sprintf("E2TInstance:%s", address)}
        expectedErr := errors.New("expected error")
-       sdlInstanceMock.On("Remove", e2tAddresses).Return(expectedErr)
+       sdlMock.On("Remove", namespace, e2tAddresses).Return(expectedErr)
 
        rNibErr := w.RemoveE2TInstance(address)
        assert.IsType(t, &common.InternalError{}, rNibErr)
 }
 
 func TestRemoveE2TInstanceEmptyAddressFailure(t *testing.T) {
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
 
        rNibErr := w.RemoveE2TInstance("")
        assert.IsType(t, &common.ValidationError{}, rNibErr)
-       sdlInstanceMock.AssertExpectations(t)
+       sdlMock.AssertExpectations(t)
 }
 
 func TestUpdateNodebInfoOnConnectionStatusInversionSuccess(t *testing.T) {
@@ -887,7 +956,7 @@ func TestUpdateNodebInfoOnConnectionStatusInversionSuccess(t *testing.T) {
        nbId := "4a952a0a"
        channelName := "RAN_CONNECTION_STATUS_CHANGE"
        eventName := inventoryName + "_" + "CONNECTED"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
        nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
        data, err := proto.Marshal(nodebInfo)
        if err != nil {
@@ -901,7 +970,7 @@ func TestUpdateNodebInfoOnConnectionStatusInversionSuccess(t *testing.T) {
        setExpected = append(setExpected, nodebNameKey, data)
        setExpected = append(setExpected, nodebIdKey, data)
 
-       sdlInstanceMock.On("SetAndPublish", []string{channelName, eventName}, []interface{}{setExpected}).Return(e)
+       sdlMock.On("SetAndPublish", namespace, []string{channelName, eventName}, []interface{}{setExpected}).Return(e)
 
        rNibErr := w.UpdateNodebInfoOnConnectionStatusInversion(nodebInfo, eventName)
        assert.Nil(t, rNibErr)
@@ -913,7 +982,7 @@ func TestUpdateNodebInfoOnConnectionStatusInversionMissingInventoryNameFailure(t
        nbId := "4a952a0a"
        channelName := "RAN_CONNECTION_STATUS_CHANGE"
        eventName := inventoryName + "_" + "CONNECTED"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
        nodebInfo := &entities.NodebInfo{}
        data, err := proto.Marshal(nodebInfo)
        if err != nil {
@@ -927,7 +996,7 @@ func TestUpdateNodebInfoOnConnectionStatusInversionMissingInventoryNameFailure(t
        setExpected = append(setExpected, nodebNameKey, data)
        setExpected = append(setExpected, nodebIdKey, data)
 
-       sdlInstanceMock.On("SetAndPublish", []string{channelName, eventName}, []interface{}{setExpected}).Return(e)
+       sdlMock.On("SetAndPublish", namespace, []string{channelName, eventName}, []interface{}{setExpected}).Return(e)
 
        rNibErr := w.UpdateNodebInfoOnConnectionStatusInversion(nodebInfo, eventName)
 
@@ -939,7 +1008,7 @@ func TestUpdateNodebInfoOnConnectionStatusInversionMissingGlobalNbId(t *testing.
        inventoryName := "name"
        channelName := "RAN_CONNECTION_STATUS_CHANGE"
        eventName := inventoryName + "_" + "CONNECTED"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
        nodebInfo := &entities.NodebInfo{}
        nodebInfo.RanName = inventoryName
        data, err := proto.Marshal(nodebInfo)
@@ -951,30 +1020,57 @@ func TestUpdateNodebInfoOnConnectionStatusInversionMissingGlobalNbId(t *testing.
 
        nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
        setExpected = append(setExpected, nodebNameKey, data)
-       sdlInstanceMock.On("SetAndPublish", []string{channelName, eventName}, []interface{}{setExpected}).Return(e)
+       sdlMock.On("SetAndPublish", namespace, []string{channelName, eventName}, []interface{}{setExpected}).Return(e)
 
        rNibErr := w.UpdateNodebInfoOnConnectionStatusInversion(nodebInfo, eventName)
 
        assert.Nil(t, rNibErr)
 }
 
+func TestUpdateNodebInfoOnConnectionStatusInversionSdlFailure(t *testing.T) {
+       inventoryName := "name"
+       plmnId := "02f829"
+       nbId := "4a952a0a"
+       channelName := "RAN_CONNECTION_STATUS_CHANGE"
+       eventName := inventoryName + "_" + "CONNECTED"
+       w, sdlMock := initSdlMock()
+       nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
+       data, err := proto.Marshal(nodebInfo)
+       if err != nil {
+               t.Errorf("#rNibWriter_test.TestUpdateNodebInfoOnConnectionStatusInversionSuccess - Failed to marshal NodeB entity. Error: %v", err)
+       }
+       e := errors.New("expected error")
+       var setExpected []interface{}
+
+       nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
+       nodebIdKey := fmt.Sprintf("ENB:%s:%s", plmnId, nbId)
+       setExpected = append(setExpected, nodebNameKey, data)
+       setExpected = append(setExpected, nodebIdKey, data)
+
+       sdlMock.On("SetAndPublish", namespace, []string{channelName, eventName}, []interface{}{setExpected}).Return(e)
+
+       rNibErr := w.UpdateNodebInfoOnConnectionStatusInversion(nodebInfo, eventName)
+       assert.NotNil(t, rNibErr)
+       assert.IsType(t, &common.InternalError{}, rNibErr)
+}
+
 func TestSaveGeneralConfiguration(t *testing.T) {
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
 
        key := common.BuildGeneralConfigurationKey()
        configurationData := "{\"enableRic\":true}"
        configuration := &entities.GeneralConfiguration{}
        configuration.EnableRic = true
 
-       sdlInstanceMock.On("Set", []interface{}{[]interface{}{key, []byte(configurationData)}}).Return(nil)
+       sdlMock.On("Set", namespace, []interface{}{[]interface{}{key, []byte(configurationData)}}).Return(nil)
        rNibErr := w.SaveGeneralConfiguration(configuration)
 
        assert.Nil(t, rNibErr)
-       sdlInstanceMock.AssertExpectations(t)
+       sdlMock.AssertExpectations(t)
 }
 
 func TestSaveGeneralConfigurationDbError(t *testing.T) {
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
 
        key := common.BuildGeneralConfigurationKey()
        configurationData := "{\"enableRic\":true}"
@@ -983,17 +1079,17 @@ func TestSaveGeneralConfigurationDbError(t *testing.T) {
 
        expectedErr := errors.New("expected error")
 
-       sdlInstanceMock.On("Set", []interface{}{[]interface{}{key, []byte(configurationData)}}).Return(expectedErr)
+       sdlMock.On("Set", namespace, []interface{}{[]interface{}{key, []byte(configurationData)}}).Return(expectedErr)
        rNibErr := w.SaveGeneralConfiguration(configuration)
 
        assert.NotNil(t, rNibErr)
 }
 
 func TestRemoveServedCellsFailure(t *testing.T) {
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
        servedCellsToRemove := generateServedCells("whatever1", "whatever2")
        expectedErr := errors.New("expected error")
-       sdlInstanceMock.On("Remove", buildServedCellInfoKeysToRemove(RanName, servedCellsToRemove)).Return(expectedErr)
+       sdlMock.On("Remove", namespace, buildServedCellInfoKeysToRemove(RanName, servedCellsToRemove)).Return(expectedErr)
 
        rNibErr := w.RemoveServedCells(RanName, servedCellsToRemove)
 
@@ -1001,18 +1097,18 @@ func TestRemoveServedCellsFailure(t *testing.T) {
 }
 
 func TestRemoveServedCellsSuccess(t *testing.T) {
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
        servedCellsToRemove := generateServedCells("whatever1", "whatever2")
-       sdlInstanceMock.On("Remove", buildServedCellInfoKeysToRemove(RanName, servedCellsToRemove)).Return(nil)
+       sdlMock.On("Remove", namespace, buildServedCellInfoKeysToRemove(RanName, servedCellsToRemove)).Return(nil)
        err := w.RemoveServedCells(RanName, servedCellsToRemove)
        assert.Nil(t, err)
 }
 
 func TestUpdateEnbInvalidNodebInfoFailure(t *testing.T) {
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
        servedCells := generateServedCells("test1", "test2")
        nodebInfo := &entities.NodebInfo{}
-       sdlInstanceMock.AssertNotCalled(t, "SetAndPublish")
+       sdlMock.AssertNotCalled(t, "SetAndPublish")
        rNibErr := w.UpdateEnb(nodebInfo, servedCells)
        assert.IsType(t, &common.ValidationError{}, rNibErr)
 }
@@ -1021,11 +1117,25 @@ func TestUpdateEnbInvalidCellFailure(t *testing.T) {
        inventoryName := "name"
        plmnId := "02f829"
        nbId := "4a952a0a"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
        servedCells := []*entities.ServedCellInfo{{CellId: ""}}
        nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
        nodebInfo.GetEnb().ServedCells = servedCells
-       sdlInstanceMock.AssertNotCalled(t, "SetAndPublish")
+       sdlMock.AssertNotCalled(t, "SetAndPublish")
+       rNibErr := w.UpdateEnb(nodebInfo, servedCells)
+       assert.IsType(t, &common.ValidationError{}, rNibErr)
+}
+
+func TestUpdateEnbRnibKeyValidationError(t *testing.T) {
+       //Empty RAN name fails RNIB validation
+       inventoryName := ""
+       plmnId := "02f829"
+       nbId := "4a952a0a"
+       w, _ := initSdlMock()
+       servedCells := generateServedCells("test1", "test2")
+       nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
+       nodebInfo.GetEnb().ServedCells = servedCells
+
        rNibErr := w.UpdateEnb(nodebInfo, servedCells)
        assert.IsType(t, &common.ValidationError{}, rNibErr)
 }
@@ -1034,12 +1144,12 @@ func TestUpdateEnbSdlFailure(t *testing.T) {
        inventoryName := "name"
        plmnId := "02f829"
        nbId := "4a952a0a"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
        servedCells := generateServedCells("test1", "test2")
        nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
        nodebInfo.GetEnb().ServedCells = servedCells
        setExpected := getUpdateEnbCellsSetExpected(t, nodebInfo, servedCells)
-       sdlInstanceMock.On("SetAndPublish", []string{"RAN_MANIPULATION", inventoryName + "_" + RanUpdatedEvent}, []interface{}{setExpected}).Return(errors.New("expected error"))
+       sdlMock.On("SetAndPublish", namespace, []string{"RAN_MANIPULATION", inventoryName + "_" + RanUpdatedEvent}, []interface{}{setExpected}).Return(errors.New("expected error"))
        rNibErr := w.UpdateEnb(nodebInfo, servedCells)
        assert.IsType(t, &common.InternalError{}, rNibErr)
 }
@@ -1048,14 +1158,14 @@ func TestUpdateEnbSuccess(t *testing.T) {
        inventoryName := "name"
        plmnId := "02f829"
        nbId := "4a952a0a"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
        servedCells := generateServedCells("test1", "test2")
        nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
        nodebInfo.GetEnb().ServedCells = servedCells
        setExpected := getUpdateEnbCellsSetExpected(t, nodebInfo, servedCells)
 
        var e error
-       sdlInstanceMock.On("SetAndPublish", []string{"RAN_MANIPULATION", inventoryName + "_" + RanUpdatedEvent}, []interface{}{setExpected}).Return(e)
+       sdlMock.On("SetAndPublish", namespace, []string{"RAN_MANIPULATION", inventoryName + "_" + RanUpdatedEvent}, []interface{}{setExpected}).Return(e)
        rNibErr := w.UpdateEnb(nodebInfo, servedCells)
        assert.Nil(t, rNibErr)
 }
@@ -1093,7 +1203,7 @@ func TestRemoveEnbSuccess(t *testing.T) {
        nbId := "4a952a0a"
        channelName := "RAN_MANIPULATION"
        eventName := inventoryName + "_" + "DELETED"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
        nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
        nodebInfo.GetEnb().ServedCells = generateServedCellInfos("cell1", "cell2")
 
@@ -1107,11 +1217,24 @@ func TestRemoveEnbSuccess(t *testing.T) {
        nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
        nodebIdKey := fmt.Sprintf("ENB:%s:%s", plmnId, nbId)
        expectedKeys = append(expectedKeys, cell1Key, cell1PciKey, cell2Key, cell2PciKey, nodebNameKey, nodebIdKey)
-       sdlInstanceMock.On("RemoveAndPublish", []string{channelName, eventName}, expectedKeys).Return(e)
+       sdlMock.On("RemoveAndPublish", namespace, []string{channelName, eventName}, expectedKeys).Return(e)
 
        rNibErr := w.RemoveEnb(nodebInfo)
        assert.Nil(t, rNibErr)
-       sdlInstanceMock.AssertExpectations(t)
+       sdlMock.AssertExpectations(t)
+}
+
+func TestRemoveEnbRnibKeyValidationError(t *testing.T) {
+       //Empty RAN name fails RNIB key validation
+       inventoryName := ""
+       plmnId := "02f829"
+       nbId := "4a952a0a"
+       w, _ := initSdlMock()
+       nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
+       nodebInfo.GetEnb().ServedCells = generateServedCellInfos("cell1", "cell2")
+
+       rNibErr := w.RemoveEnb(nodebInfo)
+       assert.NotNil(t, rNibErr)
 }
 
 func TestRemoveEnbRemoveAndPublishError(t *testing.T) {
@@ -1120,7 +1243,7 @@ func TestRemoveEnbRemoveAndPublishError(t *testing.T) {
        nbId := "4a952a0a"
        channelName := "RAN_MANIPULATION"
        eventName := inventoryName + "_" + "DELETED"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
        nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
        nodebInfo.GetEnb().ServedCells = generateServedCellInfos("cell1", "cell2")
 
@@ -1132,46 +1255,54 @@ func TestRemoveEnbRemoveAndPublishError(t *testing.T) {
        nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
        nodebIdKey := fmt.Sprintf("ENB:%s:%s", plmnId, nbId)
        expectedKeys = append(expectedKeys, cell1Key, cell1PciKey, cell2Key, cell2PciKey, nodebNameKey, nodebIdKey)
-       sdlInstanceMock.On("RemoveAndPublish", []string{channelName, eventName}, expectedKeys).Return(errors.New("for test"))
+       sdlMock.On("RemoveAndPublish", namespace, []string{channelName, eventName}, expectedKeys).Return(errors.New("for test"))
 
        rNibErr := w.RemoveEnb(nodebInfo)
        assert.NotNil(t, rNibErr)
-       sdlInstanceMock.AssertExpectations(t)
+       sdlMock.AssertExpectations(t)
 }
 
 func TestRemoveNbIdentitySuccess(t *testing.T) {
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
        nbIdentity := &entities.NbIdentity{InventoryName: "ran1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
        nbIdData, err := proto.Marshal(nbIdentity)
        if err != nil {
                t.Errorf("#TestRemoveNbIdentitySuccess - failed to Marshal NbIdentity")
        }
 
-       sdlInstanceMock.On("RemoveMember", entities.Node_ENB.String(), []interface{}{nbIdData}).Return(nil)
+       sdlMock.On("RemoveMember", namespace, entities.Node_ENB.String(), []interface{}{nbIdData}).Return(nil)
 
        rNibErr := w.RemoveNbIdentity(entities.Node_ENB, nbIdentity)
        assert.Nil(t, rNibErr)
-       sdlInstanceMock.AssertExpectations(t)
+       sdlMock.AssertExpectations(t)
+}
+
+func TestRemoveNbIdentityMarshalNilFailure(t *testing.T) {
+       w, _ := initSdlMock()
+
+       rNibErr := w.RemoveNbIdentity(entities.Node_ENB, nil)
+       expectedErr := common.NewInternalError(errors.New("proto: Marshal called with nil"))
+       assert.Equal(t, expectedErr, rNibErr)
 }
 
 func TestRemoveNbIdentityError(t *testing.T) {
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
        nbIdentity := &entities.NbIdentity{InventoryName: "ran1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
        nbIdData, err := proto.Marshal(nbIdentity)
        if err != nil {
                t.Errorf("#TestRemoveNbIdentitySuccess - failed to Marshal NbIdentity")
        }
 
-       sdlInstanceMock.On("RemoveMember", entities.Node_ENB.String(), []interface{}{nbIdData}).Return(fmt.Errorf("for test"))
+       sdlMock.On("RemoveMember", namespace, entities.Node_ENB.String(), []interface{}{nbIdData}).Return(fmt.Errorf("for test"))
 
        rNibErr := w.RemoveNbIdentity(entities.Node_ENB, nbIdentity)
        assert.NotNil(t, rNibErr)
-       sdlInstanceMock.AssertExpectations(t)
+       sdlMock.AssertExpectations(t)
 }
 
 func TestAddEnb(t *testing.T) {
        ranName := "RAN:" + RanName
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
        nb := entities.NodebInfo{
                RanName:          RanName,
                NodeType:         entities.Node_ENB,
@@ -1205,14 +1336,22 @@ func TestAddEnb(t *testing.T) {
        setExpected = append(setExpected, fmt.Sprintf("CELL:%s", cell.GetCellId()), cellData)
        setExpected = append(setExpected, fmt.Sprintf("PCI:%s:%02x", RanName, cell.GetPci()), cellData)
 
-       sdlInstanceMock.On("SetAndPublish", []string{"RAN_MANIPULATION", RanName + "_" + RanAddedEvent}, []interface{}{setExpected}).Return(e)
+       sdlMock.On("SetAndPublish", namespace, []string{"RAN_MANIPULATION", RanName + "_" + RanAddedEvent}, []interface{}{setExpected}).Return(e)
 
        rNibErr := w.AddEnb(&nb)
        assert.Nil(t, rNibErr)
 }
 
+func TestAddEnbMarshalNilFailure(t *testing.T) {
+       w, _ := initSdlMock()
+
+       rNibErr := w.AddEnb(nil)
+       expectedErr := common.NewInternalError(errors.New("proto: Marshal called with nil"))
+       assert.Equal(t, expectedErr, rNibErr)
+}
+
 func TestAddEnbCellIdValidationFailure(t *testing.T) {
-       w, _ := initSdlInstanceMock(namespace)
+       w, _ := initSdlMock()
        nb := entities.NodebInfo{}
        nb.RanName = "name"
        nb.NodeType = entities.Node_ENB
@@ -1230,7 +1369,7 @@ func TestAddEnbCellIdValidationFailure(t *testing.T) {
 }
 
 func TestAddEnbInventoryNameValidationFailure(t *testing.T) {
-       w, _ := initSdlInstanceMock(namespace)
+       w, _ := initSdlMock()
        nb := entities.NodebInfo{
                NodeType:         entities.Node_ENB,
                ConnectionStatus: entities.ConnectionStatus_CONNECTED,
@@ -1251,41 +1390,65 @@ func TestAddEnbInventoryNameValidationFailure(t *testing.T) {
        assert.Equal(t, "#utils.ValidateAndBuildNodeBNameKey - an empty inventory name received", rNibErr.Error())
 }
 
+func TestAddEnbGlobalNbIdPlmnValidationFailure(t *testing.T) {
+       w, _ := initSdlMock()
+       nb := entities.NodebInfo{
+               RanName:          "name",
+               NodeType:         entities.Node_ENB,
+               ConnectionStatus: entities.ConnectionStatus_CONNECTED,
+               Ip:               "localhost",
+               Port:             5656,
+               GlobalNbId: &entities.GlobalNbId{
+                       NbId: "4a952a0a",
+                       //Empty PLMNID fails RNIB validation
+                       PlmnId: "",
+               },
+       }
+       enb := entities.Enb{}
+       cell := &entities.ServedCellInfo{CellId: "aaa", Pci: 3}
+       enb.ServedCells = []*entities.ServedCellInfo{cell}
+       nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
+       rNibErr := w.AddEnb(&nb)
+       assert.NotNil(t, rNibErr)
+       assert.IsType(t, &common.ValidationError{}, rNibErr)
+       assert.Equal(t, "#utils.ValidateAndBuildNodeBIdKey - an empty plmnId received", rNibErr.Error())
+}
+
 func TestUpdateNbIdentityOneMemberSuccess(t *testing.T) {
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
 
        proto, nbIdentity := createNbIdentityProto(t, "ran1", "plmnId1", "nbId1", entities.ConnectionStatus_DISCONNECTED)
        val := []interface{}{proto}
 
-       sdlInstanceMock.On("RemoveMember", entities.Node_ENB.String(), val).Return(nil)
+       sdlMock.On("RemoveMember", namespace, entities.Node_ENB.String(), val).Return(nil)
 
        protoAdd, nbIdentityAdd := createNbIdentityProto(t, "ran1_add", "plmnId1_add", "nbId1_add", entities.ConnectionStatus_CONNECTED)
-       sdlInstanceMock.On("AddMember", entities.Node_ENB.String(), []interface{}{protoAdd}).Return(nil)
+       sdlMock.On("AddMember", namespace, entities.Node_ENB.String(), []interface{}{protoAdd}).Return(nil)
 
        newNbIdIdentities := []*entities.NbIdentity{nbIdentityAdd}
        oldNbIdIdentities := []*entities.NbIdentity{nbIdentity}
 
        rNibErr := w.UpdateNbIdentities(entities.Node_ENB, oldNbIdIdentities, newNbIdIdentities)
        assert.Nil(t, rNibErr)
-       sdlInstanceMock.AssertExpectations(t)
+       sdlMock.AssertExpectations(t)
 }
 
 func TestUpdateNbIdentitySuccess(t *testing.T) {
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
 
        var nbIdIdentitiesProtoToRemove []interface{}
        protoRan1, _ := createNbIdentityProto(t, "ran1", "plmnId1", "nbId1", entities.ConnectionStatus_DISCONNECTED)
        protoRan2, _ := createNbIdentityProto(t, "ran2", "plmnId2", "nbId2", entities.ConnectionStatus_DISCONNECTED)
        nbIdIdentitiesProtoToRemove = append(nbIdIdentitiesProtoToRemove, protoRan1)
        nbIdIdentitiesProtoToRemove = append(nbIdIdentitiesProtoToRemove, protoRan2)
-       sdlInstanceMock.On("RemoveMember", entities.Node_ENB.String(), nbIdIdentitiesProtoToRemove).Return(nil)
+       sdlMock.On("RemoveMember", namespace, entities.Node_ENB.String(), nbIdIdentitiesProtoToRemove).Return(nil)
 
        var nbIdIdentitiesProtoToAdd []interface{}
        protoRan1Add, _ := createNbIdentityProto(t, "ran1_add", "plmnId1_add", "nbId1_add", entities.ConnectionStatus_CONNECTED)
        protoRan2Add, _ := createNbIdentityProto(t, "ran2_add", "plmnId2_add", "nbId2_add", entities.ConnectionStatus_CONNECTED)
        nbIdIdentitiesProtoToAdd = append(nbIdIdentitiesProtoToAdd, protoRan1Add)
        nbIdIdentitiesProtoToAdd = append(nbIdIdentitiesProtoToAdd, protoRan2Add)
-       sdlInstanceMock.On("AddMember", entities.Node_ENB.String(), nbIdIdentitiesProtoToAdd).Return(nil)
+       sdlMock.On("AddMember", namespace, entities.Node_ENB.String(), nbIdIdentitiesProtoToAdd).Return(nil)
 
        var newNbIdIdentities []*entities.NbIdentity
        firstNewNbIdIdentity := &entities.NbIdentity{InventoryName: "ran1_add", ConnectionStatus: entities.ConnectionStatus_CONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1_add", NbId: "nbId1_add"}}
@@ -1301,11 +1464,50 @@ func TestUpdateNbIdentitySuccess(t *testing.T) {
 
        rNibErr := w.UpdateNbIdentities(entities.Node_ENB, oldNbIdIdentities, newNbIdIdentities)
        assert.Nil(t, rNibErr)
-       sdlInstanceMock.AssertExpectations(t)
+       sdlMock.AssertExpectations(t)
+}
+
+func TestUpdateNbIdentityOldIdentityMarshalNilFailure(t *testing.T) {
+       w, _ := initSdlMock()
+
+       oldNbIdIdentities := []*entities.NbIdentity{nil}
+       newNbIdIdentities := []*entities.NbIdentity{
+               &entities.NbIdentity{
+                       InventoryName:    "ran1_add",
+                       ConnectionStatus: entities.ConnectionStatus_CONNECTED,
+                       GlobalNbId:       &entities.GlobalNbId{PlmnId: "plmnId1_add", NbId: "nbId1_add"},
+               },
+       }
+
+       expectedErr := common.NewInternalError(errors.New("proto: Marshal called with nil"))
+       rNibErr := w.UpdateNbIdentities(entities.Node_ENB, oldNbIdIdentities, newNbIdIdentities)
+       assert.Equal(t, expectedErr, rNibErr)
+}
+
+func TestUpdateNbIdentityNewIdentityMarshalNilFailure(t *testing.T) {
+       w, sdlMock := initSdlMock()
+
+       var nbIdIdentitiesProtoToRemove []interface{}
+       protoRan1, _ := createNbIdentityProto(t, "ran1", "plmnId1", "nbId1", entities.ConnectionStatus_DISCONNECTED)
+       nbIdIdentitiesProtoToRemove = append(nbIdIdentitiesProtoToRemove, protoRan1)
+       sdlMock.On("RemoveMember", namespace, entities.Node_ENB.String(), nbIdIdentitiesProtoToRemove).Return(nil)
+
+       oldNbIdIdentities := []*entities.NbIdentity{
+               &entities.NbIdentity{
+                       InventoryName:    "ran1",
+                       ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,
+                       GlobalNbId:       &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"},
+               },
+       }
+       newNbIdIdentities := []*entities.NbIdentity{nil}
+
+       expectedErr := common.NewInternalError(errors.New("proto: Marshal called with nil"))
+       rNibErr := w.UpdateNbIdentities(entities.Node_ENB, oldNbIdIdentities, newNbIdIdentities)
+       assert.Equal(t, expectedErr, rNibErr)
 }
 
 func TestUpdateNbIdentityRemoveFailure(t *testing.T) {
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
 
        var nbIdIdentitiesProtoToRemove []interface{}
        protoRan1, _ := createNbIdentityProto(t, "ran1", "plmnId1", "nbId1", entities.ConnectionStatus_DISCONNECTED)
@@ -1313,7 +1515,7 @@ func TestUpdateNbIdentityRemoveFailure(t *testing.T) {
        protoRan2, _ := createNbIdentityProto(t, "ran2", "plmnId2", "nbId2", entities.ConnectionStatus_DISCONNECTED)
        nbIdIdentitiesProtoToRemove = append(nbIdIdentitiesProtoToRemove, protoRan2)
 
-       sdlInstanceMock.On("RemoveMember", entities.Node_ENB.String(), nbIdIdentitiesProtoToRemove).Return(fmt.Errorf("for test"))
+       sdlMock.On("RemoveMember", namespace, entities.Node_ENB.String(), nbIdIdentitiesProtoToRemove).Return(fmt.Errorf("for test"))
 
        var oldNbIdIdentities []*entities.NbIdentity
        firstOldNbIdIdentity := &entities.NbIdentity{InventoryName: "ran1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
@@ -1325,56 +1527,82 @@ func TestUpdateNbIdentityRemoveFailure(t *testing.T) {
 
        rNibErr := w.UpdateNbIdentities(entities.Node_ENB, oldNbIdIdentities, newNbIdIdentities)
        assert.NotNil(t, rNibErr)
-       sdlInstanceMock.AssertExpectations(t)
+       sdlMock.AssertExpectations(t)
+}
+
+func TestUpdateNbIdentitySdlAddMemberFailure(t *testing.T) {
+       w, sdlMock := initSdlMock()
+
+       var nbIdIdentitiesProtoToRemove []interface{}
+       protoRan1, _ := createNbIdentityProto(t, "ran1", "plmnId1", "nbId1", entities.ConnectionStatus_DISCONNECTED)
+       nbIdIdentitiesProtoToRemove = append(nbIdIdentitiesProtoToRemove, protoRan1)
+       sdlMock.On("RemoveMember", namespace, entities.Node_ENB.String(), nbIdIdentitiesProtoToRemove).Return(nil)
+
+       var nbIdIdentitiesProtoToAdd []interface{}
+       protoRan1Add, _ := createNbIdentityProto(t, "ran1_add", "plmnId1_add", "nbId1_add", entities.ConnectionStatus_CONNECTED)
+       nbIdIdentitiesProtoToAdd = append(nbIdIdentitiesProtoToAdd, protoRan1Add)
+       sdlMock.On("AddMember", namespace, entities.Node_ENB.String(), nbIdIdentitiesProtoToAdd).Return(fmt.Errorf("for test"))
+
+       var oldNbIdIdentities []*entities.NbIdentity
+       firstOldNbIdIdentity := &entities.NbIdentity{InventoryName: "ran1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
+       oldNbIdIdentities = append(oldNbIdIdentities, firstOldNbIdIdentity)
+
+       var newNbIdIdentities []*entities.NbIdentity
+       firstNewNbIdIdentity := &entities.NbIdentity{InventoryName: "ran1_add", ConnectionStatus: entities.ConnectionStatus_CONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1_add", NbId: "nbId1_add"}}
+       newNbIdIdentities = append(newNbIdIdentities, firstNewNbIdIdentity)
+
+       rNibErr := w.UpdateNbIdentities(entities.Node_ENB, oldNbIdIdentities, newNbIdIdentities)
+       assert.NotNil(t, rNibErr)
+       sdlMock.AssertExpectations(t)
 }
 
 func TestUpdateNbIdentityAddFailure(t *testing.T) {
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
        nbIdentity := &entities.NbIdentity{InventoryName: "ran1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
        nbIdData, err := proto.Marshal(nbIdentity)
        if err != nil {
                t.Errorf("#TestRemoveNbIdentitySuccess - failed to Marshal NbIdentity")
        }
-       sdlInstanceMock.On("RemoveMember", entities.Node_ENB.String(), []interface{}{nbIdData}).Return(fmt.Errorf("for test"))
+       sdlMock.On("RemoveMember", namespace, entities.Node_ENB.String(), []interface{}{nbIdData}).Return(fmt.Errorf("for test"))
 
        rNibErr := w.RemoveNbIdentity(entities.Node_ENB, nbIdentity)
        assert.NotNil(t, rNibErr)
-       sdlInstanceMock.AssertExpectations(t)
+       sdlMock.AssertExpectations(t)
 }
 
 func TestUpdateNbIdentityNoNbIdentityToRemove(t *testing.T) {
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
        nbIdentity := &entities.NbIdentity{InventoryName: "ran1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
        nbIdData, err := proto.Marshal(nbIdentity)
        if err != nil {
                t.Errorf("#TestRemoveNbIdentitySuccess - failed to Marshal NbIdentity")
        }
-       sdlInstanceMock.On("RemoveMember", entities.Node_ENB.String(), []interface{}{nbIdData}).Return(fmt.Errorf("for test"))
+       sdlMock.On("RemoveMember", namespace, entities.Node_ENB.String(), []interface{}{nbIdData}).Return(fmt.Errorf("for test"))
 
        rNibErr := w.RemoveNbIdentity(entities.Node_ENB, nbIdentity)
        assert.NotNil(t, rNibErr)
-       sdlInstanceMock.AssertExpectations(t)
+       sdlMock.AssertExpectations(t)
 }
 
 func TestUpdateNbIdentityNoNbIdentityToAdd(t *testing.T) {
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlMock := initSdlMock()
        nbIdentity := &entities.NbIdentity{InventoryName: "ran1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
        nbIdData, err := proto.Marshal(nbIdentity)
        if err != nil {
                t.Errorf("#TestRemoveNbIdentitySuccess - failed to Marshal NbIdentity")
        }
-       sdlInstanceMock.On("RemoveMember", entities.Node_ENB.String(), []interface{}{nbIdData}).Return(fmt.Errorf("for test"))
+       sdlMock.On("RemoveMember", namespace, entities.Node_ENB.String(), []interface{}{nbIdData}).Return(fmt.Errorf("for test"))
 
        rNibErr := w.RemoveNbIdentity(entities.Node_ENB, nbIdentity)
        assert.NotNil(t, rNibErr)
-       sdlInstanceMock.AssertExpectations(t)
+       sdlMock.AssertExpectations(t)
 }
 
-func createNbIdentityProto(t *testing.T, ranName string, plmnId string, nbId string, connectionStatus entities.ConnectionStatus) ([]byte, *entities.NbIdentity){
+func createNbIdentityProto(t *testing.T, ranName string, plmnId string, nbId string, connectionStatus entities.ConnectionStatus) ([]byte, *entities.NbIdentity) {
        nbIdentity := &entities.NbIdentity{InventoryName: ranName, ConnectionStatus: connectionStatus, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
        nbIdData, err := proto.Marshal(nbIdentity)
        if err != nil {
                t.Errorf("#createNbIdentityProto - failed to Marshal NbIdentity")
        }
        return nbIdData, nbIdentity
-}
\ No newline at end of file
+}