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