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