RIC:1060: Change in PTL

[ric-plt/nodeb-rnib.git] / reader / rNibReader_test.go

diff --git a/reader/rNibReader_test.go b/reader/rNibReader_test.go
index 91f37c3..3007b33 100644 (file)
--- a/reader/rNibReader_test.go
+++ b/reader/rNibReader_test.go
@@ -14,30 +14,38 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+//  This source code is part of the near-RT RIC (RAN Intelligent Controller)
+//  platform project (RICP).
+
 package reader
 
 import (
        "encoding/json"
+       "fmt"
        "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
        "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
        "github.com/golang/protobuf/proto"
        "github.com/pkg/errors"
        "github.com/stretchr/testify/assert"
+       "strconv"
        "testing"
        "time"
 )
 
-var namespace = "namespace"
-
-func initSdlInstanceMock(namespace string) (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(namespace)
+       w, sdlInstanceMock := initSdlSyncStorageMock()
        nb := entities.NodebInfo{}
        nb.ConnectionStatus = 1
        nb.Ip = "localhost"
@@ -56,7 +64,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)
@@ -68,14 +76,14 @@ func TestGetNodeB(t *testing.T) {
 
 func TestGetNodeBNotFoundFailure(t *testing.T) {
        name := "name"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       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)
@@ -85,7 +93,7 @@ func TestGetNodeBNotFoundFailure(t *testing.T) {
 
 func TestGetNodeBUnmarshalFailure(t *testing.T) {
        name := "name"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlInstanceMock := initSdlSyncStorageMock()
        var e error
        ret := make(map[string]interface{}, 1)
        redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
@@ -93,26 +101,26 @@ 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)
        assert.IsType(t, &common.InternalError{}, er)
-       assert.EqualValues(t, "proto: can't skip unknown wire type 4", er.Error())
+       assert.Contains(t,  er.Error(), "proto:")
 }
 
 func TestGetNodeBSdlgoFailure(t *testing.T) {
        name := "name"
        errMsg := "expected Sdlgo error"
        errMsgExpected := "expected Sdlgo error"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       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)
@@ -122,7 +130,7 @@ func TestGetNodeBSdlgoFailure(t *testing.T) {
 
 func TestGetNodeBCellsListEnb(t *testing.T) {
        name := "name"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlInstanceMock := initSdlSyncStorageMock()
        nb := entities.NodebInfo{}
        nb.ConnectionStatus = 1
        nb.Ip = "localhost"
@@ -141,7 +149,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)
@@ -152,7 +160,7 @@ func TestGetNodeBCellsListEnb(t *testing.T) {
 
 func TestGetNodeBCellsListGnb(t *testing.T) {
        name := "name"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlInstanceMock := initSdlSyncStorageMock()
        nb := entities.NodebInfo{}
        nb.ConnectionStatus = 1
        nb.Ip = "localhost"
@@ -172,7 +180,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)
@@ -183,7 +191,7 @@ func TestGetNodeBCellsListGnb(t *testing.T) {
 
 func TestGetNodeBCellsListNodeUnmarshalFailure(t *testing.T) {
        name := "name"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlInstanceMock := initSdlSyncStorageMock()
        var e error
        ret := make(map[string]interface{}, 1)
        redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
@@ -191,24 +199,24 @@ 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)
        assert.IsType(t, &common.InternalError{}, er)
-       assert.EqualValues(t, "proto: can't skip unknown wire type 4", er.Error())
+       assert.Contains(t,  er.Error(), "proto:")
 }
 
 func TestGetNodeBCellsListNodeNotFoundFailure(t *testing.T) {
        name := "name"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       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)
@@ -218,7 +226,7 @@ func TestGetNodeBCellsListNodeNotFoundFailure(t *testing.T) {
 
 func TestGetNodeBCellsListNotFoundFailureEnb(t *testing.T) {
        name := "name"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlInstanceMock := initSdlSyncStorageMock()
        nb := entities.NodebInfo{}
        nb.ConnectionStatus = 1
        nb.Ip = "localhost"
@@ -235,7 +243,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())
@@ -243,7 +251,7 @@ func TestGetNodeBCellsListNotFoundFailureEnb(t *testing.T) {
 
 func TestGetNodeBCellsListNotFoundFailureGnb(t *testing.T) {
        name := "name"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlInstanceMock := initSdlSyncStorageMock()
        nb := entities.NodebInfo{}
        nb.ConnectionStatus = 1
        nb.Ip = "localhost"
@@ -260,30 +268,30 @@ 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(namespace)
+       w, sdlInstanceMock := initSdlSyncStorageMock()
        var e error
-       sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return([]string{"data"}, e)
+       sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_GNB.String()).Return([]string{"data"}, e)
        ids, er := w.GetListGnbIds()
        assert.NotNil(t, er)
        assert.Nil(t, ids)
        assert.IsType(t, &common.InternalError{}, er)
-       assert.Equal(t, "proto: can't skip unknown wire type 4", er.Error())
+       assert.Contains(t,  er.Error(), "proto:")
 }
 
 func TestGetListGnbIdsSdlgoFailure(t *testing.T) {
        errMsg := "expected Sdlgo error"
        errMsgExpected := "expected Sdlgo error"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       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)
@@ -292,7 +300,7 @@ func TestGetListGnbIdsSdlgoFailure(t *testing.T) {
 }
 
 func TestGetListNodesIdsGnbSdlgoFailure(t *testing.T) {
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlInstanceMock := initSdlSyncStorageMock()
 
        name := "name"
        plmnId := "02f829"
@@ -303,13 +311,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)
@@ -319,7 +327,7 @@ func TestGetListNodesIdsGnbSdlgoFailure(t *testing.T) {
 }
 
 func TestGetListNodesIdsEnbSdlgoFailure(t *testing.T) {
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlInstanceMock := initSdlSyncStorageMock()
 
        name := "name"
        plmnId := "02f829"
@@ -330,13 +338,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)
@@ -346,7 +354,7 @@ func TestGetListNodesIdsEnbSdlgoFailure(t *testing.T) {
 }
 
 func TestGetListNodesIdsSuccess(t *testing.T) {
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlInstanceMock := initSdlSyncStorageMock()
        var nilError error
 
        name := "name"
@@ -367,46 +375,38 @@ func TestGetListNodesIdsSuccess(t *testing.T) {
                t.Errorf("#rNibReader_test.TestGetListNodesIdsSuccess - Failed to marshal nodeb identity entity. Error: %v", err)
        }
 
-       name2 := "name2"
-       nbIdentity2 := &entities.NbIdentity{InventoryName: name2}
-       data2, err := proto.Marshal(nbIdentity2)
-       if err != nil {
-               t.Errorf("#rNibReader_test.TestGetListNodesIdsSuccess - Failed to marshal nodeb identity entity. Error: %v", err)
-       }
-
-       sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return([]string{string(data)}, nilError)
-       sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{string(data1)}, nilError)
-       sdlInstanceMock.On("GetMembers", entities.Node_UNKNOWN.String()).Return([]string{string(data2)}, nilError)
+       sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_GNB.String()).Return([]string{string(data)}, nilError)
+       sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_ENB.String()).Return([]string{string(data1)}, nilError)
 
        ids, er := w.GetListNodebIds()
        assert.Nil(t, er)
        assert.NotNil(t, ids)
-       assert.Len(t, ids, 3)
+       assert.Len(t, ids, 2)
 }
 
 func TestGetListEnbIdsUnmarshalFailure(t *testing.T) {
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlInstanceMock := initSdlSyncStorageMock()
        var e error
-       sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{"data"}, e)
+       sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_ENB.String()).Return([]string{"data"}, e)
        ids, er := w.GetListEnbIds()
        assert.NotNil(t, er)
        assert.Nil(t, ids)
        assert.IsType(t, &common.InternalError{}, er)
