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("SetAndPublish", []string{"RAN_MANIPULATION", RanName + "_" + RanAddedEvent}, []interface{}{setExpected}).Return(e)
384 rNibErr := w.SaveNodeb(&nb)
385 assert.Nil(t, rNibErr)
388 func TestSaveEnbCellIdValidationFailure(t *testing.T) {
389 w, _ := initSdlInstanceMock(namespace)
390 nb := entities.NodebInfo{}
392 nb.NodeType = entities.Node_ENB
393 nb.ConnectionStatus = 1
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())
406 func TestSaveEnbInventoryNameValidationFailure(t *testing.T) {
407 w, _ := initSdlInstanceMock(namespace)
408 nb := entities.NodebInfo{
409 NodeType: entities.Node_ENB,
410 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
413 GlobalNbId: &entities.GlobalNbId{
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())
428 func TestSaveGnbCellIdValidationFailure(t *testing.T) {
429 w, _ := initSdlInstanceMock(namespace)
430 nb := entities.NodebInfo{}
432 nb.NodeType = entities.Node_GNB
433 nb.ConnectionStatus = 1
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}
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())
448 func TestSaveGnb(t *testing.T) {
449 ranName := "RAN:" + RanName
450 w, sdlInstanceMock := initSdlInstanceMock(namespace)
451 nb := entities.NodebInfo{
453 NodeType: entities.Node_GNB,
455 GlobalNbId: &entities.GlobalNbId{
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)
471 t.Errorf("#rNibWriter_test.TestSaveGnb - Failed to marshal NodeB entity. Error: %v", err)
475 cellData, err := proto.Marshal(&cellEntity)
477 t.Errorf("#rNibWriter_test.TestSaveGnb - Failed to marshal Cell entity. Error: %v", err)
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)
485 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
486 rNibErr := w.SaveNodeb(&nb)
487 assert.Nil(t, rNibErr)
490 func TestSaveRanLoadInformationSuccess(t *testing.T) {
491 inventoryName := "name"
492 loadKey, validationErr := common.ValidateAndBuildRanLoadInformationKey(inventoryName)
494 if validationErr != nil {
495 t.Errorf("#rNibWriter_test.TestSaveRanLoadInformationSuccess - Failed to build ran load infromation key. Error: %v", validationErr)
498 w, sdlInstanceMock := initSdlInstanceMock(namespace)
500 ranLoadInformation := generateRanLoadInformation()
501 data, err := proto.Marshal(ranLoadInformation)
504 t.Errorf("#rNibWriter_test.TestSaveRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
508 var setExpected []interface{}
509 setExpected = append(setExpected, loadKey, data)
510 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
512 rNibErr := w.SaveRanLoadInformation(inventoryName, ranLoadInformation)
513 assert.Nil(t, rNibErr)
516 func TestSaveRanLoadInformationMarshalNilFailure(t *testing.T) {
517 inventoryName := "name2"
518 w, _ := initSdlInstanceMock(namespace)
520 expectedErr := common.NewInternalError(errors.New("proto: Marshal called with nil"))
521 err := w.SaveRanLoadInformation(inventoryName, nil)
522 assert.Equal(t, expectedErr, err)
525 func TestSaveRanLoadInformationEmptyInventoryNameFailure(t *testing.T) {
527 w, _ := initSdlInstanceMock(namespace)
529 err := w.SaveRanLoadInformation(inventoryName, nil)
530 assert.NotNil(t, err)
531 assert.IsType(t, &common.ValidationError{}, err)
534 func TestSaveRanLoadInformationSdlFailure(t *testing.T) {
535 inventoryName := "name2"
537 loadKey, validationErr := common.ValidateAndBuildRanLoadInformationKey(inventoryName)
539 if validationErr != nil {
540 t.Errorf("#rNibWriter_test.TestSaveRanLoadInformationSuccess - Failed to build ran load infromation key. Error: %v", validationErr)
543 w, sdlInstanceMock := initSdlInstanceMock(namespace)
545 ranLoadInformation := generateRanLoadInformation()
546 data, err := proto.Marshal(ranLoadInformation)
549 t.Errorf("#rNibWriter_test.TestSaveRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
552 expectedErr := errors.New("expected error")
553 var setExpected []interface{}
554 setExpected = append(setExpected, loadKey, data)
555 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(expectedErr)
557 rNibErr := w.SaveRanLoadInformation(inventoryName, ranLoadInformation)
558 assert.NotNil(t, rNibErr)
559 assert.IsType(t, &common.InternalError{}, rNibErr)
562 func generateCellLoadInformation() *entities.CellLoadInformation {
563 cellLoadInformation := entities.CellLoadInformation{}
565 cellLoadInformation.CellId = "123"
567 ulInterferenceOverloadIndication := entities.UlInterferenceOverloadIndication_HIGH_INTERFERENCE
568 cellLoadInformation.UlInterferenceOverloadIndications = []entities.UlInterferenceOverloadIndication{ulInterferenceOverloadIndication}
570 ulHighInterferenceInformation := entities.UlHighInterferenceInformation{
572 UlHighInterferenceIndication: "xxx",
575 cellLoadInformation.UlHighInterferenceInfos = []*entities.UlHighInterferenceInformation{&ulHighInterferenceInformation}
577 cellLoadInformation.RelativeNarrowbandTxPower = &entities.RelativeNarrowbandTxPower{
579 RntpThreshold: entities.RntpThreshold_NEG_4,
580 NumberOfCellSpecificAntennaPorts: entities.NumberOfCellSpecificAntennaPorts_V1_ANT_PRT,
582 PdcchInterferenceImpact: 2,
583 EnhancedRntp: &entities.EnhancedRntp{
584 EnhancedRntpBitmap: "xxx",
585 RntpHighPowerThreshold: entities.RntpThreshold_NEG_2,
586 EnhancedRntpStartTime: &entities.StartTime{StartSfn: 500, StartSubframeNumber: 5},
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",
597 cellLoadInformation.InvokeIndication = entities.InvokeIndication_ABS_INFORMATION
599 cellLoadInformation.ExtendedUlInterferenceOverloadInfo = &entities.ExtendedUlInterferenceOverloadInfo{
600 AssociatedSubframes: "xxx",
601 ExtendedUlInterferenceOverloadIndications: cellLoadInformation.UlInterferenceOverloadIndications,
604 compInformationItem := &entities.CompInformationItem{
605 CompHypothesisSets: []*entities.CompHypothesisSet{{CellId: "789", CompHypothesis: "xxx"}},
609 cellLoadInformation.CompInformation = &entities.CompInformation{
610 CompInformationItems: []*entities.CompInformationItem{compInformationItem},
611 CompInformationStartTime: &entities.StartTime{StartSfn: 123, StartSubframeNumber: 456},
614 cellLoadInformation.DynamicDlTransmissionInformation = &entities.DynamicDlTransmissionInformation{
615 State: entities.NaicsState_NAICS_ACTIVE,
616 TransmissionModes: "xxx",
618 PAList: []entities.PA{entities.PA_DB_NEG_3},
621 return &cellLoadInformation
624 func generateRanLoadInformation() *entities.RanLoadInformation {
625 ranLoadInformation := entities.RanLoadInformation{}
627 ranLoadInformation.LoadTimestamp = uint64(time.Now().UnixNano())
629 cellLoadInformation := generateCellLoadInformation()
630 ranLoadInformation.CellLoadInfos = []*entities.CellLoadInformation{cellLoadInformation}
632 return &ranLoadInformation
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)
642 func TestSaveUnknownTypeEntityFailure(t *testing.T) {
643 w, _ := initSdlInstanceMock(namespace)
644 nb := &entities.NodebInfo{}
647 actualErr := w.SaveNodeb(nb)
648 assert.IsType(t, &common.ValidationError{}, actualErr)
651 func TestSaveEntityFailure(t *testing.T) {
656 w, sdlInstanceMock := initSdlInstanceMock(namespace)
657 gnb := entities.NodebInfo{}
658 gnb.NodeType = entities.Node_GNB
659 data, err := proto.Marshal(&gnb)
661 t.Errorf("#rNibWriter_test.TestSaveEntityFailure - Failed to marshal NodeB entity. Error: %v", err)
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)
671 func TestGetRNibWriter(t *testing.T) {
672 received, _ := initSdlInstanceMock(namespace)
673 assert.NotEmpty(t, received)
676 func TestSaveE2TInstanceSuccess(t *testing.T) {
677 address := "10.10.2.15:9800"
678 loadKey, validationErr := common.ValidateAndBuildE2TInstanceKey(address)
680 if validationErr != nil {
681 t.Errorf("#rNibWriter_test.TestSaveE2TInstanceSuccess - Failed to build E2T Instance key. Error: %v", validationErr)
684 w, sdlInstanceMock := initSdlInstanceMock(namespace)
686 e2tInstance := generateE2tInstance(address)
687 data, err := json.Marshal(e2tInstance)
690 t.Errorf("#rNibWriter_test.TestSaveE2TInstanceSuccess - Failed to marshal E2tInstance entity. Error: %v", err)
694 var setExpected []interface{}
695 setExpected = append(setExpected, loadKey, data)
696 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
698 rNibErr := w.SaveE2TInstance(e2tInstance)
699 assert.Nil(t, rNibErr)
702 func TestSaveE2TInstanceNullE2tInstanceFailure(t *testing.T) {
703 w, _ := initSdlInstanceMock(namespace)
705 e2tInstance := entities.NewE2TInstance(address, "test")
706 err := w.SaveE2TInstance(e2tInstance)
707 assert.NotNil(t, err)
708 assert.IsType(t, &common.ValidationError{}, err)
711 func TestSaveE2TInstanceSdlFailure(t *testing.T) {
712 address := "10.10.2.15:9800"
713 loadKey, validationErr := common.ValidateAndBuildE2TInstanceKey(address)
715 if validationErr != nil {
716 t.Errorf("#rNibWriter_test.TestSaveE2TInstanceSdlFailure - Failed to build E2T Instance key. Error: %v", validationErr)
719 w, sdlInstanceMock := initSdlInstanceMock(namespace)
721 e2tInstance := generateE2tInstance(address)
722 data, err := json.Marshal(e2tInstance)
725 t.Errorf("#rNibWriter_test.TestSaveE2TInstanceSdlFailure - Failed to marshal E2tInstance entity. Error: %v", err)
728 expectedErr := errors.New("expected error")
729 var setExpected []interface{}
730 setExpected = append(setExpected, loadKey, data)
731 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(expectedErr)
733 rNibErr := w.SaveE2TInstance(e2tInstance)
734 assert.NotNil(t, rNibErr)
735 assert.IsType(t, &common.InternalError{}, rNibErr)
738 func generateE2tInstance(address string) *entities.E2TInstance {
739 e2tInstance := entities.NewE2TInstance(address, "pod test")
741 e2tInstance.AssociatedRanList = []string{"test1", "test2"}
746 func TestSaveE2TAddressesSuccess(t *testing.T) {
747 address := "10.10.2.15:9800"
748 w, sdlInstanceMock := initSdlInstanceMock(namespace)
750 e2tAddresses := []string{address}
751 data, err := json.Marshal(e2tAddresses)
754 t.Errorf("#rNibWriter_test.TestSaveE2TInfoListSuccess - Failed to marshal E2TInfoList. Error: %v", err)
758 var setExpected []interface{}
759 setExpected = append(setExpected, E2TAddressesKey, data)
760 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
762 rNibErr := w.SaveE2TAddresses(e2tAddresses)
763 assert.Nil(t, rNibErr)
766 func TestSaveE2TAddressesSdlFailure(t *testing.T) {
767 address := "10.10.2.15:9800"
768 w, sdlInstanceMock := initSdlInstanceMock(namespace)
770 e2tAddresses := []string{address}
771 data, err := json.Marshal(e2tAddresses)
774 t.Errorf("#rNibWriter_test.TestSaveE2TInfoListSdlFailure - Failed to marshal E2TInfoList. Error: %v", err)
777 expectedErr := errors.New("expected error")
778 var setExpected []interface{}
779 setExpected = append(setExpected, E2TAddressesKey, data)
780 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(expectedErr)
782 rNibErr := w.SaveE2TAddresses(e2tAddresses)
783 assert.NotNil(t, rNibErr)
784 assert.IsType(t, &common.InternalError{}, rNibErr)
787 func TestRemoveE2TInstanceSuccess(t *testing.T) {
788 address := "10.10.2.15:9800"
789 w, sdlInstanceMock := initSdlInstanceMock(namespace)
791 e2tAddresses := []string{fmt.Sprintf("E2TInstance:%s", address)}
793 sdlInstanceMock.On("Remove", e2tAddresses).Return(e)
795 rNibErr := w.RemoveE2TInstance(address)
796 assert.Nil(t, rNibErr)
797 sdlInstanceMock.AssertExpectations(t)
800 func TestRemoveE2TInstanceSdlFailure(t *testing.T) {
801 address := "10.10.2.15:9800"
802 w, sdlInstanceMock := initSdlInstanceMock(namespace)
804 e2tAddresses := []string{fmt.Sprintf("E2TInstance:%s", address)}
805 expectedErr := errors.New("expected error")
806 sdlInstanceMock.On("Remove", e2tAddresses).Return(expectedErr)
808 rNibErr := w.RemoveE2TInstance(address)
809 assert.IsType(t, &common.InternalError{}, rNibErr)
812 func TestRemoveE2TInstanceEmptyAddressFailure(t *testing.T) {
813 w, sdlInstanceMock := initSdlInstanceMock(namespace)
815 rNibErr := w.RemoveE2TInstance("")
816 assert.IsType(t, &common.ValidationError{}, rNibErr)
817 sdlInstanceMock.AssertExpectations(t)
820 func TestUpdateNodebInfoOnConnectionStatusInversionSuccess(t *testing.T) {
821 inventoryName := "name"
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)
830 t.Errorf("#rNibWriter_test.TestUpdateNodebInfoOnConnectionStatusInversionSuccess - Failed to marshal NodeB entity. Error: %v", err)
833 var setExpected []interface{}
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)
840 sdlInstanceMock.On("SetAndPublish", []string{channelName, eventName}, []interface{}{setExpected}).Return(e)
842 rNibErr := w.UpdateNodebInfoOnConnectionStatusInversion(nodebInfo, eventName)
843 assert.Nil(t, rNibErr)
846 func TestUpdateNodebInfoOnConnectionStatusInversionMissingInventoryNameFailure(t *testing.T) {
847 inventoryName := "name"
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)
856 t.Errorf("#rNibWriter_test.TestUpdateNodebInfoOnConnectionStatusInversionMissingInventoryNameFailure - Failed to marshal NodeB entity. Error: %v", err)
859 var setExpected []interface{}
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)
866 sdlInstanceMock.On("SetAndPublish", []string{channelName, eventName}, []interface{}{setExpected}).Return(e)
868 rNibErr := w.UpdateNodebInfoOnConnectionStatusInversion(nodebInfo, eventName)
870 assert.NotNil(t, rNibErr)
871 assert.IsType(t, &common.ValidationError{}, rNibErr)
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)
883 t.Errorf("#rNibWriter_test.TestUpdateNodebInfoOnConnectionStatusInversionMissingInventoryNameFailure - Failed to marshal NodeB entity. Error: %v", err)
886 var setExpected []interface{}
888 nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
889 setExpected = append(setExpected, nodebNameKey, data)
890 sdlInstanceMock.On("SetAndPublish", []string{channelName, eventName}, []interface{}{setExpected}).Return(e)
892 rNibErr := w.UpdateNodebInfoOnConnectionStatusInversion(nodebInfo, eventName)
894 assert.Nil(t, rNibErr)
897 func TestSaveGeneralConfiguration(t *testing.T) {
898 w, sdlInstanceMock := initSdlInstanceMock(namespace)
900 key := common.BuildGeneralConfigurationKey()
901 configurationData := "{\"enableRic\":true}"
902 configuration := &entities.GeneralConfiguration{}
903 configuration.EnableRic = true
905 sdlInstanceMock.On("Set", []interface{}{[]interface{}{key, []byte(configurationData)}}).Return(nil)
906 rNibErr := w.SaveGeneralConfiguration(configuration)
908 assert.Nil(t, rNibErr)
909 sdlInstanceMock.AssertExpectations(t)
912 func TestSaveGeneralConfigurationDbError(t *testing.T) {
913 w, sdlInstanceMock := initSdlInstanceMock(namespace)
915 key := common.BuildGeneralConfigurationKey()
916 configurationData := "{\"enableRic\":true}"
917 configuration := &entities.GeneralConfiguration{}
918 configuration.EnableRic = true
920 expectedErr := errors.New("expected error")
922 sdlInstanceMock.On("Set", []interface{}{[]interface{}{key, []byte(configurationData)}}).Return(expectedErr)
923 rNibErr := w.SaveGeneralConfiguration(configuration)
925 assert.NotNil(t, rNibErr)
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)
934 rNibErr := w.RemoveServedCells(RanName, servedCellsToRemove)
936 assert.NotNil(t, rNibErr)
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)
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)
956 func TestUpdateEnbInvalidCellFailure(t *testing.T) {
957 inventoryName := "name"
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)
969 func TestUpdateEnbSdlFailure(t *testing.T) {
970 inventoryName := "name"
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)
983 func TestUpdateEnbSuccess(t *testing.T) {
984 inventoryName := "name"
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)
994 sdlInstanceMock.On("SetAndPublish", []string{"RAN_MANIPULATION", inventoryName + "_" + RanUpdatedEvent}, []interface{}{setExpected}).Return(e)
995 rNibErr := w.UpdateEnb(nodebInfo, servedCells)
996 assert.Nil(t, rNibErr)
999 func getUpdateEnbSetExpected(t *testing.T, nodebInfo *entities.NodebInfo, servedCells []*entities.ServedCellInfo) []interface{} {
1001 nodebInfoData, err := proto.Marshal(nodebInfo)
1003 t.Fatalf("#rNibWriter_test.getUpdateEnbSetExpected - Failed to marshal NodeB entity. Error: %s", err)
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}
1010 for _, v := range servedCells {
1012 cellEntity := entities.ServedCellInfo{CellId: "some cell id", EutraMode: entities.Eutra_FDD, CsgId: "some csg id"}
1013 cellData, err := proto.Marshal(&cellEntity)
1016 t.Fatalf("#rNibWriter_test.getUpdateEnbSetExpected - Failed to marshal cell entity. Error: %s", err)
1019 nrCellIdKey, _ := common.ValidateAndBuildNrCellIdKey(v.GetCellId())
1020 cellNamePciKey, _ := common.ValidateAndBuildCellNamePciKey(nodebInfo.RanName, v.GetPci())
1021 setExpected = append(setExpected, nrCellIdKey, cellData, cellNamePciKey, cellData)
1026 func TestRemoveEnbSuccess(t *testing.T) {
1027 inventoryName := "name"
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")
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)
1048 rNibErr := w.RemoveEnb(nodebInfo)
1049 assert.Nil(t, rNibErr)
1050 sdlInstanceMock.AssertExpectations(t)
1053 func TestRemoveEnbRemoveAndPublishError(t *testing.T) {
1054 inventoryName := "name"
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")
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"))
1073 rNibErr := w.RemoveEnb(nodebInfo)
1074 assert.NotNil(t, rNibErr)
1075 sdlInstanceMock.AssertExpectations(t)
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)
1083 t.Errorf("#TestRemoveNbIdentitySuccess - failed to Marshal NbIdentity")
1086 sdlInstanceMock.On("RemoveMember", entities.Node_ENB.String(), []interface{}{nbIdData}).Return(nil)
1088 rNibErr := w.RemoveNbIdentity(entities.Node_ENB, nbIdentity)
1089 assert.Nil(t, rNibErr)
1090 sdlInstanceMock.AssertExpectations(t)
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)
1098 t.Errorf("#TestRemoveNbIdentitySuccess - failed to Marshal NbIdentity")
1101 sdlInstanceMock.On("RemoveMember", entities.Node_ENB.String(), []interface{}{nbIdData}).Return(fmt.Errorf("for test"))
1103 rNibErr := w.RemoveNbIdentity(entities.Node_ENB, nbIdentity)
1104 assert.NotNil(t, rNibErr)
1105 sdlInstanceMock.AssertExpectations(t)
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)
1130 // t.Errorf("#rNibWriter_test.TestSaveEnbInteg - Failed to save NodeB entity. Error: %v", err)
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)
1147 // t.Errorf("#rNibWriter_test.TestSaveEnbInteg - Failed to save NodeB entity. Error: %v", err)
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)
1163 // t.Errorf("#rNibWriter_test.TestSaveEnbInteg - Failed to save NodeB entity. Error: %v", err)
1168 //func TestSaveRanLoadInformationInteg(t *testing.T){
1169 // Init("e2Manager", 1)
1170 // w := GetRNibWriter()
1171 // ranLoadInformation := generateRanLoadInformation()
1172 // err := w.SaveRanLoadInformation("ran_integ", ranLoadInformation)
1174 // t.Errorf("#rNibWriter_test.TestSaveRanLoadInformationInteg - Failed to save RanLoadInformation entity. Error: %v", err)