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.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
  22         "gerrit.o-ran-sc.org/r/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 not found. Key: RAN:name", 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 not found. Key: RAN:name", 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", GnbType).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", GnbType).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 TestGetListNodesIdsGnbSdlgoFailure(t *testing.T) {
 342
 343         readerPool = nil
 344         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 345         w := GetRNibReader()
 346
 347         name := "name"
 348         plmnId := "02f829"
 349         nbId := "4a952a0a"
 350         nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
 351         var nilError error
 352         data, err := proto.Marshal(nbIdentity)
 353         if err != nil {
 354                 t.Errorf("#rNibReader_test.TestGetListNodesIdsGnbSdlgoFailure - Failed to marshal nodeb identity entity. Error: %v", err)
 355         }
 356         sdlInstanceMock.On("GetMembers", EnbType).Return([]string{string(data)}, nilError)
 357
 358         errMsg := "expected Sdlgo error"
 359         errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
 360         expectedError := errors.New(errMsg)
 361         var nilData []string
 362         sdlInstanceMock.On("GetMembers", GnbType).Return(nilData, expectedError)
 363
 364         ids, er := w.GetListNodebIds()
 365         assert.NotNil(t, er)
 366         assert.Nil(t, ids)
 367         assert.Equal(t, 2, er.GetCode())
 368         assert.EqualValues(t, errMsgExpected, er.Error())
 369 }
 370
 371 func TestGetListNodesIdsEnbSdlgoFailure(t *testing.T) {
 372
 373         readerPool = nil
 374         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 375         w := GetRNibReader()
 376
 377         name := "name"
 378         plmnId := "02f829"
 379         nbId := "4a952a0a"
 380         nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
 381         var nilError error
 382         data, err := proto.Marshal(nbIdentity)
 383         if err != nil {
 384                 t.Errorf("#rNibReader_test.TestGetListNodesIdsEnbSdlgoFailure - Failed to marshal nodeb identity entity. Error: %v", err)
 385         }
 386         sdlInstanceMock.On("GetMembers", GnbType).Return([]string{string(data)}, nilError)
 387
 388         errMsg := "expected Sdlgo error"
 389         errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
 390         expectedError := errors.New(errMsg)
 391         var nilData []string
 392         sdlInstanceMock.On("GetMembers", EnbType).Return(nilData, expectedError)
 393
 394         ids, er := w.GetListNodebIds()
 395         assert.NotNil(t, er)
 396         assert.Nil(t, ids)
 397         assert.Equal(t, 2, er.GetCode())
 398         assert.EqualValues(t, errMsgExpected, er.Error())
 399 }
 400
 401 func TestGetListNodesIdsEnbSdlgoSuccess(t *testing.T) {
 402
 403         readerPool = nil
 404         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 405         w := GetRNibReader()
 406
 407         name := "name"
 408         plmnId := "02f829"
 409         nbId := "4a952a0a"
 410         nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
 411         var nilError error
 412         data, err := proto.Marshal(nbIdentity)
 413         if err != nil {
 414                 t.Errorf("#rNibReader_test.TestGetListNodesIdsEnbSdlgoFailure - Failed to marshal nodeb identity entity. Error: %v", err)
 415         }
 416         sdlInstanceMock.On("GetMembers", GnbType).Return([]string{string(data)}, nilError)
 417         sdlInstanceMock.On("GetMembers", EnbType).Return([]string{string(data)}, nilError)
 418
 419         ids, er := w.GetListNodebIds()
 420         assert.Nil(t, er)
 421         assert.NotNil(t, ids)
 422         assert.Len(t, ids, 2)
 423 }
 424
 425 func TestGetListEnbIdsUnmarshalFailure(t *testing.T) {
 426         readerPool = nil
 427         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 428         w := GetRNibReader()
 429         var e error
 430         sdlInstanceMock.On("GetMembers", EnbType).Return([]string{"data"}, e)
 431         ids, er := w.GetListEnbIds()
 432         assert.NotNil(t, er)
 433         assert.Nil(t, ids)
 434         assert.Equal(t, 2, er.GetCode())
 435         assert.Equal(t, "2 INTERNAL_ERROR - proto: can't skip unknown wire type 4", er.Error())
 436 }
 437
 438 func TestGetListEnbIdsOneId(t *testing.T) {
 439         name := "name"
 440         plmnId := "02f829"
 441         nbId := "4a952a0a"
 442         readerPool = nil
 443         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 444         w := GetRNibReader()
 445         nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
 446         var e error
 447         data, err := proto.Marshal(nbIdentity)
 448         if err != nil {
 449                 t.Errorf("#rNibReader_test.TestGetListEnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
 450         }
 451         sdlInstanceMock.On("GetMembers", EnbType).Return([]string{string(data)}, e)
 452         ids, er := w.GetListEnbIds()
 453         assert.Nil(t, er)
 454         assert.Len(t, *ids, 1)
 455         assert.Equal(t, (*ids)[0].GetInventoryName(), name)
 456         assert.Equal(t, (*ids)[0].GetGlobalNbId().GetPlmnId(), nbIdentity.GetGlobalNbId().GetPlmnId())
 457         assert.Equal(t, (*ids)[0].GetGlobalNbId().GetNbId(), nbIdentity.GetGlobalNbId().GetNbId())
 458 }
 459
 460 func TestGetListEnbIdsNoIds(t *testing.T) {
 461         readerPool = nil
 462         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 463         w := GetRNibReader()
 464         var e error
 465         sdlInstanceMock.On("GetMembers", EnbType).Return([]string{}, e)
 466         ids, er := w.GetListEnbIds()
 467         assert.Nil(t, er)
 468         assert.Len(t, *ids, 0)
 469 }
 470
 471 func TestGetListEnbIds(t *testing.T) {
 472         name := "name"
 473         plmnId := 0x02f829
 474         nbId := 0x4a952a0a
 475         listSize := 3
 476         readerPool = nil
 477         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 478         w := GetRNibReader()
 479         idsData := make([]string, listSize)
 480         idsEntities := make([]*entities.NbIdentity, listSize)
 481         for i := 0; i < listSize; i++ {
 482                 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: string(plmnId + i), NbId: string(nbId + i)}}
 483                 data, err := proto.Marshal(nbIdentity)
 484                 if err != nil {
 485                         t.Errorf("#rNibReader_test.TestGetListEnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
 486                 }
 487                 idsData[i] = string(data)
 488                 idsEntities[i] = nbIdentity
 489         }
 490         var e error
 491         sdlInstanceMock.On("GetMembers", EnbType).Return(idsData, e)
 492         ids, er := w.GetListEnbIds()
 493         assert.Nil(t, er)
 494         assert.Len(t, *ids, listSize)
 495         for i, id := range *ids {
 496                 assert.Equal(t, id.GetInventoryName(), name)
 497                 assert.Equal(t, id.GetGlobalNbId().GetPlmnId(), idsEntities[i].GetGlobalNbId().GetPlmnId())
 498                 assert.Equal(t, id.GetGlobalNbId().GetNbId(), idsEntities[i].GetGlobalNbId().GetNbId())
 499         }
 500 }
 501
 502 func TestGetListGnbIdsOneId(t *testing.T) {
 503         name := "name"
 504         plmnId := "02f829"
 505         nbId := "4a952a0a"
 506         readerPool = nil
 507         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 508         w := GetRNibReader()
 509         nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
 510         var e error
 511         data, err := proto.Marshal(nbIdentity)
 512         if err != nil {
 513                 t.Errorf("#rNibReader_test.TestGetListGnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
 514         }
 515         sdlInstanceMock.On("GetMembers", GnbType).Return([]string{string(data)}, e)
 516         ids, er := w.GetListGnbIds()
 517         assert.Nil(t, er)
 518         assert.Len(t, *ids, 1)
 519         assert.Equal(t, (*ids)[0].GetInventoryName(), name)
 520         assert.Equal(t, (*ids)[0].GetGlobalNbId().GetPlmnId(), nbIdentity.GetGlobalNbId().GetPlmnId())
 521         assert.Equal(t, (*ids)[0].GetGlobalNbId().GetNbId(), nbIdentity.GetGlobalNbId().GetNbId())
 522 }
 523
 524 func TestGetListGnbIdsNoIds(t *testing.T) {
 525         readerPool = nil
 526         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 527         w := GetRNibReader()
 528         var e error
 529         sdlInstanceMock.On("GetMembers", GnbType).Return([]string{}, e)
 530         ids, er := w.GetListGnbIds()
 531         assert.Nil(t, er)
 532         assert.Len(t, *ids, 0)
 533 }
 534
 535 func TestGetListGnbIds(t *testing.T) {
 536         name := "name"
 537         plmnId := 0x02f829
 538         nbId := 0x4a952a0a
 539         listSize := 3
 540         readerPool = nil
 541         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 542         w := GetRNibReader()
 543         idsData := make([]string, listSize)
 544         idsEntities := make([]*entities.NbIdentity, listSize)
 545         for i := 0; i < listSize; i++ {
 546                 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: string(plmnId + i), NbId: string(nbId + i)}}
 547                 data, err := proto.Marshal(nbIdentity)
 548                 if err != nil {
 549                         t.Errorf("#rNibReader_test.TestGetListGnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
 550                 }
 551                 idsData[i] = string(data)
 552                 idsEntities[i] = nbIdentity
 553         }
 554         var e error
 555         sdlInstanceMock.On("GetMembers", GnbType).Return(idsData, e)
 556         ids, er := w.GetListGnbIds()
 557         assert.Nil(t, er)
 558         assert.Len(t, *ids, listSize)
 559         for i, id := range *ids {
 560                 assert.Equal(t, id.GetInventoryName(), name)
 561                 assert.Equal(t, id.GetGlobalNbId().GetPlmnId(), idsEntities[i].GetGlobalNbId().GetPlmnId())
 562                 assert.Equal(t, id.GetGlobalNbId().GetNbId(), idsEntities[i].GetGlobalNbId().GetNbId())
 563         }
 564 }
 565
 566 func TestGetListEnbIdsSdlgoFailure(t *testing.T) {
 567         errMsg := "expected Sdlgo error"
 568         errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
 569         readerPool = nil
 570         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 571         w := GetRNibReader()
 572         e := errors.New(errMsg)
 573         var data []string
 574         sdlInstanceMock.On("GetMembers", EnbType).Return(data, e)
 575         ids, er := w.GetListEnbIds()
 576         assert.NotNil(t, er)
 577         assert.Nil(t, ids)
 578         assert.Equal(t, 2, er.GetCode())
 579         assert.EqualValues(t, errMsgExpected, er.Error())
 580 }
 581
 582 func TestGetCountGnbListOneId(t *testing.T) {
 583         readerPool = nil
 584         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 585         w := GetRNibReader()
 586         var e error
 587         sdlInstanceMock.On("GroupSize", GnbType).Return(1, e)
 588         count, er := w.GetCountGnbList()
 589         assert.Nil(t, er)
 590         assert.Equal(t, count, 1)
 591 }
 592
 593 func TestGetCountGnbList(t *testing.T) {
 594         readerPool = nil
 595         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 596         w := GetRNibReader()
 597         var e error
 598         sdlInstanceMock.On("GroupSize", GnbType).Return(3, e)
 599         count, er := w.GetCountGnbList()
 600         assert.Nil(t, er)
 601         assert.Equal(t, count, 3)
 602 }
 603
 604 func TestGetCountGnbListSdlgoFailure(t *testing.T) {
 605         errMsg := "expected Sdlgo error"
 606         errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
 607         readerPool = nil
 608         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 609         w := GetRNibReader()
 610         e := errors.New(errMsg)
 611         var count int
 612         sdlInstanceMock.On("GroupSize", GnbType).Return(count, e)
 613         count, er := w.GetCountGnbList()
 614         assert.NotNil(t, er)
 615         assert.Equal(t, 0, count)
 616         assert.Equal(t, 2, er.GetCode())
 617         assert.EqualValues(t, errMsgExpected, er.Error())
 618 }
 619
 620 func TestGetCell(t *testing.T) {
 621         name := "name"
 622         var pci uint32 = 10
 623         readerPool = nil
 624         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 625         w := GetRNibReader()
 626         cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: &entities.ServedCellInfo{Pci: pci}}}
 627         cellData, err := proto.Marshal(&cellEntity)
 628         if err != nil {
 629                 t.Errorf("#rNibReader_test.TestGetCell - Failed to marshal Cell entity. Error: %v", err)
 630         }
 631         var e error
 632         key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
 633         if rNibErr != nil {
 634                 t.Errorf("#rNibReader_test.TestGetCell - failed to validate key parameter")
 635         }
 636         ret := map[string]interface{}{key: string(cellData)}
 637         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
 638         cell, er := w.GetCell(name, pci)
 639         assert.Nil(t, er)
 640         assert.NotNil(t, cell)
 641         assert.Equal(t, cell.Type, entities.Cell_LTE_CELL)
 642         assert.NotNil(t, cell.GetServedCellInfo())
 643         assert.Equal(t, cell.GetServedCellInfo().GetPci(), pci)
 644 }
 645
 646 func TestGetCellNotFoundFailure(t *testing.T) {
 647         name := "name"
 648         var pci uint32
 649         readerPool = nil
 650         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 651         w := GetRNibReader()
 652         var e error
 653         var ret map[string]interface{}
 654         key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
 655         if rNibErr != nil {
 656                 t.Errorf("#rNibReader_test.TestGetCellNotFoundFailure - failed to validate key parameter")
 657         }
 658         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
 659         cell, er := w.GetCell(name, pci)
 660         assert.NotNil(t, er)
 661         assert.Nil(t, cell)
 662         assert.Equal(t, 1, er.GetCode())
 663         assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.getCellByKey - cell not found, key: PCI:name:00", er.Error())
 664 }
 665
 666 func TestGetCellUnmarshalFailure(t *testing.T) {
 667         name := "name"
 668         var pci uint32
 669         readerPool = nil
 670         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 671         w := GetRNibReader()
 672         var e error
 673         ret := make(map[string]interface{}, 1)
 674         key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
 675         if rNibErr != nil {
 676                 t.Errorf("#rNibReader_test.TestGetCellUnmarshalFailure - failed to validate key parameter")
 677         }
 678         ret[key] = "data"
 679         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
 680         cell, er := w.GetCell(name, pci)
 681         assert.NotNil(t, er)
 682         assert.Nil(t, cell)
 683         assert.Equal(t, 2, er.GetCode())
 684         assert.EqualValues(t, "2 INTERNAL_ERROR - proto: can't skip unknown wire type 4", er.Error())
 685 }
 686
 687 func TestGetCellSdlgoFailure(t *testing.T) {
 688         name := "name"
 689         var pci uint32
 690         errMsg := "expected Sdlgo error"
 691         errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
 692         readerPool = nil
 693         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 694         w := GetRNibReader()
 695         e := errors.New(errMsg)
 696         var ret map[string]interface{}
 697         key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
 698         if rNibErr != nil {
 699                 t.Errorf("#rNibReader_test.TestGetCellSdlgoFailure - failed to validate key parameter")
 700         }
 701         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
 702         cell, er := w.GetCell(name, pci)
 703         assert.NotNil(t, er)
 704         assert.Nil(t, cell)
 705         assert.Equal(t, 2, er.GetCode())
 706         assert.EqualValues(t, errMsgExpected, er.Error())
 707 }
 708
 709 func TestGetNodebById(t *testing.T) {
 710         readerPool = nil
 711         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 712         w := GetRNibReader()
 713         nb := entities.NodebInfo{NodeType: entities.Node_ENB}
 714         nb.ConnectionStatus = 1
 715         nb.Ip = "localhost"
 716         nb.Port = 5656
 717         enb := entities.Enb{}
 718         cell := entities.ServedCellInfo{Tac: "tac"}
 719         enb.ServedCells = []*entities.ServedCellInfo{&cell}
 720         nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
 721         var e error
 722         data, err := proto.Marshal(&nb)
 723         if err != nil {
 724                 t.Errorf("#rNibReader_test.TestGetNodebById - Failed to marshal ENB instance. Error: %v", err)
 725         }
 726
 727         plmnId := "02f829"
 728         nbId := "4a952a0a"
 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         ret := map[string]interface{}{key: string(data)}
 734         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
 735         globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
 736         getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
 737         assert.Nil(t, er)
 738         assert.Equal(t, getNb.Ip, nb.Ip)
 739         assert.Equal(t, getNb.Port, nb.Port)
 740         assert.Equal(t, getNb.ConnectionStatus, nb.ConnectionStatus)
 741         assert.Len(t, getNb.GetEnb().GetServedCells(), 1)
 742         assert.Equal(t, getNb.GetEnb().GetServedCells()[0].Tac, nb.GetEnb().GetServedCells()[0].Tac)
 743 }
 744
 745 func TestGetNodebByIdNotFoundFailureEnb(t *testing.T) {
 746         plmnId := "02f829"
 747         nbId := "4a952a0a"
 748         readerPool = nil
 749         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 750         w := GetRNibReader()
 751         var e error
 752         key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_ENB.String(), plmnId, nbId)
 753         if rNibErr != nil {
 754                 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
 755         }
 756         var ret map[string]interface{}
 757         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
 758         globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
 759         getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
 760         assert.NotNil(t, er)
 761         assert.Nil(t, getNb)
 762         assert.Equal(t, 1, er.GetCode())
 763         assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.getNodeb - responding node not found. Key: ENB:02f829:4a952a0a", er.Error())
 764 }
 765
 766 func TestGetNodebByIdNotFoundFailureGnb(t *testing.T) {
 767         plmnId := "02f829"
 768         nbId := "4a952a0a"
 769         readerPool = nil
 770         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 771         w := GetRNibReader()
 772         var e error
 773         key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_GNB.String(), plmnId, nbId)
 774         if rNibErr != nil {
 775                 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
 776         }
 777         var ret map[string]interface{}
 778         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
 779         globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
 780         getNb, er := w.GetNodebByGlobalNbId(entities.Node_GNB, globalNbId)
 781         assert.NotNil(t, er)
 782         assert.Nil(t, getNb)
 783         assert.Equal(t, 1, er.GetCode())
 784         assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.getNodeb - responding node not found. Key: GNB:02f829:4a952a0a", er.Error())
 785 }
 786
 787 func TestGetNodeByIdUnmarshalFailure(t *testing.T) {
 788         plmnId := "02f829"
 789         nbId := "4a952a0a"
 790         readerPool = nil
 791         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 792         w := GetRNibReader()
 793         key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_ENB.String(), plmnId, nbId)
 794         if rNibErr != nil {
 795                 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
 796         }
 797         var e error
 798         ret := make(map[string]interface{}, 1)
 799         ret[key] = "data"
 800         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
 801         globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
 802         getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
 803         assert.NotNil(t, er)
 804         assert.Nil(t, getNb)
 805         assert.Equal(t, 2, er.GetCode())
 806         assert.EqualValues(t, "2 INTERNAL_ERROR - proto: can't skip unknown wire type 4", er.Error())
 807 }
 808
 809 func TestGetNodeByIdSdlgoFailure(t *testing.T) {
 810         plmnId := "02f829"
 811         nbId := "4a952a0a"
 812         errMsg := "expected Sdlgo error"
 813         errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
 814         readerPool = nil
 815         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 816         w := GetRNibReader()
 817         key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_GNB.String(), plmnId, nbId)
 818         if rNibErr != nil {
 819                 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
 820         }
 821         e := errors.New(errMsg)
 822         var ret map[string]interface{}
 823         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
 824         globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
 825         getNb, er := w.GetNodebByGlobalNbId(entities.Node_GNB, globalNbId)
 826         assert.NotNil(t, er)
 827         assert.Nil(t, getNb)
 828         assert.Equal(t, 2, er.GetCode())
 829         assert.EqualValues(t, errMsgExpected, er.Error())
 830 }
 831
 832 func TestGetCellById(t *testing.T) {
 833         cellId := "aaaa"
 834         var pci uint32 = 10
 835         readerPool = nil
 836         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 837         w := GetRNibReader()
 838         cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: &entities.ServedCellInfo{Pci: pci}}}
 839         cellData, err := proto.Marshal(&cellEntity)
 840         if err != nil {
 841                 t.Errorf("#rNibReader_test.TestGetCellById - Failed to marshal Cell entity. Error: %v", err)
 842         }
 843         var e error
 844         key, rNibErr := common.ValidateAndBuildCellIdKey(cellId)
 845         if rNibErr != nil {
 846                 t.Errorf("#rNibReader_test.TestGetCellById - failed to validate key parameter")
 847         }
 848         ret := map[string]interface{}{key: string(cellData)}
 849         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
 850         cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
 851         assert.Nil(t, er)
 852         assert.NotNil(t, cell)
 853         assert.Equal(t, cell.Type, entities.Cell_LTE_CELL)
 854         assert.NotNil(t, cell.GetServedCellInfo())
 855         assert.Equal(t, cell.GetServedCellInfo().GetPci(), pci)
 856 }
 857
 858 func TestGetCellByIdNotFoundFailureEnb(t *testing.T) {
 859         cellId := "bbbb"
 860         readerPool = nil
 861         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 862         w := GetRNibReader()
 863         var e error
 864         var ret map[string]interface{}
 865         key, rNibErr := common.ValidateAndBuildCellIdKey(cellId)
 866         if rNibErr != nil {
 867                 t.Errorf("#rNibReader_test.TestGetCellByIdNotFoundFailure - failed to validate key parameter")
 868         }
 869         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
 870         cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
 871         assert.NotNil(t, er)
 872         assert.Nil(t, cell)
 873         assert.Equal(t, 1, er.GetCode())
 874         assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.getCellByKey - cell not found, key: CELL:bbbb", er.Error())
 875 }
 876
 877 func TestGetCellByIdNotFoundFailureGnb(t *testing.T) {
 878         cellId := "bbbb"
 879         readerPool = nil
 880         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 881         w := GetRNibReader()
 882         var e error
 883         var ret map[string]interface{}
 884         key, rNibErr := common.ValidateAndBuildNrCellIdKey(cellId)
 885         if rNibErr != nil {
 886                 t.Errorf("#rNibReader_test.TestGetCellByIdNotFoundFailure - failed to validate key parameter")
 887         }
 888         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
 889         cell, er := w.GetCellById(entities.Cell_NR_CELL, cellId)
 890         assert.NotNil(t, er)
 891         assert.Nil(t, cell)
 892         assert.Equal(t, 1, er.GetCode())
 893         assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.getCellByKey - cell not found, key: NRCELL:bbbb", er.Error())
 894 }
 895
 896 func TestGetCellByIdTypeValidationFailure(t *testing.T) {
 897         cellId := "dddd"
 898         readerPool = nil
 899         initSdlInstanceMock(namespace, 1)
 900         w := GetRNibReader()
 901         cell, er := w.GetCellById(5, cellId)
 902         assert.NotNil(t, er)
 903         assert.Nil(t, cell)
 904         assert.Equal(t, 3, er.GetCode())
 905         assert.EqualValues(t, "3 VALIDATION_ERROR - #rNibReader.GetCellById - invalid cell type: 5", er.Error())
 906 }
 907
 908 func TestGetCellByIdValidationFailureGnb(t *testing.T) {
 909         cellId := ""
 910         readerPool = nil
 911         initSdlInstanceMock(namespace, 1)
 912         w := GetRNibReader()
 913         cell, er := w.GetCellById(entities.Cell_NR_CELL, cellId)
 914         assert.NotNil(t, er)
 915         assert.Nil(t, cell)
 916         assert.Equal(t, 3, er.GetCode())
 917         assert.EqualValues(t, "3 VALIDATION_ERROR - #utils.ValidateAndBuildNrCellIdKey - an empty cell id received", er.Error())
 918 }
 919
 920 func TestGetCellByIdValidationFailureEnb(t *testing.T) {
 921         cellId := ""
 922         readerPool = nil
 923         initSdlInstanceMock(namespace, 1)
 924         w := GetRNibReader()
 925         cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
 926         assert.NotNil(t, er)
 927         assert.Nil(t, cell)
 928         assert.Equal(t, 3, er.GetCode())
 929         assert.EqualValues(t, "3 VALIDATION_ERROR - #utils.ValidateAndBuildCellIdKey - an empty cell id received", er.Error())
 930 }
 931
 932 //integration tests
 933
 934 //func TestGetEnbInteg(t *testing.T){
 935 //      name := "nameEnb1"
 936 //      Init("namespace", 1)
 937 //      w := GetRNibReader()
 938 //      nb, err := w.GetNodeb(name)
 939 //      if err != nil{
 940 //              fmt.Println(err)
 941 //      } else {
 942 //              fmt.Printf("#TestGetEnbInteg - responding node type: %v\n", nb)
 943 //      }
 944 //}
 945 //
 946 //func TestGetEnbCellsInteg(t *testing.T){
 947 //      name := "nameEnb1"
 948 //      Init("namespace", 1)
 949 //      w := GetRNibReader()
 950 //      cells, err := w.GetCellList(name)
 951 //      if err != nil{
 952 //              fmt.Println(err)
 953 //      } else if cells != nil{
 954 //              for _, cell := range cells.GetServedCellInfos().ServedCells{
 955 //                      fmt.Printf("responding node type Cell: %v\n", *cell)
 956 //              }
 957 //      }
 958 //}
 959 //
 960 //func TestGetGnbInteg(t *testing.T){
 961 //      name := "nameGnb1"
 962 //      Init("namespace", 1)
 963 //      w := GetRNibReader()
 964 //      nb, err := w.GetNodeb(name)
 965 //      if err != nil{
 966 //              fmt.Println(err)
 967 //      } else {
 968 //              fmt.Printf("#TestGetGnbInteg - responding node type: %v\n", nb)
 969 //      }
 970 //}
 971 //
 972 //func TestGetGnbCellsInteg(t *testing.T){
 973 //      name := "nameGnb1"
 974 //      Init("namespace", 1)
 975 //      w := GetRNibReader()
 976 //      cells, err := w.GetCellList(name)
 977 //      if err != nil{
 978 //              fmt.Println(err)
 979 //      } else if cells != nil{
 980 //              for _, cell := range cells.GetServedNrCells().ServedCells{
 981 //                      fmt.Printf("responding node type NR Cell: %v\n", *cell)
 982 //              }
 983 //      }
 984 //}
 985 //
 986 //func TestGetListEnbIdsInteg(t *testing.T) {
 987 //      Init("namespace", 1)
 988 //      w := GetRNibReader()
 989 //      ids, err := w.GetListEnbIds()
 990 //      if err != nil{
 991 //              fmt.Println(err)
 992 //      } else {
 993 //              for _, id := range *ids{
 994 //                      fmt.Printf("#TestGetListEnbIdsInteg - ENB ID: %s\n", id)
 995 //              }
 996 //      }
 997 //}
 998 //
 999 //func TestGetListGnbIdsInteg(t *testing.T) {