-       assert.Equal(t, "proto: can't skip unknown wire type 4", er.Error())
+       assert.Contains(t,  er.Error(), "proto:")
 }
 
 func TestGetListEnbIdsOneId(t *testing.T) {
        name := "name"
        plmnId := "02f829"
        nbId := "4a952a0a"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       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)
@@ -416,9 +416,9 @@ func TestGetListEnbIdsOneId(t *testing.T) {
 }
 
 func TestGetListEnbIdsNoIds(t *testing.T) {
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       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)
@@ -429,11 +429,17 @@ func TestGetListEnbIds(t *testing.T) {
        plmnId := 0x02f829
        nbId := 0x4a952a0a
        listSize := 3
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlInstanceMock := initSdlSyncStorageMock()
        idsData := make([]string, listSize)
        idsEntities := make([]*entities.NbIdentity, listSize)
        for i := 0; i < listSize; i++ {
-               nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: string(plmnId + i), NbId: string(nbId + i)}}
+               nbIdentity := &entities.NbIdentity{
+                       InventoryName: name,
+                       GlobalNbId: &entities.GlobalNbId{
+                               PlmnId: strconv.FormatInt(int64(plmnId+i), 16),
+                               NbId:   strconv.FormatInt(int64(nbId+i), 16),
+                       },
+               }
                data, err := proto.Marshal(nbIdentity)
                if err != nil {
                        t.Errorf("#rNibReader_test.TestGetListEnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
@@ -442,7 +448,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)
@@ -457,14 +463,14 @@ func TestGetListGnbIdsOneId(t *testing.T) {
        name := "name"
        plmnId := "02f829"
        nbId := "4a952a0a"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       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)
@@ -474,9 +480,9 @@ func TestGetListGnbIdsOneId(t *testing.T) {
 }
 
 func TestGetListGnbIdsNoIds(t *testing.T) {
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       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)
@@ -487,11 +493,17 @@ func TestGetListGnbIds(t *testing.T) {
        plmnId := 0x02f829
        nbId := 0x4a952a0a
        listSize := 3
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlInstanceMock := initSdlSyncStorageMock()
        idsData := make([]string, listSize)
        idsEntities := make([]*entities.NbIdentity, listSize)
        for i := 0; i < listSize; i++ {
-               nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: string(plmnId + i), NbId: string(nbId + i)}}
+               nbIdentity := &entities.NbIdentity{
+                       InventoryName: name,
+                       GlobalNbId: &entities.GlobalNbId{
+                               PlmnId: strconv.FormatInt(int64(plmnId+i), 16),
+                               NbId:   strconv.FormatInt(int64(nbId+i), 16),
+                       },
+               }
                data, err := proto.Marshal(nbIdentity)
                if err != nil {
                        t.Errorf("#rNibReader_test.TestGetListGnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
@@ -500,7 +512,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)
@@ -514,10 +526,10 @@ func TestGetListGnbIds(t *testing.T) {
 func TestGetListEnbIdsSdlgoFailure(t *testing.T) {
        errMsg := "expected Sdlgo error"
        errMsgExpected := "expected Sdlgo error"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       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)
@@ -526,18 +538,18 @@ func TestGetListEnbIdsSdlgoFailure(t *testing.T) {
 }
 
 func TestGetCountGnbListOneId(t *testing.T) {
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       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(namespace)
+       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)
@@ -546,10 +558,10 @@ func TestGetCountGnbList(t *testing.T) {
 func TestGetCountGnbListSdlgoFailure(t *testing.T) {
        errMsg := "expected Sdlgo error"
        errMsgExpected := "expected Sdlgo error"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       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)
@@ -560,7 +572,7 @@ func TestGetCountGnbListSdlgoFailure(t *testing.T) {
 func TestGetCell(t *testing.T) {
        name := "name"
        var pci uint32 = 10
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       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 {
@@ -572,7 +584,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)
@@ -584,14 +596,14 @@ func TestGetCell(t *testing.T) {
 func TestGetCellNotFoundFailure(t *testing.T) {
        name := "name"
        var pci uint32
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       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)
@@ -602,7 +614,7 @@ func TestGetCellNotFoundFailure(t *testing.T) {
 func TestGetCellUnmarshalFailure(t *testing.T) {
        name := "name"
        var pci uint32
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlInstanceMock := initSdlSyncStorageMock()
        var e error
        ret := make(map[string]interface{}, 1)
        key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
@@ -610,12 +622,12 @@ 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)
        assert.IsType(t, &common.InternalError{}, er)
-       assert.EqualValues(t, "proto: can't skip unknown wire type 4", er.Error())
+       assert.Contains(t,  er.Error(), "proto:")
 }
 
 func TestGetCellSdlgoFailure(t *testing.T) {
@@ -623,14 +635,14 @@ func TestGetCellSdlgoFailure(t *testing.T) {
        var pci uint32
        errMsg := "expected Sdlgo error"
        errMsgExpected := "expected Sdlgo error"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       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)
@@ -639,7 +651,7 @@ func TestGetCellSdlgoFailure(t *testing.T) {
 }
 
 func TestGetNodebById(t *testing.T) {
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlInstanceMock := initSdlSyncStorageMock()
        nb := entities.NodebInfo{NodeType: entities.Node_ENB}
        nb.ConnectionStatus = 1
        nb.Ip = "localhost"
@@ -661,7 +673,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)
@@ -675,14 +687,14 @@ func TestGetNodebById(t *testing.T) {
 func TestGetNodebByIdNotFoundFailureEnb(t *testing.T) {
        plmnId := "02f829"
        nbId := "4a952a0a"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       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)
@@ -694,14 +706,14 @@ func TestGetNodebByIdNotFoundFailureEnb(t *testing.T) {
 func TestGetNodebByIdNotFoundFailureGnb(t *testing.T) {
        plmnId := "02f829"
        nbId := "4a952a0a"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       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)
@@ -713,7 +725,7 @@ func TestGetNodebByIdNotFoundFailureGnb(t *testing.T) {
 func TestGetNodeByIdUnmarshalFailure(t *testing.T) {
        plmnId := "02f829"
        nbId := "4a952a0a"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       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)
@@ -721,13 +733,13 @@ 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)
        assert.Nil(t, getNb)
        assert.IsType(t, &common.InternalError{}, er)
-       assert.EqualValues(t, "proto: can't skip unknown wire type 4", er.Error())
+       assert.Contains(t,  er.Error(), "proto:")
 }
 
 func TestGetNodeByIdSdlgoFailure(t *testing.T) {
@@ -735,14 +747,14 @@ func TestGetNodeByIdSdlgoFailure(t *testing.T) {
        nbId := "4a952a0a"
        errMsg := "expected Sdlgo error"
        errMsgExpected := "expected Sdlgo error"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       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)
@@ -754,7 +766,7 @@ func TestGetNodeByIdSdlgoFailure(t *testing.T) {
 func TestGetCellById(t *testing.T) {
        cellId := "aaaa"
        var pci uint32 = 10
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       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 {
@@ -766,7 +778,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)
@@ -777,14 +789,14 @@ func TestGetCellById(t *testing.T) {
 
 func TestGetCellByIdNotFoundFailureEnb(t *testing.T) {
        cellId := "bbbb"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       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)
@@ -794,14 +806,14 @@ func TestGetCellByIdNotFoundFailureEnb(t *testing.T) {
 
 func TestGetCellByIdNotFoundFailureGnb(t *testing.T) {
        cellId := "bbbb"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       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)
@@ -811,7 +823,7 @@ func TestGetCellByIdNotFoundFailureGnb(t *testing.T) {
 
 func TestGetCellByIdTypeValidationFailure(t *testing.T) {
        cellId := "dddd"
-       w, _ := initSdlInstanceMock(namespace)
+       w, _ := initSdlSyncStorageMock()
        cell, er := w.GetCellById(5, cellId)
        assert.NotNil(t, er)
        assert.Nil(t, cell)
@@ -821,7 +833,7 @@ func TestGetCellByIdTypeValidationFailure(t *testing.T) {
 
 func TestGetCellByIdValidationFailureGnb(t *testing.T) {
        cellId := ""
-       w, _ := initSdlInstanceMock(namespace)
+       w, _ := initSdlSyncStorageMock()
        cell, er := w.GetCellById(entities.Cell_NR_CELL, cellId)
        assert.NotNil(t, er)
        assert.Nil(t, cell)
@@ -831,7 +843,7 @@ func TestGetCellByIdValidationFailureGnb(t *testing.T) {
 
 func TestGetCellByIdValidationFailureEnb(t *testing.T) {
        cellId := ""
-       w, _ := initSdlInstanceMock(namespace)
+       w, _ := initSdlSyncStorageMock()
        cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
        assert.NotNil(t, er)
        assert.Nil(t, cell)
@@ -841,7 +853,7 @@ func TestGetCellByIdValidationFailureEnb(t *testing.T) {
 
 func TestGetRanLoadInformation(t *testing.T) {
        name := "name"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlInstanceMock := initSdlSyncStorageMock()
        loadInfo := generateRanLoadInformation()
        var e error
        data, err := proto.Marshal(loadInfo)
@@ -853,7 +865,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)
@@ -870,7 +882,7 @@ func TestGetRanLoadInformation(t *testing.T) {
 
 func TestGetRanLoadInformationValidationFailure(t *testing.T) {
        name := ""
-       w, _ := initSdlInstanceMock(namespace)
+       w, _ := initSdlSyncStorageMock()
        getNb, er := w.GetRanLoadInformation(name)
        assert.NotNil(t, er)
        assert.Nil(t, getNb)
@@ -880,14 +892,14 @@ func TestGetRanLoadInformationValidationFailure(t *testing.T) {
 
 func TestGetRanLoadInformationNotFoundFailure(t *testing.T) {
        name := "name"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       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)
@@ -897,7 +909,7 @@ func TestGetRanLoadInformationNotFoundFailure(t *testing.T) {
 
 func TestGetRanLoadInformationUnmarshalFailure(t *testing.T) {
        name := "name"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       w, sdlInstanceMock := initSdlSyncStorageMock()
        var e error
        ret := make(map[string]interface{}, 1)
        redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
@@ -905,26 +917,26 @@ 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)
        assert.IsType(t, &common.InternalError{}, er)
-       assert.EqualValues(t, "proto: can't skip unknown wire type 4", er.Error())
+       assert.Contains(t,  er.Error(), "proto:")
 }
 
 func TestGetRanLoadInformationSdlgoFailure(t *testing.T) {
        name := "name"
        errMsg := "expected Sdlgo error"
        errMsgExpected := "expected Sdlgo error"
-       w, sdlInstanceMock := initSdlInstanceMock(namespace)
+       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)
@@ -1005,6 +1017,260 @@ func generateRanLoadInformation() *entities.RanLoadInformation {
        return &ranLoadInformation
 }
 
+func TestGetE2TInstanceSuccess(t *testing.T) {
+       address := "10.10.2.15:9800"
+       redisKey, validationErr := common.ValidateAndBuildE2TInstanceKey(address)
+
+       if validationErr != nil {
+               t.Errorf("#rNibReader_test.TestGetE2TInstanceSuccess - Failed to build E2T Instance key. Error: %v", validationErr)
+       }
+
+       w, sdlInstanceMock := initSdlSyncStorageMock()
+
+       e2tInstance := generateE2tInstance(address)
+       data, err := json.Marshal(e2tInstance)
+
+       if err != nil {
+               t.Errorf("#rNibReader_test.TestGetE2TInstanceSuccess - Failed to marshal E2tInstance entity. Error: %v", err)
+       }
+
+       var e error
+       ret := map[string]interface{}{redisKey: string(data)}
+       sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
+
+       res, rNibErr := w.GetE2TInstance(address)
+       assert.Nil(t, rNibErr)
+       assert.Equal(t, e2tInstance, res)
+}
+
+func TestUnmarshal(t *testing.T) {
+       e2tInstance := generateE2tInstance("10.0.2.15:5555")
+       marshaled, _ := json.Marshal(e2tInstance)
+       m := map[string]interface{}{
+               "whatever": string(marshaled),
+       }
+       var entity entities.E2TInstance
+       err := json.Unmarshal([]byte(m["whatever"].(string)), &entity)
+       assert.Nil(t, err)
+}
+
+func TestGetE2TInstanceEmptyAddressFailure(t *testing.T) {
+       w, _ := initSdlSyncStorageMock()
+       res, err := w.GetE2TInstance("")
+       assert.NotNil(t, err)
+       assert.IsType(t, &common.ValidationError{}, err)
+       assert.Nil(t, res)
+}
+
+func TestGetE2TInstanceSdlError(t *testing.T) {
+       address := "10.10.2.15:9800"
+       redisKey, validationErr := common.ValidateAndBuildE2TInstanceKey(address)
+
+       if validationErr != nil {
+               t.Errorf("#rNibReader_test.TestGetE2TInstanceSuccess - Failed to build E2T Instance key. Error: %v", validationErr)
+       }
+
+       w, sdlInstanceMock := initSdlSyncStorageMock()
+
+       expectedErr := errors.New("expected error")
+       var ret map[string]interface{}
+       sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, expectedErr)
+
+       res, rNibErr := w.GetE2TInstance(address)
+       assert.NotNil(t, rNibErr)
+       assert.Nil(t, res)
+}
+
+func generateE2tInstance(address string) *entities.E2TInstance {
+       e2tInstance := entities.NewE2TInstance(address,"")
+       e2tInstance.AssociatedRanList = []string{"test1", "test2"}
+       e2tInstance.DeletionTimestamp = time.Now().UnixNano()
+       return e2tInstance
+}
+
+func TestGetE2TAddressesSdlError(t *testing.T) {
+       w, sdlInstanceMock := initSdlSyncStorageMock()
+
+       expectedErr := errors.New("expected error")
+       var ret map[string]interface{}
+       sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{E2TAddressesKey}).Return(ret, expectedErr)
+
+       res, rNibErr := w.GetE2TAddresses()
+       assert.NotNil(t, rNibErr)
+       assert.Nil(t, res)
+}
+
+func TestGetE2TAddressesSuccess(t *testing.T) {
+       address := "10.10.2.15:9800"
+       w, sdlInstanceMock := initSdlSyncStorageMock()
+
+       e2tAddresses := []string{address}
+       data, err := json.Marshal(e2tAddresses)
+
+       if err != nil {
+               t.Errorf("#rNibReader_test.TestGetE2TInfoListSuccess - Failed to marshal E2TInfoList. Error: %v", err)
+       }
+
+       var e error
+       ret := map[string]interface{}{E2TAddressesKey: string(data)}
+       sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{E2TAddressesKey}).Return(ret, e)
+
+       res, rNibErr := w.GetE2TAddresses()
+       assert.Nil(t, rNibErr)
+       assert.Equal(t, e2tAddresses, res)
+}
+
+func TestGetE2TInstancesSuccess(t *testing.T) {
+       address := "10.10.2.15:9800"
+       address2 := "10.10.2.16:9800"
+       redisKey, _ := common.ValidateAndBuildE2TInstanceKey(address)
+       redisKey2, _ := common.ValidateAndBuildE2TInstanceKey(address2)
+
+       w, sdlInstanceMock := initSdlSyncStorageMock()
+
+       e2tInstance1 := generateE2tInstance(address)
+       e2tInstance2 := generateE2tInstance(address2)
+
+       data1, _ := json.Marshal(e2tInstance1)
+       data2, _ := json.Marshal(e2tInstance2)
+
+       var e error
+       ret := map[string]interface{}{redisKey: string(data1), redisKey2: string(data2)}
+       sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey, redisKey2}).Return(ret, e)
+
+       res, err := w.GetE2TInstances([]string{address, address2})
+       assert.Nil(t, err)
+       assert.Equal(t, []*entities.E2TInstance{e2tInstance1, e2tInstance2}, res)
+}
+
+func TestGetE2TInstancesUnmarhalPartialSuccess(t *testing.T) {
+       address := "10.10.2.15:9800"
+       address2 := "10.10.2.16:9800"
+       redisKey, _ := common.ValidateAndBuildE2TInstanceKey(address)
+       redisKey2, _ := common.ValidateAndBuildE2TInstanceKey(address2)
+
+       w, sdlInstanceMock := initSdlSyncStorageMock()
+
+       e2tInstance1 := generateE2tInstance(address)
+       data1, _ := json.Marshal(e2tInstance1)
+
+       var e error
+       ret := map[string]interface{}{redisKey: string(data1), redisKey2: "abc"}
+       sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey, redisKey2}).Return(ret, e)
+
+       res, err := w.GetE2TInstances([]string{address, address2})
+       assert.Nil(t, err)
+       assert.Equal(t, []*entities.E2TInstance{e2tInstance1}, res)
+}
+
+func TestGetE2TInstancesSdlFailure(t *testing.T) {
+       address := "10.10.2.15:9800"
+       address2 := "10.10.2.16:9800"
+       redisKey, _ := common.ValidateAndBuildE2TInstanceKey(address)
+       redisKey2, _ := common.ValidateAndBuildE2TInstanceKey(address2)
+
+       w, sdlInstanceMock := initSdlSyncStorageMock()
+
+       sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey, redisKey2}).Return(map[string]interface{}{}, fmt.Errorf(""))
+       _, err := w.GetE2TInstances([]string{address, address2})
+       assert.IsType(t, &common.InternalError{}, err)
+}
+
+func TestGetE2TInstancesEmptyData(t *testing.T) {
+       address := "10.10.2.15:9800"
+       address2 := "10.10.2.16:9800"
+       redisKey, _ := common.ValidateAndBuildE2TInstanceKey(address)
+       redisKey2, _ := common.ValidateAndBuildE2TInstanceKey(address2)
+
+       w, sdlInstanceMock := initSdlSyncStorageMock()
+
+       sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey, redisKey2}).Return(map[string]interface{}{}, nil)
+       _, err := w.GetE2TInstances([]string{address, address2})
+       assert.IsType(t, &common.ResourceNotFoundError{}, err)
+}
+
+func TestGetGeneralConfiguration(t *testing.T) {
+
+       key := common.BuildGeneralConfigurationKey()
+       w, sdlInstanceMock := initSdlSyncStorageMock()
+
+       configurationData := "{\"enableRic\":true}"
+       sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(map[string]interface{}{key: configurationData}, nil)
+
+       res, rNibErr := w.GetGeneralConfiguration()
+       assert.Nil(t, rNibErr)
+       assert.Equal(t, true, res.EnableRic)
+}
+
+func TestGetGeneralConfigurationNotFound(t *testing.T) {
+
+       key := common.BuildGeneralConfigurationKey()
+       w, sdlInstanceMock := initSdlSyncStorageMock()
+
+       sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(map[string]interface{}{}, nil)
+
+       _, rNibErr := w.GetGeneralConfiguration()
+
+       assert.NotNil(t, rNibErr)
+       assert.Equal(t, "#rNibReader.getByKeyAndUnmarshalJson - entity of type *entities.GeneralConfiguration not found. Key: GENERAL", rNibErr.Error())
+}
+
+func TestGetGeneralConfigurationSdlFailure(t *testing.T) {
+
+       key := common.BuildGeneralConfigurationKey()
+       w, sdlInstanceMock := initSdlSyncStorageMock()
+
+       sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(map[string]interface{}{}, fmt.Errorf("sdl error"))
+
+       _, rNibErr := w.GetGeneralConfiguration()
+
+       assert.NotNil(t, rNibErr)
+
+       assert.Equal(t, "sdl error", rNibErr.Error())
+}
+
+func TestGetGeneralConfigurationUnmarshalError(t *testing.T) {
+
+       key := common.BuildGeneralConfigurationKey()
+       w, sdlInstanceMock := initSdlSyncStorageMock()
+
+       configurationData := "{\"enableRic :true}"
+       sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(map[string]interface{}{key: configurationData}, nil)
+
+       _, rNibErr := w.GetGeneralConfiguration()
+
+       assert.NotNil(t, rNibErr)
+       assert.Equal(t, rNibErr.Error(), "unexpected end of JSON input")
+}
+
+func TestGetRanFunctionDefinition(t *testing.T) {
+    name := "name"
+    oid := "1.3.6.1.4.1.1.2.2.2"
+    w, sdlInstanceMock := initSdlSyncStorageMock()
+    nb := entities.NodebInfo{}
+    nb.ConnectionStatus = 1
+    nb.Ip = "localhost"
+    nb.Port = 5656
+    enb := entities.Enb{}
+    cell := entities.ServedCellInfo{Tac: "tac"}
+    enb.ServedCells = []*entities.ServedCellInfo{&cell}
+    nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
+    var e error
+    data, err := proto.Marshal(&nb)
+    if err != nil {
+        t.Errorf("#rNibReader_test.GetRanFunctionDefinition - Failed to marshal ENB instance. Error: %v", err)
+    }
+    redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
+    if rNibErr != nil {
+        t.Errorf("#rNibReader_test.TestRanFunctionDefinition - failed to validate key parameter")
+    }
+    ret := map[string]interface{}{redisKey: string(data)}
+    sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
+    ranFuncs, er := w.GetRanFunctionDefinition(name, oid)
+    assert.IsType(t, &common.ResourceNotFoundError{}, er)
+    assert.Nil(t, ranFuncs)
+}
+
 //integration tests
 //
 //func TestGetEnbInteg(t *testing.T){
@@ -1156,3 +1422,11 @@ func generateRanLoadInformation() *entities.RanLoadInformation {
 //     assert.NotNil(t, ranLoadInformation)
 //     fmt.Printf("#rNibReader_test.TestGetRanLoadInformationInteg - GNB ID: %s\n", ranLoadInformation)
 //}
+
+//func TestGetE2TInstancesInteg(t *testing.T) {
+//     db := sdlgo.NewDatabase()
+//     sdl := sdlgo.NewSdlInstance("e2Manager", db)
+//     rnibReader := GetRNibReader(sdl)
+//     e2tInstances, _ := rnibReader.GetE2TInstances([]string{"e2t.att.com:38000","whatever"})
+//     assert.Len(t, e2tInstances, 1)
+//}