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 TestRemoveServedNrCellsSuccess(t *testing.T) {
109 w, sdlInstanceMock := initSdlInstanceMock(namespace)
110 servedNrCellsToRemove := generateServedNrCells("whatever1", "whatever2")
111 sdlInstanceMock.On("Remove", buildServedNRCellKeysToRemove(RanName, servedNrCellsToRemove)).Return(nil)
113 err := w.RemoveServedNrCells(RanName, servedNrCellsToRemove)
117 func TestRemoveServedNrCellsFailure(t *testing.T) {
118 w, sdlInstanceMock := initSdlInstanceMock(namespace)
119 servedNrCellsToRemove := generateServedNrCells("whatever1", "whatever2")
120 sdlInstanceMock.On("Remove", buildServedNRCellKeysToRemove(RanName, servedNrCellsToRemove)).Return(errors.New("expected error"))
122 err := w.RemoveServedNrCells(RanName, servedNrCellsToRemove)
123 assert.IsType(t, &common.InternalError{}, err)
126 func TestUpdateGnbCellsInvalidNodebInfoFailure(t *testing.T) {
127 w, sdlInstanceMock := initSdlInstanceMock(namespace)
128 servedNrCells := generateServedNrCells("test1", "test2")
129 nodebInfo := &entities.NodebInfo{}
130 sdlInstanceMock.AssertNotCalled(t, "Set")
131 rNibErr := w.UpdateGnbCells(nodebInfo, servedNrCells)
132 assert.IsType(t, &common.ValidationError{}, rNibErr)
135 func TestUpdateGnbCellsInvalidCellFailure(t *testing.T) {
136 inventoryName := "name"
139 w, sdlInstanceMock := initSdlInstanceMock(namespace)
140 servedNrCells := []*entities.ServedNRCell{{ServedNrCellInformation: &entities.ServedNRCellInformation{}}}
141 nodebInfo := generateNodebInfo(inventoryName, entities.Node_GNB, plmnId, nbId)
142 nodebInfo.GetGnb().ServedNrCells = servedNrCells
143 sdlInstanceMock.AssertNotCalled(t, "Set")
144 rNibErr := w.UpdateGnbCells(nodebInfo, servedNrCells)
145 assert.IsType(t, &common.ValidationError{}, rNibErr)
148 func getUpdateGnbCellsSetExpected(t *testing.T, nodebInfo *entities.NodebInfo, servedNrCells []*entities.ServedNRCell) []interface{} {
150 nodebInfoData, err := proto.Marshal(nodebInfo)
152 t.Fatalf("#rNibWriter_test.getUpdateGnbCellsSetExpected - Failed to marshal NodeB entity. Error: %s", err)
155 nodebNameKey, _ := common.ValidateAndBuildNodeBNameKey(nodebInfo.RanName)
156 nodebIdKey, _ := common.ValidateAndBuildNodeBIdKey(nodebInfo.NodeType.String(), nodebInfo.GlobalNbId.PlmnId, nodebInfo.GlobalNbId.NbId)
157 setExpected := []interface{}{nodebNameKey, nodebInfoData, nodebIdKey, nodebInfoData}
159 for _, v := range servedNrCells {
161 cellEntity := entities.Cell{Type: entities.Cell_NR_CELL, Cell: &entities.Cell_ServedNrCell{ServedNrCell: v}}
162 cellData, err := proto.Marshal(&cellEntity)
165 t.Fatalf("#rNibWriter_test.getUpdateGnbCellsSetExpected - Failed to marshal cell entity. Error: %s", err)
168 nrCellIdKey, _ := common.ValidateAndBuildNrCellIdKey(v.GetServedNrCellInformation().GetCellId())
169 cellNamePciKey, _ := common.ValidateAndBuildCellNamePciKey(nodebInfo.RanName, v.GetServedNrCellInformation().GetNrPci())
170 setExpected = append(setExpected, nrCellIdKey, cellData, cellNamePciKey, cellData)
176 func TestUpdateGnbCellsSdlFailure(t *testing.T) {
177 inventoryName := "name"
180 w, sdlInstanceMock := initSdlInstanceMock(namespace)
181 servedNrCells := generateServedNrCells("test1", "test2")
182 nodebInfo := generateNodebInfo(inventoryName, entities.Node_GNB, plmnId, nbId)
183 nodebInfo.GetGnb().ServedNrCells = servedNrCells
184 setExpected := getUpdateGnbCellsSetExpected(t, nodebInfo, servedNrCells)
185 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(errors.New("expected error"))
186 rNibErr := w.UpdateGnbCells(nodebInfo, servedNrCells)
187 assert.IsType(t, &common.InternalError{}, rNibErr)
190 func TestUpdateGnbCellsSuccess(t *testing.T) {
191 inventoryName := "name"
194 w, sdlInstanceMock := initSdlInstanceMock(namespace)
195 servedNrCells := generateServedNrCells("test1", "test2")
196 nodebInfo := generateNodebInfo(inventoryName, entities.Node_GNB, plmnId, nbId)
197 nodebInfo.GetGnb().ServedNrCells = servedNrCells
198 setExpected := getUpdateGnbCellsSetExpected(t, nodebInfo, servedNrCells)
200 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
201 rNibErr := w.UpdateGnbCells(nodebInfo, servedNrCells)
202 assert.Nil(t, rNibErr)
205 func TestUpdateNodebInfoSuccess(t *testing.T) {
206 inventoryName := "name"
209 w, sdlInstanceMock := initSdlInstanceMock(namespace)
210 nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
211 data, err := proto.Marshal(nodebInfo)
213 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal NodeB entity. Error: %v", err)
216 var setExpected []interface{}
218 nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
219 nodebIdKey := fmt.Sprintf("ENB:%s:%s", plmnId, nbId)
220 setExpected = append(setExpected, nodebNameKey, data)
221 setExpected = append(setExpected, nodebIdKey, data)
223 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
225 rNibErr := w.UpdateNodebInfo(nodebInfo)
226 assert.Nil(t, rNibErr)
229 func TestUpdateNodebInfoMissingInventoryNameFailure(t *testing.T) {
230 inventoryName := "name"
233 w, sdlInstanceMock := initSdlInstanceMock(namespace)
234 nodebInfo := &entities.NodebInfo{}
235 data, err := proto.Marshal(nodebInfo)
237 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal NodeB entity. Error: %v", err)
240 var setExpected []interface{}
242 nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
243 nodebIdKey := fmt.Sprintf("ENB:%s:%s", plmnId, nbId)
244 setExpected = append(setExpected, nodebNameKey, data)
245 setExpected = append(setExpected, nodebIdKey, data)
247 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
249 rNibErr := w.UpdateNodebInfo(nodebInfo)
251 assert.NotNil(t, rNibErr)
252 assert.IsType(t, &common.ValidationError{}, rNibErr)
255 func TestUpdateNodebInfoMissingGlobalNbId(t *testing.T) {
256 inventoryName := "name"
257 w, sdlInstanceMock := initSdlInstanceMock(namespace)
258 nodebInfo := &entities.NodebInfo{}
259 nodebInfo.RanName = inventoryName
260 data, err := proto.Marshal(nodebInfo)
262 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal NodeB entity. Error: %v", err)
265 var setExpected []interface{}
267 nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
268 setExpected = append(setExpected, nodebNameKey, data)
269 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
271 rNibErr := w.UpdateNodebInfo(nodebInfo)
273 assert.Nil(t, rNibErr)
276 func TestSaveEnb(t *testing.T) {
278 ranName := "RAN:" + name
279 w, sdlInstanceMock := initSdlInstanceMock(namespace)
280 nb := entities.NodebInfo{}
282 nb.NodeType = entities.Node_ENB
283 nb.ConnectionStatus = 1
286 enb := entities.Enb{}
287 cell := &entities.ServedCellInfo{CellId: "aaff", Pci: 3}
288 cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: cell}}
289 enb.ServedCells = []*entities.ServedCellInfo{cell}
290 nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
291 data, err := proto.Marshal(&nb)
293 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal NodeB entity. Error: %v", err)
297 cellData, err := proto.Marshal(&cellEntity)
299 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal Cell entity. Error: %v", err)
301 var setExpected []interface{}
302 setExpected = append(setExpected, ranName, data)
303 setExpected = append(setExpected, "ENB:02f829:4a952a0a", data)
304 setExpected = append(setExpected, fmt.Sprintf("CELL:%s", cell.GetCellId()), cellData)
305 setExpected = append(setExpected, fmt.Sprintf("PCI:%s:%02x", name, cell.GetPci()), cellData)
307 sdlInstanceMock.On("SetAndPublish", []string{"RAN_MANIPULATION", name + "_" + RanAddedEvent}, []interface{}{setExpected}).Return(e)
309 nbIdData, err := proto.Marshal(&entities.NbIdentity{InventoryName: name})
311 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal nbIdentity entity. Error: %v", err)
313 sdlInstanceMock.On("RemoveMember", entities.Node_UNKNOWN.String(), []interface{}{nbIdData}).Return(e)
315 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: "02f829", NbId: "4a952a0a"}}
316 nbIdData, err = proto.Marshal(nbIdentity)
318 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal NodeB Identity entity. Error: %v", err)
320 sdlInstanceMock.On("AddMember", "ENB", []interface{}{nbIdData}).Return(e)
322 rNibErr := w.SaveNodeb(nbIdentity, &nb)
323 assert.Nil(t, rNibErr)
326 func TestSaveEnbCellIdValidationFailure(t *testing.T) {
328 w, _ := initSdlInstanceMock(namespace)
329 nb := entities.NodebInfo{}
330 nb.NodeType = entities.Node_ENB
331 nb.ConnectionStatus = 1
334 enb := entities.Enb{}
335 cell := &entities.ServedCellInfo{Pci: 3}
336 enb.ServedCells = []*entities.ServedCellInfo{cell}
337 nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
339 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: "02f829", NbId: "4a952a0a"}}
340 rNibErr := w.SaveNodeb(nbIdentity, &nb)
341 assert.NotNil(t, rNibErr)
342 assert.IsType(t, &common.ValidationError{}, rNibErr)
343 assert.Equal(t, "#utils.ValidateAndBuildCellIdKey - an empty cell id received", rNibErr.Error())
346 func TestSaveEnbInventoryNameValidationFailure(t *testing.T) {
347 w, _ := initSdlInstanceMock(namespace)
348 nb := entities.NodebInfo{}
349 nb.NodeType = entities.Node_ENB
350 nb.ConnectionStatus = 1
353 enb := entities.Enb{}
354 cell := &entities.ServedCellInfo{CellId: "aaa", Pci: 3}
355 enb.ServedCells = []*entities.ServedCellInfo{cell}
356 nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
358 nbIdentity := &entities.NbIdentity{InventoryName: "", GlobalNbId: &entities.GlobalNbId{PlmnId: "02f829", NbId: "4a952a0a"}}
359 rNibErr := w.SaveNodeb(nbIdentity, &nb)
360 assert.NotNil(t, rNibErr)
361 assert.IsType(t, &common.ValidationError{}, rNibErr)
362 assert.Equal(t, "#utils.ValidateAndBuildNodeBNameKey - an empty inventory name received", rNibErr.Error())
365 func TestSaveGnbCellIdValidationFailure(t *testing.T) {
367 w, _ := initSdlInstanceMock(namespace)
368 nb := entities.NodebInfo{}
369 nb.NodeType = entities.Node_GNB
370 nb.ConnectionStatus = 1
373 gnb := entities.Gnb{}
374 cellInfo := &entities.ServedNRCellInformation{NrPci: 2}
375 cell := &entities.ServedNRCell{ServedNrCellInformation: cellInfo}
376 gnb.ServedNrCells = []*entities.ServedNRCell{cell}
377 nb.Configuration = &entities.NodebInfo_Gnb{Gnb: &gnb}
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.ValidateAndBuildNrCellIdKey - an empty cell id received", rNibErr.Error())
386 func TestSaveGnb(t *testing.T) {
388 ranName := "RAN:" + name
389 w, sdlInstanceMock := initSdlInstanceMock(namespace)
390 nb := entities.NodebInfo{}
391 nb.NodeType = entities.Node_GNB
392 nb.ConnectionStatus = 1
395 gnb := entities.Gnb{}
396 cellInfo := &entities.ServedNRCellInformation{NrPci: 2, CellId: "ccdd"}
397 cell := &entities.ServedNRCell{ServedNrCellInformation: cellInfo}
398 cellEntity := entities.Cell{Type: entities.Cell_NR_CELL, Cell: &entities.Cell_ServedNrCell{ServedNrCell: cell}}
399 gnb.ServedNrCells = []*entities.ServedNRCell{cell}
400 nb.Configuration = &entities.NodebInfo_Gnb{Gnb: &gnb}
401 data, err := proto.Marshal(&nb)
403 t.Errorf("#rNibWriter_test.TestSaveGnb - Failed to marshal NodeB entity. Error: %v", err)
407 cellData, err := proto.Marshal(&cellEntity)
409 t.Errorf("#rNibWriter_test.TestSaveGnb - Failed to marshal Cell entity. Error: %v", err)
411 var setExpected []interface{}
412 setExpected = append(setExpected, ranName, data)
413 setExpected = append(setExpected, "GNB:02f829:4a952a0a", data)
414 setExpected = append(setExpected, fmt.Sprintf("NRCELL:%s", cell.GetServedNrCellInformation().GetCellId()), cellData)
415 setExpected = append(setExpected, fmt.Sprintf("PCI:%s:%02x", name, cell.GetServedNrCellInformation().GetNrPci()), cellData)
417 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
418 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: "02f829", NbId: "4a952a0a"}}
419 nbIdData, err := proto.Marshal(nbIdentity)
421 t.Errorf("#rNibWriter_test.TestSaveGnb - Failed to marshal NodeB Identity entity. Error: %v", err)
423 sdlInstanceMock.On("AddMember", "GNB", []interface{}{nbIdData}).Return(e)
425 nbIdData, err = proto.Marshal(&entities.NbIdentity{InventoryName: name})
427 t.Errorf("#rNibWriter_test.TestSaveEnb - Failed to marshal nbIdentity entity. Error: %v", err)
429 sdlInstanceMock.On("RemoveMember", entities.Node_UNKNOWN.String(), []interface{}{nbIdData}).Return(e)
431 rNibErr := w.SaveNodeb(nbIdentity, &nb)
432 assert.Nil(t, rNibErr)
435 func TestSaveRanLoadInformationSuccess(t *testing.T) {
436 inventoryName := "name"
437 loadKey, validationErr := common.ValidateAndBuildRanLoadInformationKey(inventoryName)
439 if validationErr != nil {
440 t.Errorf("#rNibWriter_test.TestSaveRanLoadInformationSuccess - Failed to build ran load infromation key. Error: %v", validationErr)
443 w, sdlInstanceMock := initSdlInstanceMock(namespace)
445 ranLoadInformation := generateRanLoadInformation()
446 data, err := proto.Marshal(ranLoadInformation)
449 t.Errorf("#rNibWriter_test.TestSaveRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
453 var setExpected []interface{}
454 setExpected = append(setExpected, loadKey, data)
455 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
457 rNibErr := w.SaveRanLoadInformation(inventoryName, ranLoadInformation)
458 assert.Nil(t, rNibErr)
461 func TestSaveRanLoadInformationMarshalNilFailure(t *testing.T) {
462 inventoryName := "name2"
463 w, _ := initSdlInstanceMock(namespace)
465 expectedErr := common.NewInternalError(errors.New("proto: Marshal called with nil"))
466 err := w.SaveRanLoadInformation(inventoryName, nil)
467 assert.Equal(t, expectedErr, err)
470 func TestSaveRanLoadInformationEmptyInventoryNameFailure(t *testing.T) {
472 w, _ := initSdlInstanceMock(namespace)
474 err := w.SaveRanLoadInformation(inventoryName, nil)
475 assert.NotNil(t, err)
476 assert.IsType(t, &common.ValidationError{}, err)
479 func TestSaveRanLoadInformationSdlFailure(t *testing.T) {
480 inventoryName := "name2"
482 loadKey, validationErr := common.ValidateAndBuildRanLoadInformationKey(inventoryName)
484 if validationErr != nil {
485 t.Errorf("#rNibWriter_test.TestSaveRanLoadInformationSuccess - Failed to build ran load infromation key. Error: %v", validationErr)
488 w, sdlInstanceMock := initSdlInstanceMock(namespace)
490 ranLoadInformation := generateRanLoadInformation()
491 data, err := proto.Marshal(ranLoadInformation)
494 t.Errorf("#rNibWriter_test.TestSaveRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
497 expectedErr := errors.New("expected error")
498 var setExpected []interface{}
499 setExpected = append(setExpected, loadKey, data)
500 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(expectedErr)
502 rNibErr := w.SaveRanLoadInformation(inventoryName, ranLoadInformation)
503 assert.NotNil(t, rNibErr)
504 assert.IsType(t, &common.InternalError{}, rNibErr)
507 func generateCellLoadInformation() *entities.CellLoadInformation {
508 cellLoadInformation := entities.CellLoadInformation{}
510 cellLoadInformation.CellId = "123"
512 ulInterferenceOverloadIndication := entities.UlInterferenceOverloadIndication_HIGH_INTERFERENCE
513 cellLoadInformation.UlInterferenceOverloadIndications = []entities.UlInterferenceOverloadIndication{ulInterferenceOverloadIndication}
515 ulHighInterferenceInformation := entities.UlHighInterferenceInformation{
517 UlHighInterferenceIndication: "xxx",
520 cellLoadInformation.UlHighInterferenceInfos = []*entities.UlHighInterferenceInformation{&ulHighInterferenceInformation}
522 cellLoadInformation.RelativeNarrowbandTxPower = &entities.RelativeNarrowbandTxPower{
524 RntpThreshold: entities.RntpThreshold_NEG_4,
525 NumberOfCellSpecificAntennaPorts: entities.NumberOfCellSpecificAntennaPorts_V1_ANT_PRT,
527 PdcchInterferenceImpact: 2,
528 EnhancedRntp: &entities.EnhancedRntp{
529 EnhancedRntpBitmap: "xxx",
530 RntpHighPowerThreshold: entities.RntpThreshold_NEG_2,
531 EnhancedRntpStartTime: &entities.StartTime{StartSfn: 500, StartSubframeNumber: 5},
535 cellLoadInformation.AbsInformation = &entities.AbsInformation{
536 Mode: entities.AbsInformationMode_ABS_INFO_FDD,
537 AbsPatternInfo: "xxx",
538 NumberOfCellSpecificAntennaPorts: entities.NumberOfCellSpecificAntennaPorts_V2_ANT_PRT,
539 MeasurementSubset: "xxx",
542 cellLoadInformation.InvokeIndication = entities.InvokeIndication_ABS_INFORMATION
544 cellLoadInformation.ExtendedUlInterferenceOverloadInfo = &entities.ExtendedUlInterferenceOverloadInfo{
545 AssociatedSubframes: "xxx",
546 ExtendedUlInterferenceOverloadIndications: cellLoadInformation.UlInterferenceOverloadIndications,
549 compInformationItem := &entities.CompInformationItem{
550 CompHypothesisSets: []*entities.CompHypothesisSet{{CellId: "789", CompHypothesis: "xxx"}},
554 cellLoadInformation.CompInformation = &entities.CompInformation{
555 CompInformationItems: []*entities.CompInformationItem{compInformationItem},
556 CompInformationStartTime: &entities.StartTime{StartSfn: 123, StartSubframeNumber: 456},
559 cellLoadInformation.DynamicDlTransmissionInformation = &entities.DynamicDlTransmissionInformation{
560 State: entities.NaicsState_NAICS_ACTIVE,
561 TransmissionModes: "xxx",
563 PAList: []entities.PA{entities.PA_DB_NEG_3},
566 return &cellLoadInformation
569 func generateRanLoadInformation() *entities.RanLoadInformation {
570 ranLoadInformation := entities.RanLoadInformation{}
572 ranLoadInformation.LoadTimestamp = uint64(time.Now().UnixNano())
574 cellLoadInformation := generateCellLoadInformation()
575 ranLoadInformation.CellLoadInfos = []*entities.CellLoadInformation{cellLoadInformation}
577 return &ranLoadInformation
580 func TestSaveNilEntityFailure(t *testing.T) {
581 w, _ := initSdlInstanceMock(namespace)
582 expectedErr := common.NewInternalError(errors.New("proto: Marshal called with nil"))
583 nbIdentity := &entities.NbIdentity{}
584 actualErr := w.SaveNodeb(nbIdentity, nil)
585 assert.Equal(t, expectedErr, actualErr)
588 func TestSaveUnknownTypeEntityFailure(t *testing.T) {
589 w, _ := initSdlInstanceMock(namespace)
590 nbIdentity := &entities.NbIdentity{InventoryName: "name", GlobalNbId: &entities.GlobalNbId{PlmnId: "02f829", NbId: "4a952a0a"}}
591 nb := &entities.NodebInfo{}
594 actualErr := w.SaveNodeb(nbIdentity, nb)
595 assert.IsType(t, &common.ValidationError{}, actualErr)
598 func TestSaveEntityFailure(t *testing.T) {
603 w, sdlInstanceMock := initSdlInstanceMock(namespace)
604 gnb := entities.NodebInfo{}
605 gnb.NodeType = entities.Node_GNB
606 data, err := proto.Marshal(&gnb)
608 t.Errorf("#rNibWriter_test.TestSaveEntityFailure - Failed to marshal NodeB entity. Error: %v", err)
610 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
611 setExpected := []interface{}{"RAN:" + name, data}
612 setExpected = append(setExpected, "GNB:"+plmnId+":"+nbId, data)
613 expectedErr := errors.New("expected error")
614 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(expectedErr)
615 rNibErr := w.SaveNodeb(nbIdentity, &gnb)
616 assert.NotEmpty(t, rNibErr)
619 func TestGetRNibWriter(t *testing.T) {
620 received, _ := initSdlInstanceMock(namespace)
621 assert.NotEmpty(t, received)
624 func TestSaveE2TInstanceSuccess(t *testing.T) {
625 address := "10.10.2.15:9800"
626 loadKey, validationErr := common.ValidateAndBuildE2TInstanceKey(address)
628 if validationErr != nil {
629 t.Errorf("#rNibWriter_test.TestSaveE2TInstanceSuccess - Failed to build E2T Instance key. Error: %v", validationErr)
632 w, sdlInstanceMock := initSdlInstanceMock(namespace)
634 e2tInstance := generateE2tInstance(address)
635 data, err := json.Marshal(e2tInstance)
638 t.Errorf("#rNibWriter_test.TestSaveE2TInstanceSuccess - Failed to marshal E2tInstance entity. Error: %v", err)
642 var setExpected []interface{}
643 setExpected = append(setExpected, loadKey, data)
644 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
646 rNibErr := w.SaveE2TInstance(e2tInstance)
647 assert.Nil(t, rNibErr)
650 func TestSaveE2TInstanceNullE2tInstanceFailure(t *testing.T) {
651 w, _ := initSdlInstanceMock(namespace)
653 e2tInstance := entities.NewE2TInstance(address, "test")
654 err := w.SaveE2TInstance(e2tInstance)
655 assert.NotNil(t, err)
656 assert.IsType(t, &common.ValidationError{}, err)
659 func TestSaveE2TInstanceSdlFailure(t *testing.T) {
660 address := "10.10.2.15:9800"
661 loadKey, validationErr := common.ValidateAndBuildE2TInstanceKey(address)
663 if validationErr != nil {
664 t.Errorf("#rNibWriter_test.TestSaveE2TInstanceSdlFailure - Failed to build E2T Instance key. Error: %v", validationErr)
667 w, sdlInstanceMock := initSdlInstanceMock(namespace)
669 e2tInstance := generateE2tInstance(address)
670 data, err := json.Marshal(e2tInstance)
673 t.Errorf("#rNibWriter_test.TestSaveE2TInstanceSdlFailure - Failed to marshal E2tInstance entity. Error: %v", err)
676 expectedErr := errors.New("expected error")
677 var setExpected []interface{}
678 setExpected = append(setExpected, loadKey, data)
679 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(expectedErr)
681 rNibErr := w.SaveE2TInstance(e2tInstance)
682 assert.NotNil(t, rNibErr)
683 assert.IsType(t, &common.InternalError{}, rNibErr)
686 func generateE2tInstance(address string) *entities.E2TInstance {
687 e2tInstance := entities.NewE2TInstance(address, "pod test")
689 e2tInstance.AssociatedRanList = []string{"test1", "test2"}
694 func TestSaveE2TAddressesSuccess(t *testing.T) {
695 address := "10.10.2.15:9800"
696 w, sdlInstanceMock := initSdlInstanceMock(namespace)
698 e2tAddresses := []string{address}
699 data, err := json.Marshal(e2tAddresses)
702 t.Errorf("#rNibWriter_test.TestSaveE2TInfoListSuccess - Failed to marshal E2TInfoList. Error: %v", err)
706 var setExpected []interface{}
707 setExpected = append(setExpected, E2TAddressesKey, data)
708 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(e)
710 rNibErr := w.SaveE2TAddresses(e2tAddresses)
711 assert.Nil(t, rNibErr)
714 func TestSaveE2TAddressesSdlFailure(t *testing.T) {
715 address := "10.10.2.15:9800"
716 w, sdlInstanceMock := initSdlInstanceMock(namespace)
718 e2tAddresses := []string{address}
719 data, err := json.Marshal(e2tAddresses)
722 t.Errorf("#rNibWriter_test.TestSaveE2TInfoListSdlFailure - Failed to marshal E2TInfoList. Error: %v", err)
725 expectedErr := errors.New("expected error")
726 var setExpected []interface{}
727 setExpected = append(setExpected, E2TAddressesKey, data)
728 sdlInstanceMock.On("Set", []interface{}{setExpected}).Return(expectedErr)
730 rNibErr := w.SaveE2TAddresses(e2tAddresses)
731 assert.NotNil(t, rNibErr)
732 assert.IsType(t, &common.InternalError{}, rNibErr)
735 func TestRemoveE2TInstanceSuccess(t *testing.T) {
736 address := "10.10.2.15:9800"
737 w, sdlInstanceMock := initSdlInstanceMock(namespace)
739 e2tAddresses := []string{fmt.Sprintf("E2TInstance:%s", address)}
741 sdlInstanceMock.On("Remove", e2tAddresses).Return(e)
743 rNibErr := w.RemoveE2TInstance(address)
744 assert.Nil(t, rNibErr)
745 sdlInstanceMock.AssertExpectations(t)
748 func TestRemoveE2TInstanceSdlFailure(t *testing.T) {
749 address := "10.10.2.15:9800"
750 w, sdlInstanceMock := initSdlInstanceMock(namespace)
752 e2tAddresses := []string{fmt.Sprintf("E2TInstance:%s", address)}
753 expectedErr := errors.New("expected error")
754 sdlInstanceMock.On("Remove", e2tAddresses).Return(expectedErr)
756 rNibErr := w.RemoveE2TInstance(address)
757 assert.IsType(t, &common.InternalError{}, rNibErr)
760 func TestRemoveE2TInstanceEmptyAddressFailure(t *testing.T) {
761 w, sdlInstanceMock := initSdlInstanceMock(namespace)
763 rNibErr := w.RemoveE2TInstance("")
764 assert.IsType(t, &common.ValidationError{}, rNibErr)
765 sdlInstanceMock.AssertExpectations(t)
768 func TestUpdateNodebInfoOnConnectionStatusInversionSuccess(t *testing.T) {
769 inventoryName := "name"
772 channelName := "RAN_CONNECTION_STATUS_CHANGE"
773 eventName := inventoryName + "_" + "CONNECTED"
774 w, sdlInstanceMock := initSdlInstanceMock(namespace)
775 nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
776 data, err := proto.Marshal(nodebInfo)
778 t.Errorf("#rNibWriter_test.TestUpdateNodebInfoOnConnectionStatusInversionSuccess - Failed to marshal NodeB entity. Error: %v", err)
781 var setExpected []interface{}
783 nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
784 nodebIdKey := fmt.Sprintf("ENB:%s:%s", plmnId, nbId)
785 setExpected = append(setExpected, nodebNameKey, data)
786 setExpected = append(setExpected, nodebIdKey, data)
788 sdlInstanceMock.On("SetAndPublish", []string{channelName, eventName}, []interface{}{setExpected}).Return(e)
790 rNibErr := w.UpdateNodebInfoOnConnectionStatusInversion(nodebInfo, eventName)
791 assert.Nil(t, rNibErr)
794 func TestUpdateNodebInfoOnConnectionStatusInversionMissingInventoryNameFailure(t *testing.T) {
795 inventoryName := "name"
798 channelName := "RAN_CONNECTION_STATUS_CHANGE"
799 eventName := inventoryName + "_" + "CONNECTED"
800 w, sdlInstanceMock := initSdlInstanceMock(namespace)
801 nodebInfo := &entities.NodebInfo{}
802 data, err := proto.Marshal(nodebInfo)
804 t.Errorf("#rNibWriter_test.TestUpdateNodebInfoOnConnectionStatusInversionMissingInventoryNameFailure - Failed to marshal NodeB entity. Error: %v", err)
807 var setExpected []interface{}
809 nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
810 nodebIdKey := fmt.Sprintf("ENB:%s:%s", plmnId, nbId)
811 setExpected = append(setExpected, nodebNameKey, data)
812 setExpected = append(setExpected, nodebIdKey, data)
814 sdlInstanceMock.On("SetAndPublish", []string{channelName, eventName}, []interface{}{setExpected}).Return(e)
816 rNibErr := w.UpdateNodebInfoOnConnectionStatusInversion(nodebInfo, eventName)
818 assert.NotNil(t, rNibErr)
819 assert.IsType(t, &common.ValidationError{}, rNibErr)
822 func TestUpdateNodebInfoOnConnectionStatusInversionMissingGlobalNbId(t *testing.T) {
823 inventoryName := "name"
824 channelName := "RAN_CONNECTION_STATUS_CHANGE"
825 eventName := inventoryName + "_" + "CONNECTED"
826 w, sdlInstanceMock := initSdlInstanceMock(namespace)
827 nodebInfo := &entities.NodebInfo{}
828 nodebInfo.RanName = inventoryName
829 data, err := proto.Marshal(nodebInfo)
831 t.Errorf("#rNibWriter_test.TestUpdateNodebInfoOnConnectionStatusInversionMissingInventoryNameFailure - Failed to marshal NodeB entity. Error: %v", err)
834 var setExpected []interface{}
836 nodebNameKey := fmt.Sprintf("RAN:%s", inventoryName)
837 setExpected = append(setExpected, nodebNameKey, data)
838 sdlInstanceMock.On("SetAndPublish", []string{channelName, eventName}, []interface{}{setExpected}).Return(e)
840 rNibErr := w.UpdateNodebInfoOnConnectionStatusInversion(nodebInfo, eventName)
842 assert.Nil(t, rNibErr)
845 func TestSaveGeneralConfiguration(t *testing.T) {
846 w, sdlInstanceMock := initSdlInstanceMock(namespace)
848 key := common.BuildGeneralConfigurationKey()
849 configurationData := "{\"enableRic\":true}"
850 configuration := &entities.GeneralConfiguration{}
851 configuration.EnableRic = true
853 sdlInstanceMock.On("Set", []interface{}{[]interface{}{key, []byte(configurationData)}}).Return(nil)
854 rNibErr := w.SaveGeneralConfiguration(configuration)
856 assert.Nil(t, rNibErr)
857 sdlInstanceMock.AssertExpectations(t)
860 func TestSaveGeneralConfigurationDbError(t *testing.T) {
861 w, sdlInstanceMock := initSdlInstanceMock(namespace)
863 key := common.BuildGeneralConfigurationKey()
864 configurationData := "{\"enableRic\":true}"
865 configuration := &entities.GeneralConfiguration{}
866 configuration.EnableRic = true
868 expectedErr := errors.New("expected error")
870 sdlInstanceMock.On("Set", []interface{}{[]interface{}{key, []byte(configurationData)}}).Return(expectedErr)
871 rNibErr := w.SaveGeneralConfiguration(configuration)
873 assert.NotNil(t, rNibErr)
875 func TestRemoveServedCellsSuccess(t *testing.T) {
876 w, sdlInstanceMock := initSdlInstanceMock(namespace)
877 servedCellsToRemove := generateServedCells("whatever1", "whatever2")
878 sdlInstanceMock.On("Remove", buildServedCellInfoKeysToRemove(RanName, servedCellsToRemove)).Return(nil)
879 err := w.RemoveServedCells(RanName, servedCellsToRemove)
883 func TestUpdateEnbInvalidNodebInfoFailure(t *testing.T) {
884 w, sdlInstanceMock := initSdlInstanceMock(namespace)
885 servedCells := generateServedCells("test1", "test2")
886 nodebInfo := &entities.NodebInfo{}
887 sdlInstanceMock.AssertNotCalled(t, "SetAndPublish")
888 rNibErr := w.UpdateEnb(nodebInfo, servedCells)
889 assert.IsType(t, &common.ValidationError{}, rNibErr)
892 func TestUpdateEnbInvalidCellFailure(t *testing.T) {
893 inventoryName := "name"
896 w, sdlInstanceMock := initSdlInstanceMock(namespace)
897 servedCells := []*entities.ServedCellInfo{{CellId: ""}}
898 nodebInfo := generateNodebInfo(inventoryName, entities.Node_ENB, plmnId, nbId)
899 nodebInfo.GetEnb().ServedCells = servedCells
900 sdlInstanceMock.AssertNotCalled(t, "SetAndPublish")
901 rNibErr := w.UpdateEnb(nodebInfo, servedCells)
902 assert.IsType(t, &common.ValidationError{}, rNibErr)
905 /*func TestUpdateEnbSdlFailure(t *testing.T) {
906 inventoryName := "ranName"
909 w, sdlInstanceMock := initSdlInstanceMock(namespace)
910 servedCells := generateServedCells("test1", "test2")
911 nodebInfo := generateNodebInfo(inventoryName, entities.Node_GNB, plmnId, nbId)
912 nodebInfo.GetEnb().ServedCells = servedCells
913 setExpected := getUpdateEnbSetExpected(t, nodebInfo, servedCells)
914 sdlInstanceMock.On("SetAndPublish", []string{"RAN_MANIPULATION", inventoryName + "_" + RanUpdatedEvent}, []interface{}{setExpected}).Return(errors.New("expected error"))
915 rNibErr := w.UpdateEnb(nodebInfo, servedCells)
916 assert.IsType(t, &common.InternalError{}, rNibErr)
919 /*func TestUpdateEnbSuccess(t *testing.T) {
920 inventoryName := "ranName"
923 w, sdlInstanceMock := initSdlInstanceMock(namespace)
924 servedCells := generateServedCells("test1", "test2")
925 nodebInfo := generateNodebInfo(inventoryName, entities.Node_GNB, plmnId, nbId)
926 nodebInfo.GetEnb().ServedCells = servedCells
927 setExpected := getUpdateEnbSetExpected(t, nodebInfo, servedCells)
930 sdlInstanceMock.On("SetAndPublish", []string{"RAN_MANIPULATION", inventoryName + "_" + RanUpdatedEvent}, []interface{}{setExpected}).Return(e)
931 rNibErr := w.UpdateEnb(nodebInfo, servedCells)
932 assert.Nil(t, rNibErr)
935 func getUpdateEnbSetExpected(t *testing.T, nodebInfo *entities.NodebInfo, servedCells []*entities.ServedCellInfo) []interface{} {
937 nodebInfoData, err := proto.Marshal(nodebInfo)
939 t.Fatalf("#rNibWriter_test.getUpdateEnbSetExpected - Failed to marshal NodeB entity. Error: %s", err)
942 nodebNameKey, _ := common.ValidateAndBuildNodeBNameKey(nodebInfo.RanName)
943 nodebIdKey, _ := common.ValidateAndBuildNodeBIdKey(nodebInfo.NodeType.String(), nodebInfo.GlobalNbId.PlmnId, nodebInfo.GlobalNbId.NbId)
944 setExpected := []interface{}{nodebNameKey, nodebInfoData, nodebIdKey, nodebInfoData}
946 for _, v := range servedCells {
948 cellEntity := entities.ServedCellInfo{CellId: "some cell id", EutraMode: entities.Eutra_FDD, CsgId: "some csg id"}
949 cellData, err := proto.Marshal(&cellEntity)
952 t.Fatalf("#rNibWriter_test.getUpdateEnbSetExpected - Failed to marshal cell entity. Error: %s", err)
955 nrCellIdKey, _ := common.ValidateAndBuildNrCellIdKey(v.GetCellId())
956 cellNamePciKey, _ := common.ValidateAndBuildCellNamePciKey(nodebInfo.RanName, v.GetPci())
957 setExpected = append(setExpected, nrCellIdKey, cellData, cellNamePciKey, cellData)