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