reader/rNibReader_test.go

   1 //
   2 // Copyright 2019 AT&T Intellectual Property
   3 // Copyright 2019 Nokia
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the "License");
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //      http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16
  17 //  This source code is part of the near-RT RIC (RAN Intelligent Controller)
  18 //  platform project (RICP).
  19
  20 package reader
  21
  22 import (
  23         "encoding/json"
  24         "fmt"
  25         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
  26         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
  27         "github.com/golang/protobuf/proto"
  28         "github.com/pkg/errors"
  29         "github.com/stretchr/testify/assert"
  30         "strconv"
  31         "testing"
  32         "time"
  33 )
  34
  35 func initSdlSyncStorageMock() (w RNibReader, sdlStorageMock *MockSdlSyncStorage) {
  36         sdlStorageMock = new(MockSdlSyncStorage)
  37         w = GetNewRNibReader(sdlStorageMock)
  38         return
  39 }
  40
  41 func TestGetRNibNamespace(t *testing.T) {
  42         ns := common.GetRNibNamespace()
  43         assert.Equal(t, "e2Manager", ns)
  44 }
  45
  46 func TestGetNodeB(t *testing.T) {
  47         name := "name"
  48         w, sdlInstanceMock := initSdlSyncStorageMock()
  49         nb := entities.NodebInfo{}
  50         nb.ConnectionStatus = 1
  51         nb.Ip = "localhost"
  52         nb.Port = 5656
  53         enb := entities.Enb{}
  54         cell := entities.ServedCellInfo{Tac: "tac"}
  55         enb.ServedCells = []*entities.ServedCellInfo{&cell}
  56         nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
  57         var e error
  58         data, err := proto.Marshal(&nb)
  59         if err != nil {
  60                 t.Errorf("#rNibReader_test.TestGetNb - Failed to marshal ENB instance. Error: %v", err)
  61         }
  62         redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
  63         if rNibErr != nil {
  64                 t.Errorf("#rNibReader_test.TestGetNodeB - failed to validate key parameter")
  65         }
  66         ret := map[string]interface{}{redisKey: string(data)}
  67         sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
  68         getNb, er := w.GetNodeb(name)
  69         assert.Nil(t, er)
  70         assert.Equal(t, getNb.Ip, nb.Ip)
  71         assert.Equal(t, getNb.Port, nb.Port)
  72         assert.Equal(t, getNb.ConnectionStatus, nb.ConnectionStatus)
  73         assert.Len(t, getNb.GetEnb().GetServedCells(), 1)
  74         assert.Equal(t, getNb.GetEnb().GetServedCells()[0].Tac, nb.GetEnb().GetServedCells()[0].Tac)
  75 }
  76
  77 func TestGetNodeBNotFoundFailure(t *testing.T) {
  78         name := "name"
  79         w, sdlInstanceMock := initSdlSyncStorageMock()
  80         var e error
  81         var ret map[string]interface{}
  82         redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
  83         if rNibErr != nil {
  84                 t.Errorf("#rNibReader_test.TestGetNodeBNotFoundFailure - failed to validate key parameter")
  85         }
  86         sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
  87         getNb, er := w.GetNodeb(name)
  88         assert.NotNil(t, er)
  89         assert.Nil(t, getNb)
  90         assert.IsType(t, &common.ResourceNotFoundError{}, er)
  91         assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.NodebInfo not found. Key: RAN:name", er.Error())
  92 }
  93
  94 func TestGetNodeBUnmarshalFailure(t *testing.T) {
  95         name := "name"
  96         w, sdlInstanceMock := initSdlSyncStorageMock()
  97         var e error
  98         ret := make(map[string]interface{}, 1)
  99         redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
 100         if rNibErr != nil {
 101                 t.Errorf("#rNibReader_test.TestGetNodeBUnmarshalFailure - failed to validate key parameter")
 102         }
 103         ret[redisKey] = "data"
 104         sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
 105         getNb, er := w.GetNodeb(name)
 106         assert.NotNil(t, er)
 107         assert.Nil(t, getNb)
 108         assert.IsType(t, &common.InternalError{}, er)
 109         assert.Contains(t,  er.Error(), "proto:")
 110 }
 111
 112 func TestGetNodeBSdlgoFailure(t *testing.T) {
 113         name := "name"
 114         errMsg := "expected Sdlgo error"
 115         errMsgExpected := "expected Sdlgo error"
 116         w, sdlInstanceMock := initSdlSyncStorageMock()
 117         e := errors.New(errMsg)
 118         var ret map[string]interface{}
 119         redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
 120         if rNibErr != nil {
 121                 t.Errorf("#rNibReader_test.TestGetNodeBSdlgoFailure - failed to validate key parameter")
 122         }
 123         sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
 124         getNb, er := w.GetNodeb(name)
 125         assert.NotNil(t, er)
 126         assert.Nil(t, getNb)
 127         assert.IsType(t, &common.InternalError{}, er)
 128         assert.EqualValues(t, errMsgExpected, er.Error())
 129 }
 130
 131 func TestGetNodeBCellsListEnb(t *testing.T) {
 132         name := "name"
 133         w, sdlInstanceMock := initSdlSyncStorageMock()
 134         nb := entities.NodebInfo{}
 135         nb.ConnectionStatus = 1
 136         nb.Ip = "localhost"
 137         nb.Port = 5656
 138         enb := entities.Enb{}
 139         cell := entities.ServedCellInfo{Tac: "tac"}
 140         enb.ServedCells = []*entities.ServedCellInfo{&cell}
 141         nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
 142         var e error
 143         data, err := proto.Marshal(&nb)
 144         if err != nil {
 145                 t.Errorf("#rNibReader_test.GetNodeBCellsList - Failed to marshal ENB instance. Error: %v", err)
 146         }
 147         redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
 148         if rNibErr != nil {
 149                 t.Errorf("#rNibReader_test.TestGetNodeBCellsListEnb - failed to validate key parameter")
 150         }
 151         ret := map[string]interface{}{redisKey: string(data)}
 152         sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
 153         cells, er := w.GetCellList(name)
 154         assert.Nil(t, er)
 155         assert.NotNil(t, cells)
 156         assert.Len(t, cells.GetServedCellInfos().GetServedCells(), 1)
 157         retCell := cells.GetServedCellInfos().GetServedCells()[0]
 158         assert.Equal(t, retCell.Tac, "tac")
 159 }
 160
 161 func TestGetNodeBCellsListGnb(t *testing.T) {
 162         name := "name"
 163         w, sdlInstanceMock := initSdlSyncStorageMock()
 164         nb := entities.NodebInfo{}
 165         nb.ConnectionStatus = 1
 166         nb.Ip = "localhost"
 167         nb.Port = 5656
 168         nb.NodeType = entities.Node_GNB
 169         gnb := entities.Gnb{}
 170         cell := entities.ServedNRCell{ServedNrCellInformation: &entities.ServedNRCellInformation{NrPci: 10}}
 171         gnb.ServedNrCells = []*entities.ServedNRCell{&cell}
 172         nb.Configuration = &entities.NodebInfo_Gnb{Gnb: &gnb}
 173         var e error
 174         data, err := proto.Marshal(&nb)
 175         if err != nil {
 176                 t.Errorf("#rNibReader_test.GetNodeBCellsList - Failed to marshal GNB instance. Error: %v", err)
 177         }
 178         redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
 179         if rNibErr != nil {
 180                 t.Errorf("#rNibReader_test.TestGetNodeBCellsListGnb - failed to validate key parameter")
 181         }
 182         ret := map[string]interface{}{redisKey: string(data)}
 183         sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
 184         cells, er := w.GetCellList(name)
 185         assert.Nil(t, er)
 186         assert.NotNil(t, cells)
 187         assert.Len(t, cells.GetServedNrCells().GetServedCells(), 1)
 188         retCell := cells.GetServedNrCells().GetServedCells()[0]
 189         assert.Equal(t, retCell.GetServedNrCellInformation().GetNrPci(), uint32(10))
 190 }
 191
 192 func TestGetNodeBCellsListNodeUnmarshalFailure(t *testing.T) {
 193         name := "name"
 194         w, sdlInstanceMock := initSdlSyncStorageMock()
 195         var e error
 196         ret := make(map[string]interface{}, 1)
 197         redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
 198         if rNibErr != nil {
 199                 t.Errorf("#rNibReader_test.TestGetNodeBCellsListNodeUnmarshalFailure - failed to validate key parameter")
 200         }
 201         ret[redisKey] = "data"
 202         sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
 203         cells, er := w.GetCellList(name)
 204         assert.NotNil(t, er)
 205         assert.Nil(t, cells)
 206         assert.IsType(t, &common.InternalError{}, er)
 207         assert.Contains(t,  er.Error(), "proto:")
 208 }
 209
 210 func TestGetNodeBCellsListNodeNotFoundFailure(t *testing.T) {
 211         name := "name"
 212         w, sdlInstanceMock := initSdlSyncStorageMock()
 213         var e error
 214         var ret map[string]interface{}
 215         redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
 216         if rNibErr != nil {
 217                 t.Errorf("#rNibReader_test.TestGetNodeBCellsListNodeNotFoundFailure - failed to validate key parameter")
 218         }
 219         sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
 220         cells, er := w.GetCellList(name)
 221         assert.NotNil(t, er)
 222         assert.Nil(t, cells)
 223         assert.IsType(t, &common.ResourceNotFoundError{}, er)
 224         assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.NodebInfo not found. Key: RAN:name", er.Error())
 225 }
 226
 227 func TestGetNodeBCellsListNotFoundFailureEnb(t *testing.T) {
 228         name := "name"
 229         w, sdlInstanceMock := initSdlSyncStorageMock()
 230         nb := entities.NodebInfo{}
 231         nb.ConnectionStatus = 1
 232         nb.Ip = "localhost"
 233         nb.Port = 5656
 234         enb := entities.Enb{}
 235         nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
 236         var e error
 237         data, err := proto.Marshal(&nb)
 238         if err != nil {
 239                 t.Errorf("#rNibReader_test.TestGetNbCellsListNotFoundFailure - Failed to marshal ENB instance. Error: %v", err)
 240         }
 241         redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
 242         if rNibErr != nil {
 243                 t.Errorf("#rNibReader_test.TestGetNodeBCellsListNotFoundFailureEnb - failed to validate key parameter")
 244         }
 245         ret := map[string]interface{}{redisKey: string(data)}
 246         sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
 247         _, er := w.GetCellList(name)
 248         assert.NotNil(t, er)
 249         assert.EqualValues(t, "#rNibReader.GetCellList - served cells not found. Responding node RAN name: name.", er.Error())
 250 }
 251
 252 func TestGetNodeBCellsListNotFoundFailureGnb(t *testing.T) {
 253         name := "name"
 254         w, sdlInstanceMock := initSdlSyncStorageMock()
 255         nb := entities.NodebInfo{}
 256         nb.ConnectionStatus = 1
 257         nb.Ip = "localhost"
 258         nb.Port = 5656
 259         gnb := entities.Gnb{}
 260         nb.Configuration = &entities.NodebInfo_Gnb{Gnb: &gnb}
 261         var e error
 262         data, err := proto.Marshal(&nb)
 263         if err != nil {
 264                 t.Errorf("#rNibReader_test.TestGetNodeBCellsListNotFoundFailureGnb - Failed to marshal ENB instance. Error: %v", err)
 265         }
 266         redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
 267         if rNibErr != nil {
 268                 t.Errorf("#rNibReader_test.TestGetNodeBCellsListNotFoundFailureGnb - failed to validate key parameter")
 269         }
 270         ret := map[string]interface{}{redisKey: string(data)}
 271         sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
 272         _, er := w.GetCellList(name)
 273         assert.NotNil(t, er)
 274         assert.EqualValues(t, "#rNibReader.GetCellList - served cells not found. Responding node RAN name: name.", er.Error())
 275 }
 276
 277 func TestGetListGnbIdsUnmarshalFailure(t *testing.T) {
 278         w, sdlInstanceMock := initSdlSyncStorageMock()
 279         var e error
 280         sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_GNB.String()).Return([]string{"data"}, e)
 281         ids, er := w.GetListGnbIds()
 282         assert.NotNil(t, er)
 283         assert.Nil(t, ids)
 284         assert.IsType(t, &common.InternalError{}, er)
 285         assert.Contains(t,  er.Error(), "proto:")
 286 }
 287
 288 func TestGetListGnbIdsSdlgoFailure(t *testing.T) {
 289         errMsg := "expected Sdlgo error"
 290         errMsgExpected := "expected Sdlgo error"
 291         w, sdlInstanceMock := initSdlSyncStorageMock()
 292         e := errors.New(errMsg)
 293         var data []string
 294         sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_GNB.String()).Return(data, e)
 295         ids, er := w.GetListGnbIds()
 296         assert.NotNil(t, er)
 297         assert.Nil(t, ids)
 298         assert.IsType(t, &common.InternalError{}, er)
 299         assert.EqualValues(t, errMsgExpected, er.Error())
 300 }
 301
 302 func TestGetListNodesIdsGnbSdlgoFailure(t *testing.T) {
 303         w, sdlInstanceMock := initSdlSyncStorageMock()
 304
 305         name := "name"
 306         plmnId := "02f829"
 307         nbId := "4a952a0a"
 308         nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
 309         var nilError error
 310         data, err := proto.Marshal(nbIdentity)
 311         if err != nil {
 312                 t.Errorf("#rNibReader_test.TestGetListNodesIdsGnbSdlgoFailure - Failed to marshal nodeb identity entity. Error: %v", err)
 313         }
 314         sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_ENB.String()).Return([]string{string(data)}, nilError)
 315
 316         errMsg := "expected Sdlgo error"
 317         errMsgExpected := "expected Sdlgo error"
 318         expectedError := errors.New(errMsg)
 319         var nilData []string
 320         sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_GNB.String()).Return(nilData, expectedError)
 321
 322         ids, er := w.GetListNodebIds()
 323         assert.NotNil(t, er)
 324         assert.Nil(t, ids)
 325         assert.IsType(t, &common.InternalError{}, er)
 326         assert.EqualValues(t, errMsgExpected, er.Error())
 327 }
 328
 329 func TestGetListNodesIdsEnbSdlgoFailure(t *testing.T) {
 330         w, sdlInstanceMock := initSdlSyncStorageMock()
 331
 332         name := "name"
 333         plmnId := "02f829"
 334         nbId := "4a952a0a"
 335         nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
 336         var nilError error
 337         data, err := proto.Marshal(nbIdentity)
 338         if err != nil {
 339                 t.Errorf("#rNibReader_test.TestGetListNodesIdsEnbSdlgoFailure - Failed to marshal nodeb identity entity. Error: %v", err)
 340         }
 341         sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_GNB.String()).Return([]string{string(data)}, nilError)
 342
 343         errMsg := "expected Sdlgo error"
 344         errMsgExpected := "expected Sdlgo error"
 345         expectedError := errors.New(errMsg)
 346         var nilData []string
 347         sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_ENB.String()).Return(nilData, expectedError)
 348
 349         ids, er := w.GetListNodebIds()
 350         assert.NotNil(t, er)
 351         assert.Nil(t, ids)
 352         assert.IsType(t, &common.InternalError{}, er)
 353         assert.EqualValues(t, errMsgExpected, er.Error())
 354 }
 355
 356 func TestGetListNodesIdsSuccess(t *testing.T) {
 357         w, sdlInstanceMock := initSdlSyncStorageMock()
 358         var nilError error
 359
 360         name := "name"
 361         plmnId := "02f829"
 362         nbId := "4a952a0a"
 363         nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
 364         data, err := proto.Marshal(nbIdentity)
 365         if err != nil {
 366                 t.Errorf("#rNibReader_test.TestGetListNodesIdsSuccess - Failed to marshal nodeb identity entity. Error: %v", err)
 367         }
 368
 369         name1 := "name1"
 370         plmnId1 := "02f845"
 371         nbId1 := "4a952a75"
 372         nbIdentity1 := &entities.NbIdentity{InventoryName: name1, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId1, NbId: nbId1}}
 373         data1, err := proto.Marshal(nbIdentity1)
 374         if err != nil {
 375                 t.Errorf("#rNibReader_test.TestGetListNodesIdsSuccess - Failed to marshal nodeb identity entity. Error: %v", err)
 376         }
 377
 378         sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_GNB.String()).Return([]string{string(data)}, nilError)
 379         sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_ENB.String()).Return([]string{string(data1)}, nilError)
 380
 381         ids, er := w.GetListNodebIds()
 382         assert.Nil(t, er)
 383         assert.NotNil(t, ids)
 384         assert.Len(t, ids, 2)
 385 }
 386
 387 func TestGetListEnbIdsUnmarshalFailure(t *testing.T) {
 388         w, sdlInstanceMock := initSdlSyncStorageMock()
 389         var e error
 390         sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_ENB.String()).Return([]string{"data"}, e)
 391         ids, er := w.GetListEnbIds()
 392         assert.NotNil(t, er)
 393         assert.Nil(t, ids)
 394         assert.IsType(t, &common.InternalError{}, er)
 395         assert.Contains(t,  er.Error(), "proto:")
 396 }
 397
 398 func TestGetListEnbIdsOneId(t *testing.T) {
 399         name := "name"
 400         plmnId := "02f829"
 401         nbId := "4a952a0a"
 402         w, sdlInstanceMock := initSdlSyncStorageMock()
 403         nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
 404         var e error
 405         data, err := proto.Marshal(nbIdentity)
 406         if err != nil {
 407                 t.Errorf("#rNibReader_test.TestGetListEnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
 408         }
 409         sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_ENB.String()).Return([]string{string(data)}, e)
 410         ids, er := w.GetListEnbIds()
 411         assert.Nil(t, er)
 412         assert.Len(t, ids, 1)
 413         assert.Equal(t, (ids)[0].GetInventoryName(), name)
 414         assert.Equal(t, (ids)[0].GetGlobalNbId().GetPlmnId(), nbIdentity.GetGlobalNbId().GetPlmnId())
 415         assert.Equal(t, (ids)[0].GetGlobalNbId().GetNbId(), nbIdentity.GetGlobalNbId().GetNbId())
 416 }
 417
 418 func TestGetListEnbIdsNoIds(t *testing.T) {
 419         w, sdlInstanceMock := initSdlSyncStorageMock()
 420         var e error
 421         sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_ENB.String()).Return([]string{}, e)
 422         ids, er := w.GetListEnbIds()
 423         assert.Nil(t, er)
 424         assert.Len(t, ids, 0)
 425 }
 426
 427 func TestGetListEnbIds(t *testing.T) {
 428         name := "name"
 429         plmnId := 0x02f829
 430         nbId := 0x4a952a0a
 431         listSize := 3
 432         w, sdlInstanceMock := initSdlSyncStorageMock()
 433         idsData := make([]string, listSize)
 434         idsEntities := make([]*entities.NbIdentity, listSize)
 435         for i := 0; i < listSize; i++ {
 436                 nbIdentity := &entities.NbIdentity{
 437                         InventoryName: name,
 438                         GlobalNbId: &entities.GlobalNbId{
 439                                 PlmnId: strconv.FormatInt(int64(plmnId+i), 16),
 440                                 NbId:   strconv.FormatInt(int64(nbId+i), 16),
 441                         },
 442                 }
 443                 data, err := proto.Marshal(nbIdentity)
 444                 if err != nil {
 445                         t.Errorf("#rNibReader_test.TestGetListEnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
 446                 }
 447                 idsData[i] = string(data)
 448                 idsEntities[i] = nbIdentity
 449         }
 450         var e error
 451         sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_ENB.String()).Return(idsData, e)
 452         ids, er := w.GetListEnbIds()
 453         assert.Nil(t, er)
 454         assert.Len(t, ids, listSize)
 455         for i, id := range ids {
 456                 assert.Equal(t, id.GetInventoryName(), name)
 457                 assert.Equal(t, id.GetGlobalNbId().GetPlmnId(), idsEntities[i].GetGlobalNbId().GetPlmnId())
 458                 assert.Equal(t, id.GetGlobalNbId().GetNbId(), idsEntities[i].GetGlobalNbId().GetNbId())
 459         }
 460 }
 461
 462 func TestGetListGnbIdsOneId(t *testing.T) {
 463         name := "name"
 464         plmnId := "02f829"
 465         nbId := "4a952a0a"
 466         w, sdlInstanceMock := initSdlSyncStorageMock()
 467         nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
 468         var e error
 469         data, err := proto.Marshal(nbIdentity)
 470         if err != nil {
 471                 t.Errorf("#rNibReader_test.TestGetListGnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
 472         }
 473         sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_GNB.String()).Return([]string{string(data)}, e)
 474         ids, er := w.GetListGnbIds()
 475         assert.Nil(t, er)
 476         assert.Len(t, ids, 1)
 477         assert.Equal(t, (ids)[0].GetInventoryName(), name)
 478         assert.Equal(t, (ids)[0].GetGlobalNbId().GetPlmnId(), nbIdentity.GetGlobalNbId().GetPlmnId())
 479         assert.Equal(t, (ids)[0].GetGlobalNbId().GetNbId(), nbIdentity.GetGlobalNbId().GetNbId())
 480 }
 481
 482 func TestGetListGnbIdsNoIds(t *testing.T) {
 483         w, sdlInstanceMock := initSdlSyncStorageMock()
 484         var e error
 485         sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_GNB.String()).Return([]string{}, e)
 486         ids, er := w.GetListGnbIds()
 487         assert.Nil(t, er)
 488         assert.Len(t, ids, 0)
 489 }
 490
 491 func TestGetListGnbIds(t *testing.T) {
 492         name := "name"
 493         plmnId := 0x02f829
 494         nbId := 0x4a952a0a
 495         listSize := 3
 496         w, sdlInstanceMock := initSdlSyncStorageMock()
 497         idsData := make([]string, listSize)
 498         idsEntities := make([]*entities.NbIdentity, listSize)
 499         for i := 0; i < listSize; i++ {
 500                 nbIdentity := &entities.NbIdentity{
 501                         InventoryName: name,
 502                         GlobalNbId: &entities.GlobalNbId{
 503                                 PlmnId: strconv.FormatInt(int64(plmnId+i), 16),
 504                                 NbId:   strconv.FormatInt(int64(nbId+i), 16),
 505                         },
 506                 }
 507                 data, err := proto.Marshal(nbIdentity)
 508                 if err != nil {
 509                         t.Errorf("#rNibReader_test.TestGetListGnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
 510                 }
 511                 idsData[i] = string(data)
 512                 idsEntities[i] = nbIdentity
 513         }
 514         var e error
 515         sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_GNB.String()).Return(idsData, e)
 516         ids, er := w.GetListGnbIds()
 517         assert.Nil(t, er)
 518         assert.Len(t, ids, listSize)
 519         for i, id := range ids {
 520                 assert.Equal(t, id.GetInventoryName(), name)
 521                 assert.Equal(t, id.GetGlobalNbId().GetPlmnId(), idsEntities[i].GetGlobalNbId().GetPlmnId())
 522                 assert.Equal(t, id.GetGlobalNbId().GetNbId(), idsEntities[i].GetGlobalNbId().GetNbId())
 523         }
 524 }
 525
 526 func TestGetListEnbIdsSdlgoFailure(t *testing.T) {
 527         errMsg := "expected Sdlgo error"
 528         errMsgExpected := "expected Sdlgo error"
 529         w, sdlInstanceMock := initSdlSyncStorageMock()
 530         e := errors.New(errMsg)
 531         var data []string
 532         sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_ENB.String()).Return(data, e)
 533         ids, er := w.GetListEnbIds()
 534         assert.NotNil(t, er)
 535         assert.Nil(t, ids)
 536         assert.IsType(t, &common.InternalError{}, er)
 537         assert.EqualValues(t, errMsgExpected, er.Error())
 538 }
 539
 540 func TestGetCountGnbListOneId(t *testing.T) {
 541         w, sdlInstanceMock := initSdlSyncStorageMock()
 542         var e error
 543         sdlInstanceMock.On("GroupSize", common.GetRNibNamespace(), entities.Node_GNB.String()).Return(1, e)
 544         count, er := w.GetCountGnbList()
 545         assert.Nil(t, er)
 546         assert.Equal(t, count, 1)
 547 }
 548
 549 func TestGetCountGnbList(t *testing.T) {
 550         w, sdlInstanceMock := initSdlSyncStorageMock()
 551         var e error
 552         sdlInstanceMock.On("GroupSize", common.GetRNibNamespace(), entities.Node_GNB.String()).Return(3, e)
 553         count, er := w.GetCountGnbList()
 554         assert.Nil(t, er)
 555         assert.Equal(t, count, 3)
 556 }
 557
 558 func TestGetCountGnbListSdlgoFailure(t *testing.T) {
 559         errMsg := "expected Sdlgo error"
 560         errMsgExpected := "expected Sdlgo error"
 561         w, sdlInstanceMock := initSdlSyncStorageMock()
 562         e := errors.New(errMsg)
 563         var count int
 564         sdlInstanceMock.On("GroupSize", common.GetRNibNamespace(), entities.Node_GNB.String()).Return(count, e)
 565         count, er := w.GetCountGnbList()
 566         assert.NotNil(t, er)
 567         assert.Equal(t, 0, count)
 568         assert.IsType(t, &common.InternalError{}, er)
 569         assert.EqualValues(t, errMsgExpected, er.Error())
 570 }
 571
 572 func TestGetCell(t *testing.T) {
 573         name := "name"
 574         var pci uint32 = 10
 575         w, sdlInstanceMock := initSdlSyncStorageMock()
 576         cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: &entities.ServedCellInfo{Pci: pci}}}
 577         cellData, err := proto.Marshal(&cellEntity)
 578         if err != nil {
 579                 t.Errorf("#rNibReader_test.TestGetCell - Failed to marshal Cell entity. Error: %v", err)
 580         }
 581         var e error
 582         key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
 583         if rNibErr != nil {
 584                 t.Errorf("#rNibReader_test.TestGetCell - failed to validate key parameter")
 585         }
 586         ret := map[string]interface{}{key: string(cellData)}
 587         sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
 588         cell, er := w.GetCell(name, pci)
 589         assert.Nil(t, er)
 590         assert.NotNil(t, cell)
 591         assert.Equal(t, cell.Type, entities.Cell_LTE_CELL)
 592         assert.NotNil(t, cell.GetServedCellInfo())
 593         assert.Equal(t, cell.GetServedCellInfo().GetPci(), pci)
 594 }
 595
 596 func TestGetCellNotFoundFailure(t *testing.T) {
 597         name := "name"
 598         var pci uint32
 599         w, sdlInstanceMock := initSdlSyncStorageMock()
 600         var e error
 601         var ret map[string]interface{}
 602         key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
 603         if rNibErr != nil {
 604                 t.Errorf("#rNibReader_test.TestGetCellNotFoundFailure - failed to validate key parameter")
 605         }
 606         sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
 607         cell, er := w.GetCell(name, pci)
 608         assert.NotNil(t, er)
 609         assert.Nil(t, cell)
 610         assert.IsType(t, &common.ResourceNotFoundError{}, er)
 611         assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.Cell not found. Key: PCI:name:00", er.Error())
 612 }
 613
 614 func TestGetCellUnmarshalFailure(t *testing.T) {
 615         name := "name"
 616         var pci uint32
 617         w, sdlInstanceMock := initSdlSyncStorageMock()
 618         var e error
 619         ret := make(map[string]interface{}, 1)
 620         key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
 621         if rNibErr != nil {
 622                 t.Errorf("#rNibReader_test.TestGetCellUnmarshalFailure - failed to validate key parameter")
 623         }
 624         ret[key] = "data"
 625         sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
 626         cell, er := w.GetCell(name, pci)
 627         assert.NotNil(t, er)
 628         assert.Nil(t, cell)
 629         assert.IsType(t, &common.InternalError{}, er)
 630         assert.Contains(t,  er.Error(), "proto:")
 631 }
 632
 633 func TestGetCellSdlgoFailure(t *testing.T) {
 634         name := "name"
 635         var pci uint32
 636         errMsg := "expected Sdlgo error"
 637         errMsgExpected := "expected Sdlgo error"
 638         w, sdlInstanceMock := initSdlSyncStorageMock()
 639         e := errors.New(errMsg)
 640         var ret map[string]interface{}
 641         key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
 642         if rNibErr != nil {
 643                 t.Errorf("#rNibReader_test.TestGetCellSdlgoFailure - failed to validate key parameter")
 644         }
 645         sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
 646         cell, er := w.GetCell(name, pci)
 647         assert.NotNil(t, er)
 648         assert.Nil(t, cell)
 649         assert.IsType(t, &common.InternalError{}, er)
 650         assert.EqualValues(t, errMsgExpected, er.Error())
 651 }
 652
 653 func TestGetNodebById(t *testing.T) {
 654         w, sdlInstanceMock := initSdlSyncStorageMock()
 655         nb := entities.NodebInfo{NodeType: entities.Node_ENB}
 656         nb.ConnectionStatus = 1
 657         nb.Ip = "localhost"
 658         nb.Port = 5656
 659         enb := entities.Enb{}
 660         cell := entities.ServedCellInfo{Tac: "tac"}
 661         enb.ServedCells = []*entities.ServedCellInfo{&cell}
 662         nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
 663         var e error
 664         data, err := proto.Marshal(&nb)
 665         if err != nil {
 666                 t.Errorf("#rNibReader_test.TestGetNodebById - Failed to marshal ENB instance. Error: %v", err)
 667         }
 668
 669         plmnId := "02f829"
 670         nbId := "4a952a0a"
 671         key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_ENB.String(), plmnId, nbId)
 672         if rNibErr != nil {
 673                 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
 674         }
 675         ret := map[string]interface{}{key: string(data)}
 676         sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
 677         globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
 678         getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
 679         assert.Nil(t, er)
 680         assert.Equal(t, getNb.Ip, nb.Ip)
 681         assert.Equal(t, getNb.Port, nb.Port)
 682         assert.Equal(t, getNb.ConnectionStatus, nb.ConnectionStatus)
 683         assert.Len(t, getNb.GetEnb().GetServedCells(), 1)
 684         assert.Equal(t, getNb.GetEnb().GetServedCells()[0].Tac, nb.GetEnb().GetServedCells()[0].Tac)
 685 }
 686
 687 func TestGetNodebByIdNotFoundFailureEnb(t *testing.T) {
 688         plmnId := "02f829"
 689         nbId := "4a952a0a"
 690         w, sdlInstanceMock := initSdlSyncStorageMock()
 691         var e error
 692         key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_ENB.String(), plmnId, nbId)
 693         if rNibErr != nil {
 694                 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
 695         }
 696         var ret map[string]interface{}
 697         sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
 698         globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
 699         getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
 700         assert.NotNil(t, er)
 701         assert.Nil(t, getNb)
 702         assert.IsType(t, &common.ResourceNotFoundError{}, er)
 703         assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.NodebInfo not found. Key: ENB:02f829:4a952a0a", er.Error())
 704 }
 705
 706 func TestGetNodebByIdNotFoundFailureGnb(t *testing.T) {
 707         plmnId := "02f829"
 708         nbId := "4a952a0a"
 709         w, sdlInstanceMock := initSdlSyncStorageMock()
 710         var e error
 711         key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_GNB.String(), plmnId, nbId)
 712         if rNibErr != nil {
 713                 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
 714         }
 715         var ret map[string]interface{}
 716         sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
 717         globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
 718         getNb, er := w.GetNodebByGlobalNbId(entities.Node_GNB, globalNbId)
 719         assert.NotNil(t, er)
 720         assert.Nil(t, getNb)
 721         assert.IsType(t, &common.ResourceNotFoundError{}, er)
 722         assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.NodebInfo not found. Key: GNB:02f829:4a952a0a", er.Error())
 723 }
 724
 725 func TestGetNodeByIdUnmarshalFailure(t *testing.T) {
 726         plmnId := "02f829"
 727         nbId := "4a952a0a"
 728         w, sdlInstanceMock := initSdlSyncStorageMock()
 729         key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_ENB.String(), plmnId, nbId)
 730         if rNibErr != nil {
 731                 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
 732         }
 733         var e error
 734         ret := make(map[string]interface{}, 1)
 735         ret[key] = "data"
 736         sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
 737         globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
 738         getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
 739         assert.NotNil(t, er)
 740         assert.Nil(t, getNb)
 741         assert.IsType(t, &common.InternalError{}, er)
 742         assert.Contains(t,  er.Error(), "proto:")
 743 }
 744
 745 func TestGetNodeByIdSdlgoFailure(t *testing.T) {
 746         plmnId := "02f829"
 747         nbId := "4a952a0a"
 748         errMsg := "expected Sdlgo error"
 749         errMsgExpected := "expected Sdlgo error"
 750         w, sdlInstanceMock := initSdlSyncStorageMock()
 751         key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_GNB.String(), plmnId, nbId)
 752         if rNibErr != nil {
 753                 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
 754         }
 755         e := errors.New(errMsg)
 756         var ret map[string]interface{}
 757         sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
 758         globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
 759         getNb, er := w.GetNodebByGlobalNbId(entities.Node_GNB, globalNbId)
 760         assert.NotNil(t, er)
 761         assert.Nil(t, getNb)
 762         assert.IsType(t, &common.InternalError{}, er)
 763         assert.EqualValues(t, errMsgExpected, er.Error())
 764 }
 765
 766 func TestGetCellById(t *testing.T) {
 767         cellId := "aaaa"
 768         var pci uint32 = 10
 769         w, sdlInstanceMock := initSdlSyncStorageMock()
 770         cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: &entities.ServedCellInfo{Pci: pci}}}
 771         cellData, err := proto.Marshal(&cellEntity)
 772         if err != nil {
 773                 t.Errorf("#rNibReader_test.TestGetCellById - Failed to marshal Cell entity. Error: %v", err)
 774         }
 775         var e error
 776         key, rNibErr := common.ValidateAndBuildCellIdKey(cellId)
 777         if rNibErr != nil {
 778                 t.Errorf("#rNibReader_test.TestGetCellById - failed to validate key parameter")
 779         }
 780         ret := map[string]interface{}{key: string(cellData)}
 781         sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
 782         cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
 783         assert.Nil(t, er)
 784         assert.NotNil(t, cell)
 785         assert.Equal(t, cell.Type, entities.Cell_LTE_CELL)
 786         assert.NotNil(t, cell.GetServedCellInfo())
 787         assert.Equal(t, cell.GetServedCellInfo().GetPci(), pci)
 788 }
 789
 790 func TestGetCellByIdNotFoundFailureEnb(t *testing.T) {
 791         cellId := "bbbb"
 792         w, sdlInstanceMock := initSdlSyncStorageMock()
 793         var e error
 794         var ret map[string]interface{}
 795         key, rNibErr := common.ValidateAndBuildCellIdKey(cellId)
 796         if rNibErr != nil {
 797                 t.Errorf("#rNibReader_test.TestGetCellByIdNotFoundFailure - failed to validate key parameter")
 798         }
 799         sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
 800         cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
 801         assert.NotNil(t, er)
 802         assert.Nil(t, cell)
 803         assert.IsType(t, &common.ResourceNotFoundError{}, er)
 804         assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.Cell not found. Key: CELL:bbbb", er.Error())
 805 }
 806
 807 func TestGetCellByIdNotFoundFailureGnb(t *testing.T) {
 808         cellId := "bbbb"
 809         w, sdlInstanceMock := initSdlSyncStorageMock()
 810         var e error
 811         var ret map[string]interface{}
 812         key, rNibErr := common.ValidateAndBuildNrCellIdKey(cellId)
 813         if rNibErr != nil {
 814                 t.Errorf("#rNibReader_test.TestGetCellByIdNotFoundFailure - failed to validate key parameter")
 815         }
 816         sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
 817         cell, er := w.GetCellById(entities.Cell_NR_CELL, cellId)
 818         assert.NotNil(t, er)
 819         assert.Nil(t, cell)
 820         assert.IsType(t, &common.ResourceNotFoundError{}, er)
 821         assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.Cell not found. Key: NRCELL:bbbb", er.Error())
 822 }
 823
 824 func TestGetCellByIdTypeValidationFailure(t *testing.T) {
 825         cellId := "dddd"
 826         w, _ := initSdlSyncStorageMock()
 827         cell, er := w.GetCellById(5, cellId)
 828         assert.NotNil(t, er)
 829         assert.Nil(t, cell)
 830         assert.IsType(t, &common.ValidationError{}, er)
 831         assert.EqualValues(t, "#rNibReader.GetCellById - invalid cell type: 5", er.Error())
 832 }
 833
 834 func TestGetCellByIdValidationFailureGnb(t *testing.T) {
 835         cellId := ""
 836         w, _ := initSdlSyncStorageMock()
 837         cell, er := w.GetCellById(entities.Cell_NR_CELL, cellId)
 838         assert.NotNil(t, er)
 839         assert.Nil(t, cell)
 840         assert.IsType(t, &common.ValidationError{}, er)
 841         assert.EqualValues(t, "#utils.ValidateAndBuildNrCellIdKey - an empty cell id received", er.Error())
 842 }
 843
 844 func TestGetCellByIdValidationFailureEnb(t *testing.T) {
 845         cellId := ""
 846         w, _ := initSdlSyncStorageMock()
 847         cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
 848         assert.NotNil(t, er)
 849         assert.Nil(t, cell)
 850         assert.IsType(t, &common.ValidationError{}, er)
 851         assert.EqualValues(t, "#utils.ValidateAndBuildCellIdKey - an empty cell id received", er.Error())
 852 }
 853
 854 func TestGetRanLoadInformation(t *testing.T) {
 855         name := "name"
 856         w, sdlInstanceMock := initSdlSyncStorageMock()
 857         loadInfo := generateRanLoadInformation()
 858         var e error
 859         data, err := proto.Marshal(loadInfo)
 860         if err != nil {
 861                 t.Errorf("#rNibReader_test.TestGetRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
 862         }
 863         redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
 864         if rNibErr != nil {
 865                 t.Errorf("#rNibReader_test.TestGetRanLoadInformationNotFoundFailure - failed to validate key parameter")
 866         }
 867         ret := map[string]interface{}{redisKey: string(data)}
 868         sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
 869         getLoadInfo, er := w.GetRanLoadInformation(name)
 870         assert.Nil(t, er)
 871         assert.NotNil(t, getLoadInfo)
 872         expected, err := json.Marshal(loadInfo)
 873         if err != nil {
 874                 t.Errorf("#rNibReader_test.TestGetRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
 875         }
 876         actual, err := json.Marshal(getLoadInfo)
 877         if err != nil {
 878                 t.Errorf("#rNibReader_test.TestGetRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
 879         }
 880         assert.EqualValues(t, expected, actual)
 881 }
 882
 883 func TestGetRanLoadInformationValidationFailure(t *testing.T) {
 884         name := ""
 885         w, _ := initSdlSyncStorageMock()
 886         getNb, er := w.GetRanLoadInformation(name)
 887         assert.NotNil(t, er)
 888         assert.Nil(t, getNb)
 889         assert.IsType(t, &common.ValidationError{}, er)
 890         assert.EqualValues(t, "#utils.ValidateAndBuildRanLoadInformationKey - an empty inventory name received", er.Error())
 891 }
 892
 893 func TestGetRanLoadInformationNotFoundFailure(t *testing.T) {
 894         name := "name"
 895         w, sdlInstanceMock := initSdlSyncStorageMock()
 896         var e error
 897         var ret map[string]interface{}
 898         redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
 899         if rNibErr != nil {
 900                 t.Errorf("#rNibReader_test.TestGetRanLoadInformationNotFoundFailure - failed to validate key parameter")
 901         }
 902         sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
 903         getNb, er := w.GetRanLoadInformation(name)
 904         assert.NotNil(t, er)
 905         assert.Nil(t, getNb)
 906         assert.IsType(t, &common.ResourceNotFoundError{}, er)
 907         assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.RanLoadInformation not found. Key: LOAD:name", er.Error())
 908 }
 909
 910 func TestGetRanLoadInformationUnmarshalFailure(t *testing.T) {
 911         name := "name"
 912         w, sdlInstanceMock := initSdlSyncStorageMock()
 913         var e error
 914         ret := make(map[string]interface{}, 1)
 915         redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
 916         if rNibErr != nil {
 917                 t.Errorf("#rNibReader_test.TestGetRanLoadInformationUnmarshalFailure - failed to validate key parameter")
 918         }
 919         ret[redisKey] = "data"
 920         sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
 921         getNb, er := w.GetRanLoadInformation(name)
 922         assert.NotNil(t, er)
 923         assert.Nil(t, getNb)
 924         assert.IsType(t, &common.InternalError{}, er)
 925         assert.Contains(t,  er.Error(), "proto:")
 926 }
 927
 928 func TestGetRanLoadInformationSdlgoFailure(t *testing.T) {
 929         name := "name"
 930         errMsg := "expected Sdlgo error"
 931         errMsgExpected := "expected Sdlgo error"
 932         w, sdlInstanceMock := initSdlSyncStorageMock()
 933         e := errors.New(errMsg)
 934         var ret map[string]interface{}
 935         redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
 936         if rNibErr != nil {
 937                 t.Errorf("#rNibReader_test.TestGetRanLoadInformationSdlgoFailure - failed to validate key parameter")
 938         }
 939         sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
 940         getNb, er := w.GetRanLoadInformation(name)
 941         assert.NotNil(t, er)
 942         assert.Nil(t, getNb)
 943         assert.IsType(t, &common.InternalError{}, er)
 944         assert.EqualValues(t, errMsgExpected, er.Error())
 945 }
 946
 947 func generateCellLoadInformation() *entities.CellLoadInformation {
 948         cellLoadInformation := entities.CellLoadInformation{}
 949
 950         cellLoadInformation.CellId = "123"
 951
 952         ulInterferenceOverloadIndication := entities.UlInterferenceOverloadIndication_HIGH_INTERFERENCE
 953         cellLoadInformation.UlInterferenceOverloadIndications = []entities.UlInterferenceOverloadIndication{ulInterferenceOverloadIndication}
 954
 955         ulHighInterferenceInformation := entities.UlHighInterferenceInformation{
 956                 TargetCellId:                 "456",
 957                 UlHighInterferenceIndication: "xxx",
 958         }
 959
 960         cellLoadInformation.UlHighInterferenceInfos = []*entities.UlHighInterferenceInformation{&ulHighInterferenceInformation}
 961
 962         cellLoadInformation.RelativeNarrowbandTxPower = &entities.RelativeNarrowbandTxPower{
 963                 RntpPerPrb:                       "xxx",
 964                 RntpThreshold:                    entities.RntpThreshold_NEG_4,
 965                 NumberOfCellSpecificAntennaPorts: entities.NumberOfCellSpecificAntennaPorts_V1_ANT_PRT,
 966                 PB:                               1,
 967                 PdcchInterferenceImpact:          2,
 968                 EnhancedRntp: &entities.EnhancedRntp{
 969                         EnhancedRntpBitmap:     "xxx",
 970                         RntpHighPowerThreshold: entities.RntpThreshold_NEG_2,
 971                         EnhancedRntpStartTime:  &entities.StartTime{StartSfn: 500, StartSubframeNumber: 5},
 972                 },
 973         }
 974
 975         cellLoadInformation.AbsInformation = &entities.AbsInformation{
 976                 Mode:                             entities.AbsInformationMode_ABS_INFO_FDD,
 977                 AbsPatternInfo:                   "xxx",
 978                 NumberOfCellSpecificAntennaPorts: entities.NumberOfCellSpecificAntennaPorts_V2_ANT_PRT,
 979                 MeasurementSubset:                "xxx",
 980         }
 981
 982         cellLoadInformation.InvokeIndication = entities.InvokeIndication_ABS_INFORMATION
 983
 984         cellLoadInformation.ExtendedUlInterferenceOverloadInfo = &entities.ExtendedUlInterferenceOverloadInfo{
 985                 AssociatedSubframes:                       "xxx",
 986                 ExtendedUlInterferenceOverloadIndications: cellLoadInformation.UlInterferenceOverloadIndications,
 987         }
 988
 989         compInformationItem := &entities.CompInformationItem{
 990                 CompHypothesisSets: []*entities.CompHypothesisSet{{CellId: "789", CompHypothesis: "xxx"}},
 991                 BenefitMetric:      50,
 992         }
 993
 994         cellLoadInformation.CompInformation = &entities.CompInformation{
 995                 CompInformationItems:     []*entities.CompInformationItem{compInformationItem},
 996                 CompInformationStartTime: &entities.StartTime{StartSfn: 123, StartSubframeNumber: 456},
 997         }
 998
 999         cellLoadInformation.DynamicDlTransmissionInformation = &entities.DynamicDlTransmissionInformation{
1000                 State:             entities.NaicsState_NAICS_ACTIVE,
1001                 TransmissionModes: "xxx",
1002                 PB:                2,
1003                 PAList:            []entities.PA{entities.PA_DB_NEG_3},
1004         }
1005
1006         return &cellLoadInformation
1007 }
1008
1009 func generateRanLoadInformation() *entities.RanLoadInformation {
1010         ranLoadInformation := entities.RanLoadInformation{}
1011
1012         ranLoadInformation.LoadTimestamp = uint64(time.Now().UnixNano())
1013
1014         cellLoadInformation := generateCellLoadInformation()
1015         ranLoadInformation.CellLoadInfos = []*entities.CellLoadInformation{cellLoadInformation}
1016
1017         return &ranLoadInformation
1018 }
1019
1020 func TestGetE2TInstanceSuccess(t *testing.T) {
1021         address := "10.10.2.15:9800"
1022         redisKey, validationErr := common.ValidateAndBuildE2TInstanceKey(address)
1023
1024         if validationErr != nil {
1025                 t.Errorf("#rNibReader_test.TestGetE2TInstanceSuccess - Failed to build E2T Instance key. Error: %v", validationErr)
1026         }
1027
1028         w, sdlInstanceMock := initSdlSyncStorageMock()
1029
1030         e2tInstance := generateE2tInstance(address)
1031         data, err := json.Marshal(e2tInstance)
1032
1033         if err != nil {
1034                 t.Errorf("#rNibReader_test.TestGetE2TInstanceSuccess - Failed to marshal E2tInstance entity. Error: %v", err)
1035         }
1036
1037         var e error
1038         ret := map[string]interface{}{redisKey: string(data)}
1039         sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
1040
1041         res, rNibErr := w.GetE2TInstance(address)
1042         assert.Nil(t, rNibErr)
1043         assert.Equal(t, e2tInstance, res)
1044 }
1045
1046 func TestUnmarshal(t *testing.T) {
1047         e2tInstance := generateE2tInstance("10.0.2.15:5555")
1048         marshaled, _ := json.Marshal(e2tInstance)
1049         m := map[string]interface{}{
1050                 "whatever": string(marshaled),
1051         }
1052         var entity entities.E2TInstance
1053         err := json.Unmarshal([]byte(m["whatever"].(string)), &entity)
1054         assert.Nil(t, err)
1055 }
1056
1057 func TestGetE2TInstanceEmptyAddressFailure(t *testing.T) {
1058         w, _ := initSdlSyncStorageMock()
1059         res, err := w.GetE2TInstance("")
1060         assert.NotNil(t, err)
1061         assert.IsType(t, &common.ValidationError{}, err)
1062         assert.Nil(t, res)
1063 }
1064
1065 func TestGetE2TInstanceSdlError(t *testing.T) {
1066         address := "10.10.2.15:9800"
1067         redisKey, validationErr := common.ValidateAndBuildE2TInstanceKey(address)
1068
1069         if validationErr != nil {
1070                 t.Errorf("#rNibReader_test.TestGetE2TInstanceSuccess - Failed to build E2T Instance key. Error: %v", validationErr)
1071         }
1072
1073         w, sdlInstanceMock := initSdlSyncStorageMock()
1074
1075         expectedErr := errors.New("expected error")
1076         var ret map[string]interface{}
1077         sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, expectedErr)
1078
1079         res, rNibErr := w.GetE2TInstance(address)
1080         assert.NotNil(t, rNibErr)
1081         assert.Nil(t, res)
1082 }
1083
1084 func generateE2tInstance(address string) *entities.E2TInstance {
1085         e2tInstance := entities.NewE2TInstance(address,"")
1086         e2tInstance.AssociatedRanList = []string{"test1", "test2"}
1087         e2tInstance.DeletionTimestamp = time.Now().UnixNano()
1088         return e2tInstance
1089 }
1090
1091 func TestGetE2TAddressesSdlError(t *testing.T) {
1092         w, sdlInstanceMock := initSdlSyncStorageMock()
1093
1094         expectedErr := errors.New("expected error")
1095         var ret map[string]interface{}
1096         sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{E2TAddressesKey}).Return(ret, expectedErr)
1097
1098         res, rNibErr := w.GetE2TAddresses()
1099         assert.NotNil(t, rNibErr)
1100         assert.Nil(t, res)
1101 }
1102
1103 func TestGetE2TAddressesSuccess(t *testing.T) {
1104         address := "10.10.2.15:9800"
1105         w, sdlInstanceMock := initSdlSyncStorageMock()
1106
1107         e2tAddresses := []string{address}
1108         data, err := json.Marshal(e2tAddresses)
1109
1110         if err != nil {
1111                 t.Errorf("#rNibReader_test.TestGetE2TInfoListSuccess - Failed to marshal E2TInfoList. Error: %v", err)
1112         }
1113
1114         var e error
1115         ret := map[string]interface{}{E2TAddressesKey: string(data)}
1116         sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{E2TAddressesKey}).Return(ret, e)
1117
1118         res, rNibErr := w.GetE2TAddresses()
1119         assert.Nil(t, rNibErr)
1120         assert.Equal(t, e2tAddresses, res)
1121 }
1122
1123 func TestGetE2TInstancesSuccess(t *testing.T) {
1124         address := "10.10.2.15:9800"
1125         address2 := "10.10.2.16:9800"
1126         redisKey, _ := common.ValidateAndBuildE2TInstanceKey(address)
1127         redisKey2, _ := common.ValidateAndBuildE2TInstanceKey(address2)
1128
1129         w, sdlInstanceMock := initSdlSyncStorageMock()
1130
1131         e2tInstance1 := generateE2tInstance(address)
1132         e2tInstance2 := generateE2tInstance(address2)
1133
1134         data1, _ := json.Marshal(e2tInstance1)
1135         data2, _ := json.Marshal(e2tInstance2)
1136
1137         var e error
1138         ret := map[string]interface{}{redisKey: string(data1), redisKey2: string(data2)}
1139         sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey, redisKey2}).Return(ret, e)
1140
1141         res, err := w.GetE2TInstances([]string{address, address2})
1142         assert.Nil(t, err)
1143         assert.Equal(t, []*entities.E2TInstance{e2tInstance1, e2tInstance2}, res)
1144 }
1145
1146 func TestGetE2TInstancesUnmarhalPartialSuccess(t *testing.T) {
1147         address := "10.10.2.15:9800"
1148         address2 := "10.10.2.16:9800"
1149         redisKey, _ := common.ValidateAndBuildE2TInstanceKey(address)
1150         redisKey2, _ := common.ValidateAndBuildE2TInstanceKey(address2)
1151
1152         w, sdlInstanceMock := initSdlSyncStorageMock()
1153
1154         e2tInstance1 := generateE2tInstance(address)
1155         data1, _ := json.Marshal(e2tInstance1)
1156
1157         var e error
1158         ret := map[string]interface{}{redisKey: string(data1), redisKey2: "abc"}
1159         sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey, redisKey2}).Return(ret, e)
1160
1161         res, err := w.GetE2TInstances([]string{address, address2})
1162         assert.Nil(t, err)
1163         assert.Equal(t, []*entities.E2TInstance{e2tInstance1}, res)
1164 }
1165
1166 func TestGetE2TInstancesSdlFailure(t *testing.T) {
1167         address := "10.10.2.15:9800"
1168         address2 := "10.10.2.16:9800"
1169         redisKey, _ := common.ValidateAndBuildE2TInstanceKey(address)
1170         redisKey2, _ := common.ValidateAndBuildE2TInstanceKey(address2)
1171
1172         w, sdlInstanceMock := initSdlSyncStorageMock()
1173
1174         sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey, redisKey2}).Return(map[string]interface{}{}, fmt.Errorf(""))
1175         _, err := w.GetE2TInstances([]string{address, address2})
1176         assert.IsType(t, &common.InternalError{}, err)
1177 }
1178
1179 func TestGetE2TInstancesEmptyData(t *testing.T) {
1180         address := "10.10.2.15:9800"
1181         address2 := "10.10.2.16:9800"
1182         redisKey, _ := common.ValidateAndBuildE2TInstanceKey(address)
1183         redisKey2, _ := common.ValidateAndBuildE2TInstanceKey(address2)
1184
1185         w, sdlInstanceMock := initSdlSyncStorageMock()
1186
1187         sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey, redisKey2}).Return(map[string]interface{}{}, nil)
1188         _, err := w.GetE2TInstances([]string{address, address2})
1189         assert.IsType(t, &common.ResourceNotFoundError{}, err)
1190 }
1191
1192 func TestGetGeneralConfiguration(t *testing.T) {
1193
1194         key := common.BuildGeneralConfigurationKey()
1195         w, sdlInstanceMock := initSdlSyncStorageMock()
1196
1197         configurationData := "{\"enableRic\":true}"
1198         sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(map[string]interface{}{key: configurationData}, nil)
1199
1200         res, rNibErr := w.GetGeneralConfiguration()
1201         assert.Nil(t, rNibErr)
1202         assert.Equal(t, true, res.EnableRic)
1203 }
1204
1205 func TestGetGeneralConfigurationNotFound(t *testing.T) {
1206
1207         key := common.BuildGeneralConfigurationKey()
1208         w, sdlInstanceMock := initSdlSyncStorageMock()
1209
1210         sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(map[string]interface{}{}, nil)
1211
1212         _, rNibErr := w.GetGeneralConfiguration()
1213
1214         assert.NotNil(t, rNibErr)
1215         assert.Equal(t, "#rNibReader.getByKeyAndUnmarshalJson - entity of type *entities.GeneralConfiguration not found. Key: GENERAL", rNibErr.Error())
1216 }
1217
1218 func TestGetGeneralConfigurationSdlFailure(t *testing.T) {
1219
1220         key := common.BuildGeneralConfigurationKey()
1221         w, sdlInstanceMock := initSdlSyncStorageMock()
1222
1223         sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(map[string]interface{}{}, fmt.Errorf("sdl error"))
1224
1225         _, rNibErr := w.GetGeneralConfiguration()
1226
1227         assert.NotNil(t, rNibErr)
1228
1229         assert.Equal(t, "sdl error", rNibErr.Error())
1230 }
1231
1232 func TestGetGeneralConfigurationUnmarshalError(t *testing.T) {
1233
1234         key := common.BuildGeneralConfigurationKey()
1235         w, sdlInstanceMock := initSdlSyncStorageMock()
1236
1237         configurationData := "{\"enableRic :true}"
1238         sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(map[string]interface{}{key: configurationData}, nil)
1239
1240         _, rNibErr := w.GetGeneralConfiguration()
1241
1242         assert.NotNil(t, rNibErr)
1243         assert.Equal(t, rNibErr.Error(), "unexpected end of JSON input")
1244 }
1245
1246 func TestGetRanFunctionDefinition(t *testing.T) {
1247     name := "name"
1248     oid := "1.3.6.1.4.1.1.2.2.2"
1249     w, sdlInstanceMock := initSdlSyncStorageMock()
1250     nb := entities.NodebInfo{}
1251     nb.ConnectionStatus = 1
1252     nb.Ip = "localhost"
1253     nb.Port = 5656
1254     enb := entities.Enb{}
1255     cell := entities.ServedCellInfo{Tac: "tac"}
1256     enb.ServedCells = []*entities.ServedCellInfo{&cell}
1257     nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
1258     var e error
1259     data, err := proto.Marshal(&nb)
1260     if err != nil {
1261         t.Errorf("#rNibReader_test.GetRanFunctionDefinition - Failed to marshal ENB instance. Error: %v", err)
1262     }
1263     redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
1264     if rNibErr != nil {
1265         t.Errorf("#rNibReader_test.TestRanFunctionDefinition - failed to validate key parameter")
1266     }
1267     ret := map[string]interface{}{redisKey: string(data)}
1268     sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
1269     ranFuncs, er := w.GetRanFunctionDefinition(name, oid)
1270     assert.IsType(t, &common.ResourceNotFoundError{}, er)
1271     assert.Nil(t, ranFuncs)
1272 }
1273
1274 //integration tests
1275 //
1276 //func TestGetEnbInteg(t *testing.T){
1277 //      name := "nameEnb1"
1278 //      Init("namespace", 1)
1279 //      w := GetRNibReader()
1280 //      nb, err := w.GetNodeb(name)
1281 //      if err != nil{
1282 //              fmt.Println(err)
1283 //      } else {
1284 //              fmt.Printf("#TestGetEnbInteg - responding node type: %v\n", nb)
1285 //      }
1286 //}
1287 //
1288 //func TestGetEnbCellsInteg(t *testing.T){
1289 //      name := "nameEnb1"
1290 //      Init("namespace", 1)
1291 //      w := GetRNibReader()
1292 //      cells, err := w.GetCellList(name)
1293 //      if err != nil{
1294 //              fmt.Println(err)
1295 //      } else if cells != nil{
1296 //              for _, cell := range cells.GetServedCellInfos().ServedCells{
1297 //                      fmt.Printf("responding node type Cell: %v\n", *cell)
1298 //              }
1299 //      }
1300 //}
1301 //
1302 //func TestGetGnbInteg(t *testing.T){
1303 //      name := "nameGnb1"
1304 //      Init("namespace", 1)
1305 //      w := GetRNibReader()
1306 //      nb, err := w.GetNodeb(name)
1307 //      if err != nil{
1308 //              fmt.Println(err)
1309 //      } else {
1310 //              fmt.Printf("#TestGetGnbInteg - responding node type: %v\n", nb)
1311 //      }
1312 //}
1313 //
1314 //func TestGetGnbCellsInteg(t *testing.T){
1315 //      name := "nameGnb1"
1316 //      Init("namespace", 1)
1317 //      w := GetRNibReader()
1318 //      cells, err := w.GetCellList(name)
1319 //      if err != nil{
1320 //              fmt.Println(err)
1321 //      } else if cells != nil{
1322 //              for _, cell := range cells.GetServedNrCells().ServedCells{
1323 //                      fmt.Printf("responding node type NR Cell: %v\n", *cell)
1324 //              }
1325 //      }
1326 //}
1327 //
1328 //func TestGetListEnbIdsInteg(t *testing.T) {
1329 //      Init("namespace", 1)
1330 //      w := GetRNibReader()
1331 //      ids, err := w.GetListEnbIds()
1332 //      if err != nil{
1333 //              fmt.Println(err)
1334 //      } else {
1335 //              for _, id := range ids{
1336 //                      fmt.Printf("#TestGetListEnbIdsInteg - ENB ID: %s\n", id)
1337 //              }
1338 //      }
1339 //}
1340 //
1341 //func TestGetListGnbIdsInteg(t *testing.T) {
1342 //      Init("namespace", 1)
1343 //      w := GetRNibReader()
1344 //      ids, err := w.GetListGnbIds()
1345 //      if err != nil{
1346 //              fmt.Println(err)
1347 //      } else {
1348 //              for _, id := range ids{
1349 //                      fmt.Printf("#TestGetListGnbIdsInteg - GNB ID: %s\n", id)
1350 //              }
1351 //      }
1352 //}
1353 //
1354 //func TestGetCountGnbListInteg(t *testing.T) {
1355 //      Init("namespace", 1)
1356 //      w := GetRNibReader()
1357 //      count, err := w.GetCountGnbList()
1358 //      if err != nil{
1359 //              fmt.Println(err)
1360 //      } else {
1361 //              fmt.Printf("#TestGetCountGnbListInteg - count Gnb list: %d\n", count)
1362 //      }
1363 //}
1364 //
1365 //func TestGetGnbCellInteg(t *testing.T){
1366 //      name := "nameGnb7"
1367 //      pci := 0x0a
1368 //      Init("namespace", 1)
1369 //      w := GetRNibReader()
1370 //      cell, err := w.GetCell(name, uint32(pci))
1371 //      if err != nil{
1372 //              fmt.Println(err)
1373 //      } else if cell != nil{
1374 //              fmt.Printf("responding node type NR Cell: %v\n", cell.GetServedNrCell())
1375 //      }
1376 //}
1377 //
1378 //func TestGetEnbCellInteg(t *testing.T) {
1379 //      name := "nameEnb1"
1380 //      pci := 0x22
1381 //      Init("namespace", 1)
1382 //      w := GetRNibReader()
1383 //      cell, err := w.GetCell(name, uint32(pci))
1384 //      if err != nil {
1385 //              fmt.Println(err)
1386 //      } else if cell != nil {
1387 //              fmt.Printf("responding node type LTE Cell: %v\n", cell.GetServedCellInfo())
1388 //      }
1389 //}
1390 //
1391 //func TestGetEnbCellByIdInteg(t *testing.T){
1392 //      Init("namespace", 1)
1393 //      w := GetRNibReader()
1394 //      cell, err := w.GetCellById(entities.Cell_NR_CELL, "45d")
1395 //      if err != nil{
1396 //              fmt.Println(err)
1397 //      } else if cell != nil{
1398 //              fmt.Printf("responding node type NR Cell: %v\n", cell.GetServedNrCell())
1399 //      }
1400 //}
1401 //
1402 //func TestGetListNbIdsInteg(t *testing.T) {
1403 //      Init("e2Manager", 1)
1404 //      w := GetRNibReader()
1405 //      ids, err := w.GetListNodebIds()
1406 //      if err != nil{
1407 //              fmt.Println(err)
1408 //      } else {
1409 //              for _, id := range ids{
1410 //                      fmt.Printf("#TestGetListGnbIdsInteg - NB ID: %s\n", id)
1411 //              }
1412 //      }
1413 //}
1414 //
1415 //func TestGetRanLoadInformationInteg(t *testing.T){
1416 //      Init("e2Manager", 1)
1417 //      w := GetRNibReader()
1418 //      ranLoadInformation, err := w.GetRanLoadInformation("ran_integ")
1419 //      if err != nil{
1420 //              t.Errorf("#rNibReader_test.TestGetRanLoadInformationInteg - Failed to get RanLoadInformation entity. Error: %v", err)
1421 //      }
1422 //      assert.NotNil(t, ranLoadInformation)
1423 //      fmt.Printf("#rNibReader_test.TestGetRanLoadInformationInteg - GNB ID: %s\n", ranLoadInformation)
1424 //}
1425
1426 //func TestGetE2TInstancesInteg(t *testing.T) {
1427 //      db := sdlgo.NewDatabase()
1428 //      sdl := sdlgo.NewSdlInstance("e2Manager", db)
1429 //      rnibReader := GetRNibReader(sdl)
1430 //      e2tInstances, _ := rnibReader.GetE2TInstances([]string{"e2t.att.com:38000","whatever"})
1431 //      assert.Len(t, e2tInstances, 1)
1432 //}