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.
24 "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
25 "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
26 "github.com/golang/protobuf/proto"
27 "github.com/stretchr/testify/assert"
32 func initSdlInstanceMock(namespace string) (w RNibWriter, sdlInstanceMock *mocks.MockSdlInstance) {
33 sdlInstanceMock = new(mocks.MockSdlInstance)
34 w = GetRNibWriter(sdlInstanceMock)
38 var namespace = "namespace"
40 func TestUpdateNodebInfoSuccess(t *testing.T) {
41 inventoryName := "name"
44 w, sdlInstanceMock := initSdlInstanceMock(namespace)
45 nodebInfo := &entities.NodebInfo{}
46 nodebInfo.RanName = inventoryName
47 nodebInfo.GlobalNbId = &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
48 nodebInfo.NodeType = entities.Node_ENB
49 nodebInfo.ConnectionStatus = 1
51 nodebInfo.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
52 data, err := proto.Marshal(nodebInfo)
54 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal NodeB entity. Error: %v", err)
57 var setExpected []interface{}
59 nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
60 nodebIdKey := fmt.Sprintf("ENB:%s:%s", plmnId, nbId)
61 setExpected = append(setExpected, nodebNameKey, data)
62 setExpected = append(setExpected, nodebIdKey, data)
64 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
66 rNibErr := w.UpdateNodebInfo(nodebInfo)
67 assert.Nil(t, rNibErr)
70 func TestUpdateNodebInfoMissingInventoryNameFailure(t *testing.T) {
71 inventoryName := "name"
74 w, sdlInstanceMock := initSdlInstanceMock(namespace)
75 nodebInfo := &entities.NodebInfo{}
76 data, err := proto.Marshal(nodebInfo)
78 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal NodeB entity. Error: %v", err)
81 var setExpected []interface{}
83 nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
84 nodebIdKey := fmt.Sprintf("ENB:%s:%s", plmnId, nbId)
85 setExpected = append(setExpected, nodebNameKey, data)
86 setExpected = append(setExpected, nodebIdKey, data)
88 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
90 rNibErr := w.UpdateNodebInfo(nodebInfo)
92 assert.NotNil(t, rNibErr)
93 assert.IsType(t, &common.ValidationError{}, rNibErr)
96 func TestUpdateNodebInfoMissingGlobalNbId(t *testing.T) {
97 inventoryName := "name"
98 w, sdlInstanceMock := initSdlInstanceMock(namespace)
99 nodebInfo := &entities.NodebInfo{}
100 nodebInfo.RanName = inventoryName
101 data, err := proto.Marshal(nodebInfo)
103 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal NodeB entity. Error: %v", err)
106 var setExpected []interface{}
108 nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
109 setExpected = append(setExpected, nodebNameKey, data)
110 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
112 rNibErr := w.UpdateNodebInfo(nodebInfo)
114 assert.Nil(t, rNibErr)
117 func TestSaveEnb(t *testing.T) {
119 ranName := "RAN:" + name
120 w, sdlInstanceMock := initSdlInstanceMock(namespace)
121 nb := entities.NodebInfo{}
122 nb.NodeType = entities.Node_ENB
123 nb.ConnectionStatus = 1
126 enb := entities.Enb{}
127 cell := &entities.ServedCellInfo{CellId: "aaff", Pci: 3}
128 cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: cell}}
129 enb.ServedCells = []*entities.ServedCellInfo{cell}
130 nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
131 data, err := proto.Marshal(&nb)
133 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal NodeB entity. Error: %v", err)
137 cellData, err := proto.Marshal(&cellEntity)
139 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal Cell entity. Error: %v", err)
141 var setExpected []interface{}
142 setExpected = append(setExpected, ranName, data)
143 setExpected = append(setExpected, "ENB:02f829:4a952a0a", data)
144 setExpected = append(setExpected, fmt.Sprintf("CELL:%s", cell.GetCellId()), cellData)
145 setExpected = append(setExpected, fmt.Sprintf("PCI:%s:%02x", name, cell.GetPci()), cellData)
147 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
149 nbIdData, err := proto.Marshal(&entities.NbIdentity{InventoryName: name})
151 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal nbIdentity entity. Error: %v", err)
153 sdlInstanceMock.On("RemoveMember", entities.Node_UNKNOWN.String(), []interface{}{nbIdData}).Return(e)
155 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: "02f829", NbId: "4a952a0a"}}
156 nbIdData, err = proto.Marshal(nbIdentity)
158 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal NodeB Identity entity. Error: %v", err)
160 sdlInstanceMock.On("AddMember", "ENB", []interface{}{nbIdData}).Return(e)
162 rNibErr := w.SaveNodeb(nbIdentity, &nb)
163 assert.Nil(t, rNibErr)
166 func TestSaveEnbCellIdValidationFailure(t *testing.T) {
168 w, _ := initSdlInstanceMock(namespace)
169 nb := entities.NodebInfo{}
170 nb.NodeType = entities.Node_ENB
171 nb.ConnectionStatus = 1
174 enb := entities.Enb{}
175 cell := &entities.ServedCellInfo{Pci: 3}
176 enb.ServedCells = []*entities.ServedCellInfo{cell}
177 nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
179 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: "02f829", NbId: "4a952a0a"}}
180 rNibErr := w.SaveNodeb(nbIdentity, &nb)
181 assert.NotNil(t, rNibErr)
182 assert.IsType(t, &common.ValidationError{}, rNibErr)
183 assert.Equal(t, "#utils.ValidateAndBuildCellIdKey - an empty cell id received", rNibErr.Error())
186 func TestSaveEnbInventoryNameValidationFailure(t *testing.T) {
187 w, _ := initSdlInstanceMock(namespace)
188 nb := entities.NodebInfo{}
189 nb.NodeType = entities.Node_ENB
190 nb.ConnectionStatus = 1
193 enb := entities.Enb{}
194 cell := &entities.ServedCellInfo{CellId: "aaa", Pci: 3}
195 enb.ServedCells = []*entities.ServedCellInfo{cell}
196 nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
198 nbIdentity := &entities.NbIdentity{InventoryName: "", GlobalNbId: &entities.GlobalNbId{PlmnId: "02f829", NbId: "4a952a0a"}}
199 rNibErr := w.SaveNodeb(nbIdentity, &nb)
200 assert.NotNil(t, rNibErr)
201 assert.IsType(t, &common.ValidationError{}, rNibErr)
202 assert.Equal(t, "#utils.ValidateAndBuildNodeBNameKey - an empty inventory name received", rNibErr.Error())
205 func TestSaveGnbCellIdValidationFailure(t *testing.T) {
207 w, _ := initSdlInstanceMock(namespace)
208 nb := entities.NodebInfo{}
209 nb.NodeType = entities.Node_GNB
210 nb.ConnectionStatus = 1
213 gnb := entities.Gnb{}
214 cellInfo := &entities.ServedNRCellInformation{NrPci: 2}
215 cell := &entities.ServedNRCell{ServedNrCellInformation: cellInfo}
216 gnb.ServedNrCells = []*entities.ServedNRCell{cell}
217 nb.Configuration = &entities.NodebInfo_Gnb{Gnb: &gnb}
219 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: "02f829", NbId: "4a952a0a"}}
220 rNibErr := w.SaveNodeb(nbIdentity, &nb)
221 assert.NotNil(t, rNibErr)
222 assert.IsType(t, &common.ValidationError{}, rNibErr)
223 assert.Equal(t, "#utils.ValidateAndBuildNrCellIdKey - an empty cell id received", rNibErr.Error())
226 func TestSaveGnb(t *testing.T) {
228 ranName := "RAN:" + name
229 w, sdlInstanceMock := initSdlInstanceMock(namespace)
230 nb := entities.NodebInfo{}
231 nb.NodeType = entities.Node_GNB
232 nb.ConnectionStatus = 1
235 gnb := entities.Gnb{}
236 cellInfo := &entities.ServedNRCellInformation{NrPci: 2, CellId: "ccdd"}
237 cell := &entities.ServedNRCell{ServedNrCellInformation: cellInfo}
238 cellEntity := entities.Cell{Type: entities.Cell_NR_CELL, Cell: &entities.Cell_ServedNrCell{ServedNrCell: cell}}
239 gnb.ServedNrCells = []*entities.ServedNRCell{cell}
240 nb.Configuration = &entities.NodebInfo_Gnb{Gnb: &gnb}
241 data, err := proto.Marshal(&nb)
243 t.Errorf("#rNibWriter_test.TestSaveGnb - Failed to marshal NodeB entity. Error: %v", err)
247 cellData, err := proto.Marshal(&cellEntity)
249 t.Errorf("#rNibWriter_test.TestSaveGnb - Failed to marshal Cell entity. Error: %v", err)
251 var setExpected []interface{}
252 setExpected = append(setExpected, ranName, data)
253 setExpected = append(setExpected, "GNB:02f829:4a952a0a", data)
254 setExpected = append(setExpected, fmt.Sprintf("NRCELL:%s", cell.GetServedNrCellInformation().GetCellId()), cellData)
255 setExpected = append(setExpected, fmt.Sprintf("PCI:%s:%02x", name, cell.GetServedNrCellInformation().GetNrPci()), cellData)
257 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
258 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: "02f829", NbId: "4a952a0a"}}
259 nbIdData, err := proto.Marshal(nbIdentity)
261 t.Errorf("#rNibWriter_test.TestSaveGnb - Failed to marshal NodeB Identity entity. Error: %v", err)
263 sdlInstanceMock.On("AddMember", "GNB", []interface{}{nbIdData}).Return(e)
265 nbIdData, err = proto.Marshal(&entities.NbIdentity{InventoryName: name})
267 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal nbIdentity entity. Error: %v", err)
269 sdlInstanceMock.On("RemoveMember", entities.Node_UNKNOWN.String(), []interface{}{nbIdData}).Return(e)
271 rNibErr := w.SaveNodeb(nbIdentity, &nb)
272 assert.Nil(t, rNibErr)
275 func TestSaveRanLoadInformationSuccess(t *testing.T) {
276 inventoryName := "name"
277 loadKey, validationErr := common.ValidateAndBuildRanLoadInformationKey(inventoryName)
279 if validationErr != nil {
280 t.Errorf("#rNibWriter_test.TestSaveRanLoadInformationSuccess - Failed to build ran load infromation key. Error: %v", validationErr)
283 w, sdlInstanceMock := initSdlInstanceMock(namespace)
285 ranLoadInformation := generateRanLoadInformation()
286 data, err := proto.Marshal(ranLoadInformation)
289 t.Errorf("#rNibWriter_test.TestSaveRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
293 var setExpected []interface{}
294 setExpected = append(setExpected, loadKey, data)
295 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
297 rNibErr := w.SaveRanLoadInformation(inventoryName, ranLoadInformation)
298 assert.Nil(t, rNibErr)
301 func TestSaveRanLoadInformationMarshalNilFailure(t *testing.T) {
302 inventoryName := "name2"
303 w, _ := initSdlInstanceMock(namespace)
305 expectedErr := common.NewInternalError(errors.New("proto: Marshal called with nil"))
306 err := w.SaveRanLoadInformation(inventoryName, nil)
307 assert.Equal(t, expectedErr, err)
310 func TestSaveRanLoadInformationEmptyInventoryNameFailure(t *testing.T) {
312 w, _ := initSdlInstanceMock(namespace)
314 err := w.SaveRanLoadInformation(inventoryName, nil)
315 assert.NotNil(t, err)
316 assert.IsType(t, &common.ValidationError{}, err)
319 func TestSaveRanLoadInformationSdlFailure(t *testing.T) {
320 inventoryName := "name2"
322 loadKey, validationErr := common.ValidateAndBuildRanLoadInformationKey(inventoryName)
324 if validationErr != nil {
325 t.Errorf("#rNibWriter_test.TestSaveRanLoadInformationSuccess - Failed to build ran load infromation key. Error: %v", validationErr)
328 w, sdlInstanceMock := initSdlInstanceMock(namespace)
330 ranLoadInformation := generateRanLoadInformation()
331 data, err := proto.Marshal(ranLoadInformation)
334 t.Errorf("#rNibWriter_test.TestSaveRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
337 expectedErr := errors.New("expected error")
338 var setExpected []interface{}
339 setExpected = append(setExpected, loadKey, data)
340 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(expectedErr)
342 rNibErr := w.SaveRanLoadInformation(inventoryName, ranLoadInformation)
343 assert.NotNil(t, rNibErr)
344 assert.IsType(t, &common.InternalError{}, rNibErr)
347 func generateCellLoadInformation() *entities.CellLoadInformation {
348 cellLoadInformation := entities.CellLoadInformation{}
350 cellLoadInformation.CellId = "123"
352 ulInterferenceOverloadIndication := entities.UlInterferenceOverloadIndication_HIGH_INTERFERENCE
353 cellLoadInformation.UlInterferenceOverloadIndications = []entities.UlInterferenceOverloadIndication{ulInterferenceOverloadIndication}
355 ulHighInterferenceInformation := entities.UlHighInterferenceInformation{
357 UlHighInterferenceIndication: "xxx",
360 cellLoadInformation.UlHighInterferenceInfos = []*entities.UlHighInterferenceInformation{&ulHighInterferenceInformation}
362 cellLoadInformation.RelativeNarrowbandTxPower = &entities.RelativeNarrowbandTxPower{
364 RntpThreshold: entities.RntpThreshold_NEG_4,
365 NumberOfCellSpecificAntennaPorts: entities.NumberOfCellSpecificAntennaPorts_V1_ANT_PRT,
367 PdcchInterferenceImpact: 2,
368 EnhancedRntp: &entities.EnhancedRntp{
369 EnhancedRntpBitmap: "xxx",
370 RntpHighPowerThreshold: entities.RntpThreshold_NEG_2,
371 EnhancedRntpStartTime: &entities.StartTime{StartSfn: 500, StartSubframeNumber: 5},
375 cellLoadInformation.AbsInformation = &entities.AbsInformation{
376 Mode: entities.AbsInformationMode_ABS_INFO_FDD,
377 AbsPatternInfo: "xxx",
378 NumberOfCellSpecificAntennaPorts: entities.NumberOfCellSpecificAntennaPorts_V2_ANT_PRT,
379 MeasurementSubset: "xxx",
382 cellLoadInformation.InvokeIndication = entities.InvokeIndication_ABS_INFORMATION
384 cellLoadInformation.ExtendedUlInterferenceOverloadInfo = &entities.ExtendedUlInterferenceOverloadInfo{
385 AssociatedSubframes: "xxx",
386 ExtendedUlInterferenceOverloadIndications: cellLoadInformation.UlInterferenceOverloadIndications,
389 compInformationItem := &entities.CompInformationItem{
390 CompHypothesisSets: []*entities.CompHypothesisSet{&entities.CompHypothesisSet{CellId: "789", CompHypothesis: "xxx"}},
394 cellLoadInformation.CompInformation = &entities.CompInformation{
395 CompInformationItems: []*entities.CompInformationItem{compInformationItem},
396 CompInformationStartTime: &entities.StartTime{StartSfn: 123, StartSubframeNumber: 456},
399 cellLoadInformation.DynamicDlTransmissionInformation = &entities.DynamicDlTransmissionInformation{
400 State: entities.NaicsState_NAICS_ACTIVE,
401 TransmissionModes: "xxx",
403 PAList: []entities.PA{entities.PA_DB_NEG_3},
406 return &cellLoadInformation
409 func generateRanLoadInformation() *entities.RanLoadInformation {
410 ranLoadInformation := entities.RanLoadInformation{}
412 ranLoadInformation.LoadTimestamp = uint64(time.Now().UnixNano())
414 cellLoadInformation := generateCellLoadInformation()
415 ranLoadInformation.CellLoadInfos = []*entities.CellLoadInformation{cellLoadInformation}
417 return &ranLoadInformation
420 func TestSaveNilEntityFailure(t *testing.T) {
421 w, _ := initSdlInstanceMock(namespace)
422 expectedErr := common.NewInternalError(errors.New("proto: Marshal called with nil"))
423 nbIdentity := &entities.NbIdentity{}
424 actualErr := w.SaveNodeb(nbIdentity, nil)
425 assert.Equal(t, expectedErr, actualErr)
428 func TestSaveUnknownTypeEntityFailure(t *testing.T) {
429 w, _ := initSdlInstanceMock(namespace)
430 expectedErr := common.NewValidationError("#rNibWriter.saveNodeB - Unknown responding node type, entity: ip:\"localhost\" port:5656 ")
431 nbIdentity := &entities.NbIdentity{InventoryName: "name", GlobalNbId: &entities.GlobalNbId{PlmnId: "02f829", NbId: "4a952a0a"}}
432 nb := &entities.NodebInfo{}
435 actualErr := w.SaveNodeb(nbIdentity, nb)
436 assert.Equal(t, expectedErr, actualErr)
439 func TestSaveEntityFailure(t *testing.T) {
444 w, sdlInstanceMock := initSdlInstanceMock(namespace)
445 gnb := entities.NodebInfo{}
446 gnb.NodeType = entities.Node_GNB
447 data, err := proto.Marshal(&gnb)
449 t.Errorf("#rNibWriter_test.TestSaveEntityFailure - Failed to marshal NodeB entity. Error: %v", err)
451 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
452 setExpected := []interface{}{"RAN:" + name, data}
453 setExpected = append(setExpected, "GNB:"+plmnId+":"+nbId, data)
454 expectedErr := errors.New("expected error")
455 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(expectedErr)
456 rNibErr := w.SaveNodeb(nbIdentity, &gnb)
457 assert.NotEmpty(t, rNibErr)
460 func TestGetRNibWriter(t *testing.T) {
461 received, _ := initSdlInstanceMock(namespace)
462 assert.NotEmpty(t, received)
467 //func TestSaveEnbGnbInteg(t *testing.T){
468 // for i := 0; i<10; i++{
469 // Init("e2Manager", 1)
470 // w := GetRNibWriter()
471 // nb := entities.NodebInfo{}
472 // nb.NodeType = entities.Node_ENB
473 // nb.ConnectionStatus = entities.ConnectionStatus_CONNECTED
474 // nb.Ip = "localhost"
475 // nb.Port = uint32(5656 + i)
476 // enb := entities.Enb{}
477 // cell1 := &entities.ServedCellInfo{CellId:fmt.Sprintf("%02x",111 + i), Pci:uint32(11 + i)}
478 // cell2 := &entities.ServedCellInfo{CellId:fmt.Sprintf("%02x",222 + i), Pci:uint32(22 + i)}
479 // cell3 := &entities.ServedCellInfo{CellId:fmt.Sprintf("%02x",333 + i), Pci:uint32(33 + i)}
480 // enb.ServedCells = []*entities.ServedCellInfo{cell1, cell2, cell3}
481 // nb.Configuration = &entities.NodebInfo_Enb{Enb:&enb}
482 // plmnId := 0x02f828
483 // nbId := 0x4a952a0a
484 // nbIdentity := &entities.NbIdentity{InventoryName: fmt.Sprintf("nameEnb%d" ,i), GlobalNbId:&entities.GlobalNbId{PlmnId:fmt.Sprintf("%02x", plmnId + i), NbId:fmt.Sprintf("%02x", nbId + i)}}
485 // err := w.SaveNodeb(nbIdentity, &nb)
487 // t.Errorf("#rNibWriter_test.TestSaveEnbInteg - Failed to save NodeB entity. Error: %v", err)
490 // nb1 := entities.NodebInfo{}
491 // nb1.NodeType = entities.Node_GNB
492 // nb1.ConnectionStatus = entities.ConnectionStatus_CONNECTED
493 // nb1.Ip = "localhost"
494 // nb1.Port = uint32(6565 + i)
495 // gnb := entities.Gnb{}
496 // gCell1 := &entities.ServedNRCell{ServedNrCellInformation:&entities.ServedNRCellInformation{CellId:fmt.Sprintf("%02x",1111 + i), NrPci:uint32(1 + i)}}
497 // gCell2 := &entities.ServedNRCell{ServedNrCellInformation:&entities.ServedNRCellInformation{CellId:fmt.Sprintf("%02x",2222 + i), NrPci:uint32(2 + i)}}
498 // gCell3 := &entities.ServedNRCell{ServedNrCellInformation:&entities.ServedNRCellInformation{CellId:fmt.Sprintf("%02x",3333 + i), NrPci:uint32(3 + i)}}
499 // gnb.ServedNrCells = []*entities.ServedNRCell{gCell1, gCell2, gCell3,}
500 // nb1.Configuration = &entities.NodebInfo_Gnb{Gnb:&gnb}
501 // nbIdentity = &entities.NbIdentity{InventoryName: fmt.Sprintf("nameGnb%d" ,i), GlobalNbId:&entities.GlobalNbId{PlmnId:fmt.Sprintf("%02x", plmnId - i), NbId:fmt.Sprintf("%02x", nbId - i)}}
502 // err = w.SaveNodeb(nbIdentity, &nb1)
504 // t.Errorf("#rNibWriter_test.TestSaveEnbInteg - Failed to save NodeB entity. Error: %v", err)
509 //func TestSaveNbRanNamesInteg(t *testing.T){
510 // for i := 0; i<10; i++{
511 // Init("e2Manager", 1)
512 // w := GetRNibWriter()
513 // nb := entities.NodebInfo{}
514 // nb.ConnectionStatus = entities.ConnectionStatus_CONNECTING
515 // nb.Ip = "localhost"
516 // nb.Port = uint32(5656 + i)
517 // nbIdentity := &entities.NbIdentity{InventoryName: fmt.Sprintf("nameOnly%d" ,i)}
518 // err := w.SaveNodeb(nbIdentity, &nb)
520 // t.Errorf("#rNibWriter_test.TestSaveEnbInteg - Failed to save NodeB entity. Error: %v", err)
525 //func TestSaveRanLoadInformationInteg(t *testing.T){
526 // Init("e2Manager", 1)
527 // w := GetRNibWriter()
528 // ranLoadInformation := generateRanLoadInformation()
529 // err := w.SaveRanLoadInformation("ran_integ", ranLoadInformation)
531 // t.Errorf("#rNibWriter_test.TestSaveRanLoadInformationInteg - Failed to save RanLoadInformation entity. Error: %v", err)