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