package common
-/*
-ISdlInstance integrates (wraps) the functionality that sdlgo library provides
- */
+
+//ISdlInstance integrates (wraps) the functionality that sdlgo library provides
+//Deprecated: Will be removed in a future release.
type ISdlInstance interface {
SubscribeChannel(cb func(string, ...string), channels ...string) error
UnsubscribeChannel(channels ...string) error
--- /dev/null
+//
+// Copyright 2021 AT&T Intellectual Property
+// Copyright 2021 Nokia
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This source code is part of the near-RT RIC (RAN Intelligent Controller)
+// platform project (RICP).
+
+package common
+
+// ISdlSyncStorage integrates (wraps) the functionality that sdlgo SyncStorage provides
+type ISdlSyncStorage interface {
+ SubscribeChannel(ns string, cb func(string, ...string), channels ...string) error
+ UnsubscribeChannel(ns string, channels ...string) error
+ Close() error
+ SetAndPublish(ns string, channelsAndEvents []string, pairs ...interface{}) error
+ Set(ns string, pairs ...interface{}) error
+ Get(ns string, keys []string) (map[string]interface{}, error)
+ SetIfAndPublish(ns string, channelsAndEvents []string, key string, oldData, newData interface{}) (bool, error)
+ SetIf(ns string, key string, oldData, newData interface{}) (bool, error)
+ SetIfNotExistsAndPublish(ns string, channelsAndEvents []string, key string, data interface{}) (bool, error)
+ SetIfNotExists(ns string, key string, data interface{}) (bool, error)
+ RemoveAndPublish(ns string, channelsAndEvents []string, keys []string) error
+ Remove(ns string, keys []string) error
+ RemoveIfAndPublish(ns string, channelsAndEvents []string, key string, data interface{}) (bool, error)
+ RemoveIf(ns string, key string, data interface{}) (bool, error)
+ GetAll(ns string) ([]string, error)
+ RemoveAll(ns string) error
+ RemoveAllAndPublish(ns string, channelsAndEvents []string) error
+ AddMember(ns string, group string, member ...interface{}) error
+ RemoveMember(ns string, group string, member ...interface{}) error
+ RemoveGroup(ns string, group string) error
+ GetMembers(ns string, group string) ([]string, error)
+ IsMember(ns string, group string, member interface{}) (bool, error)
+ GroupSize(ns string, group string) (int64, error)
+}
"fmt"
)
+//SDL namespace used by the RNIB
+const rnibNamespace = "e2Manager"
+
/*
ValidateAndBuildCellIdKey builds key according to the specified format returns the resulting string
*/
return keys
}
+
+//GetRNibNamespace returns namespace used by the RNIB in SDL.
+func GetRNibNamespace() string {
+ return rnibNamespace
+}
go 1.12
require (
- gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common v1.0.48
- gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities v1.0.48
+ gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common v1.0.49
+ gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities v1.0.49
+ gerrit.o-ran-sc.org/r/ric-plt/sdlgo v0.7.0
github.com/golang/protobuf v1.4.2
github.com/google/go-cmp v0.4.1 // indirect
github.com/pkg/errors v0.8.1
const E2TAddressesKey = "E2TAddresses"
type rNibReaderInstance struct {
- sdl common.ISdlInstance
+ sdl common.ISdlInstance //Deprecated: Will be removed in a future release and replaced by sdlStorage
+ sdlStorage common.ISdlSyncStorage
+ ns string
}
/*
GetGeneralConfiguration() (*entities.GeneralConfiguration, error)
}
-/*
-GetRNibReader returns reference to RNibReader
-*/
+//GetNewRNibReader returns reference to RNibReader
+func GetNewRNibReader(storage common.ISdlSyncStorage) RNibReader {
+ return &rNibReaderInstance{
+ sdl: nil,
+ sdlStorage: storage,
+ ns: common.GetRNibNamespace(),
+ }
+}
+
+//GetRNibReader returns reference to RNibReader
+//Deprecated: Will be removed in a future release, please use GetNewRNibReader instead.
func GetRNibReader(sdl common.ISdlInstance) RNibReader {
- return &rNibReaderInstance{sdl: sdl}
+ return &rNibReaderInstance{
+ sdl: sdl,
+ sdlStorage: nil,
+ ns: "",
+ }
}
func (w *rNibReaderInstance) GetNodeb(inventoryName string) (*entities.NodebInfo, error) {
}
func (w *rNibReaderInstance) GetCountGnbList() (int, error) {
- size, err := w.sdl.GroupSize(entities.Node_GNB.String())
+ var size int64
+ var err error
+ if w.sdlStorage != nil {
+ size, err = w.sdlStorage.GroupSize(w.ns, entities.Node_GNB.String())
+ } else {
+ size, err = w.sdl.GroupSize(entities.Node_GNB.String())
+ }
if err != nil {
return 0, common.NewInternalError(err)
}
}
func (w *rNibReaderInstance) GetListNodebIds() ([]*entities.NbIdentity, error) {
- dataEnb, err := w.sdl.GetMembers(entities.Node_ENB.String())
+ var dataEnb, dataGnb []string
+ var err error
+ if w.sdlStorage != nil {
+ dataEnb, err = w.sdlStorage.GetMembers(w.ns, entities.Node_ENB.String())
+ } else {
+ dataEnb, err = w.sdl.GetMembers(entities.Node_ENB.String())
+ }
if err != nil {
return nil, common.NewInternalError(err)
}
- dataGnb, err := w.sdl.GetMembers(entities.Node_GNB.String())
+ if w.sdlStorage != nil {
+ dataGnb, err = w.sdlStorage.GetMembers(w.ns, entities.Node_GNB.String())
+ } else {
+ dataGnb, err = w.sdl.GetMembers(entities.Node_GNB.String())
+ }
if err != nil {
return nil, common.NewInternalError(err)
}
}
func (w *rNibReaderInstance) GetE2TInstances(addresses []string) ([]*entities.E2TInstance, error) {
+ var data map[string]interface{}
+ var err error
+
keys := common.MapE2TAddressesToKeys(addresses)
e2tInstances := []*entities.E2TInstance{}
- data, err := w.sdl.Get(keys)
+ if w.sdlStorage != nil {
+ data, err = w.sdlStorage.Get(w.ns, keys)
+ } else {
+ data, err = w.sdl.Get(keys)
+ }
if err != nil {
return []*entities.E2TInstance{}, common.NewInternalError(err)
}
func (w *rNibReaderInstance) getByKeyAndUnmarshalJson(key string, entity interface{}) error {
- data, err := w.sdl.Get([]string{key})
+ var data map[string]interface{}
+ var err error
+ if w.sdlStorage != nil {
+ data, err = w.sdlStorage.Get(w.ns, []string{key})
+ } else {
+ data, err = w.sdl.Get([]string{key})
+ }
if err != nil {
return common.NewInternalError(err)
}
func (w *rNibReaderInstance) getByKeyAndUnmarshal(key string, entity proto.Message) error {
- data, err := w.sdl.Get([]string{key})
+ var data map[string]interface{}
+ var err error
+ if w.sdlStorage != nil {
+ data, err = w.sdlStorage.Get(w.ns, []string{key})
+ } else {
+ data, err = w.sdl.Get([]string{key})
+ }
+
if err != nil {
return common.NewInternalError(err)
}
}
func (w *rNibReaderInstance) getListNodebIdsByType(nbType string) ([]*entities.NbIdentity, error) {
- data, err := w.sdl.GetMembers(nbType)
+ var data []string
+ var err error
+ if w.sdlStorage != nil {
+ data, err = w.sdlStorage.GetMembers(w.ns, nbType)
+ } else {
+ data, err = w.sdl.GetMembers(nbType)
+ }
if err != nil {
return nil, common.NewInternalError(err)
}
--- /dev/null
+//
+// Copyright 2021 AT&T Intellectual Property
+// Copyright 2021 Nokia
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This source code is part of the near-RT RIC (RAN Intelligent Controller)
+// platform project (RICP).
+
+package 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"
+ "testing"
+ "time"
+)
+
+//Deprecated: This file will be removed in a future release when SDL SdlInstance usage will be replaced by SynchStorage.
+//Valid RNIB Reader unit tests are in rNibReader_test.go file, rNibReaderDeprecated_test.go will exist until SdlInstance
+//usage will be removed from the RNIB source code.
+
+func initSdlInstanceMock() (w RNibReader, sdlInstanceMock *MockSdlInstance) {
+ sdlInstanceMock = new(MockSdlInstance)
+ w = GetRNibReader(sdlInstanceMock)
+ return
+}
+
+func TestGetNodeBDeprecated(t *testing.T) {
+ name := "name"
+ w, sdlInstanceMock := initSdlInstanceMock()
+ 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.TestGetNb - Failed to marshal ENB instance. Error: %v", err)
+ }
+ 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)
+ assert.Equal(t, getNb.Port, nb.Port)
+ assert.Equal(t, getNb.ConnectionStatus, nb.ConnectionStatus)
+ assert.Len(t, getNb.GetEnb().GetServedCells(), 1)
+ assert.Equal(t, getNb.GetEnb().GetServedCells()[0].Tac, nb.GetEnb().GetServedCells()[0].Tac)
+}
+
+func TestGetNodeBNotFoundFailureDeprecated(t *testing.T) {
+ name := "name"
+ w, sdlInstanceMock := initSdlInstanceMock()
+ 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)
+ getNb, er := w.GetNodeb(name)
+ assert.NotNil(t, er)
+ assert.Nil(t, getNb)
+ assert.IsType(t, &common.ResourceNotFoundError{}, er)
+ assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.NodebInfo not found. Key: RAN:name", er.Error())
+}
+
+func TestGetNodeBUnmarshalFailureDeprecated(t *testing.T) {
+ name := "name"
+ w, sdlInstanceMock := initSdlInstanceMock()
+ var e error
+ ret := make(map[string]interface{}, 1)
+ 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.IsType(t, &common.InternalError{}, er)
+ assert.Contains(t, er.Error(), "proto:")
+}
+
+func TestGetNodeBSdlgoFailureDeprecated(t *testing.T) {
+ name := "name"
+ errMsg := "expected Sdlgo error"
+ errMsgExpected := "expected Sdlgo error"
+ w, sdlInstanceMock := initSdlInstanceMock()
+ 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)
+ getNb, er := w.GetNodeb(name)
+ assert.NotNil(t, er)
+ assert.Nil(t, getNb)
+ assert.IsType(t, &common.InternalError{}, er)
+ assert.EqualValues(t, errMsgExpected, er.Error())
+}
+
+func TestGetNodeBCellsListEnbDeprecated(t *testing.T) {
+ name := "name"
+ w, sdlInstanceMock := initSdlInstanceMock()
+ 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.GetNodeBCellsList - Failed to marshal ENB instance. Error: %v", err)
+ }
+ 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)
+ assert.Len(t, cells.GetServedCellInfos().GetServedCells(), 1)
+ retCell := cells.GetServedCellInfos().GetServedCells()[0]
+ assert.Equal(t, retCell.Tac, "tac")
+}
+
+func TestGetNodeBCellsListGnbDeprecated(t *testing.T) {
+ name := "name"
+ w, sdlInstanceMock := initSdlInstanceMock()
+ nb := entities.NodebInfo{}
+ nb.ConnectionStatus = 1
+ nb.Ip = "localhost"
+ nb.Port = 5656
+ nb.NodeType = entities.Node_GNB
+ gnb := entities.Gnb{}
+ cell := entities.ServedNRCell{ServedNrCellInformation: &entities.ServedNRCellInformation{NrPci: 10}}
+ gnb.ServedNrCells = []*entities.ServedNRCell{&cell}
+ nb.Configuration = &entities.NodebInfo_Gnb{Gnb: &gnb}
+ var e error
+ data, err := proto.Marshal(&nb)
+ if err != nil {
+ t.Errorf("#rNibReader_test.GetNodeBCellsList - Failed to marshal GNB instance. Error: %v", err)
+ }
+ 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)
+ assert.Len(t, cells.GetServedNrCells().GetServedCells(), 1)
+ retCell := cells.GetServedNrCells().GetServedCells()[0]
+ assert.Equal(t, retCell.GetServedNrCellInformation().GetNrPci(), uint32(10))
+}
+
+func TestGetNodeBCellsListNodeUnmarshalFailureDeprecated(t *testing.T) {
+ name := "name"
+ w, sdlInstanceMock := initSdlInstanceMock()
+ var e error
+ ret := make(map[string]interface{}, 1)
+ 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.IsType(t, &common.InternalError{}, er)
+ assert.Contains(t, er.Error(), "proto:")
+}
+
+func TestGetNodeBCellsListNodeNotFoundFailureDeprecated(t *testing.T) {
+ name := "name"
+ w, sdlInstanceMock := initSdlInstanceMock()
+ 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)
+ cells, er := w.GetCellList(name)
+ assert.NotNil(t, er)
+ assert.Nil(t, cells)
+ assert.IsType(t, &common.ResourceNotFoundError{}, er)
+ assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.NodebInfo not found. Key: RAN:name", er.Error())
+}
+
+func TestGetNodeBCellsListNotFoundFailureEnbDeprecated(t *testing.T) {
+ name := "name"
+ w, sdlInstanceMock := initSdlInstanceMock()
+ nb := entities.NodebInfo{}
+ nb.ConnectionStatus = 1
+ nb.Ip = "localhost"
+ nb.Port = 5656
+ enb := entities.Enb{}
+ nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
+ var e error
+ data, err := proto.Marshal(&nb)
+ if err != nil {
+ t.Errorf("#rNibReader_test.TestGetNbCellsListNotFoundFailure - Failed to marshal ENB instance. Error: %v", err)
+ }
+ 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, "#rNibReader.GetCellList - served cells not found. Responding node RAN name: name.", er.Error())
+}
+
+func TestGetNodeBCellsListNotFoundFailureGnbDeprecated(t *testing.T) {
+ name := "name"
+ w, sdlInstanceMock := initSdlInstanceMock()
+ nb := entities.NodebInfo{}
+ nb.ConnectionStatus = 1
+ nb.Ip = "localhost"
+ nb.Port = 5656
+ gnb := entities.Gnb{}
+ nb.Configuration = &entities.NodebInfo_Gnb{Gnb: &gnb}
+ var e error
+ data, err := proto.Marshal(&nb)
+ if err != nil {
+ 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{}{redisKey: string(data)}
+ sdlInstanceMock.On("Get", []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 TestGetListGnbIdsUnmarshalFailureDeprecated(t *testing.T) {
+ w, sdlInstanceMock := initSdlInstanceMock()
+ var e error
+ sdlInstanceMock.On("GetMembers", 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.Contains(t, er.Error(), "proto:")
+}
+
+func TestGetListGnbIdsSdlgoFailureDeprecated(t *testing.T) {
+ errMsg := "expected Sdlgo error"
+ errMsgExpected := "expected Sdlgo error"
+ w, sdlInstanceMock := initSdlInstanceMock()
+ e := errors.New(errMsg)
+ var data []string
+ sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return(data, e)
+ ids, er := w.GetListGnbIds()
+ assert.NotNil(t, er)
+ assert.Nil(t, ids)
+ assert.IsType(t, &common.InternalError{}, er)
+ assert.EqualValues(t, errMsgExpected, er.Error())
+}
+
+func TestGetListNodesIdsGnbSdlgoFailureDeprecated(t *testing.T) {
+ w, sdlInstanceMock := initSdlInstanceMock()
+
+ 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.TestGetListNodesIdsGnbSdlgoFailure - Failed to marshal nodeb identity entity. Error: %v", err)
+ }
+ sdlInstanceMock.On("GetMembers", 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)
+
+ ids, er := w.GetListNodebIds()
+ assert.NotNil(t, er)
+ assert.Nil(t, ids)
+ assert.IsType(t, &common.InternalError{}, er)
+ assert.EqualValues(t, errMsgExpected, er.Error())
+}
+
+func TestGetListNodesIdsEnbSdlgoFailureDeprecated(t *testing.T) {
+ w, sdlInstanceMock := initSdlInstanceMock()
+
+ 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)
+ }
+ sdlInstanceMock.On("GetMembers", 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)
+
+ ids, er := w.GetListNodebIds()
+ assert.NotNil(t, er)
+ assert.Nil(t, ids)
+ assert.IsType(t, &common.InternalError{}, er)
+ assert.EqualValues(t, errMsgExpected, er.Error())
+}
+
+func TestGetListNodesIdsSuccessDeprecated(t *testing.T) {
+ w, sdlInstanceMock := initSdlInstanceMock()
+ var nilError error
+
+ name := "name"
+ plmnId := "02f829"
+ nbId := "4a952a0a"
+ nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
+ data, err := proto.Marshal(nbIdentity)
+ if err != nil {
+ 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", entities.Node_GNB.String()).Return([]string{string(data)}, nilError)
+ sdlInstanceMock.On("GetMembers", 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, 2)
+}
+
+func TestGetListEnbIdsUnmarshalFailureDeprecated(t *testing.T) {
+ w, sdlInstanceMock := initSdlInstanceMock()
+ var e error
+ sdlInstanceMock.On("GetMembers", 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.Contains(t, er.Error(), "proto:")
+}
+
+func TestGetListEnbIdsOneIdDeprecated(t *testing.T) {
+ name := "name"
+ plmnId := "02f829"
+ nbId := "4a952a0a"
+ w, sdlInstanceMock := initSdlInstanceMock()
+ 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)
+ 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())
+}
+
+func TestGetListEnbIdsNoIdsDeprecated(t *testing.T) {
+ w, sdlInstanceMock := initSdlInstanceMock()
+ var e error
+ sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{}, e)
+ ids, er := w.GetListEnbIds()
+ assert.Nil(t, er)
+ assert.Len(t, ids, 0)
+}
+
+func TestGetListEnbIdsDeprecated(t *testing.T) {
+ name := "name"
+ plmnId := 0x02f829
+ nbId := 0x4a952a0a
+ listSize := 3
+ w, sdlInstanceMock := initSdlInstanceMock()
+ 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)}}
+ data, err := proto.Marshal(nbIdentity)
+ if err != nil {
+ t.Errorf("#rNibReader_test.TestGetListEnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
+ }
+ idsData[i] = string(data)
+ idsEntities[i] = nbIdentity
+ }
+ var e error
+ 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.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 TestGetListGnbIdsOneIdDeprecated(t *testing.T) {
+ name := "name"
+ plmnId := "02f829"
+ nbId := "4a952a0a"
+ w, sdlInstanceMock := initSdlInstanceMock()
+ 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)
+ 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())
+}
+
+func TestGetListGnbIdsNoIdsDeprecated(t *testing.T) {
+ w, sdlInstanceMock := initSdlInstanceMock()
+ var e error
+ sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return([]string{}, e)
+ ids, er := w.GetListGnbIds()
+ assert.Nil(t, er)
+ assert.Len(t, ids, 0)
+}
+
+func TestGetListGnbIdsDeprecated(t *testing.T) {
+ name := "name"
+ plmnId := 0x02f829
+ nbId := 0x4a952a0a
+ listSize := 3
+ w, sdlInstanceMock := initSdlInstanceMock()
+ 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)}}
+ data, err := proto.Marshal(nbIdentity)
+ if err != nil {
+ t.Errorf("#rNibReader_test.TestGetListGnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
+ }
+ idsData[i] = string(data)
+ idsEntities[i] = nbIdentity
+ }
+ var e error
+ 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.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 TestGetListEnbIdsSdlgoFailureDeprecated(t *testing.T) {
+ errMsg := "expected Sdlgo error"
+ errMsgExpected := "expected Sdlgo error"
+ w, sdlInstanceMock := initSdlInstanceMock()
+ e := errors.New(errMsg)
+ var data []string
+ sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return(data, e)
+ ids, er := w.GetListEnbIds()
+ assert.NotNil(t, er)
+ assert.Nil(t, ids)
+ assert.IsType(t, &common.InternalError{}, er)
+ assert.EqualValues(t, errMsgExpected, er.Error())
+}
+
+func TestGetCountGnbListOneIdDeprecated(t *testing.T) {
+ w, sdlInstanceMock := initSdlInstanceMock()
+ var e error
+ sdlInstanceMock.On("GroupSize", entities.Node_GNB.String()).Return(1, e)
+ count, er := w.GetCountGnbList()
+ assert.Nil(t, er)
+ assert.Equal(t, count, 1)
+}
+
+func TestGetCountGnbListDeprecated(t *testing.T) {
+ w, sdlInstanceMock := initSdlInstanceMock()
+ var e error
+ sdlInstanceMock.On("GroupSize", entities.Node_GNB.String()).Return(3, e)
+ count, er := w.GetCountGnbList()
+ assert.Nil(t, er)
+ assert.Equal(t, count, 3)
+}
+
+func TestGetCountGnbListSdlgoFailureDeprecated(t *testing.T) {
+ errMsg := "expected Sdlgo error"
+ errMsgExpected := "expected Sdlgo error"
+ w, sdlInstanceMock := initSdlInstanceMock()
+ e := errors.New(errMsg)
+ var count int
+ sdlInstanceMock.On("GroupSize", entities.Node_GNB.String()).Return(count, e)
+ count, er := w.GetCountGnbList()
+ assert.NotNil(t, er)
+ assert.Equal(t, 0, count)
+ assert.IsType(t, &common.InternalError{}, er)
+ assert.EqualValues(t, errMsgExpected, er.Error())
+}
+
+func TestGetCellDeprecated(t *testing.T) {
+ name := "name"
+ var pci uint32 = 10
+ w, sdlInstanceMock := initSdlInstanceMock()
+ 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 marshal Cell entity. Error: %v", err)
+ }
+ var e error
+ key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
+ if rNibErr != 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)
+ cell, er := w.GetCell(name, pci)
+ assert.Nil(t, er)
+ assert.NotNil(t, cell)
+ assert.Equal(t, cell.Type, entities.Cell_LTE_CELL)
+ assert.NotNil(t, cell.GetServedCellInfo())
+ assert.Equal(t, cell.GetServedCellInfo().GetPci(), pci)
+}
+
+func TestGetCellNotFoundFailureDeprecated(t *testing.T) {
+ name := "name"
+ var pci uint32
+ w, sdlInstanceMock := initSdlInstanceMock()
+ 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)
+ cell, er := w.GetCell(name, pci)
+ assert.NotNil(t, er)
+ assert.Nil(t, cell)
+ 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 TestGetCellUnmarshalFailureDeprecated(t *testing.T) {
+ name := "name"
+ var pci uint32
+ w, sdlInstanceMock := initSdlInstanceMock()
+ var e error
+ ret := make(map[string]interface{}, 1)
+ key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
+ if rNibErr != nil {
+ t.Errorf("#rNibReader_test.TestGetCellUnmarshalFailure - failed to validate key parameter")
+ }
+ ret[key] = "data"
+ sdlInstanceMock.On("Get", []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.Contains(t, er.Error(), "proto:")
+}
+
+func TestGetCellSdlgoFailureDeprecated(t *testing.T) {
+ name := "name"
+ var pci uint32
+ errMsg := "expected Sdlgo error"
+ errMsgExpected := "expected Sdlgo error"
+ w, sdlInstanceMock := initSdlInstanceMock()
+ 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)
+ cell, er := w.GetCell(name, pci)
+ assert.NotNil(t, er)
+ assert.Nil(t, cell)
+ assert.IsType(t, &common.InternalError{}, er)
+ assert.EqualValues(t, errMsgExpected, er.Error())
+}
+
+func TestGetNodebByIdDeprecated(t *testing.T) {
+ w, sdlInstanceMock := initSdlInstanceMock()
+ nb := entities.NodebInfo{NodeType: entities.Node_ENB}
+ 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.TestGetNodebById - Failed to marshal ENB instance. Error: %v", err)
+ }
+
+ plmnId := "02f829"
+ nbId := "4a952a0a"
+ 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)
+ }
+ ret := map[string]interface{}{key: string(data)}
+ sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
+ globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
+ getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
+ assert.Nil(t, er)
+ assert.Equal(t, getNb.Ip, nb.Ip)
+ assert.Equal(t, getNb.Port, nb.Port)
+ assert.Equal(t, getNb.ConnectionStatus, nb.ConnectionStatus)
+ assert.Len(t, getNb.GetEnb().GetServedCells(), 1)
+ assert.Equal(t, getNb.GetEnb().GetServedCells()[0].Tac, nb.GetEnb().GetServedCells()[0].Tac)
+}
+
+func TestGetNodebByIdNotFoundFailureEnbDeprecated(t *testing.T) {
+ plmnId := "02f829"
+ nbId := "4a952a0a"
+ w, sdlInstanceMock := initSdlInstanceMock()
+ 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)
+ 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.ResourceNotFoundError{}, er)
+ assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.NodebInfo not found. Key: ENB:02f829:4a952a0a", er.Error())
+}
+
+func TestGetNodebByIdNotFoundFailureGnbDeprecated(t *testing.T) {
+ plmnId := "02f829"
+ nbId := "4a952a0a"
+ w, sdlInstanceMock := initSdlInstanceMock()
+ 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)
+ globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
+ getNb, er := w.GetNodebByGlobalNbId(entities.Node_GNB, globalNbId)
+ assert.NotNil(t, er)
+ assert.Nil(t, getNb)
+ 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 TestGetNodeByIdUnmarshalFailureDeprecated(t *testing.T) {
+ plmnId := "02f829"
+ nbId := "4a952a0a"
+ w, sdlInstanceMock := initSdlInstanceMock()
+ 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)
+ 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.Contains(t, er.Error(), "proto:")
+}
+
+func TestGetNodeByIdSdlgoFailureDeprecated(t *testing.T) {
+ plmnId := "02f829"
+ nbId := "4a952a0a"
+ errMsg := "expected Sdlgo error"
+ errMsgExpected := "expected Sdlgo error"
+ w, sdlInstanceMock := initSdlInstanceMock()
+ 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)
+ globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
+ getNb, er := w.GetNodebByGlobalNbId(entities.Node_GNB, globalNbId)
+ assert.NotNil(t, er)
+ assert.Nil(t, getNb)
+ assert.IsType(t, &common.InternalError{}, er)
+ assert.EqualValues(t, errMsgExpected, er.Error())
+}
+
+func TestGetCellByIdDeprecated(t *testing.T) {
+ cellId := "aaaa"
+ var pci uint32 = 10
+ w, sdlInstanceMock := initSdlInstanceMock()
+ 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 marshal Cell entity. Error: %v", err)
+ }
+ var e error
+ key, rNibErr := common.ValidateAndBuildCellIdKey(cellId)
+ if rNibErr != 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)
+ cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
+ assert.Nil(t, er)
+ assert.NotNil(t, cell)
+ assert.Equal(t, cell.Type, entities.Cell_LTE_CELL)
+ assert.NotNil(t, cell.GetServedCellInfo())
+ assert.Equal(t, cell.GetServedCellInfo().GetPci(), pci)
+}
+
+func TestGetCellByIdNotFoundFailureEnbDeprecated(t *testing.T) {
+ cellId := "bbbb"
+ w, sdlInstanceMock := initSdlInstanceMock()
+ 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)
+ cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
+ assert.NotNil(t, er)
+ assert.Nil(t, cell)
+ assert.IsType(t, &common.ResourceNotFoundError{}, er)
+ assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.Cell not found. Key: CELL:bbbb", er.Error())
+}
+
+func TestGetCellByIdNotFoundFailureGnbDeprecated(t *testing.T) {
+ cellId := "bbbb"
+ w, sdlInstanceMock := initSdlInstanceMock()
+ 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)
+ cell, er := w.GetCellById(entities.Cell_NR_CELL, cellId)
+ assert.NotNil(t, er)
+ assert.Nil(t, cell)
+ assert.IsType(t, &common.ResourceNotFoundError{}, er)
+ assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.Cell not found. Key: NRCELL:bbbb", er.Error())
+}
+
+func TestGetCellByIdTypeValidationFailureDeprecated(t *testing.T) {
+ cellId := "dddd"
+ w, _ := initSdlInstanceMock()
+ cell, er := w.GetCellById(5, cellId)
+ assert.NotNil(t, er)
+ assert.Nil(t, cell)
+ assert.IsType(t, &common.ValidationError{}, er)
+ assert.EqualValues(t, "#rNibReader.GetCellById - invalid cell type: 5", er.Error())
+}
+
+func TestGetCellByIdValidationFailureGnbDeprecated(t *testing.T) {
+ cellId := ""
+ w, _ := initSdlInstanceMock()
+ cell, er := w.GetCellById(entities.Cell_NR_CELL, cellId)
+ assert.NotNil(t, er)
+ assert.Nil(t, cell)
+ assert.IsType(t, &common.ValidationError{}, er)
+ assert.EqualValues(t, "#utils.ValidateAndBuildNrCellIdKey - an empty cell id received", er.Error())
+}
+
+func TestGetCellByIdValidationFailureEnbDeprecated(t *testing.T) {
+ cellId := ""
+ w, _ := initSdlInstanceMock()
+ cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
+ assert.NotNil(t, er)
+ assert.Nil(t, cell)
+ assert.IsType(t, &common.ValidationError{}, er)
+ assert.EqualValues(t, "#utils.ValidateAndBuildCellIdKey - an empty cell id received", er.Error())
+}
+
+func TestGetRanLoadInformationDeprecated(t *testing.T) {
+ name := "name"
+ w, sdlInstanceMock := initSdlInstanceMock()
+ loadInfo := generateRanLoadInformationDeprecated()
+ 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 TestGetRanLoadInformationValidationFailureDeprecated(t *testing.T) {
+ name := ""
+ w, _ := initSdlInstanceMock()
+ 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 TestGetRanLoadInformationNotFoundFailureDeprecated(t *testing.T) {
+ name := "name"
+ w, sdlInstanceMock := initSdlInstanceMock()
+ 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 TestGetRanLoadInformationUnmarshalFailureDeprecated(t *testing.T) {
+ name := "name"
+ w, sdlInstanceMock := initSdlInstanceMock()
+ 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.Contains(t, er.Error(), "proto:")
+}
+
+func TestGetRanLoadInformationSdlgoFailureDeprecated(t *testing.T) {
+ name := "name"
+ errMsg := "expected Sdlgo error"
+ errMsgExpected := "expected Sdlgo error"
+ w, sdlInstanceMock := initSdlInstanceMock()
+ 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 generateCellLoadInformationDeprecated() *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 generateRanLoadInformationDeprecated() *entities.RanLoadInformation {
+ ranLoadInformation := entities.RanLoadInformation{}
+
+ ranLoadInformation.LoadTimestamp = uint64(time.Now().UnixNano())
+
+ cellLoadInformation := generateCellLoadInformationDeprecated()
+ ranLoadInformation.CellLoadInfos = []*entities.CellLoadInformation{cellLoadInformation}
+
+ return &ranLoadInformation
+}
+
+func TestGetE2TInstanceSuccessDeprecated(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 := initSdlInstanceMock()
+
+ e2tInstance := generateE2tInstanceDeprecated(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", []string{redisKey}).Return(ret, e)
+
+ res, rNibErr := w.GetE2TInstance(address)
+ assert.Nil(t, rNibErr)
+ assert.Equal(t, e2tInstance, res)
+}
+
+func TestUnmarshalDeprecated(t *testing.T) {
+ e2tInstance := generateE2tInstanceDeprecated("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 TestGetE2TInstanceEmptyAddressFailureDeprecated(t *testing.T) {
+ w, _ := initSdlInstanceMock()
+ res, err := w.GetE2TInstance("")
+ assert.NotNil(t, err)
+ assert.IsType(t, &common.ValidationError{}, err)
+ assert.Nil(t, res)
+}
+
+func TestGetE2TInstanceSdlErrorDeprecated(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 := initSdlInstanceMock()
+
+ expectedErr := errors.New("expected error")
+ var ret map[string]interface{}
+ sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, expectedErr)
+
+ res, rNibErr := w.GetE2TInstance(address)
+ assert.NotNil(t, rNibErr)
+ assert.Nil(t, res)
+}
+
+func generateE2tInstanceDeprecated(address string) *entities.E2TInstance {
+ e2tInstance := entities.NewE2TInstance(address, "")
+ e2tInstance.AssociatedRanList = []string{"test1", "test2"}
+ e2tInstance.DeletionTimestamp = time.Now().UnixNano()
+ return e2tInstance
+}
+
+func TestGetE2TAddressesSdlErrorDeprecated(t *testing.T) {
+ w, sdlInstanceMock := initSdlInstanceMock()
+
+ expectedErr := errors.New("expected error")
+ var ret map[string]interface{}
+ sdlInstanceMock.On("Get", []string{E2TAddressesKey}).Return(ret, expectedErr)
+
+ res, rNibErr := w.GetE2TAddresses()
+ assert.NotNil(t, rNibErr)
+ assert.Nil(t, res)
+}
+
+func TestGetE2TAddressesSuccessDeprecated(t *testing.T) {
+ address := "10.10.2.15:9800"
+ w, sdlInstanceMock := initSdlInstanceMock()
+
+ 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", []string{E2TAddressesKey}).Return(ret, e)
+
+ res, rNibErr := w.GetE2TAddresses()
+ assert.Nil(t, rNibErr)
+ assert.Equal(t, e2tAddresses, res)
+}
+
+func TestGetE2TInstancesSuccessDeprecated(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 := initSdlInstanceMock()
+
+ e2tInstance1 := generateE2tInstanceDeprecated(address)
+ e2tInstance2 := generateE2tInstanceDeprecated(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", []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 TestGetE2TInstancesUnmarhalPartialSuccessDeprecated(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 := initSdlInstanceMock()
+
+ e2tInstance1 := generateE2tInstanceDeprecated(address)
+ data1, _ := json.Marshal(e2tInstance1)
+
+ var e error
+ ret := map[string]interface{}{redisKey: string(data1), redisKey2: "abc"}
+ sdlInstanceMock.On("Get", []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 TestGetE2TInstancesSdlFailureDeprecated(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 := initSdlInstanceMock()
+
+ sdlInstanceMock.On("Get", []string{redisKey, redisKey2}).Return(map[string]interface{}{}, fmt.Errorf(""))
+ _, err := w.GetE2TInstances([]string{address, address2})
+ assert.IsType(t, &common.InternalError{}, err)
+}
+
+func TestGetE2TInstancesEmptyDataDeprecated(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 := initSdlInstanceMock()
+
+ sdlInstanceMock.On("Get", []string{redisKey, redisKey2}).Return(map[string]interface{}{}, nil)
+ _, err := w.GetE2TInstances([]string{address, address2})
+ assert.IsType(t, &common.ResourceNotFoundError{}, err)
+}
+
+func TestGetGeneralConfigurationDeprecated(t *testing.T) {
+
+ key := common.BuildGeneralConfigurationKey()
+ w, sdlInstanceMock := initSdlInstanceMock()
+
+ configurationData := "{\"enableRic\":true}"
+ sdlInstanceMock.On("Get", []string{key}).Return(map[string]interface{}{key: configurationData}, nil)
+
+ res, rNibErr := w.GetGeneralConfiguration()
+ assert.Nil(t, rNibErr)
+ assert.Equal(t, true, res.EnableRic)
+}
+
+func TestGetGeneralConfigurationNotFoundDeprecated(t *testing.T) {
+
+ key := common.BuildGeneralConfigurationKey()
+ w, sdlInstanceMock := initSdlInstanceMock()
+
+ sdlInstanceMock.On("Get", []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 TestGetGeneralConfigurationSdlFailureDeprecated(t *testing.T) {
+
+ key := common.BuildGeneralConfigurationKey()
+ w, sdlInstanceMock := initSdlInstanceMock()
+
+ sdlInstanceMock.On("Get", []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 TestGetGeneralConfigurationUnmarshalErrorDeprecated(t *testing.T) {
+
+ key := common.BuildGeneralConfigurationKey()
+ w, sdlInstanceMock := initSdlInstanceMock()
+
+ configurationData := "{\"enableRic :true}"
+ sdlInstanceMock.On("Get", []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")
+}
+
+//integration tests
+//
+//func TestGetEnbIntegDeprecated(t *testing.T){
+// name := "nameEnb1"
+// Init("namespace", 1)
+// w := GetRNibReader()
+// nb, err := w.GetNodeb(name)
+// if err != nil{
+// fmt.Println(err)
+// } else {
+// fmt.Printf("#TestGetEnbInteg - responding node type: %v\n", nb)
+// }
+//}
+//
+//func TestGetEnbCellsIntegDeprecated(t *testing.T){
+// name := "nameEnb1"
+// Init("namespace", 1)
+// w := GetRNibReader()
+// cells, err := w.GetCellList(name)
+// if err != nil{
+// fmt.Println(err)
+// } else if cells != nil{
+// for _, cell := range cells.GetServedCellInfos().ServedCells{
+// fmt.Printf("responding node type Cell: %v\n", *cell)
+// }
+// }
+//}
+//
+//func TestGetGnbIntegDeprecated(t *testing.T){
+// name := "nameGnb1"
+// Init("namespace", 1)
+// w := GetRNibReader()
+// nb, err := w.GetNodeb(name)
+// if err != nil{
+// fmt.Println(err)
+// } else {
+// fmt.Printf("#TestGetGnbInteg - responding node type: %v\n", nb)
+// }
+//}
+//
+//func TestGetGnbCellsIntegDeprecated(t *testing.T){
+// name := "nameGnb1"
+// Init("namespace", 1)
+// w := GetRNibReader()
+// cells, err := w.GetCellList(name)
+// if err != nil{
+// fmt.Println(err)
+// } else if cells != nil{
+// for _, cell := range cells.GetServedNrCells().ServedCells{
+// fmt.Printf("responding node type NR Cell: %v\n", *cell)
+// }
+// }
+//}
+//
+//func TestGetListEnbIdsIntegDeprecated(t *testing.T) {
+// Init("namespace", 1)
+// w := GetRNibReader()
+// ids, err := w.GetListEnbIds()
+// if err != nil{
+// fmt.Println(err)
+// } else {
+// for _, id := range ids{
+// fmt.Printf("#TestGetListEnbIdsInteg - ENB ID: %s\n", id)
+// }
+// }
+//}
+//
+//func TestGetListGnbIdsIntegDeprecated(t *testing.T) {
+// Init("namespace", 1)
+// w := GetRNibReader()
+// ids, err := w.GetListGnbIds()
+// if err != nil{
+// fmt.Println(err)
+// } else {
+// for _, id := range ids{
+// fmt.Printf("#TestGetListGnbIdsInteg - GNB ID: %s\n", id)
+// }
+// }
+//}
+//
+//func TestGetCountGnbListIntegDeprecated(t *testing.T) {
+// Init("namespace", 1)
+// w := GetRNibReader()
+// count, err := w.GetCountGnbList()
+// if err != nil{
+// fmt.Println(err)
+// } else {
+// fmt.Printf("#TestGetCountGnbListInteg - count Gnb list: %d\n", count)
+// }
+//}
+//
+//func TestGetGnbCellIntegDeprecated(t *testing.T){
+// name := "nameGnb7"
+// pci := 0x0a
+// Init("namespace", 1)
+// w := GetRNibReader()
+// cell, err := w.GetCell(name, uint32(pci))
+// if err != nil{
+// fmt.Println(err)
+// } else if cell != nil{
+// fmt.Printf("responding node type NR Cell: %v\n", cell.GetServedNrCell())
+// }
+//}
+//
+//func TestGetEnbCellIntegDeprecated(t *testing.T) {
+// name := "nameEnb1"
+// pci := 0x22
+// Init("namespace", 1)
+// w := GetRNibReader()
+// cell, err := w.GetCell(name, uint32(pci))
+// if err != nil {
+// fmt.Println(err)
+// } else if cell != nil {
+// fmt.Printf("responding node type LTE Cell: %v\n", cell.GetServedCellInfo())
+// }
+//}
+//
+//func TestGetEnbCellByIdIntegDeprecated(t *testing.T){
+// Init("namespace", 1)
+// w := GetRNibReader()
+// cell, err := w.GetCellById(entities.Cell_NR_CELL, "45d")
+// if err != nil{
+// fmt.Println(err)
+// } else if cell != nil{
+// fmt.Printf("responding node type NR Cell: %v\n", cell.GetServedNrCell())
+// }
+//}
+//
+//func TestGetListNbIdsIntegDeprecated(t *testing.T) {
+// Init("e2Manager", 1)
+// w := GetRNibReader()
+// ids, err := w.GetListNodebIds()
+// if err != nil{
+// fmt.Println(err)
+// } else {
+// for _, id := range ids{
+// fmt.Printf("#TestGetListGnbIdsInteg - NB ID: %s\n", id)
+// }
+// }
+//}
+//
+//func TestGetRanLoadInformationIntegDeprecated(t *testing.T){
+// Init("e2Manager", 1)
+// w := GetRNibReader()
+// 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)
+//}
+
+//func TestGetE2TInstancesIntegDeprecated(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)
+//}
"time"
)
-func initSdlInstanceMock() (w RNibReader, sdlInstanceMock *MockSdlInstance) {
- sdlInstanceMock = new(MockSdlInstance)
- w = GetRNibReader(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"
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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"
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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"
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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)
name := "name"
errMsg := "expected Sdlgo error"
errMsgExpected := "expected Sdlgo error"
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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"
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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"
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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"
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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)
func TestGetNodeBCellsListNodeNotFoundFailure(t *testing.T) {
name := "name"
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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"
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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"
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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 TestGetListGnbIdsUnmarshalFailure(t *testing.T) {
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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)
func TestGetListGnbIdsSdlgoFailure(t *testing.T) {
errMsg := "expected Sdlgo error"
errMsgExpected := "expected Sdlgo error"
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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) {
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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) {
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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) {
- w, sdlInstanceMock := initSdlInstanceMock()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
var nilError error
name := "name"
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", 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)
}
func TestGetListEnbIdsUnmarshalFailure(t *testing.T) {
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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)
name := "name"
plmnId := "02f829"
nbId := "4a952a0a"
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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) {
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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
- w, sdlInstanceMock := initSdlInstanceMock()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
idsData := make([]string, listSize)
idsEntities := make([]*entities.NbIdentity, listSize)
for i := 0; i < listSize; i++ {
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"
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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) {
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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
- w, sdlInstanceMock := initSdlInstanceMock()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
idsData := make([]string, listSize)
idsEntities := make([]*entities.NbIdentity, listSize)
for i := 0; i < listSize; i++ {
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"
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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) {
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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) {
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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"
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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)
var pci uint32
errMsg := "expected Sdlgo error"
errMsgExpected := "expected Sdlgo error"
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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) {
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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"
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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"
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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"
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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)
nbId := "4a952a0a"
errMsg := "expected Sdlgo error"
errMsgExpected := "expected Sdlgo error"
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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"
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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"
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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"
- w, _ := initSdlInstanceMock()
+ w, _ := initSdlSyncStorageMock()
cell, er := w.GetCellById(5, cellId)
assert.NotNil(t, er)
assert.Nil(t, cell)
func TestGetCellByIdValidationFailureGnb(t *testing.T) {
cellId := ""
- w, _ := initSdlInstanceMock()
+ 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 := ""
- w, _ := initSdlInstanceMock()
+ 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"
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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 := ""
- w, _ := initSdlInstanceMock()
+ w, _ := initSdlSyncStorageMock()
getNb, er := w.GetRanLoadInformation(name)
assert.NotNil(t, er)
assert.Nil(t, getNb)
func TestGetRanLoadInformationNotFoundFailure(t *testing.T) {
name := "name"
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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"
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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)
name := "name"
errMsg := "expected Sdlgo error"
errMsgExpected := "expected Sdlgo error"
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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)
t.Errorf("#rNibReader_test.TestGetE2TInstanceSuccess - Failed to build E2T Instance key. Error: %v", validationErr)
}
- w, sdlInstanceMock := initSdlInstanceMock()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
e2tInstance := generateE2tInstance(address)
data, err := json.Marshal(e2tInstance)
var e error
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)
res, rNibErr := w.GetE2TInstance(address)
assert.Nil(t, rNibErr)
}
func TestGetE2TInstanceEmptyAddressFailure(t *testing.T) {
- w, _ := initSdlInstanceMock()
+ w, _ := initSdlSyncStorageMock()
res, err := w.GetE2TInstance("")
assert.NotNil(t, err)
assert.IsType(t, &common.ValidationError{}, err)
t.Errorf("#rNibReader_test.TestGetE2TInstanceSuccess - Failed to build E2T Instance key. Error: %v", validationErr)
}
- w, sdlInstanceMock := initSdlInstanceMock()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
expectedErr := errors.New("expected error")
var ret map[string]interface{}
- sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, expectedErr)
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, expectedErr)
res, rNibErr := w.GetE2TInstance(address)
assert.NotNil(t, rNibErr)
}
func TestGetE2TAddressesSdlError(t *testing.T) {
- w, sdlInstanceMock := initSdlInstanceMock()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
expectedErr := errors.New("expected error")
var ret map[string]interface{}
- sdlInstanceMock.On("Get", []string{E2TAddressesKey}).Return(ret, expectedErr)
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{E2TAddressesKey}).Return(ret, expectedErr)
res, rNibErr := w.GetE2TAddresses()
assert.NotNil(t, rNibErr)
func TestGetE2TAddressesSuccess(t *testing.T) {
address := "10.10.2.15:9800"
- w, sdlInstanceMock := initSdlInstanceMock()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
e2tAddresses := []string{address}
data, err := json.Marshal(e2tAddresses)
var e error
ret := map[string]interface{}{E2TAddressesKey: string(data)}
- sdlInstanceMock.On("Get", []string{E2TAddressesKey}).Return(ret, e)
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{E2TAddressesKey}).Return(ret, e)
res, rNibErr := w.GetE2TAddresses()
assert.Nil(t, rNibErr)
redisKey, _ := common.ValidateAndBuildE2TInstanceKey(address)
redisKey2, _ := common.ValidateAndBuildE2TInstanceKey(address2)
- w, sdlInstanceMock := initSdlInstanceMock()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
e2tInstance1 := generateE2tInstance(address)
e2tInstance2 := generateE2tInstance(address2)
var e error
ret := map[string]interface{}{redisKey: string(data1), redisKey2: string(data2)}
- sdlInstanceMock.On("Get", []string{redisKey, redisKey2}).Return(ret, e)
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey, redisKey2}).Return(ret, e)
res, err := w.GetE2TInstances([]string{address, address2})
assert.Nil(t, err)
redisKey, _ := common.ValidateAndBuildE2TInstanceKey(address)
redisKey2, _ := common.ValidateAndBuildE2TInstanceKey(address2)
- w, sdlInstanceMock := initSdlInstanceMock()
+ 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", []string{redisKey, redisKey2}).Return(ret, e)
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey, redisKey2}).Return(ret, e)
res, err := w.GetE2TInstances([]string{address, address2})
assert.Nil(t, err)
redisKey, _ := common.ValidateAndBuildE2TInstanceKey(address)
redisKey2, _ := common.ValidateAndBuildE2TInstanceKey(address2)
- w, sdlInstanceMock := initSdlInstanceMock()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
- sdlInstanceMock.On("Get", []string{redisKey, redisKey2}).Return(map[string]interface{}{}, fmt.Errorf(""))
+ 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)
}
redisKey, _ := common.ValidateAndBuildE2TInstanceKey(address)
redisKey2, _ := common.ValidateAndBuildE2TInstanceKey(address2)
- w, sdlInstanceMock := initSdlInstanceMock()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
- sdlInstanceMock.On("Get", []string{redisKey, redisKey2}).Return(map[string]interface{}{}, nil)
+ 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 := initSdlInstanceMock()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
configurationData := "{\"enableRic\":true}"
- sdlInstanceMock.On("Get", []string{key}).Return(map[string]interface{}{key: configurationData}, nil)
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(map[string]interface{}{key: configurationData}, nil)
res, rNibErr := w.GetGeneralConfiguration()
assert.Nil(t, rNibErr)
func TestGetGeneralConfigurationNotFound(t *testing.T) {
key := common.BuildGeneralConfigurationKey()
- w, sdlInstanceMock := initSdlInstanceMock()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
- sdlInstanceMock.On("Get", []string{key}).Return(map[string]interface{}{}, nil)
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(map[string]interface{}{}, nil)
_, rNibErr := w.GetGeneralConfiguration()
func TestGetGeneralConfigurationSdlFailure(t *testing.T) {
key := common.BuildGeneralConfigurationKey()
- w, sdlInstanceMock := initSdlInstanceMock()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
- sdlInstanceMock.On("Get", []string{key}).Return(map[string]interface{}{}, fmt.Errorf("sdl error"))
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(map[string]interface{}{}, fmt.Errorf("sdl error"))
_, rNibErr := w.GetGeneralConfiguration()
func TestGetGeneralConfigurationUnmarshalError(t *testing.T) {
key := common.BuildGeneralConfigurationKey()
- w, sdlInstanceMock := initSdlInstanceMock()
+ w, sdlInstanceMock := initSdlSyncStorageMock()
configurationData := "{\"enableRic :true}"
- sdlInstanceMock.On("Get", []string{key}).Return(map[string]interface{}{key: configurationData}, nil)
+ sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(map[string]interface{}{key: configurationData}, nil)
_, rNibErr := w.GetGeneralConfiguration()
// rnibReader := GetRNibReader(sdl)
// e2tInstances, _ := rnibReader.GetE2TInstances([]string{"e2t.att.com:38000","whatever"})
// assert.Len(t, e2tInstances, 1)
-//}
\ No newline at end of file
+//}
import "github.com/stretchr/testify/mock"
+//Deprecated: Will be removed in a future release, please use MockSdlSyncStorage instead.
type MockSdlInstance struct {
mock.Mock
}
+//Deprecated: Will be removed in a future release, please use instead the SubscribeChannel
+//receiver function of the MockSdlSyncStorage type.
func (m *MockSdlInstance) SubscribeChannel(cb func(string, ...string), channels ...string) error {
a := m.Called(cb, channels)
return a.Error(0)
}
+//Deprecated: Will be removed in a future release, please use instead the UnsubscribeChannel
+//receiver function of the MockSdlSyncStorage type.
func (m *MockSdlInstance) UnsubscribeChannel(channels ...string) error {
a := m.Called(channels)
return a.Error(0)
}
+//Deprecated: Will be removed in a future release, please use instead the SetAndPublish
+//receiver function of the MockSdlSyncStorage type.
func (m *MockSdlInstance) SetAndPublish(channelsAndEvents []string, pairs ...interface{}) error {
a := m.Called(channelsAndEvents, pairs)
return a.Error(0)
}
+//Deprecated: Will be removed in a future release, please use instead the SetIfAndPublish
+//receiver function of the MockSdlSyncStorage type.
func (m *MockSdlInstance) SetIfAndPublish(channelsAndEvents []string, key string, oldData, newData interface{}) (bool, error) {
a := m.Called(channelsAndEvents, key, oldData, newData)
return a.Bool(0), a.Error(1)
}
+//Deprecated: Will be removed in a future release, please use instead the SetIfNotExistsAndPublish
+//receiver function of the MockSdlSyncStorage type.
func (m *MockSdlInstance) SetIfNotExistsAndPublish(channelsAndEvents []string, key string, data interface{}) (bool, error) {
a := m.Called(channelsAndEvents, key, data)
return a.Bool(0), a.Error(1)
}
+//Deprecated: Will be removed in a future release, please use instead the RemoveAndPublish
+//receiver function of the MockSdlSyncStorage type.
func (m *MockSdlInstance) RemoveAndPublish(channelsAndEvents []string, keys []string) error {
a := m.Called(channelsAndEvents, keys)
return a.Error(0)
}
+//Deprecated: Will be removed in a future release, please use instead the RemoveIfAndPublish
+//receiver function of the MockSdlSyncStorage type.
func (m *MockSdlInstance) RemoveIfAndPublish(channelsAndEvents []string, key string, data interface{}) (bool, error) {
a := m.Called(channelsAndEvents, key, data)
return a.Bool(0), a.Error(1)
}
+//Deprecated: Will be removed in a future release, please use instead the RemoveAllAndPublish
+//receiver function of the MockSdlSyncStorage type.
func (m *MockSdlInstance) RemoveAllAndPublish(channelsAndEvents []string) error {
a := m.Called(channelsAndEvents)
return a.Error(0)
}
+//Deprecated: Will be removed in a future release, please use instead the Set
+//receiver function of the MockSdlSyncStorage type.
func (m *MockSdlInstance) Set(pairs ...interface{}) error {
a := m.Called(pairs)
return a.Error(0)
}
+//Deprecated: Will be removed in a future release, please use instead the Get
+//receiver function of the MockSdlSyncStorage type.
func (m *MockSdlInstance) Get(keys []string) (map[string]interface{}, error) {
a := m.Called(keys)
return a.Get(0).(map[string]interface{}), a.Error(1)
}
+//Deprecated: Will be removed in a future release, please use instead the GetAll
+//receiver function of the MockSdlSyncStorage type.
func (m *MockSdlInstance) GetAll() ([]string, error) {
a := m.Called()
return a.Get(0).([]string), a.Error(1)
}
+//Deprecated: Will be removed in a future release, please use instead the Close
+//receiver function of the MockSdlSyncStorage type.
func (m *MockSdlInstance) Close() error {
a := m.Called()
return a.Error(0)
}
+//Deprecated: Will be removed in a future release, please use instead the Remove
+//receiver function of the MockSdlSyncStorage type.
func (m *MockSdlInstance) Remove(keys []string) error {
a := m.Called(keys)
return a.Error(0)
}
+//Deprecated: Will be removed in a future release, please use instead the RemoveAll
+//receiver function of the MockSdlSyncStorage type.
func (m *MockSdlInstance) RemoveAll() error {
a := m.Called()
return a.Error(0)
}
+//Deprecated: Will be removed in a future release, please use instead the SetIf
+//receiver function of the MockSdlSyncStorage type.
func (m *MockSdlInstance) SetIf(key string, oldData, newData interface{}) (bool, error) {
a := m.Called(key, oldData, newData)
return a.Bool(0), a.Error(1)
}
+//Deprecated: Will be removed in a future release, please use instead the SetIfNotExists
+//receiver function of the MockSdlSyncStorage type.
func (m *MockSdlInstance) SetIfNotExists(key string, data interface{}) (bool, error) {
a := m.Called(key, data)
return a.Bool(0), a.Error(1)
}
+
+//Deprecated: Will be removed in a future release, please use instead the RemoveIf
+//receiver function of the MockSdlSyncStorage type.
func (m *MockSdlInstance) RemoveIf(key string, data interface{}) (bool, error) {
a := m.Called(key, data)
return a.Bool(0), a.Error(1)
}
+//Deprecated: Will be removed in a future release, please use instead the AddMember
+//receiver function of the MockSdlSyncStorage type.
func (m *MockSdlInstance) AddMember(group string, member ...interface{}) error {
a := m.Called(group, member)
return a.Error(0)
}
+//Deprecated: Will be removed in a future release, please use instead the RemoveMember
+//receiver function of the MockSdlSyncStorage type.
func (m *MockSdlInstance) RemoveMember(group string, member ...interface{}) error {
a := m.Called(group, member)
return a.Error(0)
}
+
+//Deprecated: Will be removed in a future release, please use instead the RemoveGroup
+//receiver function of the MockSdlSyncStorage type.
func (m *MockSdlInstance) RemoveGroup(group string) error {
a := m.Called(group)
return a.Error(0)
}
+
+//Deprecated: Will be removed in a future release, please use instead the GetMembers
+//receiver function of the MockSdlSyncStorage type.
func (m *MockSdlInstance) GetMembers(group string) ([]string, error) {
a := m.Called(group)
return a.Get(0).([]string), a.Error(1)
}
+
+//Deprecated: Will be removed in a future release, please use instead the IsMember
+//receiver function of the MockSdlSyncStorage type.
func (m *MockSdlInstance) IsMember(group string, member interface{}) (bool, error) {
a := m.Called(group, member)
return a.Bool(0), a.Error(1)
}
+
+//Deprecated: Will be removed in a future release, please use instead the GroupSize
+//receiver function of the MockSdlSyncStorage type.
func (m *MockSdlInstance) GroupSize(group string) (int64, error) {
a := m.Called(group, )
return int64(a.Int(0)), a.Error(1)
"github.com/stretchr/testify/assert"
)
+//Deprecated: Will be removed in a future release and tests in sdlSyncStorageMock_test.go
+//should be used instead.
func initSdlInstanceMockTest() (sdlInstanceMockTest *MockSdlInstance) {
sdlInstanceMockTest = new(MockSdlInstance)
return
}
+//Deprecated: Will be removed in a future release and tests in sdlSyncStorageMock_test.go
+//should be used instead.
func TestRemoveAll(t *testing.T){
sdlInstanceMockTest := initSdlInstanceMockTest()
sdlInstanceMockTest.On("RemoveAll").Return(nil)
assert.Nil(t, err)
}
+//Deprecated: Will be removed in a future release and tests in sdlSyncStorageMock_test.go
+//should be used instead.
func TestRemove(t *testing.T){
var data []string
sdlInstanceMockTest := initSdlInstanceMockTest()
}
+//Deprecated: Will be removed in a future release and tests in sdlSyncStorageMock_test.go
+//should be used instead.
func TestRemoveIf(t *testing.T){
var data map[string]interface{}
key := "key"
}
+//Deprecated: Will be removed in a future release and tests in sdlSyncStorageMock_test.go
+//should be used instead.
func TestRemoveGroup(t *testing.T){
group := "group"
sdlInstanceMockTest := initSdlInstanceMockTest()
}
+//Deprecated: Will be removed in a future release and tests in sdlSyncStorageMock_test.go
+//should be used instead.
func TestRemoveIfAndPublish(t *testing.T){
var data map[string]interface{}
var channelsAndEvents []string
}
+//Deprecated: Will be removed in a future release and tests in sdlSyncStorageMock_test.go
+//should be used instead.
func TestRemoveAndPublish(t *testing.T){
var channelsAndEvents []string
var keys []string
assert.Nil(t, err)
}
+//Deprecated: Will be removed in a future release and tests in sdlSyncStorageMock_test.go
+//should be used instead.
func TestRemoveAllAndPublish(t *testing.T){
var channelsAndEvents []string
sdlInstanceMockTest := initSdlInstanceMockTest()
assert.Nil(t, err)
}
+//Deprecated: Will be removed in a future release and tests in sdlSyncStorageMock_test.go
+//should be used instead.
func TestIsMember(t *testing.T){
var ret map[string]interface{}
sdlInstanceMockTest := initSdlInstanceMockTest()
assert.NotNil(t, res)
}
+//Deprecated: Will be removed in a future release and tests in sdlSyncStorageMock_test.go
+//should be used instead.
func TestClose(t *testing.T){
sdlInstanceMockTest := initSdlInstanceMockTest()
sdlInstanceMockTest.On("Close").Return(nil)
assert.Nil(t, err)
}
+//Deprecated: Will be removed in a future release and tests in sdlSyncStorageMock_test.go
+//should be used instead.
func TestSetIfNotExists(t *testing.T){
var data map[string]interface{}
key := "key"
assert.NotNil(t, res)
}
+//Deprecated: Will be removed in a future release and tests in sdlSyncStorageMock_test.go
+//should be used instead.
func TestAddMember(t *testing.T){
var ret []interface{}
sdlInstanceMockTest := initSdlInstanceMockTest()
assert.Nil(t, err)
}
+//Deprecated: Will be removed in a future release and tests in sdlSyncStorageMock_test.go
+//should be used instead.
func TestRemoveMember(t *testing.T){
var ret []interface{}
sdlInstanceMockTest := initSdlInstanceMockTest()
assert.Nil(t, err)
}
+//Deprecated: Will be removed in a future release and tests in sdlSyncStorageMock_test.go
+//should be used instead.
func TestSetAndPublish(t *testing.T){
var pairs []interface{}
var channelsAndEvents []string
assert.Nil(t, err)
}
+//Deprecated: Will be removed in a future release and tests in sdlSyncStorageMock_test.go
+//should be used instead.
func TestSetIfAndPublish(t *testing.T){
var newData map[string]interface{}
var oldData map[string]interface{}
assert.NotNil(t, res)
}
+//Deprecated: Will be removed in a future release and tests in sdlSyncStorageMock_test.go
+//should be used instead.
func TestSet(t *testing.T){
var pairs []interface{}
sdlInstanceMockTest := initSdlInstanceMockTest()
assert.Nil(t, err)
}
+//Deprecated: Will be removed in a future release and tests in sdlSyncStorageMock_test.go
+//should be used instead.
func TestSetIf(t *testing.T){
var newData map[string]interface{}
var oldData map[string]interface{}
assert.NotNil(t, res)
}
+//Deprecated: Will be removed in a future release and tests in sdlSyncStorageMock_test.go
+//should be used instead.
func TestGetAll(t *testing.T){
var data []string
sdlInstanceMockTest := initSdlInstanceMockTest()
assert.Nil(t, res)
}
+//Deprecated: Will be removed in a future release and tests in sdlSyncStorageMock_test.go
+//should be used instead.
func TestSetIfNotExistsAndPublish(t *testing.T){
var data map[string]interface{}
var channelsAndEvents []string
assert.Nil(t, err)
assert.NotNil(t, res)
}
-
--- /dev/null
+//
+// Copyright 2021 AT&T Intellectual Property
+// Copyright 2021 Nokia
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This source code is part of the near-RT RIC (RAN Intelligent Controller)
+// platform project (RICP).
+
+package reader
+
+import "github.com/stretchr/testify/mock"
+
+type MockSdlSyncStorage struct {
+ mock.Mock
+}
+
+func (m *MockSdlSyncStorage) SubscribeChannel(ns string, cb func(string, ...string), channels ...string) error {
+ a := m.Called(ns, cb, channels)
+ return a.Error(0)
+}
+
+func (m *MockSdlSyncStorage) UnsubscribeChannel(ns string, channels ...string) error {
+ a := m.Called(ns, channels)
+ return a.Error(0)
+}
+
+func (m *MockSdlSyncStorage) SetAndPublish(ns string, channelsAndEvents []string, pairs ...interface{}) error {
+ a := m.Called(ns, channelsAndEvents, pairs)
+ return a.Error(0)
+}
+
+func (m *MockSdlSyncStorage) SetIfAndPublish(ns string, channelsAndEvents []string, key string, oldData, newData interface{}) (bool, error) {
+ a := m.Called(ns, channelsAndEvents, key, oldData, newData)
+ return a.Bool(0), a.Error(1)
+}
+
+func (m *MockSdlSyncStorage) SetIfNotExistsAndPublish(ns string, channelsAndEvents []string, key string, data interface{}) (bool, error) {
+ a := m.Called(ns, channelsAndEvents, key, data)
+ return a.Bool(0), a.Error(1)
+}
+
+func (m *MockSdlSyncStorage) RemoveAndPublish(ns string, channelsAndEvents []string, keys []string) error {
+ a := m.Called(ns, channelsAndEvents, keys)
+ return a.Error(0)
+}
+
+func (m *MockSdlSyncStorage) RemoveIfAndPublish(ns string, channelsAndEvents []string, key string, data interface{}) (bool, error) {
+ a := m.Called(ns, channelsAndEvents, key, data)
+ return a.Bool(0), a.Error(1)
+}
+
+func (m *MockSdlSyncStorage) RemoveAllAndPublish(ns string, channelsAndEvents []string) error {
+ a := m.Called(ns, channelsAndEvents)
+ return a.Error(0)
+}
+
+func (m *MockSdlSyncStorage) Set(ns string, pairs ...interface{}) error {
+ a := m.Called(ns, pairs)
+ return a.Error(0)
+}
+
+func (m *MockSdlSyncStorage) Get(ns string, keys []string) (map[string]interface{}, error) {
+ a := m.Called(ns, keys)
+ return a.Get(0).(map[string]interface{}), a.Error(1)
+}
+
+func (m *MockSdlSyncStorage) GetAll(ns string) ([]string, error) {
+ a := m.Called(ns)
+ return a.Get(0).([]string), a.Error(1)
+}
+
+func (m *MockSdlSyncStorage) Close() error {
+ a := m.Called()
+ return a.Error(0)
+}
+
+func (m *MockSdlSyncStorage) Remove(ns string, keys []string) error {
+ a := m.Called(ns, keys)
+ return a.Error(0)
+}
+
+func (m *MockSdlSyncStorage) RemoveAll(ns string) error {
+ a := m.Called(ns)
+ return a.Error(0)
+}
+
+func (m *MockSdlSyncStorage) SetIf(ns string, key string, oldData, newData interface{}) (bool, error) {
+ a := m.Called(ns, key, oldData, newData)
+ return a.Bool(0), a.Error(1)
+}
+
+func (m *MockSdlSyncStorage) SetIfNotExists(ns string, key string, data interface{}) (bool, error) {
+ a := m.Called(ns, key, data)
+ return a.Bool(0), a.Error(1)
+}
+func (m *MockSdlSyncStorage) RemoveIf(ns string, key string, data interface{}) (bool, error) {
+ a := m.Called(ns, key, data)
+ return a.Bool(0), a.Error(1)
+}
+
+func (m *MockSdlSyncStorage) AddMember(ns string, group string, member ...interface{}) error {
+ a := m.Called(ns, group, member)
+ return a.Error(0)
+}
+
+func (m *MockSdlSyncStorage) RemoveMember(ns string, group string, member ...interface{}) error {
+ a := m.Called(ns, group, member)
+ return a.Error(0)
+}
+func (m *MockSdlSyncStorage) RemoveGroup(ns string, group string) error {
+ a := m.Called(ns, group)
+ return a.Error(0)
+}
+func (m *MockSdlSyncStorage) GetMembers(ns string, group string) ([]string, error) {
+ a := m.Called(ns, group)
+ return a.Get(0).([]string), a.Error(1)
+}
+func (m *MockSdlSyncStorage) IsMember(ns string, group string, member interface{}) (bool, error) {
+ a := m.Called(ns, group, member)
+ return a.Bool(0), a.Error(1)
+}
+func (m *MockSdlSyncStorage) GroupSize(ns string, group string) (int64, error) {
+ a := m.Called(ns, group)
+ return int64(a.Int(0)), a.Error(1)
+}
--- /dev/null
+//
+// Copyright 2021 AT&T Intellectual Property
+// Copyright 2021 Nokia
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This source code is part of the near-RT RIC (RAN Intelligent Controller)
+// platform project (RICP).
+
+package reader
+
+import (
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/mock"
+ "testing"
+)
+
+func initSdlSyncStorageMockTest() (sdlSyncStorageMockTest *MockSdlSyncStorage) {
+ sdlSyncStorageMockTest = new(MockSdlSyncStorage)
+ return
+}
+
+func TestRemoveAllMock(t *testing.T) {
+ ns := "some-ns"
+ sdlSyncStorageMockTest := initSdlSyncStorageMockTest()
+ sdlSyncStorageMockTest.On("RemoveAll", ns).Return(nil)
+ err := sdlSyncStorageMockTest.RemoveAll(ns)
+ assert.Nil(t, err)
+}
+
+func TestRemoveMock(t *testing.T) {
+ var data []string
+ ns := "some-ns"
+ sdlSyncStorageMockTest := initSdlSyncStorageMockTest()
+ sdlSyncStorageMockTest.On("Remove", ns, []string(data)).Return(nil)
+ err := sdlSyncStorageMockTest.Remove(ns, data)
+ assert.Nil(t, err)
+
+}
+
+func TestRemoveIfMock(t *testing.T) {
+ var data map[string]interface{}
+ ns := "some-ns"
+ key := "key"
+ sdlSyncStorageMockTest := initSdlSyncStorageMockTest()
+ sdlSyncStorageMockTest.On("RemoveIf", ns, key, data).Return(true, nil)
+ res, err := sdlSyncStorageMockTest.RemoveIf(ns, key, data)
+ assert.Nil(t, err)
+ assert.NotNil(t, res)
+
+}
+
+func TestRemoveGroupMock(t *testing.T) {
+ ns := "some-ns"
+ group := "group"
+ sdlSyncStorageMockTest := initSdlSyncStorageMockTest()
+ sdlSyncStorageMockTest.On("RemoveGroup", ns, group).Return(nil)
+ err := sdlSyncStorageMockTest.RemoveGroup(ns, group)
+ assert.Nil(t, err)
+
+}
+
+func TestRemoveIfAndPublishMock(t *testing.T) {
+ var data map[string]interface{}
+ var channelsAndEvents []string
+ ns := "some-ns"
+ key := "key"
+ sdlSyncStorageMockTest := initSdlSyncStorageMockTest()
+ sdlSyncStorageMockTest.On("RemoveIfAndPublish", ns, channelsAndEvents, key, data).Return(true, nil)
+ res, err := sdlSyncStorageMockTest.RemoveIfAndPublish(ns, channelsAndEvents, key, data)
+ assert.Nil(t, err)
+ assert.NotNil(t, res)
+
+}
+
+func TestRemoveAndPublishMock(t *testing.T) {
+ var channelsAndEvents []string
+ var keys []string
+ ns := "some-ns"
+
+ sdlSyncStorageMockTest := initSdlSyncStorageMockTest()
+ sdlSyncStorageMockTest.On("RemoveAndPublish", ns, []string(channelsAndEvents), []string(keys)).Return(nil)
+ err := sdlSyncStorageMockTest.RemoveAndPublish(ns, channelsAndEvents, keys)
+ assert.Nil(t, err)
+}
+
+func TestRemoveAllAndPublishMock(t *testing.T) {
+ var channelsAndEvents []string
+ ns := "some-ns"
+ sdlSyncStorageMockTest := initSdlSyncStorageMockTest()
+ sdlSyncStorageMockTest.On("RemoveAllAndPublish", ns, []string(channelsAndEvents)).Return(nil)
+ err := sdlSyncStorageMockTest.RemoveAllAndPublish(ns, channelsAndEvents)
+ assert.Nil(t, err)
+}
+
+func TestIsMemberMock(t *testing.T) {
+ var ret map[string]interface{}
+ ns := "some-ns"
+ sdlSyncStorageMockTest := initSdlSyncStorageMockTest()
+ sdlSyncStorageMockTest.On("IsMember", ns, "group", ret).Return(true, nil)
+ res, err := sdlSyncStorageMockTest.IsMember(ns, "group", ret)
+ assert.Nil(t, err)
+ assert.NotNil(t, res)
+}
+
+func TestCloseMock(t *testing.T) {
+ sdlSyncStorageMockTest := initSdlSyncStorageMockTest()
+ sdlSyncStorageMockTest.On("Close").Return(nil)
+ err := sdlSyncStorageMockTest.Close()
+ assert.Nil(t, err)
+}
+
+func TestSetIfNotExistsMock(t *testing.T) {
+ var data map[string]interface{}
+ ns := "some-ns"
+ key := "key"
+ sdlSyncStorageMockTest := initSdlSyncStorageMockTest()
+ sdlSyncStorageMockTest.On("SetIfNotExists", ns, key, data).Return(true, nil)
+ res, err := sdlSyncStorageMockTest.SetIfNotExists(ns, key, data)
+ assert.Nil(t, err)
+ assert.NotNil(t, res)
+}
+
+func TestAddMemberMock(t *testing.T) {
+ var ret []interface{}
+ ns := "some-ns"
+ sdlSyncStorageMockTest := initSdlSyncStorageMockTest()
+ sdlSyncStorageMockTest.On("AddMember", ns, "group", []interface{}{ret}).Return(nil)
+ err := sdlSyncStorageMockTest.AddMember(ns, "group", ret)
+ assert.Nil(t, err)
+}
+
+func TestRemoveMemberMock(t *testing.T) {
+ var ret []interface{}
+ ns := "some-ns"
+ sdlSyncStorageMockTest := initSdlSyncStorageMockTest()
+ sdlSyncStorageMockTest.On("RemoveMember", ns, "group", []interface{}{ret}).Return(nil)
+ err := sdlSyncStorageMockTest.RemoveMember(ns, "group", ret)
+ assert.Nil(t, err)
+}
+
+func TestSetAndPublishMock(t *testing.T) {
+ var pairs []interface{}
+ var channelsAndEvents []string
+ ns := "some-ns"
+ sdlSyncStorageMockTest := initSdlSyncStorageMockTest()
+ sdlSyncStorageMockTest.On("SetAndPublish", ns, channelsAndEvents, []interface{}{pairs}).Return(nil)
+ err := sdlSyncStorageMockTest.SetAndPublish(ns, channelsAndEvents, pairs)
+ assert.Nil(t, err)
+}
+
+func TestSetIfAndPublishMock(t *testing.T) {
+ var newData map[string]interface{}
+ var oldData map[string]interface{}
+ var group []string
+ ns := "some-ns"
+ sdlSyncStorageMockTest := initSdlSyncStorageMockTest()
+ sdlSyncStorageMockTest.On("SetIfAndPublish", ns, group, "key", oldData, newData).Return(true, nil)
+ res, err := sdlSyncStorageMockTest.SetIfAndPublish(ns, group, "key", oldData, newData)
+ assert.Nil(t, err)
+ assert.NotNil(t, res)
+}
+
+func TestSetMock(t *testing.T) {
+ var pairs []interface{}
+ ns := "some-ns"
+ sdlSyncStorageMockTest := initSdlSyncStorageMockTest()
+ sdlSyncStorageMockTest.On("Set", ns, []interface{}{pairs}).Return(nil)
+ err := sdlSyncStorageMockTest.Set(ns, pairs)
+ assert.Nil(t, err)
+}
+
+func TestSetIfMock(t *testing.T) {
+ var newData map[string]interface{}
+ var oldData map[string]interface{}
+ ns := "some-ns"
+ sdlSyncStorageMockTest := initSdlSyncStorageMockTest()
+ sdlSyncStorageMockTest.On("SetIf", ns, "key", newData, oldData).Return(true, nil)
+ res, err := sdlSyncStorageMockTest.SetIf(ns, "key", newData, oldData)
+ assert.Nil(t, err)
+ assert.NotNil(t, res)
+}
+
+func TestGetAllMock(t *testing.T) {
+ var data []string
+ ns := "some-ns"
+ sdlSyncStorageMockTest := initSdlSyncStorageMockTest()
+ sdlSyncStorageMockTest.On("GetAll", ns).Return(data, nil)
+ res, err := sdlSyncStorageMockTest.GetAll(ns)
+ assert.Nil(t, err)
+ assert.Nil(t, res)
+}
+
+func TestSetIfNotExistsAndPublishMock(t *testing.T) {
+ var data map[string]interface{}
+ var channelsAndEvents []string
+ ns := "some-ns"
+ sdlSyncStorageMockTest := initSdlSyncStorageMockTest()
+ sdlSyncStorageMockTest.On("SetIfNotExistsAndPublish", ns, channelsAndEvents, "key", data).Return(true, nil)
+ res, err := sdlSyncStorageMockTest.SetIfNotExistsAndPublish(ns, channelsAndEvents, "key", data)
+ assert.Nil(t, err)
+ assert.NotNil(t, res)
+}
+
+func TestSubscribeChannelMock(t *testing.T) {
+ ns := "some-ns"
+ cb := func(channel string, events ...string) {}
+ ch := "some-channel"
+ sdlSyncStorageMockTest := initSdlSyncStorageMockTest()
+ sdlSyncStorageMockTest.On("SubscribeChannel", ns, mock.AnythingOfType("func(string, ...string)"),
+ []string{ch}).Return(nil)
+ err := sdlSyncStorageMockTest.SubscribeChannel(ns, cb, ch)
+ assert.Nil(t, err)
+}
+
+func TestUnsubscribeChannelMock(t *testing.T) {
+ ns := "some-ns"
+ ch := "some-channel"
+ sdlSyncStorageMockTest := initSdlSyncStorageMockTest()
+ sdlSyncStorageMockTest.On("UnsubscribeChannel", ns, []string{ch}).Return(nil)
+ err := sdlSyncStorageMockTest.UnsubscribeChannel(ns, ch)
+ assert.Nil(t, err)
+}
Code Review / ric-plt / nodeb-rnib.git / commitdiff