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
  21 package rNibWriter
  22
  23 import (
  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 func initSdlInstanceMock(namespace string) (w RNibWriter, sdlInstanceMock *mocks.MockSdlInstance) {
  37         sdlInstanceMock = new(mocks.MockSdlInstance)
  38         w = GetRNibWriter(sdlInstanceMock)
  39         return
  40 }
  41
  42 var namespace = "namespace"
  43
  44 func TestUpdateNodebInfoSuccess(t *testing.T) {
  45         inventoryName := "name"
  46         plmnId := "02f829"
  47         nbId := "4a952a0a"
  48         w, sdlInstanceMock := initSdlInstanceMock(namespace)
  49         nodebInfo := &entities.NodebInfo{}
  50         nodebInfo.RanName = inventoryName
  51         nodebInfo.GlobalNbId = &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
  52         nodebInfo.NodeType = entities.Node_ENB
  53         nodebInfo.ConnectionStatus = 1
  54         enb := entities.Enb{}
  55         nodebInfo.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
  56         data, err := proto.Marshal(nodebInfo)
  57         if err != nil {
  58                 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal NodeB entity. Error: %v", err)
  59         }
  60         var e error
  61         var setExpected []interface{}
  62
  63         nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
  64         nodebIdKey := fmt.Sprintf("ENB:%s:%s", plmnId, nbId)
  65         setExpected = append(setExpected, nodebNameKey, data)
  66         setExpected = append(setExpected, nodebIdKey, data)
  67
  68         sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
  69
  70         rNibErr := w.UpdateNodebInfo(nodebInfo)
  71         assert.Nil(t, rNibErr)
  72 }
  73
  74 func TestUpdateNodebInfoMissingInventoryNameFailure(t *testing.T) {
  75         inventoryName := "name"
  76         plmnId := "02f829"
  77         nbId := "4a952a0a"
  78         w, sdlInstanceMock := initSdlInstanceMock(namespace)
  79         nodebInfo := &entities.NodebInfo{}
  80         data, err := proto.Marshal(nodebInfo)
  81         if err != nil {
  82                 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal NodeB entity. Error: %v", err)
  83         }
  84         var e error
  85         var setExpected []interface{}
  86
  87         nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
  88         nodebIdKey := fmt.Sprintf("ENB:%s:%s", plmnId, nbId)
  89         setExpected = append(setExpected, nodebNameKey, data)
  90         setExpected = append(setExpected, nodebIdKey, data)
  91
  92         sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
  93
  94         rNibErr := w.UpdateNodebInfo(nodebInfo)
  95
  96         assert.NotNil(t, rNibErr)
  97         assert.IsType(t, &common.ValidationError{}, rNibErr)
  98 }
  99
 100 func TestUpdateNodebInfoMissingGlobalNbId(t *testing.T) {
 101         inventoryName := "name"
 102         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 103         nodebInfo := &entities.NodebInfo{}
 104         nodebInfo.RanName = inventoryName
 105         data, err := proto.Marshal(nodebInfo)
 106         if err != nil {
 107                 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal NodeB entity. Error: %v", err)
 108         }
 109         var e error
 110         var setExpected []interface{}
 111
 112         nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
 113         setExpected = append(setExpected, nodebNameKey, data)
 114         sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
 115
 116         rNibErr := w.UpdateNodebInfo(nodebInfo)
 117
 118         assert.Nil(t, rNibErr)
 119 }
 120
 121 func TestSaveEnb(t *testing.T) {
 122         name := "name"
 123         ranName := "RAN:" + name
 124         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 125         nb := entities.NodebInfo{}
 126         nb.NodeType = entities.Node_ENB
 127         nb.ConnectionStatus = 1
 128         nb.Ip = "localhost"
 129         nb.Port = 5656
 130         enb := entities.Enb{}
 131         cell := &entities.ServedCellInfo{CellId: "aaff", Pci: 3}
 132         cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: cell}}
 133         enb.ServedCells = []*entities.ServedCellInfo{cell}
 134         nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
 135         data, err := proto.Marshal(&nb)
 136         if err != nil {
 137                 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal NodeB entity. Error: %v", err)
 138         }
 139         var e error
 140
 141         cellData, err := proto.Marshal(&cellEntity)
 142         if err != nil {
 143                 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal Cell entity. Error: %v", err)
 144         }
 145         var setExpected []interface{}
 146         setExpected = append(setExpected, ranName, data)
 147         setExpected = append(setExpected, "ENB:02f829:4a952a0a", data)
 148         setExpected = append(setExpected, fmt.Sprintf("CELL:%s", cell.GetCellId()), cellData)
 149         setExpected = append(setExpected, fmt.Sprintf("PCI:%s:%02x", name, cell.GetPci()), cellData)
 150
 151         sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
 152
 153         nbIdData, err := proto.Marshal(&entities.NbIdentity{InventoryName: name})
 154         if err != nil {
 155                 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal nbIdentity entity. Error: %v", err)
 156         }
 157         sdlInstanceMock.On("RemoveMember", entities.Node_UNKNOWN.String(), []interface{}{nbIdData}).Return(e)
 158
 159         nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: "02f829", NbId: "4a952a0a"}}
 160         nbIdData, err = proto.Marshal(nbIdentity)
 161         if err != nil {
 162                 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal NodeB Identity entity. Error: %v", err)
 163         }
 164         sdlInstanceMock.On("AddMember", "ENB", []interface{}{nbIdData}).Return(e)
 165
 166         rNibErr := w.SaveNodeb(nbIdentity, &nb)
 167         assert.Nil(t, rNibErr)
 168 }
 169
 170 func TestSaveEnbCellIdValidationFailure(t *testing.T) {
 171         name := "name"
 172         w, _ := initSdlInstanceMock(namespace)
 173         nb := entities.NodebInfo{}
 174         nb.NodeType = entities.Node_ENB
 175         nb.ConnectionStatus = 1
 176         nb.Ip = "localhost"
 177         nb.Port = 5656
 178         enb := entities.Enb{}
 179         cell := &entities.ServedCellInfo{Pci: 3}
 180         enb.ServedCells = []*entities.ServedCellInfo{cell}
 181         nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
 182
 183         nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: "02f829", NbId: "4a952a0a"}}
 184         rNibErr := w.SaveNodeb(nbIdentity, &nb)
 185         assert.NotNil(t, rNibErr)
 186         assert.IsType(t, &common.ValidationError{}, rNibErr)
 187         assert.Equal(t, "#utils.ValidateAndBuildCellIdKey - an empty cell id received", rNibErr.Error())
 188 }
 189
 190 func TestSaveEnbInventoryNameValidationFailure(t *testing.T) {
 191         w, _ := initSdlInstanceMock(namespace)
 192         nb := entities.NodebInfo{}
 193         nb.NodeType = entities.Node_ENB
 194         nb.ConnectionStatus = 1
 195         nb.Ip = "localhost"
 196         nb.Port = 5656
 197         enb := entities.Enb{}
 198         cell := &entities.ServedCellInfo{CellId: "aaa", Pci: 3}
 199         enb.ServedCells = []*entities.ServedCellInfo{cell}
 200         nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
 201
 202         nbIdentity := &entities.NbIdentity{InventoryName: "", GlobalNbId: &entities.GlobalNbId{PlmnId: "02f829", NbId: "4a952a0a"}}
 203         rNibErr := w.SaveNodeb(nbIdentity, &nb)
 204         assert.NotNil(t, rNibErr)
 205         assert.IsType(t, &common.ValidationError{}, rNibErr)
 206         assert.Equal(t, "#utils.ValidateAndBuildNodeBNameKey - an empty inventory name received", rNibErr.Error())
 207 }
 208
 209 func TestSaveGnbCellIdValidationFailure(t *testing.T) {
 210         name := "name"
 211         w, _ := initSdlInstanceMock(namespace)
 212         nb := entities.NodebInfo{}
 213         nb.NodeType = entities.Node_GNB
 214         nb.ConnectionStatus = 1
 215         nb.Ip = "localhost"
 216         nb.Port = 5656
 217         gnb := entities.Gnb{}
 218         cellInfo := &entities.ServedNRCellInformation{NrPci: 2}
 219         cell := &entities.ServedNRCell{ServedNrCellInformation: cellInfo}
 220         gnb.ServedNrCells = []*entities.ServedNRCell{cell}
 221         nb.Configuration = &entities.NodebInfo_Gnb{Gnb: &gnb}
 222
 223         nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: "02f829", NbId: "4a952a0a"}}
 224         rNibErr := w.SaveNodeb(nbIdentity, &nb)
 225         assert.NotNil(t, rNibErr)
 226         assert.IsType(t, &common.ValidationError{}, rNibErr)
 227         assert.Equal(t, "#utils.ValidateAndBuildNrCellIdKey - an empty cell id received", rNibErr.Error())
 228 }
 229
 230 func TestSaveGnb(t *testing.T) {
 231         name := "name"
 232         ranName := "RAN:" + name
 233         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 234         nb := entities.NodebInfo{}
 235         nb.NodeType = entities.Node_GNB
 236         nb.ConnectionStatus = 1
 237         nb.Ip = "localhost"
 238         nb.Port = 5656
 239         gnb := entities.Gnb{}
 240         cellInfo := &entities.ServedNRCellInformation{NrPci: 2, CellId: "ccdd"}
 241         cell := &entities.ServedNRCell{ServedNrCellInformation: cellInfo}
 242         cellEntity := entities.Cell{Type: entities.Cell_NR_CELL, Cell: &entities.Cell_ServedNrCell{ServedNrCell: cell}}
 243         gnb.ServedNrCells = []*entities.ServedNRCell{cell}
 244         nb.Configuration = &entities.NodebInfo_Gnb{Gnb: &gnb}
 245         data, err := proto.Marshal(&nb)
 246         if err != nil {
 247                 t.Errorf("#rNibWriter_test.TestSaveGnb - Failed to marshal NodeB entity. Error: %v", err)
 248         }
 249         var e error
 250
 251         cellData, err := proto.Marshal(&cellEntity)
 252         if err != nil {
 253                 t.Errorf("#rNibWriter_test.TestSaveGnb - Failed to marshal Cell entity. Error: %v", err)
 254         }
 255         var setExpected []interface{}
 256         setExpected = append(setExpected, ranName, data)
 257         setExpected = append(setExpected, "GNB:02f829:4a952a0a", data)
 258         setExpected = append(setExpected, fmt.Sprintf("NRCELL:%s", cell.GetServedNrCellInformation().GetCellId()), cellData)
 259         setExpected = append(setExpected, fmt.Sprintf("PCI:%s:%02x", name, cell.GetServedNrCellInformation().GetNrPci()), cellData)
 260
 261         sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
 262         nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: "02f829", NbId: "4a952a0a"}}
 263         nbIdData, err := proto.Marshal(nbIdentity)
 264         if err != nil {
 265                 t.Errorf("#rNibWriter_test.TestSaveGnb - Failed to marshal NodeB Identity entity. Error: %v", err)
 266         }
 267         sdlInstanceMock.On("AddMember", "GNB", []interface{}{nbIdData}).Return(e)
 268
 269         nbIdData, err = proto.Marshal(&entities.NbIdentity{InventoryName: name})
 270         if err != nil {
 271                 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal nbIdentity entity. Error: %v", err)
 272         }
 273         sdlInstanceMock.On("RemoveMember", entities.Node_UNKNOWN.String(), []interface{}{nbIdData}).Return(e)
 274
 275         rNibErr := w.SaveNodeb(nbIdentity, &nb)
 276         assert.Nil(t, rNibErr)
 277 }
 278
 279 func TestSaveRanLoadInformationSuccess(t *testing.T) {
 280         inventoryName := "name"
 281         loadKey, validationErr := common.ValidateAndBuildRanLoadInformationKey(inventoryName)
 282
 283         if validationErr != nil {
 284                 t.Errorf("#rNibWriter_test.TestSaveRanLoadInformationSuccess - Failed to build ran load infromation key. Error: %v", validationErr)
 285         }
 286
 287         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 288
 289         ranLoadInformation := generateRanLoadInformation()
 290         data, err := proto.Marshal(ranLoadInformation)
 291
 292         if err != nil {
 293                 t.Errorf("#rNibWriter_test.TestSaveRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
 294         }
 295
 296         var e error
 297         var setExpected []interface{}
 298         setExpected = append(setExpected, loadKey, data)
 299         sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
 300
 301         rNibErr := w.SaveRanLoadInformation(inventoryName, ranLoadInformation)
 302         assert.Nil(t, rNibErr)
 303 }
 304
 305 func TestSaveRanLoadInformationMarshalNilFailure(t *testing.T) {
 306         inventoryName := "name2"
 307         w, _ := initSdlInstanceMock(namespace)
 308
 309         expectedErr := common.NewInternalError(errors.New("proto: Marshal called with nil"))
 310         err := w.SaveRanLoadInformation(inventoryName, nil)
 311         assert.Equal(t, expectedErr, err)
 312 }
 313
 314 func TestSaveRanLoadInformationEmptyInventoryNameFailure(t *testing.T) {
 315         inventoryName := ""
 316         w, _ := initSdlInstanceMock(namespace)
 317
 318         err := w.SaveRanLoadInformation(inventoryName, nil)
 319         assert.NotNil(t, err)
 320         assert.IsType(t, &common.ValidationError{}, err)
 321 }
 322
 323 func TestSaveRanLoadInformationSdlFailure(t *testing.T) {
 324         inventoryName := "name2"
 325
 326         loadKey, validationErr := common.ValidateAndBuildRanLoadInformationKey(inventoryName)
 327
 328         if validationErr != nil {
 329                 t.Errorf("#rNibWriter_test.TestSaveRanLoadInformationSuccess - Failed to build ran load infromation key. Error: %v", validationErr)
 330         }
 331
 332         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 333
 334         ranLoadInformation := generateRanLoadInformation()
 335         data, err := proto.Marshal(ranLoadInformation)
 336
 337         if err != nil {
 338                 t.Errorf("#rNibWriter_test.TestSaveRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
 339         }
 340
 341         expectedErr := errors.New("expected error")
 342         var setExpected []interface{}
 343         setExpected = append(setExpected, loadKey, data)
 344         sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(expectedErr)
 345
 346         rNibErr := w.SaveRanLoadInformation(inventoryName, ranLoadInformation)
 347         assert.NotNil(t, rNibErr)
 348         assert.IsType(t, &common.InternalError{}, rNibErr)
 349 }
 350
 351 func generateCellLoadInformation() *entities.CellLoadInformation {
 352         cellLoadInformation := entities.CellLoadInformation{}
 353
 354         cellLoadInformation.CellId = "123"
 355
 356         ulInterferenceOverloadIndication := entities.UlInterferenceOverloadIndication_HIGH_INTERFERENCE
 357         cellLoadInformation.UlInterferenceOverloadIndications = []entities.UlInterferenceOverloadIndication{ulInterferenceOverloadIndication}
 358
 359         ulHighInterferenceInformation := entities.UlHighInterferenceInformation{
 360                 TargetCellId:                 "456",
 361                 UlHighInterferenceIndication: "xxx",
 362         }
 363
 364         cellLoadInformation.UlHighInterferenceInfos = []*entities.UlHighInterferenceInformation{&ulHighInterferenceInformation}
 365
 366         cellLoadInformation.RelativeNarrowbandTxPower = &entities.RelativeNarrowbandTxPower{
 367                 RntpPerPrb:                       "xxx",
 368                 RntpThreshold:                    entities.RntpThreshold_NEG_4,
 369                 NumberOfCellSpecificAntennaPorts: entities.NumberOfCellSpecificAntennaPorts_V1_ANT_PRT,
 370                 PB:                               1,
 371                 PdcchInterferenceImpact:          2,
 372                 EnhancedRntp: &entities.EnhancedRntp{
 373                         EnhancedRntpBitmap:     "xxx",
 374                         RntpHighPowerThreshold: entities.RntpThreshold_NEG_2,
 375                         EnhancedRntpStartTime:  &entities.StartTime{StartSfn: 500, StartSubframeNumber: 5},
 376                 },
 377         }
 378
 379         cellLoadInformation.AbsInformation = &entities.AbsInformation{
 380                 Mode:                             entities.AbsInformationMode_ABS_INFO_FDD,
 381                 AbsPatternInfo:                   "xxx",
 382                 NumberOfCellSpecificAntennaPorts: entities.NumberOfCellSpecificAntennaPorts_V2_ANT_PRT,
 383                 MeasurementSubset:                "xxx",
 384         }
 385
 386         cellLoadInformation.InvokeIndication = entities.InvokeIndication_ABS_INFORMATION
 387
 388         cellLoadInformation.ExtendedUlInterferenceOverloadInfo = &entities.ExtendedUlInterferenceOverloadInfo{
 389                 AssociatedSubframes:                       "xxx",
 390                 ExtendedUlInterferenceOverloadIndications: cellLoadInformation.UlInterferenceOverloadIndications,
 391         }
 392
 393         compInformationItem := &entities.CompInformationItem{
 394                 CompHypothesisSets: []*entities.CompHypothesisSet{&entities.CompHypothesisSet{CellId: "789", CompHypothesis: "xxx"}},
 395                 BenefitMetric:      50,
 396         }
 397
 398         cellLoadInformation.CompInformation = &entities.CompInformation{
 399                 CompInformationItems:     []*entities.CompInformationItem{compInformationItem},
 400                 CompInformationStartTime: &entities.StartTime{StartSfn: 123, StartSubframeNumber: 456},
 401         }
 402
 403         cellLoadInformation.DynamicDlTransmissionInformation = &entities.DynamicDlTransmissionInformation{
 404                 State:             entities.NaicsState_NAICS_ACTIVE,
 405                 TransmissionModes: "xxx",
 406                 PB:                2,
 407                 PAList:            []entities.PA{entities.PA_DB_NEG_3},
 408         }
 409
 410         return &cellLoadInformation
 411 }
 412
 413 func generateRanLoadInformation() *entities.RanLoadInformation {
 414         ranLoadInformation := entities.RanLoadInformation{}
 415
 416         ranLoadInformation.LoadTimestamp = uint64(time.Now().UnixNano())
 417
 418         cellLoadInformation := generateCellLoadInformation()
 419         ranLoadInformation.CellLoadInfos = []*entities.CellLoadInformation{cellLoadInformation}
 420
 421         return &ranLoadInformation
 422 }
 423
 424 func TestSaveNilEntityFailure(t *testing.T) {
 425         w, _ := initSdlInstanceMock(namespace)
 426         expectedErr := common.NewInternalError(errors.New("proto: Marshal called with nil"))
 427         nbIdentity := &entities.NbIdentity{}
 428         actualErr := w.SaveNodeb(nbIdentity, nil)
 429         assert.Equal(t, expectedErr, actualErr)
 430 }
 431
 432 func TestSaveUnknownTypeEntityFailure(t *testing.T) {
 433         w, _ := initSdlInstanceMock(namespace)
 434         expectedErr := common.NewValidationError("#rNibWriter.saveNodeB - Unknown responding node type, entity: ip:\"localhost\" port:5656 ")
 435         nbIdentity := &entities.NbIdentity{InventoryName: "name", GlobalNbId: &entities.GlobalNbId{PlmnId: "02f829", NbId: "4a952a0a"}}
 436         nb := &entities.NodebInfo{}
 437         nb.Port = 5656
 438         nb.Ip = "localhost"
 439         actualErr := w.SaveNodeb(nbIdentity, nb)
 440         assert.Equal(t, expectedErr, actualErr)
 441 }
 442
 443 func TestSaveEntityFailure(t *testing.T) {
 444         name := "name"
 445         plmnId := "02f829"
 446         nbId := "4a952a0a"
 447
 448         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 449         gnb := entities.NodebInfo{}
 450         gnb.NodeType = entities.Node_GNB
 451         data, err := proto.Marshal(&gnb)
 452         if err != nil {
 453                 t.Errorf("#rNibWriter_test.TestSaveEntityFailure - Failed to marshal NodeB entity. Error: %v", err)
 454         }
 455         nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
 456         setExpected := []interface{}{"RAN:" + name, data}
 457         setExpected = append(setExpected, "GNB:"+plmnId+":"+nbId, data)
 458         expectedErr := errors.New("expected error")
 459         sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(expectedErr)
 460         rNibErr := w.SaveNodeb(nbIdentity, &gnb)
 461         assert.NotEmpty(t, rNibErr)
 462 }
 463
 464 func TestGetRNibWriter(t *testing.T) {
 465         received, _ := initSdlInstanceMock(namespace)
 466         assert.NotEmpty(t, received)
 467 }
 468
 469 func TestSaveE2TInstanceSuccess(t *testing.T) {
 470         address := "10.10.2.15:9800"
 471         loadKey, validationErr := common.ValidateAndBuildE2TInstanceKey(address)
 472
 473         if validationErr != nil {
 474                 t.Errorf("#rNibWriter_test.TestSaveE2TInstanceSuccess - Failed to build E2T Instance key. Error: %v", validationErr)
 475         }
 476
 477         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 478
 479         e2tInstance := generateE2tInstance(address)
 480         data, err := json.Marshal(e2tInstance)
 481
 482         if err != nil {
 483                 t.Errorf("#rNibWriter_test.TestSaveE2TInstanceSuccess - Failed to marshal E2tInstance entity. Error: %v", err)
 484         }
 485
 486         var e error
 487         var setExpected []interface{}
 488         setExpected = append(setExpected, loadKey, data)
 489         sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
 490
 491         rNibErr := w.SaveE2TInstance(e2tInstance)
 492         assert.Nil(t, rNibErr)
 493 }
 494
 495 func TestSaveE2TInstanceNullE2tInstanceFailure(t *testing.T) {
 496         w, _ := initSdlInstanceMock(namespace)
 497         var address string
 498         e2tInstance := entities.NewE2TInstance(address)
 499         err := w.SaveE2TInstance(e2tInstance)
 500         assert.NotNil(t, err)
 501         assert.IsType(t, &common.ValidationError{}, err)
 502 }
 503
 504 func TestSaveE2TInstanceSdlFailure(t *testing.T) {
 505         address := "10.10.2.15:9800"
 506         loadKey, validationErr := common.ValidateAndBuildE2TInstanceKey(address)
 507
 508         if validationErr != nil {
 509                 t.Errorf("#rNibWriter_test.TestSaveE2TInstanceSdlFailure - Failed to build E2T Instance key. Error: %v", validationErr)
 510         }
 511
 512         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 513
 514         e2tInstance := generateE2tInstance(address)
 515         data, err := json.Marshal(e2tInstance)
 516
 517         if err != nil {
 518                 t.Errorf("#rNibWriter_test.TestSaveE2TInstanceSdlFailure - Failed to marshal E2tInstance entity. Error: %v", err)
 519         }
 520
 521         expectedErr := errors.New("expected error")
 522         var setExpected []interface{}
 523         setExpected = append(setExpected, loadKey, data)
 524         sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(expectedErr)
 525
 526         rNibErr := w.SaveE2TInstance(e2tInstance)
 527         assert.NotNil(t, rNibErr)
 528         assert.IsType(t, &common.InternalError{}, rNibErr)
 529 }
 530
 531 func generateE2tInstance(address string) *entities.E2TInstance {
 532         e2tInstance := entities.NewE2TInstance(address)
 533
 534         e2tInstance.AssociatedRanList = []string{"test1", "test2"}
 535
 536         return e2tInstance
 537 }
 538
 539 func TestSaveE2TAddressesSuccess(t *testing.T) {
 540         address := "10.10.2.15:9800"
 541         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 542
 543         e2tAddresses := []string{address}
 544         data, err := json.Marshal(e2tAddresses)
 545
 546         if err != nil {
 547                 t.Errorf("#rNibWriter_test.TestSaveE2TInfoListSuccess - Failed to marshal E2TInfoList. Error: %v", err)
 548         }
 549
 550         var e error
 551         var setExpected []interface{}
 552         setExpected = append(setExpected, E2TAddressesKey, data)
 553         sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
 554
 555         rNibErr := w.SaveE2TAddresses(e2tAddresses)
 556         assert.Nil(t, rNibErr)
 557 }
 558
 559 func TestSaveE2TAddressesSdlFailure(t *testing.T) {
 560         address := "10.10.2.15:9800"
 561         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 562
 563         e2tAddresses := []string{address}
 564         data, err := json.Marshal(e2tAddresses)
 565
 566         if err != nil {
 567                 t.Errorf("#rNibWriter_test.TestSaveE2TInfoListSdlFailure - Failed to marshal E2TInfoList. Error: %v", err)
 568         }
 569
 570         expectedErr := errors.New("expected error")
 571         var setExpected []interface{}
 572         setExpected = append(setExpected, E2TAddressesKey, data)
 573         sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(expectedErr)
 574
 575         rNibErr := w.SaveE2TAddresses(e2tAddresses)
 576         assert.NotNil(t, rNibErr)
 577         assert.IsType(t, &common.InternalError{}, rNibErr)
 578 }
 579
 580 func TestRemoveE2TInstanceSuccess(t *testing.T) {
 581         address := "10.10.2.15:9800"
 582         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 583
 584         e2tAddresses := []string{fmt.Sprintf("E2TInstance:%s", address)}
 585         var e error
 586         sdlInstanceMock.On("Remove", e2tAddresses).Return(e)
 587
 588         rNibErr := w.RemoveE2TInstance(address)
 589         assert.Nil(t, rNibErr)
 590         sdlInstanceMock.AssertExpectations(t)
 591 }
 592
 593 func TestRemoveE2TInstanceSdlFailure(t *testing.T) {
 594         address := "10.10.2.15:9800"
 595         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 596
 597         e2tAddresses := []string{fmt.Sprintf("E2TInstance:%s", address)}
 598         expectedErr := errors.New("expected error")
 599         sdlInstanceMock.On("Remove", e2tAddresses).Return(expectedErr)
 600
 601         rNibErr := w.RemoveE2TInstance(address)
 602         assert.IsType(t, &common.InternalError{}, rNibErr)
 603 }
 604
 605 func TestRemoveE2TInstanceEmptyAddressFailure(t *testing.T) {
 606         w, sdlInstanceMock := initSdlInstanceMock(namespace)
 607
 608         rNibErr := w.RemoveE2TInstance("")
 609         assert.IsType(t, &common.ValidationError{}, rNibErr)
 610         sdlInstanceMock.AssertExpectations(t)
 611 }
 612
 613 //Integration tests
 614 //
 615 //func TestSaveEnbGnbInteg(t *testing.T){
 616 //      for i := 0; i<10; i++{
 617 //              Init("e2Manager", 1)
 618 //              w := GetRNibWriter()
 619 //              nb := entities.NodebInfo{}
 620 //              nb.NodeType = entities.Node_ENB
 621 //              nb.ConnectionStatus = entities.ConnectionStatus_CONNECTED
 622 //              nb.Ip = "localhost"
 623 //              nb.Port = uint32(5656 + i)
 624 //              enb := entities.Enb{}
 625 //              cell1 := &entities.ServedCellInfo{CellId:fmt.Sprintf("%02x",111 + i), Pci:uint32(11 + i)}
 626 //              cell2 := &entities.ServedCellInfo{CellId:fmt.Sprintf("%02x",222 + i), Pci:uint32(22 + i)}
 627 //              cell3 := &entities.ServedCellInfo{CellId:fmt.Sprintf("%02x",333 + i), Pci:uint32(33 + i)}
 628 //              enb.ServedCells = []*entities.ServedCellInfo{cell1, cell2, cell3}
 629 //              nb.Configuration = &entities.NodebInfo_Enb{Enb:&enb}
 630 //              plmnId := 0x02f828
 631 //              nbId := 0x4a952a0a
 632 //              nbIdentity := &entities.NbIdentity{InventoryName: fmt.Sprintf("nameEnb%d" ,i), GlobalNbId:&entities.GlobalNbId{PlmnId:fmt.Sprintf("%02x", plmnId + i), NbId:fmt.Sprintf("%02x", nbId + i)}}
 633 //              err := w.SaveNodeb(nbIdentity, &nb)
 634 //              if err != nil{
 635 //                      t.Errorf("#rNibWriter_test.TestSaveEnbInteg - Failed to save NodeB entity. Error: %v", err)
 636 //              }
 637 //
 638 //              nb1 := entities.NodebInfo{}
 639 //              nb1.NodeType = entities.Node_GNB
 640 //              nb1.ConnectionStatus = entities.ConnectionStatus_CONNECTED
 641 //              nb1.Ip = "localhost"
 642 //              nb1.Port =  uint32(6565 + i)
 643 //              gnb := entities.Gnb{}
 644 //              gCell1 := &entities.ServedNRCell{ServedNrCellInformation:&entities.ServedNRCellInformation{CellId:fmt.Sprintf("%02x",1111 + i), NrPci:uint32(1 + i)}}
 645 //              gCell2 := &entities.ServedNRCell{ServedNrCellInformation:&entities.ServedNRCellInformation{CellId:fmt.Sprintf("%02x",2222 + i), NrPci:uint32(2 + i)}}
 646 //              gCell3 := &entities.ServedNRCell{ServedNrCellInformation:&entities.ServedNRCellInformation{CellId:fmt.Sprintf("%02x",3333 + i), NrPci:uint32(3 + i)}}
 647 //              gnb.ServedNrCells = []*entities.ServedNRCell{gCell1, gCell2, gCell3,}
 648 //              nb1.Configuration = &entities.NodebInfo_Gnb{Gnb:&gnb}
 649 //              nbIdentity = &entities.NbIdentity{InventoryName: fmt.Sprintf("nameGnb%d" ,i), GlobalNbId:&entities.GlobalNbId{PlmnId:fmt.Sprintf("%02x", plmnId - i), NbId:fmt.Sprintf("%02x", nbId - i)}}
 650 //              err = w.SaveNodeb(nbIdentity, &nb1)
 651 //              if err != nil{
 652 //                      t.Errorf("#rNibWriter_test.TestSaveEnbInteg - Failed to save NodeB entity. Error: %v", err)
 653 //              }
 654 //      }
 655 //}
 656 //
 657 //func TestSaveNbRanNamesInteg(t *testing.T){
 658 //      for i := 0; i<10; i++{
 659 //              Init("e2Manager", 1)
 660 //              w := GetRNibWriter()
 661 //              nb := entities.NodebInfo{}
 662 //              nb.ConnectionStatus = entities.ConnectionStatus_CONNECTING
 663 //              nb.Ip = "localhost"
 664 //              nb.Port = uint32(5656 + i)
 665 //              nbIdentity := &entities.NbIdentity{InventoryName: fmt.Sprintf("nameOnly%d" ,i)}
 666 //              err := w.SaveNodeb(nbIdentity, &nb)
 667 //              if err != nil{
 668 //                      t.Errorf("#rNibWriter_test.TestSaveEnbInteg - Failed to save NodeB entity. Error: %v", err)
 669 //              }
 670 //      }
 671 //}
 672 //
 673 //func TestSaveRanLoadInformationInteg(t *testing.T){
 674 //              Init("e2Manager", 1)
 675 //              w := GetRNibWriter()
 676 //              ranLoadInformation := generateRanLoadInformation()
 677 //              err := w.SaveRanLoadInformation("ran_integ", ranLoadInformation)
 678 //              if err != nil{
 679 //                      t.Errorf("#rNibWriter_test.TestSaveRanLoadInformationInteg - Failed to save RanLoadInformation entity. Error: %v", err)
 680 //              }
 681 //}