package reader
import (
- "errors"
+ "encoding/json"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
"github.com/golang/protobuf/proto"
+ "github.com/pkg/errors"
"github.com/stretchr/testify/assert"
"testing"
+ "time"
)
var namespace = "namespace"
name := "name"
readerPool = nil
sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
nb := entities.NodebInfo{}
nb.ConnectionStatus = 1
nb.Ip = "localhost"
if err != nil {
t.Errorf("#rNibReader_test.TestGetNb - Failed to marshal ENB instance. Error: %v", err)
}
- ret := map[string]interface{}{"RAN:" + name: string(data)}
- sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
+ redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
+ if rNibErr != nil {
+ t.Errorf("#rNibReader_test.TestGetNodeB - failed to validate key parameter")
+ }
+ ret := map[string]interface{}{redisKey: string(data)}
+ sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
getNb, er := w.GetNodeb(name)
assert.Nil(t, er)
assert.Equal(t, getNb.Ip, nb.Ip)
name := "name"
readerPool = nil
sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
var e error
var ret map[string]interface{}
- sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
+ redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
+ if rNibErr != nil {
+ t.Errorf("#rNibReader_test.TestGetNodeBNotFoundFailure - failed to validate key parameter")
+ }
+ sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
getNb, er := w.GetNodeb(name)
assert.NotNil(t, er)
assert.Nil(t, getNb)
- assert.Equal(t, 1, er.GetCode())
- assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.getNodeb - responding node not found. Key: RAN:name", er.Error())
+ assert.IsType(t, &common.ResourceNotFoundError{}, er)
+ assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.NodebInfo not found. Key: RAN:name", er.Error())
}
func TestGetNodeBUnmarshalFailure(t *testing.T) {
name := "name"
readerPool = nil
sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
var e error
ret := make(map[string]interface{}, 1)
- ret["RAN:"+name] = "data"
- sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
+ redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
+ if rNibErr != nil {
+ t.Errorf("#rNibReader_test.TestGetNodeBUnmarshalFailure - failed to validate key parameter")
+ }
+ ret[redisKey] = "data"
+ sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
getNb, er := w.GetNodeb(name)
assert.NotNil(t, er)
assert.Nil(t, getNb)
- assert.Equal(t, 2, er.GetCode())
- assert.EqualValues(t, "2 INTERNAL_ERROR - proto: can't skip unknown wire type 4", er.Error())
+ assert.IsType(t, &common.InternalError{}, er)
+ assert.EqualValues(t, "proto: can't skip unknown wire type 4", er.Error())
}
func TestGetNodeBSdlgoFailure(t *testing.T) {
name := "name"
errMsg := "expected Sdlgo error"
- errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
+ errMsgExpected := "expected Sdlgo error"
readerPool = nil
sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
e := errors.New(errMsg)
var ret map[string]interface{}
- sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
+ redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
+ if rNibErr != nil {
+ t.Errorf("#rNibReader_test.TestGetNodeBSdlgoFailure - failed to validate key parameter")
+ }
+ sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
getNb, er := w.GetNodeb(name)
assert.NotNil(t, er)
assert.Nil(t, getNb)
- assert.Equal(t, 2, er.GetCode())
+ assert.IsType(t, &common.InternalError{}, er)
assert.EqualValues(t, errMsgExpected, er.Error())
}
name := "name"
readerPool = nil
sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
nb := entities.NodebInfo{}
nb.ConnectionStatus = 1
nb.Ip = "localhost"
if err != nil {
t.Errorf("#rNibReader_test.GetNodeBCellsList - Failed to marshal ENB instance. Error: %v", err)
}
- ret := map[string]interface{}{"RAN:" + name: string(data)}
- sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
+ redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
+ if rNibErr != nil {
+ t.Errorf("#rNibReader_test.TestGetNodeBCellsListEnb - failed to validate key parameter")
+ }
+ ret := map[string]interface{}{redisKey: string(data)}
+ sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
cells, er := w.GetCellList(name)
assert.Nil(t, er)
assert.NotNil(t, cells)
name := "name"
readerPool = nil
sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
nb := entities.NodebInfo{}
nb.ConnectionStatus = 1
nb.Ip = "localhost"
if err != nil {
t.Errorf("#rNibReader_test.GetNodeBCellsList - Failed to marshal GNB instance. Error: %v", err)
}
- ret := map[string]interface{}{"RAN:" + name: string(data)}
- sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
+ redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
+ if rNibErr != nil {
+ t.Errorf("#rNibReader_test.TestGetNodeBCellsListGnb - failed to validate key parameter")
+ }
+ ret := map[string]interface{}{redisKey: string(data)}
+ sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
cells, er := w.GetCellList(name)
assert.Nil(t, er)
assert.NotNil(t, cells)
name := "name"
readerPool = nil
sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
var e error
ret := make(map[string]interface{}, 1)
- ret["RAN:"+name] = "data"
- sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
+ redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
+ if rNibErr != nil {
+ t.Errorf("#rNibReader_test.TestGetNodeBCellsListNodeUnmarshalFailure - failed to validate key parameter")
+ }
+ ret[redisKey] = "data"
+ sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
cells, er := w.GetCellList(name)
assert.NotNil(t, er)
assert.Nil(t, cells)
- assert.Equal(t, 2, er.GetCode())
- assert.EqualValues(t, "2 INTERNAL_ERROR - proto: can't skip unknown wire type 4", er.Error())
+ assert.IsType(t, &common.InternalError{}, er)
+ assert.EqualValues(t, "proto: can't skip unknown wire type 4", er.Error())
}
func TestGetNodeBCellsListNodeNotFoundFailure(t *testing.T) {
name := "name"
readerPool = nil
sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
var e error
var ret map[string]interface{}
- sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
+ redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
+ if rNibErr != nil {
+ t.Errorf("#rNibReader_test.TestGetNodeBCellsListNodeNotFoundFailure - failed to validate key parameter")
+ }
+ sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
cells, er := w.GetCellList(name)
assert.NotNil(t, er)
assert.Nil(t, cells)
- assert.Equal(t, 1, er.GetCode())
- assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.getNodeb - responding node not found. Key: RAN:name", er.Error())
+ assert.IsType(t, &common.ResourceNotFoundError{}, er)
+ assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.NodebInfo not found. Key: RAN:name", er.Error())
}
func TestGetNodeBCellsListNotFoundFailureEnb(t *testing.T) {
name := "name"
readerPool = nil
sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
nb := entities.NodebInfo{}
nb.ConnectionStatus = 1
nb.Ip = "localhost"
if err != nil {
t.Errorf("#rNibReader_test.TestGetNbCellsListNotFoundFailure - Failed to marshal ENB instance. Error: %v", err)
}
- ret := map[string]interface{}{"RAN:" + name: string(data)}
- sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
+ redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
+ if rNibErr != nil {
+ t.Errorf("#rNibReader_test.TestGetNodeBCellsListNotFoundFailureEnb - failed to validate key parameter")
+ }
+ ret := map[string]interface{}{redisKey: string(data)}
+ sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
_, er := w.GetCellList(name)
assert.NotNil(t, er)
- assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.GetCellList - served cells not found. Responding node RAN name: name.", er.Error())
+ assert.EqualValues(t, "#rNibReader.GetCellList - served cells not found. Responding node RAN name: name.", er.Error())
}
func TestGetNodeBCellsListNotFoundFailureGnb(t *testing.T) {
name := "name"
readerPool = nil
sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
nb := entities.NodebInfo{}
nb.ConnectionStatus = 1
nb.Ip = "localhost"
var e error
data, err := proto.Marshal(&nb)
if err != nil {
- t.Errorf("#rNibReader_test.TestGetNbCellsListNotFoundFailure - Failed to marshal ENB instance. Error: %v", err)
+ t.Errorf("#rNibReader_test.TestGetNodeBCellsListNotFoundFailureGnb - Failed to marshal ENB instance. Error: %v", err)
+ }
+ redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
+ if rNibErr != nil {
+ t.Errorf("#rNibReader_test.TestGetNodeBCellsListNotFoundFailureGnb - failed to validate key parameter")
}
- ret := map[string]interface{}{"RAN:" + name: string(data)}
- sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
+ ret := map[string]interface{}{redisKey: string(data)}
+ sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
_, er := w.GetCellList(name)
assert.NotNil(t, er)
- assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.GetCellList - served cells not found. Responding node RAN name: name.", er.Error())
+ assert.EqualValues(t, "#rNibReader.GetCellList - served cells not found. Responding node RAN name: name.", er.Error())
}
func TestCloseOnClosedPoolFailure(t *testing.T) {
readerPool = nil
instanceMock := initSdlInstanceMock(namespace, 1)
- w1 := GetRNibReader()
+ w1 := &rNibReaderInstance{}
+ _, err := w1.GetNodeb("")
+ if err == nil{
+ t.Errorf("#rNibReader_test.TestCloseOnClosedPoolFailure - failed to validate key parameter")
+ }
readerPool.Put(w1)
available, created := readerPool.Stats()
assert.Equal(t, 1, available, "number of available objects in the readerPool should be 1")
func TestCloseFailure(t *testing.T) {
readerPool = nil
instanceMock := initSdlInstanceMock(namespace, 2)
- w1 := GetRNibReader()
- readerPool.Put(w1)
+ w1 := &rNibReaderInstance{}
+ _, err := w1.GetNodeb("")
+ if err == nil{
+ t.Errorf("#rNibReader_test.TestCloseFailure - failed to validate key parameter")
+ }
available, created := readerPool.Stats()
- assert.Equal(t, 1, available, "number of available objects in the readerPool should be 1")
+ assert.Equal(t, 1, available, "number of available objects in the readerPool should be 2")
assert.Equal(t, 1, created, "number of created objects in the readerPool should be 1")
e := errors.New("expected error")
instanceMock.On("Close").Return(e)
func TestGetListGnbIdsUnmarshalFailure(t *testing.T) {
readerPool = nil
sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
var e error
- sdlInstanceMock.On("GetMembers", GnbType).Return([]string{"data"}, e)
+ sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return([]string{"data"}, e)
ids, er := w.GetListGnbIds()
assert.NotNil(t, er)
assert.Nil(t, ids)
- assert.Equal(t, 2, er.GetCode())
- assert.Equal(t, "2 INTERNAL_ERROR - proto: can't skip unknown wire type 4", er.Error())
+ assert.IsType(t, &common.InternalError{}, er)
+ assert.Equal(t, "proto: can't skip unknown wire type 4", er.Error())
}
func TestGetListGnbIdsSdlgoFailure(t *testing.T) {
errMsg := "expected Sdlgo error"
- errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
+ errMsgExpected := "expected Sdlgo error"
readerPool = nil
sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
e := errors.New(errMsg)
var data []string
- sdlInstanceMock.On("GetMembers", GnbType).Return(data, e)
+ sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return(data, e)
ids, er := w.GetListGnbIds()
assert.NotNil(t, er)
assert.Nil(t, ids)
- assert.Equal(t, 2, er.GetCode())
+ assert.IsType(t, &common.InternalError{}, er)
assert.EqualValues(t, errMsgExpected, er.Error())
}
readerPool = nil
sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
name := "name"
plmnId := "02f829"
if err != nil {
t.Errorf("#rNibReader_test.TestGetListNodesIdsGnbSdlgoFailure - Failed to marshal nodeb identity entity. Error: %v", err)
}
- sdlInstanceMock.On("GetMembers", EnbType).Return([]string{string(data)}, nilError)
+ sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{string(data)}, nilError)
errMsg := "expected Sdlgo error"
- errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
+ errMsgExpected := "expected Sdlgo error"
expectedError := errors.New(errMsg)
var nilData []string
- sdlInstanceMock.On("GetMembers", GnbType).Return(nilData, expectedError)
+ sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return(nilData, expectedError)
ids, er := w.GetListNodebIds()
assert.NotNil(t, er)
assert.Nil(t, ids)
- assert.Equal(t, 2, er.GetCode())
+ assert.IsType(t, &common.InternalError{}, er)
assert.EqualValues(t, errMsgExpected, er.Error())
}
readerPool = nil
sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
name := "name"
plmnId := "02f829"
if err != nil {
t.Errorf("#rNibReader_test.TestGetListNodesIdsEnbSdlgoFailure - Failed to marshal nodeb identity entity. Error: %v", err)
}
- sdlInstanceMock.On("GetMembers", GnbType).Return([]string{string(data)}, nilError)
+ sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return([]string{string(data)}, nilError)
errMsg := "expected Sdlgo error"
- errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
+ errMsgExpected := "expected Sdlgo error"
expectedError := errors.New(errMsg)
var nilData []string
- sdlInstanceMock.On("GetMembers", EnbType).Return(nilData, expectedError)
+ sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return(nilData, expectedError)
ids, er := w.GetListNodebIds()
assert.NotNil(t, er)
assert.Nil(t, ids)
- assert.Equal(t, 2, er.GetCode())
+ assert.IsType(t, &common.InternalError{}, er)
assert.EqualValues(t, errMsgExpected, er.Error())
}
-func TestGetListNodesIdsEnbSdlgoSuccess(t *testing.T) {
+func TestGetListNodesIdsSuccess(t *testing.T) {
readerPool = nil
sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
+ var nilError error
name := "name"
plmnId := "02f829"
nbId := "4a952a0a"
nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
- var nilError error
data, err := proto.Marshal(nbIdentity)
if err != nil {
- t.Errorf("#rNibReader_test.TestGetListNodesIdsEnbSdlgoFailure - Failed to marshal nodeb identity entity. Error: %v", err)
+ t.Errorf("#rNibReader_test.TestGetListNodesIdsSuccess - Failed to marshal nodeb identity entity. Error: %v", err)
+ }
+
+ name1 := "name1"
+ plmnId1 := "02f845"
+ nbId1 := "4a952a75"
+ nbIdentity1 := &entities.NbIdentity{InventoryName: name1, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId1, NbId: nbId1}}
+ data1, err := proto.Marshal(nbIdentity1)
+ if err != nil {
+ t.Errorf("#rNibReader_test.TestGetListNodesIdsSuccess - Failed to marshal nodeb identity entity. Error: %v", err)
}
- sdlInstanceMock.On("GetMembers", GnbType).Return([]string{string(data)}, nilError)
- sdlInstanceMock.On("GetMembers", EnbType).Return([]string{string(data)}, nilError)
+
+ name2 := "name2"
+ nbIdentity2 := &entities.NbIdentity{InventoryName: name2}
+ data2, err := proto.Marshal(nbIdentity2)
+ if err != nil {
+ t.Errorf("#rNibReader_test.TestGetListNodesIdsSuccess - Failed to marshal nodeb identity entity. Error: %v", err)
+ }
+
+ sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return([]string{string(data)}, nilError)
+ sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{string(data1)}, nilError)
+ sdlInstanceMock.On("GetMembers", entities.Node_UNKNOWN.String()).Return([]string{string(data2)}, nilError)
ids, er := w.GetListNodebIds()
assert.Nil(t, er)
assert.NotNil(t, ids)
- assert.Len(t, ids, 2)
+ assert.Len(t, ids, 3)
}
func TestGetListEnbIdsUnmarshalFailure(t *testing.T) {
readerPool = nil
sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
var e error
- sdlInstanceMock.On("GetMembers", EnbType).Return([]string{"data"}, e)
+ sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{"data"}, e)
ids, er := w.GetListEnbIds()
assert.NotNil(t, er)
assert.Nil(t, ids)
- assert.Equal(t, 2, er.GetCode())
- assert.Equal(t, "2 INTERNAL_ERROR - proto: can't skip unknown wire type 4", er.Error())
+ assert.IsType(t, &common.InternalError{}, er)
+ assert.Equal(t, "proto: can't skip unknown wire type 4", er.Error())
}
func TestGetListEnbIdsOneId(t *testing.T) {
nbId := "4a952a0a"
readerPool = nil
sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
var e error
data, err := proto.Marshal(nbIdentity)
if err != nil {
t.Errorf("#rNibReader_test.TestGetListEnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
}
- sdlInstanceMock.On("GetMembers", EnbType).Return([]string{string(data)}, e)
+ sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{string(data)}, e)
ids, er := w.GetListEnbIds()
assert.Nil(t, er)
- assert.Len(t, *ids, 1)
- assert.Equal(t, (*ids)[0].GetInventoryName(), name)
- assert.Equal(t, (*ids)[0].GetGlobalNbId().GetPlmnId(), nbIdentity.GetGlobalNbId().GetPlmnId())
- assert.Equal(t, (*ids)[0].GetGlobalNbId().GetNbId(), nbIdentity.GetGlobalNbId().GetNbId())
+ assert.Len(t, ids, 1)
+ assert.Equal(t, (ids)[0].GetInventoryName(), name)
+ assert.Equal(t, (ids)[0].GetGlobalNbId().GetPlmnId(), nbIdentity.GetGlobalNbId().GetPlmnId())
+ assert.Equal(t, (ids)[0].GetGlobalNbId().GetNbId(), nbIdentity.GetGlobalNbId().GetNbId())
}
func TestGetListEnbIdsNoIds(t *testing.T) {
readerPool = nil
sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
var e error
- sdlInstanceMock.On("GetMembers", EnbType).Return([]string{}, e)
+ sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{}, e)
ids, er := w.GetListEnbIds()
assert.Nil(t, er)
- assert.Len(t, *ids, 0)
+ assert.Len(t, ids, 0)
}
func TestGetListEnbIds(t *testing.T) {
listSize := 3
readerPool = nil
sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
idsData := make([]string, listSize)
idsEntities := make([]*entities.NbIdentity, listSize)
for i := 0; i < listSize; i++ {
idsEntities[i] = nbIdentity
}
var e error
- sdlInstanceMock.On("GetMembers", EnbType).Return(idsData, e)
+ sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return(idsData, e)
ids, er := w.GetListEnbIds()
assert.Nil(t, er)
- assert.Len(t, *ids, listSize)
- for i, id := range *ids {
+ assert.Len(t, ids, listSize)
+ for i, id := range ids {
assert.Equal(t, id.GetInventoryName(), name)
assert.Equal(t, id.GetGlobalNbId().GetPlmnId(), idsEntities[i].GetGlobalNbId().GetPlmnId())
assert.Equal(t, id.GetGlobalNbId().GetNbId(), idsEntities[i].GetGlobalNbId().GetNbId())
nbId := "4a952a0a"
readerPool = nil
sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
var e error
data, err := proto.Marshal(nbIdentity)
if err != nil {
t.Errorf("#rNibReader_test.TestGetListGnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
}
- sdlInstanceMock.On("GetMembers", GnbType).Return([]string{string(data)}, e)
+ sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return([]string{string(data)}, e)
ids, er := w.GetListGnbIds()
assert.Nil(t, er)
- assert.Len(t, *ids, 1)
- assert.Equal(t, (*ids)[0].GetInventoryName(), name)
- assert.Equal(t, (*ids)[0].GetGlobalNbId().GetPlmnId(), nbIdentity.GetGlobalNbId().GetPlmnId())
- assert.Equal(t, (*ids)[0].GetGlobalNbId().GetNbId(), nbIdentity.GetGlobalNbId().GetNbId())
+ assert.Len(t, ids, 1)
+ assert.Equal(t, (ids)[0].GetInventoryName(), name)
+ assert.Equal(t, (ids)[0].GetGlobalNbId().GetPlmnId(), nbIdentity.GetGlobalNbId().GetPlmnId())
+ assert.Equal(t, (ids)[0].GetGlobalNbId().GetNbId(), nbIdentity.GetGlobalNbId().GetNbId())
}
func TestGetListGnbIdsNoIds(t *testing.T) {
readerPool = nil
sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
var e error
- sdlInstanceMock.On("GetMembers", GnbType).Return([]string{}, e)
+ sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return([]string{}, e)
ids, er := w.GetListGnbIds()
assert.Nil(t, er)
- assert.Len(t, *ids, 0)
+ assert.Len(t, ids, 0)
}
func TestGetListGnbIds(t *testing.T) {
listSize := 3
readerPool = nil
sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
idsData := make([]string, listSize)
idsEntities := make([]*entities.NbIdentity, listSize)
for i := 0; i < listSize; i++ {
idsEntities[i] = nbIdentity
}
var e error
- sdlInstanceMock.On("GetMembers", GnbType).Return(idsData, e)
+ sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return(idsData, e)
ids, er := w.GetListGnbIds()
assert.Nil(t, er)
- assert.Len(t, *ids, listSize)
- for i, id := range *ids {
+ assert.Len(t, ids, listSize)
+ for i, id := range ids {
assert.Equal(t, id.GetInventoryName(), name)
assert.Equal(t, id.GetGlobalNbId().GetPlmnId(), idsEntities[i].GetGlobalNbId().GetPlmnId())
assert.Equal(t, id.GetGlobalNbId().GetNbId(), idsEntities[i].GetGlobalNbId().GetNbId())
func TestGetListEnbIdsSdlgoFailure(t *testing.T) {
errMsg := "expected Sdlgo error"
- errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
+ errMsgExpected := "expected Sdlgo error"
readerPool = nil
sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
e := errors.New(errMsg)
var data []string
- sdlInstanceMock.On("GetMembers", EnbType).Return(data, e)
+ sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return(data, e)
ids, er := w.GetListEnbIds()
assert.NotNil(t, er)
assert.Nil(t, ids)
- assert.Equal(t, 2, er.GetCode())
+ assert.IsType(t, &common.InternalError{}, er)
assert.EqualValues(t, errMsgExpected, er.Error())
}
func TestGetCountGnbListOneId(t *testing.T) {
readerPool = nil
sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
var e error
- sdlInstanceMock.On("GroupSize", GnbType).Return(1, e)
+ sdlInstanceMock.On("GroupSize", entities.Node_GNB.String()).Return(1, e)
count, er := w.GetCountGnbList()
assert.Nil(t, er)
assert.Equal(t, count, 1)
func TestGetCountGnbList(t *testing.T) {
readerPool = nil
sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
var e error
- sdlInstanceMock.On("GroupSize", GnbType).Return(3, e)
+ sdlInstanceMock.On("GroupSize", entities.Node_GNB.String()).Return(3, e)
count, er := w.GetCountGnbList()
assert.Nil(t, er)
assert.Equal(t, count, 3)
func TestGetCountGnbListSdlgoFailure(t *testing.T) {
errMsg := "expected Sdlgo error"
- errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
+ errMsgExpected := "expected Sdlgo error"
readerPool = nil
sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
e := errors.New(errMsg)
var count int
- sdlInstanceMock.On("GroupSize", GnbType).Return(count, e)
+ sdlInstanceMock.On("GroupSize", entities.Node_GNB.String()).Return(count, e)
count, er := w.GetCountGnbList()
assert.NotNil(t, er)
assert.Equal(t, 0, count)
- assert.Equal(t, 2, er.GetCode())
+ assert.IsType(t, &common.InternalError{}, er)
assert.EqualValues(t, errMsgExpected, er.Error())
}
var pci uint32 = 10
readerPool = nil
sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: &entities.ServedCellInfo{Pci: pci}}}
cellData, err := proto.Marshal(&cellEntity)
if err != nil {
var pci uint32
readerPool = nil
sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
var e error
var ret map[string]interface{}
key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
cell, er := w.GetCell(name, pci)
assert.NotNil(t, er)
assert.Nil(t, cell)
- assert.Equal(t, 1, er.GetCode())
- assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.getCellByKey - cell not found, key: PCI:name:00", er.Error())
+ assert.IsType(t, &common.ResourceNotFoundError{}, er)
+ assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.Cell not found. Key: PCI:name:00", er.Error())
}
func TestGetCellUnmarshalFailure(t *testing.T) {
var pci uint32
readerPool = nil
sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
var e error
ret := make(map[string]interface{}, 1)
key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
cell, er := w.GetCell(name, pci)
assert.NotNil(t, er)
assert.Nil(t, cell)
- assert.Equal(t, 2, er.GetCode())
- assert.EqualValues(t, "2 INTERNAL_ERROR - proto: can't skip unknown wire type 4", er.Error())
+ assert.IsType(t, &common.InternalError{}, er)
+ assert.EqualValues(t, "proto: can't skip unknown wire type 4", er.Error())
}
func TestGetCellSdlgoFailure(t *testing.T) {
name := "name"
var pci uint32
errMsg := "expected Sdlgo error"
- errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
+ errMsgExpected := "expected Sdlgo error"
readerPool = nil
sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
e := errors.New(errMsg)
var ret map[string]interface{}
key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
cell, er := w.GetCell(name, pci)
assert.NotNil(t, er)
assert.Nil(t, cell)
- assert.Equal(t, 2, er.GetCode())
+ assert.IsType(t, &common.InternalError{}, er)
assert.EqualValues(t, errMsgExpected, er.Error())
}
func TestGetNodebById(t *testing.T) {
readerPool = nil
sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
nb := entities.NodebInfo{NodeType: entities.Node_ENB}
nb.ConnectionStatus = 1
nb.Ip = "localhost"
nbId := "4a952a0a"
readerPool = nil
sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
var e error
key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_ENB.String(), plmnId, nbId)
if rNibErr != nil {
getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
assert.NotNil(t, er)
assert.Nil(t, getNb)
- assert.Equal(t, 1, er.GetCode())
- assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.getNodeb - responding node not found. Key: ENB:02f829:4a952a0a", er.Error())
+ assert.IsType(t, &common.ResourceNotFoundError{}, er)
+ assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.NodebInfo not found. Key: ENB:02f829:4a952a0a", er.Error())
}
func TestGetNodebByIdNotFoundFailureGnb(t *testing.T) {
nbId := "4a952a0a"
readerPool = nil
sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
var e error
key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_GNB.String(), plmnId, nbId)
if rNibErr != nil {
getNb, er := w.GetNodebByGlobalNbId(entities.Node_GNB, globalNbId)
assert.NotNil(t, er)
assert.Nil(t, getNb)
- assert.Equal(t, 1, er.GetCode())
- assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.getNodeb - responding node not found. Key: GNB:02f829:4a952a0a", er.Error())
+ assert.IsType(t, &common.ResourceNotFoundError{}, er)
+ assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.NodebInfo not found. Key: GNB:02f829:4a952a0a", er.Error())
}
func TestGetNodeByIdUnmarshalFailure(t *testing.T) {
nbId := "4a952a0a"
readerPool = nil
sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_ENB.String(), plmnId, nbId)
if rNibErr != nil {
t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
assert.NotNil(t, er)
assert.Nil(t, getNb)
- assert.Equal(t, 2, er.GetCode())
- assert.EqualValues(t, "2 INTERNAL_ERROR - proto: can't skip unknown wire type 4", er.Error())
+ assert.IsType(t, &common.InternalError{}, er)
+ assert.EqualValues(t, "proto: can't skip unknown wire type 4", er.Error())
}
func TestGetNodeByIdSdlgoFailure(t *testing.T) {
plmnId := "02f829"
nbId := "4a952a0a"
errMsg := "expected Sdlgo error"
- errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
+ errMsgExpected := "expected Sdlgo error"
readerPool = nil
sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_GNB.String(), plmnId, nbId)
if rNibErr != nil {
t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
getNb, er := w.GetNodebByGlobalNbId(entities.Node_GNB, globalNbId)
assert.NotNil(t, er)
assert.Nil(t, getNb)
- assert.Equal(t, 2, er.GetCode())
+ assert.IsType(t, &common.InternalError{}, er)
assert.EqualValues(t, errMsgExpected, er.Error())
}
var pci uint32 = 10
readerPool = nil
sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: &entities.ServedCellInfo{Pci: pci}}}
cellData, err := proto.Marshal(&cellEntity)
if err != nil {
cellId := "bbbb"
readerPool = nil
sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
var e error
var ret map[string]interface{}
key, rNibErr := common.ValidateAndBuildCellIdKey(cellId)
cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
assert.NotNil(t, er)
assert.Nil(t, cell)
- assert.Equal(t, 1, er.GetCode())
- assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.getCellByKey - cell not found, key: CELL:bbbb", er.Error())
+ assert.IsType(t, &common.ResourceNotFoundError{}, er)
+ assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.Cell not found. Key: CELL:bbbb", er.Error())
}
func TestGetCellByIdNotFoundFailureGnb(t *testing.T) {
cellId := "bbbb"
readerPool = nil
sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
var e error
var ret map[string]interface{}
key, rNibErr := common.ValidateAndBuildNrCellIdKey(cellId)
cell, er := w.GetCellById(entities.Cell_NR_CELL, cellId)
assert.NotNil(t, er)
assert.Nil(t, cell)
- assert.Equal(t, 1, er.GetCode())
- assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.getCellByKey - cell not found, key: NRCELL:bbbb", er.Error())
+ assert.IsType(t, &common.ResourceNotFoundError{}, er)
+ assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.Cell not found. Key: NRCELL:bbbb", er.Error())
}
func TestGetCellByIdTypeValidationFailure(t *testing.T) {
cellId := "dddd"
readerPool = nil
initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
cell, er := w.GetCellById(5, cellId)
assert.NotNil(t, er)
assert.Nil(t, cell)
- assert.Equal(t, 3, er.GetCode())
- assert.EqualValues(t, "3 VALIDATION_ERROR - #rNibReader.GetCellById - invalid cell type: 5", er.Error())
+ assert.IsType(t, &common.ValidationError{}, er)
+ assert.EqualValues(t, "#rNibReader.GetCellById - invalid cell type: 5", er.Error())
}
func TestGetCellByIdValidationFailureGnb(t *testing.T) {
cellId := ""
readerPool = nil
initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
cell, er := w.GetCellById(entities.Cell_NR_CELL, cellId)
assert.NotNil(t, er)
assert.Nil(t, cell)
- assert.Equal(t, 3, er.GetCode())
- assert.EqualValues(t, "3 VALIDATION_ERROR - #utils.ValidateAndBuildNrCellIdKey - an empty cell id received", er.Error())
+ assert.IsType(t, &common.ValidationError{}, er)
+ assert.EqualValues(t, "#utils.ValidateAndBuildNrCellIdKey - an empty cell id received", er.Error())
}
func TestGetCellByIdValidationFailureEnb(t *testing.T) {
cellId := ""
readerPool = nil
initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w := &rNibReaderInstance{}
cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
assert.NotNil(t, er)
assert.Nil(t, cell)
- assert.Equal(t, 3, er.GetCode())
- assert.EqualValues(t, "3 VALIDATION_ERROR - #utils.ValidateAndBuildCellIdKey - an empty cell id received", er.Error())
+ assert.IsType(t, &common.ValidationError{}, er)
+ assert.EqualValues(t, "#utils.ValidateAndBuildCellIdKey - an empty cell id received", er.Error())
}
-//integration tests
+func TestGetRanLoadInformation(t *testing.T) {
+ name := "name"
+ readerPool = nil
+ sdlInstanceMock := initSdlInstanceMock(namespace, 1)
+ w := &rNibReaderInstance{}
+ loadInfo := generateRanLoadInformation()
+ var e error
+ data, err := proto.Marshal(loadInfo)
+ if err != nil {
+ t.Errorf("#rNibReader_test.TestGetRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
+ }
+ redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
+ if rNibErr != nil {
+ t.Errorf("#rNibReader_test.TestGetRanLoadInformationNotFoundFailure - failed to validate key parameter")
+ }
+ ret := map[string]interface{}{redisKey: string(data)}
+ sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
+ getLoadInfo, er := w.GetRanLoadInformation(name)
+ assert.Nil(t, er)
+ assert.NotNil(t, getLoadInfo)
+ expected, err := json.Marshal(loadInfo)
+ if err != nil {
+ t.Errorf("#rNibReader_test.TestGetRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
+ }
+ actual, err := json.Marshal(getLoadInfo)
+ if err != nil {
+ t.Errorf("#rNibReader_test.TestGetRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
+ }
+ assert.EqualValues(t, expected, actual)
+}
+
+func TestGetRanLoadInformationValidationFailure(t *testing.T) {
+ name := ""
+ readerPool = nil
+ initSdlInstanceMock(namespace, 1)
+ w := &rNibReaderInstance{}
+ getNb, er := w.GetRanLoadInformation(name)
+ assert.NotNil(t, er)
+ assert.Nil(t, getNb)
+ assert.IsType(t, &common.ValidationError{}, er)
+ assert.EqualValues(t, "#utils.ValidateAndBuildRanLoadInformationKey - an empty inventory name received", er.Error())
+}
+
+func TestGetRanLoadInformationNotFoundFailure(t *testing.T) {
+ name := "name"
+ readerPool = nil
+ sdlInstanceMock := initSdlInstanceMock(namespace, 1)
+ w := &rNibReaderInstance{}
+ var e error
+ var ret map[string]interface{}
+ redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
+ if rNibErr != nil {
+ t.Errorf("#rNibReader_test.TestGetRanLoadInformationNotFoundFailure - failed to validate key parameter")
+ }
+ sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
+ getNb, er := w.GetRanLoadInformation(name)
+ assert.NotNil(t, er)
+ assert.Nil(t, getNb)
+ assert.IsType(t, &common.ResourceNotFoundError{}, er)
+ assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.RanLoadInformation not found. Key: LOAD:name", er.Error())
+}
+func TestGetRanLoadInformationUnmarshalFailure(t *testing.T) {
+ name := "name"
+ readerPool = nil
+ sdlInstanceMock := initSdlInstanceMock(namespace, 1)
+ w := &rNibReaderInstance{}
+ var e error
+ ret := make(map[string]interface{}, 1)
+ redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
+ if rNibErr != nil {
+ t.Errorf("#rNibReader_test.TestGetRanLoadInformationUnmarshalFailure - failed to validate key parameter")
+ }
+ ret[redisKey] = "data"
+ sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
+ getNb, er := w.GetRanLoadInformation(name)
+ assert.NotNil(t, er)
+ assert.Nil(t, getNb)
+ assert.IsType(t, &common.InternalError{}, er)
+ assert.EqualValues(t, "proto: can't skip unknown wire type 4", er.Error())
+}
+
+func TestGetRanLoadInformationSdlgoFailure(t *testing.T) {
+ name := "name"
+ errMsg := "expected Sdlgo error"
+ errMsgExpected := "expected Sdlgo error"
+ readerPool = nil
+ sdlInstanceMock := initSdlInstanceMock(namespace, 1)
+ w := &rNibReaderInstance{}
+ e := errors.New(errMsg)
+ var ret map[string]interface{}
+ redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
+ if rNibErr != nil {
+ t.Errorf("#rNibReader_test.TestGetRanLoadInformationSdlgoFailure - failed to validate key parameter")
+ }
+ sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
+ getNb, er := w.GetRanLoadInformation(name)
+ assert.NotNil(t, er)
+ assert.Nil(t, getNb)
+ assert.IsType(t, &common.InternalError{}, er)
+ assert.EqualValues(t, errMsgExpected, er.Error())
+}
+
+func generateCellLoadInformation() *entities.CellLoadInformation {
+ cellLoadInformation := entities.CellLoadInformation{}
+
+ cellLoadInformation.CellId = "123"
+
+ ulInterferenceOverloadIndication := entities.UlInterferenceOverloadIndication_HIGH_INTERFERENCE
+ cellLoadInformation.UlInterferenceOverloadIndications = []entities.UlInterferenceOverloadIndication{ulInterferenceOverloadIndication}
+
+ ulHighInterferenceInformation := entities.UlHighInterferenceInformation{
+ TargetCellId:"456",
+ UlHighInterferenceIndication:"xxx",
+ }
+
+ cellLoadInformation.UlHighInterferenceInfos = []*entities.UlHighInterferenceInformation{&ulHighInterferenceInformation }
+
+ cellLoadInformation.RelativeNarrowbandTxPower = &entities.RelativeNarrowbandTxPower{
+ RntpPerPrb:"xxx",
+ RntpThreshold:entities.RntpThreshold_NEG_4,
+ NumberOfCellSpecificAntennaPorts: entities.NumberOfCellSpecificAntennaPorts_V1_ANT_PRT,
+ PB: 1,
+ PdcchInterferenceImpact:2,
+ EnhancedRntp: &entities.EnhancedRntp{
+ EnhancedRntpBitmap:"xxx",
+ RntpHighPowerThreshold:entities.RntpThreshold_NEG_2,
+ EnhancedRntpStartTime: &entities.StartTime{StartSfn:500,StartSubframeNumber:5},
+ },
+ }
+
+ cellLoadInformation.AbsInformation = &entities.AbsInformation{
+ Mode: entities.AbsInformationMode_ABS_INFO_FDD,
+ AbsPatternInfo:"xxx",
+ NumberOfCellSpecificAntennaPorts:entities.NumberOfCellSpecificAntennaPorts_V2_ANT_PRT,
+ MeasurementSubset:"xxx",
+ }
+
+ cellLoadInformation.InvokeIndication = entities.InvokeIndication_ABS_INFORMATION
+
+ cellLoadInformation.ExtendedUlInterferenceOverloadInfo = &entities.ExtendedUlInterferenceOverloadInfo{
+ AssociatedSubframes:"xxx",
+ ExtendedUlInterferenceOverloadIndications:cellLoadInformation.UlInterferenceOverloadIndications,
+ }
+
+ compInformationItem := &entities.CompInformationItem{
+ CompHypothesisSets: []*entities.CompHypothesisSet{{CellId: "789", CompHypothesis: "xxx"}},
+ BenefitMetric:50,
+ }
+
+ cellLoadInformation.CompInformation = &entities.CompInformation{
+ CompInformationItems:[]*entities.CompInformationItem{compInformationItem},
+ CompInformationStartTime:&entities.StartTime{StartSfn:123,StartSubframeNumber:456},
+ }
+
+ cellLoadInformation.DynamicDlTransmissionInformation = &entities.DynamicDlTransmissionInformation{
+ State: entities.NaicsState_NAICS_ACTIVE,
+ TransmissionModes:"xxx",
+ PB: 2,
+ PAList:[]entities.PA{entities.PA_DB_NEG_3},
+ }
+
+ return &cellLoadInformation
+}
+
+func generateRanLoadInformation() *entities.RanLoadInformation {
+ ranLoadInformation := entities.RanLoadInformation{}
+
+ ranLoadInformation.LoadTimestamp = uint64(time.Now().UnixNano())
+
+ cellLoadInformation := generateCellLoadInformation()
+ ranLoadInformation.CellLoadInfos = []*entities.CellLoadInformation{cellLoadInformation}
+
+ return &ranLoadInformation
+}
+
+//integration tests
+//
//func TestGetEnbInteg(t *testing.T){
// name := "nameEnb1"
// Init("namespace", 1)
-// w := GetRNibReader()
+// w := &rNibReaderInstance{}
// nb, err := w.GetNodeb(name)
// if err != nil{
// fmt.Println(err)
//func TestGetEnbCellsInteg(t *testing.T){
// name := "nameEnb1"
// Init("namespace", 1)
-// w := GetRNibReader()
+// w := &rNibReaderInstance{}
// cells, err := w.GetCellList(name)
// if err != nil{
// fmt.Println(err)
//func TestGetGnbInteg(t *testing.T){
// name := "nameGnb1"
// Init("namespace", 1)
-// w := GetRNibReader()
+// w := &rNibReaderInstance{}
// nb, err := w.GetNodeb(name)
// if err != nil{
// fmt.Println(err)
//func TestGetGnbCellsInteg(t *testing.T){
// name := "nameGnb1"
// Init("namespace", 1)
-// w := GetRNibReader()
+// w := &rNibReaderInstance{}
// cells, err := w.GetCellList(name)
// if err != nil{
// fmt.Println(err)
//
//func TestGetListEnbIdsInteg(t *testing.T) {
// Init("namespace", 1)
-// w := GetRNibReader()
+// w := &rNibReaderInstance{}
// ids, err := w.GetListEnbIds()
// if err != nil{
// fmt.Println(err)
// } else {
-// for _, id := range *ids{
+// for _, id := range ids{
// fmt.Printf("#TestGetListEnbIdsInteg - ENB ID: %s\n", id)
// }
// }
//
//func TestGetListGnbIdsInteg(t *testing.T) {
// Init("namespace", 1)
-// w := GetRNibReader()
+// w := &rNibReaderInstance{}
// ids, err := w.GetListGnbIds()
// if err != nil{
// fmt.Println(err)
// } else {
-// for _, id := range *ids{
+// for _, id := range ids{
// fmt.Printf("#TestGetListGnbIdsInteg - GNB ID: %s\n", id)
// }
// }
//
//func TestGetCountGnbListInteg(t *testing.T) {
// Init("namespace", 1)
-// w := GetRNibReader()
+// w := &rNibReaderInstance{}
// count, err := w.GetCountGnbList()
// if err != nil{
// fmt.Println(err)
// name := "nameGnb7"
// pci := 0x0a
// Init("namespace", 1)
-// w := GetRNibReader()
+// w := &rNibReaderInstance{}
// cell, err := w.GetCell(name, uint32(pci))
// if err != nil{
// fmt.Println(err)
// name := "nameEnb1"
// pci := 0x22
// Init("namespace", 1)
-// w := GetRNibReader()
+// w := &rNibReaderInstance{}
// cell, err := w.GetCell(name, uint32(pci))
// if err != nil {
// fmt.Println(err)
//
//func TestGetEnbCellByIdInteg(t *testing.T){
// Init("namespace", 1)
-// w := GetRNibReader()
+// w := &rNibReaderInstance{}
// cell, err := w.GetCellById(entities.Cell_NR_CELL, "45d")
// if err != nil{
// fmt.Println(err)
// fmt.Printf("responding node type NR Cell: %v\n", cell.GetServedNrCell())
// }
//}
+//
+//func TestGetListNbIdsInteg(t *testing.T) {
+// Init("e2Manager", 1)
+// w := &rNibReaderInstance{}
+// ids, err := w.GetListNodebIds()
+// if err != nil{
+// fmt.Println(err)
+// } else {
+// for _, id := range ids{
+// fmt.Printf("#TestGetListGnbIdsInteg - NB ID: %s\n", id)
+// }
+// }
+//}
+//
+//func TestGetRanLoadInformationInteg(t *testing.T){
+// Init("e2Manager", 1)
+// w := &rNibReaderInstance{}
+// ranLoadInformation, err := w.GetRanLoadInformation("ran_integ")
+// if err != nil{
+// t.Errorf("#rNibReader_test.TestGetRanLoadInformationInteg - Failed to get RanLoadInformation entity. Error: %v", err)
+// }
+// assert.NotNil(t, ranLoadInformation)
+// fmt.Printf("#rNibReader_test.TestGetRanLoadInformationInteg - GNB ID: %s\n", ranLoadInformation)
+//}
\ No newline at end of file
Code Review / ric-plt / nodeb-rnib.git / blobdiff