reader/rNibReader_test.go

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