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"
42 func initSdlInstanceMock(namespace string) (w RNibWriter, sdlInstanceMock *mocks.MockSdlInstance) {
43 sdlInstanceMock = new(mocks.MockSdlInstance)
44 w = GetRNibWriter(sdlInstanceMock, configuration.RnibWriterConfig{StateChangeMessageChannel: "RAN_CONNECTION_STATUS_CHANGE", RanManipulationMessageChannel: "RAN_MANIPULATION"})
48 func generateNodebInfo(inventoryName string, nodeType entities.Node_Type, plmnId string, nbId string) *entities.NodebInfo {
49 nodebInfo := &entities.NodebInfo{
50 RanName: inventoryName,
51 GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId},
53 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
56 if nodeType == entities.Node_ENB {
57 nodebInfo.Configuration = &entities.NodebInfo_Enb{
60 } else if nodeType == entities.Node_GNB {
61 nodebInfo.Configuration = &entities.NodebInfo_Gnb{
69 func generateServedNrCells(cellIds ...string) []*entities.ServedNRCell {
71 var servedNrCells []*entities.ServedNRCell
73 for i, v := range cellIds {
74 servedNrCells = append(servedNrCells, &entities.ServedNRCell{ServedNrCellInformation: &entities.ServedNRCellInformation{
76 ChoiceNrMode: &entities.ServedNRCellInformation_ChoiceNRMode{
77 Fdd: &entities.ServedNRCellInformation_ChoiceNRMode_FddInfo{
81 NrMode: entities.Nr_FDD,
83 ServedPlmns: []string{"whatever"},
90 func generateServedCells(cellIds ...string) []*entities.ServedCellInfo {
92 var servedCells []*entities.ServedCellInfo
94 for i, v := range cellIds {
95 servedCells = append(servedCells, &entities.ServedCellInfo{
97 ChoiceEutraMode: &entities.ChoiceEUTRAMode{
98 Fdd: &entities.FddInfo{},
101 BroadcastPlmns: []string{"whatever"},
108 func generateServedCellInfos(cellIds ...string) []*entities.ServedCellInfo {
110 servedCells := []*entities.ServedCellInfo{}
112 for i, v := range cellIds {
113 servedCells = append(servedCells, &entities.ServedCellInfo{
122 func TestRemoveServedNrCellsSuccess(t *testing.T) {
123 w, sdlInstanceMock := initSdlInstanceMock(namespace)
124 servedNrCellsToRemove := generateServedNrCells("whatever1", "whatever2")
125 sdlInstanceMock.On("Remove", buildServedNRCellKeysToRemove(RanName, servedNrCellsToRemove)).Return(nil)
126 err := w.RemoveServedNrCells(RanName, servedNrCellsToRemove)
130 func TestRemoveServedNrCellsFailure(t *testing.T) {
131 w, sdlInstanceMock := initSdlInstanceMock(namespace)
132 servedNrCellsToRemove := generateServedNrCells("whatever1", "whatever2")
133 sdlInstanceMock.On("Remove", buildServedNRCellKeysToRemove(RanName, servedNrCellsToRemove)).Return(errors.New("expected error"))
134 err := w.RemoveServedNrCells(RanName, servedNrCellsToRemove)
135 assert.IsType(t, &common.InternalError{}, err)
138 func TestUpdateGnbCellsInvalidNodebInfoFailure(t *testing.T) {
139 w, sdlInstanceMock := initSdlInstanceMock(namespace)
140 servedNrCells := generateServedNrCells("test1", "test2")
141 nodebInfo := &entities.NodebInfo{}
142 sdlInstanceMock.AssertNotCalled(t, "Set")
143 rNibErr := w.UpdateGnbCells(nodebInfo, servedNrCells)
144 assert.IsType(t, &common.ValidationError{}, rNibErr)
147 func TestUpdateGnbCellsInvalidCellFailure(t *testing.T) {
148 inventoryName := "name"
151 w, sdlInstanceMock := initSdlInstanceMock(namespace)
152 servedNrCells := []*entities.ServedNRCell{{ServedNrCellInformation: &entities.ServedNRCellInformation{}}}
153 nodebInfo := generateNodebInfo(inventoryName, entities.Node_GNB, plmnId, nbId)
154 nodebInfo.GetGnb().ServedNrCells = servedNrCells
155 sdlInstanceMock.AssertNotCalled(t, "Set")
156 rNibErr := w.UpdateGnbCells(nodebInfo, servedNrCells)
157 assert.IsType(t, &common.ValidationError{}, rNibErr)
160 func getUpdateEnbCellsSetExpected(t *testing.T, nodebInfo *entities.NodebInfo, servedCells []*entities.ServedCellInfo) []interface{} {
162 nodebInfoData, err := proto.Marshal(nodebInfo)
164 t.Fatalf("#rNibWriter_test.getUpdateEnbCellsSetExpected - Failed to marshal NodeB entity. Error: %s", err)
167 nodebNameKey, _ := common.ValidateAndBuildNodeBNameKey(nodebInfo.RanName)
168 nodebIdKey, _ := common.ValidateAndBuildNodeBIdKey(nodebInfo.NodeType.String(), nodebInfo.GlobalNbId.PlmnId, nodebInfo.GlobalNbId.NbId)
169 setExpected := []interface{}{nodebNameKey, nodebInfoData, nodebIdKey, nodebInfoData}
171 for _, cell := range servedCells {
173 cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: cell}}
174 cellData, err := proto.Marshal(&cellEntity)
177 t.Fatalf("#rNibWriter_test.getUpdateEnbCellsSetExpected - Failed to marshal cell entity. Error: %s", err)
180 nrCellIdKey, _ := common.ValidateAndBuildCellIdKey(cell.GetCellId())
181 cellNamePciKey, _ := common.ValidateAndBuildCellNamePciKey(nodebInfo.RanName, cell.GetPci())
182 setExpected = append(setExpected, nrCellIdKey, cellData, cellNamePciKey, cellData)
188 func getUpdateGnbCellsSetExpected(t *testing.T, nodebInfo *entities.NodebInfo, servedNrCells []*entities.ServedNRCell) []interface{} {
190 nodebInfoData, err := proto.Marshal(nodebInfo)
192 t.Fatalf("#rNibWriter_test.getUpdateGnbCellsSetExpected - Failed to marshal NodeB entity. Error: %s", err)
195 nodebNameKey, _ := common.ValidateAndBuildNodeBNameKey(nodebInfo.RanName)
196 nodebIdKey, _ := common.ValidateAndBuildNodeBIdKey(nodebInfo.NodeType.String(), nodebInfo.GlobalNbId.PlmnId, nodebInfo.GlobalNbId.NbId)
197 setExpected := []interface{}{nodebNameKey, nodebInfoData, nodebIdKey, nodebInfoData}
199 for _, v := range servedNrCells {
201 cellEntity := entities.Cell{Type: entities.Cell_NR_CELL, Cell: &entities.Cell_ServedNrCell{ServedNrCell: v}}
202 cellData, err := proto.Marshal(&cellEntity)
205 t.Fatalf("#rNibWriter_test.getUpdateGnbCellsSetExpected - Failed to marshal cell entity. Error: %s", err)
208 nrCellIdKey, _ := common.ValidateAndBuildNrCellIdKey(v.GetServedNrCellInformation().GetCellId())
209 cellNamePciKey, _ := common.ValidateAndBuildCellNamePciKey(nodebInfo.RanName, v.GetServedNrCellInformation().GetNrPci())
210 setExpected = append(setExpected, nrCellIdKey, cellData, cellNamePciKey, cellData)
216 func TestUpdateGnbCellsSdlFailure(t *testing.T) {
217 inventoryName := "name"
220 w, sdlInstanceMock := initSdlInstanceMock(namespace)
221 servedNrCells := generateServedNrCells("test1", "test2")
222 nodebInfo := generateNodebInfo(inventoryName, entities.Node_GNB, plmnId, nbId)
223 nodebInfo.GetGnb().ServedNrCells = servedNrCells
224 setExpected := getUpdateGnbCellsSetExpected(t, nodebInfo, servedNrCells)
225 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(errors.New("expected error"))
226 rNibErr := w.UpdateGnbCells(nodebInfo, servedNrCells)
227 assert.IsType(t, &common.InternalError{}, rNibErr)
230 func TestUpdateGnbCellsSuccess(t *testing.T) {
231 inventoryName := "name"
234 w, sdlInstanceMock := initSdlInstanceMock(namespace)
235 servedNrCells := generateServedNrCells("test1", "test2")
236 nodebInfo := generateNodebInfo(inventoryName, entities.Node_GNB, plmnId, nbId)
237 nodebInfo.GetGnb().ServedNrCells = servedNrCells
238 setExpected := getUpdateGnbCellsSetExpected(t, nodebInfo, servedNrCells)
240 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
241 rNibErr := w.UpdateGnbCells(nodebInfo, servedNrCells)
242 assert.Nil(t, rNibErr)
245 func TestUpdateNodebInfoSuccess(t *testing.T) {
246 inventoryName := "name"
249 w, sdlInstanceMock := initSdlInstanceMock(namespace)
250 nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
251 data, err := proto.Marshal(nodebInfo)
253 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal NodeB entity. Error: %v", err)
256 var setExpected []interface{}
258 nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
259 nodebIdKey := fmt.Sprintf("ENB:%s:%s", plmnId, nbId)
260 setExpected = append(setExpected, nodebNameKey, data)
261 setExpected = append(setExpected, nodebIdKey, data)
263 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
265 rNibErr := w.UpdateNodebInfo(nodebInfo)
266 assert.Nil(t, rNibErr)
269 func TestUpdateNodebInfoMissingInventoryNameFailure(t *testing.T) {
270 inventoryName := "name"
273 w, sdlInstanceMock := initSdlInstanceMock(namespace)
274 nodebInfo := &entities.NodebInfo{}
275 data, err := proto.Marshal(nodebInfo)
277 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal NodeB entity. Error: %v", err)
280 var setExpected []interface{}
282 nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
283 nodebIdKey := fmt.Sprintf("ENB:%s:%s", plmnId, nbId)
284 setExpected = append(setExpected, nodebNameKey, data)
285 setExpected = append(setExpected, nodebIdKey, data)
287 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
289 rNibErr := w.UpdateNodebInfo(nodebInfo)
291 assert.NotNil(t, rNibErr)
292 assert.IsType(t, &common.ValidationError{}, rNibErr)
295 func TestUpdateNodebInfoMissingGlobalNbId(t *testing.T) {
296 inventoryName := "name"
297 w, sdlInstanceMock := initSdlInstanceMock(namespace)
298 nodebInfo := &entities.NodebInfo{}
299 nodebInfo.RanName = inventoryName
300 data, err := proto.Marshal(nodebInfo)
302 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal NodeB entity. Error: %v", err)
305 var setExpected []interface{}
307 nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
308 setExpected = append(setExpected, nodebNameKey, data)
309 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
311 rNibErr := w.UpdateNodebInfo(nodebInfo)
313 assert.Nil(t, rNibErr)
316 func TestSaveEnb(t *testing.T) {
317 ranName := "RAN:" + RanName
318 w, sdlInstanceMock := initSdlInstanceMock(namespace)
319 nb := entities.NodebInfo{
321 NodeType: entities.Node_ENB,
322 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
325 GlobalNbId: &entities.GlobalNbId{
331 enb := entities.Enb{}
332 cell := &entities.ServedCellInfo{CellId: "aaff", Pci: 3}
333 cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: cell}}
334 enb.ServedCells = []*entities.ServedCellInfo{cell}
335 nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
336 data, err := proto.Marshal(&nb)
338 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal NodeB entity. Error: %v", err)
342 cellData, err := proto.Marshal(&cellEntity)
344 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal Cell entity. Error: %v", err)
346 var setExpected []interface{}
347 setExpected = append(setExpected, ranName, data)
348 setExpected = append(setExpected, "ENB:02f829:4a952a0a", data)
349 setExpected = append(setExpected, fmt.Sprintf("CELL:%s", cell.GetCellId()), cellData)
350 setExpected = append(setExpected, fmt.Sprintf("PCI:%s:%02x", RanName, cell.GetPci()), cellData)
352 sdlInstanceMock.On("SetAndPublish", []string{"RAN_MANIPULATION", RanName + "_" + RanAddedEvent}, []interface{}{setExpected}).Return(e)
354 rNibErr := w.SaveNodeb(&nb)
355 assert.Nil(t, rNibErr)
358 func TestSaveEnbCellIdValidationFailure(t *testing.T) {
359 w, _ := initSdlInstanceMock(namespace)
360 nb := entities.NodebInfo{}
362 nb.NodeType = entities.Node_ENB
363 nb.ConnectionStatus = 1
366 enb := entities.Enb{}
367 cell := &entities.ServedCellInfo{Pci: 3}
368 enb.ServedCells = []*entities.ServedCellInfo{cell}
369 nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
370 rNibErr := w.SaveNodeb(&nb)
371 assert.NotNil(t, rNibErr)
372 assert.IsType(t, &common.ValidationError{}, rNibErr)
373 assert.Equal(t, "#utils.ValidateAndBuildCellIdKey - an empty cell id received", rNibErr.Error())
376 func TestSaveEnbInventoryNameValidationFailure(t *testing.T) {
377 w, _ := initSdlInstanceMock(namespace)
378 nb := entities.NodebInfo{
379 NodeType: entities.Node_ENB,
380 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
383 GlobalNbId: &entities.GlobalNbId{
388 enb := entities.Enb{}
389 cell := &entities.ServedCellInfo{CellId: "aaa", Pci: 3}
390 enb.ServedCells = []*entities.ServedCellInfo{cell}
391 nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
392 rNibErr := w.SaveNodeb(&nb)
393 assert.NotNil(t, rNibErr)
394 assert.IsType(t, &common.ValidationError{}, rNibErr)
395 assert.Equal(t, "#utils.ValidateAndBuildNodeBNameKey - an empty inventory name received", rNibErr.Error())
398 func TestSaveGnbCellIdValidationFailure(t *testing.T) {
399 w, _ := initSdlInstanceMock(namespace)
400 nb := entities.NodebInfo{}
402 nb.NodeType = entities.Node_GNB
403 nb.ConnectionStatus = 1
406 gnb := entities.Gnb{}
407 cellInfo := &entities.ServedNRCellInformation{NrPci: 2}
408 cell := &entities.ServedNRCell{ServedNrCellInformation: cellInfo}
409 gnb.ServedNrCells = []*entities.ServedNRCell{cell}
410 nb.Configuration = &entities.NodebInfo_Gnb{Gnb: &gnb}
412 rNibErr := w.SaveNodeb(&nb)
413 assert.NotNil(t, rNibErr)
414 assert.IsType(t, &common.ValidationError{}, rNibErr)
415 assert.Equal(t, "#utils.ValidateAndBuildNrCellIdKey - an empty cell id received", rNibErr.Error())
418 func TestSaveGnb(t *testing.T) {
419 ranName := "RAN:" + RanName
420 w, sdlInstanceMock := initSdlInstanceMock(namespace)
421 nb := entities.NodebInfo{
423 NodeType: entities.Node_GNB,
425 GlobalNbId: &entities.GlobalNbId{
433 gnb := entities.Gnb{}
434 cellInfo := &entities.ServedNRCellInformation{NrPci: 2, CellId: "ccdd"}
435 cell := &entities.ServedNRCell{ServedNrCellInformation: cellInfo}
436 cellEntity := entities.Cell{Type: entities.Cell_NR_CELL, Cell: &entities.Cell_ServedNrCell{ServedNrCell: cell}}
437 gnb.ServedNrCells = []*entities.ServedNRCell{cell}
438 nb.Configuration = &entities.NodebInfo_Gnb{Gnb: &gnb}
439 data, err := proto.Marshal(&nb)
441 t.Errorf("#rNibWriter_test.TestSaveGnb - Failed to marshal NodeB entity. Error: %v", err)
445 cellData, err := proto.Marshal(&cellEntity)
447 t.Errorf("#rNibWriter_test.TestSaveGnb - Failed to marshal Cell entity. Error: %v", err)
449 var setExpected []interface{}
450 setExpected = append(setExpected, ranName, data)
451 setExpected = append(setExpected, "GNB:02f829:4a952a0a", data)
452 setExpected = append(setExpected, fmt.Sprintf("NRCELL:%s", cell.GetServedNrCellInformation().GetCellId()), cellData)
453 setExpected = append(setExpected, fmt.Sprintf("PCI:%s:%02x", RanName, cell.GetServedNrCellInformation().GetNrPci()), cellData)
455 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
456 rNibErr := w.SaveNodeb(&nb)
457 assert.Nil(t, rNibErr)
460 func TestSaveRanLoadInformationSuccess(t *testing.T) {
461 inventoryName := "name"
462 loadKey, validationErr := common.ValidateAndBuildRanLoadInformationKey(inventoryName)
464 if validationErr != nil {
465 t.Errorf("#rNibWriter_test.TestSaveRanLoadInformationSuccess - Failed to build ran load infromation key. Error: %v", validationErr)
468 w, sdlInstanceMock := initSdlInstanceMock(namespace)
470 ranLoadInformation := generateRanLoadInformation()
471 data, err := proto.Marshal(ranLoadInformation)
474 t.Errorf("#rNibWriter_test.TestSaveRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
478 var setExpected []interface{}
479 setExpected = append(setExpected, loadKey, data)
480 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
482 rNibErr := w.SaveRanLoadInformation(inventoryName, ranLoadInformation)
483 assert.Nil(t, rNibErr)
486 func TestSaveRanLoadInformationMarshalNilFailure(t *testing.T) {
487 inventoryName := "name2"
488 w, _ := initSdlInstanceMock(namespace)
490 expectedErr := common.NewInternalError(errors.New("proto: Marshal called with nil"))
491 err := w.SaveRanLoadInformation(inventoryName, nil)
492 assert.Equal(t, expectedErr, err)
495 func TestSaveRanLoadInformationEmptyInventoryNameFailure(t *testing.T) {
497 w, _ := initSdlInstanceMock(namespace)
499 err := w.SaveRanLoadInformation(inventoryName, nil)
500 assert.NotNil(t, err)
501 assert.IsType(t, &common.ValidationError{}, err)
504 func TestSaveRanLoadInformationSdlFailure(t *testing.T) {
505 inventoryName := "name2"
507 loadKey, validationErr := common.ValidateAndBuildRanLoadInformationKey(inventoryName)
509 if validationErr != nil {
510 t.Errorf("#rNibWriter_test.TestSaveRanLoadInformationSuccess - Failed to build ran load infromation key. Error: %v", validationErr)
513 w, sdlInstanceMock := initSdlInstanceMock(namespace)
515 ranLoadInformation := generateRanLoadInformation()
516 data, err := proto.Marshal(ranLoadInformation)
519 t.Errorf("#rNibWriter_test.TestSaveRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
522 expectedErr := errors.New("expected error")
523 var setExpected []interface{}
524 setExpected = append(setExpected, loadKey, data)
525 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(expectedErr)
527 rNibErr := w.SaveRanLoadInformation(inventoryName, ranLoadInformation)
528 assert.NotNil(t, rNibErr)
529 assert.IsType(t, &common.InternalError{}, rNibErr)
532 func generateCellLoadInformation() *entities.CellLoadInformation {
533 cellLoadInformation := entities.CellLoadInformation{}
535 cellLoadInformation.CellId = "123"
537 ulInterferenceOverloadIndication := entities.UlInterferenceOverloadIndication_HIGH_INTERFERENCE
538 cellLoadInformation.UlInterferenceOverloadIndications = []entities.UlInterferenceOverloadIndication{ulInterferenceOverloadIndication}
540 ulHighInterferenceInformation := entities.UlHighInterferenceInformation{
542 UlHighInterferenceIndication: "xxx",
545 cellLoadInformation.UlHighInterferenceInfos = []*entities.UlHighInterferenceInformation{&ulHighInterferenceInformation}
547 cellLoadInformation.RelativeNarrowbandTxPower = &entities.RelativeNarrowbandTxPower{
549 RntpThreshold: entities.RntpThreshold_NEG_4,
550 NumberOfCellSpecificAntennaPorts: entities.NumberOfCellSpecificAntennaPorts_V1_ANT_PRT,
552 PdcchInterferenceImpact: 2,
553 EnhancedRntp: &entities.EnhancedRntp{
554 EnhancedRntpBitmap: "xxx",
555 RntpHighPowerThreshold: entities.RntpThreshold_NEG_2,
556 EnhancedRntpStartTime: &entities.StartTime{StartSfn: 500, StartSubframeNumber: 5},
560 cellLoadInformation.AbsInformation = &entities.AbsInformation{
561 Mode: entities.AbsInformationMode_ABS_INFO_FDD,
562 AbsPatternInfo: "xxx",
563 NumberOfCellSpecificAntennaPorts: entities.NumberOfCellSpecificAntennaPorts_V2_ANT_PRT,
564 MeasurementSubset: "xxx",
567 cellLoadInformation.InvokeIndication = entities.InvokeIndication_ABS_INFORMATION
569 cellLoadInformation.ExtendedUlInterferenceOverloadInfo = &entities.ExtendedUlInterferenceOverloadInfo{
570 AssociatedSubframes: "xxx",
571 ExtendedUlInterferenceOverloadIndications: cellLoadInformation.UlInterferenceOverloadIndications,
574 compInformationItem := &entities.CompInformationItem{
575 CompHypothesisSets: []*entities.CompHypothesisSet{{CellId: "789", CompHypothesis: "xxx"}},
579 cellLoadInformation.CompInformation = &entities.CompInformation{
580 CompInformationItems: []*entities.CompInformationItem{compInformationItem},
581 CompInformationStartTime: &entities.StartTime{StartSfn: 123, StartSubframeNumber: 456},
584 cellLoadInformation.DynamicDlTransmissionInformation = &entities.DynamicDlTransmissionInformation{
585 State: entities.NaicsState_NAICS_ACTIVE,
586 TransmissionModes: "xxx",
588 PAList: []entities.PA{entities.PA_DB_NEG_3},
591 return &cellLoadInformation
594 func generateRanLoadInformation() *entities.RanLoadInformation {
595 ranLoadInformation := entities.RanLoadInformation{}
597 ranLoadInformation.LoadTimestamp = uint64(time.Now().UnixNano())
599 cellLoadInformation := generateCellLoadInformation()
600 ranLoadInformation.CellLoadInfos = []*entities.CellLoadInformation{cellLoadInformation}
602 return &ranLoadInformation
605 func TestSaveNilEntityFailure(t *testing.T) {
606 w, _ := initSdlInstanceMock(namespace)
607 expectedErr := common.NewInternalError(errors.New("proto: Marshal called with nil"))
608 actualErr := w.SaveNodeb(nil)
609 assert.Equal(t, expectedErr, actualErr)
612 func TestSaveUnknownTypeEntityFailure(t *testing.T) {
613 w, _ := initSdlInstanceMock(namespace)
614 nb := &entities.NodebInfo{}
617 actualErr := w.SaveNodeb(nb)
618 assert.IsType(t, &common.ValidationError{}, actualErr)
621 func TestSaveEntityFailure(t *testing.T) {
626 w, sdlInstanceMock := initSdlInstanceMock(namespace)
627 gnb := entities.NodebInfo{}
628 gnb.NodeType = entities.Node_GNB
629 data, err := proto.Marshal(&gnb)
631 t.Errorf("#rNibWriter_test.TestSaveEntityFailure - Failed to marshal NodeB entity. Error: %v", err)
633 setExpected := []interface{}{"RAN:" + name, data}
634 setExpected = append(setExpected, "GNB:"+plmnId+":"+nbId, data)
635 expectedErr := errors.New("expected error")
636 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(expectedErr)
637 rNibErr := w.SaveNodeb(&gnb)
638 assert.NotEmpty(t, rNibErr)
641 func TestGetRNibWriter(t *testing.T) {
642 received, _ := initSdlInstanceMock(namespace)
643 assert.NotEmpty(t, received)
646 func TestSaveE2TInstanceSuccess(t *testing.T) {
647 address := "10.10.2.15:9800"
648 loadKey, validationErr := common.ValidateAndBuildE2TInstanceKey(address)
650 if validationErr != nil {
651 t.Errorf("#rNibWriter_test.TestSaveE2TInstanceSuccess - Failed to build E2T Instance key. Error: %v", validationErr)
654 w, sdlInstanceMock := initSdlInstanceMock(namespace)
656 e2tInstance := generateE2tInstance(address)
657 data, err := json.Marshal(e2tInstance)
660 t.Errorf("#rNibWriter_test.TestSaveE2TInstanceSuccess - Failed to marshal E2tInstance entity. Error: %v", err)
664 var setExpected []interface{}
665 setExpected = append(setExpected, loadKey, data)
666 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
668 rNibErr := w.SaveE2TInstance(e2tInstance)
669 assert.Nil(t, rNibErr)
672 func TestSaveE2TInstanceNullE2tInstanceFailure(t *testing.T) {
673 w, _ := initSdlInstanceMock(namespace)
675 e2tInstance := entities.NewE2TInstance(address, "test")
676 err := w.SaveE2TInstance(e2tInstance)
677 assert.NotNil(t, err)
678 assert.IsType(t, &common.ValidationError{}, err)
681 func TestSaveE2TInstanceSdlFailure(t *testing.T) {
682 address := "10.10.2.15:9800"
683 loadKey, validationErr := common.ValidateAndBuildE2TInstanceKey(address)
685 if validationErr != nil {
686 t.Errorf("#rNibWriter_test.TestSaveE2TInstanceSdlFailure - Failed to build E2T Instance key. Error: %v", validationErr)
689 w, sdlInstanceMock := initSdlInstanceMock(namespace)
691 e2tInstance := generateE2tInstance(address)
692 data, err := json.Marshal(e2tInstance)
695 t.Errorf("#rNibWriter_test.TestSaveE2TInstanceSdlFailure - Failed to marshal E2tInstance entity. Error: %v", err)
698 expectedErr := errors.New("expected error")
699 var setExpected []interface{}
700 setExpected = append(setExpected, loadKey, data)
701 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(expectedErr)
703 rNibErr := w.SaveE2TInstance(e2tInstance)
704 assert.NotNil(t, rNibErr)
705 assert.IsType(t, &common.InternalError{}, rNibErr)
708 func generateE2tInstance(address string) *entities.E2TInstance {
709 e2tInstance := entities.NewE2TInstance(address, "pod test")
711 e2tInstance.AssociatedRanList = []string{"test1", "test2"}
716 func TestSaveE2TAddressesSuccess(t *testing.T) {
717 address := "10.10.2.15:9800"
718 w, sdlInstanceMock := initSdlInstanceMock(namespace)
720 e2tAddresses := []string{address}
721 data, err := json.Marshal(e2tAddresses)
724 t.Errorf("#rNibWriter_test.TestSaveE2TInfoListSuccess - Failed to marshal E2TInfoList. Error: %v", err)
728 var setExpected []interface{}
729 setExpected = append(setExpected, E2TAddressesKey, data)
730 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
732 rNibErr := w.SaveE2TAddresses(e2tAddresses)
733 assert.Nil(t, rNibErr)
736 func TestSaveE2TAddressesSdlFailure(t *testing.T) {
737 address := "10.10.2.15:9800"
738 w, sdlInstanceMock := initSdlInstanceMock(namespace)
740 e2tAddresses := []string{address}
741 data, err := json.Marshal(e2tAddresses)
744 t.Errorf("#rNibWriter_test.TestSaveE2TInfoListSdlFailure - Failed to marshal E2TInfoList. Error: %v", err)
747 expectedErr := errors.New("expected error")
748 var setExpected []interface{}
749 setExpected = append(setExpected, E2TAddressesKey, data)
750 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(expectedErr)
752 rNibErr := w.SaveE2TAddresses(e2tAddresses)
753 assert.NotNil(t, rNibErr)
754 assert.IsType(t, &common.InternalError{}, rNibErr)
757 func TestRemoveE2TInstanceSuccess(t *testing.T) {
758 address := "10.10.2.15:9800"
759 w, sdlInstanceMock := initSdlInstanceMock(namespace)
761 e2tAddresses := []string{fmt.Sprintf("E2TInstance:%s", address)}
763 sdlInstanceMock.On("Remove", e2tAddresses).Return(e)
765 rNibErr := w.RemoveE2TInstance(address)
766 assert.Nil(t, rNibErr)
767 sdlInstanceMock.AssertExpectations(t)
770 func TestRemoveE2TInstanceSdlFailure(t *testing.T) {
771 address := "10.10.2.15:9800"
772 w, sdlInstanceMock := initSdlInstanceMock(namespace)
774 e2tAddresses := []string{fmt.Sprintf("E2TInstance:%s", address)}
775 expectedErr := errors.New("expected error")
776 sdlInstanceMock.On("Remove", e2tAddresses).Return(expectedErr)
778 rNibErr := w.RemoveE2TInstance(address)
779 assert.IsType(t, &common.InternalError{}, rNibErr)
782 func TestRemoveE2TInstanceEmptyAddressFailure(t *testing.T) {
783 w, sdlInstanceMock := initSdlInstanceMock(namespace)
785 rNibErr := w.RemoveE2TInstance("")
786 assert.IsType(t, &common.ValidationError{}, rNibErr)
787 sdlInstanceMock.AssertExpectations(t)
790 func TestUpdateNodebInfoOnConnectionStatusInversionSuccess(t *testing.T) {
791 inventoryName := "name"
794 channelName := "RAN_CONNECTION_STATUS_CHANGE"
795 eventName := inventoryName + "_" + "CONNECTED"
796 w, sdlInstanceMock := initSdlInstanceMock(namespace)
797 nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
798 data, err := proto.Marshal(nodebInfo)
800 t.Errorf("#rNibWriter_test.TestUpdateNodebInfoOnConnectionStatusInversionSuccess - Failed to marshal NodeB entity. Error: %v", err)
803 var setExpected []interface{}
805 nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
806 nodebIdKey := fmt.Sprintf("ENB:%s:%s", plmnId, nbId)
807 setExpected = append(setExpected, nodebNameKey, data)
808 setExpected = append(setExpected, nodebIdKey, data)
810 sdlInstanceMock.On("SetAndPublish", []string{channelName, eventName}, []interface{}{setExpected}).Return(e)
812 rNibErr := w.UpdateNodebInfoOnConnectionStatusInversion(nodebInfo, eventName)
813 assert.Nil(t, rNibErr)
816 func TestUpdateNodebInfoOnConnectionStatusInversionMissingInventoryNameFailure(t *testing.T) {
817 inventoryName := "name"
820 channelName := "RAN_CONNECTION_STATUS_CHANGE"
821 eventName := inventoryName + "_" + "CONNECTED"
822 w, sdlInstanceMock := initSdlInstanceMock(namespace)
823 nodebInfo := &entities.NodebInfo{}
824 data, err := proto.Marshal(nodebInfo)
826 t.Errorf("#rNibWriter_test.TestUpdateNodebInfoOnConnectionStatusInversionMissingInventoryNameFailure - Failed to marshal NodeB entity. Error: %v", err)
829 var setExpected []interface{}
831 nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
832 nodebIdKey := fmt.Sprintf("ENB:%s:%s", plmnId, nbId)
833 setExpected = append(setExpected, nodebNameKey, data)
834 setExpected = append(setExpected, nodebIdKey, data)
836 sdlInstanceMock.On("SetAndPublish", []string{channelName, eventName}, []interface{}{setExpected}).Return(e)
838 rNibErr := w.UpdateNodebInfoOnConnectionStatusInversion(nodebInfo, eventName)
840 assert.NotNil(t, rNibErr)
841 assert.IsType(t, &common.ValidationError{}, rNibErr)
844 func TestUpdateNodebInfoOnConnectionStatusInversionMissingGlobalNbId(t *testing.T) {
845 inventoryName := "name"
846 channelName := "RAN_CONNECTION_STATUS_CHANGE"
847 eventName := inventoryName + "_" + "CONNECTED"
848 w, sdlInstanceMock := initSdlInstanceMock(namespace)
849 nodebInfo := &entities.NodebInfo{}
850 nodebInfo.RanName = inventoryName
851 data, err := proto.Marshal(nodebInfo)
853 t.Errorf("#rNibWriter_test.TestUpdateNodebInfoOnConnectionStatusInversionMissingInventoryNameFailure - Failed to marshal NodeB entity. Error: %v", err)
856 var setExpected []interface{}
858 nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
859 setExpected = append(setExpected, nodebNameKey, data)
860 sdlInstanceMock.On("SetAndPublish", []string{channelName, eventName}, []interface{}{setExpected}).Return(e)
862 rNibErr := w.UpdateNodebInfoOnConnectionStatusInversion(nodebInfo, eventName)
864 assert.Nil(t, rNibErr)
867 func TestSaveGeneralConfiguration(t *testing.T) {
868 w, sdlInstanceMock := initSdlInstanceMock(namespace)
870 key := common.BuildGeneralConfigurationKey()
871 configurationData := "{\"enableRic\":true}"
872 configuration := &entities.GeneralConfiguration{}
873 configuration.EnableRic = true
875 sdlInstanceMock.On("Set", []interface{}{[]interface{}{key, []byte(configurationData)}}).Return(nil)
876 rNibErr := w.SaveGeneralConfiguration(configuration)
878 assert.Nil(t, rNibErr)
879 sdlInstanceMock.AssertExpectations(t)
882 func TestSaveGeneralConfigurationDbError(t *testing.T) {
883 w, sdlInstanceMock := initSdlInstanceMock(namespace)
885 key := common.BuildGeneralConfigurationKey()
886 configurationData := "{\"enableRic\":true}"
887 configuration := &entities.GeneralConfiguration{}
888 configuration.EnableRic = true
890 expectedErr := errors.New("expected error")
892 sdlInstanceMock.On("Set", []interface{}{[]interface{}{key, []byte(configurationData)}}).Return(expectedErr)
893 rNibErr := w.SaveGeneralConfiguration(configuration)
895 assert.NotNil(t, rNibErr)
898 func TestRemoveServedCellsFailure(t *testing.T) {
899 w, sdlInstanceMock := initSdlInstanceMock(namespace)
900 servedCellsToRemove := generateServedCells("whatever1", "whatever2")
901 expectedErr := errors.New("expected error")
902 sdlInstanceMock.On("Remove", buildServedCellInfoKeysToRemove(RanName, servedCellsToRemove)).Return(expectedErr)
904 rNibErr := w.RemoveServedCells(RanName, servedCellsToRemove)
906 assert.NotNil(t, rNibErr)
909 func TestRemoveServedCellsSuccess(t *testing.T) {
910 w, sdlInstanceMock := initSdlInstanceMock(namespace)
911 servedCellsToRemove := generateServedCells("whatever1", "whatever2")
912 sdlInstanceMock.On("Remove", buildServedCellInfoKeysToRemove(RanName, servedCellsToRemove)).Return(nil)
913 err := w.RemoveServedCells(RanName, servedCellsToRemove)
917 func TestUpdateEnbInvalidNodebInfoFailure(t *testing.T) {
918 w, sdlInstanceMock := initSdlInstanceMock(namespace)
919 servedCells := generateServedCells("test1", "test2")
920 nodebInfo := &entities.NodebInfo{}
921 sdlInstanceMock.AssertNotCalled(t, "SetAndPublish")
922 rNibErr := w.UpdateEnb(nodebInfo, servedCells)
923 assert.IsType(t, &common.ValidationError{}, rNibErr)
926 func TestUpdateEnbInvalidCellFailure(t *testing.T) {
927 inventoryName := "name"
930 w, sdlInstanceMock := initSdlInstanceMock(namespace)
931 servedCells := []*entities.ServedCellInfo{{CellId: ""}}
932 nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
933 nodebInfo.GetEnb().ServedCells = servedCells
934 sdlInstanceMock.AssertNotCalled(t, "SetAndPublish")
935 rNibErr := w.UpdateEnb(nodebInfo, servedCells)
936 assert.IsType(t, &common.ValidationError{}, rNibErr)
939 func TestUpdateEnbSdlFailure(t *testing.T) {
940 inventoryName := "name"
943 w, sdlInstanceMock := initSdlInstanceMock(namespace)
944 servedCells := generateServedCells("test1", "test2")
945 nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
946 nodebInfo.GetEnb().ServedCells = servedCells
947 setExpected := getUpdateEnbCellsSetExpected(t, nodebInfo, servedCells)
948 sdlInstanceMock.On("SetAndPublish", []string{"RAN_MANIPULATION", inventoryName + "_" + RanUpdatedEvent}, []interface{}{setExpected}).Return(errors.New("expected error"))
949 rNibErr := w.UpdateEnb(nodebInfo, servedCells)
950 assert.IsType(t, &common.InternalError{}, rNibErr)
953 func TestUpdateEnbSuccess(t *testing.T) {
954 inventoryName := "name"
957 w, sdlInstanceMock := initSdlInstanceMock(namespace)
958 servedCells := generateServedCells("test1", "test2")
959 nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
960 nodebInfo.GetEnb().ServedCells = servedCells
961 setExpected := getUpdateEnbCellsSetExpected(t, nodebInfo, servedCells)
964 sdlInstanceMock.On("SetAndPublish", []string{"RAN_MANIPULATION", inventoryName + "_" + RanUpdatedEvent}, []interface{}{setExpected}).Return(e)
965 rNibErr := w.UpdateEnb(nodebInfo, servedCells)
966 assert.Nil(t, rNibErr)
969 func getUpdateEnbSetExpected(t *testing.T, nodebInfo *entities.NodebInfo, servedCells []*entities.ServedCellInfo) []interface{} {
971 nodebInfoData, err := proto.Marshal(nodebInfo)
973 t.Fatalf("#rNibWriter_test.getUpdateEnbSetExpected - Failed to marshal NodeB entity. Error: %s", err)
976 nodebNameKey, _ := common.ValidateAndBuildNodeBNameKey(nodebInfo.RanName)
977 nodebIdKey, _ := common.ValidateAndBuildNodeBIdKey(nodebInfo.NodeType.String(), nodebInfo.GlobalNbId.PlmnId, nodebInfo.GlobalNbId.NbId)
978 setExpected := []interface{}{nodebNameKey, nodebInfoData, nodebIdKey, nodebInfoData}
980 for _, v := range servedCells {
982 cellEntity := entities.ServedCellInfo{CellId: "some cell id", EutraMode: entities.Eutra_FDD, CsgId: "some csg id"}
983 cellData, err := proto.Marshal(&cellEntity)
986 t.Fatalf("#rNibWriter_test.getUpdateEnbSetExpected - Failed to marshal cell entity. Error: %s", err)
989 nrCellIdKey, _ := common.ValidateAndBuildNrCellIdKey(v.GetCellId())
990 cellNamePciKey, _ := common.ValidateAndBuildCellNamePciKey(nodebInfo.RanName, v.GetPci())
991 setExpected = append(setExpected, nrCellIdKey, cellData, cellNamePciKey, cellData)
996 func TestRemoveEnbSuccess(t *testing.T) {
997 inventoryName := "name"
1000 channelName := "RAN_MANIPULATION"
1001 eventName := inventoryName + "_" + "DELETED"
1002 w, sdlInstanceMock := initSdlInstanceMock(namespace)
1003 nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
1004 nodebInfo.GetEnb().ServedCells = generateServedCellInfos("cell1", "cell2")
1008 expectedKeys := []string{}
1009 cell1Key := fmt.Sprintf("CELL:%s", nodebInfo.GetEnb().ServedCells[0].CellId)
1010 cell1PciKey := fmt.Sprintf("PCI:%s:%02x", inventoryName, nodebInfo.GetEnb().ServedCells[0].Pci)
1011 cell2Key := fmt.Sprintf("CELL:%s", nodebInfo.GetEnb().ServedCells[1].CellId)
1012 cell2PciKey := fmt.Sprintf("PCI:%s:%02x", inventoryName, nodebInfo.GetEnb().ServedCells[1].Pci)
1013 nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
1014 nodebIdKey := fmt.Sprintf("ENB:%s:%s", plmnId, nbId)
1015 expectedKeys = append(expectedKeys, cell1Key, cell1PciKey, cell2Key, cell2PciKey, nodebNameKey, nodebIdKey)
1016 sdlInstanceMock.On("RemoveAndPublish", []string{channelName, eventName}, expectedKeys).Return(e)
1018 rNibErr := w.RemoveEnb(nodebInfo)
1019 assert.Nil(t, rNibErr)
1020 sdlInstanceMock.AssertExpectations(t)
1023 func TestRemoveEnbRemoveAndPublishError(t *testing.T) {
1024 inventoryName := "name"
1027 channelName := "RAN_MANIPULATION"
1028 eventName := inventoryName + "_" + "DELETED"
1029 w, sdlInstanceMock := initSdlInstanceMock(namespace)
1030 nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
1031 nodebInfo.GetEnb().ServedCells = generateServedCellInfos("cell1", "cell2")
1033 expectedKeys := []string{}
1034 cell1Key := fmt.Sprintf("CELL:%s", nodebInfo.GetEnb().ServedCells[0].CellId)
1035 cell1PciKey := fmt.Sprintf("PCI:%s:%02x", inventoryName, nodebInfo.GetEnb().ServedCells[0].Pci)
1036 cell2Key := fmt.Sprintf("CELL:%s", nodebInfo.GetEnb().ServedCells[1].CellId)
1037 cell2PciKey := fmt.Sprintf("PCI:%s:%02x", inventoryName, nodebInfo.GetEnb().ServedCells[1].Pci)
1038 nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
1039 nodebIdKey := fmt.Sprintf("ENB:%s:%s", plmnId, nbId)
1040 expectedKeys = append(expectedKeys, cell1Key, cell1PciKey, cell2Key, cell2PciKey, nodebNameKey, nodebIdKey)
1041 sdlInstanceMock.On("RemoveAndPublish", []string{channelName, eventName}, expectedKeys).Return(errors.New("for test"))
1043 rNibErr := w.RemoveEnb(nodebInfo)
1044 assert.NotNil(t, rNibErr)
1045 sdlInstanceMock.AssertExpectations(t)
1048 func TestRemoveNbIdentitySuccess(t *testing.T) {
1049 w, sdlInstanceMock := initSdlInstanceMock(namespace)
1050 nbIdentity := &entities.NbIdentity{InventoryName: "ran1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
1051 nbIdData, err := proto.Marshal(nbIdentity)
1053 t.Errorf("#TestRemoveNbIdentitySuccess - failed to Marshal NbIdentity")
1056 sdlInstanceMock.On("RemoveMember", entities.Node_ENB.String(), []interface{}{nbIdData}).Return(nil)
1058 rNibErr := w.RemoveNbIdentity(entities.Node_ENB, nbIdentity)
1059 assert.Nil(t, rNibErr)
1060 sdlInstanceMock.AssertExpectations(t)
1063 func TestRemoveNbIdentityError(t *testing.T) {
1064 w, sdlInstanceMock := initSdlInstanceMock(namespace)
1065 nbIdentity := &entities.NbIdentity{InventoryName: "ran1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
1066 nbIdData, err := proto.Marshal(nbIdentity)
1068 t.Errorf("#TestRemoveNbIdentitySuccess - failed to Marshal NbIdentity")
1071 sdlInstanceMock.On("RemoveMember", entities.Node_ENB.String(), []interface{}{nbIdData}).Return(fmt.Errorf("for test"))
1073 rNibErr := w.RemoveNbIdentity(entities.Node_ENB, nbIdentity)
1074 assert.NotNil(t, rNibErr)
1075 sdlInstanceMock.AssertExpectations(t)
1080 //func TestSaveEnbGnbInteg(t *testing.T){
1081 // for i := 0; i<10; i++{
1082 // Init("e2Manager", 1)
1083 // w := GetRNibWriter()
1084 // nb := entities.NodebInfo{}
1085 // nb.NodeType = entities.Node_ENB
1086 // nb.ConnectionStatus = entities.ConnectionStatus_CONNECTED
1087 // nb.Ip = "localhost"
1088 // nb.Port = uint32(5656 + i)
1089 // enb := entities.Enb{}
1090 // cell1 := &entities.ServedCellInfo{CellId:fmt.Sprintf("%02x",111 + i), Pci:uint32(11 + i)}
1091 // cell2 := &entities.ServedCellInfo{CellId:fmt.Sprintf("%02x",222 + i), Pci:uint32(22 + i)}
1092 // cell3 := &entities.ServedCellInfo{CellId:fmt.Sprintf("%02x",333 + i), Pci:uint32(33 + i)}
1093 // enb.ServedCells = []*entities.ServedCellInfo{cell1, cell2, cell3}
1094 // nb.Configuration = &entities.NodebInfo_Enb{Enb:&enb}
1095 // plmnId := 0x02f828
1096 // nbId := 0x4a952a0a
1097 // nbIdentity := &entities.NbIdentity{InventoryName: fmt.Sprintf("nameEnb%d" ,i), GlobalNbId:&entities.GlobalNbId{RicId:fmt.Sprintf("%02x", plmnId + i), NbId:fmt.Sprintf("%02x", nbId + i)}}
1098 // err := w.SaveNodeb(nbIdentity, &nb)
1100 // t.Errorf("#rNibWriter_test.TestSaveEnbInteg - Failed to save NodeB entity. Error: %v", err)
1103 // nb1 := entities.NodebInfo{}
1104 // nb1.NodeType = entities.Node_GNB
1105 // nb1.ConnectionStatus = entities.ConnectionStatus_CONNECTED
1106 // nb1.Ip = "localhost"
1107 // nb1.Port = uint32(6565 + i)
1108 // gnb := entities.Gnb{}
1109 // gCell1 := &entities.ServedNRCell{ServedNrCellInformation:&entities.ServedNRCellInformation{CellId:fmt.Sprintf("%02x",1111 + i), NrPci:uint32(1 + i)}}
1110 // gCell2 := &entities.ServedNRCell{ServedNrCellInformation:&entities.ServedNRCellInformation{CellId:fmt.Sprintf("%02x",2222 + i), NrPci:uint32(2 + i)}}
1111 // gCell3 := &entities.ServedNRCell{ServedNrCellInformation:&entities.ServedNRCellInformation{CellId:fmt.Sprintf("%02x",3333 + i), NrPci:uint32(3 + i)}}
1112 // gnb.ServedNrCells = []*entities.ServedNRCell{gCell1, gCell2, gCell3,}
1113 // nb1.Configuration = &entities.NodebInfo_Gnb{Gnb:&gnb}
1114 // nbIdentity = &entities.NbIdentity{InventoryName: fmt.Sprintf("nameGnb%d" ,i), GlobalNbId:&entities.GlobalNbId{RicId:fmt.Sprintf("%02x", plmnId - i), NbId:fmt.Sprintf("%02x", nbId - i)}}
1115 // err = w.SaveNodeb(nbIdentity, &nb1)
1117 // t.Errorf("#rNibWriter_test.TestSaveEnbInteg - Failed to save NodeB entity. Error: %v", err)
1122 //func TestSaveNbRanNamesInteg(t *testing.T){
1123 // for i := 0; i<10; i++{
1124 // Init("e2Manager", 1)
1125 // w := GetRNibWriter()
1126 // nb := entities.NodebInfo{}
1127 // nb.ConnectionStatus = entities.ConnectionStatus_CONNECTING
1128 // nb.Ip = "localhost"
1129 // nb.Port = uint32(5656 + i)
1130 // nbIdentity := &entities.NbIdentity{InventoryName: fmt.Sprintf("nameOnly%d" ,i)}
1131 // err := w.SaveNodeb(nbIdentity, &nb)
1133 // t.Errorf("#rNibWriter_test.TestSaveEnbInteg - Failed to save NodeB entity. Error: %v", err)
1138 //func TestSaveRanLoadInformationInteg(t *testing.T){
1139 // Init("e2Manager", 1)
1140 // w := GetRNibWriter()
1141 // ranLoadInformation := generateRanLoadInformation()
1142 // err := w.SaveRanLoadInformation("ran_integ", ranLoadInformation)
1144 // t.Errorf("#rNibWriter_test.TestSaveRanLoadInformationInteg - Failed to save RanLoadInformation entity. Error: %v", err)