// 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 reader
import (
"encoding/json"
+ "fmt"
"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"
+ "strconv"
"testing"
"time"
)
-var namespace = "namespace"
-
-func TestInit(t *testing.T) {
- readerPool = nil
- Init("", 1)
- assert.NotNil(t, readerPool)
- assert.NotNil(t, readerPool.New)
- assert.NotNil(t, readerPool.Destroy)
- available, created := readerPool.Stats()
- assert.Equal(t, 0, available, "number of available objects in the readerPool should be 0")
- assert.Equal(t, 0, created, "number of created objects in the readerPool should be 0")
-}
-
-func TestInitPool(t *testing.T) {
- readerPool = nil
- sdlInstanceMock := new(MockSdlInstance)
- initPool(1, func() interface{} {
- sdlI := common.ISdlInstance(sdlInstanceMock)
- return &rNibReaderInstance{sdl: &sdlI, namespace: namespace}
- },
- func(obj interface{}) {
- },
- )
- assert.NotNil(t, readerPool)
- assert.NotNil(t, readerPool.New)
- assert.NotNil(t, readerPool.Destroy)
- available, created := readerPool.Stats()
- assert.Equal(t, 0, available, "number of available objects in the readerPool should be 0")
- assert.Equal(t, 0, created, "number of created objects in the readerPool should be 0")
-}
-
-func initSdlInstanceMock(namespace string, poolSize int) *MockSdlInstance {
- sdlInstanceMock := new(MockSdlInstance)
- initPool(poolSize, func() interface{} {
- sdlI := common.ISdlInstance(sdlInstanceMock)
- return &rNibReaderInstance{sdl: &sdlI, namespace: namespace}
- },
- func(obj interface{}) {
- },
- )
- return sdlInstanceMock
+func initSdlSyncStorageMock() (w RNibReader, sdlStorageMock *MockSdlSyncStorage) {
+ sdlStorageMock = new(MockSdlSyncStorage)
+ w = GetNewRNibReader(sdlStorageMock)
+ return
+}
+
+func TestGetRNibNamespace(t *testing.T) {
+ ns := common.GetRNibNamespace()
+ assert.Equal(t, "e2Manager", ns)
}
func TestGetNodeB(t *testing.T) {
name := "name"
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
nb := entities.NodebInfo{}
nb.ConnectionStatus = 1
nb.Ip = "localhost"
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)
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
getNb, er := w.GetNodeb(name)
assert.Nil(t, er)
assert.Equal(t, getNb.Ip, nb.Ip)
func TestGetNodeBNotFoundFailure(t *testing.T) {
name := "name"
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
var e error
var ret map[string]interface{}
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)
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
getNb, er := w.GetNodeb(name)
assert.NotNil(t, er)
assert.Nil(t, getNb)
func TestGetNodeBUnmarshalFailure(t *testing.T) {
name := "name"
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
var e error
ret := make(map[string]interface{}, 1)
redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
t.Errorf("#rNibReader_test.TestGetNodeBUnmarshalFailure - failed to validate key parameter")
}
ret[redisKey] = "data"
- sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
getNb, er := w.GetNodeb(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())
+ assert.Contains(t, er.Error(), "proto:")
}
func TestGetNodeBSdlgoFailure(t *testing.T) {
name := "name"
errMsg := "expected Sdlgo error"
errMsgExpected := "expected Sdlgo error"
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
e := errors.New(errMsg)
var ret map[string]interface{}
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)
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
getNb, er := w.GetNodeb(name)
assert.NotNil(t, er)
assert.Nil(t, getNb)
func TestGetNodeBCellsListEnb(t *testing.T) {
name := "name"
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
nb := entities.NodebInfo{}
nb.ConnectionStatus = 1
nb.Ip = "localhost"
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)
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
cells, er := w.GetCellList(name)
assert.Nil(t, er)
assert.NotNil(t, cells)
func TestGetNodeBCellsListGnb(t *testing.T) {
name := "name"
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
nb := entities.NodebInfo{}
nb.ConnectionStatus = 1
nb.Ip = "localhost"
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)
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
cells, er := w.GetCellList(name)
assert.Nil(t, er)
assert.NotNil(t, cells)
func TestGetNodeBCellsListNodeUnmarshalFailure(t *testing.T) {
name := "name"
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
var e error
ret := make(map[string]interface{}, 1)
redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
t.Errorf("#rNibReader_test.TestGetNodeBCellsListNodeUnmarshalFailure - failed to validate key parameter")
}
ret[redisKey] = "data"
- sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
cells, er := w.GetCellList(name)
assert.NotNil(t, er)
assert.Nil(t, cells)
assert.IsType(t, &common.InternalError{}, er)
- assert.EqualValues(t, "proto: can't skip unknown wire type 4", er.Error())
+ assert.Contains(t, er.Error(), "proto:")
}
func TestGetNodeBCellsListNodeNotFoundFailure(t *testing.T) {
name := "name"
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
var e error
var ret map[string]interface{}
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)
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
cells, er := w.GetCellList(name)
assert.NotNil(t, er)
assert.Nil(t, cells)
func TestGetNodeBCellsListNotFoundFailureEnb(t *testing.T) {
name := "name"
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
nb := entities.NodebInfo{}
nb.ConnectionStatus = 1
nb.Ip = "localhost"
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)
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
_, er := w.GetCellList(name)
assert.NotNil(t, er)
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, sdlInstanceMock := initSdlSyncStorageMock()
nb := entities.NodebInfo{}
nb.ConnectionStatus = 1
nb.Ip = "localhost"
t.Errorf("#rNibReader_test.TestGetNodeBCellsListNotFoundFailureGnb - failed to validate key parameter")
}
ret := map[string]interface{}{redisKey: string(data)}
- sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
_, er := w.GetCellList(name)
assert.NotNil(t, er)
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()
- _, 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")
- assert.Equal(t, 1, created, "number of created objects in the readerPool should be 1")
- var e error
- instanceMock.On("Close").Return(e)
- Close()
- assert.Panics(t, func() { Close() })
-}
-
-func TestCloseFailure(t *testing.T) {
- readerPool = nil
- instanceMock := initSdlInstanceMock(namespace, 2)
- w1 := GetRNibReader()
- _, 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 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)
- Close()
- available, created = readerPool.Stats()
- assert.Equal(t, 0, available, "number of available objects in the readerPool should be 0")
- assert.Equal(t, 0, created, "number of created objects in the readerPool should be 0")
-}
-
func TestGetListGnbIdsUnmarshalFailure(t *testing.T) {
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
var e error
- sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return([]string{"data"}, e)
+ sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_GNB.String()).Return([]string{"data"}, e)
ids, er := w.GetListGnbIds()
assert.NotNil(t, er)
assert.Nil(t, ids)
assert.IsType(t, &common.InternalError{}, er)
- assert.Equal(t, "proto: can't skip unknown wire type 4", er.Error())
+ assert.Contains(t, er.Error(), "proto:")
}
func TestGetListGnbIdsSdlgoFailure(t *testing.T) {
errMsg := "expected Sdlgo error"
errMsgExpected := "expected Sdlgo error"
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
e := errors.New(errMsg)
var data []string
- sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return(data, e)
+ sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_GNB.String()).Return(data, e)
ids, er := w.GetListGnbIds()
assert.NotNil(t, er)
assert.Nil(t, ids)
}
func TestGetListNodesIdsGnbSdlgoFailure(t *testing.T) {
-
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
name := "name"
plmnId := "02f829"
if err != nil {
t.Errorf("#rNibReader_test.TestGetListNodesIdsGnbSdlgoFailure - Failed to marshal nodeb identity entity. Error: %v", err)
}
- sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{string(data)}, nilError)
+ sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_ENB.String()).Return([]string{string(data)}, nilError)
errMsg := "expected Sdlgo error"
errMsgExpected := "expected Sdlgo error"
expectedError := errors.New(errMsg)
var nilData []string
- sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return(nilData, expectedError)
+ sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_GNB.String()).Return(nilData, expectedError)
ids, er := w.GetListNodebIds()
assert.NotNil(t, er)
}
func TestGetListNodesIdsEnbSdlgoFailure(t *testing.T) {
-
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
name := "name"
plmnId := "02f829"
if err != nil {
t.Errorf("#rNibReader_test.TestGetListNodesIdsEnbSdlgoFailure - Failed to marshal nodeb identity entity. Error: %v", err)
}
- sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return([]string{string(data)}, nilError)
+ sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_GNB.String()).Return([]string{string(data)}, nilError)
errMsg := "expected Sdlgo error"
errMsgExpected := "expected Sdlgo error"
expectedError := errors.New(errMsg)
var nilData []string
- sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return(nilData, expectedError)
+ sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_ENB.String()).Return(nilData, expectedError)
ids, er := w.GetListNodebIds()
assert.NotNil(t, er)
}
func TestGetListNodesIdsSuccess(t *testing.T) {
-
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
var nilError error
name := "name"
t.Errorf("#rNibReader_test.TestGetListNodesIdsSuccess - Failed to marshal nodeb identity entity. Error: %v", err)
}
- 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)
+ sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_GNB.String()).Return([]string{string(data)}, nilError)
+ sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_ENB.String()).Return([]string{string(data1)}, nilError)
ids, er := w.GetListNodebIds()
assert.Nil(t, er)
assert.NotNil(t, ids)
- assert.Len(t, ids, 3)
+ assert.Len(t, ids, 2)
}
func TestGetListEnbIdsUnmarshalFailure(t *testing.T) {
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
var e error
- sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{"data"}, e)
+ sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_ENB.String()).Return([]string{"data"}, e)
ids, er := w.GetListEnbIds()
assert.NotNil(t, er)
assert.Nil(t, ids)
assert.IsType(t, &common.InternalError{}, er)
- assert.Equal(t, "proto: can't skip unknown wire type 4", er.Error())
+ assert.Contains(t, er.Error(), "proto:")
}
func TestGetListEnbIdsOneId(t *testing.T) {
name := "name"
plmnId := "02f829"
nbId := "4a952a0a"
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
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", entities.Node_ENB.String()).Return([]string{string(data)}, e)
+ sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_ENB.String()).Return([]string{string(data)}, e)
ids, er := w.GetListEnbIds()
assert.Nil(t, er)
assert.Len(t, ids, 1)
}
func TestGetListEnbIdsNoIds(t *testing.T) {
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
var e error
- sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{}, e)
+ sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_ENB.String()).Return([]string{}, e)
ids, er := w.GetListEnbIds()
assert.Nil(t, er)
assert.Len(t, ids, 0)
plmnId := 0x02f829
nbId := 0x4a952a0a
listSize := 3
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
idsData := make([]string, listSize)
idsEntities := make([]*entities.NbIdentity, listSize)
for i := 0; i < listSize; i++ {
- nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: string(plmnId + i), NbId: string(nbId + i)}}
+ nbIdentity := &entities.NbIdentity{
+ InventoryName: name,
+ GlobalNbId: &entities.GlobalNbId{
+ PlmnId: strconv.FormatInt(int64(plmnId+i), 16),
+ NbId: strconv.FormatInt(int64(nbId+i), 16),
+ },
+ }
data, err := proto.Marshal(nbIdentity)
if err != nil {
t.Errorf("#rNibReader_test.TestGetListEnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
idsEntities[i] = nbIdentity
}
var e error
- sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return(idsData, e)
+ sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_ENB.String()).Return(idsData, e)
ids, er := w.GetListEnbIds()
assert.Nil(t, er)
assert.Len(t, ids, listSize)
name := "name"
plmnId := "02f829"
nbId := "4a952a0a"
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
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", entities.Node_GNB.String()).Return([]string{string(data)}, e)
+ sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_GNB.String()).Return([]string{string(data)}, e)
ids, er := w.GetListGnbIds()
assert.Nil(t, er)
assert.Len(t, ids, 1)
}
func TestGetListGnbIdsNoIds(t *testing.T) {
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
var e error
- sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return([]string{}, e)
+ sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_GNB.String()).Return([]string{}, e)
ids, er := w.GetListGnbIds()
assert.Nil(t, er)
assert.Len(t, ids, 0)
plmnId := 0x02f829
nbId := 0x4a952a0a
listSize := 3
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
idsData := make([]string, listSize)
idsEntities := make([]*entities.NbIdentity, listSize)
for i := 0; i < listSize; i++ {
- nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: string(plmnId + i), NbId: string(nbId + i)}}
+ nbIdentity := &entities.NbIdentity{
+ InventoryName: name,
+ GlobalNbId: &entities.GlobalNbId{
+ PlmnId: strconv.FormatInt(int64(plmnId+i), 16),
+ NbId: strconv.FormatInt(int64(nbId+i), 16),
+ },
+ }
data, err := proto.Marshal(nbIdentity)
if err != nil {
t.Errorf("#rNibReader_test.TestGetListGnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
idsEntities[i] = nbIdentity
}
var e error
- sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return(idsData, e)
+ sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_GNB.String()).Return(idsData, e)
ids, er := w.GetListGnbIds()
assert.Nil(t, er)
assert.Len(t, ids, listSize)
func TestGetListEnbIdsSdlgoFailure(t *testing.T) {
errMsg := "expected Sdlgo error"
errMsgExpected := "expected Sdlgo error"
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
e := errors.New(errMsg)
var data []string
- sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return(data, e)
+ sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_ENB.String()).Return(data, e)
ids, er := w.GetListEnbIds()
assert.NotNil(t, er)
assert.Nil(t, ids)
}
func TestGetCountGnbListOneId(t *testing.T) {
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
var e error
- sdlInstanceMock.On("GroupSize", entities.Node_GNB.String()).Return(1, e)
+ sdlInstanceMock.On("GroupSize", common.GetRNibNamespace(), 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, sdlInstanceMock := initSdlSyncStorageMock()
var e error
- sdlInstanceMock.On("GroupSize", entities.Node_GNB.String()).Return(3, e)
+ sdlInstanceMock.On("GroupSize", common.GetRNibNamespace(), 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 := "expected Sdlgo error"
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
e := errors.New(errMsg)
var count int
- sdlInstanceMock.On("GroupSize", entities.Node_GNB.String()).Return(count, e)
+ sdlInstanceMock.On("GroupSize", common.GetRNibNamespace(), entities.Node_GNB.String()).Return(count, e)
count, er := w.GetCountGnbList()
assert.NotNil(t, er)
assert.Equal(t, 0, count)
func TestGetCell(t *testing.T) {
name := "name"
var pci uint32 = 10
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
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 {
t.Errorf("#rNibReader_test.TestGetCell - failed to validate key parameter")
}
ret := map[string]interface{}{key: string(cellData)}
- sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
cell, er := w.GetCell(name, pci)
assert.Nil(t, er)
assert.NotNil(t, cell)
func TestGetCellNotFoundFailure(t *testing.T) {
name := "name"
var pci uint32
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
var e error
var ret map[string]interface{}
key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
if rNibErr != nil {
t.Errorf("#rNibReader_test.TestGetCellNotFoundFailure - failed to validate key parameter")
}
- sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
cell, er := w.GetCell(name, pci)
assert.NotNil(t, er)
assert.Nil(t, cell)
func TestGetCellUnmarshalFailure(t *testing.T) {
name := "name"
var pci uint32
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
var e error
ret := make(map[string]interface{}, 1)
key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
t.Errorf("#rNibReader_test.TestGetCellUnmarshalFailure - failed to validate key parameter")
}
ret[key] = "data"
- sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
cell, er := w.GetCell(name, pci)
assert.NotNil(t, er)
assert.Nil(t, cell)
assert.IsType(t, &common.InternalError{}, er)
- assert.EqualValues(t, "proto: can't skip unknown wire type 4", er.Error())
+ assert.Contains(t, er.Error(), "proto:")
}
func TestGetCellSdlgoFailure(t *testing.T) {
var pci uint32
errMsg := "expected Sdlgo error"
errMsgExpected := "expected Sdlgo error"
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
e := errors.New(errMsg)
var ret map[string]interface{}
key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
if rNibErr != nil {
t.Errorf("#rNibReader_test.TestGetCellSdlgoFailure - failed to validate key parameter")
}
- sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
cell, er := w.GetCell(name, pci)
assert.NotNil(t, er)
assert.Nil(t, cell)
}
func TestGetNodebById(t *testing.T) {
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
nb := entities.NodebInfo{NodeType: entities.Node_ENB}
nb.ConnectionStatus = 1
nb.Ip = "localhost"
t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
}
ret := map[string]interface{}{key: string(data)}
- sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
assert.Nil(t, er)
func TestGetNodebByIdNotFoundFailureEnb(t *testing.T) {
plmnId := "02f829"
nbId := "4a952a0a"
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
var e error
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)
}
var ret map[string]interface{}
- sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
assert.NotNil(t, er)
func TestGetNodebByIdNotFoundFailureGnb(t *testing.T) {
plmnId := "02f829"
nbId := "4a952a0a"
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
var e error
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)
}
var ret map[string]interface{}
- sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
getNb, er := w.GetNodebByGlobalNbId(entities.Node_GNB, globalNbId)
assert.NotNil(t, er)
func TestGetNodeByIdUnmarshalFailure(t *testing.T) {
plmnId := "02f829"
nbId := "4a952a0a"
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
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)
var e error
ret := make(map[string]interface{}, 1)
ret[key] = "data"
- sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
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())
+ assert.Contains(t, er.Error(), "proto:")
}
func TestGetNodeByIdSdlgoFailure(t *testing.T) {
nbId := "4a952a0a"
errMsg := "expected Sdlgo error"
errMsgExpected := "expected Sdlgo error"
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
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)
}
e := errors.New(errMsg)
var ret map[string]interface{}
- sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
getNb, er := w.GetNodebByGlobalNbId(entities.Node_GNB, globalNbId)
assert.NotNil(t, er)
func TestGetCellById(t *testing.T) {
cellId := "aaaa"
var pci uint32 = 10
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
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 {
t.Errorf("#rNibReader_test.TestGetCellById - failed to validate key parameter")
}
ret := map[string]interface{}{key: string(cellData)}
- sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
assert.Nil(t, er)
assert.NotNil(t, cell)
func TestGetCellByIdNotFoundFailureEnb(t *testing.T) {
cellId := "bbbb"
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
var e error
var ret map[string]interface{}
key, rNibErr := common.ValidateAndBuildCellIdKey(cellId)
if rNibErr != nil {
t.Errorf("#rNibReader_test.TestGetCellByIdNotFoundFailure - failed to validate key parameter")
}
- sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
assert.NotNil(t, er)
assert.Nil(t, cell)
func TestGetCellByIdNotFoundFailureGnb(t *testing.T) {
cellId := "bbbb"
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
var e error
var ret map[string]interface{}
key, rNibErr := common.ValidateAndBuildNrCellIdKey(cellId)
if rNibErr != nil {
t.Errorf("#rNibReader_test.TestGetCellByIdNotFoundFailure - failed to validate key parameter")
}
- sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
cell, er := w.GetCellById(entities.Cell_NR_CELL, cellId)
assert.NotNil(t, er)
assert.Nil(t, cell)
func TestGetCellByIdTypeValidationFailure(t *testing.T) {
cellId := "dddd"
- readerPool = nil
- initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, _ := initSdlSyncStorageMock()
cell, er := w.GetCellById(5, cellId)
assert.NotNil(t, er)
assert.Nil(t, cell)
func TestGetCellByIdValidationFailureGnb(t *testing.T) {
cellId := ""
- readerPool = nil
- initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, _ := initSdlSyncStorageMock()
cell, er := w.GetCellById(entities.Cell_NR_CELL, cellId)
assert.NotNil(t, er)
assert.Nil(t, cell)
func TestGetCellByIdValidationFailureEnb(t *testing.T) {
cellId := ""
- readerPool = nil
- initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, _ := initSdlSyncStorageMock()
cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
assert.NotNil(t, er)
assert.Nil(t, cell)
func TestGetRanLoadInformation(t *testing.T) {
name := "name"
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
loadInfo := generateRanLoadInformation()
var e error
data, err := proto.Marshal(loadInfo)
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)
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
getLoadInfo, er := w.GetRanLoadInformation(name)
assert.Nil(t, er)
assert.NotNil(t, getLoadInfo)
func TestGetRanLoadInformationValidationFailure(t *testing.T) {
name := ""
- readerPool = nil
- initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, _ := initSdlSyncStorageMock()
getNb, er := w.GetRanLoadInformation(name)
assert.NotNil(t, er)
assert.Nil(t, getNb)
func TestGetRanLoadInformationNotFoundFailure(t *testing.T) {
name := "name"
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
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)
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
getNb, er := w.GetRanLoadInformation(name)
assert.NotNil(t, er)
assert.Nil(t, getNb)
func TestGetRanLoadInformationUnmarshalFailure(t *testing.T) {
name := "name"
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
var e error
ret := make(map[string]interface{}, 1)
redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
t.Errorf("#rNibReader_test.TestGetRanLoadInformationUnmarshalFailure - failed to validate key parameter")
}
ret[redisKey] = "data"
- sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []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())
+ assert.Contains(t, er.Error(), "proto:")
}
func TestGetRanLoadInformationSdlgoFailure(t *testing.T) {
name := "name"
errMsg := "expected Sdlgo error"
errMsgExpected := "expected Sdlgo error"
- readerPool = nil
- sdlInstanceMock := initSdlInstanceMock(namespace, 1)
- w := GetRNibReader()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
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)
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
getNb, er := w.GetRanLoadInformation(name)
assert.NotNil(t, er)
assert.Nil(t, getNb)
cellLoadInformation.UlInterferenceOverloadIndications = []entities.UlInterferenceOverloadIndication{ulInterferenceOverloadIndication}
ulHighInterferenceInformation := entities.UlHighInterferenceInformation{
- TargetCellId:"456",
- UlHighInterferenceIndication:"xxx",
+ TargetCellId: "456",
+ UlHighInterferenceIndication: "xxx",
}
- cellLoadInformation.UlHighInterferenceInfos = []*entities.UlHighInterferenceInformation{&ulHighInterferenceInformation }
+ cellLoadInformation.UlHighInterferenceInfos = []*entities.UlHighInterferenceInformation{&ulHighInterferenceInformation}
cellLoadInformation.RelativeNarrowbandTxPower = &entities.RelativeNarrowbandTxPower{
- RntpPerPrb:"xxx",
- RntpThreshold:entities.RntpThreshold_NEG_4,
+ RntpPerPrb: "xxx",
+ RntpThreshold: entities.RntpThreshold_NEG_4,
NumberOfCellSpecificAntennaPorts: entities.NumberOfCellSpecificAntennaPorts_V1_ANT_PRT,
- PB: 1,
- PdcchInterferenceImpact:2,
+ PB: 1,
+ PdcchInterferenceImpact: 2,
EnhancedRntp: &entities.EnhancedRntp{
- EnhancedRntpBitmap:"xxx",
- RntpHighPowerThreshold:entities.RntpThreshold_NEG_2,
- EnhancedRntpStartTime: &entities.StartTime{StartSfn:500,StartSubframeNumber:5},
+ 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",
+ 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,
+ AssociatedSubframes: "xxx",
+ ExtendedUlInterferenceOverloadIndications: cellLoadInformation.UlInterferenceOverloadIndications,
}
compInformationItem := &entities.CompInformationItem{
CompHypothesisSets: []*entities.CompHypothesisSet{{CellId: "789", CompHypothesis: "xxx"}},
- BenefitMetric:50,
+ BenefitMetric: 50,
}
cellLoadInformation.CompInformation = &entities.CompInformation{
- CompInformationItems:[]*entities.CompInformationItem{compInformationItem},
- CompInformationStartTime:&entities.StartTime{StartSfn:123,StartSubframeNumber:456},
+ 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},
+ State: entities.NaicsState_NAICS_ACTIVE,
+ TransmissionModes: "xxx",
+ PB: 2,
+ PAList: []entities.PA{entities.PA_DB_NEG_3},
}
return &cellLoadInformation
return &ranLoadInformation
}
+func TestGetE2TInstanceSuccess(t *testing.T) {
+ address := "10.10.2.15:9800"
+ redisKey, validationErr := common.ValidateAndBuildE2TInstanceKey(address)
+
+ if validationErr != nil {
+ t.Errorf("#rNibReader_test.TestGetE2TInstanceSuccess - Failed to build E2T Instance key. Error: %v", validationErr)
+ }
+
+ w, sdlInstanceMock := initSdlSyncStorageMock()
+
+ e2tInstance := generateE2tInstance(address)
+ data, err := json.Marshal(e2tInstance)
+
+ if err != nil {
+ t.Errorf("#rNibReader_test.TestGetE2TInstanceSuccess - Failed to marshal E2tInstance entity. Error: %v", err)
+ }
+
+ var e error
+ ret := map[string]interface{}{redisKey: string(data)}
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
+
+ res, rNibErr := w.GetE2TInstance(address)
+ assert.Nil(t, rNibErr)
+ assert.Equal(t, e2tInstance, res)
+}
+
+func TestUnmarshal(t *testing.T) {
+ e2tInstance := generateE2tInstance("10.0.2.15:5555")
+ marshaled, _ := json.Marshal(e2tInstance)
+ m := map[string]interface{}{
+ "whatever": string(marshaled),
+ }
+ var entity entities.E2TInstance
+ err := json.Unmarshal([]byte(m["whatever"].(string)), &entity)
+ assert.Nil(t, err)
+}
+
+func TestGetE2TInstanceEmptyAddressFailure(t *testing.T) {
+ w, _ := initSdlSyncStorageMock()
+ res, err := w.GetE2TInstance("")
+ assert.NotNil(t, err)
+ assert.IsType(t, &common.ValidationError{}, err)
+ assert.Nil(t, res)
+}
+
+func TestGetE2TInstanceSdlError(t *testing.T) {
+ address := "10.10.2.15:9800"
+ redisKey, validationErr := common.ValidateAndBuildE2TInstanceKey(address)
+
+ if validationErr != nil {
+ t.Errorf("#rNibReader_test.TestGetE2TInstanceSuccess - Failed to build E2T Instance key. Error: %v", validationErr)
+ }
+
+ w, sdlInstanceMock := initSdlSyncStorageMock()
+
+ expectedErr := errors.New("expected error")
+ var ret map[string]interface{}
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, expectedErr)
+
+ res, rNibErr := w.GetE2TInstance(address)
+ assert.NotNil(t, rNibErr)
+ assert.Nil(t, res)
+}
+
+func generateE2tInstance(address string) *entities.E2TInstance {
+ e2tInstance := entities.NewE2TInstance(address,"")
+ e2tInstance.AssociatedRanList = []string{"test1", "test2"}
+ e2tInstance.DeletionTimestamp = time.Now().UnixNano()
+ return e2tInstance
+}
+
+func TestGetE2TAddressesSdlError(t *testing.T) {
+ w, sdlInstanceMock := initSdlSyncStorageMock()
+
+ expectedErr := errors.New("expected error")
+ var ret map[string]interface{}
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{E2TAddressesKey}).Return(ret, expectedErr)
+
+ res, rNibErr := w.GetE2TAddresses()
+ assert.NotNil(t, rNibErr)
+ assert.Nil(t, res)
+}
+
+func TestGetE2TAddressesSuccess(t *testing.T) {
+ address := "10.10.2.15:9800"
+ w, sdlInstanceMock := initSdlSyncStorageMock()
+
+ e2tAddresses := []string{address}
+ data, err := json.Marshal(e2tAddresses)
+
+ if err != nil {
+ t.Errorf("#rNibReader_test.TestGetE2TInfoListSuccess - Failed to marshal E2TInfoList. Error: %v", err)
+ }
+
+ var e error
+ ret := map[string]interface{}{E2TAddressesKey: string(data)}
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{E2TAddressesKey}).Return(ret, e)
+
+ res, rNibErr := w.GetE2TAddresses()
+ assert.Nil(t, rNibErr)
+ assert.Equal(t, e2tAddresses, res)
+}
+
+func TestGetE2TInstancesSuccess(t *testing.T) {
+ address := "10.10.2.15:9800"
+ address2 := "10.10.2.16:9800"
+ redisKey, _ := common.ValidateAndBuildE2TInstanceKey(address)
+ redisKey2, _ := common.ValidateAndBuildE2TInstanceKey(address2)
+
+ w, sdlInstanceMock := initSdlSyncStorageMock()
+
+ e2tInstance1 := generateE2tInstance(address)
+ e2tInstance2 := generateE2tInstance(address2)
+
+ data1, _ := json.Marshal(e2tInstance1)
+ data2, _ := json.Marshal(e2tInstance2)
+
+ var e error
+ ret := map[string]interface{}{redisKey: string(data1), redisKey2: string(data2)}
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey, redisKey2}).Return(ret, e)
+
+ res, err := w.GetE2TInstances([]string{address, address2})
+ assert.Nil(t, err)
+ assert.Equal(t, []*entities.E2TInstance{e2tInstance1, e2tInstance2}, res)
+}
+
+func TestGetE2TInstancesUnmarhalPartialSuccess(t *testing.T) {
+ address := "10.10.2.15:9800"
+ address2 := "10.10.2.16:9800"
+ redisKey, _ := common.ValidateAndBuildE2TInstanceKey(address)
+ redisKey2, _ := common.ValidateAndBuildE2TInstanceKey(address2)
+
+ w, sdlInstanceMock := initSdlSyncStorageMock()
+
+ e2tInstance1 := generateE2tInstance(address)
+ data1, _ := json.Marshal(e2tInstance1)
+
+ var e error
+ ret := map[string]interface{}{redisKey: string(data1), redisKey2: "abc"}
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey, redisKey2}).Return(ret, e)
+
+ res, err := w.GetE2TInstances([]string{address, address2})
+ assert.Nil(t, err)
+ assert.Equal(t, []*entities.E2TInstance{e2tInstance1}, res)
+}
+
+func TestGetE2TInstancesSdlFailure(t *testing.T) {
+ address := "10.10.2.15:9800"
+ address2 := "10.10.2.16:9800"
+ redisKey, _ := common.ValidateAndBuildE2TInstanceKey(address)
+ redisKey2, _ := common.ValidateAndBuildE2TInstanceKey(address2)
+
+ w, sdlInstanceMock := initSdlSyncStorageMock()
+
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey, redisKey2}).Return(map[string]interface{}{}, fmt.Errorf(""))
+ _, err := w.GetE2TInstances([]string{address, address2})
+ assert.IsType(t, &common.InternalError{}, err)
+}
+
+func TestGetE2TInstancesEmptyData(t *testing.T) {
+ address := "10.10.2.15:9800"
+ address2 := "10.10.2.16:9800"
+ redisKey, _ := common.ValidateAndBuildE2TInstanceKey(address)
+ redisKey2, _ := common.ValidateAndBuildE2TInstanceKey(address2)
+
+ w, sdlInstanceMock := initSdlSyncStorageMock()
+
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey, redisKey2}).Return(map[string]interface{}{}, nil)
+ _, err := w.GetE2TInstances([]string{address, address2})
+ assert.IsType(t, &common.ResourceNotFoundError{}, err)
+}
+
+func TestGetGeneralConfiguration(t *testing.T) {
+
+ key := common.BuildGeneralConfigurationKey()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
+
+ configurationData := "{\"enableRic\":true}"
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(map[string]interface{}{key: configurationData}, nil)
+
+ res, rNibErr := w.GetGeneralConfiguration()
+ assert.Nil(t, rNibErr)
+ assert.Equal(t, true, res.EnableRic)
+}
+
+func TestGetGeneralConfigurationNotFound(t *testing.T) {
+
+ key := common.BuildGeneralConfigurationKey()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
+
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(map[string]interface{}{}, nil)
+
+ _, rNibErr := w.GetGeneralConfiguration()
+
+ assert.NotNil(t, rNibErr)
+ assert.Equal(t, "#rNibReader.getByKeyAndUnmarshalJson - entity of type *entities.GeneralConfiguration not found. Key: GENERAL", rNibErr.Error())
+}
+
+func TestGetGeneralConfigurationSdlFailure(t *testing.T) {
+
+ key := common.BuildGeneralConfigurationKey()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
+
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(map[string]interface{}{}, fmt.Errorf("sdl error"))
+
+ _, rNibErr := w.GetGeneralConfiguration()
+
+ assert.NotNil(t, rNibErr)
+
+ assert.Equal(t, "sdl error", rNibErr.Error())
+}
+
+func TestGetGeneralConfigurationUnmarshalError(t *testing.T) {
+
+ key := common.BuildGeneralConfigurationKey()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
+
+ configurationData := "{\"enableRic :true}"
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(map[string]interface{}{key: configurationData}, nil)
+
+ _, rNibErr := w.GetGeneralConfiguration()
+
+ assert.NotNil(t, rNibErr)
+ assert.Equal(t, rNibErr.Error(), "unexpected end of JSON input")
+}
+
+func TestGetRanFunctionDefinition(t *testing.T) {
+ name := "name"
+ oid := "1.3.6.1.4.1.1.2.2.2"
+ w, sdlInstanceMock := initSdlSyncStorageMock()
+ nb := entities.NodebInfo{}
+ nb.ConnectionStatus = 1
+ nb.Ip = "localhost"
+ nb.Port = 5656
+ enb := entities.Enb{}
+ cell := entities.ServedCellInfo{Tac: "tac"}
+ enb.ServedCells = []*entities.ServedCellInfo{&cell}
+ nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
+ var e error
+ data, err := proto.Marshal(&nb)
+ if err != nil {
+ t.Errorf("#rNibReader_test.GetRanFunctionDefinition - Failed to marshal ENB instance. Error: %v", err)
+ }
+ redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
+ if rNibErr != nil {
+ t.Errorf("#rNibReader_test.TestRanFunctionDefinition - failed to validate key parameter")
+ }
+ ret := map[string]interface{}{redisKey: string(data)}
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
+ ranFuncs, er := w.GetRanFunctionDefinition(name, oid)
+ assert.IsType(t, &common.ResourceNotFoundError{}, er)
+ assert.Nil(t, ranFuncs)
+}
+
//integration tests
//
//func TestGetEnbInteg(t *testing.T){
// }
// assert.NotNil(t, ranLoadInformation)
// fmt.Printf("#rNibReader_test.TestGetRanLoadInformationInteg - GNB ID: %s\n", ranLoadInformation)
-//}
\ No newline at end of file
+//}
+
+//func TestGetE2TInstancesInteg(t *testing.T) {
+// db := sdlgo.NewDatabase()
+// sdl := sdlgo.NewSdlInstance("e2Manager", db)
+// rnibReader := GetRNibReader(sdl)
+// e2tInstances, _ := rnibReader.GetE2TInstances([]string{"e2t.att.com:38000","whatever"})
+// assert.Len(t, e2tInstances, 1)
+//}
Code Review / ric-plt / nodeb-rnib.git / blobdiff