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