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