From e9fee6f254270875378e5bec3bd7a3ff1dfae51f Mon Sep 17 00:00:00 2001 From: Timo Tietavainen Date: Thu, 16 Sep 2021 15:21:47 +0300 Subject: [PATCH] Preparation for SdlInstance usage removal in RNIB SdlInstance type with its API functions has been deprecated and its source code will be removed at some point of time from SDLGO repository. SDLGO repository provides the SyncStorage type what should be used instead of the SdlInstance type. Since there exists applications that are using RNIB, it's not possible just to replace SdlInstance with SyncStorage in RNIB code but instead this commit is a first step where it's implemented a new RNIB interface that utilizes SDL SyncStorage and it is left the existing RNIB interface still in place. After some reasonable time has passed there will be made next RNIB commit to remove the old RNIB code based on use of the SDL SdlInstance type. This commit has following changes: * Implement a new ISdlSyncStorage interface type. * Implement a new function GetNewRNibReader to create RNIB reader instance. * Add deprecation warning for GetRNibReader function. All application should use instead GetNewRNibReader to create RNIB reader instance. * Change RNIB reader instance APIs to use either SDL SdlInstance or SyncStorage instance depending on was the RNIB instance created by GetNewRNibReader or GetRNibReader function. * Add unit tests to cover both the SdlInstance and the SyncStorage SDL APIs use cases. * Add deprecation warnings to those RNIB code blocks and test cases that will be removed later when it's time to remove SDL SdlInstance from the code repository. Issue-Id: RIC-805 Signed-off-by: Timo Tietavainen Change-Id: I68345de5664edb4245f18f550a40974a4f79ad92 --- common/iSdlInstance.go | 6 +- common/iSdlSyncStorage.go | 47 ++ common/utils.go | 8 + reader/go.mod | 5 +- reader/rNibReader.go | 80 +- reader/rNibReaderDeprecated_test.go | 1390 +++++++++++++++++++++++++++++++++++ reader/rNibReader_test.go | 245 +++--- reader/sdlInstanceMock.go | 52 ++ reader/sdlInstanceMock_test.go | 39 +- reader/sdlSyncStorageMock.go | 136 ++++ reader/sdlSyncStorageMock_test.go | 233 ++++++ 11 files changed, 2103 insertions(+), 138 deletions(-) create mode 100644 common/iSdlSyncStorage.go create mode 100644 reader/rNibReaderDeprecated_test.go create mode 100644 reader/sdlSyncStorageMock.go create mode 100644 reader/sdlSyncStorageMock_test.go diff --git a/common/iSdlInstance.go b/common/iSdlInstance.go index ec2b2e0..526ed59 100644 --- a/common/iSdlInstance.go +++ b/common/iSdlInstance.go @@ -19,9 +19,9 @@ 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 diff --git a/common/iSdlSyncStorage.go b/common/iSdlSyncStorage.go new file mode 100644 index 0000000..7fe5181 --- /dev/null +++ b/common/iSdlSyncStorage.go @@ -0,0 +1,47 @@ +// +// 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) +} diff --git a/common/utils.go b/common/utils.go index 5c3bff9..1cae140 100644 --- a/common/utils.go +++ b/common/utils.go @@ -23,6 +23,9 @@ import ( "fmt" ) +//SDL namespace used by the RNIB +const rnibNamespace = "e2Manager" + /* ValidateAndBuildCellIdKey builds key according to the specified format returns the resulting string */ @@ -112,3 +115,8 @@ func MapE2TAddressesToKeys(addresses []string) []string { return keys } + +//GetRNibNamespace returns namespace used by the RNIB in SDL. +func GetRNibNamespace() string { + return rnibNamespace +} diff --git a/reader/go.mod b/reader/go.mod index 406d746..2a86311 100644 --- a/reader/go.mod +++ b/reader/go.mod @@ -3,8 +3,9 @@ module gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader 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 diff --git a/reader/rNibReader.go b/reader/rNibReader.go index a83c033..77fee8d 100644 --- a/reader/rNibReader.go +++ b/reader/rNibReader.go @@ -30,7 +30,9 @@ import ( 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 } /* @@ -67,11 +69,23 @@ type RNibReader interface { 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) { @@ -128,7 +142,13 @@ func (w *rNibReaderInstance) GetListEnbIds() ([]*entities.NbIdentity, 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) } @@ -170,11 +190,21 @@ func (w *rNibReaderInstance) GetCellById(cellType entities.Cell_Type, cellId str } 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) } @@ -210,11 +240,18 @@ func (w *rNibReaderInstance) GetE2TInstance(address string) (*entities.E2TInstan } 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) @@ -259,7 +296,13 @@ func (w *rNibReaderInstance) GetGeneralConfiguration() (*entities.GeneralConfigu } 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) @@ -276,7 +319,14 @@ func (w *rNibReaderInstance) getByKeyAndUnmarshalJson(key string, entity interfa } 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) } @@ -291,7 +341,13 @@ func (w *rNibReaderInstance) getByKeyAndUnmarshal(key string, entity proto.Messa } 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) } diff --git a/reader/rNibReaderDeprecated_test.go b/reader/rNibReaderDeprecated_test.go new file mode 100644 index 0000000..168432e --- /dev/null +++ b/reader/rNibReaderDeprecated_test.go @@ -0,0 +1,1390 @@ +// +// 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) +//} diff --git a/reader/rNibReader_test.go b/reader/rNibReader_test.go index 4004be5..dea8970 100644 --- a/reader/rNibReader_test.go +++ b/reader/rNibReader_test.go @@ -31,15 +31,20 @@ import ( "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" @@ -58,7 +63,7 @@ func TestGetNodeB(t *testing.T) { 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) @@ -70,14 +75,14 @@ func TestGetNodeB(t *testing.T) { 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) @@ -87,7 +92,7 @@ func TestGetNodeBNotFoundFailure(t *testing.T) { 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) @@ -95,7 +100,7 @@ func TestGetNodeBUnmarshalFailure(t *testing.T) { 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) @@ -107,14 +112,14 @@ func TestGetNodeBSdlgoFailure(t *testing.T) { 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) @@ -124,7 +129,7 @@ func TestGetNodeBSdlgoFailure(t *testing.T) { func TestGetNodeBCellsListEnb(t *testing.T) { name := "name" - w, sdlInstanceMock := initSdlInstanceMock() + w, sdlInstanceMock := initSdlSyncStorageMock() nb := entities.NodebInfo{} nb.ConnectionStatus = 1 nb.Ip = "localhost" @@ -143,7 +148,7 @@ func TestGetNodeBCellsListEnb(t *testing.T) { 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) @@ -154,7 +159,7 @@ func TestGetNodeBCellsListEnb(t *testing.T) { func TestGetNodeBCellsListGnb(t *testing.T) { name := "name" - w, sdlInstanceMock := initSdlInstanceMock() + w, sdlInstanceMock := initSdlSyncStorageMock() nb := entities.NodebInfo{} nb.ConnectionStatus = 1 nb.Ip = "localhost" @@ -174,7 +179,7 @@ func TestGetNodeBCellsListGnb(t *testing.T) { 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) @@ -185,7 +190,7 @@ func TestGetNodeBCellsListGnb(t *testing.T) { 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) @@ -193,7 +198,7 @@ func TestGetNodeBCellsListNodeUnmarshalFailure(t *testing.T) { 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) @@ -203,14 +208,14 @@ func TestGetNodeBCellsListNodeUnmarshalFailure(t *testing.T) { 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) @@ -220,7 +225,7 @@ func TestGetNodeBCellsListNodeNotFoundFailure(t *testing.T) { func TestGetNodeBCellsListNotFoundFailureEnb(t *testing.T) { name := "name" - w, sdlInstanceMock := initSdlInstanceMock() + w, sdlInstanceMock := initSdlSyncStorageMock() nb := entities.NodebInfo{} nb.ConnectionStatus = 1 nb.Ip = "localhost" @@ -237,7 +242,7 @@ func TestGetNodeBCellsListNotFoundFailureEnb(t *testing.T) { 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()) @@ -245,7 +250,7 @@ func TestGetNodeBCellsListNotFoundFailureEnb(t *testing.T) { func TestGetNodeBCellsListNotFoundFailureGnb(t *testing.T) { name := "name" - w, sdlInstanceMock := initSdlInstanceMock() + w, sdlInstanceMock := initSdlSyncStorageMock() nb := entities.NodebInfo{} nb.ConnectionStatus = 1 nb.Ip = "localhost" @@ -262,16 +267,16 @@ func TestGetNodeBCellsListNotFoundFailureGnb(t *testing.T) { 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) @@ -282,10 +287,10 @@ func TestGetListGnbIdsUnmarshalFailure(t *testing.T) { 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) @@ -294,7 +299,7 @@ func TestGetListGnbIdsSdlgoFailure(t *testing.T) { } func TestGetListNodesIdsGnbSdlgoFailure(t *testing.T) { - w, sdlInstanceMock := initSdlInstanceMock() + w, sdlInstanceMock := initSdlSyncStorageMock() name := "name" plmnId := "02f829" @@ -305,13 +310,13 @@ func TestGetListNodesIdsGnbSdlgoFailure(t *testing.T) { 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) @@ -321,7 +326,7 @@ func TestGetListNodesIdsGnbSdlgoFailure(t *testing.T) { } func TestGetListNodesIdsEnbSdlgoFailure(t *testing.T) { - w, sdlInstanceMock := initSdlInstanceMock() + w, sdlInstanceMock := initSdlSyncStorageMock() name := "name" plmnId := "02f829" @@ -332,13 +337,13 @@ func TestGetListNodesIdsEnbSdlgoFailure(t *testing.T) { 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) @@ -348,7 +353,7 @@ func TestGetListNodesIdsEnbSdlgoFailure(t *testing.T) { } func TestGetListNodesIdsSuccess(t *testing.T) { - w, sdlInstanceMock := initSdlInstanceMock() + w, sdlInstanceMock := initSdlSyncStorageMock() var nilError error name := "name" @@ -369,8 +374,8 @@ func TestGetListNodesIdsSuccess(t *testing.T) { 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) @@ -379,9 +384,9 @@ func TestGetListNodesIdsSuccess(t *testing.T) { } 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) @@ -393,14 +398,14 @@ func TestGetListEnbIdsOneId(t *testing.T) { 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) @@ -410,9 +415,9 @@ func TestGetListEnbIdsOneId(t *testing.T) { } 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) @@ -423,7 +428,7 @@ func TestGetListEnbIds(t *testing.T) { 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++ { @@ -436,7 +441,7 @@ func TestGetListEnbIds(t *testing.T) { 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) @@ -451,14 +456,14 @@ func TestGetListGnbIdsOneId(t *testing.T) { 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) @@ -468,9 +473,9 @@ func TestGetListGnbIdsOneId(t *testing.T) { } 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) @@ -481,7 +486,7 @@ func TestGetListGnbIds(t *testing.T) { 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++ { @@ -494,7 +499,7 @@ func TestGetListGnbIds(t *testing.T) { 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) @@ -508,10 +513,10 @@ func TestGetListGnbIds(t *testing.T) { 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) @@ -520,18 +525,18 @@ func TestGetListEnbIdsSdlgoFailure(t *testing.T) { } 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) @@ -540,10 +545,10 @@ func TestGetCountGnbList(t *testing.T) { 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) @@ -554,7 +559,7 @@ func TestGetCountGnbListSdlgoFailure(t *testing.T) { 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 { @@ -566,7 +571,7 @@ func TestGetCell(t *testing.T) { 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) @@ -578,14 +583,14 @@ func TestGetCell(t *testing.T) { 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) @@ -596,7 +601,7 @@ func TestGetCellNotFoundFailure(t *testing.T) { 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) @@ -604,7 +609,7 @@ func TestGetCellUnmarshalFailure(t *testing.T) { 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) @@ -617,14 +622,14 @@ func TestGetCellSdlgoFailure(t *testing.T) { 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) @@ -633,7 +638,7 @@ func TestGetCellSdlgoFailure(t *testing.T) { } func TestGetNodebById(t *testing.T) { - w, sdlInstanceMock := initSdlInstanceMock() + w, sdlInstanceMock := initSdlSyncStorageMock() nb := entities.NodebInfo{NodeType: entities.Node_ENB} nb.ConnectionStatus = 1 nb.Ip = "localhost" @@ -655,7 +660,7 @@ func TestGetNodebById(t *testing.T) { 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) @@ -669,14 +674,14 @@ func TestGetNodebById(t *testing.T) { 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) @@ -688,14 +693,14 @@ func TestGetNodebByIdNotFoundFailureEnb(t *testing.T) { 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) @@ -707,7 +712,7 @@ func TestGetNodebByIdNotFoundFailureGnb(t *testing.T) { 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) @@ -715,7 +720,7 @@ func TestGetNodeByIdUnmarshalFailure(t *testing.T) { 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) @@ -729,14 +734,14 @@ func TestGetNodeByIdSdlgoFailure(t *testing.T) { 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) @@ -748,7 +753,7 @@ func TestGetNodeByIdSdlgoFailure(t *testing.T) { 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 { @@ -760,7 +765,7 @@ func TestGetCellById(t *testing.T) { 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) @@ -771,14 +776,14 @@ func TestGetCellById(t *testing.T) { 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) @@ -788,14 +793,14 @@ func TestGetCellByIdNotFoundFailureEnb(t *testing.T) { 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) @@ -805,7 +810,7 @@ func TestGetCellByIdNotFoundFailureGnb(t *testing.T) { 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) @@ -815,7 +820,7 @@ func TestGetCellByIdTypeValidationFailure(t *testing.T) { 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) @@ -825,7 +830,7 @@ func TestGetCellByIdValidationFailureGnb(t *testing.T) { 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) @@ -835,7 +840,7 @@ func TestGetCellByIdValidationFailureEnb(t *testing.T) { func TestGetRanLoadInformation(t *testing.T) { name := "name" - w, sdlInstanceMock := initSdlInstanceMock() + w, sdlInstanceMock := initSdlSyncStorageMock() loadInfo := generateRanLoadInformation() var e error data, err := proto.Marshal(loadInfo) @@ -847,7 +852,7 @@ func TestGetRanLoadInformation(t *testing.T) { 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) @@ -864,7 +869,7 @@ func TestGetRanLoadInformation(t *testing.T) { func TestGetRanLoadInformationValidationFailure(t *testing.T) { name := "" - w, _ := initSdlInstanceMock() + w, _ := initSdlSyncStorageMock() getNb, er := w.GetRanLoadInformation(name) assert.NotNil(t, er) assert.Nil(t, getNb) @@ -874,14 +879,14 @@ func TestGetRanLoadInformationValidationFailure(t *testing.T) { 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) @@ -891,7 +896,7 @@ func TestGetRanLoadInformationNotFoundFailure(t *testing.T) { 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) @@ -899,7 +904,7 @@ func TestGetRanLoadInformationUnmarshalFailure(t *testing.T) { 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) @@ -911,14 +916,14 @@ func TestGetRanLoadInformationSdlgoFailure(t *testing.T) { 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) @@ -1007,7 +1012,7 @@ func TestGetE2TInstanceSuccess(t *testing.T) { 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) @@ -1018,7 +1023,7 @@ func TestGetE2TInstanceSuccess(t *testing.T) { 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) @@ -1037,7 +1042,7 @@ func TestUnmarshal(t *testing.T) { } func TestGetE2TInstanceEmptyAddressFailure(t *testing.T) { - w, _ := initSdlInstanceMock() + w, _ := initSdlSyncStorageMock() res, err := w.GetE2TInstance("") assert.NotNil(t, err) assert.IsType(t, &common.ValidationError{}, err) @@ -1052,11 +1057,11 @@ func TestGetE2TInstanceSdlError(t *testing.T) { 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) @@ -1071,11 +1076,11 @@ func generateE2tInstance(address string) *entities.E2TInstance { } 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) @@ -1084,7 +1089,7 @@ func TestGetE2TAddressesSdlError(t *testing.T) { 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) @@ -1095,7 +1100,7 @@ func TestGetE2TAddressesSuccess(t *testing.T) { 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) @@ -1108,7 +1113,7 @@ func TestGetE2TInstancesSuccess(t *testing.T) { redisKey, _ := common.ValidateAndBuildE2TInstanceKey(address) redisKey2, _ := common.ValidateAndBuildE2TInstanceKey(address2) - w, sdlInstanceMock := initSdlInstanceMock() + w, sdlInstanceMock := initSdlSyncStorageMock() e2tInstance1 := generateE2tInstance(address) e2tInstance2 := generateE2tInstance(address2) @@ -1118,7 +1123,7 @@ func TestGetE2TInstancesSuccess(t *testing.T) { 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) @@ -1131,14 +1136,14 @@ func TestGetE2TInstancesUnmarhalPartialSuccess(t *testing.T) { 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) @@ -1151,9 +1156,9 @@ func TestGetE2TInstancesSdlFailure(t *testing.T) { 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) } @@ -1164,9 +1169,9 @@ func TestGetE2TInstancesEmptyData(t *testing.T) { 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) } @@ -1174,10 +1179,10 @@ func TestGetE2TInstancesEmptyData(t *testing.T) { 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) @@ -1187,9 +1192,9 @@ func TestGetGeneralConfiguration(t *testing.T) { 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() @@ -1200,9 +1205,9 @@ func TestGetGeneralConfigurationNotFound(t *testing.T) { 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() @@ -1214,10 +1219,10 @@ func TestGetGeneralConfigurationSdlFailure(t *testing.T) { 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() @@ -1383,4 +1388,4 @@ func TestGetGeneralConfigurationUnmarshalError(t *testing.T) { // rnibReader := GetRNibReader(sdl) // e2tInstances, _ := rnibReader.GetE2TInstances([]string{"e2t.att.com:38000","whatever"}) // assert.Len(t, e2tInstances, 1) -//} \ No newline at end of file +//} diff --git a/reader/sdlInstanceMock.go b/reader/sdlInstanceMock.go index 39cb8bc..9bc26a6 100644 --- a/reader/sdlInstanceMock.go +++ b/reader/sdlInstanceMock.go @@ -21,115 +21,167 @@ package reader 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) diff --git a/reader/sdlInstanceMock_test.go b/reader/sdlInstanceMock_test.go index 0ebeca2..437ae33 100644 --- a/reader/sdlInstanceMock_test.go +++ b/reader/sdlInstanceMock_test.go @@ -24,11 +24,15 @@ import ( "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) @@ -36,6 +40,8 @@ func TestRemoveAll(t *testing.T){ 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() @@ -45,6 +51,8 @@ func TestRemove(t *testing.T){ } +//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" @@ -56,6 +64,8 @@ func TestRemoveIf(t *testing.T){ } +//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() @@ -65,6 +75,8 @@ func TestRemoveGroup(t *testing.T){ } +//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 @@ -77,6 +89,8 @@ func TestRemoveIfAndPublish(t *testing.T){ } +//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 @@ -86,6 +100,8 @@ func TestRemoveAndPublish(t *testing.T){ 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() @@ -94,6 +110,8 @@ func TestRemoveAllAndPublish(t *testing.T){ 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() @@ -103,6 +121,8 @@ func TestIsMember(t *testing.T){ 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) @@ -110,6 +130,8 @@ func TestClose(t *testing.T){ 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" @@ -120,6 +142,8 @@ func TestSetIfNotExists(t *testing.T){ 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() @@ -128,6 +152,8 @@ func TestAddMember(t *testing.T){ 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() @@ -136,6 +162,8 @@ func TestRemoveMember(t *testing.T){ 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 @@ -145,6 +173,8 @@ func TestSetAndPublish(t *testing.T){ 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{} @@ -156,6 +186,8 @@ func TestSetIfAndPublish(t *testing.T){ 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() @@ -164,6 +196,8 @@ func TestSet(t *testing.T){ 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{} @@ -174,6 +208,8 @@ func TestSetIf(t *testing.T){ 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() @@ -183,6 +219,8 @@ func TestGetAll(t *testing.T){ 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 @@ -192,4 +230,3 @@ func TestSetIfNotExistsAndPublish(t *testing.T){ assert.Nil(t, err) assert.NotNil(t, res) } - diff --git a/reader/sdlSyncStorageMock.go b/reader/sdlSyncStorageMock.go new file mode 100644 index 0000000..2fd4391 --- /dev/null +++ b/reader/sdlSyncStorageMock.go @@ -0,0 +1,136 @@ +// +// 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) +} diff --git a/reader/sdlSyncStorageMock_test.go b/reader/sdlSyncStorageMock_test.go new file mode 100644 index 0000000..f024c3a --- /dev/null +++ b/reader/sdlSyncStorageMock_test.go @@ -0,0 +1,233 @@ +// +// 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) +} -- 2.16.6