// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
-//
+
+// This source code is part of the near-RT RIC (RAN Intelligent Controller)
+// platform project (RICP).
package rNibWriter
import (
+ "e2mgr/configuration"
"e2mgr/mocks"
+ "encoding/json"
"errors"
"fmt"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
"time"
)
-func TestInitRNibWriter(t *testing.T) {
- writerPool = nil
- initSdlInstanceMock(namespace, 1)
- available, created := writerPool.Stats()
- assert.Equal(t, available, 0, "number of available objects in the writerPool should be 0")
- assert.Equal(t, created, 0, "number of created objects in the writerPool should be 0")
- w := GetRNibWriter()
- assert.NotNil(t, w)
-}
-
-func TestInitPool(t *testing.T) {
- writerPool = nil
- sdlInstanceMock := new(mocks.MockSdlInstance)
- initPool(1, func() interface{} {
- sdlI := common.ISdlInstance(sdlInstanceMock)
- return &rNibWriterInstance{sdl: &sdlI, namespace: namespace}
- },
- func(obj interface{}) {
- },
- )
- assert.NotNil(t, writerPool)
- assert.NotNil(t, writerPool.New)
- assert.NotNil(t, writerPool.Destroy)
- available, created := writerPool.Stats()
- assert.Equal(t, 0, available, "number of available objects in the writerPool should be 0")
- assert.Equal(t, 0, created, "number of created objects in the writerPool should be 0")
-}
-
-var namespace = "namespace"
-
-func initSdlInstanceMock(namespace string, poolSize int) *mocks.MockSdlInstance {
- sdlInstanceMock := new(mocks.MockSdlInstance)
- initPool(poolSize, func() interface{} {
- sdlI := common.ISdlInstance(sdlInstanceMock)
- return &rNibWriterInstance{sdl: &sdlI, namespace: namespace}
- },
- func(obj interface{}) {
- },
- )
- return sdlInstanceMock
+var namespace = common.GetRNibNamespace()
+
+const (
+ RanName = "test"
+ PlmnId = "02f829"
+ NbId = "4a952a0a"
+)
+
+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
+}
+
+func generateNodebInfo(inventoryName string, nodeType entities.Node_Type, plmnId string, nbId string) *entities.NodebInfo {
+ nodebInfo := &entities.NodebInfo{
+ RanName: inventoryName,
+ GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId},
+ NodeType: nodeType,
+ ConnectionStatus: entities.ConnectionStatus_CONNECTED,
+ }
+
+ if nodeType == entities.Node_ENB {
+ nodebInfo.Configuration = &entities.NodebInfo_Enb{
+ Enb: &entities.Enb{},
+ }
+ } else if nodeType == entities.Node_GNB {
+ nodebInfo.Configuration = &entities.NodebInfo_Gnb{
+ Gnb: &entities.Gnb{},
+ }
+ }
+
+ return nodebInfo
+}
+
+func generateServedNrCells(cellIds ...string) []*entities.ServedNRCell {
+
+ var servedNrCells []*entities.ServedNRCell
+
+ for i, v := range cellIds {
+ servedNrCells = append(servedNrCells, &entities.ServedNRCell{ServedNrCellInformation: &entities.ServedNRCellInformation{
+ CellId: v,
+ ChoiceNrMode: &entities.ServedNRCellInformation_ChoiceNRMode{
+ Fdd: &entities.ServedNRCellInformation_ChoiceNRMode_FddInfo{},
+ },
+ NrMode: entities.Nr_FDD,
+ NrPci: uint32(i + 1),
+ ServedPlmns: []string{"whatever"},
+ }})
+ }
+
+ return servedNrCells
+}
+
+func generateServedCells(cellIds ...string) []*entities.ServedCellInfo {
+
+ var servedCells []*entities.ServedCellInfo
+
+ for i, v := range cellIds {
+ servedCells = append(servedCells, &entities.ServedCellInfo{
+ CellId: v,
+ ChoiceEutraMode: &entities.ChoiceEUTRAMode{
+ Fdd: &entities.FddInfo{},
+ },
+ Pci: uint32(i + 1),
+ BroadcastPlmns: []string{"whatever"},
+ })
+ }
+
+ return servedCells
+}
+
+func generateServedCellInfos(cellIds ...string) []*entities.ServedCellInfo {
+
+ servedCells := []*entities.ServedCellInfo{}
+
+ for i, v := range cellIds {
+ servedCells = append(servedCells, &entities.ServedCellInfo{
+ CellId: v,
+ Pci: uint32(i + 1),
+ })
+ }
+
+ return servedCells
+}
+
+func TestRemoveServedNrCellsSuccess(t *testing.T) {
+ w, sdlMock := initSdlMock()
+ servedNrCellsToRemove := generateServedNrCells("whatever1", "whatever2")
+ sdlMock.On("Remove", namespace, buildServedNRCellKeysToRemove(RanName, servedNrCellsToRemove)).Return(nil)
+ err := w.RemoveServedNrCells(RanName, servedNrCellsToRemove)
+ assert.Nil(t, err)
+}
+
+func TestRemoveServedNrCellsFailure(t *testing.T) {
+ w, sdlMock := initSdlMock()
+ servedNrCellsToRemove := generateServedNrCells("whatever1", "whatever2")
+ 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, sdlMock := initSdlMock()
+ servedNrCells := generateServedNrCells("test1", "test2")
+ nodebInfo := &entities.NodebInfo{}
+ sdlMock.AssertNotCalled(t, "SetAndPublish")
+ rNibErr := w.UpdateGnbCells(nodebInfo, servedNrCells)
+ assert.IsType(t, &common.ValidationError{}, rNibErr)
+}
+
+func TestAddNbIdentitySuccess(t *testing.T) {
+ w, sdlMock := initSdlMock()
+
+ 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)
+ }
+
+ 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, sdlMock := initSdlMock()
+
+ 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)
+ }
+
+ 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)
+}
+
+func TestUpdateGnbCellsInvalidCellFailure(t *testing.T) {
+ inventoryName := "name"
+ plmnId := "02f829"
+ nbId := "4a952a0a"
+ w, sdlMock := initSdlMock()
+ servedNrCells := []*entities.ServedNRCell{{ServedNrCellInformation: &entities.ServedNRCellInformation{}}}
+ nodebInfo := generateNodebInfo(inventoryName, entities.Node_GNB, plmnId, nbId)
+ nodebInfo.GetGnb().ServedNrCells = servedNrCells
+ sdlMock.AssertNotCalled(t, "SetAndPublish")
+ rNibErr := w.UpdateGnbCells(nodebInfo, servedNrCells)
+ assert.IsType(t, &common.ValidationError{}, rNibErr)
+}
+
+func getUpdateEnbCellsSetExpected(t *testing.T, nodebInfo *entities.NodebInfo, servedCells []*entities.ServedCellInfo) []interface{} {
+
+ nodebInfoData, err := proto.Marshal(nodebInfo)
+ if err != nil {
+ t.Fatalf("#rNibWriter_test.getUpdateEnbCellsSetExpected - Failed to marshal NodeB entity. Error: %s", err)
+ }
+
+ nodebNameKey, _ := common.ValidateAndBuildNodeBNameKey(nodebInfo.RanName)
+ nodebIdKey, _ := common.ValidateAndBuildNodeBIdKey(nodebInfo.NodeType.String(), nodebInfo.GlobalNbId.PlmnId, nodebInfo.GlobalNbId.NbId)
+ setExpected := []interface{}{nodebNameKey, nodebInfoData, nodebIdKey, nodebInfoData}
+
+ for _, cell := range servedCells {
+
+ cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: cell}}
+ cellData, err := proto.Marshal(&cellEntity)
+
+ if err != nil {
+ t.Fatalf("#rNibWriter_test.getUpdateEnbCellsSetExpected - Failed to marshal cell entity. Error: %s", err)
+ }
+
+ nrCellIdKey, _ := common.ValidateAndBuildCellIdKey(cell.GetCellId())
+ cellNamePciKey, _ := common.ValidateAndBuildCellNamePciKey(nodebInfo.RanName, cell.GetPci())
+ setExpected = append(setExpected, nrCellIdKey, cellData, cellNamePciKey, cellData)
+ }
+
+ return setExpected
+}
+
+func getUpdateGnbCellsSetExpected(t *testing.T, nodebInfo *entities.NodebInfo, servedNrCells []*entities.ServedNRCell) []interface{} {
+
+ nodebInfoData, err := proto.Marshal(nodebInfo)
+ if err != nil {
+ t.Fatalf("#rNibWriter_test.getUpdateGnbCellsSetExpected - Failed to marshal NodeB entity. Error: %s", err)
+ }
+
+ nodebNameKey, _ := common.ValidateAndBuildNodeBNameKey(nodebInfo.RanName)
+ nodebIdKey, _ := common.ValidateAndBuildNodeBIdKey(nodebInfo.NodeType.String(), nodebInfo.GlobalNbId.PlmnId, nodebInfo.GlobalNbId.NbId)
+ setExpected := []interface{}{nodebNameKey, nodebInfoData, nodebIdKey, nodebInfoData}
+
+ for _, v := range servedNrCells {
+
+ cellEntity := entities.Cell{Type: entities.Cell_NR_CELL, Cell: &entities.Cell_ServedNrCell{ServedNrCell: v}}
+ cellData, err := proto.Marshal(&cellEntity)
+
+ if err != nil {
+ t.Fatalf("#rNibWriter_test.getUpdateGnbCellsSetExpected - Failed to marshal cell entity. Error: %s", err)
+ }
+
+ nrCellIdKey, _ := common.ValidateAndBuildNrCellIdKey(v.GetServedNrCellInformation().GetCellId())
+ cellNamePciKey, _ := common.ValidateAndBuildCellNamePciKey(nodebInfo.RanName, v.GetServedNrCellInformation().GetNrPci())
+ setExpected = append(setExpected, nrCellIdKey, cellData, cellNamePciKey, cellData)
+ }
+
+ return setExpected
+}
+
+func TestUpdateGnbCellsSdlFailure(t *testing.T) {
+ inventoryName := "name"
+ plmnId := "02f829"
+ nbId := "4a952a0a"
+ w, sdlMock := initSdlMock()
+ servedNrCells := generateServedNrCells("test1", "test2")
+ nodebInfo := generateNodebInfo(inventoryName, entities.Node_GNB, plmnId, nbId)
+ nodebInfo.GetGnb().ServedNrCells = servedNrCells
+ setExpected := getUpdateGnbCellsSetExpected(t, nodebInfo, servedNrCells)
+ 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, 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
+ sdlMock.On("SetAndPublish", namespace, []string{"RAN_MANIPULATION", inventoryName + "_" + RanUpdatedEvent}, []interface{}{setExpected}).Return(e)
+ rNibErr := w.UpdateGnbCells(nodebInfo, servedNrCells)
+ assert.Nil(t, rNibErr)
}
func TestUpdateNodebInfoSuccess(t *testing.T) {
inventoryName := "name"
plmnId := "02f829"
nbId := "4a952a0a"
- writerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibWriter()
- nodebInfo := &entities.NodebInfo{}
- nodebInfo.RanName = inventoryName
- nodebInfo.GlobalNbId = &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
- nodebInfo.NodeType = entities.Node_ENB
- nodebInfo.ConnectionStatus = 1
- enb := entities.Enb{}
- nodebInfo.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
+ 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)
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)
+ sdlMock.AssertExpectations(t)
+}
+
+func TestUpdateNodebInfoAndPublishSuccess(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)
+ }
+ var e 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{"RAN_MANIPULATION", inventoryName + "_" + RanUpdatedEvent}, []interface{}{setExpected}).Return(e)
+
+ rNibErr := w.UpdateNodebInfoAndPublish(nodebInfo)
+ assert.Nil(t, rNibErr)
+ sdlMock.AssertExpectations(t)
}
func TestUpdateNodebInfoMissingInventoryNameFailure(t *testing.T) {
inventoryName := "name"
plmnId := "02f829"
nbId := "4a952a0a"
- writerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibWriter()
+ w, sdlMock := initSdlMock()
nodebInfo := &entities.NodebInfo{}
data, err := proto.Marshal(nodebInfo)
if err != nil {
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)
func TestUpdateNodebInfoMissingGlobalNbId(t *testing.T) {
inventoryName := "name"
- writerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibWriter()
+ w, sdlMock := initSdlMock()
nodebInfo := &entities.NodebInfo{}
nodebInfo.RanName = inventoryName
data, err := proto.Marshal(nodebInfo)
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) {
- name := "name"
- ranName := "RAN:" + name
- writerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibWriter()
- nb := entities.NodebInfo{}
- nb.NodeType = entities.Node_ENB
- nb.ConnectionStatus = 1
- nb.Ip = "localhost"
- nb.Port = 5656
+ ranName := "RAN:" + RanName
+ w, sdlMock := initSdlMock()
+ nb := entities.NodebInfo{
+ RanName: RanName,
+ NodeType: entities.Node_ENB,
+ ConnectionStatus: entities.ConnectionStatus_CONNECTED,
+ Ip: "localhost",
+ Port: 5656,
+ GlobalNbId: &entities.GlobalNbId{
+ NbId: "4a952a0a",
+ PlmnId: "02f829",
+ },
+ }
+
enb := entities.Enb{}
cell := &entities.ServedCellInfo{CellId: "aaff", Pci: 3}
cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: cell}}
setExpected = append(setExpected, ranName, data)
setExpected = append(setExpected, "ENB:02f829:4a952a0a", data)
setExpected = append(setExpected, fmt.Sprintf("CELL:%s", cell.GetCellId()), cellData)
- setExpected = append(setExpected, fmt.Sprintf("PCI:%s:%02x", name, cell.GetPci()), cellData)
-
- sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
-
- nbIdData, err := proto.Marshal(&entities.NbIdentity{InventoryName: name})
- if err != nil {
- t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal nbIdentity entity. Error: %v", err)
- }
- sdlInstanceMock.On("RemoveMember", entities.Node_UNKNOWN.String(), []interface{}{nbIdData}).Return(e)
-
- nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: "02f829", NbId: "4a952a0a"}}
- nbIdData, err = proto.Marshal(nbIdentity)
- if err != nil {
- t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal NodeB Identity entity. Error: %v", err)
- }
- sdlInstanceMock.On("AddMember", "ENB", []interface{}{nbIdData}).Return(e)
+ setExpected = append(setExpected, fmt.Sprintf("PCI:%s:%02x", RanName, cell.GetPci()), cellData)
- rNibErr := w.SaveNodeb(nbIdentity, &nb)
+ sdlMock.On("Set", namespace, []interface{}{setExpected}).Return(e)
+ rNibErr := w.SaveNodeb(&nb)
assert.Nil(t, rNibErr)
}
func TestSaveEnbCellIdValidationFailure(t *testing.T) {
- name := "name"
- writerPool = nil
- initSdlInstanceMock(namespace, 1)
- w := GetRNibWriter()
+ w, _ := initSdlMock()
nb := entities.NodebInfo{}
+ nb.RanName = "name"
nb.NodeType = entities.Node_ENB
nb.ConnectionStatus = 1
nb.Ip = "localhost"
cell := &entities.ServedCellInfo{Pci: 3}
enb.ServedCells = []*entities.ServedCellInfo{cell}
nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
-
- nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: "02f829", NbId: "4a952a0a"}}
- rNibErr := w.SaveNodeb(nbIdentity, &nb)
+ rNibErr := w.SaveNodeb(&nb)
assert.NotNil(t, rNibErr)
assert.IsType(t, &common.ValidationError{}, rNibErr)
assert.Equal(t, "#utils.ValidateAndBuildCellIdKey - an empty cell id received", rNibErr.Error())
}
func TestSaveEnbInventoryNameValidationFailure(t *testing.T) {
- writerPool = nil
- initSdlInstanceMock(namespace, 1)
- w := GetRNibWriter()
- nb := entities.NodebInfo{}
- nb.NodeType = entities.Node_ENB
- nb.ConnectionStatus = 1
- nb.Ip = "localhost"
- nb.Port = 5656
+ w, _ := initSdlMock()
+ nb := entities.NodebInfo{
+ NodeType: entities.Node_ENB,
+ ConnectionStatus: entities.ConnectionStatus_CONNECTED,
+ Ip: "localhost",
+ Port: 5656,
+ GlobalNbId: &entities.GlobalNbId{
+ NbId: "4a952a0a",
+ PlmnId: "02f829",
+ },
+ }
enb := entities.Enb{}
cell := &entities.ServedCellInfo{CellId: "aaa", Pci: 3}
enb.ServedCells = []*entities.ServedCellInfo{cell}
nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
-
- nbIdentity := &entities.NbIdentity{InventoryName: "", GlobalNbId: &entities.GlobalNbId{PlmnId: "02f829", NbId: "4a952a0a"}}
- rNibErr := w.SaveNodeb(nbIdentity, &nb)
+ rNibErr := w.SaveNodeb(&nb)
assert.NotNil(t, rNibErr)
assert.IsType(t, &common.ValidationError{}, rNibErr)
assert.Equal(t, "#utils.ValidateAndBuildNodeBNameKey - an empty inventory name received", rNibErr.Error())
}
-func TestSaveEnbOnClosedPool(t *testing.T) {
- name := "name"
- writerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibWriter()
- nb := entities.NodebInfo{}
- nb.NodeType = entities.Node_ENB
- nb.ConnectionStatus = 1
- nb.Ip = "localhost"
- nb.Port = 5656
+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}
- data, err := proto.Marshal(&nb)
- if err != nil {
- t.Errorf("#rNibWriter_test.TestSaveEnbOnClosedPool - Failed to marshal NodeB entity. Error: %v", err)
- }
- setExpected := []interface{}{name, data}
- var e error
- sdlInstanceMock.On("Set", setExpected).Return(e)
- writerPool.Close()
- nbIdentity := &entities.NbIdentity{}
- assert.Panics(t, func() { w.SaveNodeb(nbIdentity, &nb) })
+ 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) {
- name := "name"
- writerPool = nil
- initSdlInstanceMock(namespace, 1)
- w := GetRNibWriter()
+ w, _ := initSdlMock()
nb := entities.NodebInfo{}
+ nb.RanName = "name"
nb.NodeType = entities.Node_GNB
nb.ConnectionStatus = 1
nb.Ip = "localhost"
gnb.ServedNrCells = []*entities.ServedNRCell{cell}
nb.Configuration = &entities.NodebInfo_Gnb{Gnb: &gnb}
- nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: "02f829", NbId: "4a952a0a"}}
- rNibErr := w.SaveNodeb(nbIdentity, &nb)
+ rNibErr := w.SaveNodeb(&nb)
assert.NotNil(t, rNibErr)
assert.IsType(t, &common.ValidationError{}, rNibErr)
assert.Equal(t, "#utils.ValidateAndBuildNrCellIdKey - an empty cell id received", rNibErr.Error())
}
func TestSaveGnb(t *testing.T) {
- name := "name"
- ranName := "RAN:" + name
- writerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibWriter()
- nb := entities.NodebInfo{}
- nb.NodeType = entities.Node_GNB
- nb.ConnectionStatus = 1
- nb.Ip = "localhost"
- nb.Port = 5656
+ ranName := "RAN:" + RanName
+ w, sdlMock := initSdlMock()
+ nb := entities.NodebInfo{
+ RanName: RanName,
+ NodeType: entities.Node_GNB,
+ ConnectionStatus: 1,
+ GlobalNbId: &entities.GlobalNbId{
+ NbId: "4a952a0a",
+ PlmnId: "02f829",
+ },
+ Ip: "localhost",
+ Port: 5656,
+ }
+
gnb := entities.Gnb{}
cellInfo := &entities.ServedNRCellInformation{NrPci: 2, CellId: "ccdd"}
cell := &entities.ServedNRCell{ServedNrCellInformation: cellInfo}
setExpected = append(setExpected, ranName, data)
setExpected = append(setExpected, "GNB:02f829:4a952a0a", data)
setExpected = append(setExpected, fmt.Sprintf("NRCELL:%s", cell.GetServedNrCellInformation().GetCellId()), cellData)
- setExpected = append(setExpected, fmt.Sprintf("PCI:%s:%02x", name, cell.GetServedNrCellInformation().GetNrPci()), cellData)
-
- sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
- nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: "02f829", NbId: "4a952a0a"}}
- nbIdData, err := proto.Marshal(nbIdentity)
- if err != nil {
- t.Errorf("#rNibWriter_test.TestSaveGnb - Failed to marshal NodeB Identity entity. Error: %v", err)
- }
- sdlInstanceMock.On("AddMember", "GNB", []interface{}{nbIdData}).Return(e)
+ setExpected = append(setExpected, fmt.Sprintf("PCI:%s:%02x", RanName, cell.GetServedNrCellInformation().GetNrPci()), cellData)
- nbIdData, err = proto.Marshal(&entities.NbIdentity{InventoryName: name})
- if err != nil {
- t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal nbIdentity entity. Error: %v", err)
- }
- sdlInstanceMock.On("RemoveMember", entities.Node_UNKNOWN.String(), []interface{}{nbIdData}).Return(e)
-
- rNibErr := w.SaveNodeb(nbIdentity, &nb)
+ sdlMock.On("Set", namespace, []interface{}{setExpected}).Return(e)
+ rNibErr := w.SaveNodeb(&nb)
assert.Nil(t, rNibErr)
}
t.Errorf("#rNibWriter_test.TestSaveRanLoadInformationSuccess - Failed to build ran load infromation key. Error: %v", validationErr)
}
- writerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibWriter()
+ w, sdlMock := initSdlMock()
ranLoadInformation := generateRanLoadInformation()
data, err := proto.Marshal(ranLoadInformation)
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)
func TestSaveRanLoadInformationMarshalNilFailure(t *testing.T) {
inventoryName := "name2"
- writerPool = nil
- initSdlInstanceMock(namespace, 1)
- w := GetRNibWriter()
+ w, _ := initSdlMock()
expectedErr := common.NewInternalError(errors.New("proto: Marshal called with nil"))
err := w.SaveRanLoadInformation(inventoryName, nil)
func TestSaveRanLoadInformationEmptyInventoryNameFailure(t *testing.T) {
inventoryName := ""
- writerPool = nil
- initSdlInstanceMock(namespace, 1)
- w := GetRNibWriter()
+ w, _ := initSdlMock()
err := w.SaveRanLoadInformation(inventoryName, nil)
assert.NotNil(t, err)
t.Errorf("#rNibWriter_test.TestSaveRanLoadInformationSuccess - Failed to build ran load infromation key. Error: %v", validationErr)
}
- writerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibWriter()
+ w, sdlMock := initSdlMock()
ranLoadInformation := generateRanLoadInformation()
data, err := proto.Marshal(ranLoadInformation)
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)
}
compInformationItem := &entities.CompInformationItem{
- CompHypothesisSets: []*entities.CompHypothesisSet{&entities.CompHypothesisSet{CellId: "789", CompHypothesis: "xxx"}},
+ CompHypothesisSets: []*entities.CompHypothesisSet{{CellId: "789", CompHypothesis: "xxx"}},
BenefitMetric: 50,
}
}
func TestSaveNilEntityFailure(t *testing.T) {
- writerPool = nil
- initSdlInstanceMock(namespace, 1)
- w := GetRNibWriter()
+ w, _ := initSdlMock()
expectedErr := common.NewInternalError(errors.New("proto: Marshal called with nil"))
- nbIdentity := &entities.NbIdentity{}
- actualErr := w.SaveNodeb(nbIdentity, nil)
+ actualErr := w.SaveNodeb(nil)
assert.Equal(t, expectedErr, actualErr)
}
func TestSaveUnknownTypeEntityFailure(t *testing.T) {
- writerPool = nil
- initSdlInstanceMock(namespace, 1)
- w := GetRNibWriter()
- expectedErr := common.NewValidationError("#rNibWriter.saveNodeB - Unknown responding node type, entity: ip:\"localhost\" port:5656 ")
- nbIdentity := &entities.NbIdentity{InventoryName: "name", GlobalNbId: &entities.GlobalNbId{PlmnId: "02f829", NbId: "4a952a0a"}}
+ w, _ := initSdlMock()
nb := &entities.NodebInfo{}
nb.Port = 5656
nb.Ip = "localhost"
- actualErr := w.SaveNodeb(nbIdentity, nb)
- assert.Equal(t, expectedErr, actualErr)
+ actualErr := w.SaveNodeb(nb)
+ assert.IsType(t, &common.ValidationError{}, actualErr)
}
-func TestSaveEntityFailure(t *testing.T) {
+func TestSaveEntitySetFailure(t *testing.T) {
name := "name"
plmnId := "02f829"
nbId := "4a952a0a"
- writerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibWriter()
- gnb := entities.NodebInfo{}
- gnb.NodeType = entities.Node_GNB
+ w, sdlMock := initSdlMock()
+ gnb := entities.NodebInfo{
+ RanName: name,
+ NodeType: entities.Node_GNB,
+ ConnectionStatus: 1,
+ GlobalNbId: &entities.GlobalNbId{
+ NbId: nbId,
+ PlmnId: plmnId,
+ },
+ Ip: "localhost",
+ Port: 5656,
+ }
data, err := proto.Marshal(&gnb)
if err != nil {
t.Errorf("#rNibWriter_test.TestSaveEntityFailure - Failed to marshal NodeB entity. Error: %v", err)
}
- nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
setExpected := []interface{}{"RAN:" + name, data}
setExpected = append(setExpected, "GNB:"+plmnId+":"+nbId, data)
expectedErr := errors.New("expected error")
- sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(expectedErr)
- rNibErr := w.SaveNodeb(nbIdentity, &gnb)
+ sdlMock.On("Set", namespace, []interface{}{setExpected}).Return(expectedErr)
+ rNibErr := w.SaveNodeb(&gnb)
assert.NotEmpty(t, rNibErr)
}
-func TestGetRNibWriterPoolNotInitializedFailure(t *testing.T) {
- writerPool = nil
- assert.Panics(t, func() { GetRNibWriter().SaveNodeb(nil,nil) })
+func TestSaveEntitySetAndPublishFailure(t *testing.T) {
+ name := "name"
+ plmnId := "02f829"
+ nbId := "4a952a0a"
+
+ w, sdlMock := initSdlMock()
+ enb := entities.NodebInfo{
+ RanName: name,
+ NodeType: entities.Node_ENB,
+ ConnectionStatus: 1,
+ GlobalNbId: &entities.GlobalNbId{
+ NbId: nbId,
+ PlmnId: plmnId,
+ },
+ Ip: "localhost",
+ Port: 5656,
+ }
+ data, err := proto.Marshal(&enb)
+ if err != nil {
+ t.Errorf("#rNibWriter_test.TestSaveEntityFailure - Failed to marshal NodeB entity. Error: %v", err)
+ }
+ setExpected := []interface{}{"RAN:" + name, data}
+ setExpected = append(setExpected, "ENB:"+plmnId+":"+nbId, data)
+ expectedErr := errors.New("expected error")
+ 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) {
- writerPool = nil
- initSdlInstanceMock(namespace, 1)
- received := GetRNibWriter()
- assert.Empty(t, received)
- available, created := writerPool.Stats()
- assert.Equal(t, 0, available, "number of available objects in the writerPool should be 0")
- assert.Equal(t, 0, created, "number of created objects in the writerPool should be 0")
- writerPool.Close()
-}
-
-func TestClose(t *testing.T) {
- writerPool = nil
- instanceMock := initSdlInstanceMock(namespace, 2)
- w1 := GetRNibWriter()
- w2 := GetRNibWriter()
- writerPool.Put(w1)
- writerPool.Put(w2)
- available, created := writerPool.Stats()
- assert.Equal(t, 2, available, "number of available objects in the writerPool should be 2")
- assert.Equal(t, 0, created, "number of created objects in the writerPool should be 0")
- var e error
- instanceMock.On("Close").Return(e)
- Close()
- available, created = writerPool.Stats()
- assert.Equal(t, 0, available, "number of available objects in the writerPool should be 0")
-}
-
-func TestCloseOnClosedPoolFailure(t *testing.T) {
- writerPool = nil
- instanceMock := initSdlInstanceMock(namespace, 1)
- w1 := GetRNibWriter()
- writerPool.Put(w1)
- available, created := writerPool.Stats()
- assert.Equal(t, 1, available, "number of available objects in the writerPool should be 1")
- assert.Equal(t, 0, created, "number of created objects in the writerPool should be 0")
+ received, _ := initSdlMock()
+ assert.NotEmpty(t, received)
+}
+
+func TestSaveE2TInstanceSuccess(t *testing.T) {
+ address := "10.10.2.15:9800"
+ loadKey, validationErr := common.ValidateAndBuildE2TInstanceKey(address)
+
+ if validationErr != nil {
+ t.Errorf("#rNibWriter_test.TestSaveE2TInstanceSuccess - Failed to build E2T Instance key. Error: %v", validationErr)
+ }
+
+ w, sdlMock := initSdlMock()
+
+ e2tInstance := generateE2tInstance(address)
+ data, err := json.Marshal(e2tInstance)
+
+ if err != nil {
+ t.Errorf("#rNibWriter_test.TestSaveE2TInstanceSuccess - Failed to marshal E2tInstance entity. Error: %v", err)
+ }
+
var e error
- instanceMock.On("Close").Return(e)
- Close()
- assert.Panics(t, func() { Close() })
-}
-
-func TestCloseFailure(t *testing.T) {
- writerPool = nil
- instanceMock := initSdlInstanceMock(namespace, 2)
- w1 := GetRNibWriter()
- writerPool.Put(w1)
- available, created := writerPool.Stats()
- assert.Equal(t, 1, available, "number of available objects in the writerPool should be 1")
- assert.Equal(t, 0, created, "number of created objects in the writerPool should be 0")
- e := errors.New("expected error")
- instanceMock.On("Close").Return(e)
- Close()
- available, created = writerPool.Stats()
- assert.Equal(t, 0, available, "number of available objects in the writerPool should be 0")
+ var setExpected []interface{}
+ setExpected = append(setExpected, loadKey, data)
+ sdlMock.On("Set", namespace, []interface{}{setExpected}).Return(e)
+
+ rNibErr := w.SaveE2TInstance(e2tInstance)
+ assert.Nil(t, rNibErr)
}
-func TestInit(t *testing.T) {
- writerPool = nil
- Init("", 1)
- assert.NotNil(t, writerPool)
- assert.NotNil(t, writerPool.New)
- assert.NotNil(t, writerPool.Destroy)
- available, created := writerPool.Stats()
- assert.Equal(t, 0, available, "number of available objects in the writerPool should be 0")
- assert.Equal(t, 0, created, "number of created objects in the writerPool should be 0")
+func TestSaveE2TInstanceNullE2tInstanceFailure(t *testing.T) {
+ w, _ := initSdlMock()
+ var address string
+ e2tInstance := entities.NewE2TInstance(address, "test")
+ err := w.SaveE2TInstance(e2tInstance)
+ assert.NotNil(t, err)
+ assert.IsType(t, &common.ValidationError{}, err)
}
-//Integration tests
-//
-//func TestSaveEnbGnbInteg(t *testing.T){
-// for i := 0; i<10; i++{
-// Init("e2Manager", 1)
-// w := GetRNibWriter()
-// nb := entities.NodebInfo{}
-// nb.NodeType = entities.Node_ENB
-// nb.ConnectionStatus = entities.ConnectionStatus_CONNECTED
-// nb.Ip = "localhost"
-// nb.Port = uint32(5656 + i)
-// enb := entities.Enb{}
-// cell1 := &entities.ServedCellInfo{CellId:fmt.Sprintf("%02x",111 + i), Pci:uint32(11 + i)}
-// cell2 := &entities.ServedCellInfo{CellId:fmt.Sprintf("%02x",222 + i), Pci:uint32(22 + i)}
-// cell3 := &entities.ServedCellInfo{CellId:fmt.Sprintf("%02x",333 + i), Pci:uint32(33 + i)}
-// enb.ServedCells = []*entities.ServedCellInfo{cell1, cell2, cell3}
-// nb.Configuration = &entities.NodebInfo_Enb{Enb:&enb}
-// plmnId := 0x02f828
-// nbId := 0x4a952a0a
-// nbIdentity := &entities.NbIdentity{InventoryName: fmt.Sprintf("nameEnb%d" ,i), GlobalNbId:&entities.GlobalNbId{PlmnId:fmt.Sprintf("%02x", plmnId + i), NbId:fmt.Sprintf("%02x", nbId + i)}}
-// err := w.SaveNodeb(nbIdentity, &nb)
-// if err != nil{
-// t.Errorf("#rNibWriter_test.TestSaveEnbInteg - Failed to save NodeB entity. Error: %v", err)
-// }
-//
-// nb1 := entities.NodebInfo{}
-// nb1.NodeType = entities.Node_GNB
-// nb1.ConnectionStatus = entities.ConnectionStatus_CONNECTED
-// nb1.Ip = "localhost"
-// nb1.Port = uint32(6565 + i)
-// gnb := entities.Gnb{}
-// gCell1 := &entities.ServedNRCell{ServedNrCellInformation:&entities.ServedNRCellInformation{CellId:fmt.Sprintf("%02x",1111 + i), NrPci:uint32(1 + i)}}
-// gCell2 := &entities.ServedNRCell{ServedNrCellInformation:&entities.ServedNRCellInformation{CellId:fmt.Sprintf("%02x",2222 + i), NrPci:uint32(2 + i)}}
-// gCell3 := &entities.ServedNRCell{ServedNrCellInformation:&entities.ServedNRCellInformation{CellId:fmt.Sprintf("%02x",3333 + i), NrPci:uint32(3 + i)}}
-// gnb.ServedNrCells = []*entities.ServedNRCell{gCell1, gCell2, gCell3,}
-// nb1.Configuration = &entities.NodebInfo_Gnb{Gnb:&gnb}
-// nbIdentity = &entities.NbIdentity{InventoryName: fmt.Sprintf("nameGnb%d" ,i), GlobalNbId:&entities.GlobalNbId{PlmnId:fmt.Sprintf("%02x", plmnId - i), NbId:fmt.Sprintf("%02x", nbId - i)}}
-// err = w.SaveNodeb(nbIdentity, &nb1)
-// if err != nil{
-// t.Errorf("#rNibWriter_test.TestSaveEnbInteg - Failed to save NodeB entity. Error: %v", err)
-// }
-// }
-//}
-//
-//func TestSaveNbRanNamesInteg(t *testing.T){
-// for i := 0; i<10; i++{
-// Init("e2Manager", 1)
-// w := GetRNibWriter()
-// nb := entities.NodebInfo{}
-// nb.ConnectionStatus = entities.ConnectionStatus_CONNECTING
-// nb.Ip = "localhost"
-// nb.Port = uint32(5656 + i)
-// nbIdentity := &entities.NbIdentity{InventoryName: fmt.Sprintf("nameOnly%d" ,i)}
-// err := w.SaveNodeb(nbIdentity, &nb)
-// if err != nil{
-// t.Errorf("#rNibWriter_test.TestSaveEnbInteg - Failed to save NodeB entity. Error: %v", err)
-// }
-// }
-//}
-//
-//func TestSaveRanLoadInformationInteg(t *testing.T){
-// Init("e2Manager", 1)
-// w := GetRNibWriter()
-// ranLoadInformation := generateRanLoadInformation()
-// err := w.SaveRanLoadInformation("ran_integ", ranLoadInformation)
-// if err != nil{
-// t.Errorf("#rNibWriter_test.TestSaveRanLoadInformationInteg - Failed to save RanLoadInformation entity. Error: %v", err)
-// }
-//}
+func TestSaveE2TInstanceSdlFailure(t *testing.T) {
+ address := "10.10.2.15:9800"
+ loadKey, validationErr := common.ValidateAndBuildE2TInstanceKey(address)
+
+ if validationErr != nil {
+ t.Errorf("#rNibWriter_test.TestSaveE2TInstanceSdlFailure - Failed to build E2T Instance key. Error: %v", validationErr)
+ }
+
+ w, sdlMock := initSdlMock()
+
+ e2tInstance := generateE2tInstance(address)
+ data, err := json.Marshal(e2tInstance)
+
+ if err != nil {
+ t.Errorf("#rNibWriter_test.TestSaveE2TInstanceSdlFailure - Failed to marshal E2tInstance entity. Error: %v", err)
+ }
+
+ expectedErr := errors.New("expected error")
+ var setExpected []interface{}
+ setExpected = append(setExpected, loadKey, data)
+ sdlMock.On("Set", namespace, []interface{}{setExpected}).Return(expectedErr)
+
+ rNibErr := w.SaveE2TInstance(e2tInstance)
+ assert.NotNil(t, rNibErr)
+ assert.IsType(t, &common.InternalError{}, rNibErr)
+}
+
+func generateE2tInstance(address string) *entities.E2TInstance {
+ e2tInstance := entities.NewE2TInstance(address, "pod test")
+
+ e2tInstance.AssociatedRanList = []string{"test1", "test2"}
+
+ return e2tInstance
+}
+
+func TestSaveE2TAddressesSuccess(t *testing.T) {
+ address := "10.10.2.15:9800"
+ w, sdlMock := initSdlMock()
+
+ e2tAddresses := []string{address}
+ data, err := json.Marshal(e2tAddresses)
+
+ if err != nil {
+ t.Errorf("#rNibWriter_test.TestSaveE2TInfoListSuccess - Failed to marshal E2TInfoList. Error: %v", err)
+ }
+
+ var e error
+ var setExpected []interface{}
+ setExpected = append(setExpected, E2TAddressesKey, data)
+ sdlMock.On("Set", namespace, []interface{}{setExpected}).Return(e)
+
+ rNibErr := w.SaveE2TAddresses(e2tAddresses)
+ assert.Nil(t, rNibErr)
+}
+
+func TestSaveE2TAddressesSdlFailure(t *testing.T) {
+ address := "10.10.2.15:9800"
+ w, sdlMock := initSdlMock()
+
+ e2tAddresses := []string{address}
+ data, err := json.Marshal(e2tAddresses)
+
+ if err != nil {
+ t.Errorf("#rNibWriter_test.TestSaveE2TInfoListSdlFailure - Failed to marshal E2TInfoList. Error: %v", err)
+ }
+
+ expectedErr := errors.New("expected error")
+ var setExpected []interface{}
+ setExpected = append(setExpected, E2TAddressesKey, data)
+ sdlMock.On("Set", namespace, []interface{}{setExpected}).Return(expectedErr)
+
+ rNibErr := w.SaveE2TAddresses(e2tAddresses)
+ assert.NotNil(t, rNibErr)
+ assert.IsType(t, &common.InternalError{}, rNibErr)
+}
+
+func TestRemoveE2TInstanceSuccess(t *testing.T) {
+ address := "10.10.2.15:9800"
+ w, sdlMock := initSdlMock()
+
+ e2tAddresses := []string{fmt.Sprintf("E2TInstance:%s", address)}
+ var e error
+ sdlMock.On("Remove", namespace, e2tAddresses).Return(e)
+
+ rNibErr := w.RemoveE2TInstance(address)
+ assert.Nil(t, rNibErr)
+ sdlMock.AssertExpectations(t)
+}
+
+func TestRemoveE2TInstanceSdlFailure(t *testing.T) {
+ address := "10.10.2.15:9800"
+ w, sdlMock := initSdlMock()
+
+ e2tAddresses := []string{fmt.Sprintf("E2TInstance:%s", address)}
+ expectedErr := errors.New("expected error")
+ sdlMock.On("Remove", namespace, e2tAddresses).Return(expectedErr)
+
+ rNibErr := w.RemoveE2TInstance(address)
+ assert.IsType(t, &common.InternalError{}, rNibErr)
+}
+
+func TestRemoveE2TInstanceEmptyAddressFailure(t *testing.T) {
+ w, sdlMock := initSdlMock()
+
+ rNibErr := w.RemoveE2TInstance("")
+ assert.IsType(t, &common.ValidationError{}, rNibErr)
+ sdlMock.AssertExpectations(t)
+}
+
+func TestUpdateNodebInfoOnConnectionStatusInversionSuccess(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)
+ }
+ var e 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.Nil(t, rNibErr)
+}
+
+func TestUpdateNodebInfoOnConnectionStatusInversionMissingInventoryNameFailure(t *testing.T) {
+ inventoryName := "name"
+ plmnId := "02f829"
+ nbId := "4a952a0a"
+ channelName := "RAN_CONNECTION_STATUS_CHANGE"
+ eventName := inventoryName + "_" + "CONNECTED"
+ w, sdlMock := initSdlMock()
+ nodebInfo := &entities.NodebInfo{}
+ data, err := proto.Marshal(nodebInfo)
+ if err != nil {
+ t.Errorf("#rNibWriter_test.TestUpdateNodebInfoOnConnectionStatusInversionMissingInventoryNameFailure - Failed to marshal NodeB entity. Error: %v", err)
+ }
+ var e 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.ValidationError{}, rNibErr)
+}
+
+func TestUpdateNodebInfoOnConnectionStatusInversionMissingGlobalNbId(t *testing.T) {
+ inventoryName := "name"
+ channelName := "RAN_CONNECTION_STATUS_CHANGE"
+ eventName := inventoryName + "_" + "CONNECTED"
+ w, sdlMock := initSdlMock()
+ nodebInfo := &entities.NodebInfo{}
+ nodebInfo.RanName = inventoryName
+ data, err := proto.Marshal(nodebInfo)
+ if err != nil {
+ t.Errorf("#rNibWriter_test.TestUpdateNodebInfoOnConnectionStatusInversionMissingInventoryNameFailure - Failed to marshal NodeB entity. Error: %v", err)
+ }
+ var e error
+ var setExpected []interface{}
+
+ nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
+ setExpected = append(setExpected, nodebNameKey, data)
+ 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, sdlMock := initSdlMock()
+
+ key := common.BuildGeneralConfigurationKey()
+ configurationData := "{\"enableRic\":true}"
+ configuration := &entities.GeneralConfiguration{}
+ configuration.EnableRic = true
+
+ sdlMock.On("Set", namespace, []interface{}{[]interface{}{key, []byte(configurationData)}}).Return(nil)
+ rNibErr := w.SaveGeneralConfiguration(configuration)
+
+ assert.Nil(t, rNibErr)
+ sdlMock.AssertExpectations(t)
+}
+
+func TestSaveGeneralConfigurationDbError(t *testing.T) {
+ w, sdlMock := initSdlMock()
+
+ key := common.BuildGeneralConfigurationKey()
+ configurationData := "{\"enableRic\":true}"
+ configuration := &entities.GeneralConfiguration{}
+ configuration.EnableRic = true
+
+ expectedErr := errors.New("expected error")
+
+ 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, sdlMock := initSdlMock()
+ servedCellsToRemove := generateServedCells("whatever1", "whatever2")
+ expectedErr := errors.New("expected error")
+ sdlMock.On("Remove", namespace, buildServedCellInfoKeysToRemove(RanName, servedCellsToRemove)).Return(expectedErr)
+
+ rNibErr := w.RemoveServedCells(RanName, servedCellsToRemove)
+
+ assert.NotNil(t, rNibErr)
+}
+
+func TestRemoveServedCellsSuccess(t *testing.T) {
+ w, sdlMock := initSdlMock()
+ servedCellsToRemove := generateServedCells("whatever1", "whatever2")
+ sdlMock.On("Remove", namespace, buildServedCellInfoKeysToRemove(RanName, servedCellsToRemove)).Return(nil)
+ err := w.RemoveServedCells(RanName, servedCellsToRemove)
+ assert.Nil(t, err)
+}
+
+func TestUpdateEnbInvalidNodebInfoFailure(t *testing.T) {
+ w, sdlMock := initSdlMock()
+ servedCells := generateServedCells("test1", "test2")
+ nodebInfo := &entities.NodebInfo{}
+ sdlMock.AssertNotCalled(t, "SetAndPublish")
+ rNibErr := w.UpdateEnb(nodebInfo, servedCells)
+ assert.IsType(t, &common.ValidationError{}, rNibErr)
+}
+
+func TestUpdateEnbInvalidCellFailure(t *testing.T) {
+ inventoryName := "name"
+ plmnId := "02f829"
+ nbId := "4a952a0a"
+ w, sdlMock := initSdlMock()
+ servedCells := []*entities.ServedCellInfo{{CellId: ""}}
+ nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
+ nodebInfo.GetEnb().ServedCells = servedCells
+ 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)
+}
+
+func TestUpdateEnbSdlFailure(t *testing.T) {
+ inventoryName := "name"
+ plmnId := "02f829"
+ nbId := "4a952a0a"
+ w, sdlMock := initSdlMock()
+ servedCells := generateServedCells("test1", "test2")
+ nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
+ nodebInfo.GetEnb().ServedCells = servedCells
+ setExpected := getUpdateEnbCellsSetExpected(t, nodebInfo, servedCells)
+ 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)
+}
+
+func TestUpdateEnbSuccess(t *testing.T) {
+ inventoryName := "name"
+ plmnId := "02f829"
+ nbId := "4a952a0a"
+ 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
+ sdlMock.On("SetAndPublish", namespace, []string{"RAN_MANIPULATION", inventoryName + "_" + RanUpdatedEvent}, []interface{}{setExpected}).Return(e)
+ rNibErr := w.UpdateEnb(nodebInfo, servedCells)
+ assert.Nil(t, rNibErr)
+}
+
+func getUpdateEnbSetExpected(t *testing.T, nodebInfo *entities.NodebInfo, servedCells []*entities.ServedCellInfo) []interface{} {
+
+ nodebInfoData, err := proto.Marshal(nodebInfo)
+ if err != nil {
+ t.Fatalf("#rNibWriter_test.getUpdateEnbSetExpected - Failed to marshal NodeB entity. Error: %s", err)
+ }
+
+ nodebNameKey, _ := common.ValidateAndBuildNodeBNameKey(nodebInfo.RanName)
+ nodebIdKey, _ := common.ValidateAndBuildNodeBIdKey(nodebInfo.NodeType.String(), nodebInfo.GlobalNbId.PlmnId, nodebInfo.GlobalNbId.NbId)
+ setExpected := []interface{}{nodebNameKey, nodebInfoData, nodebIdKey, nodebInfoData}
+
+ for _, v := range servedCells {
+
+ cellEntity := entities.ServedCellInfo{CellId: "some cell id", EutraMode: entities.Eutra_FDD, CsgId: "some csg id"}
+ cellData, err := proto.Marshal(&cellEntity)
+
+ if err != nil {
+ t.Fatalf("#rNibWriter_test.getUpdateEnbSetExpected - Failed to marshal cell entity. Error: %s", err)
+ }
+
+ nrCellIdKey, _ := common.ValidateAndBuildNrCellIdKey(v.GetCellId())
+ cellNamePciKey, _ := common.ValidateAndBuildCellNamePciKey(nodebInfo.RanName, v.GetPci())
+ setExpected = append(setExpected, nrCellIdKey, cellData, cellNamePciKey, cellData)
+ }
+ return setExpected
+}
+
+func TestRemoveEnbSuccess(t *testing.T) {
+ inventoryName := "name"
+ plmnId := "02f829"
+ nbId := "4a952a0a"
+ channelName := "RAN_MANIPULATION"
+ eventName := inventoryName + "_" + "DELETED"
+ w, sdlMock := initSdlMock()
+ nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
+ nodebInfo.GetEnb().ServedCells = generateServedCellInfos("cell1", "cell2")
+
+ var e error
+
+ expectedKeys := []string{}
+ cell1Key := fmt.Sprintf("CELL:%s", nodebInfo.GetEnb().ServedCells[0].CellId)
+ cell1PciKey := fmt.Sprintf("PCI:%s:%02x", inventoryName, nodebInfo.GetEnb().ServedCells[0].Pci)
+ cell2Key := fmt.Sprintf("CELL:%s", nodebInfo.GetEnb().ServedCells[1].CellId)
+ cell2PciKey := fmt.Sprintf("PCI:%s:%02x", inventoryName, nodebInfo.GetEnb().ServedCells[1].Pci)
+ nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
+ nodebIdKey := fmt.Sprintf("ENB:%s:%s", plmnId, nbId)
+ expectedKeys = append(expectedKeys, cell1Key, cell1PciKey, cell2Key, cell2PciKey, nodebNameKey, nodebIdKey)
+ sdlMock.On("RemoveAndPublish", namespace, []string{channelName, eventName}, expectedKeys).Return(e)
+
+ rNibErr := w.RemoveEnb(nodebInfo)
+ assert.Nil(t, rNibErr)
+ 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) {
+ inventoryName := "name"
+ plmnId := "02f829"
+ nbId := "4a952a0a"
+ channelName := "RAN_MANIPULATION"
+ eventName := inventoryName + "_" + "DELETED"
+ w, sdlMock := initSdlMock()
+ nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
+ nodebInfo.GetEnb().ServedCells = generateServedCellInfos("cell1", "cell2")
+
+ expectedKeys := []string{}
+ cell1Key := fmt.Sprintf("CELL:%s", nodebInfo.GetEnb().ServedCells[0].CellId)
+ cell1PciKey := fmt.Sprintf("PCI:%s:%02x", inventoryName, nodebInfo.GetEnb().ServedCells[0].Pci)
+ cell2Key := fmt.Sprintf("CELL:%s", nodebInfo.GetEnb().ServedCells[1].CellId)
+ cell2PciKey := fmt.Sprintf("PCI:%s:%02x", inventoryName, nodebInfo.GetEnb().ServedCells[1].Pci)
+ nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
+ nodebIdKey := fmt.Sprintf("ENB:%s:%s", plmnId, nbId)
+ expectedKeys = append(expectedKeys, cell1Key, cell1PciKey, cell2Key, cell2PciKey, nodebNameKey, nodebIdKey)
+ sdlMock.On("RemoveAndPublish", namespace, []string{channelName, eventName}, expectedKeys).Return(errors.New("for test"))
+
+ rNibErr := w.RemoveEnb(nodebInfo)
+ assert.NotNil(t, rNibErr)
+ sdlMock.AssertExpectations(t)
+}
+
+func TestRemoveNbIdentitySuccess(t *testing.T) {
+ 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")
+ }
+
+ sdlMock.On("RemoveMember", namespace, entities.Node_ENB.String(), []interface{}{nbIdData}).Return(nil)
+
+ rNibErr := w.RemoveNbIdentity(entities.Node_ENB, nbIdentity)
+ assert.Nil(t, rNibErr)
+ 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, 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")
+ }
+
+ 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)
+ sdlMock.AssertExpectations(t)
+}
+
+func TestAddEnb(t *testing.T) {
+ ranName := "RAN:" + RanName
+ w, sdlMock := initSdlMock()
+ nb := entities.NodebInfo{
+ RanName: RanName,
+ NodeType: entities.Node_ENB,
+ ConnectionStatus: entities.ConnectionStatus_CONNECTED,
+ Ip: "localhost",
+ Port: 5656,
+ GlobalNbId: &entities.GlobalNbId{
+ NbId: "4a952a0a",
+ PlmnId: "02f829",
+ },
+ }
+
+ enb := entities.Enb{}
+ cell := &entities.ServedCellInfo{CellId: "aaff", Pci: 3}
+ cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: cell}}
+ enb.ServedCells = []*entities.ServedCellInfo{cell}
+ nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
+ data, err := proto.Marshal(&nb)
+ if err != nil {
+ t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal NodeB entity. Error: %v", err)
+ }
+ var e error
+
+ cellData, err := proto.Marshal(&cellEntity)
+ if err != nil {
+ t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal Cell entity. Error: %v", err)
+ }
+ var setExpected []interface{}
+ setExpected = append(setExpected, ranName, data)
+ setExpected = append(setExpected, "ENB:02f829:4a952a0a", data)
+ setExpected = append(setExpected, fmt.Sprintf("CELL:%s", cell.GetCellId()), cellData)
+ setExpected = append(setExpected, fmt.Sprintf("PCI:%s:%02x", RanName, cell.GetPci()), cellData)
+
+ 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, _ := initSdlMock()
+ nb := entities.NodebInfo{}
+ nb.RanName = "name"
+ nb.NodeType = entities.Node_ENB
+ nb.ConnectionStatus = 1
+ nb.Ip = "localhost"
+ nb.Port = 5656
+ enb := entities.Enb{}
+ cell := &entities.ServedCellInfo{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.ValidateAndBuildCellIdKey - an empty cell id received", rNibErr.Error())
+}
+
+func TestAddEnbInventoryNameValidationFailure(t *testing.T) {
+ w, _ := initSdlMock()
+ nb := entities.NodebInfo{
+ NodeType: entities.Node_ENB,
+ ConnectionStatus: entities.ConnectionStatus_CONNECTED,
+ Ip: "localhost",
+ Port: 5656,
+ GlobalNbId: &entities.GlobalNbId{
+ NbId: "4a952a0a",
+ PlmnId: "02f829",
+ },
+ }
+ 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.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, sdlMock := initSdlMock()
+
+ proto, nbIdentity := createNbIdentityProto(t, "ran1", "plmnId1", "nbId1", entities.ConnectionStatus_DISCONNECTED)
+ val := []interface{}{proto}
+
+ sdlMock.On("RemoveMember", namespace, entities.Node_ENB.String(), val).Return(nil)
+
+ protoAdd, nbIdentityAdd := createNbIdentityProto(t, "ran1_add", "plmnId1_add", "nbId1_add", entities.ConnectionStatus_CONNECTED)
+ 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)
+ sdlMock.AssertExpectations(t)
+}
+
+func TestUpdateNbIdentitySuccess(t *testing.T) {
+ 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)
+ 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)
+ 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"}}
+ secondNewNbIdIdentity := &entities.NbIdentity{InventoryName: "ran2_add", ConnectionStatus: entities.ConnectionStatus_CONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId2_add", NbId: "nbId2_add"}}
+ newNbIdIdentities = append(newNbIdIdentities, firstNewNbIdIdentity)
+ newNbIdIdentities = append(newNbIdIdentities, secondNewNbIdIdentity)
+
+ var oldNbIdIdentities []*entities.NbIdentity
+ firstOldNbIdIdentity := &entities.NbIdentity{InventoryName: "ran1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
+ secondOldNbIdIdentity := &entities.NbIdentity{InventoryName: "ran2", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId2", NbId: "nbId2"}}
+ oldNbIdIdentities = append(oldNbIdIdentities, firstOldNbIdIdentity)
+ oldNbIdIdentities = append(oldNbIdIdentities, secondOldNbIdIdentity)
+
+ rNibErr := w.UpdateNbIdentities(entities.Node_ENB, oldNbIdIdentities, newNbIdIdentities)
+ assert.Nil(t, rNibErr)
+ 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, sdlMock := initSdlMock()
+
+ var nbIdIdentitiesProtoToRemove []interface{}
+ protoRan1, _ := createNbIdentityProto(t, "ran1", "plmnId1", "nbId1", entities.ConnectionStatus_DISCONNECTED)
+ nbIdIdentitiesProtoToRemove = append(nbIdIdentitiesProtoToRemove, protoRan1)
+ protoRan2, _ := createNbIdentityProto(t, "ran2", "plmnId2", "nbId2", entities.ConnectionStatus_DISCONNECTED)
+ nbIdIdentitiesProtoToRemove = append(nbIdIdentitiesProtoToRemove, protoRan2)
+
+ 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"}}
+ secondOldNbIdIdentity := &entities.NbIdentity{InventoryName: "ran2", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId2", NbId: "nbId2"}}
+ oldNbIdIdentities = append(oldNbIdIdentities, firstOldNbIdIdentity)
+ oldNbIdIdentities = append(oldNbIdIdentities, secondOldNbIdIdentity)
+
+ var newNbIdIdentities []*entities.NbIdentity
+
+ rNibErr := w.UpdateNbIdentities(entities.Node_ENB, oldNbIdIdentities, newNbIdIdentities)
+ assert.NotNil(t, rNibErr)
+ 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, 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")
+ }
+ 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)
+ sdlMock.AssertExpectations(t)
+}
+
+func TestUpdateNbIdentityNoNbIdentityToRemove(t *testing.T) {
+ 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")
+ }
+ 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)
+ sdlMock.AssertExpectations(t)
+}
+
+func TestUpdateNbIdentityNoNbIdentityToAdd(t *testing.T) {
+ 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")
+ }
+ 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)
+ sdlMock.AssertExpectations(t)
+}
+
+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
+}