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).
25 "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
26 "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
27 "github.com/golang/protobuf/proto"
28 "github.com/pkg/errors"
29 "github.com/stretchr/testify/assert"
34 func initSdlInstanceMock() (w RNibReader, sdlInstanceMock *MockSdlInstance) {
35 sdlInstanceMock = new(MockSdlInstance)
36 w = GetRNibReader(sdlInstanceMock)
40 func TestGetNodeB(t *testing.T) {
42 w, sdlInstanceMock := initSdlInstanceMock()
43 nb := entities.NodebInfo{}
44 nb.ConnectionStatus = 1
48 cell := entities.ServedCellInfo{Tac: "tac"}
49 enb.ServedCells = []*entities.ServedCellInfo{&cell}
50 nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
52 data, err := proto.Marshal(&nb)
54 t.Errorf("#rNibReader_test.TestGetNb - Failed to marshal ENB instance. Error: %v", err)
56 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
58 t.Errorf("#rNibReader_test.TestGetNodeB - failed to validate key parameter")
60 ret := map[string]interface{}{redisKey: string(data)}
61 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
62 getNb, er := w.GetNodeb(name)
64 assert.Equal(t, getNb.Ip, nb.Ip)
65 assert.Equal(t, getNb.Port, nb.Port)
66 assert.Equal(t, getNb.ConnectionStatus, nb.ConnectionStatus)
67 assert.Len(t, getNb.GetEnb().GetServedCells(), 1)
68 assert.Equal(t, getNb.GetEnb().GetServedCells()[0].Tac, nb.GetEnb().GetServedCells()[0].Tac)
71 func TestGetNodeBNotFoundFailure(t *testing.T) {
73 w, sdlInstanceMock := initSdlInstanceMock()
75 var ret map[string]interface{}
76 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
78 t.Errorf("#rNibReader_test.TestGetNodeBNotFoundFailure - failed to validate key parameter")
80 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
81 getNb, er := w.GetNodeb(name)
84 assert.IsType(t, &common.ResourceNotFoundError{}, er)
85 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.NodebInfo not found. Key: RAN:name", er.Error())
88 func TestGetNodeBUnmarshalFailure(t *testing.T) {
90 w, sdlInstanceMock := initSdlInstanceMock()
92 ret := make(map[string]interface{}, 1)
93 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
95 t.Errorf("#rNibReader_test.TestGetNodeBUnmarshalFailure - failed to validate key parameter")
97 ret[redisKey] = "data"
98 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
99 getNb, er := w.GetNodeb(name)
102 assert.IsType(t, &common.InternalError{}, er)
103 assert.Contains(t, er.Error(), "proto:")
106 func TestGetNodeBSdlgoFailure(t *testing.T) {
108 errMsg := "expected Sdlgo error"
109 errMsgExpected := "expected Sdlgo error"
110 w, sdlInstanceMock := initSdlInstanceMock()
111 e := errors.New(errMsg)
112 var ret map[string]interface{}
113 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
115 t.Errorf("#rNibReader_test.TestGetNodeBSdlgoFailure - failed to validate key parameter")
117 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
118 getNb, er := w.GetNodeb(name)
121 assert.IsType(t, &common.InternalError{}, er)
122 assert.EqualValues(t, errMsgExpected, er.Error())
125 func TestGetNodeBCellsListEnb(t *testing.T) {
127 w, sdlInstanceMock := initSdlInstanceMock()
128 nb := entities.NodebInfo{}
129 nb.ConnectionStatus = 1
132 enb := entities.Enb{}
133 cell := entities.ServedCellInfo{Tac: "tac"}
134 enb.ServedCells = []*entities.ServedCellInfo{&cell}
135 nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
137 data, err := proto.Marshal(&nb)
139 t.Errorf("#rNibReader_test.GetNodeBCellsList - Failed to marshal ENB instance. Error: %v", err)
141 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
143 t.Errorf("#rNibReader_test.TestGetNodeBCellsListEnb - failed to validate key parameter")
145 ret := map[string]interface{}{redisKey: string(data)}
146 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
147 cells, er := w.GetCellList(name)
149 assert.NotNil(t, cells)
150 assert.Len(t, cells.GetServedCellInfos().GetServedCells(), 1)
151 retCell := cells.GetServedCellInfos().GetServedCells()[0]
152 assert.Equal(t, retCell.Tac, "tac")
155 func TestGetNodeBCellsListGnb(t *testing.T) {
157 w, sdlInstanceMock := initSdlInstanceMock()
158 nb := entities.NodebInfo{}
159 nb.ConnectionStatus = 1
162 nb.NodeType = entities.Node_GNB
163 gnb := entities.Gnb{}
164 cell := entities.ServedNRCell{ServedNrCellInformation: &entities.ServedNRCellInformation{NrPci: 10}}
165 gnb.ServedNrCells = []*entities.ServedNRCell{&cell}
166 nb.Configuration = &entities.NodebInfo_Gnb{Gnb: &gnb}
168 data, err := proto.Marshal(&nb)
170 t.Errorf("#rNibReader_test.GetNodeBCellsList - Failed to marshal GNB instance. Error: %v", err)
172 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
174 t.Errorf("#rNibReader_test.TestGetNodeBCellsListGnb - failed to validate key parameter")
176 ret := map[string]interface{}{redisKey: string(data)}
177 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
178 cells, er := w.GetCellList(name)
180 assert.NotNil(t, cells)
181 assert.Len(t, cells.GetServedNrCells().GetServedCells(), 1)
182 retCell := cells.GetServedNrCells().GetServedCells()[0]
183 assert.Equal(t, retCell.GetServedNrCellInformation().GetNrPci(), uint32(10))
186 func TestGetNodeBCellsListNodeUnmarshalFailure(t *testing.T) {
188 w, sdlInstanceMock := initSdlInstanceMock()
190 ret := make(map[string]interface{}, 1)
191 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
193 t.Errorf("#rNibReader_test.TestGetNodeBCellsListNodeUnmarshalFailure - failed to validate key parameter")
195 ret[redisKey] = "data"
196 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
197 cells, er := w.GetCellList(name)
200 assert.IsType(t, &common.InternalError{}, er)
201 assert.Contains(t, er.Error(), "proto:")
204 func TestGetNodeBCellsListNodeNotFoundFailure(t *testing.T) {
206 w, sdlInstanceMock := initSdlInstanceMock()
208 var ret map[string]interface{}
209 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
211 t.Errorf("#rNibReader_test.TestGetNodeBCellsListNodeNotFoundFailure - failed to validate key parameter")
213 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
214 cells, er := w.GetCellList(name)
217 assert.IsType(t, &common.ResourceNotFoundError{}, er)
218 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.NodebInfo not found. Key: RAN:name", er.Error())
221 func TestGetNodeBCellsListNotFoundFailureEnb(t *testing.T) {
223 w, sdlInstanceMock := initSdlInstanceMock()
224 nb := entities.NodebInfo{}
225 nb.ConnectionStatus = 1
228 enb := entities.Enb{}
229 nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
231 data, err := proto.Marshal(&nb)
233 t.Errorf("#rNibReader_test.TestGetNbCellsListNotFoundFailure - Failed to marshal ENB instance. Error: %v", err)
235 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
237 t.Errorf("#rNibReader_test.TestGetNodeBCellsListNotFoundFailureEnb - failed to validate key parameter")
239 ret := map[string]interface{}{redisKey: string(data)}
240 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
241 _, er := w.GetCellList(name)
243 assert.EqualValues(t, "#rNibReader.GetCellList - served cells not found. Responding node RAN name: name.", er.Error())
246 func TestGetNodeBCellsListNotFoundFailureGnb(t *testing.T) {
248 w, sdlInstanceMock := initSdlInstanceMock()
249 nb := entities.NodebInfo{}
250 nb.ConnectionStatus = 1
253 gnb := entities.Gnb{}
254 nb.Configuration = &entities.NodebInfo_Gnb{Gnb: &gnb}
256 data, err := proto.Marshal(&nb)
258 t.Errorf("#rNibReader_test.TestGetNodeBCellsListNotFoundFailureGnb - Failed to marshal ENB instance. Error: %v", err)
260 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
262 t.Errorf("#rNibReader_test.TestGetNodeBCellsListNotFoundFailureGnb - failed to validate key parameter")
264 ret := map[string]interface{}{redisKey: string(data)}
265 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
266 _, er := w.GetCellList(name)
268 assert.EqualValues(t, "#rNibReader.GetCellList - served cells not found. Responding node RAN name: name.", er.Error())
271 func TestGetListGnbIdsUnmarshalFailure(t *testing.T) {
272 w, sdlInstanceMock := initSdlInstanceMock()
274 sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return([]string{"data"}, e)
275 ids, er := w.GetListGnbIds()
278 assert.IsType(t, &common.InternalError{}, er)
279 assert.Contains(t, er.Error(), "proto:")
282 func TestGetListGnbIdsSdlgoFailure(t *testing.T) {
283 errMsg := "expected Sdlgo error"
284 errMsgExpected := "expected Sdlgo error"
285 w, sdlInstanceMock := initSdlInstanceMock()
286 e := errors.New(errMsg)
288 sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return(data, e)
289 ids, er := w.GetListGnbIds()
292 assert.IsType(t, &common.InternalError{}, er)
293 assert.EqualValues(t, errMsgExpected, er.Error())
296 func TestGetListNodesIdsGnbSdlgoFailure(t *testing.T) {
297 w, sdlInstanceMock := initSdlInstanceMock()
302 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
304 data, err := proto.Marshal(nbIdentity)
306 t.Errorf("#rNibReader_test.TestGetListNodesIdsGnbSdlgoFailure - Failed to marshal nodeb identity entity. Error: %v", err)
308 sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{string(data)}, nilError)
310 errMsg := "expected Sdlgo error"
311 errMsgExpected := "expected Sdlgo error"
312 expectedError := errors.New(errMsg)
314 sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return(nilData, expectedError)
316 ids, er := w.GetListNodebIds()
319 assert.IsType(t, &common.InternalError{}, er)
320 assert.EqualValues(t, errMsgExpected, er.Error())
323 func TestGetListNodesIdsEnbSdlgoFailure(t *testing.T) {
324 w, sdlInstanceMock := initSdlInstanceMock()
329 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
331 data, err := proto.Marshal(nbIdentity)
333 t.Errorf("#rNibReader_test.TestGetListNodesIdsEnbSdlgoFailure - Failed to marshal nodeb identity entity. Error: %v", err)
335 sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return([]string{string(data)}, nilError)
337 errMsg := "expected Sdlgo error"
338 errMsgExpected := "expected Sdlgo error"
339 expectedError := errors.New(errMsg)
341 sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return(nilData, expectedError)
343 ids, er := w.GetListNodebIds()
346 assert.IsType(t, &common.InternalError{}, er)
347 assert.EqualValues(t, errMsgExpected, er.Error())
350 func TestGetListNodesIdsSuccess(t *testing.T) {
351 w, sdlInstanceMock := initSdlInstanceMock()
357 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
358 data, err := proto.Marshal(nbIdentity)
360 t.Errorf("#rNibReader_test.TestGetListNodesIdsSuccess - Failed to marshal nodeb identity entity. Error: %v", err)
366 nbIdentity1 := &entities.NbIdentity{InventoryName: name1, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId1, NbId: nbId1}}
367 data1, err := proto.Marshal(nbIdentity1)
369 t.Errorf("#rNibReader_test.TestGetListNodesIdsSuccess - Failed to marshal nodeb identity entity. Error: %v", err)
373 nbIdentity2 := &entities.NbIdentity{InventoryName: name2}
374 data2, err := proto.Marshal(nbIdentity2)
376 t.Errorf("#rNibReader_test.TestGetListNodesIdsSuccess - Failed to marshal nodeb identity entity. Error: %v", err)
379 sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return([]string{string(data)}, nilError)
380 sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{string(data1)}, nilError)
381 sdlInstanceMock.On("GetMembers", entities.Node_UNKNOWN.String()).Return([]string{string(data2)}, nilError)
383 ids, er := w.GetListNodebIds()
385 assert.NotNil(t, ids)
386 assert.Len(t, ids, 3)
389 func TestGetListEnbIdsUnmarshalFailure(t *testing.T) {
390 w, sdlInstanceMock := initSdlInstanceMock()
392 sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{"data"}, e)
393 ids, er := w.GetListEnbIds()
396 assert.IsType(t, &common.InternalError{}, er)
397 assert.Contains(t, er.Error(), "proto:")
400 func TestGetListEnbIdsOneId(t *testing.T) {
404 w, sdlInstanceMock := initSdlInstanceMock()
405 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
407 data, err := proto.Marshal(nbIdentity)
409 t.Errorf("#rNibReader_test.TestGetListEnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
411 sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{string(data)}, e)
412 ids, er := w.GetListEnbIds()
414 assert.Len(t, ids, 1)
415 assert.Equal(t, (ids)[0].GetInventoryName(), name)
416 assert.Equal(t, (ids)[0].GetGlobalNbId().GetPlmnId(), nbIdentity.GetGlobalNbId().GetPlmnId())
417 assert.Equal(t, (ids)[0].GetGlobalNbId().GetNbId(), nbIdentity.GetGlobalNbId().GetNbId())
420 func TestGetListEnbIdsNoIds(t *testing.T) {
421 w, sdlInstanceMock := initSdlInstanceMock()
423 sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{}, e)
424 ids, er := w.GetListEnbIds()
426 assert.Len(t, ids, 0)
429 func TestGetListEnbIds(t *testing.T) {
434 w, sdlInstanceMock := initSdlInstanceMock()
435 idsData := make([]string, listSize)
436 idsEntities := make([]*entities.NbIdentity, listSize)
437 for i := 0; i < listSize; i++ {
438 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: string(plmnId + i), NbId: string(nbId + i)}}
439 data, err := proto.Marshal(nbIdentity)
441 t.Errorf("#rNibReader_test.TestGetListEnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
443 idsData[i] = string(data)
444 idsEntities[i] = nbIdentity
447 sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return(idsData, e)
448 ids, er := w.GetListEnbIds()
450 assert.Len(t, ids, listSize)
451 for i, id := range ids {
452 assert.Equal(t, id.GetInventoryName(), name)
453 assert.Equal(t, id.GetGlobalNbId().GetPlmnId(), idsEntities[i].GetGlobalNbId().GetPlmnId())
454 assert.Equal(t, id.GetGlobalNbId().GetNbId(), idsEntities[i].GetGlobalNbId().GetNbId())
458 func TestGetListGnbIdsOneId(t *testing.T) {
462 w, sdlInstanceMock := initSdlInstanceMock()
463 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
465 data, err := proto.Marshal(nbIdentity)
467 t.Errorf("#rNibReader_test.TestGetListGnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
469 sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return([]string{string(data)}, e)
470 ids, er := w.GetListGnbIds()
472 assert.Len(t, ids, 1)
473 assert.Equal(t, (ids)[0].GetInventoryName(), name)
474 assert.Equal(t, (ids)[0].GetGlobalNbId().GetPlmnId(), nbIdentity.GetGlobalNbId().GetPlmnId())
475 assert.Equal(t, (ids)[0].GetGlobalNbId().GetNbId(), nbIdentity.GetGlobalNbId().GetNbId())
478 func TestGetListGnbIdsNoIds(t *testing.T) {
479 w, sdlInstanceMock := initSdlInstanceMock()
481 sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return([]string{}, e)
482 ids, er := w.GetListGnbIds()
484 assert.Len(t, ids, 0)
487 func TestGetListGnbIds(t *testing.T) {
492 w, sdlInstanceMock := initSdlInstanceMock()
493 idsData := make([]string, listSize)
494 idsEntities := make([]*entities.NbIdentity, listSize)
495 for i := 0; i < listSize; i++ {
496 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: string(plmnId + i), NbId: string(nbId + i)}}
497 data, err := proto.Marshal(nbIdentity)
499 t.Errorf("#rNibReader_test.TestGetListGnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
501 idsData[i] = string(data)
502 idsEntities[i] = nbIdentity
505 sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return(idsData, e)
506 ids, er := w.GetListGnbIds()
508 assert.Len(t, ids, listSize)
509 for i, id := range ids {
510 assert.Equal(t, id.GetInventoryName(), name)
511 assert.Equal(t, id.GetGlobalNbId().GetPlmnId(), idsEntities[i].GetGlobalNbId().GetPlmnId())
512 assert.Equal(t, id.GetGlobalNbId().GetNbId(), idsEntities[i].GetGlobalNbId().GetNbId())
516 func TestGetListEnbIdsSdlgoFailure(t *testing.T) {
517 errMsg := "expected Sdlgo error"
518 errMsgExpected := "expected Sdlgo error"
519 w, sdlInstanceMock := initSdlInstanceMock()
520 e := errors.New(errMsg)
522 sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return(data, e)
523 ids, er := w.GetListEnbIds()
526 assert.IsType(t, &common.InternalError{}, er)
527 assert.EqualValues(t, errMsgExpected, er.Error())
530 func TestGetCountGnbListOneId(t *testing.T) {
531 w, sdlInstanceMock := initSdlInstanceMock()
533 sdlInstanceMock.On("GroupSize", entities.Node_GNB.String()).Return(1, e)
534 count, er := w.GetCountGnbList()
536 assert.Equal(t, count, 1)
539 func TestGetCountGnbList(t *testing.T) {
540 w, sdlInstanceMock := initSdlInstanceMock()
542 sdlInstanceMock.On("GroupSize", entities.Node_GNB.String()).Return(3, e)
543 count, er := w.GetCountGnbList()
545 assert.Equal(t, count, 3)
548 func TestGetCountGnbListSdlgoFailure(t *testing.T) {
549 errMsg := "expected Sdlgo error"
550 errMsgExpected := "expected Sdlgo error"
551 w, sdlInstanceMock := initSdlInstanceMock()
552 e := errors.New(errMsg)
554 sdlInstanceMock.On("GroupSize", entities.Node_GNB.String()).Return(count, e)
555 count, er := w.GetCountGnbList()
557 assert.Equal(t, 0, count)
558 assert.IsType(t, &common.InternalError{}, er)
559 assert.EqualValues(t, errMsgExpected, er.Error())
562 func TestGetCell(t *testing.T) {
565 w, sdlInstanceMock := initSdlInstanceMock()
566 cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: &entities.ServedCellInfo{Pci: pci}}}
567 cellData, err := proto.Marshal(&cellEntity)
569 t.Errorf("#rNibReader_test.TestGetCell - Failed to marshal Cell entity. Error: %v", err)
572 key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
574 t.Errorf("#rNibReader_test.TestGetCell - failed to validate key parameter")
576 ret := map[string]interface{}{key: string(cellData)}
577 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
578 cell, er := w.GetCell(name, pci)
580 assert.NotNil(t, cell)
581 assert.Equal(t, cell.Type, entities.Cell_LTE_CELL)
582 assert.NotNil(t, cell.GetServedCellInfo())
583 assert.Equal(t, cell.GetServedCellInfo().GetPci(), pci)
586 func TestGetCellNotFoundFailure(t *testing.T) {
589 w, sdlInstanceMock := initSdlInstanceMock()
591 var ret map[string]interface{}
592 key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
594 t.Errorf("#rNibReader_test.TestGetCellNotFoundFailure - failed to validate key parameter")
596 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
597 cell, er := w.GetCell(name, pci)
600 assert.IsType(t, &common.ResourceNotFoundError{}, er)
601 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.Cell not found. Key: PCI:name:00", er.Error())
604 func TestGetCellUnmarshalFailure(t *testing.T) {
607 w, sdlInstanceMock := initSdlInstanceMock()
609 ret := make(map[string]interface{}, 1)
610 key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
612 t.Errorf("#rNibReader_test.TestGetCellUnmarshalFailure - failed to validate key parameter")
615 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
616 cell, er := w.GetCell(name, pci)
619 assert.IsType(t, &common.InternalError{}, er)
620 assert.Contains(t, er.Error(), "proto:")
623 func TestGetCellSdlgoFailure(t *testing.T) {
626 errMsg := "expected Sdlgo error"
627 errMsgExpected := "expected Sdlgo error"
628 w, sdlInstanceMock := initSdlInstanceMock()
629 e := errors.New(errMsg)
630 var ret map[string]interface{}
631 key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
633 t.Errorf("#rNibReader_test.TestGetCellSdlgoFailure - failed to validate key parameter")
635 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
636 cell, er := w.GetCell(name, pci)
639 assert.IsType(t, &common.InternalError{}, er)
640 assert.EqualValues(t, errMsgExpected, er.Error())
643 func TestGetNodebById(t *testing.T) {
644 w, sdlInstanceMock := initSdlInstanceMock()
645 nb := entities.NodebInfo{NodeType: entities.Node_ENB}
646 nb.ConnectionStatus = 1
649 enb := entities.Enb{}
650 cell := entities.ServedCellInfo{Tac: "tac"}
651 enb.ServedCells = []*entities.ServedCellInfo{&cell}
652 nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
654 data, err := proto.Marshal(&nb)
656 t.Errorf("#rNibReader_test.TestGetNodebById - Failed to marshal ENB instance. Error: %v", err)
661 key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_ENB.String(), plmnId, nbId)
663 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
665 ret := map[string]interface{}{key: string(data)}
666 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
667 globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
668 getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
670 assert.Equal(t, getNb.Ip, nb.Ip)
671 assert.Equal(t, getNb.Port, nb.Port)
672 assert.Equal(t, getNb.ConnectionStatus, nb.ConnectionStatus)
673 assert.Len(t, getNb.GetEnb().GetServedCells(), 1)
674 assert.Equal(t, getNb.GetEnb().GetServedCells()[0].Tac, nb.GetEnb().GetServedCells()[0].Tac)
677 func TestGetNodebByIdNotFoundFailureEnb(t *testing.T) {
680 w, sdlInstanceMock := initSdlInstanceMock()
682 key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_ENB.String(), plmnId, nbId)
684 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
686 var ret map[string]interface{}
687 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
688 globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
689 getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
692 assert.IsType(t, &common.ResourceNotFoundError{}, er)
693 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.NodebInfo not found. Key: ENB:02f829:4a952a0a", er.Error())
696 func TestGetNodebByIdNotFoundFailureGnb(t *testing.T) {
699 w, sdlInstanceMock := initSdlInstanceMock()
701 key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_GNB.String(), plmnId, nbId)
703 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
705 var ret map[string]interface{}
706 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
707 globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
708 getNb, er := w.GetNodebByGlobalNbId(entities.Node_GNB, globalNbId)
711 assert.IsType(t, &common.ResourceNotFoundError{}, er)
712 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.NodebInfo not found. Key: GNB:02f829:4a952a0a", er.Error())
715 func TestGetNodeByIdUnmarshalFailure(t *testing.T) {
718 w, sdlInstanceMock := initSdlInstanceMock()
719 key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_ENB.String(), plmnId, nbId)
721 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
724 ret := make(map[string]interface{}, 1)
726 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
727 globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
728 getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
731 assert.IsType(t, &common.InternalError{}, er)
732 assert.Contains(t, er.Error(), "proto:")
735 func TestGetNodeByIdSdlgoFailure(t *testing.T) {
738 errMsg := "expected Sdlgo error"
739 errMsgExpected := "expected Sdlgo error"
740 w, sdlInstanceMock := initSdlInstanceMock()
741 key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_GNB.String(), plmnId, nbId)
743 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
745 e := errors.New(errMsg)
746 var ret map[string]interface{}
747 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
748 globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
749 getNb, er := w.GetNodebByGlobalNbId(entities.Node_GNB, globalNbId)
752 assert.IsType(t, &common.InternalError{}, er)
753 assert.EqualValues(t, errMsgExpected, er.Error())
756 func TestGetCellById(t *testing.T) {
759 w, sdlInstanceMock := initSdlInstanceMock()
760 cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: &entities.ServedCellInfo{Pci: pci}}}
761 cellData, err := proto.Marshal(&cellEntity)
763 t.Errorf("#rNibReader_test.TestGetCellById - Failed to marshal Cell entity. Error: %v", err)
766 key, rNibErr := common.ValidateAndBuildCellIdKey(cellId)
768 t.Errorf("#rNibReader_test.TestGetCellById - failed to validate key parameter")
770 ret := map[string]interface{}{key: string(cellData)}
771 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
772 cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
774 assert.NotNil(t, cell)
775 assert.Equal(t, cell.Type, entities.Cell_LTE_CELL)
776 assert.NotNil(t, cell.GetServedCellInfo())
777 assert.Equal(t, cell.GetServedCellInfo().GetPci(), pci)
780 func TestGetCellByIdNotFoundFailureEnb(t *testing.T) {
782 w, sdlInstanceMock := initSdlInstanceMock()
784 var ret map[string]interface{}
785 key, rNibErr := common.ValidateAndBuildCellIdKey(cellId)
787 t.Errorf("#rNibReader_test.TestGetCellByIdNotFoundFailure - failed to validate key parameter")
789 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
790 cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
793 assert.IsType(t, &common.ResourceNotFoundError{}, er)
794 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.Cell not found. Key: CELL:bbbb", er.Error())
797 func TestGetCellByIdNotFoundFailureGnb(t *testing.T) {
799 w, sdlInstanceMock := initSdlInstanceMock()
801 var ret map[string]interface{}
802 key, rNibErr := common.ValidateAndBuildNrCellIdKey(cellId)
804 t.Errorf("#rNibReader_test.TestGetCellByIdNotFoundFailure - failed to validate key parameter")
806 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
807 cell, er := w.GetCellById(entities.Cell_NR_CELL, cellId)
810 assert.IsType(t, &common.ResourceNotFoundError{}, er)
811 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.Cell not found. Key: NRCELL:bbbb", er.Error())
814 func TestGetCellByIdTypeValidationFailure(t *testing.T) {
816 w, _ := initSdlInstanceMock()
817 cell, er := w.GetCellById(5, cellId)
820 assert.IsType(t, &common.ValidationError{}, er)
821 assert.EqualValues(t, "#rNibReader.GetCellById - invalid cell type: 5", er.Error())
824 func TestGetCellByIdValidationFailureGnb(t *testing.T) {
826 w, _ := initSdlInstanceMock()
827 cell, er := w.GetCellById(entities.Cell_NR_CELL, cellId)
830 assert.IsType(t, &common.ValidationError{}, er)
831 assert.EqualValues(t, "#utils.ValidateAndBuildNrCellIdKey - an empty cell id received", er.Error())
834 func TestGetCellByIdValidationFailureEnb(t *testing.T) {
836 w, _ := initSdlInstanceMock()
837 cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
840 assert.IsType(t, &common.ValidationError{}, er)
841 assert.EqualValues(t, "#utils.ValidateAndBuildCellIdKey - an empty cell id received", er.Error())
844 func TestGetRanLoadInformation(t *testing.T) {
846 w, sdlInstanceMock := initSdlInstanceMock()
847 loadInfo := generateRanLoadInformation()
849 data, err := proto.Marshal(loadInfo)
851 t.Errorf("#rNibReader_test.TestGetRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
853 redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
855 t.Errorf("#rNibReader_test.TestGetRanLoadInformationNotFoundFailure - failed to validate key parameter")
857 ret := map[string]interface{}{redisKey: string(data)}
858 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
859 getLoadInfo, er := w.GetRanLoadInformation(name)
861 assert.NotNil(t, getLoadInfo)
862 expected, err := json.Marshal(loadInfo)
864 t.Errorf("#rNibReader_test.TestGetRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
866 actual, err := json.Marshal(getLoadInfo)
868 t.Errorf("#rNibReader_test.TestGetRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
870 assert.EqualValues(t, expected, actual)
873 func TestGetRanLoadInformationValidationFailure(t *testing.T) {
875 w, _ := initSdlInstanceMock()
876 getNb, er := w.GetRanLoadInformation(name)
879 assert.IsType(t, &common.ValidationError{}, er)
880 assert.EqualValues(t, "#utils.ValidateAndBuildRanLoadInformationKey - an empty inventory name received", er.Error())
883 func TestGetRanLoadInformationNotFoundFailure(t *testing.T) {
885 w, sdlInstanceMock := initSdlInstanceMock()
887 var ret map[string]interface{}
888 redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
890 t.Errorf("#rNibReader_test.TestGetRanLoadInformationNotFoundFailure - failed to validate key parameter")
892 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
893 getNb, er := w.GetRanLoadInformation(name)
896 assert.IsType(t, &common.ResourceNotFoundError{}, er)
897 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.RanLoadInformation not found. Key: LOAD:name", er.Error())
900 func TestGetRanLoadInformationUnmarshalFailure(t *testing.T) {
902 w, sdlInstanceMock := initSdlInstanceMock()
904 ret := make(map[string]interface{}, 1)
905 redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
907 t.Errorf("#rNibReader_test.TestGetRanLoadInformationUnmarshalFailure - failed to validate key parameter")
909 ret[redisKey] = "data"
910 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
911 getNb, er := w.GetRanLoadInformation(name)
914 assert.IsType(t, &common.InternalError{}, er)
915 assert.Contains(t, er.Error(), "proto:")
918 func TestGetRanLoadInformationSdlgoFailure(t *testing.T) {
920 errMsg := "expected Sdlgo error"
921 errMsgExpected := "expected Sdlgo error"
922 w, sdlInstanceMock := initSdlInstanceMock()
923 e := errors.New(errMsg)
924 var ret map[string]interface{}
925 redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
927 t.Errorf("#rNibReader_test.TestGetRanLoadInformationSdlgoFailure - failed to validate key parameter")
929 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
930 getNb, er := w.GetRanLoadInformation(name)
933 assert.IsType(t, &common.InternalError{}, er)
934 assert.EqualValues(t, errMsgExpected, er.Error())
937 func generateCellLoadInformation() *entities.CellLoadInformation {
938 cellLoadInformation := entities.CellLoadInformation{}
940 cellLoadInformation.CellId = "123"
942 ulInterferenceOverloadIndication := entities.UlInterferenceOverloadIndication_HIGH_INTERFERENCE
943 cellLoadInformation.UlInterferenceOverloadIndications = []entities.UlInterferenceOverloadIndication{ulInterferenceOverloadIndication}
945 ulHighInterferenceInformation := entities.UlHighInterferenceInformation{
947 UlHighInterferenceIndication: "xxx",
950 cellLoadInformation.UlHighInterferenceInfos = []*entities.UlHighInterferenceInformation{&ulHighInterferenceInformation}
952 cellLoadInformation.RelativeNarrowbandTxPower = &entities.RelativeNarrowbandTxPower{
954 RntpThreshold: entities.RntpThreshold_NEG_4,
955 NumberOfCellSpecificAntennaPorts: entities.NumberOfCellSpecificAntennaPorts_V1_ANT_PRT,
957 PdcchInterferenceImpact: 2,
958 EnhancedRntp: &entities.EnhancedRntp{
959 EnhancedRntpBitmap: "xxx",
960 RntpHighPowerThreshold: entities.RntpThreshold_NEG_2,
961 EnhancedRntpStartTime: &entities.StartTime{StartSfn: 500, StartSubframeNumber: 5},
965 cellLoadInformation.AbsInformation = &entities.AbsInformation{
966 Mode: entities.AbsInformationMode_ABS_INFO_FDD,
967 AbsPatternInfo: "xxx",
968 NumberOfCellSpecificAntennaPorts: entities.NumberOfCellSpecificAntennaPorts_V2_ANT_PRT,
969 MeasurementSubset: "xxx",
972 cellLoadInformation.InvokeIndication = entities.InvokeIndication_ABS_INFORMATION
974 cellLoadInformation.ExtendedUlInterferenceOverloadInfo = &entities.ExtendedUlInterferenceOverloadInfo{
975 AssociatedSubframes: "xxx",
976 ExtendedUlInterferenceOverloadIndications: cellLoadInformation.UlInterferenceOverloadIndications,
979 compInformationItem := &entities.CompInformationItem{
980 CompHypothesisSets: []*entities.CompHypothesisSet{{CellId: "789", CompHypothesis: "xxx"}},
984 cellLoadInformation.CompInformation = &entities.CompInformation{
985 CompInformationItems: []*entities.CompInformationItem{compInformationItem},
986 CompInformationStartTime: &entities.StartTime{StartSfn: 123, StartSubframeNumber: 456},
989 cellLoadInformation.DynamicDlTransmissionInformation = &entities.DynamicDlTransmissionInformation{
990 State: entities.NaicsState_NAICS_ACTIVE,
991 TransmissionModes: "xxx",
993 PAList: []entities.PA{entities.PA_DB_NEG_3},
996 return &cellLoadInformation
999 func generateRanLoadInformation() *entities.RanLoadInformation {
1000 ranLoadInformation := entities.RanLoadInformation{}
1002 ranLoadInformation.LoadTimestamp = uint64(time.Now().UnixNano())
1004 cellLoadInformation := generateCellLoadInformation()
1005 ranLoadInformation.CellLoadInfos = []*entities.CellLoadInformation{cellLoadInformation}
1007 return &ranLoadInformation
1010 func TestGetE2TInstanceSuccess(t *testing.T) {
1011 address := "10.10.2.15:9800"
1012 redisKey, validationErr := common.ValidateAndBuildE2TInstanceKey(address)
1014 if validationErr != nil {
1015 t.Errorf("#rNibReader_test.TestGetE2TInstanceSuccess - Failed to build E2T Instance key. Error: %v", validationErr)
1018 w, sdlInstanceMock := initSdlInstanceMock()
1020 e2tInstance := generateE2tInstance(address)
1021 data, err := json.Marshal(e2tInstance)
1024 t.Errorf("#rNibReader_test.TestGetE2TInstanceSuccess - Failed to marshal E2tInstance entity. Error: %v", err)
1028 ret := map[string]interface{}{redisKey: string(data)}
1029 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
1031 res, rNibErr := w.GetE2TInstance(address)
1032 assert.Nil(t, rNibErr)
1033 assert.Equal(t, e2tInstance, res)
1036 func TestUnmarshal(t *testing.T) {
1037 e2tInstance := generateE2tInstance("10.0.2.15:5555")
1038 marshaled, _ := json.Marshal(e2tInstance)
1039 m := map[string]interface{}{
1040 "whatever": string(marshaled),
1042 var entity entities.E2TInstance
1043 err := json.Unmarshal([]byte(m["whatever"].(string)), &entity)
1047 func TestGetE2TInstanceEmptyAddressFailure(t *testing.T) {
1048 w, _ := initSdlInstanceMock()
1049 res, err := w.GetE2TInstance("")
1050 assert.NotNil(t, err)
1051 assert.IsType(t, &common.ValidationError{}, err)
1055 func TestGetE2TInstanceSdlError(t *testing.T) {
1056 address := "10.10.2.15:9800"
1057 redisKey, validationErr := common.ValidateAndBuildE2TInstanceKey(address)
1059 if validationErr != nil {
1060 t.Errorf("#rNibReader_test.TestGetE2TInstanceSuccess - Failed to build E2T Instance key. Error: %v", validationErr)
1063 w, sdlInstanceMock := initSdlInstanceMock()
1065 expectedErr := errors.New("expected error")
1066 var ret map[string]interface{}
1067 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, expectedErr)
1069 res, rNibErr := w.GetE2TInstance(address)
1070 assert.NotNil(t, rNibErr)
1074 func generateE2tInstance(address string) *entities.E2TInstance {
1075 e2tInstance := entities.NewE2TInstance(address,"")
1076 e2tInstance.AssociatedRanList = []string{"test1", "test2"}
1077 e2tInstance.DeletionTimestamp = time.Now().UnixNano()
1081 func TestGetE2TAddressesSdlError(t *testing.T) {
1082 w, sdlInstanceMock := initSdlInstanceMock()
1084 expectedErr := errors.New("expected error")
1085 var ret map[string]interface{}
1086 sdlInstanceMock.On("Get", []string{E2TAddressesKey}).Return(ret, expectedErr)
1088 res, rNibErr := w.GetE2TAddresses()
1089 assert.NotNil(t, rNibErr)
1093 func TestGetE2TAddressesSuccess(t *testing.T) {
1094 address := "10.10.2.15:9800"
1095 w, sdlInstanceMock := initSdlInstanceMock()
1097 e2tAddresses := []string{address}
1098 data, err := json.Marshal(e2tAddresses)
1101 t.Errorf("#rNibReader_test.TestGetE2TInfoListSuccess - Failed to marshal E2TInfoList. Error: %v", err)
1105 ret := map[string]interface{}{E2TAddressesKey: string(data)}
1106 sdlInstanceMock.On("Get", []string{E2TAddressesKey}).Return(ret, e)
1108 res, rNibErr := w.GetE2TAddresses()
1109 assert.Nil(t, rNibErr)
1110 assert.Equal(t, e2tAddresses, res)
1113 func TestGetE2TInstancesSuccess(t *testing.T) {
1114 address := "10.10.2.15:9800"
1115 address2 := "10.10.2.16:9800"
1116 redisKey, _ := common.ValidateAndBuildE2TInstanceKey(address)
1117 redisKey2, _ := common.ValidateAndBuildE2TInstanceKey(address2)
1119 w, sdlInstanceMock := initSdlInstanceMock()
1121 e2tInstance1 := generateE2tInstance(address)
1122 e2tInstance2 := generateE2tInstance(address2)
1124 data1, _ := json.Marshal(e2tInstance1)
1125 data2, _ := json.Marshal(e2tInstance2)
1128 ret := map[string]interface{}{redisKey: string(data1), redisKey2: string(data2)}
1129 sdlInstanceMock.On("Get", []string{redisKey, redisKey2}).Return(ret, e)
1131 res, err := w.GetE2TInstances([]string{address, address2})
1133 assert.Equal(t, []*entities.E2TInstance{e2tInstance1, e2tInstance2}, res)
1136 func TestGetE2TInstancesUnmarhalPartialSuccess(t *testing.T) {
1137 address := "10.10.2.15:9800"
1138 address2 := "10.10.2.16:9800"
1139 redisKey, _ := common.ValidateAndBuildE2TInstanceKey(address)
1140 redisKey2, _ := common.ValidateAndBuildE2TInstanceKey(address2)
1142 w, sdlInstanceMock := initSdlInstanceMock()
1144 e2tInstance1 := generateE2tInstance(address)
1145 data1, _ := json.Marshal(e2tInstance1)
1148 ret := map[string]interface{}{redisKey: string(data1), redisKey2: "abc"}
1149 sdlInstanceMock.On("Get", []string{redisKey, redisKey2}).Return(ret, e)
1151 res, err := w.GetE2TInstances([]string{address, address2})
1153 assert.Equal(t, []*entities.E2TInstance{e2tInstance1}, res)
1156 func TestGetE2TInstancesSdlFailure(t *testing.T) {
1157 address := "10.10.2.15:9800"
1158 address2 := "10.10.2.16:9800"
1159 redisKey, _ := common.ValidateAndBuildE2TInstanceKey(address)
1160 redisKey2, _ := common.ValidateAndBuildE2TInstanceKey(address2)
1162 w, sdlInstanceMock := initSdlInstanceMock()
1164 sdlInstanceMock.On("Get", []string{redisKey, redisKey2}).Return(map[string]interface{}{}, fmt.Errorf(""))
1165 _, err := w.GetE2TInstances([]string{address, address2})
1166 assert.IsType(t, &common.InternalError{}, err)
1169 func TestGetE2TInstancesEmptyData(t *testing.T) {
1170 address := "10.10.2.15:9800"
1171 address2 := "10.10.2.16:9800"
1172 redisKey, _ := common.ValidateAndBuildE2TInstanceKey(address)
1173 redisKey2, _ := common.ValidateAndBuildE2TInstanceKey(address2)
1175 w, sdlInstanceMock := initSdlInstanceMock()
1177 sdlInstanceMock.On("Get", []string{redisKey, redisKey2}).Return(map[string]interface{}{}, nil)
1178 _, err := w.GetE2TInstances([]string{address, address2})
1179 assert.IsType(t, &common.ResourceNotFoundError{}, err)
1182 func TestGetGeneralConfiguration(t *testing.T) {
1184 key := common.BuildGeneralConfigurationKey()
1185 w, sdlInstanceMock := initSdlInstanceMock()
1187 configurationData := "{\"enableRic\":true}"
1188 sdlInstanceMock.On("Get", []string{key}).Return(map[string]interface{}{key: configurationData}, nil)
1190 res, rNibErr := w.GetGeneralConfiguration()
1191 assert.Nil(t, rNibErr)
1192 assert.Equal(t, true, res.EnableRic)
1195 func TestGetGeneralConfigurationNotFound(t *testing.T) {
1197 key := common.BuildGeneralConfigurationKey()
1198 w, sdlInstanceMock := initSdlInstanceMock()
1200 sdlInstanceMock.On("Get", []string{key}).Return(map[string]interface{}{}, nil)
1202 _, rNibErr := w.GetGeneralConfiguration()
1204 assert.NotNil(t, rNibErr)
1205 assert.Equal(t, "#rNibReader.getByKeyAndUnmarshalJson - entity of type *entities.GeneralConfiguration not found. Key: GENERAL", rNibErr.Error())
1208 func TestGetGeneralConfigurationSdlFailure(t *testing.T) {
1210 key := common.BuildGeneralConfigurationKey()
1211 w, sdlInstanceMock := initSdlInstanceMock()
1213 sdlInstanceMock.On("Get", []string{key}).Return(map[string]interface{}{}, fmt.Errorf("sdl error"))
1215 _, rNibErr := w.GetGeneralConfiguration()
1217 assert.NotNil(t, rNibErr)
1219 assert.Equal(t, "sdl error", rNibErr.Error())
1222 func TestGetGeneralConfigurationUnmarshalError(t *testing.T) {
1224 key := common.BuildGeneralConfigurationKey()
1225 w, sdlInstanceMock := initSdlInstanceMock()
1227 configurationData := "{\"enableRic :true}"
1228 sdlInstanceMock.On("Get", []string{key}).Return(map[string]interface{}{key: configurationData}, nil)
1230 _, rNibErr := w.GetGeneralConfiguration()
1232 assert.NotNil(t, rNibErr)
1233 assert.Equal(t, rNibErr.Error(), "unexpected end of JSON input")
1238 //func TestGetEnbInteg(t *testing.T){
1239 // name := "nameEnb1"
1240 // Init("namespace", 1)
1241 // w := GetRNibReader()
1242 // nb, err := w.GetNodeb(name)
1246 // fmt.Printf("#TestGetEnbInteg - responding node type: %v\n", nb)
1250 //func TestGetEnbCellsInteg(t *testing.T){
1251 // name := "nameEnb1"
1252 // Init("namespace", 1)
1253 // w := GetRNibReader()
1254 // cells, err := w.GetCellList(name)
1257 // } else if cells != nil{
1258 // for _, cell := range cells.GetServedCellInfos().ServedCells{
1259 // fmt.Printf("responding node type Cell: %v\n", *cell)
1264 //func TestGetGnbInteg(t *testing.T){
1265 // name := "nameGnb1"
1266 // Init("namespace", 1)
1267 // w := GetRNibReader()
1268 // nb, err := w.GetNodeb(name)
1272 // fmt.Printf("#TestGetGnbInteg - responding node type: %v\n", nb)
1276 //func TestGetGnbCellsInteg(t *testing.T){
1277 // name := "nameGnb1"
1278 // Init("namespace", 1)
1279 // w := GetRNibReader()
1280 // cells, err := w.GetCellList(name)
1283 // } else if cells != nil{
1284 // for _, cell := range cells.GetServedNrCells().ServedCells{
1285 // fmt.Printf("responding node type NR Cell: %v\n", *cell)
1290 //func TestGetListEnbIdsInteg(t *testing.T) {
1291 // Init("namespace", 1)
1292 // w := GetRNibReader()
1293 // ids, err := w.GetListEnbIds()
1297 // for _, id := range ids{
1298 // fmt.Printf("#TestGetListEnbIdsInteg - ENB ID: %s\n", id)
1303 //func TestGetListGnbIdsInteg(t *testing.T) {
1304 // Init("namespace", 1)
1305 // w := GetRNibReader()
1306 // ids, err := w.GetListGnbIds()
1310 // for _, id := range ids{
1311 // fmt.Printf("#TestGetListGnbIdsInteg - GNB ID: %s\n", id)
1316 //func TestGetCountGnbListInteg(t *testing.T) {
1317 // Init("namespace", 1)
1318 // w := GetRNibReader()
1319 // count, err := w.GetCountGnbList()
1323 // fmt.Printf("#TestGetCountGnbListInteg - count Gnb list: %d\n", count)
1327 //func TestGetGnbCellInteg(t *testing.T){
1328 // name := "nameGnb7"
1330 // Init("namespace", 1)
1331 // w := GetRNibReader()
1332 // cell, err := w.GetCell(name, uint32(pci))
1335 // } else if cell != nil{
1336 // fmt.Printf("responding node type NR Cell: %v\n", cell.GetServedNrCell())
1340 //func TestGetEnbCellInteg(t *testing.T) {
1341 // name := "nameEnb1"
1343 // Init("namespace", 1)
1344 // w := GetRNibReader()
1345 // cell, err := w.GetCell(name, uint32(pci))
1348 // } else if cell != nil {
1349 // fmt.Printf("responding node type LTE Cell: %v\n", cell.GetServedCellInfo())
1353 //func TestGetEnbCellByIdInteg(t *testing.T){
1354 // Init("namespace", 1)
1355 // w := GetRNibReader()
1356 // cell, err := w.GetCellById(entities.Cell_NR_CELL, "45d")
1359 // } else if cell != nil{
1360 // fmt.Printf("responding node type NR Cell: %v\n", cell.GetServedNrCell())
1364 //func TestGetListNbIdsInteg(t *testing.T) {
1365 // Init("e2Manager", 1)
1366 // w := GetRNibReader()
1367 // ids, err := w.GetListNodebIds()
1371 // for _, id := range ids{
1372 // fmt.Printf("#TestGetListGnbIdsInteg - NB ID: %s\n", id)
1377 //func TestGetRanLoadInformationInteg(t *testing.T){
1378 // Init("e2Manager", 1)
1379 // w := GetRNibReader()
1380 // ranLoadInformation, err := w.GetRanLoadInformation("ran_integ")
1382 // t.Errorf("#rNibReader_test.TestGetRanLoadInformationInteg - Failed to get RanLoadInformation entity. Error: %v", err)
1384 // assert.NotNil(t, ranLoadInformation)
1385 // fmt.Printf("#rNibReader_test.TestGetRanLoadInformationInteg - GNB ID: %s\n", ranLoadInformation)
1388 //func TestGetE2TInstancesInteg(t *testing.T) {
1389 // db := sdlgo.NewDatabase()
1390 // sdl := sdlgo.NewSdlInstance("e2Manager", db)
1391 // rnibReader := GetRNibReader(sdl)
1392 // e2tInstances, _ := rnibReader.GetE2TInstances([]string{"e2t.att.com:38000","whatever"})
1393 // assert.Len(t, e2tInstances, 1)