E2Manager/rNibWriter/rNibWriter_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 rNibWriter
  21
  22 import (
  23         "e2mgr/configuration"
  24         "e2mgr/mocks"
  25         "encoding/json"
  26         "errors"
  27         "fmt"
  28         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
  29         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
  30         "github.com/golang/protobuf/proto"
  31         "github.com/stretchr/testify/assert"
  32         "testing"
  33         "time"
  34 )
  35
  36 var namespace = "namespace"
  37
  38 const (
  39         RanName = "test"
  40 )
  41
  42 func initSdlInstanceMock(namespace string) (w RNibWriter, sdlInstanceMock *mocks.MockSdlInstance) {
  43         sdlInstanceMock = new(mocks.MockSdlInstance)
  44         w = GetRNibWriter(sdlInstanceMock, configuration.RnibWriterConfig{StateChangeMessageChannel: "RAN_CONNECTION_STATUS_CHANGE", RanManipulationMessageChannel: "RAN_MANIPULATION"})
  45         return
  46 }
  47
  48 func generateNodebInfo(inventoryName string, nodeType entities.Node_Type, plmnId string, nbId string) *entities.NodebInfo {
  49         nodebInfo := &entities.NodebInfo{
  50                 RanName:          inventoryName,
  51                 GlobalNbId:       &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId},
  52                 NodeType:         nodeType,
  53                 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
  54         }
  55
  56         if nodeType == entities.Node_ENB {
  57                 nodebInfo.Configuration = &entities.NodebInfo_Enb{
  58                         Enb: &entities.Enb{},
  59                 }
  60         } else if nodeType == entities.Node_GNB {
  61                 nodebInfo.Configuration = &entities.NodebInfo_Gnb{
  62                         Gnb: &entities.Gnb{},
  63                 }
  64         }
  65
  66         return nodebInfo
  67 }
  68
  69 func generateServedNrCells(cellIds ...string) []*entities.ServedNRCell {
  70
  71         var servedNrCells []*entities.ServedNRCell
  72
  73         for i, v := range cellIds {
  74                 servedNrCells = append(servedNrCells, &entities.ServedNRCell{ServedNrCellInformation: &entities.ServedNRCellInformation{
  75                         CellId: v,
  76                         ChoiceNrMode: &entities.ServedNRCellInformation_ChoiceNRMode{
  77                                 Fdd: &entities.ServedNRCellInformation_ChoiceNRMode_FddInfo{
  78
  79                                 },
  80                         },
  81                         NrMode:      entities.Nr_FDD,
  82                         NrPci:       uint32(i + 1),
  83                         ServedPlmns: []string{"whatever"},
  84                 }})
  85         }
  86
  87         return servedNrCells
  88 }
  89
  90 func generateServedCells(cellIds ...string) []*entities.ServedCellInfo {
  91
  92         var servedCells []*entities.ServedCellInfo
  93
  94         for i, v := range cellIds {
  95                 servedCells = append(servedCells, &entities.ServedCellInfo{
  96                         CellId: v,
  97                         ChoiceEutraMode: &entities.ChoiceEUTRAMode{
  98                                 Fdd: &entities.FddInfo{},
  99                         },
 100                         Pci:            uint32(i + 1),
 101                         BroadcastPlmns: []string{"whatever"},
 102                 })
 103         }
 104
 105         return servedCells
 106 }
 107
 108 func generateServedCellInfos(cellIds ...string) []*entities.ServedCellInfo {
 109
 110         servedCells := []*entities.ServedCellInfo{}
 111
 112         for i, v := range cellIds {
 113                 servedCells = append(servedCells, &entities.ServedCellInfo{
 114                         CellId: v,
 115                         Pci:    uint32(i + 1),
 116                 })
 117         }
 118
 119         return servedCells
 120 }
 121
 122 func TestRemoveServedNrCellsSuccess(t *testing.T) {
 123         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 124         servedNrCellsToRemove := generateServedNrCells("whatever1", "whatever2")
 125         sdlInstanceMock.On("Remove", buildServedNRCellKeysToRemove(RanName, servedNrCellsToRemove)).Return(nil)
 126         err := w.RemoveServedNrCells(RanName, servedNrCellsToRemove)
 127         assert.Nil(t, err)
 128 }
 129
 130 func TestRemoveServedNrCellsFailure(t *testing.T) {
 131         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 132         servedNrCellsToRemove := generateServedNrCells("whatever1", "whatever2")
 133         sdlInstanceMock.On("Remove", buildServedNRCellKeysToRemove(RanName, servedNrCellsToRemove)).Return(errors.New("expected error"))
 134         err := w.RemoveServedNrCells(RanName, servedNrCellsToRemove)
 135         assert.IsType(t, &common.InternalError{}, err)
 136 }
 137
 138 func TestUpdateGnbCellsInvalidNodebInfoFailure(t *testing.T) {
 139         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 140         servedNrCells := generateServedNrCells("test1", "test2")
 141         nodebInfo := &entities.NodebInfo{}
 142         sdlInstanceMock.AssertNotCalled(t, "Set")
 143         rNibErr := w.UpdateGnbCells(nodebInfo, servedNrCells)
 144         assert.IsType(t, &common.ValidationError{}, rNibErr)
 145 }
 146
 147 func TestUpdateGnbCellsInvalidCellFailure(t *testing.T) {
 148         inventoryName := "name"
 149         plmnId := "02f829"
 150         nbId := "4a952a0a"
 151         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 152         servedNrCells := []*entities.ServedNRCell{{ServedNrCellInformation: &entities.ServedNRCellInformation{}}}
 153         nodebInfo := generateNodebInfo(inventoryName, entities.Node_GNB, plmnId, nbId)
 154         nodebInfo.GetGnb().ServedNrCells = servedNrCells
 155         sdlInstanceMock.AssertNotCalled(t, "Set")
 156         rNibErr := w.UpdateGnbCells(nodebInfo, servedNrCells)
 157         assert.IsType(t, &common.ValidationError{}, rNibErr)
 158 }
 159
 160 func getUpdateEnbCellsSetExpected(t *testing.T, nodebInfo *entities.NodebInfo, servedCells []*entities.ServedCellInfo) []interface{} {
 161
 162         nodebInfoData, err := proto.Marshal(nodebInfo)
 163         if err != nil {
 164                 t.Fatalf("#rNibWriter_test.getUpdateEnbCellsSetExpected - Failed to marshal NodeB entity. Error: %s", err)
 165         }
 166
 167         nodebNameKey, _ := common.ValidateAndBuildNodeBNameKey(nodebInfo.RanName)
 168         nodebIdKey, _ := common.ValidateAndBuildNodeBIdKey(nodebInfo.NodeType.String(), nodebInfo.GlobalNbId.PlmnId, nodebInfo.GlobalNbId.NbId)
 169         setExpected := []interface{}{nodebNameKey, nodebInfoData, nodebIdKey, nodebInfoData}
 170
 171         for _, cell := range servedCells {
 172
 173                 cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: cell}}
 174                 cellData, err := proto.Marshal(&cellEntity)
 175
 176                 if err != nil {
 177                         t.Fatalf("#rNibWriter_test.getUpdateEnbCellsSetExpected - Failed to marshal cell entity. Error: %s", err)
 178                 }
 179
 180                 nrCellIdKey, _ := common.ValidateAndBuildCellIdKey(cell.GetCellId())
 181                 cellNamePciKey, _ := common.ValidateAndBuildCellNamePciKey(nodebInfo.RanName, cell.GetPci())
 182                 setExpected = append(setExpected, nrCellIdKey, cellData, cellNamePciKey, cellData)
 183         }
 184
 185         return setExpected
 186 }
 187
 188 func getUpdateGnbCellsSetExpected(t *testing.T, nodebInfo *entities.NodebInfo, servedNrCells []*entities.ServedNRCell) []interface{} {
 189
 190         nodebInfoData, err := proto.Marshal(nodebInfo)
 191         if err != nil {
 192                 t.Fatalf("#rNibWriter_test.getUpdateGnbCellsSetExpected - Failed to marshal NodeB entity. Error: %s", err)
 193         }
 194
 195         nodebNameKey, _ := common.ValidateAndBuildNodeBNameKey(nodebInfo.RanName)
 196         nodebIdKey, _ := common.ValidateAndBuildNodeBIdKey(nodebInfo.NodeType.String(), nodebInfo.GlobalNbId.PlmnId, nodebInfo.GlobalNbId.NbId)
 197         setExpected := []interface{}{nodebNameKey, nodebInfoData, nodebIdKey, nodebInfoData}
 198
 199         for _, v := range servedNrCells {
 200
 201                 cellEntity := entities.Cell{Type: entities.Cell_NR_CELL, Cell: &entities.Cell_ServedNrCell{ServedNrCell: v}}
 202                 cellData, err := proto.Marshal(&cellEntity)
 203
 204                 if err != nil {
 205                         t.Fatalf("#rNibWriter_test.getUpdateGnbCellsSetExpected - Failed to marshal cell entity. Error: %s", err)
 206                 }
 207
 208                 nrCellIdKey, _ := common.ValidateAndBuildNrCellIdKey(v.GetServedNrCellInformation().GetCellId())
 209                 cellNamePciKey, _ := common.ValidateAndBuildCellNamePciKey(nodebInfo.RanName, v.GetServedNrCellInformation().GetNrPci())
 210                 setExpected = append(setExpected, nrCellIdKey, cellData, cellNamePciKey, cellData)
 211         }
 212
 213         return setExpected
 214 }
 215
 216 func TestUpdateGnbCellsSdlFailure(t *testing.T) {
 217         inventoryName := "name"
 218         plmnId := "02f829"
 219         nbId := "4a952a0a"
 220         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 221         servedNrCells := generateServedNrCells("test1", "test2")
 222         nodebInfo := generateNodebInfo(inventoryName, entities.Node_GNB, plmnId, nbId)
 223         nodebInfo.GetGnb().ServedNrCells = servedNrCells
 224         setExpected := getUpdateGnbCellsSetExpected(t, nodebInfo, servedNrCells)
 225         sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(errors.New("expected error"))
 226         rNibErr := w.UpdateGnbCells(nodebInfo, servedNrCells)
 227         assert.IsType(t, &common.InternalError{}, rNibErr)
 228 }
 229
 230 func TestUpdateGnbCellsSuccess(t *testing.T) {
 231         inventoryName := "name"
 232         plmnId := "02f829"
 233         nbId := "4a952a0a"
 234         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 235         servedNrCells := generateServedNrCells("test1", "test2")
 236         nodebInfo := generateNodebInfo(inventoryName, entities.Node_GNB, plmnId, nbId)
 237         nodebInfo.GetGnb().ServedNrCells = servedNrCells
 238         setExpected := getUpdateGnbCellsSetExpected(t, nodebInfo, servedNrCells)
 239         var e error
 240         sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
 241         rNibErr := w.UpdateGnbCells(nodebInfo, servedNrCells)
 242         assert.Nil(t, rNibErr)
 243 }
 244
 245 func TestUpdateNodebInfoSuccess(t *testing.T) {
 246         inventoryName := "name"
 247         plmnId := "02f829"
 248         nbId := "4a952a0a"
 249         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 250         nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
 251         data, err := proto.Marshal(nodebInfo)
 252         if err != nil {
 253                 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal NodeB entity. Error: %v", err)
 254         }
 255         var e error
 256         var setExpected []interface{}
 257
 258         nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
 259         nodebIdKey := fmt.Sprintf("ENB:%s:%s", plmnId, nbId)
 260         setExpected = append(setExpected, nodebNameKey, data)
 261         setExpected = append(setExpected, nodebIdKey, data)
 262
 263         sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
 264
 265         rNibErr := w.UpdateNodebInfo(nodebInfo)
 266         assert.Nil(t, rNibErr)
 267 }
 268
 269 func TestUpdateNodebInfoMissingInventoryNameFailure(t *testing.T) {
 270         inventoryName := "name"
 271         plmnId := "02f829"
 272         nbId := "4a952a0a"
 273         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 274         nodebInfo := &entities.NodebInfo{}
 275         data, err := proto.Marshal(nodebInfo)
 276         if err != nil {
 277                 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal NodeB entity. Error: %v", err)
 278         }
 279         var e error
 280         var setExpected []interface{}
 281
 282         nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
 283         nodebIdKey := fmt.Sprintf("ENB:%s:%s", plmnId, nbId)
 284         setExpected = append(setExpected, nodebNameKey, data)
 285         setExpected = append(setExpected, nodebIdKey, data)
 286
 287         sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
 288
 289         rNibErr := w.UpdateNodebInfo(nodebInfo)
 290
 291         assert.NotNil(t, rNibErr)
 292         assert.IsType(t, &common.ValidationError{}, rNibErr)
 293 }
 294
 295 func TestUpdateNodebInfoMissingGlobalNbId(t *testing.T) {
 296         inventoryName := "name"
 297         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 298         nodebInfo := &entities.NodebInfo{}
 299         nodebInfo.RanName = inventoryName
 300         data, err := proto.Marshal(nodebInfo)
 301         if err != nil {
 302                 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal NodeB entity. Error: %v", err)
 303         }
 304         var e error
 305         var setExpected []interface{}
 306
 307         nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
 308         setExpected = append(setExpected, nodebNameKey, data)
 309         sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
 310
 311         rNibErr := w.UpdateNodebInfo(nodebInfo)
 312
 313         assert.Nil(t, rNibErr)
 314 }
 315
 316 func TestSaveEnb(t *testing.T) {
 317         ranName := "RAN:" + RanName
 318         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 319         nb := entities.NodebInfo{
 320                 RanName:          RanName,
 321                 NodeType:         entities.Node_ENB,
 322                 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
 323                 Ip:               "localhost",
 324                 Port:             5656,
 325                 GlobalNbId: &entities.GlobalNbId{
 326                         NbId:   "4a952a0a",
 327                         PlmnId: "02f829",
 328                 },
 329         }
 330
 331         enb := entities.Enb{}
 332         cell := &entities.ServedCellInfo{CellId: "aaff", Pci: 3}
 333         cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: cell}}
 334         enb.ServedCells = []*entities.ServedCellInfo{cell}
 335         nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
 336         data, err := proto.Marshal(&nb)
 337         if err != nil {
 338                 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal NodeB entity. Error: %v", err)
 339         }
 340         var e error
 341
 342         cellData, err := proto.Marshal(&cellEntity)
 343         if err != nil {
 344                 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal Cell entity. Error: %v", err)
 345         }
 346         var setExpected []interface{}
 347         setExpected = append(setExpected, ranName, data)
 348         setExpected = append(setExpected, "ENB:02f829:4a952a0a", data)
 349         setExpected = append(setExpected, fmt.Sprintf("CELL:%s", cell.GetCellId()), cellData)
 350         setExpected = append(setExpected, fmt.Sprintf("PCI:%s:%02x", RanName, cell.GetPci()), cellData)
 351
 352         sdlInstanceMock.On("SetAndPublish", []string{"RAN_MANIPULATION", RanName + "_" + RanAddedEvent}, []interface{}{setExpected}).Return(e)
 353
 354         rNibErr := w.SaveNodeb(&nb)
 355         assert.Nil(t, rNibErr)
 356 }
 357
 358 func TestSaveEnbCellIdValidationFailure(t *testing.T) {
 359         w, _ := initSdlInstanceMock(namespace)
 360         nb := entities.NodebInfo{}
 361         nb.RanName = "name"
 362         nb.NodeType = entities.Node_ENB
 363         nb.ConnectionStatus = 1
 364         nb.Ip = "localhost"
 365         nb.Port = 5656
 366         enb := entities.Enb{}
 367         cell := &entities.ServedCellInfo{Pci: 3}
 368         enb.ServedCells = []*entities.ServedCellInfo{cell}
 369         nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
 370         rNibErr := w.SaveNodeb(&nb)
 371         assert.NotNil(t, rNibErr)
 372         assert.IsType(t, &common.ValidationError{}, rNibErr)
 373         assert.Equal(t, "#utils.ValidateAndBuildCellIdKey - an empty cell id received", rNibErr.Error())
 374 }
 375
 376 func TestSaveEnbInventoryNameValidationFailure(t *testing.T) {
 377         w, _ := initSdlInstanceMock(namespace)
 378         nb := entities.NodebInfo{
 379                 NodeType:         entities.Node_ENB,
 380                 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
 381                 Ip:               "localhost",
 382                 Port:             5656,
 383                 GlobalNbId: &entities.GlobalNbId{
 384                         NbId:   "4a952a0a",
 385                         PlmnId: "02f829",
 386                 },
 387         }
 388         enb := entities.Enb{}
 389         cell := &entities.ServedCellInfo{CellId: "aaa", Pci: 3}
 390         enb.ServedCells = []*entities.ServedCellInfo{cell}
 391         nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
 392         rNibErr := w.SaveNodeb(&nb)
 393         assert.NotNil(t, rNibErr)
 394         assert.IsType(t, &common.ValidationError{}, rNibErr)
 395         assert.Equal(t, "#utils.ValidateAndBuildNodeBNameKey - an empty inventory name received", rNibErr.Error())
 396 }
 397
 398 func TestSaveGnbCellIdValidationFailure(t *testing.T) {
 399         w, _ := initSdlInstanceMock(namespace)
 400         nb := entities.NodebInfo{}
 401         nb.RanName = "name"
 402         nb.NodeType = entities.Node_GNB
 403         nb.ConnectionStatus = 1
 404         nb.Ip = "localhost"
 405         nb.Port = 5656
 406         gnb := entities.Gnb{}
 407         cellInfo := &entities.ServedNRCellInformation{NrPci: 2}
 408         cell := &entities.ServedNRCell{ServedNrCellInformation: cellInfo}
 409         gnb.ServedNrCells = []*entities.ServedNRCell{cell}
 410         nb.Configuration = &entities.NodebInfo_Gnb{Gnb: &gnb}
 411
 412         rNibErr := w.SaveNodeb(&nb)
 413         assert.NotNil(t, rNibErr)
 414         assert.IsType(t, &common.ValidationError{}, rNibErr)
 415         assert.Equal(t, "#utils.ValidateAndBuildNrCellIdKey - an empty cell id received", rNibErr.Error())
 416 }
 417
 418 func TestSaveGnb(t *testing.T) {
 419         ranName := "RAN:" + RanName
 420         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 421         nb := entities.NodebInfo{
 422                 RanName: RanName,
 423                 NodeType:         entities.Node_GNB,
 424                 ConnectionStatus: 1,
 425                 GlobalNbId: &entities.GlobalNbId{
 426                         NbId:   "4a952a0a",
 427                         PlmnId: "02f829",
 428                 },
 429                 Ip:   "localhost",
 430                 Port: 5656,
 431         }
 432
 433         gnb := entities.Gnb{}
 434         cellInfo := &entities.ServedNRCellInformation{NrPci: 2, CellId: "ccdd"}
 435         cell := &entities.ServedNRCell{ServedNrCellInformation: cellInfo}
 436         cellEntity := entities.Cell{Type: entities.Cell_NR_CELL, Cell: &entities.Cell_ServedNrCell{ServedNrCell: cell}}
 437         gnb.ServedNrCells = []*entities.ServedNRCell{cell}
 438         nb.Configuration = &entities.NodebInfo_Gnb{Gnb: &gnb}
 439         data, err := proto.Marshal(&nb)
 440         if err != nil {
 441                 t.Errorf("#rNibWriter_test.TestSaveGnb - Failed to marshal NodeB entity. Error: %v", err)
 442         }
 443         var e error
 444
 445         cellData, err := proto.Marshal(&cellEntity)
 446         if err != nil {
 447                 t.Errorf("#rNibWriter_test.TestSaveGnb - Failed to marshal Cell entity. Error: %v", err)
 448         }
 449         var setExpected []interface{}
 450         setExpected = append(setExpected, ranName, data)
 451         setExpected = append(setExpected, "GNB:02f829:4a952a0a", data)
 452         setExpected = append(setExpected, fmt.Sprintf("NRCELL:%s", cell.GetServedNrCellInformation().GetCellId()), cellData)
 453         setExpected = append(setExpected, fmt.Sprintf("PCI:%s:%02x", RanName, cell.GetServedNrCellInformation().GetNrPci()), cellData)
 454
 455         sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
 456         rNibErr := w.SaveNodeb(&nb)
 457         assert.Nil(t, rNibErr)
 458 }
 459
 460 func TestSaveRanLoadInformationSuccess(t *testing.T) {
 461         inventoryName := "name"
 462         loadKey, validationErr := common.ValidateAndBuildRanLoadInformationKey(inventoryName)
 463
 464         if validationErr != nil {
 465                 t.Errorf("#rNibWriter_test.TestSaveRanLoadInformationSuccess - Failed to build ran load infromation key. Error: %v", validationErr)
 466         }
 467
 468         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 469
 470         ranLoadInformation := generateRanLoadInformation()
 471         data, err := proto.Marshal(ranLoadInformation)
 472
 473         if err != nil {
 474                 t.Errorf("#rNibWriter_test.TestSaveRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
 475         }
 476
 477         var e error
 478         var setExpected []interface{}
 479         setExpected = append(setExpected, loadKey, data)
 480         sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
 481
 482         rNibErr := w.SaveRanLoadInformation(inventoryName, ranLoadInformation)
 483         assert.Nil(t, rNibErr)
 484 }
 485
 486 func TestSaveRanLoadInformationMarshalNilFailure(t *testing.T) {
 487         inventoryName := "name2"
 488         w, _ := initSdlInstanceMock(namespace)
 489
 490         expectedErr := common.NewInternalError(errors.New("proto: Marshal called with nil"))
 491         err := w.SaveRanLoadInformation(inventoryName, nil)
 492         assert.Equal(t, expectedErr, err)
 493 }
 494
 495 func TestSaveRanLoadInformationEmptyInventoryNameFailure(t *testing.T) {
 496         inventoryName := ""
 497         w, _ := initSdlInstanceMock(namespace)
 498
 499         err := w.SaveRanLoadInformation(inventoryName, nil)
 500         assert.NotNil(t, err)
 501         assert.IsType(t, &common.ValidationError{}, err)
 502 }
 503
 504 func TestSaveRanLoadInformationSdlFailure(t *testing.T) {
 505         inventoryName := "name2"
 506
 507         loadKey, validationErr := common.ValidateAndBuildRanLoadInformationKey(inventoryName)
 508
 509         if validationErr != nil {
 510                 t.Errorf("#rNibWriter_test.TestSaveRanLoadInformationSuccess - Failed to build ran load infromation key. Error: %v", validationErr)
 511         }
 512
 513         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 514
 515         ranLoadInformation := generateRanLoadInformation()
 516         data, err := proto.Marshal(ranLoadInformation)
 517
 518         if err != nil {
 519                 t.Errorf("#rNibWriter_test.TestSaveRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
 520         }
 521
 522         expectedErr := errors.New("expected error")
 523         var setExpected []interface{}
 524         setExpected = append(setExpected, loadKey, data)
 525         sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(expectedErr)
 526
 527         rNibErr := w.SaveRanLoadInformation(inventoryName, ranLoadInformation)
 528         assert.NotNil(t, rNibErr)
 529         assert.IsType(t, &common.InternalError{}, rNibErr)
 530 }
 531
 532 func generateCellLoadInformation() *entities.CellLoadInformation {
 533         cellLoadInformation := entities.CellLoadInformation{}
 534
 535         cellLoadInformation.CellId = "123"
 536
 537         ulInterferenceOverloadIndication := entities.UlInterferenceOverloadIndication_HIGH_INTERFERENCE
 538         cellLoadInformation.UlInterferenceOverloadIndications = []entities.UlInterferenceOverloadIndication{ulInterferenceOverloadIndication}
 539
 540         ulHighInterferenceInformation := entities.UlHighInterferenceInformation{
 541                 TargetCellId:                 "456",
 542                 UlHighInterferenceIndication: "xxx",
 543         }
 544
 545         cellLoadInformation.UlHighInterferenceInfos = []*entities.UlHighInterferenceInformation{&ulHighInterferenceInformation}
 546
 547         cellLoadInformation.RelativeNarrowbandTxPower = &entities.RelativeNarrowbandTxPower{
 548                 RntpPerPrb:                       "xxx",
 549                 RntpThreshold:                    entities.RntpThreshold_NEG_4,
 550                 NumberOfCellSpecificAntennaPorts: entities.NumberOfCellSpecificAntennaPorts_V1_ANT_PRT,
 551                 PB:                               1,
 552                 PdcchInterferenceImpact:          2,
 553                 EnhancedRntp: &entities.EnhancedRntp{
 554                         EnhancedRntpBitmap:     "xxx",
 555                         RntpHighPowerThreshold: entities.RntpThreshold_NEG_2,
 556                         EnhancedRntpStartTime:  &entities.StartTime{StartSfn: 500, StartSubframeNumber: 5},
 557                 },
 558         }
 559
 560         cellLoadInformation.AbsInformation = &entities.AbsInformation{
 561                 Mode:                             entities.AbsInformationMode_ABS_INFO_FDD,
 562                 AbsPatternInfo:                   "xxx",
 563                 NumberOfCellSpecificAntennaPorts: entities.NumberOfCellSpecificAntennaPorts_V2_ANT_PRT,
 564                 MeasurementSubset:                "xxx",
 565         }
 566
 567         cellLoadInformation.InvokeIndication = entities.InvokeIndication_ABS_INFORMATION
 568
 569         cellLoadInformation.ExtendedUlInterferenceOverloadInfo = &entities.ExtendedUlInterferenceOverloadInfo{
 570                 AssociatedSubframes:                       "xxx",
 571                 ExtendedUlInterferenceOverloadIndications: cellLoadInformation.UlInterferenceOverloadIndications,
 572         }
 573
 574         compInformationItem := &entities.CompInformationItem{
 575                 CompHypothesisSets: []*entities.CompHypothesisSet{{CellId: "789", CompHypothesis: "xxx"}},
 576                 BenefitMetric:      50,
 577         }
 578
 579         cellLoadInformation.CompInformation = &entities.CompInformation{
 580                 CompInformationItems:     []*entities.CompInformationItem{compInformationItem},
 581                 CompInformationStartTime: &entities.StartTime{StartSfn: 123, StartSubframeNumber: 456},
 582         }
 583
 584         cellLoadInformation.DynamicDlTransmissionInformation = &entities.DynamicDlTransmissionInformation{
 585                 State:             entities.NaicsState_NAICS_ACTIVE,
 586                 TransmissionModes: "xxx",
 587                 PB:                2,
 588                 PAList:            []entities.PA{entities.PA_DB_NEG_3},
 589         }
 590
 591         return &cellLoadInformation
 592 }
 593
 594 func generateRanLoadInformation() *entities.RanLoadInformation {
 595         ranLoadInformation := entities.RanLoadInformation{}
 596
 597         ranLoadInformation.LoadTimestamp = uint64(time.Now().UnixNano())
 598
 599         cellLoadInformation := generateCellLoadInformation()
 600         ranLoadInformation.CellLoadInfos = []*entities.CellLoadInformation{cellLoadInformation}
 601
 602         return &ranLoadInformation
 603 }
 604
 605 func TestSaveNilEntityFailure(t *testing.T) {
 606         w, _ := initSdlInstanceMock(namespace)
 607         expectedErr := common.NewInternalError(errors.New("proto: Marshal called with nil"))
 608         actualErr := w.SaveNodeb(nil)
 609         assert.Equal(t, expectedErr, actualErr)
 610 }
 611
 612 func TestSaveUnknownTypeEntityFailure(t *testing.T) {
 613         w, _ := initSdlInstanceMock(namespace)
 614         nb := &entities.NodebInfo{}
 615         nb.Port = 5656
 616         nb.Ip = "localhost"
 617         actualErr := w.SaveNodeb(nb)
 618         assert.IsType(t, &common.ValidationError{}, actualErr)
 619 }
 620
 621 func TestSaveEntityFailure(t *testing.T) {
 622         name := "name"
 623         plmnId := "02f829"
 624         nbId := "4a952a0a"
 625
 626         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 627         gnb := entities.NodebInfo{}
 628         gnb.NodeType = entities.Node_GNB
 629         data, err := proto.Marshal(&gnb)
 630         if err != nil {
 631                 t.Errorf("#rNibWriter_test.TestSaveEntityFailure - Failed to marshal NodeB entity. Error: %v", err)
 632         }
 633         setExpected := []interface{}{"RAN:" + name, data}
 634         setExpected = append(setExpected, "GNB:"+plmnId+":"+nbId, data)
 635         expectedErr := errors.New("expected error")
 636         sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(expectedErr)
 637         rNibErr := w.SaveNodeb(&gnb)
 638         assert.NotEmpty(t, rNibErr)
 639 }
 640
 641 func TestGetRNibWriter(t *testing.T) {
 642         received, _ := initSdlInstanceMock(namespace)
 643         assert.NotEmpty(t, received)
 644 }
 645
 646 func TestSaveE2TInstanceSuccess(t *testing.T) {
 647         address := "10.10.2.15:9800"
 648         loadKey, validationErr := common.ValidateAndBuildE2TInstanceKey(address)
 649
 650         if validationErr != nil {
 651                 t.Errorf("#rNibWriter_test.TestSaveE2TInstanceSuccess - Failed to build E2T Instance key. Error: %v", validationErr)
 652         }
 653
 654         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 655
 656         e2tInstance := generateE2tInstance(address)
 657         data, err := json.Marshal(e2tInstance)
 658
 659         if err != nil {
 660                 t.Errorf("#rNibWriter_test.TestSaveE2TInstanceSuccess - Failed to marshal E2tInstance entity. Error: %v", err)
 661         }
 662
 663         var e error
 664         var setExpected []interface{}
 665         setExpected = append(setExpected, loadKey, data)
 666         sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
 667
 668         rNibErr := w.SaveE2TInstance(e2tInstance)
 669         assert.Nil(t, rNibErr)
 670 }
 671
 672 func TestSaveE2TInstanceNullE2tInstanceFailure(t *testing.T) {
 673         w, _ := initSdlInstanceMock(namespace)
 674         var address string
 675         e2tInstance := entities.NewE2TInstance(address, "test")
 676         err := w.SaveE2TInstance(e2tInstance)
 677         assert.NotNil(t, err)
 678         assert.IsType(t, &common.ValidationError{}, err)
 679 }
 680
 681 func TestSaveE2TInstanceSdlFailure(t *testing.T) {
 682         address := "10.10.2.15:9800"
 683         loadKey, validationErr := common.ValidateAndBuildE2TInstanceKey(address)
 684
 685         if validationErr != nil {
 686                 t.Errorf("#rNibWriter_test.TestSaveE2TInstanceSdlFailure - Failed to build E2T Instance key. Error: %v", validationErr)
 687         }
 688
 689         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 690
 691         e2tInstance := generateE2tInstance(address)
 692         data, err := json.Marshal(e2tInstance)
 693
 694         if err != nil {
 695                 t.Errorf("#rNibWriter_test.TestSaveE2TInstanceSdlFailure - Failed to marshal E2tInstance entity. Error: %v", err)
 696         }
 697
 698         expectedErr := errors.New("expected error")
 699         var setExpected []interface{}
 700         setExpected = append(setExpected, loadKey, data)
 701         sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(expectedErr)
 702
 703         rNibErr := w.SaveE2TInstance(e2tInstance)
 704         assert.NotNil(t, rNibErr)
 705         assert.IsType(t, &common.InternalError{}, rNibErr)
 706 }
 707
 708 func generateE2tInstance(address string) *entities.E2TInstance {
 709         e2tInstance := entities.NewE2TInstance(address, "pod test")
 710
 711         e2tInstance.AssociatedRanList = []string{"test1", "test2"}
 712
 713         return e2tInstance
 714 }
 715
 716 func TestSaveE2TAddressesSuccess(t *testing.T) {
 717         address := "10.10.2.15:9800"
 718         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 719
 720         e2tAddresses := []string{address}
 721         data, err := json.Marshal(e2tAddresses)
 722
 723         if err != nil {
 724                 t.Errorf("#rNibWriter_test.TestSaveE2TInfoListSuccess - Failed to marshal E2TInfoList. Error: %v", err)
 725         }
 726
 727         var e error
 728         var setExpected []interface{}
 729         setExpected = append(setExpected, E2TAddressesKey, data)
 730         sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
 731
 732         rNibErr := w.SaveE2TAddresses(e2tAddresses)
 733         assert.Nil(t, rNibErr)
 734 }
 735
 736 func TestSaveE2TAddressesSdlFailure(t *testing.T) {
 737         address := "10.10.2.15:9800"
 738         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 739
 740         e2tAddresses := []string{address}
 741         data, err := json.Marshal(e2tAddresses)
 742
 743         if err != nil {
 744                 t.Errorf("#rNibWriter_test.TestSaveE2TInfoListSdlFailure - Failed to marshal E2TInfoList. Error: %v", err)
 745         }
 746
 747         expectedErr := errors.New("expected error")
 748         var setExpected []interface{}
 749         setExpected = append(setExpected, E2TAddressesKey, data)
 750         sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(expectedErr)
 751
 752         rNibErr := w.SaveE2TAddresses(e2tAddresses)
 753         assert.NotNil(t, rNibErr)
 754         assert.IsType(t, &common.InternalError{}, rNibErr)
 755 }
 756
 757 func TestRemoveE2TInstanceSuccess(t *testing.T) {
 758         address := "10.10.2.15:9800"
 759         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 760
 761         e2tAddresses := []string{fmt.Sprintf("E2TInstance:%s", address)}
 762         var e error
 763         sdlInstanceMock.On("Remove", e2tAddresses).Return(e)
 764
 765         rNibErr := w.RemoveE2TInstance(address)
 766         assert.Nil(t, rNibErr)
 767         sdlInstanceMock.AssertExpectations(t)
 768 }
 769
 770 func TestRemoveE2TInstanceSdlFailure(t *testing.T) {
 771         address := "10.10.2.15:9800"
 772         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 773
 774         e2tAddresses := []string{fmt.Sprintf("E2TInstance:%s", address)}
 775         expectedErr := errors.New("expected error")
 776         sdlInstanceMock.On("Remove", e2tAddresses).Return(expectedErr)
 777
 778         rNibErr := w.RemoveE2TInstance(address)
 779         assert.IsType(t, &common.InternalError{}, rNibErr)
 780 }
 781
 782 func TestRemoveE2TInstanceEmptyAddressFailure(t *testing.T) {
 783         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 784
 785         rNibErr := w.RemoveE2TInstance("")
 786         assert.IsType(t, &common.ValidationError{}, rNibErr)
 787         sdlInstanceMock.AssertExpectations(t)
 788 }
 789
 790 func TestUpdateNodebInfoOnConnectionStatusInversionSuccess(t *testing.T) {
 791         inventoryName := "name"
 792         plmnId := "02f829"
 793         nbId := "4a952a0a"
 794         channelName := "RAN_CONNECTION_STATUS_CHANGE"
 795         eventName := inventoryName + "_" + "CONNECTED"
 796         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 797         nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
 798         data, err := proto.Marshal(nodebInfo)
 799         if err != nil {
 800                 t.Errorf("#rNibWriter_test.TestUpdateNodebInfoOnConnectionStatusInversionSuccess - Failed to marshal NodeB entity. Error: %v", err)
 801         }
 802         var e error
 803         var setExpected []interface{}
 804
 805         nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
 806         nodebIdKey := fmt.Sprintf("ENB:%s:%s", plmnId, nbId)
 807         setExpected = append(setExpected, nodebNameKey, data)
 808         setExpected = append(setExpected, nodebIdKey, data)
 809
 810         sdlInstanceMock.On("SetAndPublish", []string{channelName, eventName}, []interface{}{setExpected}).Return(e)
 811
 812         rNibErr := w.UpdateNodebInfoOnConnectionStatusInversion(nodebInfo, eventName)
 813         assert.Nil(t, rNibErr)
 814 }
 815
 816 func TestUpdateNodebInfoOnConnectionStatusInversionMissingInventoryNameFailure(t *testing.T) {
 817         inventoryName := "name"
 818         plmnId := "02f829"
 819         nbId := "4a952a0a"
 820         channelName := "RAN_CONNECTION_STATUS_CHANGE"
 821         eventName := inventoryName + "_" + "CONNECTED"
 822         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 823         nodebInfo := &entities.NodebInfo{}
 824         data, err := proto.Marshal(nodebInfo)
 825         if err != nil {
 826                 t.Errorf("#rNibWriter_test.TestUpdateNodebInfoOnConnectionStatusInversionMissingInventoryNameFailure - Failed to marshal NodeB entity. Error: %v", err)
 827         }
 828         var e error
 829         var setExpected []interface{}
 830
 831         nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
 832         nodebIdKey := fmt.Sprintf("ENB:%s:%s", plmnId, nbId)
 833         setExpected = append(setExpected, nodebNameKey, data)
 834         setExpected = append(setExpected, nodebIdKey, data)
 835
 836         sdlInstanceMock.On("SetAndPublish", []string{channelName, eventName}, []interface{}{setExpected}).Return(e)
 837
 838         rNibErr := w.UpdateNodebInfoOnConnectionStatusInversion(nodebInfo, eventName)
 839
 840         assert.NotNil(t, rNibErr)
 841         assert.IsType(t, &common.ValidationError{}, rNibErr)
 842 }
 843
 844 func TestUpdateNodebInfoOnConnectionStatusInversionMissingGlobalNbId(t *testing.T) {
 845         inventoryName := "name"
 846         channelName := "RAN_CONNECTION_STATUS_CHANGE"
 847         eventName := inventoryName + "_" + "CONNECTED"
 848         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 849         nodebInfo := &entities.NodebInfo{}
 850         nodebInfo.RanName = inventoryName
 851         data, err := proto.Marshal(nodebInfo)
 852         if err != nil {
 853                 t.Errorf("#rNibWriter_test.TestUpdateNodebInfoOnConnectionStatusInversionMissingInventoryNameFailure - Failed to marshal NodeB entity. Error: %v", err)
 854         }
 855         var e error
 856         var setExpected []interface{}
 857
 858         nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
 859         setExpected = append(setExpected, nodebNameKey, data)
 860         sdlInstanceMock.On("SetAndPublish", []string{channelName, eventName}, []interface{}{setExpected}).Return(e)
 861
 862         rNibErr := w.UpdateNodebInfoOnConnectionStatusInversion(nodebInfo, eventName)
 863
 864         assert.Nil(t, rNibErr)
 865 }
 866
 867 func TestSaveGeneralConfiguration(t *testing.T) {
 868         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 869
 870         key := common.BuildGeneralConfigurationKey()
 871         configurationData := "{\"enableRic\":true}"
 872         configuration := &entities.GeneralConfiguration{}
 873         configuration.EnableRic = true
 874
 875         sdlInstanceMock.On("Set", []interface{}{[]interface{}{key, []byte(configurationData)}}).Return(nil)
 876         rNibErr := w.SaveGeneralConfiguration(configuration)
 877
 878         assert.Nil(t, rNibErr)
 879         sdlInstanceMock.AssertExpectations(t)
 880 }
 881
 882 func TestSaveGeneralConfigurationDbError(t *testing.T) {
 883         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 884
 885         key := common.BuildGeneralConfigurationKey()
 886         configurationData := "{\"enableRic\":true}"
 887         configuration := &entities.GeneralConfiguration{}
 888         configuration.EnableRic = true
 889
 890         expectedErr := errors.New("expected error")
 891
 892         sdlInstanceMock.On("Set", []interface{}{[]interface{}{key, []byte(configurationData)}}).Return(expectedErr)
 893         rNibErr := w.SaveGeneralConfiguration(configuration)
 894
 895         assert.NotNil(t, rNibErr)
 896 }
 897
 898 func TestRemoveServedCellsFailure(t *testing.T) {
 899         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 900         servedCellsToRemove := generateServedCells("whatever1", "whatever2")
 901         expectedErr := errors.New("expected error")
 902         sdlInstanceMock.On("Remove", buildServedCellInfoKeysToRemove(RanName, servedCellsToRemove)).Return(expectedErr)
 903
 904         rNibErr := w.RemoveServedCells(RanName, servedCellsToRemove)
 905
 906         assert.NotNil(t, rNibErr)
 907 }
 908
 909 func TestRemoveServedCellsSuccess(t *testing.T) {
 910         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 911         servedCellsToRemove := generateServedCells("whatever1", "whatever2")
 912         sdlInstanceMock.On("Remove", buildServedCellInfoKeysToRemove(RanName, servedCellsToRemove)).Return(nil)
 913         err := w.RemoveServedCells(RanName, servedCellsToRemove)
 914         assert.Nil(t, err)
 915 }
 916
 917 func TestUpdateEnbInvalidNodebInfoFailure(t *testing.T) {
 918         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 919         servedCells := generateServedCells("test1", "test2")
 920         nodebInfo := &entities.NodebInfo{}
 921         sdlInstanceMock.AssertNotCalled(t, "SetAndPublish")
 922         rNibErr := w.UpdateEnb(nodebInfo, servedCells)
 923         assert.IsType(t, &common.ValidationError{}, rNibErr)
 924 }
 925
 926 func TestUpdateEnbInvalidCellFailure(t *testing.T) {
 927         inventoryName := "name"
 928         plmnId := "02f829"
 929         nbId := "4a952a0a"
 930         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 931         servedCells := []*entities.ServedCellInfo{{CellId: ""}}
 932         nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
 933         nodebInfo.GetEnb().ServedCells = servedCells
 934         sdlInstanceMock.AssertNotCalled(t, "SetAndPublish")
 935         rNibErr := w.UpdateEnb(nodebInfo, servedCells)
 936         assert.IsType(t, &common.ValidationError{}, rNibErr)
 937 }
 938
 939 func TestUpdateEnbSdlFailure(t *testing.T) {
 940         inventoryName := "name"
 941         plmnId := "02f829"
 942         nbId := "4a952a0a"
 943         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 944         servedCells := generateServedCells("test1", "test2")
 945         nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
 946         nodebInfo.GetEnb().ServedCells = servedCells
 947         setExpected := getUpdateEnbCellsSetExpected(t, nodebInfo, servedCells)
 948         sdlInstanceMock.On("SetAndPublish", []string{"RAN_MANIPULATION", inventoryName + "_" + RanUpdatedEvent}, []interface{}{setExpected}).Return(errors.New("expected error"))
 949         rNibErr := w.UpdateEnb(nodebInfo, servedCells)
 950         assert.IsType(t, &common.InternalError{}, rNibErr)
 951 }
 952
 953 func TestUpdateEnbSuccess(t *testing.T) {
 954         inventoryName := "name"
 955         plmnId := "02f829"
 956         nbId := "4a952a0a"
 957         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 958         servedCells := generateServedCells("test1", "test2")
 959         nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
 960         nodebInfo.GetEnb().ServedCells = servedCells
 961         setExpected := getUpdateEnbCellsSetExpected(t, nodebInfo, servedCells)
 962
 963         var e error
 964         sdlInstanceMock.On("SetAndPublish", []string{"RAN_MANIPULATION", inventoryName + "_" + RanUpdatedEvent}, []interface{}{setExpected}).Return(e)
 965         rNibErr := w.UpdateEnb(nodebInfo, servedCells)
 966         assert.Nil(t, rNibErr)
 967 }
 968
 969 func getUpdateEnbSetExpected(t *testing.T, nodebInfo *entities.NodebInfo, servedCells []*entities.ServedCellInfo) []interface{} {
 970
 971         nodebInfoData, err := proto.Marshal(nodebInfo)
 972         if err != nil {
 973                 t.Fatalf("#rNibWriter_test.getUpdateEnbSetExpected - Failed to marshal NodeB entity. Error: %s", err)
 974         }
 975
 976         nodebNameKey, _ := common.ValidateAndBuildNodeBNameKey(nodebInfo.RanName)
 977         nodebIdKey, _ := common.ValidateAndBuildNodeBIdKey(nodebInfo.NodeType.String(), nodebInfo.GlobalNbId.PlmnId, nodebInfo.GlobalNbId.NbId)
 978         setExpected := []interface{}{nodebNameKey, nodebInfoData, nodebIdKey, nodebInfoData}
 979
 980         for _, v := range servedCells {
 981
 982                 cellEntity := entities.ServedCellInfo{CellId: "some cell id", EutraMode: entities.Eutra_FDD, CsgId: "some csg id"}
 983                 cellData, err := proto.Marshal(&cellEntity)
 984
 985                 if err != nil {
 986                         t.Fatalf("#rNibWriter_test.getUpdateEnbSetExpected - Failed to marshal cell entity. Error: %s", err)
 987                 }
 988
 989                 nrCellIdKey, _ := common.ValidateAndBuildNrCellIdKey(v.GetCellId())
 990                 cellNamePciKey, _ := common.ValidateAndBuildCellNamePciKey(nodebInfo.RanName, v.GetPci())
 991                 setExpected = append(setExpected, nrCellIdKey, cellData, cellNamePciKey, cellData)
 992         }
 993         return setExpected
 994 }
 995
 996 func TestRemoveEnbSuccess(t *testing.T) {
 997         inventoryName := "name"
 998         plmnId := "02f829"
 999         nbId := "4a952a0a"
1000         channelName := "RAN_MANIPULATION"
1001         eventName := inventoryName + "_" + "DELETED"
1002         w, sdlInstanceMock := initSdlInstanceMock(namespace)
1003         nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
1004         nodebInfo.GetEnb().ServedCells = generateServedCellInfos("cell1", "cell2")
1005
1006         var e error
1007
1008         expectedKeys := []string{}
1009         cell1Key := fmt.Sprintf("CELL:%s", nodebInfo.GetEnb().ServedCells[0].CellId)
1010         cell1PciKey := fmt.Sprintf("PCI:%s:%02x", inventoryName, nodebInfo.GetEnb().ServedCells[0].Pci)
1011         cell2Key := fmt.Sprintf("CELL:%s", nodebInfo.GetEnb().ServedCells[1].CellId)
1012         cell2PciKey := fmt.Sprintf("PCI:%s:%02x", inventoryName, nodebInfo.GetEnb().ServedCells[1].Pci)
1013         nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
1014         nodebIdKey := fmt.Sprintf("ENB:%s:%s", plmnId, nbId)
1015         expectedKeys = append(expectedKeys, cell1Key, cell1PciKey, cell2Key, cell2PciKey, nodebNameKey, nodebIdKey)
1016         sdlInstanceMock.On("RemoveAndPublish", []string{channelName, eventName}, expectedKeys).Return(e)
1017
1018         rNibErr := w.RemoveEnb(nodebInfo)
1019         assert.Nil(t, rNibErr)
1020         sdlInstanceMock.AssertExpectations(t)
1021 }
1022
1023 func TestRemoveEnbRemoveAndPublishError(t *testing.T) {
1024         inventoryName := "name"
1025         plmnId := "02f829"
1026         nbId := "4a952a0a"
1027         channelName := "RAN_MANIPULATION"
1028         eventName := inventoryName + "_" + "DELETED"
1029         w, sdlInstanceMock := initSdlInstanceMock(namespace)
1030         nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
1031         nodebInfo.GetEnb().ServedCells = generateServedCellInfos("cell1", "cell2")
1032
1033         expectedKeys := []string{}
1034         cell1Key := fmt.Sprintf("CELL:%s", nodebInfo.GetEnb().ServedCells[0].CellId)
1035         cell1PciKey := fmt.Sprintf("PCI:%s:%02x", inventoryName, nodebInfo.GetEnb().ServedCells[0].Pci)
1036         cell2Key := fmt.Sprintf("CELL:%s", nodebInfo.GetEnb().ServedCells[1].CellId)
1037         cell2PciKey := fmt.Sprintf("PCI:%s:%02x", inventoryName, nodebInfo.GetEnb().ServedCells[1].Pci)
1038         nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
1039         nodebIdKey := fmt.Sprintf("ENB:%s:%s", plmnId, nbId)
1040         expectedKeys = append(expectedKeys, cell1Key, cell1PciKey, cell2Key, cell2PciKey, nodebNameKey, nodebIdKey)
1041         sdlInstanceMock.On("RemoveAndPublish", []string{channelName, eventName}, expectedKeys).Return(errors.New("for test"))
1042
1043         rNibErr := w.RemoveEnb(nodebInfo)
1044         assert.NotNil(t, rNibErr)
1045         sdlInstanceMock.AssertExpectations(t)
1046 }
1047
1048 func TestRemoveNbIdentitySuccess(t *testing.T) {
1049         w, sdlInstanceMock := initSdlInstanceMock(namespace)
1050         nbIdentity := &entities.NbIdentity{InventoryName: "ran1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
1051         nbIdData, err := proto.Marshal(nbIdentity)
1052         if err != nil {
1053                 t.Errorf("#TestRemoveNbIdentitySuccess - failed to Marshal NbIdentity")
1054         }
1055
1056         sdlInstanceMock.On("RemoveMember", entities.Node_ENB.String(), []interface{}{nbIdData}).Return(nil)
1057
1058         rNibErr := w.RemoveNbIdentity(entities.Node_ENB, nbIdentity)
1059         assert.Nil(t, rNibErr)
1060         sdlInstanceMock.AssertExpectations(t)
1061 }
1062
1063 func TestRemoveNbIdentityError(t *testing.T) {
1064         w, sdlInstanceMock := initSdlInstanceMock(namespace)
1065         nbIdentity := &entities.NbIdentity{InventoryName: "ran1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
1066         nbIdData, err := proto.Marshal(nbIdentity)
1067         if err != nil {
1068                 t.Errorf("#TestRemoveNbIdentitySuccess - failed to Marshal NbIdentity")
1069         }
1070
1071         sdlInstanceMock.On("RemoveMember", entities.Node_ENB.String(), []interface{}{nbIdData}).Return(fmt.Errorf("for test"))
1072
1073         rNibErr := w.RemoveNbIdentity(entities.Node_ENB, nbIdentity)
1074         assert.NotNil(t, rNibErr)
1075         sdlInstanceMock.AssertExpectations(t)
1076 }
1077
1078 //Integration tests
1079 //
1080 //func TestSaveEnbGnbInteg(t *testing.T){
1081 //      for i := 0; i<10; i++{
1082 //              Init("e2Manager", 1)
1083 //              w := GetRNibWriter()
1084 //              nb := entities.NodebInfo{}
1085 //              nb.NodeType = entities.Node_ENB
1086 //              nb.ConnectionStatus = entities.ConnectionStatus_CONNECTED
1087 //              nb.Ip = "localhost"
1088 //              nb.Port = uint32(5656 + i)
1089 //              enb := entities.Enb{}
1090 //              cell1 := &entities.ServedCellInfo{CellId:fmt.Sprintf("%02x",111 + i), Pci:uint32(11 + i)}
1091 //              cell2 := &entities.ServedCellInfo{CellId:fmt.Sprintf("%02x",222 + i), Pci:uint32(22 + i)}
1092 //              cell3 := &entities.ServedCellInfo{CellId:fmt.Sprintf("%02x",333 + i), Pci:uint32(33 + i)}
1093 //              enb.ServedCells = []*entities.ServedCellInfo{cell1, cell2, cell3}
1094 //              nb.Configuration = &entities.NodebInfo_Enb{Enb:&enb}
1095 //              plmnId := 0x02f828
1096 //              nbId := 0x4a952a0a
1097 //              nbIdentity := &entities.NbIdentity{InventoryName: fmt.Sprintf("nameEnb%d" ,i), GlobalNbId:&entities.GlobalNbId{RicId:fmt.Sprintf("%02x", plmnId + i), NbId:fmt.Sprintf("%02x", nbId + i)}}
1098 //              err := w.SaveNodeb(nbIdentity, &nb)
1099 //              if err != nil{
1100 //                      t.Errorf("#rNibWriter_test.TestSaveEnbInteg - Failed to save NodeB entity. Error: %v", err)
1101 //              }
1102 //
1103 //              nb1 := entities.NodebInfo{}
1104 //              nb1.NodeType = entities.Node_GNB
1105 //              nb1.ConnectionStatus = entities.ConnectionStatus_CONNECTED
1106 //              nb1.Ip = "localhost"
1107 //              nb1.Port =  uint32(6565 + i)
1108 //              gnb := entities.Gnb{}
1109 //              gCell1 := &entities.ServedNRCell{ServedNrCellInformation:&entities.ServedNRCellInformation{CellId:fmt.Sprintf("%02x",1111 + i), NrPci:uint32(1 + i)}}
1110 //              gCell2 := &entities.ServedNRCell{ServedNrCellInformation:&entities.ServedNRCellInformation{CellId:fmt.Sprintf("%02x",2222 + i), NrPci:uint32(2 + i)}}
1111 //              gCell3 := &entities.ServedNRCell{ServedNrCellInformation:&entities.ServedNRCellInformation{CellId:fmt.Sprintf("%02x",3333 + i), NrPci:uint32(3 + i)}}
1112 //              gnb.ServedNrCells = []*entities.ServedNRCell{gCell1, gCell2, gCell3,}
1113 //              nb1.Configuration = &entities.NodebInfo_Gnb{Gnb:&gnb}
1114 //              nbIdentity = &entities.NbIdentity{InventoryName: fmt.Sprintf("nameGnb%d" ,i), GlobalNbId:&entities.GlobalNbId{RicId:fmt.Sprintf("%02x", plmnId - i), NbId:fmt.Sprintf("%02x", nbId - i)}}
1115 //              err = w.SaveNodeb(nbIdentity, &nb1)
1116 //              if err != nil{
1117 //                      t.Errorf("#rNibWriter_test.TestSaveEnbInteg - Failed to save NodeB entity. Error: %v", err)
1118 //              }
1119 //      }
1120 //}
1121 //
1122 //func TestSaveNbRanNamesInteg(t *testing.T){
1123 //      for i := 0; i<10; i++{
1124 //              Init("e2Manager", 1)
1125 //              w := GetRNibWriter()
1126 //              nb := entities.NodebInfo{}
1127 //              nb.ConnectionStatus = entities.ConnectionStatus_CONNECTING
1128 //              nb.Ip = "localhost"
1129 //              nb.Port = uint32(5656 + i)
1130 //              nbIdentity := &entities.NbIdentity{InventoryName: fmt.Sprintf("nameOnly%d" ,i)}
1131 //              err := w.SaveNodeb(nbIdentity, &nb)
1132 //              if err != nil{
1133 //                      t.Errorf("#rNibWriter_test.TestSaveEnbInteg - Failed to save NodeB entity. Error: %v", err)
1134 //              }
1135 //      }
1136 //}
1137 //
1138 //func TestSaveRanLoadInformationInteg(t *testing.T){
1139 //              Init("e2Manager", 1)
1140 //              w := GetRNibWriter()
1141 //              ranLoadInformation := generateRanLoadInformation()
1142 //              err := w.SaveRanLoadInformation("ran_integ", ranLoadInformation)
1143 //              if err != nil{
1144 //                      t.Errorf("#rNibWriter_test.TestSaveRanLoadInformationInteg - Failed to save RanLoadInformation entity. Error: %v", err)
1145 //              }
1146 //}