1000 //      Init("namespace", 1)
1001 //      w := GetRNibReader()
1002 //      ids, err := w.GetListGnbIds()
1003 //      if err != nil{
1004 //              fmt.Println(err)
1005 //      } else {
1006 //              for _, id := range *ids{
1007 //                      fmt.Printf("#TestGetListGnbIdsInteg - GNB ID: %s\n", id)
1008 //              }
1009 //      }
1010 //}
1011 //
1012 //func TestGetCountGnbListInteg(t *testing.T) {
1013 //      Init("namespace", 1)
1014 //      w := GetRNibReader()
1015 //      count, err := w.GetCountGnbList()
1016 //      if err != nil{
1017 //              fmt.Println(err)
1018 //      } else {
1019 //              fmt.Printf("#TestGetCountGnbListInteg - count Gnb list: %d\n", count)
1020 //      }
1021 //}
1022 //
1023 //func TestGetGnbCellInteg(t *testing.T){
1024 //      name := "nameGnb7"
1025 //      pci := 0x0a
1026 //      Init("namespace", 1)
1027 //      w := GetRNibReader()
1028 //      cell, err := w.GetCell(name, uint32(pci))
1029 //      if err != nil{
1030 //              fmt.Println(err)
1031 //      } else if cell != nil{
1032 //              fmt.Printf("responding node type NR Cell: %v\n", cell.GetServedNrCell())
1033 //      }
1034 //}
1035 //
1036 //func TestGetEnbCellInteg(t *testing.T) {
1037 //      name := "nameEnb1"
1038 //      pci := 0x22
1039 //      Init("namespace", 1)
1040 //      w := GetRNibReader()
1041 //      cell, err := w.GetCell(name, uint32(pci))
1042 //      if err != nil {
1043 //              fmt.Println(err)
1044 //      } else if cell != nil {
1045 //              fmt.Printf("responding node type LTE Cell: %v\n", cell.GetServedCellInfo())
1046 //      }
1047 //}
1048 //
1049 //func TestGetEnbCellByIdInteg(t *testing.T){
1050 //      Init("namespace", 1)
1051 //      w := GetRNibReader()
1052 //      cell, err := w.GetCellById(entities.Cell_NR_CELL, "45d")
1053 //      if err != nil{
1054 //              fmt.Println(err)
1055 //      } else if cell != nil{
1056 //              fmt.Printf("responding node type NR Cell: %v\n", cell.GetServedNrCell())
1057 //      }
1058 //}