2 // Copyright 2019 AT&T Intellectual Property
3 // Copyright 2019 Nokia
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
9 // http://www.apache.org/licenses/LICENSE-2.0
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.
17 // This source code is part of the near-RT RIC (RAN Intelligent Controller)
18 // platform project (RICP).
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"
36 var namespace = "namespace"
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"})
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},
55 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
58 if nodeType == entities.Node_ENB {
59 nodebInfo.Configuration = &entities.NodebInfo_Enb{
62 } else if nodeType == entities.Node_GNB {
63 nodebInfo.Configuration = &entities.NodebInfo_Gnb{
71 func generateServedNrCells(cellIds ...string) []*entities.ServedNRCell {
73 var servedNrCells []*entities.ServedNRCell
75 for i, v := range cellIds {
76 servedNrCells = append(servedNrCells, &entities.ServedNRCell{ServedNrCellInformation: &entities.ServedNRCellInformation{
78 ChoiceNrMode: &entities.ServedNRCellInformation_ChoiceNRMode{
79 Fdd: &entities.ServedNRCellInformation_ChoiceNRMode_FddInfo{
83 NrMode: entities.Nr_FDD,
85 ServedPlmns: []string{"whatever"},
92 func generateServedCells(cellIds ...string) []*entities.ServedCellInfo {
94 var servedCells []*entities.ServedCellInfo
96 for i, v := range cellIds {
97 servedCells = append(servedCells, &entities.ServedCellInfo{
99 ChoiceEutraMode: &entities.ChoiceEUTRAMode{
100 Fdd: &entities.FddInfo{},
103 BroadcastPlmns: []string{"whatever"},
110 func generateServedCellInfos(cellIds ...string) []*entities.ServedCellInfo {
112 servedCells := []*entities.ServedCellInfo{}
114 for i, v := range cellIds {
115 servedCells = append(servedCells, &entities.ServedCellInfo{
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)
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)
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)
149 func TestAddNbIdentitySuccess(t *testing.T) {
150 w, sdlInstanceMock := initSdlInstanceMock(namespace)
152 nbIdentity := &entities.NbIdentity{InventoryName: RanName, GlobalNbId: &entities.GlobalNbId{PlmnId: PlmnId, NbId: NbId}}
153 nbIdData, err := proto.Marshal(nbIdentity)
155 t.Fatalf("#rNibWriter_test.TestAddNbIdentitySuccess - Failed to marshal NodeB Identity entity. Error: %v", err)
158 sdlInstanceMock.On("AddMember", "ENB", []interface{}{nbIdData}).Return(nil)
159 rNibErr := w.AddNbIdentity(entities.Node_ENB,nbIdentity)
160 assert.Nil(t, rNibErr)
163 func TestAddNbIdentitySdlFailure(t *testing.T) {
164 w, sdlInstanceMock := initSdlInstanceMock(namespace)
166 nbIdentity := &entities.NbIdentity{InventoryName: RanName, GlobalNbId: &entities.GlobalNbId{PlmnId: PlmnId, NbId: NbId}}
167 nbIdData, err := proto.Marshal(nbIdentity)
169 t.Fatalf("#rNibWriter_test.TestAddNbIdentitySdlFailure - Failed to marshal NodeB Identity entity. Error: %v", err)
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)
177 func TestUpdateGnbCellsInvalidCellFailure(t *testing.T) {
178 inventoryName := "name"
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)
190 func getUpdateEnbCellsSetExpected(t *testing.T, nodebInfo *entities.NodebInfo, servedCells []*entities.ServedCellInfo) []interface{} {
192 nodebInfoData, err := proto.Marshal(nodebInfo)
194 t.Fatalf("#rNibWriter_test.getUpdateEnbCellsSetExpected - Failed to marshal NodeB entity. Error: %s", err)
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}
201 for _, cell := range servedCells {
203 cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: cell}}
204 cellData, err := proto.Marshal(&cellEntity)
207 t.Fatalf("#rNibWriter_test.getUpdateEnbCellsSetExpected - Failed to marshal cell entity. Error: %s", err)
210 nrCellIdKey, _ := common.ValidateAndBuildCellIdKey(cell.GetCellId())
211 cellNamePciKey, _ := common.ValidateAndBuildCellNamePciKey(nodebInfo.RanName, cell.GetPci())
212 setExpected = append(setExpected, nrCellIdKey, cellData, cellNamePciKey, cellData)
218 func getUpdateGnbCellsSetExpected(t *testing.T, nodebInfo *entities.NodebInfo, servedNrCells []*entities.ServedNRCell) []interface{} {
220 nodebInfoData, err := proto.Marshal(nodebInfo)
222 t.Fatalf("#rNibWriter_test.getUpdateGnbCellsSetExpected - Failed to marshal NodeB entity. Error: %s", err)
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}
229 for _, v := range servedNrCells {
231 cellEntity := entities.Cell{Type: entities.Cell_NR_CELL, Cell: &entities.Cell_ServedNrCell{ServedNrCell: v}}
232 cellData, err := proto.Marshal(&cellEntity)
235 t.Fatalf("#rNibWriter_test.getUpdateGnbCellsSetExpected - Failed to marshal cell entity. Error: %s", err)
238 nrCellIdKey, _ := common.ValidateAndBuildNrCellIdKey(v.GetServedNrCellInformation().GetCellId())
239 cellNamePciKey, _ := common.ValidateAndBuildCellNamePciKey(nodebInfo.RanName, v.GetServedNrCellInformation().GetNrPci())
240 setExpected = append(setExpected, nrCellIdKey, cellData, cellNamePciKey, cellData)
246 func TestUpdateGnbCellsSdlFailure(t *testing.T) {
247 inventoryName := "name"
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)
260 func TestUpdateGnbCellsSuccess(t *testing.T) {
261 inventoryName := "name"
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)
270 sdlInstanceMock.On("SetAndPublish",[]string{"RAN_MANIPULATION", inventoryName + "_" + RanUpdatedEvent}, []interface{}{setExpected}).Return(e)
271 rNibErr := w.UpdateGnbCells(nodebInfo, servedNrCells)
272 assert.Nil(t, rNibErr)
275 func TestUpdateNodebInfoSuccess(t *testing.T) {
276 inventoryName := "name"
279 w, sdlInstanceMock := initSdlInstanceMock(namespace)
280 nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
281 data, err := proto.Marshal(nodebInfo)
283 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal NodeB entity. Error: %v", err)
286 var setExpected []interface{}
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)
293 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
295 rNibErr := w.UpdateNodebInfo(nodebInfo)
296 assert.Nil(t, rNibErr)
299 func TestUpdateNodebInfoMissingInventoryNameFailure(t *testing.T) {
300 inventoryName := "name"
303 w, sdlInstanceMock := initSdlInstanceMock(namespace)
304 nodebInfo := &entities.NodebInfo{}
305 data, err := proto.Marshal(nodebInfo)
307 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal NodeB entity. Error: %v", err)
310 var setExpected []interface{}
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)
317 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
319 rNibErr := w.UpdateNodebInfo(nodebInfo)
321 assert.NotNil(t, rNibErr)
322 assert.IsType(t, &common.ValidationError{}, rNibErr)
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)
332 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal NodeB entity. Error: %v", err)
335 var setExpected []interface{}
337 nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
338 setExpected = append(setExpected, nodebNameKey, data)
339 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
341 rNibErr := w.UpdateNodebInfo(nodebInfo)
343 assert.Nil(t, rNibErr)
346 func TestSaveEnb(t *testing.T) {
347 ranName := "RAN:" + RanName
348 w, sdlInstanceMock := initSdlInstanceMock(namespace)
349 nb := entities.NodebInfo{
351 NodeType: entities.Node_ENB,
352 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
355 GlobalNbId: &entities.GlobalNbId{
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)
368 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal NodeB entity. Error: %v", err)
372 cellData, err := proto.Marshal(&cellEntity)
374 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal Cell entity. Error: %v", err)
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)
382 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
383 rNibErr := w.SaveNodeb(&nb)
384 assert.Nil(t, rNibErr)
387 func TestSaveEnbCellIdValidationFailure(t *testing.T) {
388 w, _ := initSdlInstanceMock(namespace)
389 nb := entities.NodebInfo{}
391 nb.NodeType = entities.Node_ENB
392 nb.ConnectionStatus = 1
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())
405 func TestSaveEnbInventoryNameValidationFailure(t *testing.T) {
406 w, _ := initSdlInstanceMock(namespace)
407 nb := entities.NodebInfo{
408 NodeType: entities.Node_ENB,
409 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
412 GlobalNbId: &entities.GlobalNbId{
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())
427 func TestSaveGnbCellIdValidationFailure(t *testing.T) {
428 w, _ := initSdlInstanceMock(namespace)
429 nb := entities.NodebInfo{}
431 nb.NodeType = entities.Node_GNB
432 nb.ConnectionStatus = 1
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}
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())
447 func TestSaveGnb(t *testing.T) {
448 ranName := "RAN:" + RanName
449 w, sdlInstanceMock := initSdlInstanceMock(namespace)
450 nb := entities.NodebInfo{
452 NodeType: entities.Node_GNB,
454 GlobalNbId: &entities.GlobalNbId{
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)
470 t.Errorf("#rNibWriter_test.TestSaveGnb - Failed to marshal NodeB entity. Error: %v", err)
474 cellData, err := proto.Marshal(&cellEntity)
476 t.Errorf("#rNibWriter_test.TestSaveGnb - Failed to marshal Cell entity. Error: %v", err)
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)
484 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
485 rNibErr := w.SaveNodeb(&nb)
486 assert.Nil(t, rNibErr)
489 func TestSaveRanLoadInformationSuccess(t *testing.T) {
490 inventoryName := "name"
491 loadKey, validationErr := common.ValidateAndBuildRanLoadInformationKey(inventoryName)
493 if validationErr != nil {
494 t.Errorf("#rNibWriter_test.TestSaveRanLoadInformationSuccess - Failed to build ran load infromation key. Error: %v", validationErr)
497 w, sdlInstanceMock := initSdlInstanceMock(namespace)
499 ranLoadInformation := generateRanLoadInformation()
500 data, err := proto.Marshal(ranLoadInformation)
503 t.Errorf("#rNibWriter_test.TestSaveRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
507 var setExpected []interface{}
508 setExpected = append(setExpected, loadKey, data)
509 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
511 rNibErr := w.SaveRanLoadInformation(inventoryName, ranLoadInformation)
512 assert.Nil(t, rNibErr)
515 func TestSaveRanLoadInformationMarshalNilFailure(t *testing.T) {
516 inventoryName := "name2"
517 w, _ := initSdlInstanceMock(namespace)
519 expectedErr := common.NewInternalError(errors.New("proto: Marshal called with nil"))
520 err := w.SaveRanLoadInformation(inventoryName, nil)
521 assert.Equal(t, expectedErr, err)
524 func TestSaveRanLoadInformationEmptyInventoryNameFailure(t *testing.T) {
526 w, _ := initSdlInstanceMock(namespace)
528 err := w.SaveRanLoadInformation(inventoryName, nil)
529 assert.NotNil(t, err)
530 assert.IsType(t, &common.ValidationError{}, err)
533 func TestSaveRanLoadInformationSdlFailure(t *testing.T) {
534 inventoryName := "name2"
536 loadKey, validationErr := common.ValidateAndBuildRanLoadInformationKey(inventoryName)
538 if validationErr != nil {
539 t.Errorf("#rNibWriter_test.TestSaveRanLoadInformationSuccess - Failed to build ran load infromation key. Error: %v", validationErr)
542 w, sdlInstanceMock := initSdlInstanceMock(namespace)
544 ranLoadInformation := generateRanLoadInformation()
545 data, err := proto.Marshal(ranLoadInformation)
548 t.Errorf("#rNibWriter_test.TestSaveRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
551 expectedErr := errors.New("expected error")
552 var setExpected []interface{}
553 setExpected = append(setExpected, loadKey, data)
554 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(expectedErr)
556 rNibErr := w.SaveRanLoadInformation(inventoryName, ranLoadInformation)
557 assert.NotNil(t, rNibErr)
558 assert.IsType(t, &common.InternalError{}, rNibErr)
561 func generateCellLoadInformation() *entities.CellLoadInformation {
562 cellLoadInformation := entities.CellLoadInformation{}
564 cellLoadInformation.CellId = "123"
566 ulInterferenceOverloadIndication := entities.UlInterferenceOverloadIndication_HIGH_INTERFERENCE
567 cellLoadInformation.UlInterferenceOverloadIndications = []entities.UlInterferenceOverloadIndication{ulInterferenceOverloadIndication}
569 ulHighInterferenceInformation := entities.UlHighInterferenceInformation{
571 UlHighInterferenceIndication: "xxx",
574 cellLoadInformation.UlHighInterferenceInfos = []*entities.UlHighInterferenceInformation{&ulHighInterferenceInformation}
576 cellLoadInformation.RelativeNarrowbandTxPower = &entities.RelativeNarrowbandTxPower{
578 RntpThreshold: entities.RntpThreshold_NEG_4,
579 NumberOfCellSpecificAntennaPorts: entities.NumberOfCellSpecificAntennaPorts_V1_ANT_PRT,
581 PdcchInterferenceImpact: 2,
582 EnhancedRntp: &entities.EnhancedRntp{
583 EnhancedRntpBitmap: "xxx",
584 RntpHighPowerThreshold: entities.RntpThreshold_NEG_2,
585 EnhancedRntpStartTime: &entities.StartTime{StartSfn: 500, StartSubframeNumber: 5},
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",
596 cellLoadInformation.InvokeIndication = entities.InvokeIndication_ABS_INFORMATION
598 cellLoadInformation.ExtendedUlInterferenceOverloadInfo = &entities.ExtendedUlInterferenceOverloadInfo{
599 AssociatedSubframes: "xxx",
600 ExtendedUlInterferenceOverloadIndications: cellLoadInformation.UlInterferenceOverloadIndications,
603 compInformationItem := &entities.CompInformationItem{
604 CompHypothesisSets: []*entities.CompHypothesisSet{{CellId: "789", CompHypothesis: "xxx"}},
608 cellLoadInformation.CompInformation = &entities.CompInformation{
609 CompInformationItems: []*entities.CompInformationItem{compInformationItem},
610 CompInformationStartTime: &entities.StartTime{StartSfn: 123, StartSubframeNumber: 456},
613 cellLoadInformation.DynamicDlTransmissionInformation = &entities.DynamicDlTransmissionInformation{
614 State: entities.NaicsState_NAICS_ACTIVE,
615 TransmissionModes: "xxx",
617 PAList: []entities.PA{entities.PA_DB_NEG_3},
620 return &cellLoadInformation
623 func generateRanLoadInformation() *entities.RanLoadInformation {
624 ranLoadInformation := entities.RanLoadInformation{}
626 ranLoadInformation.LoadTimestamp = uint64(time.Now().UnixNano())
628 cellLoadInformation := generateCellLoadInformation()
629 ranLoadInformation.CellLoadInfos = []*entities.CellLoadInformation{cellLoadInformation}
631 return &ranLoadInformation
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)
641 func TestSaveUnknownTypeEntityFailure(t *testing.T) {
642 w, _ := initSdlInstanceMock(namespace)
643 nb := &entities.NodebInfo{}
646 actualErr := w.SaveNodeb(nb)
647 assert.IsType(t, &common.ValidationError{}, actualErr)
650 func TestSaveEntitySetFailure(t *testing.T) {
655 w, sdlInstanceMock := initSdlInstanceMock(namespace)
656 gnb := entities.NodebInfo{
658 NodeType: entities.Node_GNB,
660 GlobalNbId: &entities.GlobalNbId{
667 data, err := proto.Marshal(&gnb)
669 t.Errorf("#rNibWriter_test.TestSaveEntityFailure - Failed to marshal NodeB entity. Error: %v", err)
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)
679 func TestSaveEntitySetAndPublishFailure(t *testing.T) {
684 w, sdlInstanceMock := initSdlInstanceMock(namespace)
685 enb := entities.NodebInfo{
687 NodeType: entities.Node_ENB,
689 GlobalNbId: &entities.GlobalNbId{
696 data, err := proto.Marshal(&enb)
698 t.Errorf("#rNibWriter_test.TestSaveEntityFailure - Failed to marshal NodeB entity. Error: %v", err)
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)
708 func TestGetRNibWriter(t *testing.T) {
709 received, _ := initSdlInstanceMock(namespace)
710 assert.NotEmpty(t, received)
713 func TestSaveE2TInstanceSuccess(t *testing.T) {
714 address := "10.10.2.15:9800"
715 loadKey, validationErr := common.ValidateAndBuildE2TInstanceKey(address)
717 if validationErr != nil {
718 t.Errorf("#rNibWriter_test.TestSaveE2TInstanceSuccess - Failed to build E2T Instance key. Error: %v", validationErr)
721 w, sdlInstanceMock := initSdlInstanceMock(namespace)
723 e2tInstance := generateE2tInstance(address)
724 data, err := json.Marshal(e2tInstance)
727 t.Errorf("#rNibWriter_test.TestSaveE2TInstanceSuccess - Failed to marshal E2tInstance entity. Error: %v", err)
731 var setExpected []interface{}
732 setExpected = append(setExpected, loadKey, data)
733 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
735 rNibErr := w.SaveE2TInstance(e2tInstance)
736 assert.Nil(t, rNibErr)
739 func TestSaveE2TInstanceNullE2tInstanceFailure(t *testing.T) {
740 w, _ := initSdlInstanceMock(namespace)
742 e2tInstance := entities.NewE2TInstance(address, "test")
743 err := w.SaveE2TInstance(e2tInstance)
744 assert.NotNil(t, err)
745 assert.IsType(t, &common.ValidationError{}, err)
748 func TestSaveE2TInstanceSdlFailure(t *testing.T) {
749 address := "10.10.2.15:9800"
750 loadKey, validationErr := common.ValidateAndBuildE2TInstanceKey(address)
752 if validationErr != nil {
753 t.Errorf("#rNibWriter_test.TestSaveE2TInstanceSdlFailure - Failed to build E2T Instance key. Error: %v", validationErr)
756 w, sdlInstanceMock := initSdlInstanceMock(namespace)
758 e2tInstance := generateE2tInstance(address)
759 data, err := json.Marshal(e2tInstance)
762 t.Errorf("#rNibWriter_test.TestSaveE2TInstanceSdlFailure - Failed to marshal E2tInstance entity. Error: %v", err)
765 expectedErr := errors.New("expected error")
766 var setExpected []interface{}
767 setExpected = append(setExpected, loadKey, data)
768 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(expectedErr)
770 rNibErr := w.SaveE2TInstance(e2tInstance)
771 assert.NotNil(t, rNibErr)
772 assert.IsType(t, &common.InternalError{}, rNibErr)
775 func generateE2tInstance(address string) *entities.E2TInstance {
776 e2tInstance := entities.NewE2TInstance(address, "pod test")
778 e2tInstance.AssociatedRanList = []string{"test1", "test2"}
783 func TestSaveE2TAddressesSuccess(t *testing.T) {
784 address := "10.10.2.15:9800"
785 w, sdlInstanceMock := initSdlInstanceMock(namespace)
787 e2tAddresses := []string{address}
788 data, err := json.Marshal(e2tAddresses)
791 t.Errorf("#rNibWriter_test.TestSaveE2TInfoListSuccess - Failed to marshal E2TInfoList. Error: %v", err)
795 var setExpected []interface{}
796 setExpected = append(setExpected, E2TAddressesKey, data)
797 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
799 rNibErr := w.SaveE2TAddresses(e2tAddresses)
800 assert.Nil(t, rNibErr)
803 func TestSaveE2TAddressesSdlFailure(t *testing.T) {
804 address := "10.10.2.15:9800"
805 w, sdlInstanceMock := initSdlInstanceMock(namespace)
807 e2tAddresses := []string{address}
808 data, err := json.Marshal(e2tAddresses)
811 t.Errorf("#rNibWriter_test.TestSaveE2TInfoListSdlFailure - Failed to marshal E2TInfoList. Error: %v", err)
814 expectedErr := errors.New("expected error")
815 var setExpected []interface{}
816 setExpected = append(setExpected, E2TAddressesKey, data)
817 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(expectedErr)
819 rNibErr := w.SaveE2TAddresses(e2tAddresses)
820 assert.NotNil(t, rNibErr)
821 assert.IsType(t, &common.InternalError{}, rNibErr)
824 func TestRemoveE2TInstanceSuccess(t *testing.T) {
825 address := "10.10.2.15:9800"
826 w, sdlInstanceMock := initSdlInstanceMock(namespace)
828 e2tAddresses := []string{fmt.Sprintf("E2TInstance:%s", address)}
830 sdlInstanceMock.On("Remove", e2tAddresses).Return(e)
832 rNibErr := w.RemoveE2TInstance(address)
833 assert.Nil(t, rNibErr)
834 sdlInstanceMock.AssertExpectations(t)
837 func TestRemoveE2TInstanceSdlFailure(t *testing.T) {
838 address := "10.10.2.15:9800"
839 w, sdlInstanceMock := initSdlInstanceMock(namespace)
841 e2tAddresses := []string{fmt.Sprintf("E2TInstance:%s", address)}
842 expectedErr := errors.New("expected error")
843 sdlInstanceMock.On("Remove", e2tAddresses).Return(expectedErr)
845 rNibErr := w.RemoveE2TInstance(address)
846 assert.IsType(t, &common.InternalError{}, rNibErr)
849 func TestRemoveE2TInstanceEmptyAddressFailure(t *testing.T) {
850 w, sdlInstanceMock := initSdlInstanceMock(namespace)
852 rNibErr := w.RemoveE2TInstance("")
853 assert.IsType(t, &common.ValidationError{}, rNibErr)
854 sdlInstanceMock.AssertExpectations(t)
857 func TestUpdateNodebInfoOnConnectionStatusInversionSuccess(t *testing.T) {
858 inventoryName := "name"
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)
867 t.Errorf("#rNibWriter_test.TestUpdateNodebInfoOnConnectionStatusInversionSuccess - Failed to marshal NodeB entity. Error: %v", err)
870 var setExpected []interface{}
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)
877 sdlInstanceMock.On("SetAndPublish", []string{channelName, eventName}, []interface{}{setExpected}).Return(e)
879 rNibErr := w.UpdateNodebInfoOnConnectionStatusInversion(nodebInfo, eventName)
880 assert.Nil(t, rNibErr)
883 func TestUpdateNodebInfoOnConnectionStatusInversionMissingInventoryNameFailure(t *testing.T) {
884 inventoryName := "name"
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)
893 t.Errorf("#rNibWriter_test.TestUpdateNodebInfoOnConnectionStatusInversionMissingInventoryNameFailure - Failed to marshal NodeB entity. Error: %v", err)
896 var setExpected []interface{}
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)
903 sdlInstanceMock.On("SetAndPublish", []string{channelName, eventName}, []interface{}{setExpected}).Return(e)
905 rNibErr := w.UpdateNodebInfoOnConnectionStatusInversion(nodebInfo, eventName)
907 assert.NotNil(t, rNibErr)
908 assert.IsType(t, &common.ValidationError{}, rNibErr)
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)
920 t.Errorf("#rNibWriter_test.TestUpdateNodebInfoOnConnectionStatusInversionMissingInventoryNameFailure - Failed to marshal NodeB entity. Error: %v", err)
923 var setExpected []interface{}
925 nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
926 setExpected = append(setExpected, nodebNameKey, data)
927 sdlInstanceMock.On("SetAndPublish", []string{channelName, eventName}, []interface{}{setExpected}).Return(e)
929 rNibErr := w.UpdateNodebInfoOnConnectionStatusInversion(nodebInfo, eventName)
931 assert.Nil(t, rNibErr)
934 func TestSaveGeneralConfiguration(t *testing.T) {
935 w, sdlInstanceMock := initSdlInstanceMock(namespace)
937 key := common.BuildGeneralConfigurationKey()
938 configurationData := "{\"enableRic\":true}"
939 configuration := &entities.GeneralConfiguration{}
940 configuration.EnableRic = true
942 sdlInstanceMock.On("Set", []interface{}{[]interface{}{key, []byte(configurationData)}}).Return(nil)
943 rNibErr := w.SaveGeneralConfiguration(configuration)
945 assert.Nil(t, rNibErr)
946 sdlInstanceMock.AssertExpectations(t)
949 func TestSaveGeneralConfigurationDbError(t *testing.T) {
950 w, sdlInstanceMock := initSdlInstanceMock(namespace)
952 key := common.BuildGeneralConfigurationKey()
953 configurationData := "{\"enableRic\":true}"
954 configuration := &entities.GeneralConfiguration{}
955 configuration.EnableRic = true
957 expectedErr := errors.New("expected error")
959 sdlInstanceMock.On("Set", []interface{}{[]interface{}{key, []byte(configurationData)}}).Return(expectedErr)
960 rNibErr := w.SaveGeneralConfiguration(configuration)
962 assert.NotNil(t, rNibErr)
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)
971 rNibErr := w.RemoveServedCells(RanName, servedCellsToRemove)
973 assert.NotNil(t, rNibErr)
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)
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)
993 func TestUpdateEnbInvalidCellFailure(t *testing.T) {
994 inventoryName := "name"
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)
1006 func TestUpdateEnbSdlFailure(t *testing.T) {
1007 inventoryName := "name"
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)
1020 func TestUpdateEnbSuccess(t *testing.T) {
1021 inventoryName := "name"
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)
1031 sdlInstanceMock.On("SetAndPublish", []string{"RAN_MANIPULATION", inventoryName + "_" + RanUpdatedEvent}, []interface{}{setExpected}).Return(e)
1032 rNibErr := w.UpdateEnb(nodebInfo, servedCells)
1033 assert.Nil(t, rNibErr)
1036 func getUpdateEnbSetExpected(t *testing.T, nodebInfo *entities.NodebInfo, servedCells []*entities.ServedCellInfo) []interface{} {
1038 nodebInfoData, err := proto.Marshal(nodebInfo)
1040 t.Fatalf("#rNibWriter_test.getUpdateEnbSetExpected - Failed to marshal NodeB entity. Error: %s", err)
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}
1047 for _, v := range servedCells {
1049 cellEntity := entities.ServedCellInfo{CellId: "some cell id", EutraMode: entities.Eutra_FDD, CsgId: "some csg id"}
1050 cellData, err := proto.Marshal(&cellEntity)
1053 t.Fatalf("#rNibWriter_test.getUpdateEnbSetExpected - Failed to marshal cell entity. Error: %s", err)
1056 nrCellIdKey, _ := common.ValidateAndBuildNrCellIdKey(v.GetCellId())
1057 cellNamePciKey, _ := common.ValidateAndBuildCellNamePciKey(nodebInfo.RanName, v.GetPci())
1058 setExpected = append(setExpected, nrCellIdKey, cellData, cellNamePciKey, cellData)
1063 func TestRemoveEnbSuccess(t *testing.T) {
1064 inventoryName := "name"
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")
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)
1085 rNibErr := w.RemoveEnb(nodebInfo)
1086 assert.Nil(t, rNibErr)
1087 sdlInstanceMock.AssertExpectations(t)
1090 func TestRemoveEnbRemoveAndPublishError(t *testing.T) {
1091 inventoryName := "name"
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")
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"))
1110 rNibErr := w.RemoveEnb(nodebInfo)
1111 assert.NotNil(t, rNibErr)
1112 sdlInstanceMock.AssertExpectations(t)
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)
1120 t.Errorf("#TestRemoveNbIdentitySuccess - failed to Marshal NbIdentity")
1123 sdlInstanceMock.On("RemoveMember", entities.Node_ENB.String(), []interface{}{nbIdData}).Return(nil)
1125 rNibErr := w.RemoveNbIdentity(entities.Node_ENB, nbIdentity)
1126 assert.Nil(t, rNibErr)
1127 sdlInstanceMock.AssertExpectations(t)
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)
1135 t.Errorf("#TestRemoveNbIdentitySuccess - failed to Marshal NbIdentity")
1138 sdlInstanceMock.On("RemoveMember", entities.Node_ENB.String(), []interface{}{nbIdData}).Return(fmt.Errorf("for test"))
1140 rNibErr := w.RemoveNbIdentity(entities.Node_ENB, nbIdentity)
1141 assert.NotNil(t, rNibErr)
1142 sdlInstanceMock.AssertExpectations(t)
1145 func TestAddEnb(t *testing.T) {
1146 ranName := "RAN:" + RanName
1147 w, sdlInstanceMock := initSdlInstanceMock(namespace)
1148 nb := entities.NodebInfo{
1150 NodeType: entities.Node_ENB,
1151 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
1154 GlobalNbId: &entities.GlobalNbId{
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)
1167 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal NodeB entity. Error: %v", err)
1171 cellData, err := proto.Marshal(&cellEntity)
1173 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal Cell entity. Error: %v", err)
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)
1181 sdlInstanceMock.On("SetAndPublish", []string{"RAN_MANIPULATION", RanName + "_" + RanAddedEvent}, []interface{}{setExpected}).Return(e)
1183 rNibErr := w.AddEnb(&nb)
1184 assert.Nil(t, rNibErr)
1187 func TestAddEnbCellIdValidationFailure(t *testing.T) {
1188 w, _ := initSdlInstanceMock(namespace)
1189 nb := entities.NodebInfo{}
1191 nb.NodeType = entities.Node_ENB
1192 nb.ConnectionStatus = 1
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())
1205 func TestAddEnbInventoryNameValidationFailure(t *testing.T) {
1206 w, _ := initSdlInstanceMock(namespace)
1207 nb := entities.NodebInfo{
1208 NodeType: entities.Node_ENB,
1209 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
1212 GlobalNbId: &entities.GlobalNbId{
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())
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)
1249 // t.Errorf("#rNibWriter_test.TestSaveEnbInteg - Failed to save NodeB entity. Error: %v", err)
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)
1266 // t.Errorf("#rNibWriter_test.TestSaveEnbInteg - Failed to save NodeB entity. Error: %v", err)
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)
1282 // t.Errorf("#rNibWriter_test.TestSaveEnbInteg - Failed to save NodeB entity. Error: %v", err)
1287 //func TestSaveRanLoadInformationInteg(t *testing.T){
1288 // Init("e2Manager", 1)
1289 // w := GetRNibWriter()
1290 // ranLoadInformation := generateRanLoadInformation()
1291 // err := w.SaveRanLoadInformation("ran_integ", ranLoadInformation)
1293 // t.Errorf("#rNibWriter_test.TestSaveRanLoadInformationInteg - Failed to save RanLoadInformation entity. Error: %v", err)