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         "errors"
  22         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
  23         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
  24         "github.com/golang/protobuf/proto"
  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 := GetRNibReader()
  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 := GetRNibReader()
 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.Equal(t, 1, er.GetCode())
 122         assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.getNodeb - responding node 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 := GetRNibReader()
 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.Equal(t, 2, er.GetCode())
 142         assert.EqualValues(t, "2 INTERNAL_ERROR - 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 := "2 INTERNAL_ERROR - expected Sdlgo error"
 149         readerPool = nil
 150         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 151         w := GetRNibReader()
 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.Equal(t, 2, er.GetCode())
 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 := GetRNibReader()
 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 := GetRNibReader()
 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 := GetRNibReader()
 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.Equal(t, 2, er.GetCode())
 248         assert.EqualValues(t, "2 INTERNAL_ERROR - 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 := GetRNibReader()
 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.Equal(t, 1, er.GetCode())
 267         assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.getNodeb - responding node 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 := GetRNibReader()
 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, "1 RESOURCE_NOT_FOUND - #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 := GetRNibReader()
 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, "1 RESOURCE_NOT_FOUND - #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 := GetRNibReader()
 328         readerPool.Put(w1)
 329         available, created := readerPool.Stats()
 330         assert.Equal(t, 1, available, "number of available objects in the readerPool should be 1")
 331         assert.Equal(t, 1, created, "number of created objects in the readerPool should be 1")
 332         var e error
 333         instanceMock.On("Close").Return(e)
 334         Close()
 335         assert.Panics(t, func() { Close() })
 336 }
 337
 338 func TestCloseFailure(t *testing.T) {
 339         readerPool = nil
 340         instanceMock := initSdlInstanceMock(namespace, 2)
 341         w1 := GetRNibReader()
 342         readerPool.Put(w1)
 343         available, created := readerPool.Stats()
 344         assert.Equal(t, 1, available, "number of available objects in the readerPool should be 1")
 345         assert.Equal(t, 1, created, "number of created objects in the readerPool should be 1")
 346         e := errors.New("expected error")
 347         instanceMock.On("Close").Return(e)
 348         Close()
 349         available, created = readerPool.Stats()
 350         assert.Equal(t, 0, available, "number of available objects in the readerPool should be 0")
 351         assert.Equal(t, 0, created, "number of created objects in the readerPool should be 0")
 352 }
 353
 354 func TestGetListGnbIdsUnmarshalFailure(t *testing.T) {
 355         readerPool = nil
 356         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 357         w := GetRNibReader()
 358         var e error
 359         sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return([]string{"data"}, e)
 360         ids, er := w.GetListGnbIds()
 361         assert.NotNil(t, er)
 362         assert.Nil(t, ids)
 363         assert.Equal(t, 2, er.GetCode())
 364         assert.Equal(t, "2 INTERNAL_ERROR - proto: can't skip unknown wire type 4", er.Error())
 365 }
 366
 367 func TestGetListGnbIdsSdlgoFailure(t *testing.T) {
 368         errMsg := "expected Sdlgo error"
 369         errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
 370         readerPool = nil
 371         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 372         w := GetRNibReader()
 373         e := errors.New(errMsg)
 374         var data []string
 375         sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return(data, e)
 376         ids, er := w.GetListGnbIds()
 377         assert.NotNil(t, er)
 378         assert.Nil(t, ids)
 379         assert.Equal(t, 2, er.GetCode())
 380         assert.EqualValues(t, errMsgExpected, er.Error())
 381 }
 382
 383 func TestGetListNodesIdsGnbSdlgoFailure(t *testing.T) {
 384
 385         readerPool = nil
 386         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 387         w := GetRNibReader()
 388
 389         name := "name"
 390         plmnId := "02f829"
 391         nbId := "4a952a0a"
 392         nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
 393         var nilError error
 394         data, err := proto.Marshal(nbIdentity)
 395         if err != nil {
 396                 t.Errorf("#rNibReader_test.TestGetListNodesIdsGnbSdlgoFailure - Failed to marshal nodeb identity entity. Error: %v", err)
 397         }
 398         sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{string(data)}, nilError)
 399
 400         errMsg := "expected Sdlgo error"
 401         errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
 402         expectedError := errors.New(errMsg)
 403         var nilData []string
 404         sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return(nilData, expectedError)
 405
 406         ids, er := w.GetListNodebIds()
 407         assert.NotNil(t, er)
 408         assert.Nil(t, ids)
 409         assert.Equal(t, 2, er.GetCode())
 410         assert.EqualValues(t, errMsgExpected, er.Error())
 411 }
 412
 413 func TestGetListNodesIdsEnbSdlgoFailure(t *testing.T) {
 414
 415         readerPool = nil
 416         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 417         w := GetRNibReader()
 418
 419         name := "name"
 420         plmnId := "02f829"
 421         nbId := "4a952a0a"
 422         nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
 423         var nilError error
 424         data, err := proto.Marshal(nbIdentity)
 425         if err != nil {
 426                 t.Errorf("#rNibReader_test.TestGetListNodesIdsEnbSdlgoFailure - Failed to marshal nodeb identity entity. Error: %v", err)
 427         }
 428         sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return([]string{string(data)}, nilError)
 429
 430         errMsg := "expected Sdlgo error"
 431         errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
 432         expectedError := errors.New(errMsg)
 433         var nilData []string
 434         sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return(nilData, expectedError)
 435
 436         ids, er := w.GetListNodebIds()
 437         assert.NotNil(t, er)
 438         assert.Nil(t, ids)
 439         assert.Equal(t, 2, er.GetCode())
 440         assert.EqualValues(t, errMsgExpected, er.Error())
 441 }
 442
 443 func TestGetListNodesIdsSuccess(t *testing.T) {
 444
 445         readerPool = nil
 446         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 447         w := GetRNibReader()
 448         var nilError error
 449
 450         name := "name"
 451         plmnId := "02f829"
 452         nbId := "4a952a0a"
 453         nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
 454         data, err := proto.Marshal(nbIdentity)
 455         if err != nil {
 456                 t.Errorf("#rNibReader_test.TestGetListNodesIdsSuccess - Failed to marshal nodeb identity entity. Error: %v", err)
 457         }
 458
 459         name1 := "name1"
 460         plmnId1 := "02f845"
 461         nbId1 := "4a952a75"
 462         nbIdentity1 := &entities.NbIdentity{InventoryName: name1, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId1, NbId: nbId1}}
 463         data1, err := proto.Marshal(nbIdentity1)
 464         if err != nil {
 465                 t.Errorf("#rNibReader_test.TestGetListNodesIdsSuccess - Failed to marshal nodeb identity entity. Error: %v", err)
 466         }
 467
 468         name2 := "name2"
 469         nbIdentity2 := &entities.NbIdentity{InventoryName: name2}
 470         data2, err := proto.Marshal(nbIdentity2)
 471         if err != nil {
 472                 t.Errorf("#rNibReader_test.TestGetListNodesIdsSuccess - Failed to marshal nodeb identity entity. Error: %v", err)
 473         }
 474
 475         sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return([]string{string(data)}, nilError)
 476         sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{string(data1)}, nilError)
 477         sdlInstanceMock.On("GetMembers", entities.Node_UNKNOWN.String()).Return([]string{string(data2)}, nilError)
 478
 479         ids, er := w.GetListNodebIds()
 480         assert.Nil(t, er)
 481         assert.NotNil(t, ids)
 482         assert.Len(t, ids, 3)
 483 }
 484
 485 func TestGetListEnbIdsUnmarshalFailure(t *testing.T) {
 486         readerPool = nil
 487         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 488         w := GetRNibReader()
 489         var e error
 490         sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{"data"}, e)
 491         ids, er := w.GetListEnbIds()
 492         assert.NotNil(t, er)
 493         assert.Nil(t, ids)
 494         assert.Equal(t, 2, er.GetCode())
 495         assert.Equal(t, "2 INTERNAL_ERROR - proto: can't skip unknown wire type 4", er.Error())
 496 }
 497
 498 func TestGetListEnbIdsOneId(t *testing.T) {
 499         name := "name"
 500         plmnId := "02f829"
 501         nbId := "4a952a0a"
 502         readerPool = nil
 503         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 504         w := GetRNibReader()
 505         nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
 506         var e error
 507         data, err := proto.Marshal(nbIdentity)
 508         if err != nil {
 509                 t.Errorf("#rNibReader_test.TestGetListEnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
 510         }
 511         sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{string(data)}, e)
 512         ids, er := w.GetListEnbIds()
 513         assert.Nil(t, er)
 514         assert.Len(t, *ids, 1)
 515         assert.Equal(t, (*ids)[0].GetInventoryName(), name)
 516         assert.Equal(t, (*ids)[0].GetGlobalNbId().GetPlmnId(), nbIdentity.GetGlobalNbId().GetPlmnId())
 517         assert.Equal(t, (*ids)[0].GetGlobalNbId().GetNbId(), nbIdentity.GetGlobalNbId().GetNbId())
 518 }
 519
 520 func TestGetListEnbIdsNoIds(t *testing.T) {
 521         readerPool = nil
 522         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 523         w := GetRNibReader()
 524         var e error
 525         sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{}, e)
 526         ids, er := w.GetListEnbIds()
 527         assert.Nil(t, er)
 528         assert.Len(t, *ids, 0)
 529 }
 530
 531 func TestGetListEnbIds(t *testing.T) {
 532         name := "name"
 533         plmnId := 0x02f829
 534         nbId := 0x4a952a0a
 535         listSize := 3
 536         readerPool = nil
 537         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 538         w := GetRNibReader()
 539         idsData := make([]string, listSize)
 540         idsEntities := make([]*entities.NbIdentity, listSize)
 541         for i := 0; i < listSize; i++ {
 542                 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: string(plmnId + i), NbId: string(nbId + i)}}
 543                 data, err := proto.Marshal(nbIdentity)
 544                 if err != nil {
 545                         t.Errorf("#rNibReader_test.TestGetListEnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
 546                 }
 547                 idsData[i] = string(data)
 548                 idsEntities[i] = nbIdentity
 549         }
 550         var e error
 551         sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return(idsData, e)
 552         ids, er := w.GetListEnbIds()
 553         assert.Nil(t, er)
 554         assert.Len(t, *ids, listSize)
 555         for i, id := range *ids {
 556                 assert.Equal(t, id.GetInventoryName(), name)
 557                 assert.Equal(t, id.GetGlobalNbId().GetPlmnId(), idsEntities[i].GetGlobalNbId().GetPlmnId())
 558                 assert.Equal(t, id.GetGlobalNbId().GetNbId(), idsEntities[i].GetGlobalNbId().GetNbId())
 559         }
 560 }
 561
 562 func TestGetListGnbIdsOneId(t *testing.T) {
 563         name := "name"
 564         plmnId := "02f829"
 565         nbId := "4a952a0a"
 566         readerPool = nil
 567         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 568         w := GetRNibReader()
 569         nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
 570         var e error
 571         data, err := proto.Marshal(nbIdentity)
 572         if err != nil {
 573                 t.Errorf("#rNibReader_test.TestGetListGnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
 574         }
 575         sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return([]string{string(data)}, e)
 576         ids, er := w.GetListGnbIds()
 577         assert.Nil(t, er)
 578         assert.Len(t, *ids, 1)
 579         assert.Equal(t, (*ids)[0].GetInventoryName(), name)
 580         assert.Equal(t, (*ids)[0].GetGlobalNbId().GetPlmnId(), nbIdentity.GetGlobalNbId().GetPlmnId())
 581         assert.Equal(t, (*ids)[0].GetGlobalNbId().GetNbId(), nbIdentity.GetGlobalNbId().GetNbId())
 582 }
 583
 584 func TestGetListGnbIdsNoIds(t *testing.T) {
 585         readerPool = nil
 586         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 587         w := GetRNibReader()
 588         var e error
 589         sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return([]string{}, e)
 590         ids, er := w.GetListGnbIds()
 591         assert.Nil(t, er)
 592         assert.Len(t, *ids, 0)
 593 }
 594
 595 func TestGetListGnbIds(t *testing.T) {
 596         name := "name"
 597         plmnId := 0x02f829
 598         nbId := 0x4a952a0a
 599         listSize := 3
 600         readerPool = nil
 601         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 602         w := GetRNibReader()
 603         idsData := make([]string, listSize)
 604         idsEntities := make([]*entities.NbIdentity, listSize)
 605         for i := 0; i < listSize; i++ {
 606                 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: string(plmnId + i), NbId: string(nbId + i)}}
 607                 data, err := proto.Marshal(nbIdentity)
 608                 if err != nil {
 609                         t.Errorf("#rNibReader_test.TestGetListGnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
 610                 }
 611                 idsData[i] = string(data)
 612                 idsEntities[i] = nbIdentity
 613         }
 614         var e error
 615         sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return(idsData, e)
 616         ids, er := w.GetListGnbIds()
 617         assert.Nil(t, er)
 618         assert.Len(t, *ids, listSize)
 619         for i, id := range *ids {
 620                 assert.Equal(t, id.GetInventoryName(), name)
 621                 assert.Equal(t, id.GetGlobalNbId().GetPlmnId(), idsEntities[i].GetGlobalNbId().GetPlmnId())
 622                 assert.Equal(t, id.GetGlobalNbId().GetNbId(), idsEntities[i].GetGlobalNbId().GetNbId())
 623         }
 624 }
 625
 626 func TestGetListEnbIdsSdlgoFailure(t *testing.T) {
 627         errMsg := "expected Sdlgo error"
 628         errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
 629         readerPool = nil
 630         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 631         w := GetRNibReader()
 632         e := errors.New(errMsg)
 633         var data []string
 634         sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return(data, e)
 635         ids, er := w.GetListEnbIds()
 636         assert.NotNil(t, er)
 637         assert.Nil(t, ids)
 638         assert.Equal(t, 2, er.GetCode())
 639         assert.EqualValues(t, errMsgExpected, er.Error())
 640 }
 641
 642 func TestGetCountGnbListOneId(t *testing.T) {
 643         readerPool = nil
 644         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 645         w := GetRNibReader()
 646         var e error
 647         sdlInstanceMock.On("GroupSize", entities.Node_GNB.String()).Return(1, e)
 648         count, er := w.GetCountGnbList()
 649         assert.Nil(t, er)
 650         assert.Equal(t, count, 1)
 651 }
 652
 653 func TestGetCountGnbList(t *testing.T) {
 654         readerPool = nil
 655         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 656         w := GetRNibReader()
 657         var e error
 658         sdlInstanceMock.On("GroupSize", entities.Node_GNB.String()).Return(3, e)
 659         count, er := w.GetCountGnbList()
 660         assert.Nil(t, er)
 661         assert.Equal(t, count, 3)
 662 }
 663
 664 func TestGetCountGnbListSdlgoFailure(t *testing.T) {
 665         errMsg := "expected Sdlgo error"
 666         errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
 667         readerPool = nil
 668         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 669         w := GetRNibReader()
 670         e := errors.New(errMsg)
 671         var count int
 672         sdlInstanceMock.On("GroupSize", entities.Node_GNB.String()).Return(count, e)
 673         count, er := w.GetCountGnbList()
 674         assert.NotNil(t, er)
 675         assert.Equal(t, 0, count)
 676         assert.Equal(t, 2, er.GetCode())
 677         assert.EqualValues(t, errMsgExpected, er.Error())
 678 }
 679
 680 func TestGetCell(t *testing.T) {
 681         name := "name"
 682         var pci uint32 = 10
 683         readerPool = nil
 684         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 685         w := GetRNibReader()
 686         cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: &entities.ServedCellInfo{Pci: pci}}}
 687         cellData, err := proto.Marshal(&cellEntity)
 688         if err != nil {
 689                 t.Errorf("#rNibReader_test.TestGetCell - Failed to marshal Cell entity. Error: %v", err)
 690         }
 691         var e error
 692         key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
 693         if rNibErr != nil {
 694                 t.Errorf("#rNibReader_test.TestGetCell - failed to validate key parameter")
 695         }
 696         ret := map[string]interface{}{key: string(cellData)}
 697         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
 698         cell, er := w.GetCell(name, pci)
 699         assert.Nil(t, er)
 700         assert.NotNil(t, cell)
 701         assert.Equal(t, cell.Type, entities.Cell_LTE_CELL)
 702         assert.NotNil(t, cell.GetServedCellInfo())
 703         assert.Equal(t, cell.GetServedCellInfo().GetPci(), pci)
 704 }
 705
 706 func TestGetCellNotFoundFailure(t *testing.T) {
 707         name := "name"
 708         var pci uint32
 709         readerPool = nil
 710         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 711         w := GetRNibReader()
 712         var e error
 713         var ret map[string]interface{}
 714         key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
 715         if rNibErr != nil {
 716                 t.Errorf("#rNibReader_test.TestGetCellNotFoundFailure - failed to validate key parameter")
 717         }
 718         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
 719         cell, er := w.GetCell(name, pci)
 720         assert.NotNil(t, er)
 721         assert.Nil(t, cell)
 722         assert.Equal(t, 1, er.GetCode())
 723         assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.getCellByKey - cell not found, key: PCI:name:00", er.Error())
 724 }
 725
 726 func TestGetCellUnmarshalFailure(t *testing.T) {
 727         name := "name"
 728         var pci uint32
 729         readerPool = nil
 730         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 731         w := GetRNibReader()
 732         var e error
 733         ret := make(map[string]interface{}, 1)
 734         key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
 735         if rNibErr != nil {
 736                 t.Errorf("#rNibReader_test.TestGetCellUnmarshalFailure - failed to validate key parameter")
 737         }
 738         ret[key] = "data"
 739         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
 740         cell, er := w.GetCell(name, pci)
 741         assert.NotNil(t, er)
 742         assert.Nil(t, cell)
 743         assert.Equal(t, 2, er.GetCode())
 744         assert.EqualValues(t, "2 INTERNAL_ERROR - proto: can't skip unknown wire type 4", er.Error())
 745 }
 746
 747 func TestGetCellSdlgoFailure(t *testing.T) {
 748         name := "name"
 749         var pci uint32
 750         errMsg := "expected Sdlgo error"
 751         errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
 752         readerPool = nil
 753         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 754         w := GetRNibReader()
 755         e := errors.New(errMsg)
 756         var ret map[string]interface{}
 757         key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
 758         if rNibErr != nil {
 759                 t.Errorf("#rNibReader_test.TestGetCellSdlgoFailure - failed to validate key parameter")
 760         }
 761         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
 762         cell, er := w.GetCell(name, pci)
 763         assert.NotNil(t, er)
 764         assert.Nil(t, cell)
 765         assert.Equal(t, 2, er.GetCode())
 766         assert.EqualValues(t, errMsgExpected, er.Error())
 767 }
 768
 769 func TestGetNodebById(t *testing.T) {
 770         readerPool = nil
 771         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 772         w := GetRNibReader()
 773         nb := entities.NodebInfo{NodeType: entities.Node_ENB}
 774         nb.ConnectionStatus = 1
 775         nb.Ip = "localhost"
 776         nb.Port = 5656
 777         enb := entities.Enb{}
 778         cell := entities.ServedCellInfo{Tac: "tac"}
 779         enb.ServedCells = []*entities.ServedCellInfo{&cell}
 780         nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
 781         var e error
 782         data, err := proto.Marshal(&nb)
 783         if err != nil {
 784                 t.Errorf("#rNibReader_test.TestGetNodebById - Failed to marshal ENB instance. Error: %v", err)
 785         }
 786
 787         plmnId := "02f829"
 788         nbId := "4a952a0a"
 789         key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_ENB.String(), plmnId, nbId)
 790         if rNibErr != nil {
 791                 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
 792         }
 793         ret := map[string]interface{}{key: string(data)}
 794         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
 795         globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
 796         getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
 797         assert.Nil(t, er)
 798         assert.Equal(t, getNb.Ip, nb.Ip)
 799         assert.Equal(t, getNb.Port, nb.Port)
 800         assert.Equal(t, getNb.ConnectionStatus, nb.ConnectionStatus)
 801         assert.Len(t, getNb.GetEnb().GetServedCells(), 1)
 802         assert.Equal(t, getNb.GetEnb().GetServedCells()[0].Tac, nb.GetEnb().GetServedCells()[0].Tac)
 803 }
 804
 805 func TestGetNodebByIdNotFoundFailureEnb(t *testing.T) {
 806         plmnId := "02f829"
 807         nbId := "4a952a0a"
 808         readerPool = nil
 809         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 810         w := GetRNibReader()
 811         var e error
 812         key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_ENB.String(), plmnId, nbId)
 813         if rNibErr != nil {
 814                 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
 815         }
 816         var ret map[string]interface{}
 817         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
 818         globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
 819         getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
 820         assert.NotNil(t, er)
 821         assert.Nil(t, getNb)
 822         assert.Equal(t, 1, er.GetCode())
 823         assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.getNodeb - responding node not found. Key: ENB:02f829:4a952a0a", er.Error())
 824 }
 825
 826 func TestGetNodebByIdNotFoundFailureGnb(t *testing.T) {
 827         plmnId := "02f829"
 828         nbId := "4a952a0a"
 829         readerPool = nil
 830         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 831         w := GetRNibReader()
 832         var e error
 833         key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_GNB.String(), plmnId, nbId)
 834         if rNibErr != nil {
 835                 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
 836         }
 837         var ret map[string]interface{}
 838         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
 839         globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
 840         getNb, er := w.GetNodebByGlobalNbId(entities.Node_GNB, globalNbId)
 841         assert.NotNil(t, er)
 842         assert.Nil(t, getNb)
 843         assert.Equal(t, 1, er.GetCode())
 844         assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.getNodeb - responding node not found. Key: GNB:02f829:4a952a0a", er.Error())
 845 }
 846
 847 func TestGetNodeByIdUnmarshalFailure(t *testing.T) {
 848         plmnId := "02f829"
 849         nbId := "4a952a0a"
 850         readerPool = nil
 851         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 852         w := GetRNibReader()
 853         key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_ENB.String(), plmnId, nbId)
 854         if rNibErr != nil {
 855                 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
 856         }
 857         var e error
 858         ret := make(map[string]interface{}, 1)
 859         ret[key] = "data"
 860         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
 861         globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
 862         getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
 863         assert.NotNil(t, er)
 864         assert.Nil(t, getNb)
 865         assert.Equal(t, 2, er.GetCode())
 866         assert.EqualValues(t, "2 INTERNAL_ERROR - proto: can't skip unknown wire type 4", er.Error())
 867 }
 868
 869 func TestGetNodeByIdSdlgoFailure(t *testing.T) {
 870         plmnId := "02f829"
 871         nbId := "4a952a0a"
 872         errMsg := "expected Sdlgo error"
 873         errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
 874         readerPool = nil
 875         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 876         w := GetRNibReader()
 877         key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_GNB.String(), plmnId, nbId)
 878         if rNibErr != nil {
 879                 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
 880         }
 881         e := errors.New(errMsg)
 882         var ret map[string]interface{}
 883         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
 884         globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
 885         getNb, er := w.GetNodebByGlobalNbId(entities.Node_GNB, globalNbId)
 886         assert.NotNil(t, er)
 887         assert.Nil(t, getNb)
 888         assert.Equal(t, 2, er.GetCode())
 889         assert.EqualValues(t, errMsgExpected, er.Error())
 890 }
 891
 892 func TestGetCellById(t *testing.T) {
 893         cellId := "aaaa"
 894         var pci uint32 = 10
 895         readerPool = nil
 896         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 897         w := GetRNibReader()
 898         cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: &entities.ServedCellInfo{Pci: pci}}}
 899         cellData, err := proto.Marshal(&cellEntity)
 900         if err != nil {
 901                 t.Errorf("#rNibReader_test.TestGetCellById - Failed to marshal Cell entity. Error: %v", err)
 902         }
 903         var e error
 904         key, rNibErr := common.ValidateAndBuildCellIdKey(cellId)
 905         if rNibErr != nil {
 906                 t.Errorf("#rNibReader_test.TestGetCellById - failed to validate key parameter")
 907         }
 908         ret := map[string]interface{}{key: string(cellData)}
 909         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
 910         cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
 911         assert.Nil(t, er)
 912         assert.NotNil(t, cell)
 913         assert.Equal(t, cell.Type, entities.Cell_LTE_CELL)
 914         assert.NotNil(t, cell.GetServedCellInfo())
 915         assert.Equal(t, cell.GetServedCellInfo().GetPci(), pci)
 916 }
 917
 918 func TestGetCellByIdNotFoundFailureEnb(t *testing.T) {
 919         cellId := "bbbb"
 920         readerPool = nil
 921         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 922         w := GetRNibReader()
 923         var e error
 924         var ret map[string]interface{}
 925         key, rNibErr := common.ValidateAndBuildCellIdKey(cellId)
 926         if rNibErr != nil {
 927                 t.Errorf("#rNibReader_test.TestGetCellByIdNotFoundFailure - failed to validate key parameter")
 928         }
 929         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
 930         cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
 931         assert.NotNil(t, er)
 932         assert.Nil(t, cell)
 933         assert.Equal(t, 1, er.GetCode())
 934         assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.getCellByKey - cell not found, key: CELL:bbbb", er.Error())
 935 }
 936
 937 func TestGetCellByIdNotFoundFailureGnb(t *testing.T) {
 938         cellId := "bbbb"
 939         readerPool = nil
 940         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 941         w := GetRNibReader()
 942         var e error
 943         var ret map[string]interface{}
 944         key, rNibErr := common.ValidateAndBuildNrCellIdKey(cellId)
 945         if rNibErr != nil {
 946                 t.Errorf("#rNibReader_test.TestGetCellByIdNotFoundFailure - failed to validate key parameter")
 947         }
 948         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
 949         cell, er := w.GetCellById(entities.Cell_NR_CELL, cellId)
 950         assert.NotNil(t, er)
 951         assert.Nil(t, cell)
 952         assert.Equal(t, 1, er.GetCode())
 953         assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.getCellByKey - cell not found, key: NRCELL:bbbb", er.Error())
 954 }
 955
 956 func TestGetCellByIdTypeValidationFailure(t *testing.T) {
 957         cellId := "dddd"
 958         readerPool = nil
 959         initSdlInstanceMock(namespace, 1)
 960         w := GetRNibReader()
 961         cell, er := w.GetCellById(5, cellId)
 962         assert.NotNil(t, er)
 963         assert.Nil(t, cell)
 964         assert.Equal(t, 3, er.GetCode())
 965         assert.EqualValues(t, "3 VALIDATION_ERROR - #rNibReader.GetCellById - invalid cell type: 5", er.Error())
 966 }
 967
 968 func TestGetCellByIdValidationFailureGnb(t *testing.T) {
 969         cellId := ""
 970         readerPool = nil
 971         initSdlInstanceMock(namespace, 1)
 972         w := GetRNibReader()
 973         cell, er := w.GetCellById(entities.Cell_NR_CELL, cellId)
 974         assert.NotNil(t, er)
 975         assert.Nil(t, cell)
 976         assert.Equal(t, 3, er.GetCode())
 977         assert.EqualValues(t, "3 VALIDATION_ERROR - #utils.ValidateAndBuildNrCellIdKey - an empty cell id received", er.Error())
 978 }
 979
 980 func TestGetCellByIdValidationFailureEnb(t *testing.T) {
 981         cellId := ""
 982         readerPool = nil
 983         initSdlInstanceMock(namespace, 1)
 984         w := GetRNibReader()
 985         cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
 986         assert.NotNil(t, er)
 987         assert.Nil(t, cell)
 988         assert.Equal(t, 3, er.GetCode())
 989         assert.EqualValues(t, "3 VALIDATION_ERROR - #utils.ValidateAndBuildCellIdKey - an empty cell id received", er.Error())
 990 }
 991
 992 func TestGetRanLoadInformation(t *testing.T) {
 993         name := "name"
 994         readerPool = nil
 995         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
 996         w := GetRNibReader()
 997         loadInfo := generateRanLoadInformation()
 998         var e error
 999         data, err := proto.Marshal(loadInfo)
1000         if err != nil {
1001                 t.Errorf("#rNibReader_test.TestGetRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
1002         }
1003         redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
1004         if rNibErr != nil {
1005                 t.Errorf("#rNibReader_test.TestGetRanLoadInformationNotFoundFailure - failed to validate key parameter")
1006         }
1007         ret := map[string]interface{}{redisKey: string(data)}
1008         sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
1009         getLoadInfo, er := w.GetRanLoadInformation(name)
1010         assert.Nil(t, er)
1011         assert.NotNil(t, getLoadInfo)
1012         expected, err := json.Marshal(loadInfo)
1013         if err != nil {
1014                 t.Errorf("#rNibReader_test.TestGetRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
1015         }
1016         actual, err := json.Marshal(getLoadInfo)
1017         if err != nil {
1018                 t.Errorf("#rNibReader_test.TestGetRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
1019         }
1020         assert.EqualValues(t, expected, actual)
1021 }
1022
1023 func TestGetRanLoadInformationNotFoundFailure(t *testing.T) {
1024         name := "name"
1025         readerPool = nil
1026         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
1027         w := GetRNibReader()
1028         var e error
1029         var ret map[string]interface{}
1030         redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
1031         if rNibErr != nil {
1032                 t.Errorf("#rNibReader_test.TestGetRanLoadInformationNotFoundFailure - failed to validate key parameter")
1033         }
1034         sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
1035         getNb, er := w.GetRanLoadInformation(name)
1036         assert.NotNil(t, er)
1037         assert.Nil(t, getNb)
1038         assert.Equal(t, 1, er.GetCode())
1039         assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.getByKeyAndUnmarshal - entity of type *entities.RanLoadInformation not found. Key: LOAD:name", er.Error())
1040 }
1041
1042 func TestGetRanLoadInformationUnmarshalFailure(t *testing.T) {
1043         name := "name"
1044         readerPool = nil
1045         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
1046         w := GetRNibReader()
1047         var e error
1048         ret := make(map[string]interface{}, 1)
1049         redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
1050         if rNibErr != nil {
1051                 t.Errorf("#rNibReader_test.TestGetRanLoadInformationUnmarshalFailure - failed to validate key parameter")
1052         }
1053         ret[redisKey] = "data"
1054         sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
1055         getNb, er := w.GetRanLoadInformation(name)
1056         assert.NotNil(t, er)
1057         assert.Nil(t, getNb)
1058         assert.Equal(t, 2, er.GetCode())
1059         assert.EqualValues(t, "2 INTERNAL_ERROR - proto: can't skip unknown wire type 4", er.Error())
1060 }
1061
1062 func TestGetRanLoadInformationSdlgoFailure(t *testing.T) {
1063         name := "name"
1064         errMsg := "expected Sdlgo error"
1065         errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
1066         readerPool = nil
1067         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
1068         w := GetRNibReader()
1069         e := errors.New(errMsg)
1070         var ret map[string]interface{}
1071         redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
1072         if rNibErr != nil {
1073                 t.Errorf("#rNibReader_test.TestGetRanLoadInformationSdlgoFailure - failed to validate key parameter")
1074         }
1075         sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
1076         getNb, er := w.GetRanLoadInformation(name)
1077         assert.NotNil(t, er)
1078         assert.Nil(t, getNb)
1079         assert.Equal(t, 2, er.GetCode())
1080         assert.EqualValues(t, errMsgExpected, er.Error())
1081 }
1082
1083 func generateCellLoadInformation() *entities.CellLoadInformation {
1084         cellLoadInformation := entities.CellLoadInformation{}
1085
1086         cellLoadInformation.CellId = "123"
1087
1088         ulInterferenceOverloadIndication := entities.UlInterferenceOverloadIndication_HIGH_INTERFERENCE
1089         cellLoadInformation.UlInterferenceOverloadIndications = []entities.UlInterferenceOverloadIndication{ulInterferenceOverloadIndication}
1090
1091         ulHighInterferenceInformation := entities.UlHighInterferenceInformation{
1092                 TargetCellId:"456",
1093                 UlHighInterferenceIndication:"xxx",
1094         }
1095
1096         cellLoadInformation.UlHighInterferenceInfos = []*entities.UlHighInterferenceInformation{&ulHighInterferenceInformation }
1097
1098         cellLoadInformation.RelativeNarrowbandTxPower = &entities.RelativeNarrowbandTxPower{
1099                 RntpPerPrb:"xxx",
1100                 RntpThreshold:entities.RntpThreshold_NEG_4,
1101                 NumberOfCellSpecificAntennaPorts: entities.NumberOfCellSpecificAntennaPorts_V1_ANT_PRT,
1102                 PB: 1,
1103                 PdcchInterferenceImpact:2,
1104                 EnhancedRntp: &entities.EnhancedRntp{
1105                         EnhancedRntpBitmap:"xxx",
1106                         RntpHighPowerThreshold:entities.RntpThreshold_NEG_2,
1107                         EnhancedRntpStartTime: &entities.StartTime{StartSfn:500,StartSubframeNumber:5},
1108                 },
1109         }
1110
1111         cellLoadInformation.AbsInformation = &entities.AbsInformation{
1112                 Mode: entities.AbsInformationMode_ABS_INFO_FDD,
1113                 AbsPatternInfo:"xxx",
1114                 NumberOfCellSpecificAntennaPorts:entities.NumberOfCellSpecificAntennaPorts_V2_ANT_PRT,
1115                 MeasurementSubset:"xxx",
1116         }
1117
1118         cellLoadInformation.InvokeIndication = entities.InvokeIndication_ABS_INFORMATION
1119
1120         cellLoadInformation.ExtendedUlInterferenceOverloadInfo = &entities.ExtendedUlInterferenceOverloadInfo{
1121                 AssociatedSubframes:"xxx",
1122                 ExtendedUlInterferenceOverloadIndications:cellLoadInformation.UlInterferenceOverloadIndications,
1123         }
1124
1125         compInformationItem := &entities.CompInformationItem{
1126                 CompHypothesisSets: []*entities.CompHypothesisSet{&entities.CompHypothesisSet{CellId: "789", CompHypothesis:"xxx"}},
1127                 BenefitMetric:50,
1128         }
1129
1130         cellLoadInformation.CompInformation = &entities.CompInformation{
1131                 CompInformationItems:[]*entities.CompInformationItem{compInformationItem},
1132                 CompInformationStartTime:&entities.StartTime{StartSfn:123,StartSubframeNumber:456},
1133         }
1134
1135         cellLoadInformation.DynamicDlTransmissionInformation = &entities.DynamicDlTransmissionInformation{
1136                 State: entities.NaicsState_NAICS_ACTIVE,
1137                 TransmissionModes:"xxx",
1138                 PB: 2,
1139                 PAList:[]entities.PA{entities.PA_DB_NEG_3},
1140         }
1141
1142         return &cellLoadInformation
1143 }
1144
1145 func generateRanLoadInformation() *entities.RanLoadInformation {
1146         ranLoadInformation := entities.RanLoadInformation{}
1147
1148         ranLoadInformation.LoadTimestamp = uint64(time.Now().UnixNano())
1149
1150         cellLoadInformation := generateCellLoadInformation()
1151         ranLoadInformation.CellLoadInfos = []*entities.CellLoadInformation{cellLoadInformation}
1152
1153         return &ranLoadInformation
1154 }
1155
1156 //integration tests
1157
1158 //func TestGetEnbInteg(t *testing.T){
1159 //      name := "nameEnb1"
1160 //      Init("namespace", 1)
1161 //      w := GetRNibReader()
1162 //      nb, err := w.GetNodeb(name)
1163 //      if err != nil{
1164 //              fmt.Println(err)
1165 //      } else {
1166 //              fmt.Printf("#TestGetEnbInteg - responding node type: %v\n", nb)
1167 //      }
1168 //}
1169 //
1170 //func TestGetEnbCellsInteg(t *testing.T){
1171 //      name := "nameEnb1"
1172 //      Init("namespace", 1)
1173 //      w := GetRNibReader()
1174 //      cells, err := w.GetCellList(name)
1175 //      if err != nil{
1176 //              fmt.Println(err)
1177 //      } else if cells != nil{
1178 //              for _, cell := range cells.GetServedCellInfos().ServedCells{
1179 //                      fmt.Printf("responding node type Cell: %v\n", *cell)
1180 //              }
1181 //      }
1182 //}
1183 //
1184 //func TestGetGnbInteg(t *testing.T){
1185 //      name := "nameGnb1"
1186 //      Init("namespace", 1)
1187 //      w := GetRNibReader()
1188 //      nb, err := w.GetNodeb(name)
1189 //      if err != nil{
1190 //              fmt.Println(err)
1191 //      } else {
1192 //              fmt.Printf("#TestGetGnbInteg - responding node type: %v\n", nb)
1193 //      }
1194 //}
1195 //
1196 //func TestGetGnbCellsInteg(t *testing.T){
1197 //      name := "nameGnb1"
1198 //      Init("namespace", 1)
1199 //      w := GetRNibReader()
1200 //      cells, err := w.GetCellList(name)
1201 //      if err != nil{
1202 //              fmt.Println(err)
1203 //      } else if cells != nil{
1204 //              for _, cell := range cells.GetServedNrCells().ServedCells{
1205 //                      fmt.Printf("responding node type NR Cell: %v\n", *cell)
1206 //              }
1207 //      }
1208 //}
1209 //
1210 //func TestGetListEnbIdsInteg(t *testing.T) {
1211 //      Init("namespace", 1)
1212 //      w := GetRNibReader()
1213 //      ids, err := w.GetListEnbIds()
1214 //      if err != nil{
1215 //              fmt.Println(err)
1216 //      } else {
1217 //              for _, id := range *ids{
1218 //                      fmt.Printf("#TestGetListEnbIdsInteg - ENB ID: %s\n", id)
1219 //              }
1220 //      }
1221 //}
1222 //
1223 //func TestGetListGnbIdsInteg(t *testing.T) {
1224 //      Init("namespace", 1)
1225 //      w := GetRNibReader()
1226 //      ids, err := w.GetListGnbIds()
1227 //      if err != nil{
1228 //              fmt.Println(err)
1229 //      } else {
1230 //              for _, id := range *ids{
1231 //                      fmt.Printf("#TestGetListGnbIdsInteg - GNB ID: %s\n", id)
1232 //              }
1233 //      }
1234 //}
1235 //
1236 //func TestGetCountGnbListInteg(t *testing.T) {
1237 //      Init("namespace", 1)
1238 //      w := GetRNibReader()
1239 //      count, err := w.GetCountGnbList()
1240 //      if err != nil{
1241 //              fmt.Println(err)
1242 //      } else {
1243 //              fmt.Printf("#TestGetCountGnbListInteg - count Gnb list: %d\n", count)
1244 //      }
1245 //}
1246 //
1247 //func TestGetGnbCellInteg(t *testing.T){
1248 //      name := "nameGnb7"
1249 //      pci := 0x0a
1250 //      Init("namespace", 1)
1251 //      w := GetRNibReader()
1252 //      cell, err := w.GetCell(name, uint32(pci))
1253 //      if err != nil{
1254 //              fmt.Println(err)
1255 //      } else if cell != nil{
1256 //              fmt.Printf("responding node type NR Cell: %v\n", cell.GetServedNrCell())
1257 //      }
1258 //}
1259 //
1260 //func TestGetEnbCellInteg(t *testing.T) {
1261 //      name := "nameEnb1"
1262 //      pci := 0x22
1263 //      Init("namespace", 1)
1264 //      w := GetRNibReader()
1265 //      cell, err := w.GetCell(name, uint32(pci))
1266 //      if err != nil {
1267 //              fmt.Println(err)
1268 //      } else if cell != nil {
1269 //              fmt.Printf("responding node type LTE Cell: %v\n", cell.GetServedCellInfo())
1270 //      }
1271 //}
1272 //
1273 //func TestGetEnbCellByIdInteg(t *testing.T){
1274 //      Init("namespace", 1)
1275 //      w := GetRNibReader()
1276 //      cell, err := w.GetCellById(entities.Cell_NR_CELL, "45d")
1277 //      if err != nil{
1278 //              fmt.Println(err)
1279 //      } else if cell != nil{
1280 //              fmt.Printf("responding node type NR Cell: %v\n", cell.GetServedNrCell())
1281 //      }
1282 //}
1283 //
1284 //func TestGetListNbIdsInteg(t *testing.T) {
1285 //      Init("e2Manager", 1)
1286 //      w := GetRNibReader()
1287 //      ids, err := w.GetListNodebIds()
1288 //      if err != nil{
1289 //              fmt.Println(err)
1290 //      } else {
1291 //              for _, id := range ids{
1292 //                      fmt.Printf("#TestGetListGnbIdsInteg - NB ID: %s\n", id)
1293 //              }
1294 //      }
1295 //}
1296 //
1297 //func TestGetRanLoadInformationInteg(t *testing.T){
1298 //      Init("e2Manager", 1)
1299 //      w := GetRNibReader()
1300 //      ranLoadInformation, err := w.GetRanLoadInformation("ran_integ")
1301 //      if err != nil{
1302 //              t.Errorf("#rNibReader_test.TestGetRanLoadInformationInteg - Failed to save RanLoadInformation entity. Error: %v", err)
1303 //      }
1304 //      assert.NotNil(t, ranLoadInformation)
1305 //      fmt.Printf("#rNibReader_test.TestGetRanLoadInformationInteg - GNB ID: %s\n", ranLoadInformation)
1306 //}