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