reader/rNibReader_test.go

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