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