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) {
318 ranName := "RAN:" + name
319 w, sdlInstanceMock := initSdlInstanceMock(namespace)
320 nb := entities.NodebInfo{}
322 nb.NodeType = entities.Node_ENB
323 nb.ConnectionStatus = 1
326 enb := entities.Enb{}
327 cell := &entities.ServedCellInfo{CellId: "aaff", Pci: 3}
328 cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: cell}}
329 enb.ServedCells = []*entities.ServedCellInfo{cell}
330 nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
331 data, err := proto.Marshal(&nb)
333 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal NodeB entity. Error: %v", err)
337 cellData, err := proto.Marshal(&cellEntity)
339 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal Cell entity. Error: %v", err)
341 var setExpected []interface{}
342 setExpected = append(setExpected, ranName, data)
343 setExpected = append(setExpected, "ENB:02f829:4a952a0a", data)
344 setExpected = append(setExpected, fmt.Sprintf("CELL:%s", cell.GetCellId()), cellData)
345 setExpected = append(setExpected, fmt.Sprintf("PCI:%s:%02x", name, cell.GetPci()), cellData)
347 sdlInstanceMock.On("SetAndPublish", []string{"RAN_MANIPULATION", name + "_" + RanAddedEvent}, []interface{}{setExpected}).Return(e)
349 nbIdData, err := proto.Marshal(&entities.NbIdentity{InventoryName: name})
351 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal nbIdentity entity. Error: %v", err)
353 sdlInstanceMock.On("RemoveMember", entities.Node_UNKNOWN.String(), []interface{}{nbIdData}).Return(e)
355 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: "02f829", NbId: "4a952a0a"}}
356 nbIdData, err = proto.Marshal(nbIdentity)
358 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal NodeB Identity entity. Error: %v", err)
360 sdlInstanceMock.On("AddMember", "ENB", []interface{}{nbIdData}).Return(e)
362 rNibErr := w.SaveNodeb(nbIdentity, &nb)
363 assert.Nil(t, rNibErr)
366 func TestSaveEnbCellIdValidationFailure(t *testing.T) {
368 w, _ := initSdlInstanceMock(namespace)
369 nb := entities.NodebInfo{}
370 nb.NodeType = entities.Node_ENB
371 nb.ConnectionStatus = 1
374 enb := entities.Enb{}
375 cell := &entities.ServedCellInfo{Pci: 3}
376 enb.ServedCells = []*entities.ServedCellInfo{cell}
377 nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
379 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: "02f829", NbId: "4a952a0a"}}
380 rNibErr := w.SaveNodeb(nbIdentity, &nb)
381 assert.NotNil(t, rNibErr)
382 assert.IsType(t, &common.ValidationError{}, rNibErr)
383 assert.Equal(t, "#utils.ValidateAndBuildCellIdKey - an empty cell id received", rNibErr.Error())
386 func TestSaveEnbInventoryNameValidationFailure(t *testing.T) {
387 w, _ := initSdlInstanceMock(namespace)
388 nb := entities.NodebInfo{}
389 nb.NodeType = entities.Node_ENB
390 nb.ConnectionStatus = 1
393 enb := entities.Enb{}
394 cell := &entities.ServedCellInfo{CellId: "aaa", Pci: 3}
395 enb.ServedCells = []*entities.ServedCellInfo{cell}
396 nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
398 nbIdentity := &entities.NbIdentity{InventoryName: "", GlobalNbId: &entities.GlobalNbId{PlmnId: "02f829", NbId: "4a952a0a"}}
399 rNibErr := w.SaveNodeb(nbIdentity, &nb)
400 assert.NotNil(t, rNibErr)
401 assert.IsType(t, &common.ValidationError{}, rNibErr)
402 assert.Equal(t, "#utils.ValidateAndBuildNodeBNameKey - an empty inventory name received", rNibErr.Error())
405 func TestSaveGnbCellIdValidationFailure(t *testing.T) {
407 w, _ := initSdlInstanceMock(namespace)
408 nb := entities.NodebInfo{}
409 nb.NodeType = entities.Node_GNB
410 nb.ConnectionStatus = 1
413 gnb := entities.Gnb{}
414 cellInfo := &entities.ServedNRCellInformation{NrPci: 2}
415 cell := &entities.ServedNRCell{ServedNrCellInformation: cellInfo}
416 gnb.ServedNrCells = []*entities.ServedNRCell{cell}
417 nb.Configuration = &entities.NodebInfo_Gnb{Gnb: &gnb}
419 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: "02f829", NbId: "4a952a0a"}}
420 rNibErr := w.SaveNodeb(nbIdentity, &nb)
421 assert.NotNil(t, rNibErr)
422 assert.IsType(t, &common.ValidationError{}, rNibErr)
423 assert.Equal(t, "#utils.ValidateAndBuildNrCellIdKey - an empty cell id received", rNibErr.Error())
426 func TestSaveGnb(t *testing.T) {
428 ranName := "RAN:" + name
429 w, sdlInstanceMock := initSdlInstanceMock(namespace)
430 nb := entities.NodebInfo{}
431 nb.NodeType = entities.Node_GNB
432 nb.ConnectionStatus = 1
435 gnb := entities.Gnb{}
436 cellInfo := &entities.ServedNRCellInformation{NrPci: 2, CellId: "ccdd"}
437 cell := &entities.ServedNRCell{ServedNrCellInformation: cellInfo}
438 cellEntity := entities.Cell{Type: entities.Cell_NR_CELL, Cell: &entities.Cell_ServedNrCell{ServedNrCell: cell}}
439 gnb.ServedNrCells = []*entities.ServedNRCell{cell}
440 nb.Configuration = &entities.NodebInfo_Gnb{Gnb: &gnb}
441 data, err := proto.Marshal(&nb)
443 t.Errorf("#rNibWriter_test.TestSaveGnb - Failed to marshal NodeB entity. Error: %v", err)
447 cellData, err := proto.Marshal(&cellEntity)
449 t.Errorf("#rNibWriter_test.TestSaveGnb - Failed to marshal Cell entity. Error: %v", err)
451 var setExpected []interface{}
452 setExpected = append(setExpected, ranName, data)
453 setExpected = append(setExpected, "GNB:02f829:4a952a0a", data)
454 setExpected = append(setExpected, fmt.Sprintf("NRCELL:%s", cell.GetServedNrCellInformation().GetCellId()), cellData)
455 setExpected = append(setExpected, fmt.Sprintf("PCI:%s:%02x", name, cell.GetServedNrCellInformation().GetNrPci()), cellData)
457 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
458 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: "02f829", NbId: "4a952a0a"}}
459 nbIdData, err := proto.Marshal(nbIdentity)
461 t.Errorf("#rNibWriter_test.TestSaveGnb - Failed to marshal NodeB Identity entity. Error: %v", err)
463 sdlInstanceMock.On("AddMember", "GNB", []interface{}{nbIdData}).Return(e)
465 nbIdData, err = proto.Marshal(&entities.NbIdentity{InventoryName: name})
467 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal nbIdentity entity. Error: %v", err)
469 sdlInstanceMock.On("RemoveMember", entities.Node_UNKNOWN.String(), []interface{}{nbIdData}).Return(e)
471 rNibErr := w.SaveNodeb(nbIdentity, &nb)
472 assert.Nil(t, rNibErr)
475 func TestSaveRanLoadInformationSuccess(t *testing.T) {
476 inventoryName := "name"
477 loadKey, validationErr := common.ValidateAndBuildRanLoadInformationKey(inventoryName)
479 if validationErr != nil {
480 t.Errorf("#rNibWriter_test.TestSaveRanLoadInformationSuccess - Failed to build ran load infromation key. Error: %v", validationErr)
483 w, sdlInstanceMock := initSdlInstanceMock(namespace)
485 ranLoadInformation := generateRanLoadInformation()
486 data, err := proto.Marshal(ranLoadInformation)
489 t.Errorf("#rNibWriter_test.TestSaveRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
493 var setExpected []interface{}
494 setExpected = append(setExpected, loadKey, data)
495 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
497 rNibErr := w.SaveRanLoadInformation(inventoryName, ranLoadInformation)
498 assert.Nil(t, rNibErr)
501 func TestSaveRanLoadInformationMarshalNilFailure(t *testing.T) {
502 inventoryName := "name2"
503 w, _ := initSdlInstanceMock(namespace)
505 expectedErr := common.NewInternalError(errors.New("proto: Marshal called with nil"))
506 err := w.SaveRanLoadInformation(inventoryName, nil)
507 assert.Equal(t, expectedErr, err)
510 func TestSaveRanLoadInformationEmptyInventoryNameFailure(t *testing.T) {
512 w, _ := initSdlInstanceMock(namespace)
514 err := w.SaveRanLoadInformation(inventoryName, nil)
515 assert.NotNil(t, err)
516 assert.IsType(t, &common.ValidationError{}, err)
519 func TestSaveRanLoadInformationSdlFailure(t *testing.T) {
520 inventoryName := "name2"
522 loadKey, validationErr := common.ValidateAndBuildRanLoadInformationKey(inventoryName)
524 if validationErr != nil {
525 t.Errorf("#rNibWriter_test.TestSaveRanLoadInformationSuccess - Failed to build ran load infromation key. Error: %v", validationErr)
528 w, sdlInstanceMock := initSdlInstanceMock(namespace)
530 ranLoadInformation := generateRanLoadInformation()
531 data, err := proto.Marshal(ranLoadInformation)
534 t.Errorf("#rNibWriter_test.TestSaveRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
537 expectedErr := errors.New("expected error")
538 var setExpected []interface{}
539 setExpected = append(setExpected, loadKey, data)
540 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(expectedErr)
542 rNibErr := w.SaveRanLoadInformation(inventoryName, ranLoadInformation)
543 assert.NotNil(t, rNibErr)
544 assert.IsType(t, &common.InternalError{}, rNibErr)
547 func generateCellLoadInformation() *entities.CellLoadInformation {
548 cellLoadInformation := entities.CellLoadInformation{}
550 cellLoadInformation.CellId = "123"
552 ulInterferenceOverloadIndication := entities.UlInterferenceOverloadIndication_HIGH_INTERFERENCE
553 cellLoadInformation.UlInterferenceOverloadIndications = []entities.UlInterferenceOverloadIndication{ulInterferenceOverloadIndication}
555 ulHighInterferenceInformation := entities.UlHighInterferenceInformation{
557 UlHighInterferenceIndication: "xxx",
560 cellLoadInformation.UlHighInterferenceInfos = []*entities.UlHighInterferenceInformation{&ulHighInterferenceInformation}
562 cellLoadInformation.RelativeNarrowbandTxPower = &entities.RelativeNarrowbandTxPower{
564 RntpThreshold: entities.RntpThreshold_NEG_4,
565 NumberOfCellSpecificAntennaPorts: entities.NumberOfCellSpecificAntennaPorts_V1_ANT_PRT,
567 PdcchInterferenceImpact: 2,
568 EnhancedRntp: &entities.EnhancedRntp{
569 EnhancedRntpBitmap: "xxx",
570 RntpHighPowerThreshold: entities.RntpThreshold_NEG_2,
571 EnhancedRntpStartTime: &entities.StartTime{StartSfn: 500, StartSubframeNumber: 5},
575 cellLoadInformation.AbsInformation = &entities.AbsInformation{
576 Mode: entities.AbsInformationMode_ABS_INFO_FDD,
577 AbsPatternInfo: "xxx",
578 NumberOfCellSpecificAntennaPorts: entities.NumberOfCellSpecificAntennaPorts_V2_ANT_PRT,
579 MeasurementSubset: "xxx",
582 cellLoadInformation.InvokeIndication = entities.InvokeIndication_ABS_INFORMATION
584 cellLoadInformation.ExtendedUlInterferenceOverloadInfo = &entities.ExtendedUlInterferenceOverloadInfo{
585 AssociatedSubframes: "xxx",
586 ExtendedUlInterferenceOverloadIndications: cellLoadInformation.UlInterferenceOverloadIndications,
589 compInformationItem := &entities.CompInformationItem{
590 CompHypothesisSets: []*entities.CompHypothesisSet{{CellId: "789", CompHypothesis: "xxx"}},
594 cellLoadInformation.CompInformation = &entities.CompInformation{
595 CompInformationItems: []*entities.CompInformationItem{compInformationItem},
596 CompInformationStartTime: &entities.StartTime{StartSfn: 123, StartSubframeNumber: 456},
599 cellLoadInformation.DynamicDlTransmissionInformation = &entities.DynamicDlTransmissionInformation{
600 State: entities.NaicsState_NAICS_ACTIVE,
601 TransmissionModes: "xxx",
603 PAList: []entities.PA{entities.PA_DB_NEG_3},
606 return &cellLoadInformation
609 func generateRanLoadInformation() *entities.RanLoadInformation {
610 ranLoadInformation := entities.RanLoadInformation{}
612 ranLoadInformation.LoadTimestamp = uint64(time.Now().UnixNano())
614 cellLoadInformation := generateCellLoadInformation()
615 ranLoadInformation.CellLoadInfos = []*entities.CellLoadInformation{cellLoadInformation}
617 return &ranLoadInformation
620 func TestSaveNilEntityFailure(t *testing.T) {
621 w, _ := initSdlInstanceMock(namespace)
622 expectedErr := common.NewInternalError(errors.New("proto: Marshal called with nil"))
623 nbIdentity := &entities.NbIdentity{}
624 actualErr := w.SaveNodeb(nbIdentity, nil)
625 assert.Equal(t, expectedErr, actualErr)
628 func TestSaveUnknownTypeEntityFailure(t *testing.T) {
629 w, _ := initSdlInstanceMock(namespace)
630 nbIdentity := &entities.NbIdentity{InventoryName: "name", GlobalNbId: &entities.GlobalNbId{PlmnId: "02f829", NbId: "4a952a0a"}}
631 nb := &entities.NodebInfo{}
634 actualErr := w.SaveNodeb(nbIdentity, nb)
635 assert.IsType(t, &common.ValidationError{}, actualErr)
638 func TestSaveEntityFailure(t *testing.T) {
643 w, sdlInstanceMock := initSdlInstanceMock(namespace)
644 gnb := entities.NodebInfo{}
645 gnb.NodeType = entities.Node_GNB
646 data, err := proto.Marshal(&gnb)
648 t.Errorf("#rNibWriter_test.TestSaveEntityFailure - Failed to marshal NodeB entity. Error: %v", err)
650 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
651 setExpected := []interface{}{"RAN:" + name, data}
652 setExpected = append(setExpected, "GNB:"+plmnId+":"+nbId, data)
653 expectedErr := errors.New("expected error")
654 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(expectedErr)
655 rNibErr := w.SaveNodeb(nbIdentity, &gnb)
656 assert.NotEmpty(t, rNibErr)
659 func TestGetRNibWriter(t *testing.T) {
660 received, _ := initSdlInstanceMock(namespace)
661 assert.NotEmpty(t, received)
664 func TestSaveE2TInstanceSuccess(t *testing.T) {
665 address := "10.10.2.15:9800"
666 loadKey, validationErr := common.ValidateAndBuildE2TInstanceKey(address)
668 if validationErr != nil {
669 t.Errorf("#rNibWriter_test.TestSaveE2TInstanceSuccess - Failed to build E2T Instance key. Error: %v", validationErr)
672 w, sdlInstanceMock := initSdlInstanceMock(namespace)
674 e2tInstance := generateE2tInstance(address)
675 data, err := json.Marshal(e2tInstance)
678 t.Errorf("#rNibWriter_test.TestSaveE2TInstanceSuccess - Failed to marshal E2tInstance entity. Error: %v", err)
682 var setExpected []interface{}
683 setExpected = append(setExpected, loadKey, data)
684 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
686 rNibErr := w.SaveE2TInstance(e2tInstance)
687 assert.Nil(t, rNibErr)
690 func TestSaveE2TInstanceNullE2tInstanceFailure(t *testing.T) {
691 w, _ := initSdlInstanceMock(namespace)
693 e2tInstance := entities.NewE2TInstance(address, "test")
694 err := w.SaveE2TInstance(e2tInstance)
695 assert.NotNil(t, err)
696 assert.IsType(t, &common.ValidationError{}, err)
699 func TestSaveE2TInstanceSdlFailure(t *testing.T) {
700 address := "10.10.2.15:9800"
701 loadKey, validationErr := common.ValidateAndBuildE2TInstanceKey(address)
703 if validationErr != nil {
704 t.Errorf("#rNibWriter_test.TestSaveE2TInstanceSdlFailure - Failed to build E2T Instance key. Error: %v", validationErr)
707 w, sdlInstanceMock := initSdlInstanceMock(namespace)
709 e2tInstance := generateE2tInstance(address)
710 data, err := json.Marshal(e2tInstance)
713 t.Errorf("#rNibWriter_test.TestSaveE2TInstanceSdlFailure - Failed to marshal E2tInstance entity. Error: %v", err)
716 expectedErr := errors.New("expected error")
717 var setExpected []interface{}
718 setExpected = append(setExpected, loadKey, data)
719 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(expectedErr)
721 rNibErr := w.SaveE2TInstance(e2tInstance)
722 assert.NotNil(t, rNibErr)
723 assert.IsType(t, &common.InternalError{}, rNibErr)
726 func generateE2tInstance(address string) *entities.E2TInstance {
727 e2tInstance := entities.NewE2TInstance(address, "pod test")
729 e2tInstance.AssociatedRanList = []string{"test1", "test2"}
734 func TestSaveE2TAddressesSuccess(t *testing.T) {
735 address := "10.10.2.15:9800"
736 w, sdlInstanceMock := initSdlInstanceMock(namespace)
738 e2tAddresses := []string{address}
739 data, err := json.Marshal(e2tAddresses)
742 t.Errorf("#rNibWriter_test.TestSaveE2TInfoListSuccess - Failed to marshal E2TInfoList. Error: %v", err)
746 var setExpected []interface{}
747 setExpected = append(setExpected, E2TAddressesKey, data)
748 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
750 rNibErr := w.SaveE2TAddresses(e2tAddresses)
751 assert.Nil(t, rNibErr)
754 func TestSaveE2TAddressesSdlFailure(t *testing.T) {
755 address := "10.10.2.15:9800"
756 w, sdlInstanceMock := initSdlInstanceMock(namespace)
758 e2tAddresses := []string{address}
759 data, err := json.Marshal(e2tAddresses)
762 t.Errorf("#rNibWriter_test.TestSaveE2TInfoListSdlFailure - Failed to marshal E2TInfoList. Error: %v", err)
765 expectedErr := errors.New("expected error")
766 var setExpected []interface{}
767 setExpected = append(setExpected, E2TAddressesKey, data)
768 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(expectedErr)
770 rNibErr := w.SaveE2TAddresses(e2tAddresses)
771 assert.NotNil(t, rNibErr)
772 assert.IsType(t, &common.InternalError{}, rNibErr)
775 func TestRemoveE2TInstanceSuccess(t *testing.T) {
776 address := "10.10.2.15:9800"
777 w, sdlInstanceMock := initSdlInstanceMock(namespace)
779 e2tAddresses := []string{fmt.Sprintf("E2TInstance:%s", address)}
781 sdlInstanceMock.On("Remove", e2tAddresses).Return(e)
783 rNibErr := w.RemoveE2TInstance(address)
784 assert.Nil(t, rNibErr)
785 sdlInstanceMock.AssertExpectations(t)
788 func TestRemoveE2TInstanceSdlFailure(t *testing.T) {
789 address := "10.10.2.15:9800"
790 w, sdlInstanceMock := initSdlInstanceMock(namespace)
792 e2tAddresses := []string{fmt.Sprintf("E2TInstance:%s", address)}
793 expectedErr := errors.New("expected error")
794 sdlInstanceMock.On("Remove", e2tAddresses).Return(expectedErr)
796 rNibErr := w.RemoveE2TInstance(address)
797 assert.IsType(t, &common.InternalError{}, rNibErr)
800 func TestRemoveE2TInstanceEmptyAddressFailure(t *testing.T) {
801 w, sdlInstanceMock := initSdlInstanceMock(namespace)
803 rNibErr := w.RemoveE2TInstance("")
804 assert.IsType(t, &common.ValidationError{}, rNibErr)
805 sdlInstanceMock.AssertExpectations(t)
808 func TestUpdateNodebInfoOnConnectionStatusInversionSuccess(t *testing.T) {
809 inventoryName := "name"
812 channelName := "RAN_CONNECTION_STATUS_CHANGE"
813 eventName := inventoryName + "_" + "CONNECTED"
814 w, sdlInstanceMock := initSdlInstanceMock(namespace)
815 nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
816 data, err := proto.Marshal(nodebInfo)
818 t.Errorf("#rNibWriter_test.TestUpdateNodebInfoOnConnectionStatusInversionSuccess - Failed to marshal NodeB entity. Error: %v", err)
821 var setExpected []interface{}
823 nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
824 nodebIdKey := fmt.Sprintf("ENB:%s:%s", plmnId, nbId)
825 setExpected = append(setExpected, nodebNameKey, data)
826 setExpected = append(setExpected, nodebIdKey, data)
828 sdlInstanceMock.On("SetAndPublish", []string{channelName, eventName}, []interface{}{setExpected}).Return(e)
830 rNibErr := w.UpdateNodebInfoOnConnectionStatusInversion(nodebInfo, eventName)
831 assert.Nil(t, rNibErr)
834 func TestUpdateNodebInfoOnConnectionStatusInversionMissingInventoryNameFailure(t *testing.T) {
835 inventoryName := "name"
838 channelName := "RAN_CONNECTION_STATUS_CHANGE"
839 eventName := inventoryName + "_" + "CONNECTED"
840 w, sdlInstanceMock := initSdlInstanceMock(namespace)
841 nodebInfo := &entities.NodebInfo{}
842 data, err := proto.Marshal(nodebInfo)
844 t.Errorf("#rNibWriter_test.TestUpdateNodebInfoOnConnectionStatusInversionMissingInventoryNameFailure - Failed to marshal NodeB entity. Error: %v", err)
847 var setExpected []interface{}
849 nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
850 nodebIdKey := fmt.Sprintf("ENB:%s:%s", plmnId, nbId)
851 setExpected = append(setExpected, nodebNameKey, data)
852 setExpected = append(setExpected, nodebIdKey, data)
854 sdlInstanceMock.On("SetAndPublish", []string{channelName, eventName}, []interface{}{setExpected}).Return(e)
856 rNibErr := w.UpdateNodebInfoOnConnectionStatusInversion(nodebInfo, eventName)
858 assert.NotNil(t, rNibErr)
859 assert.IsType(t, &common.ValidationError{}, rNibErr)
862 func TestUpdateNodebInfoOnConnectionStatusInversionMissingGlobalNbId(t *testing.T) {
863 inventoryName := "name"
864 channelName := "RAN_CONNECTION_STATUS_CHANGE"
865 eventName := inventoryName + "_" + "CONNECTED"
866 w, sdlInstanceMock := initSdlInstanceMock(namespace)
867 nodebInfo := &entities.NodebInfo{}
868 nodebInfo.RanName = inventoryName
869 data, err := proto.Marshal(nodebInfo)
871 t.Errorf("#rNibWriter_test.TestUpdateNodebInfoOnConnectionStatusInversionMissingInventoryNameFailure - Failed to marshal NodeB entity. Error: %v", err)
874 var setExpected []interface{}
876 nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
877 setExpected = append(setExpected, nodebNameKey, data)
878 sdlInstanceMock.On("SetAndPublish", []string{channelName, eventName}, []interface{}{setExpected}).Return(e)
880 rNibErr := w.UpdateNodebInfoOnConnectionStatusInversion(nodebInfo, eventName)
882 assert.Nil(t, rNibErr)
885 func TestSaveGeneralConfiguration(t *testing.T) {
886 w, sdlInstanceMock := initSdlInstanceMock(namespace)
888 key := common.BuildGeneralConfigurationKey()
889 configurationData := "{\"enableRic\":true}"
890 configuration := &entities.GeneralConfiguration{}
891 configuration.EnableRic = true
893 sdlInstanceMock.On("Set", []interface{}{[]interface{}{key, []byte(configurationData)}}).Return(nil)
894 rNibErr := w.SaveGeneralConfiguration(configuration)
896 assert.Nil(t, rNibErr)
897 sdlInstanceMock.AssertExpectations(t)
900 func TestSaveGeneralConfigurationDbError(t *testing.T) {
901 w, sdlInstanceMock := initSdlInstanceMock(namespace)
903 key := common.BuildGeneralConfigurationKey()
904 configurationData := "{\"enableRic\":true}"
905 configuration := &entities.GeneralConfiguration{}
906 configuration.EnableRic = true
908 expectedErr := errors.New("expected error")
910 sdlInstanceMock.On("Set", []interface{}{[]interface{}{key, []byte(configurationData)}}).Return(expectedErr)
911 rNibErr := w.SaveGeneralConfiguration(configuration)
913 assert.NotNil(t, rNibErr)
916 func TestRemoveServedCellsFailure(t *testing.T) {
917 w, sdlInstanceMock := initSdlInstanceMock(namespace)
918 servedCellsToRemove := generateServedCells("whatever1", "whatever2")
919 expectedErr := errors.New("expected error")
920 sdlInstanceMock.On("Remove", buildServedCellInfoKeysToRemove(RanName, servedCellsToRemove)).Return(expectedErr)
922 rNibErr := w.RemoveServedCells(RanName, servedCellsToRemove)
924 assert.NotNil(t, rNibErr)
927 func TestRemoveServedCellsSuccess(t *testing.T) {
928 w, sdlInstanceMock := initSdlInstanceMock(namespace)
929 servedCellsToRemove := generateServedCells("whatever1", "whatever2")
930 sdlInstanceMock.On("Remove", buildServedCellInfoKeysToRemove(RanName, servedCellsToRemove)).Return(nil)
931 err := w.RemoveServedCells(RanName, servedCellsToRemove)
935 func TestUpdateEnbInvalidNodebInfoFailure(t *testing.T) {
936 w, sdlInstanceMock := initSdlInstanceMock(namespace)
937 servedCells := generateServedCells("test1", "test2")
938 nodebInfo := &entities.NodebInfo{}
939 sdlInstanceMock.AssertNotCalled(t, "SetAndPublish")
940 rNibErr := w.UpdateEnb(nodebInfo, servedCells)
941 assert.IsType(t, &common.ValidationError{}, rNibErr)
944 func TestUpdateEnbInvalidCellFailure(t *testing.T) {
945 inventoryName := "name"
948 w, sdlInstanceMock := initSdlInstanceMock(namespace)
949 servedCells := []*entities.ServedCellInfo{{CellId: ""}}
950 nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
951 nodebInfo.GetEnb().ServedCells = servedCells
952 sdlInstanceMock.AssertNotCalled(t, "SetAndPublish")
953 rNibErr := w.UpdateEnb(nodebInfo, servedCells)
954 assert.IsType(t, &common.ValidationError{}, rNibErr)
957 func TestUpdateEnbSdlFailure(t *testing.T) {
958 inventoryName := "name"
961 w, sdlInstanceMock := initSdlInstanceMock(namespace)
962 servedCells := generateServedCells("test1", "test2")
963 nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
964 nodebInfo.GetEnb().ServedCells = servedCells
965 setExpected := getUpdateEnbCellsSetExpected(t, nodebInfo, servedCells)
966 sdlInstanceMock.On("SetAndPublish", []string{"RAN_MANIPULATION", inventoryName + "_" + RanUpdatedEvent}, []interface{}{setExpected}).Return(errors.New("expected error"))
967 rNibErr := w.UpdateEnb(nodebInfo, servedCells)
968 assert.IsType(t, &common.InternalError{}, rNibErr)
971 func TestUpdateEnbSuccess(t *testing.T) {
972 inventoryName := "name"
975 w, sdlInstanceMock := initSdlInstanceMock(namespace)
976 servedCells := generateServedCells("test1", "test2")
977 nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
978 nodebInfo.GetEnb().ServedCells = servedCells
979 setExpected := getUpdateEnbCellsSetExpected(t, nodebInfo, servedCells)
982 sdlInstanceMock.On("SetAndPublish", []string{"RAN_MANIPULATION", inventoryName + "_" + RanUpdatedEvent}, []interface{}{setExpected}).Return(e)
983 rNibErr := w.UpdateEnb(nodebInfo, servedCells)
984 assert.Nil(t, rNibErr)
987 func getUpdateEnbSetExpected(t *testing.T, nodebInfo *entities.NodebInfo, servedCells []*entities.ServedCellInfo) []interface{} {
989 nodebInfoData, err := proto.Marshal(nodebInfo)
991 t.Fatalf("#rNibWriter_test.getUpdateEnbSetExpected - Failed to marshal NodeB entity. Error: %s", err)
994 nodebNameKey, _ := common.ValidateAndBuildNodeBNameKey(nodebInfo.RanName)
995 nodebIdKey, _ := common.ValidateAndBuildNodeBIdKey(nodebInfo.NodeType.String(), nodebInfo.GlobalNbId.PlmnId, nodebInfo.GlobalNbId.NbId)
996 setExpected := []interface{}{nodebNameKey, nodebInfoData, nodebIdKey, nodebInfoData}
998 for _, v := range servedCells {
1000 cellEntity := entities.ServedCellInfo{CellId: "some cell id", EutraMode: entities.Eutra_FDD, CsgId: "some csg id"}
1001 cellData, err := proto.Marshal(&cellEntity)
1004 t.Fatalf("#rNibWriter_test.getUpdateEnbSetExpected - Failed to marshal cell entity. Error: %s", err)
1007 nrCellIdKey, _ := common.ValidateAndBuildNrCellIdKey(v.GetCellId())
1008 cellNamePciKey, _ := common.ValidateAndBuildCellNamePciKey(nodebInfo.RanName, v.GetPci())
1009 setExpected = append(setExpected, nrCellIdKey, cellData, cellNamePciKey, cellData)
1014 func TestRemoveEnbSuccess(t *testing.T) {
1015 inventoryName := "name"
1018 channelName := "RAN_MANIPULATION"
1019 eventName := inventoryName + "_" + "DELETED"
1020 w, sdlInstanceMock := initSdlInstanceMock(namespace)
1021 nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
1022 nodebInfo.GetEnb().ServedCells = generateServedCellInfos("cell1", "cell2")
1026 nbIdentity := &entities.NbIdentity{InventoryName: nodebInfo.RanName, GlobalNbId: nodebInfo.GetGlobalNbId()}
1027 nbIdData, err := proto.Marshal(nbIdentity)
1029 t.Errorf("#rNibWriter_test.TestRemoveEnbSuccess - Failed to marshal NbIdentity entity. Error: %v", err)
1031 sdlInstanceMock.On("RemoveMember", entities.Node_ENB.String(), []interface{}{nbIdData}).Return(e)
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(e)
1043 rNibErr := w.RemoveEnb(nodebInfo)
1044 assert.Nil(t, rNibErr)
1045 sdlInstanceMock.AssertExpectations(t)
1048 func TestRemoveEnbRemoveNbIdentityError(t *testing.T) {
1049 inventoryName := "name"
1052 w, sdlInstanceMock := initSdlInstanceMock(namespace)
1053 nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
1054 nodebInfo.GetEnb().ServedCells = generateServedCellInfos("cell1", "cell2")
1056 nbIdentity := &entities.NbIdentity{InventoryName: nodebInfo.RanName, GlobalNbId: nodebInfo.GetGlobalNbId()}
1057 nbIdData, err := proto.Marshal(nbIdentity)
1059 t.Errorf("#rNibWriter_test.TestRemoveEnbSuccess - Failed to marshal NbIdentity entity. Error: %v", err)
1061 sdlInstanceMock.On("RemoveMember", entities.Node_ENB.String(), []interface{}{nbIdData}).Return(errors.New("for test"))
1063 rNibErr := w.RemoveEnb(nodebInfo)
1064 assert.NotNil(t, rNibErr)
1065 sdlInstanceMock.AssertExpectations(t)
1068 func TestRemoveEnbRemoveAndPublishError(t *testing.T) {
1069 inventoryName := "name"
1072 channelName := "RAN_MANIPULATION"
1073 eventName := inventoryName + "_" + "DELETED"
1074 w, sdlInstanceMock := initSdlInstanceMock(namespace)
1075 nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
1076 nodebInfo.GetEnb().ServedCells = generateServedCellInfos("cell1", "cell2")
1080 nbIdentity := &entities.NbIdentity{InventoryName: nodebInfo.RanName, GlobalNbId: nodebInfo.GetGlobalNbId()}
1081 nbIdData, err := proto.Marshal(nbIdentity)
1083 t.Errorf("#rNibWriter_test.TestRemoveEnbSuccess - Failed to marshal NbIdentity entity. Error: %v", err)
1085 sdlInstanceMock.On("RemoveMember", entities.Node_ENB.String(), []interface{}{nbIdData}).Return(e)
1087 expectedKeys := []string{}
1088 cell1Key := fmt.Sprintf("CELL:%s", nodebInfo.GetEnb().ServedCells[0].CellId)
1089 cell1PciKey := fmt.Sprintf("PCI:%s:%02x", inventoryName, nodebInfo.GetEnb().ServedCells[0].Pci)
1090 cell2Key := fmt.Sprintf("CELL:%s", nodebInfo.GetEnb().ServedCells[1].CellId)
1091 cell2PciKey := fmt.Sprintf("PCI:%s:%02x", inventoryName, nodebInfo.GetEnb().ServedCells[1].Pci)
1092 nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
1093 nodebIdKey := fmt.Sprintf("ENB:%s:%s", plmnId, nbId)
1094 expectedKeys = append(expectedKeys, cell1Key, cell1PciKey, cell2Key, cell2PciKey, nodebNameKey, nodebIdKey)
1095 sdlInstanceMock.On("RemoveAndPublish", []string{channelName, eventName}, expectedKeys).Return(errors.New("for test"))
1097 rNibErr := w.RemoveEnb(nodebInfo)
1098 assert.NotNil(t, rNibErr)
1099 sdlInstanceMock.AssertExpectations(t)
1104 //func TestSaveEnbGnbInteg(t *testing.T){
1105 // for i := 0; i<10; i++{
1106 // Init("e2Manager", 1)
1107 // w := GetRNibWriter()
1108 // nb := entities.NodebInfo{}
1109 // nb.NodeType = entities.Node_ENB
1110 // nb.ConnectionStatus = entities.ConnectionStatus_CONNECTED
1111 // nb.Ip = "localhost"
1112 // nb.Port = uint32(5656 + i)
1113 // enb := entities.Enb{}
1114 // cell1 := &entities.ServedCellInfo{CellId:fmt.Sprintf("%02x",111 + i), Pci:uint32(11 + i)}
1115 // cell2 := &entities.ServedCellInfo{CellId:fmt.Sprintf("%02x",222 + i), Pci:uint32(22 + i)}
1116 // cell3 := &entities.ServedCellInfo{CellId:fmt.Sprintf("%02x",333 + i), Pci:uint32(33 + i)}
1117 // enb.ServedCells = []*entities.ServedCellInfo{cell1, cell2, cell3}
1118 // nb.Configuration = &entities.NodebInfo_Enb{Enb:&enb}
1119 // plmnId := 0x02f828
1120 // nbId := 0x4a952a0a
1121 // nbIdentity := &entities.NbIdentity{InventoryName: fmt.Sprintf("nameEnb%d" ,i), GlobalNbId:&entities.GlobalNbId{RicId:fmt.Sprintf("%02x", plmnId + i), NbId:fmt.Sprintf("%02x", nbId + i)}}
1122 // err := w.SaveNodeb(nbIdentity, &nb)
1124 // t.Errorf("#rNibWriter_test.TestSaveEnbInteg - Failed to save NodeB entity. Error: %v", err)
1127 // nb1 := entities.NodebInfo{}
1128 // nb1.NodeType = entities.Node_GNB
1129 // nb1.ConnectionStatus = entities.ConnectionStatus_CONNECTED
1130 // nb1.Ip = "localhost"
1131 // nb1.Port = uint32(6565 + i)
1132 // gnb := entities.Gnb{}
1133 // gCell1 := &entities.ServedNRCell{ServedNrCellInformation:&entities.ServedNRCellInformation{CellId:fmt.Sprintf("%02x",1111 + i), NrPci:uint32(1 + i)}}
1134 // gCell2 := &entities.ServedNRCell{ServedNrCellInformation:&entities.ServedNRCellInformation{CellId:fmt.Sprintf("%02x",2222 + i), NrPci:uint32(2 + i)}}
1135 // gCell3 := &entities.ServedNRCell{ServedNrCellInformation:&entities.ServedNRCellInformation{CellId:fmt.Sprintf("%02x",3333 + i), NrPci:uint32(3 + i)}}
1136 // gnb.ServedNrCells = []*entities.ServedNRCell{gCell1, gCell2, gCell3,}
1137 // nb1.Configuration = &entities.NodebInfo_Gnb{Gnb:&gnb}
1138 // nbIdentity = &entities.NbIdentity{InventoryName: fmt.Sprintf("nameGnb%d" ,i), GlobalNbId:&entities.GlobalNbId{RicId:fmt.Sprintf("%02x", plmnId - i), NbId:fmt.Sprintf("%02x", nbId - i)}}
1139 // err = w.SaveNodeb(nbIdentity, &nb1)
1141 // t.Errorf("#rNibWriter_test.TestSaveEnbInteg - Failed to save NodeB entity. Error: %v", err)
1146 //func TestSaveNbRanNamesInteg(t *testing.T){
1147 // for i := 0; i<10; i++{
1148 // Init("e2Manager", 1)
1149 // w := GetRNibWriter()
1150 // nb := entities.NodebInfo{}
1151 // nb.ConnectionStatus = entities.ConnectionStatus_CONNECTING
1152 // nb.Ip = "localhost"
1153 // nb.Port = uint32(5656 + i)
1154 // nbIdentity := &entities.NbIdentity{InventoryName: fmt.Sprintf("nameOnly%d" ,i)}
1155 // err := w.SaveNodeb(nbIdentity, &nb)
1157 // t.Errorf("#rNibWriter_test.TestSaveEnbInteg - Failed to save NodeB entity. Error: %v", err)
1162 //func TestSaveRanLoadInformationInteg(t *testing.T){
1163 // Init("e2Manager", 1)
1164 // w := GetRNibWriter()
1165 // ranLoadInformation := generateRanLoadInformation()
1166 // err := w.SaveRanLoadInformation("ran_integ", ranLoadInformation)
1168 // t.Errorf("#rNibWriter_test.TestSaveRanLoadInformationInteg - Failed to save RanLoadInformation entity. Error: %v", err)