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 package reader
  18
  19 import (
  20         "errors"
  21         "gerrit.ranco-dev-tools.eastus.cloudapp.azure.com/ric-plt/nodeb-rnib.git/common"
  22         "gerrit.ranco-dev-tools.eastus.cloudapp.azure.com/ric-plt/nodeb-rnib.git/entities"
  23         "github.com/golang/protobuf/proto"
  24         "github.com/stretchr/testify/assert"
  25         "testing"
  26 )
  27
  28 var namespace = "namespace"
  29
  30 func TestInit(t *testing.T) {
  31         readerPool = nil
  32         Init("", 1)
  33         assert.NotNil(t, readerPool)
  34         assert.NotNil(t, readerPool.New)
  35         assert.NotNil(t, readerPool.Destroy)
  36         available, created := readerPool.Stats()
  37         assert.Equal(t, 0, available, "number of available objects in the readerPool should be 0")
  38         assert.Equal(t, 0, created, "number of created objects in the readerPool should be 0")
  39 }
  40
  41 func TestInitPool(t *testing.T) {
  42         readerPool = nil
  43         sdlInstanceMock := new(MockSdlInstance)
  44         initPool(1, func() interface{} {
  45                 sdlI := common.ISdlInstance(sdlInstanceMock)
  46                 return &rNibReaderInstance{sdl: &sdlI, namespace: namespace}
  47         },
  48                 func(obj interface{}) {
  49                 },
  50         )
  51         assert.NotNil(t, readerPool)
  52         assert.NotNil(t, readerPool.New)
  53         assert.NotNil(t, readerPool.Destroy)
  54         available, created := readerPool.Stats()
  55         assert.Equal(t, 0, available, "number of available objects in the readerPool should be 0")
  56         assert.Equal(t, 0, created, "number of created objects in the readerPool should be 0")
  57 }
  58
  59 func initSdlInstanceMock(namespace string, poolSize int) * MockSdlInstance {
  60         sdlInstanceMock := new( MockSdlInstance)
  61         initPool(poolSize, func() interface{} {
  62                 sdlI := common.ISdlInstance(sdlInstanceMock)
  63                 return &rNibReaderInstance{sdl: &sdlI, namespace: namespace}
  64         },
  65                 func(obj interface{}) {
  66                 },
  67         )
  68         return sdlInstanceMock
  69 }
  70
  71 func TestGetNodeB(t *testing.T) {
  72         name := "name"
  73         readerPool = nil
  74         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
  75         w := GetRNibReader()
  76         nb := entities.NodebInfo{}
  77         nb.ConnectionStatus = 1
  78         nb.Ip = "localhost"
  79         nb.Port = 5656
  80         enb := entities.Enb{}
  81         cell := entities.ServedCellInfo{Tac:"tac"}
  82         enb.ServedCells = []*entities.ServedCellInfo{&cell}
  83         nb.Configuration = &entities.NodebInfo_Enb{Enb:&enb}
  84         var e error
  85         data, err := proto.Marshal(&nb)
  86         if err != nil {
  87                 t.Errorf("#rNibReader_test.TestGetNb - Failed to marshal ENB instance. Error: %v", err)
  88         }
  89         ret := map[string]interface{}{"RAN:" + name:string(data)}
  90         sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
  91         getNb, er := w.GetNodeb(name)
  92         assert.Nil(t, er)
  93         assert.Equal(t, getNb.Ip, nb.Ip)
  94         assert.Equal(t, getNb.Port, nb.Port)
  95         assert.Equal(t, getNb.ConnectionStatus, nb.ConnectionStatus)
  96         assert.Len(t, getNb.GetEnb().GetServedCells(), 1)
  97         assert.Equal(t, getNb.GetEnb().GetServedCells()[0].Tac, nb.GetEnb().GetServedCells()[0].Tac)
  98 }
  99
 100 func TestGetNodeBNotFoundFailure(t *testing.T) {
 101         name := "name"
 102         readerPool = nil
 103         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 104         w := GetRNibReader()
 105         var e error
 106         var ret map[string]interface{}
 107         sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
 108         getNb, er := w.GetNodeb(name)
 109         assert.NotNil(t, er)
 110         assert.Nil(t, getNb)
 111         assert.Equal(t, 1, er.GetCode())
 112         assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.GetNodeb - responding node name not found", er.Error())
 113 }
 114
 115 func TestGetNodeBUnmarshalFailure(t *testing.T) {
 116         name := "name"
 117         readerPool = nil
 118         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 119         w := GetRNibReader()
 120         var e error
 121         ret := make( map[string]interface{}, 1)
 122         ret["RAN:" + name] = "data"
 123         sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
 124         getNb, er := w.GetNodeb(name)
 125         assert.NotNil(t, er)
 126         assert.Nil(t, getNb)
 127         assert.Equal(t, 2, er.GetCode())
 128         assert.EqualValues(t, "2 INTERNAL_ERROR - proto: can't skip unknown wire type 4", er.Error())
 129 }
 130
 131 func TestGetNodeBSdlgoFailure(t *testing.T) {
 132         name := "name"
 133         errMsg := "expected Sdlgo error"
 134         errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
 135         readerPool = nil
 136         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 137         w := GetRNibReader()
 138         e := errors.New(errMsg)
 139         var ret map[string]interface{}
 140         sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
 141         getNb, er := w.GetNodeb(name)
 142         assert.NotNil(t, er)
 143         assert.Nil(t, getNb)
 144         assert.Equal(t, 2, er.GetCode())
 145         assert.EqualValues(t, errMsgExpected, er.Error())
 146 }
 147
 148 func TestGetNodeBCellsListEnb(t *testing.T) {
 149         name := "name"
 150         readerPool = nil
 151         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 152         w := GetRNibReader()
 153         nb := entities.NodebInfo{}
 154         nb.ConnectionStatus = 1
 155         nb.Ip = "localhost"
 156         nb.Port = 5656
 157         enb := entities.Enb{}
 158         cell := entities.ServedCellInfo{Tac:"tac"}
 159         enb.ServedCells = []*entities.ServedCellInfo{&cell}
 160         nb.Configuration = &entities.NodebInfo_Enb{Enb:&enb}
 161         var e error
 162         data, err := proto.Marshal(&nb)
 163         if err != nil {
 164                 t.Errorf("#rNibReader_test.GetNodeBCellsList - Failed to marshal ENB instance. Error: %v", err)
 165         }
 166         ret := map[string]interface{}{"RAN:" + name:string(data)}
 167         sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
 168         cells, er := w.GetCellList(name)
 169         assert.Nil(t, er)
 170         assert.NotNil(t, cells)
 171         assert.Len(t, cells.GetServedCellInfos().GetServedCells(), 1)
 172         retCell := cells.GetServedCellInfos().GetServedCells()[0]
 173         assert.Equal(t, retCell.Tac, "tac")
 174 }
 175
 176 func TestGetNodeBCellsListGnb(t *testing.T) {
 177         name := "name"
 178         readerPool = nil
 179         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 180         w := GetRNibReader()
 181         nb := entities.NodebInfo{}
 182         nb.ConnectionStatus = 1
 183         nb.Ip = "localhost"
 184         nb.Port = 5656
 185         nb.NodeType = entities.Node_GNB
 186         gnb := entities.Gnb{}
 187         cell := entities.ServedNRCell{ServedNrCellInformation:&entities.ServedNRCellInformation{NrPci:10}}
 188         gnb.ServedNrCells = []*entities.ServedNRCell{&cell}
 189         nb.Configuration = &entities.NodebInfo_Gnb{Gnb:&gnb}
 190         var e error
 191         data, err := proto.Marshal(&nb)
 192         if err != nil {
 193                 t.Errorf("#rNibReader_test.GetNodeBCellsList - Failed to marshal GNB instance. Error: %v", err)
 194         }
 195         ret := map[string]interface{}{"RAN:" + name:string(data)}
 196         sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
 197         cells, er := w.GetCellList(name)
 198         assert.Nil(t, er)
 199         assert.NotNil(t, cells)
 200         assert.Len(t, cells.GetServedNrCells().GetServedCells(), 1)
 201         retCell := cells.GetServedNrCells().GetServedCells()[0]
 202         assert.Equal(t, retCell.GetServedNrCellInformation().GetNrPci(), uint32(10))
 203 }
 204
 205 func TestGetNodeBCellsListNodeUnmarshalFailure(t *testing.T) {
 206         name := "name"
 207         readerPool = nil
 208         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 209         w := GetRNibReader()
 210         var e error
 211         ret := make( map[string]interface{}, 1)
 212         ret["RAN:" + name] = "data"
 213         sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
 214         cells, er := w.GetCellList(name)
 215         assert.NotNil(t, er)
 216         assert.Nil(t, cells)
 217         assert.Equal(t, 2, er.GetCode())
 218         assert.EqualValues(t, "2 INTERNAL_ERROR - proto: can't skip unknown wire type 4", er.Error())
 219 }
 220
 221 func TestGetNodeBCellsListNodeNotFoundFailure(t *testing.T) {
 222         name := "name"
 223         readerPool = nil
 224         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 225         w := GetRNibReader()
 226         var e error
 227         var ret map[string]interface{}
 228         sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
 229         cells, er := w.GetCellList(name)
 230         assert.NotNil(t, er)
 231         assert.Nil(t, cells)
 232         assert.Equal(t, 1, er.GetCode())
 233         assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.GetNodeb - responding node name not found", er.Error())
 234 }
 235
 236 func TestGetNodeBCellsListNotFoundFailureEnb(t *testing.T) {
 237         name := "name"
 238         readerPool = nil
 239         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 240         w := GetRNibReader()
 241         nb := entities.NodebInfo{}
 242         nb.ConnectionStatus = 1
 243         nb.Ip = "localhost"
 244         nb.Port = 5656
 245         enb := entities.Enb{}
 246         nb.Configuration = &entities.NodebInfo_Enb{Enb:&enb}
 247         var e error
 248         data, err := proto.Marshal(&nb)
 249         if err != nil {
 250                 t.Errorf("#rNibReader_test.TestGetNbCellsListNotFoundFailure - Failed to marshal ENB instance. Error: %v", err)
 251         }
 252         ret := map[string]interface{}{"RAN:" + name:string(data)}
 253         sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
 254         _, er := w.GetCellList(name)
 255         assert.NotNil(t, er)
 256         assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.GetCellList - served cells not found. Responding node RAN name: name.", er.Error())
 257 }
 258
 259 func TestGetNodeBCellsListNotFoundFailureGnb(t *testing.T) {
 260         name := "name"
 261         readerPool = nil
 262         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 263         w := GetRNibReader()
 264         nb := entities.NodebInfo{}
 265         nb.ConnectionStatus = 1
 266         nb.Ip = "localhost"
 267         nb.Port = 5656
 268         gnb := entities.Gnb{}
 269         nb.Configuration = &entities.NodebInfo_Gnb{Gnb:&gnb}
 270         var e error
 271         data, err := proto.Marshal(&nb)
 272         if err != nil {
 273                 t.Errorf("#rNibReader_test.TestGetNbCellsListNotFoundFailure - Failed to marshal ENB instance. Error: %v", err)
 274         }
 275         ret := map[string]interface{}{"RAN:" + name:string(data)}
 276         sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
 277         _, er := w.GetCellList(name)
 278         assert.NotNil(t, er)
 279         assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.GetCellList - served cells not found. Responding node RAN name: name.", er.Error())
 280 }
 281
 282 func TestCloseOnClosedPoolFailure(t *testing.T) {
 283         readerPool = nil
 284         instanceMock := initSdlInstanceMock(namespace, 1)
 285         w1 := GetRNibReader()
 286         readerPool.Put(w1)
 287         available, created := readerPool.Stats()
 288         assert.Equal(t, 1, available, "number of available objects in the readerPool should be 1")
 289         assert.Equal(t, 1, created, "number of created objects in the readerPool should be 1")
 290         var e error
 291         instanceMock.On("Close").Return(e)
 292         Close()
 293         assert.Panics(t, func(){Close()})
 294 }
 295
 296 func TestCloseFailure(t *testing.T) {
 297         readerPool = nil
 298         instanceMock := initSdlInstanceMock(namespace, 2)
 299         w1 := GetRNibReader()
 300         readerPool.Put(w1)
 301         available, created := readerPool.Stats()
 302         assert.Equal(t, 1, available, "number of available objects in the readerPool should be 1")
 303         assert.Equal(t, 1, created, "number of created objects in the readerPool should be 1")
 304         e := errors.New("expected error")
 305         instanceMock.On("Close").Return(e)
 306         Close()
 307         available, created = readerPool.Stats()
 308         assert.Equal(t, 0, available, "number of available objects in the readerPool should be 0")
 309         assert.Equal(t, 0, created, "number of created objects in the readerPool should be 0")
 310 }
 311
 312 func TestGetListGnbIdsUnmarshalFailure(t *testing.T) {
 313         readerPool = nil
 314         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 315         w := GetRNibReader()
 316         var e error
 317         sdlInstanceMock.On("GetMembers", "GNB").Return([]string{"data"}, e)
 318         ids, er := w.GetListGnbIds()
 319         assert.NotNil(t, er)
 320         assert.Nil(t, ids)
 321         assert.Equal(t, 2, er.GetCode())
 322         assert.Equal(t, "2 INTERNAL_ERROR - proto: can't skip unknown wire type 4", er.Error())
 323 }
 324
 325 func TestGetListGnbIdsSdlgoFailure(t *testing.T) {
 326         errMsg := "expected Sdlgo error"
 327         errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
 328         readerPool = nil
 329         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 330         w := GetRNibReader()
 331         e := errors.New(errMsg)
 332         var data []string
 333         sdlInstanceMock.On("GetMembers", "GNB").Return(data, e)
 334         ids, er := w.GetListGnbIds()
 335         assert.NotNil(t, er)
 336         assert.Nil(t, ids)
 337         assert.Equal(t, 2, er.GetCode())
 338         assert.EqualValues(t, errMsgExpected,er.Error())
 339 }
 340
 341 func TestGetListEnbIdsUnmarshalFailure(t *testing.T) {
 342         readerPool = nil
 343         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 344         w := GetRNibReader()
 345         var e error
 346         sdlInstanceMock.On("GetMembers", "ENB").Return([]string{"data"}, e)
 347         ids, er := w.GetListEnbIds()
 348         assert.NotNil(t, er)
 349         assert.Nil(t, ids)
 350         assert.Equal(t, 2, er.GetCode())
 351         assert.Equal(t, "2 INTERNAL_ERROR - proto: can't skip unknown wire type 4", er.Error())
 352 }
 353
 354 func TestGetListEnbIdsOneId(t *testing.T) {
 355         name := "name"
 356         plmnId := "02f829"
 357         nbId := "4a952a0a"
 358         readerPool = nil
 359         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 360         w := GetRNibReader()
 361         nbIdentity := &entities.NbIdentity{InventoryName:name, GlobalNbId:&entities.GlobalNbId{PlmnId:plmnId, NbId:nbId}}
 362         var e error
 363         data, err := proto.Marshal(nbIdentity)
 364         if err != nil {
 365                 t.Errorf("#rNibReader_test.TestGetListEnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
 366         }
 367         sdlInstanceMock.On("GetMembers", "ENB").Return([]string{string(data)}, e)
 368         ids, er := w.GetListEnbIds()
 369         assert.Nil(t, er)
 370         assert.Len(t, *ids, 1)
 371         assert.Equal(t, (*ids)[0].GetInventoryName(), name)
 372         assert.Equal(t, (*ids)[0].GetGlobalNbId().GetPlmnId(), nbIdentity.GetGlobalNbId().GetPlmnId())
 373         assert.Equal(t, (*ids)[0].GetGlobalNbId().GetNbId(), nbIdentity.GetGlobalNbId().GetNbId())
 374 }
 375
 376 func TestGetListEnbIdsNoIds(t *testing.T) {
 377         readerPool = nil
 378         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 379         w := GetRNibReader()
 380         var e error
 381         sdlInstanceMock.On("GetMembers", "ENB").Return([]string{}, e)
 382         ids, er := w.GetListEnbIds()
 383         assert.Nil(t, er)
 384         assert.Len(t, *ids, 0)
 385 }
 386
 387 func TestGetListEnbIds(t *testing.T) {
 388         name := "name"
 389         plmnId := 0x02f829
 390         nbId := 0x4a952a0a
 391         listSize := 3
 392         readerPool = nil
 393         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 394         w := GetRNibReader()
 395         idsData := make([]string, listSize)
 396         idsEntities := make([]*entities.NbIdentity, listSize)
 397         for i:=0; i< listSize ;i++{
 398                 nbIdentity := &entities.NbIdentity{InventoryName:name, GlobalNbId:&entities.GlobalNbId{PlmnId:string(plmnId + i), NbId:string(nbId + i)}}
 399                 data, err := proto.Marshal(nbIdentity)
 400                 if err != nil {
 401                         t.Errorf("#rNibReader_test.TestGetListEnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
 402                 }
 403                 idsData[i] = string(data)
 404                 idsEntities[i] = nbIdentity
 405         }
 406         var e error
 407         sdlInstanceMock.On("GetMembers", "ENB").Return(idsData, e)
 408         ids, er := w.GetListEnbIds()
 409         assert.Nil(t, er)
 410         assert.Len(t, *ids, listSize)
 411         for i, id :=range *ids{
 412                 assert.Equal(t, id.GetInventoryName(), name)
 413                 assert.Equal(t, id.GetGlobalNbId().GetPlmnId(), idsEntities[i].GetGlobalNbId().GetPlmnId())
 414                 assert.Equal(t, id.GetGlobalNbId().GetNbId(), idsEntities[i].GetGlobalNbId().GetNbId())
 415         }
 416 }
 417
 418 func TestGetListGnbIdsOneId(t *testing.T) {
 419         name := "name"
 420         plmnId := "02f829"
 421         nbId := "4a952a0a"
 422         readerPool = nil
 423         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 424         w := GetRNibReader()
 425         nbIdentity := &entities.NbIdentity{InventoryName:name, GlobalNbId:&entities.GlobalNbId{PlmnId:plmnId, NbId:nbId}}
 426         var e error
 427         data, err := proto.Marshal(nbIdentity)
 428         if err != nil {
 429                 t.Errorf("#rNibReader_test.TestGetListGnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
 430         }
 431         sdlInstanceMock.On("GetMembers", "GNB").Return([]string{string(data)}, e)
 432         ids, er := w.GetListGnbIds()
 433         assert.Nil(t, er)
 434         assert.Len(t, *ids, 1)
 435         assert.Equal(t, (*ids)[0].GetInventoryName(), name)
 436         assert.Equal(t, (*ids)[0].GetGlobalNbId().GetPlmnId(), nbIdentity.GetGlobalNbId().GetPlmnId())
 437         assert.Equal(t, (*ids)[0].GetGlobalNbId().GetNbId(), nbIdentity.GetGlobalNbId().GetNbId())
 438 }
 439
 440 func TestGetListGnbIdsNoIds(t *testing.T) {
 441         readerPool = nil
 442         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 443         w := GetRNibReader()
 444         var e error
 445         sdlInstanceMock.On("GetMembers", "GNB").Return([]string{}, e)
 446         ids, er := w.GetListGnbIds()
 447         assert.Nil(t, er)
 448         assert.Len(t, *ids, 0)
 449 }
 450
 451 func TestGetListGnbIds(t *testing.T) {
 452         name := "name"
 453         plmnId := 0x02f829
 454         nbId := 0x4a952a0a
 455         listSize := 3
 456         readerPool = nil
 457         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 458         w := GetRNibReader()
 459         idsData := make([]string, listSize)
 460         idsEntities := make([]*entities.NbIdentity, listSize)
 461         for i:=0; i< listSize ;i++{
 462                 nbIdentity := &entities.NbIdentity{InventoryName:name, GlobalNbId:&entities.GlobalNbId{PlmnId:string(plmnId + i), NbId:string(nbId + i)}}
 463                 data, err := proto.Marshal(nbIdentity)
 464                 if err != nil {
 465                         t.Errorf("#rNibReader_test.TestGetListGnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
 466                 }
 467                 idsData[i] = string(data)
 468                 idsEntities[i] = nbIdentity
 469         }
 470         var e error
 471         sdlInstanceMock.On("GetMembers", "GNB").Return(idsData, e)
 472         ids, er := w.GetListGnbIds()
 473         assert.Nil(t, er)
 474         assert.Len(t, *ids, listSize)
 475         for i, id :=range *ids{
 476                 assert.Equal(t, id.GetInventoryName(), name)
 477                 assert.Equal(t, id.GetGlobalNbId().GetPlmnId(), idsEntities[i].GetGlobalNbId().GetPlmnId())
 478                 assert.Equal(t, id.GetGlobalNbId().GetNbId(), idsEntities[i].GetGlobalNbId().GetNbId())
 479         }
 480 }
 481
 482 func TestGetListEnbIdsSdlgoFailure(t *testing.T) {
 483         errMsg := "expected Sdlgo error"
 484         errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
 485         readerPool = nil
 486         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 487         w := GetRNibReader()
 488         e := errors.New(errMsg)
 489         var data []string
 490         sdlInstanceMock.On("GetMembers", "ENB").Return(data, e)
 491         ids, er := w.GetListEnbIds()
 492         assert.NotNil(t, er)
 493         assert.Nil(t, ids)
 494         assert.Equal(t, 2, er.GetCode())
 495         assert.EqualValues(t, errMsgExpected, er.Error())
 496 }
 497
 498 func TestGetCountGnbListOneId(t *testing.T) {
 499         name := "name"
 500         plmnId := "02f829"
 501         nbId := "4a952a0a"
 502         readerPool = nil
 503         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 504         w := GetRNibReader()
 505         nbIdentity := &entities.NbIdentity{InventoryName:name, GlobalNbId:&entities.GlobalNbId{PlmnId:plmnId, NbId:nbId}}
 506         var e error
 507         data, err := proto.Marshal(nbIdentity)
 508         if err != nil {
 509                 t.Errorf("#rNibReader_test.TestGetCountGnbList - Failed to marshal nodeb identity entity. Error: %v", err)
 510         }
 511         sdlInstanceMock.On("GetMembers", "GNB").Return([]string{string(data)}, e)
 512         count, er := w.GetCountGnbList()
 513         assert.Nil(t, er)
 514         assert.Equal(t, count, 1)
 515 }
 516
 517 func TestGetCountGnbList(t *testing.T) {
 518         listSize := 3
 519         name := "name"
 520         plmnId := 0x02f823
 521         nbId := 0x4a952a1f
 522         readerPool = nil
 523         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 524         w := GetRNibReader()
 525         var e error
 526         idsData := make([]string, listSize)
 527         idsEntities := make([]*entities.NbIdentity, listSize)
 528         for i:=0; i< listSize ;i++{
 529                 nbIdentity := &entities.NbIdentity{InventoryName:name, GlobalNbId:&entities.GlobalNbId{PlmnId:string(plmnId + i), NbId:string(nbId + i)}}
 530                 data, err := proto.Marshal(nbIdentity)
 531                 if err != nil {
 532                         t.Errorf("#rNibReader_test.TestGetListGnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
 533                 }
 534                 idsData[i] = string(data)
 535                 idsEntities[i] = nbIdentity
 536         }
 537         sdlInstanceMock.On("GetMembers", "GNB").Return(idsData, e)
 538         count, er := w.GetCountGnbList()
 539         assert.Nil(t, er)
 540         assert.Equal(t, count, 3)
 541 }
 542
 543 func TestGetCountGnbListSdlgoFailure(t *testing.T) {
 544         errMsg := "expected Sdlgo error"
 545         errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
 546         readerPool = nil
 547         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 548         w := GetRNibReader()
 549         e := errors.New(errMsg)
 550         var data []string
 551         sdlInstanceMock.On("GetMembers", "GNB").Return(data, e)
 552         count, er := w.GetCountGnbList()
 553         assert.NotNil(t, er)
 554         assert.Equal(t, 0, count)
 555         assert.Equal(t, 2, er.GetCode())
 556         assert.EqualValues(t, errMsgExpected, er.Error())
 557 }
 558
 559 func TestGetCell(t *testing.T) {
 560         name := "name"
 561         var pci uint32
 562         pci = 10
 563         readerPool = nil
 564         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 565         w := GetRNibReader()
 566         cellEntity := entities.Cell{Type:entities.Cell_LTE_CELL, Cell:&entities.Cell_ServedCellInfo{ServedCellInfo:&entities.ServedCellInfo{Pci:pci}}}
 567         cellData, err := proto.Marshal(&cellEntity)
 568         if err != nil {
 569                 t.Errorf("#rNibReader_test.TestGetCell - Failed to marshal Cell entity. Error: %v", err)
 570         }
 571         var e error
 572         key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
 573         if rNibErr != nil {
 574                 t.Errorf("#rNibReader_test.TestGetCell - failed to validate key parameter")
 575         }
 576         ret := map[string]interface{}{key:string(cellData)}
 577         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
 578         cell, er := w.GetCell(name, pci)
 579         assert.Nil(t, er)
 580         assert.NotNil(t, cell)
 581         assert.Equal(t, cell.Type, entities.Cell_LTE_CELL)
 582         assert.NotNil(t, cell.GetServedCellInfo())
 583         assert.Equal(t, cell.GetServedCellInfo().GetPci(), pci)
 584 }
 585
 586 func TestGetCellNotFoundFailure(t *testing.T) {
 587         name := "name"
 588         var pci uint32
 589         readerPool = nil
 590         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 591         w := GetRNibReader()
 592         var e error
 593         var ret map[string]interface{}
 594         key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
 595         if rNibErr != nil {
 596                 t.Errorf("#rNibReader_test.TestGetCellNotFoundFailure - failed to validate key parameter")
 597         }
 598         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
 599         cell, er := w.GetCell(name, pci)
 600         assert.NotNil(t, er)
 601         assert.Nil(t, cell)
 602         assert.Equal(t, 1, er.GetCode())
 603         assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.getCellByKey - cell not found, key: PCI:name:00", er.Error())
 604 }
 605
 606 func TestGetCellUnmarshalFailure(t *testing.T) {
 607         name := "name"
 608         var pci uint32
 609         readerPool = nil
 610         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 611         w := GetRNibReader()
 612         var e error
 613         ret := make( map[string]interface{}, 1)
 614         key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
 615         if rNibErr != nil {
 616                 t.Errorf("#rNibReader_test.TestGetCellUnmarshalFailure - failed to validate key parameter")
 617         }
 618         ret[key] = "data"
 619         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
 620         cell, er := w.GetCell(name, pci)
 621         assert.NotNil(t, er)
 622         assert.Nil(t, cell)
 623         assert.Equal(t, 2, er.GetCode())
 624         assert.EqualValues(t, "2 INTERNAL_ERROR - proto: can't skip unknown wire type 4", er.Error())
 625 }
 626
 627 func TestGetCellSdlgoFailure(t *testing.T) {
 628         name := "name"
 629         var pci uint32
 630         errMsg := "expected Sdlgo error"
 631         errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
 632         readerPool = nil
 633         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 634         w := GetRNibReader()
 635         e := errors.New(errMsg)
 636         var ret map[string]interface{}
 637         key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
 638         if rNibErr != nil {
 639                 t.Errorf("#rNibReader_test.TestGetCellSdlgoFailure - failed to validate key parameter")
 640         }
 641         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
 642         cell, er := w.GetCell(name, pci)
 643         assert.NotNil(t, er)
 644         assert.Nil(t, cell)
 645         assert.Equal(t, 2, er.GetCode())
 646         assert.EqualValues(t, errMsgExpected, er.Error())
 647 }
 648
 649 func TestGetNodebById(t *testing.T) {
 650         readerPool = nil
 651         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 652         w := GetRNibReader()
 653         nb := entities.NodebInfo{NodeType:entities.Node_ENB}
 654         nb.ConnectionStatus = 1
 655         nb.Ip = "localhost"
 656         nb.Port = 5656
 657         enb := entities.Enb{}
 658         cell := entities.ServedCellInfo{Tac:"tac"}
 659         enb.ServedCells = []*entities.ServedCellInfo{&cell}
 660         nb.Configuration = &entities.NodebInfo_Enb{Enb:&enb}
 661         var e error
 662         data, err := proto.Marshal(&nb)
 663         if err != nil {
 664                 t.Errorf("#rNibReader_test.TestGetNodebById - Failed to marshal ENB instance. Error: %v", err)
 665         }
 666
 667         plmnId := "02f829"
 668         nbId := "4a952a0a"
 669         key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_ENB.String(), plmnId, nbId)
 670         if rNibErr != nil{
 671                 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
 672         }
 673         ret := map[string]interface{}{key:string(data)}
 674         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
 675         globalNbId := &entities.GlobalNbId{PlmnId:plmnId, NbId:nbId}
 676         getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
 677         assert.Nil(t, er)
 678         assert.Equal(t, getNb.Ip, nb.Ip)
 679         assert.Equal(t, getNb.Port, nb.Port)
 680         assert.Equal(t, getNb.ConnectionStatus, nb.ConnectionStatus)
 681         assert.Len(t, getNb.GetEnb().GetServedCells(), 1)
 682         assert.Equal(t, getNb.GetEnb().GetServedCells()[0].Tac, nb.GetEnb().GetServedCells()[0].Tac)
 683 }
 684
 685 func TestGetNodebByIdNotFoundFailureEnb(t *testing.T) {
 686         plmnId := "02f829"
 687         nbId := "4a952a0a"
 688         readerPool = nil
 689         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 690         w := GetRNibReader()
 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", []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.Equal(t, 1, er.GetCode())
 703         assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.GetNodebByGlobalNbId - responding node not found, global nodeb Id: ENB:02f829:4a952a0a", er.Error())
 704 }
 705
 706 func TestGetNodebByIdNotFoundFailureGnb(t *testing.T) {
 707         plmnId := "02f829"
 708         nbId := "4a952a0a"
 709         readerPool = nil
 710         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 711         w := GetRNibReader()
 712         var e error
 713         key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_GNB.String(), plmnId, nbId)
 714         if rNibErr != nil{
 715                 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
 716         }
 717         var ret map[string]interface{}
 718         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
 719         globalNbId := &entities.GlobalNbId{PlmnId:plmnId, NbId:nbId}
 720         getNb, er := w.GetNodebByGlobalNbId(entities.Node_GNB, globalNbId)
 721         assert.NotNil(t, er)
 722         assert.Nil(t, getNb)
 723         assert.Equal(t, 1, er.GetCode())
 724         assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.GetNodebByGlobalNbId - responding node not found, global nodeb Id: GNB:02f829:4a952a0a", er.Error())
 725 }
 726
 727 func TestGetNodeByIdUnmarshalFailure(t *testing.T) {
 728         plmnId := "02f829"
 729         nbId := "4a952a0a"
 730         readerPool = nil
 731         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 732         w := GetRNibReader()
 733         key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_ENB.String(), plmnId, nbId)
 734         if rNibErr != nil{
 735                 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
 736         }
 737         var e error
 738         ret := make( map[string]interface{}, 1)
 739         ret[key] = "data"
 740         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
 741         globalNbId := &entities.GlobalNbId{PlmnId:plmnId, NbId:nbId}
 742         getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
 743         assert.NotNil(t, er)
 744         assert.Nil(t, getNb)
 745         assert.Equal(t, 2, er.GetCode())
 746         assert.EqualValues(t, "2 INTERNAL_ERROR - proto: can't skip unknown wire type 4", er.Error())
 747 }
 748
 749 func TestGetNodeByIdSdlgoFailure(t *testing.T) {
 750         plmnId := "02f829"
 751         nbId := "4a952a0a"
 752         errMsg := "expected Sdlgo error"
 753         errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
 754         readerPool = nil
 755         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 756         w := GetRNibReader()
 757         key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_GNB.String(), plmnId, nbId)
 758         if rNibErr != nil{
 759                 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
 760         }
 761         e := errors.New(errMsg)
 762         var ret map[string]interface{}
 763         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
 764         globalNbId := &entities.GlobalNbId{PlmnId:plmnId, NbId:nbId}
 765         getNb, er := w.GetNodebByGlobalNbId(entities.Node_GNB, globalNbId)
 766         assert.NotNil(t, er)
 767         assert.Nil(t, getNb)
 768         assert.Equal(t, 2, er.GetCode())
 769         assert.EqualValues(t, errMsgExpected, er.Error())
 770 }
 771
 772 func TestGetCellById(t *testing.T) {
 773         cellId := "aaaa"
 774         var pci uint32
 775         pci = 10
 776         readerPool = nil
 777         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 778         w := GetRNibReader()
 779         cellEntity := entities.Cell{Type:entities.Cell_LTE_CELL, Cell:&entities.Cell_ServedCellInfo{ServedCellInfo:&entities.ServedCellInfo{Pci:pci}}}
 780         cellData, err := proto.Marshal(&cellEntity)
 781         if err != nil {
 782                 t.Errorf("#rNibReader_test.TestGetCellById - Failed to marshal Cell entity. Error: %v", err)
 783         }
 784         var e error
 785         key, rNibErr := common.ValidateAndBuildCellIdKey(cellId)
 786         if rNibErr != nil {
 787                 t.Errorf("#rNibReader_test.TestGetCellById - failed to validate key parameter")
 788         }
 789         ret := map[string]interface{}{key:string(cellData)}
 790         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
 791         cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
 792         assert.Nil(t, er)
 793         assert.NotNil(t, cell)
 794         assert.Equal(t, cell.Type, entities.Cell_LTE_CELL)
 795         assert.NotNil(t, cell.GetServedCellInfo())
 796         assert.Equal(t, cell.GetServedCellInfo().GetPci(), pci)
 797 }
 798
 799 func TestGetCellByIdNotFoundFailureEnb(t *testing.T) {
 800         cellId := "bbbb"
 801         readerPool = nil
 802         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 803         w := GetRNibReader()
 804         var e error
 805         var ret map[string]interface{}
 806         key, rNibErr := common.ValidateAndBuildCellIdKey(cellId)
 807         if rNibErr != nil {
 808                 t.Errorf("#rNibReader_test.TestGetCellByIdNotFoundFailure - failed to validate key parameter")
 809         }
 810         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
 811         cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
 812         assert.NotNil(t, er)
 813         assert.Nil(t, cell)
 814         assert.Equal(t, 1, er.GetCode())
 815         assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.getCellByKey - cell not found, key: CELL:bbbb", er.Error())
 816 }
 817
 818 func TestGetCellByIdNotFoundFailureGnb(t *testing.T) {
 819         cellId := "bbbb"
 820         readerPool = nil
 821         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 822         w := GetRNibReader()
 823         var e error
 824         var ret map[string]interface{}
 825         key, rNibErr := common.ValidateAndBuildNrCellIdKey(cellId)
 826         if rNibErr != nil {
 827                 t.Errorf("#rNibReader_test.TestGetCellByIdNotFoundFailure - failed to validate key parameter")
 828         }
 829         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
 830         cell, er := w.GetCellById(entities.Cell_NR_CELL, cellId)
 831         assert.NotNil(t, er)
 832         assert.Nil(t, cell)
 833         assert.Equal(t, 1, er.GetCode())
 834         assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.getCellByKey - cell not found, key: NRCELL:bbbb", er.Error())
 835 }
 836
 837 func TestGetCellByIdTypeValidationFailure(t *testing.T) {
 838         cellId := "dddd"
 839         readerPool = nil
 840         initSdlInstanceMock(namespace, 1)
 841         w := GetRNibReader()
 842         cell, er := w.GetCellById(5, cellId)
 843         assert.NotNil(t, er)
 844         assert.Nil(t, cell)
 845         assert.Equal(t, 3, er.GetCode())
 846         assert.EqualValues(t, "3 VALIDATION_ERROR - #rNibReader.GetCellById - invalid cell type: 5", er.Error())
 847 }
 848
 849 func TestGetCellByIdValidationFailureGnb(t *testing.T) {
 850         cellId := ""
 851         readerPool = nil
 852         initSdlInstanceMock(namespace, 1)
 853         w := GetRNibReader()
 854         cell, er := w.GetCellById(entities.Cell_NR_CELL, cellId)
 855         assert.NotNil(t, er)
 856         assert.Nil(t, cell)
 857         assert.Equal(t, 3, er.GetCode())
 858         assert.EqualValues(t, "3 VALIDATION_ERROR - #utils.ValidateAndBuildNrCellIdKey - an empty cell id received", er.Error())
 859 }
 860
 861 func TestGetCellByIdValidationFailureEnb(t *testing.T) {
 862         cellId := ""
 863         readerPool = nil
 864         initSdlInstanceMock(namespace, 1)
 865         w := GetRNibReader()
 866         cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
 867         assert.NotNil(t, er)
 868         assert.Nil(t, cell)
 869         assert.Equal(t, 3, er.GetCode())
 870         assert.EqualValues(t, "3 VALIDATION_ERROR - #utils.ValidateAndBuildCellIdKey - an empty cell id received", er.Error())
 871 }
 872
 873 //integration tests
 874
 875 //func TestGetEnbInteg(t *testing.T){
 876 //      name := "nameEnb1"
 877 //      Init("namespace", 1)
 878 //      w := GetRNibReader()
 879 //      nb, err := w.GetNodeb(name)
 880 //      if err != nil{
 881 //              fmt.Println(err)
 882 //      } else {
 883 //              fmt.Printf("#TestGetEnbInteg - responding node type: %v\n", nb)
 884 //      }
 885 //}
 886 //
 887 //func TestGetEnbCellsInteg(t *testing.T){
 888 //      name := "nameEnb1"
 889 //      Init("namespace", 1)
 890 //      w := GetRNibReader()
 891 //      cells, err := w.GetCellList(name)
 892 //      if err != nil{
 893 //              fmt.Println(err)
 894 //      } else if cells != nil{
 895 //              for _, cell := range cells.GetServedCellInfos().ServedCells{
 896 //                      fmt.Printf("responding node type Cell: %v\n", *cell)
 897 //              }
 898 //      }
 899 //}
 900 //
 901 //func TestGetGnbInteg(t *testing.T){
 902 //      name := "nameGnb1"
 903 //      Init("namespace", 1)
 904 //      w := GetRNibReader()
 905 //      nb, err := w.GetNodeb(name)
 906 //      if err != nil{
 907 //              fmt.Println(err)
 908 //      } else {
 909 //              fmt.Printf("#TestGetGnbInteg - responding node type: %v\n", nb)
 910 //      }
 911 //}
 912 //
 913 //func TestGetGnbCellsInteg(t *testing.T){
 914 //      name := "nameGnb1"
 915 //      Init("namespace", 1)
 916 //      w := GetRNibReader()
 917 //      cells, err := w.GetCellList(name)
 918 //      if err != nil{
 919 //              fmt.Println(err)
 920 //      } else if cells != nil{
 921 //              for _, cell := range cells.GetServedNrCells().ServedCells{
 922 //                      fmt.Printf("responding node type NR Cell: %v\n", *cell)
 923 //              }
 924 //      }
 925 //}
 926 //
 927 //func TestGetListEnbIdsInteg(t *testing.T) {
 928 //      Init("namespace", 1)
 929 //      w := GetRNibReader()
 930 //      ids, err := w.GetListEnbIds()
 931 //      if err != nil{
 932 //              fmt.Println(err)
 933 //      } else {
 934 //              for _, id := range *ids{
 935 //                      fmt.Printf("#TestGetListEnbIdsInteg - ENB ID: %s\n", id)
 936 //              }
 937 //      }
 938 //}
 939 //
 940 //func TestGetListGnbIdsInteg(t *testing.T) {
 941 //      Init("namespace", 1)
 942 //      w := GetRNibReader()
 943 //      ids, err := w.GetListGnbIds()
 944 //      if err != nil{
 945 //              fmt.Println(err)
 946 //      } else {
 947 //              for _, id := range *ids{
 948 //                      fmt.Printf("#TestGetListGnbIdsInteg - GNB ID: %s\n", id)
 949 //              }
 950 //      }
 951 //}
 952 //
 953 //func TestGetCountGnbListInteg(t *testing.T) {
 954 //      Init("namespace", 1)
 955 //      w := GetRNibReader()
 956 //      count, err := w.GetCountGnbList()
 957 //      if err != nil{
 958 //              fmt.Println(err)
 959 //      } else {
 960 //              fmt.Printf("#TestGetCountGnbListInteg - count Gnb list: %d\n", count)
 961 //      }
 962 //}
 963 //
 964 //func TestGetGnbCellInteg(t *testing.T){
 965 //      name := "nameGnb7"
 966 //      pci := 0x0a
 967 //      Init("namespace", 1)
 968 //      w := GetRNibReader()
 969 //      cell, err := w.GetCell(name, uint32(pci))
 970 //      if err != nil{
 971 //              fmt.Println(err)
 972 //      } else if cell != nil{
 973 //              fmt.Printf("responding node type NR Cell: %v\n", cell.GetServedNrCell())
 974 //      }
 975 //}
 976 //
 977 //func TestGetEnbCellInteg(t *testing.T) {
 978 //      name := "nameEnb1"
 979 //      pci := 0x22
 980 //      Init("namespace", 1)
 981 //      w := GetRNibReader()
 982 //      cell, err := w.GetCell(name, uint32(pci))
 983 //      if err != nil {
 984 //              fmt.Println(err)
 985 //      } else if cell != nil {
 986 //              fmt.Printf("responding node type LTE Cell: %v\n", cell.GetServedCellInfo())
 987 //      }
 988 //}
 989 //
 990 //func TestGetEnbCellByIdInteg(t *testing.T){
 991 //      Init("namespace", 1)
 992 //      w := GetRNibReader()
 993 //      cell, err := w.GetCellById(entities.Cell_NR_CELL, "45d")
 994 //      if err != nil{
 995 //              fmt.Println(err)
 996 //      } else if cell != nil{
 997 //              fmt.Printf("responding node type NR Cell: %v\n", cell.GetServedNrCell())
 998 //      }
 999 //}