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