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)
372 sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return([]string{string(data)}, nilError)
373 sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{string(data1)}, nilError)
375 ids, er := w.GetListNodebIds()
377 assert.NotNil(t, ids)
378 assert.Len(t, ids, 2)
381 func TestGetListEnbIdsUnmarshalFailure(t *testing.T) {
382 w, sdlInstanceMock := initSdlInstanceMock()
384 sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{"data"}, e)
385 ids, er := w.GetListEnbIds()
388 assert.IsType(t, &common.InternalError{}, er)
389 assert.Contains(t, er.Error(), "proto:")
392 func TestGetListEnbIdsOneId(t *testing.T) {
396 w, sdlInstanceMock := initSdlInstanceMock()
397 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
399 data, err := proto.Marshal(nbIdentity)
401 t.Errorf("#rNibReader_test.TestGetListEnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
403 sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{string(data)}, e)
404 ids, er := w.GetListEnbIds()
406 assert.Len(t, ids, 1)
407 assert.Equal(t, (ids)[0].GetInventoryName(), name)
408 assert.Equal(t, (ids)[0].GetGlobalNbId().GetPlmnId(), nbIdentity.GetGlobalNbId().GetPlmnId())
409 assert.Equal(t, (ids)[0].GetGlobalNbId().GetNbId(), nbIdentity.GetGlobalNbId().GetNbId())
412 func TestGetListEnbIdsNoIds(t *testing.T) {
413 w, sdlInstanceMock := initSdlInstanceMock()
415 sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{}, e)
416 ids, er := w.GetListEnbIds()
418 assert.Len(t, ids, 0)
421 func TestGetListEnbIds(t *testing.T) {
426 w, sdlInstanceMock := initSdlInstanceMock()
427 idsData := make([]string, listSize)
428 idsEntities := make([]*entities.NbIdentity, listSize)
429 for i := 0; i < listSize; i++ {
430 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: string(plmnId + i), NbId: string(nbId + i)}}
431 data, err := proto.Marshal(nbIdentity)
433 t.Errorf("#rNibReader_test.TestGetListEnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
435 idsData[i] = string(data)
436 idsEntities[i] = nbIdentity
439 sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return(idsData, e)
440 ids, er := w.GetListEnbIds()
442 assert.Len(t, ids, listSize)
443 for i, id := range ids {
444 assert.Equal(t, id.GetInventoryName(), name)
445 assert.Equal(t, id.GetGlobalNbId().GetPlmnId(), idsEntities[i].GetGlobalNbId().GetPlmnId())
446 assert.Equal(t, id.GetGlobalNbId().GetNbId(), idsEntities[i].GetGlobalNbId().GetNbId())
450 func TestGetListGnbIdsOneId(t *testing.T) {
454 w, sdlInstanceMock := initSdlInstanceMock()
455 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
457 data, err := proto.Marshal(nbIdentity)
459 t.Errorf("#rNibReader_test.TestGetListGnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
461 sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return([]string{string(data)}, e)
462 ids, er := w.GetListGnbIds()
464 assert.Len(t, ids, 1)
465 assert.Equal(t, (ids)[0].GetInventoryName(), name)
466 assert.Equal(t, (ids)[0].GetGlobalNbId().GetPlmnId(), nbIdentity.GetGlobalNbId().GetPlmnId())
467 assert.Equal(t, (ids)[0].GetGlobalNbId().GetNbId(), nbIdentity.GetGlobalNbId().GetNbId())
470 func TestGetListGnbIdsNoIds(t *testing.T) {
471 w, sdlInstanceMock := initSdlInstanceMock()
473 sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return([]string{}, e)
474 ids, er := w.GetListGnbIds()
476 assert.Len(t, ids, 0)
479 func TestGetListGnbIds(t *testing.T) {
484 w, sdlInstanceMock := initSdlInstanceMock()
485 idsData := make([]string, listSize)
486 idsEntities := make([]*entities.NbIdentity, listSize)
487 for i := 0; i < listSize; i++ {
488 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: string(plmnId + i), NbId: string(nbId + i)}}
489 data, err := proto.Marshal(nbIdentity)
491 t.Errorf("#rNibReader_test.TestGetListGnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
493 idsData[i] = string(data)
494 idsEntities[i] = nbIdentity
497 sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return(idsData, e)
498 ids, er := w.GetListGnbIds()
500 assert.Len(t, ids, listSize)
501 for i, id := range ids {
502 assert.Equal(t, id.GetInventoryName(), name)
503 assert.Equal(t, id.GetGlobalNbId().GetPlmnId(), idsEntities[i].GetGlobalNbId().GetPlmnId())
504 assert.Equal(t, id.GetGlobalNbId().GetNbId(), idsEntities[i].GetGlobalNbId().GetNbId())
508 func TestGetListEnbIdsSdlgoFailure(t *testing.T) {
509 errMsg := "expected Sdlgo error"
510 errMsgExpected := "expected Sdlgo error"
511 w, sdlInstanceMock := initSdlInstanceMock()
512 e := errors.New(errMsg)
514 sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return(data, e)
515 ids, er := w.GetListEnbIds()
518 assert.IsType(t, &common.InternalError{}, er)
519 assert.EqualValues(t, errMsgExpected, er.Error())
522 func TestGetCountGnbListOneId(t *testing.T) {
523 w, sdlInstanceMock := initSdlInstanceMock()
525 sdlInstanceMock.On("GroupSize", entities.Node_GNB.String()).Return(1, e)
526 count, er := w.GetCountGnbList()
528 assert.Equal(t, count, 1)
531 func TestGetCountGnbList(t *testing.T) {
532 w, sdlInstanceMock := initSdlInstanceMock()
534 sdlInstanceMock.On("GroupSize", entities.Node_GNB.String()).Return(3, e)
535 count, er := w.GetCountGnbList()
537 assert.Equal(t, count, 3)
540 func TestGetCountGnbListSdlgoFailure(t *testing.T) {
541 errMsg := "expected Sdlgo error"
542 errMsgExpected := "expected Sdlgo error"
543 w, sdlInstanceMock := initSdlInstanceMock()
544 e := errors.New(errMsg)
546 sdlInstanceMock.On("GroupSize", entities.Node_GNB.String()).Return(count, e)
547 count, er := w.GetCountGnbList()
549 assert.Equal(t, 0, count)
550 assert.IsType(t, &common.InternalError{}, er)
551 assert.EqualValues(t, errMsgExpected, er.Error())
554 func TestGetCell(t *testing.T) {
557 w, sdlInstanceMock := initSdlInstanceMock()
558 cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: &entities.ServedCellInfo{Pci: pci}}}
559 cellData, err := proto.Marshal(&cellEntity)
561 t.Errorf("#rNibReader_test.TestGetCell - Failed to marshal Cell entity. Error: %v", err)
564 key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
566 t.Errorf("#rNibReader_test.TestGetCell - failed to validate key parameter")
568 ret := map[string]interface{}{key: string(cellData)}
569 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
570 cell, er := w.GetCell(name, pci)
572 assert.NotNil(t, cell)
573 assert.Equal(t, cell.Type, entities.Cell_LTE_CELL)
574 assert.NotNil(t, cell.GetServedCellInfo())
575 assert.Equal(t, cell.GetServedCellInfo().GetPci(), pci)
578 func TestGetCellNotFoundFailure(t *testing.T) {
581 w, sdlInstanceMock := initSdlInstanceMock()
583 var ret map[string]interface{}
584 key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
586 t.Errorf("#rNibReader_test.TestGetCellNotFoundFailure - failed to validate key parameter")
588 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
589 cell, er := w.GetCell(name, pci)
592 assert.IsType(t, &common.ResourceNotFoundError{}, er)
593 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.Cell not found. Key: PCI:name:00", er.Error())
596 func TestGetCellUnmarshalFailure(t *testing.T) {
599 w, sdlInstanceMock := initSdlInstanceMock()
601 ret := make(map[string]interface{}, 1)
602 key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
604 t.Errorf("#rNibReader_test.TestGetCellUnmarshalFailure - failed to validate key parameter")
607 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
608 cell, er := w.GetCell(name, pci)
611 assert.IsType(t, &common.InternalError{}, er)
612 assert.Contains(t, er.Error(), "proto:")
615 func TestGetCellSdlgoFailure(t *testing.T) {
618 errMsg := "expected Sdlgo error"
619 errMsgExpected := "expected Sdlgo error"
620 w, sdlInstanceMock := initSdlInstanceMock()
621 e := errors.New(errMsg)
622 var ret map[string]interface{}
623 key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
625 t.Errorf("#rNibReader_test.TestGetCellSdlgoFailure - failed to validate key parameter")
627 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
628 cell, er := w.GetCell(name, pci)
631 assert.IsType(t, &common.InternalError{}, er)
632 assert.EqualValues(t, errMsgExpected, er.Error())
635 func TestGetNodebById(t *testing.T) {
636 w, sdlInstanceMock := initSdlInstanceMock()
637 nb := entities.NodebInfo{NodeType: entities.Node_ENB}
638 nb.ConnectionStatus = 1
641 enb := entities.Enb{}
642 cell := entities.ServedCellInfo{Tac: "tac"}
643 enb.ServedCells = []*entities.ServedCellInfo{&cell}
644 nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
646 data, err := proto.Marshal(&nb)
648 t.Errorf("#rNibReader_test.TestGetNodebById - Failed to marshal ENB instance. Error: %v", err)
653 key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_ENB.String(), plmnId, nbId)
655 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
657 ret := map[string]interface{}{key: string(data)}
658 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
659 globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
660 getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
662 assert.Equal(t, getNb.Ip, nb.Ip)
663 assert.Equal(t, getNb.Port, nb.Port)
664 assert.Equal(t, getNb.ConnectionStatus, nb.ConnectionStatus)
665 assert.Len(t, getNb.GetEnb().GetServedCells(), 1)
666 assert.Equal(t, getNb.GetEnb().GetServedCells()[0].Tac, nb.GetEnb().GetServedCells()[0].Tac)
669 func TestGetNodebByIdNotFoundFailureEnb(t *testing.T) {
672 w, sdlInstanceMock := initSdlInstanceMock()
674 key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_ENB.String(), plmnId, nbId)
676 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
678 var ret map[string]interface{}
679 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
680 globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
681 getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
684 assert.IsType(t, &common.ResourceNotFoundError{}, er)
685 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.NodebInfo not found. Key: ENB:02f829:4a952a0a", er.Error())
688 func TestGetNodebByIdNotFoundFailureGnb(t *testing.T) {
691 w, sdlInstanceMock := initSdlInstanceMock()
693 key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_GNB.String(), plmnId, nbId)
695 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
697 var ret map[string]interface{}
698 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
699 globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
700 getNb, er := w.GetNodebByGlobalNbId(entities.Node_GNB, globalNbId)
703 assert.IsType(t, &common.ResourceNotFoundError{}, er)
704 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.NodebInfo not found. Key: GNB:02f829:4a952a0a", er.Error())
707 func TestGetNodeByIdUnmarshalFailure(t *testing.T) {
710 w, sdlInstanceMock := initSdlInstanceMock()
711 key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_ENB.String(), plmnId, nbId)
713 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
716 ret := make(map[string]interface{}, 1)
718 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
719 globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
720 getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
723 assert.IsType(t, &common.InternalError{}, er)
724 assert.Contains(t, er.Error(), "proto:")
727 func TestGetNodeByIdSdlgoFailure(t *testing.T) {
730 errMsg := "expected Sdlgo error"
731 errMsgExpected := "expected Sdlgo error"
732 w, sdlInstanceMock := initSdlInstanceMock()
733 key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_GNB.String(), plmnId, nbId)
735 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
737 e := errors.New(errMsg)
738 var ret map[string]interface{}
739 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
740 globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
741 getNb, er := w.GetNodebByGlobalNbId(entities.Node_GNB, globalNbId)
744 assert.IsType(t, &common.InternalError{}, er)
745 assert.EqualValues(t, errMsgExpected, er.Error())
748 func TestGetCellById(t *testing.T) {
751 w, sdlInstanceMock := initSdlInstanceMock()
752 cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: &entities.ServedCellInfo{Pci: pci}}}
753 cellData, err := proto.Marshal(&cellEntity)
755 t.Errorf("#rNibReader_test.TestGetCellById - Failed to marshal Cell entity. Error: %v", err)
758 key, rNibErr := common.ValidateAndBuildCellIdKey(cellId)
760 t.Errorf("#rNibReader_test.TestGetCellById - failed to validate key parameter")
762 ret := map[string]interface{}{key: string(cellData)}
763 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
764 cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
766 assert.NotNil(t, cell)
767 assert.Equal(t, cell.Type, entities.Cell_LTE_CELL)
768 assert.NotNil(t, cell.GetServedCellInfo())
769 assert.Equal(t, cell.GetServedCellInfo().GetPci(), pci)
772 func TestGetCellByIdNotFoundFailureEnb(t *testing.T) {
774 w, sdlInstanceMock := initSdlInstanceMock()
776 var ret map[string]interface{}
777 key, rNibErr := common.ValidateAndBuildCellIdKey(cellId)
779 t.Errorf("#rNibReader_test.TestGetCellByIdNotFoundFailure - failed to validate key parameter")
781 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
782 cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
785 assert.IsType(t, &common.ResourceNotFoundError{}, er)
786 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.Cell not found. Key: CELL:bbbb", er.Error())
789 func TestGetCellByIdNotFoundFailureGnb(t *testing.T) {
791 w, sdlInstanceMock := initSdlInstanceMock()
793 var ret map[string]interface{}
794 key, rNibErr := common.ValidateAndBuildNrCellIdKey(cellId)
796 t.Errorf("#rNibReader_test.TestGetCellByIdNotFoundFailure - failed to validate key parameter")
798 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
799 cell, er := w.GetCellById(entities.Cell_NR_CELL, cellId)
802 assert.IsType(t, &common.ResourceNotFoundError{}, er)
803 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.Cell not found. Key: NRCELL:bbbb", er.Error())
806 func TestGetCellByIdTypeValidationFailure(t *testing.T) {
808 w, _ := initSdlInstanceMock()
809 cell, er := w.GetCellById(5, cellId)
812 assert.IsType(t, &common.ValidationError{}, er)
813 assert.EqualValues(t, "#rNibReader.GetCellById - invalid cell type: 5", er.Error())
816 func TestGetCellByIdValidationFailureGnb(t *testing.T) {
818 w, _ := initSdlInstanceMock()
819 cell, er := w.GetCellById(entities.Cell_NR_CELL, cellId)
822 assert.IsType(t, &common.ValidationError{}, er)
823 assert.EqualValues(t, "#utils.ValidateAndBuildNrCellIdKey - an empty cell id received", er.Error())
826 func TestGetCellByIdValidationFailureEnb(t *testing.T) {
828 w, _ := initSdlInstanceMock()
829 cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
832 assert.IsType(t, &common.ValidationError{}, er)
833 assert.EqualValues(t, "#utils.ValidateAndBuildCellIdKey - an empty cell id received", er.Error())
836 func TestGetRanLoadInformation(t *testing.T) {
838 w, sdlInstanceMock := initSdlInstanceMock()
839 loadInfo := generateRanLoadInformation()
841 data, err := proto.Marshal(loadInfo)
843 t.Errorf("#rNibReader_test.TestGetRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
845 redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
847 t.Errorf("#rNibReader_test.TestGetRanLoadInformationNotFoundFailure - failed to validate key parameter")
849 ret := map[string]interface{}{redisKey: string(data)}
850 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
851 getLoadInfo, er := w.GetRanLoadInformation(name)
853 assert.NotNil(t, getLoadInfo)
854 expected, err := json.Marshal(loadInfo)
856 t.Errorf("#rNibReader_test.TestGetRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
858 actual, err := json.Marshal(getLoadInfo)
860 t.Errorf("#rNibReader_test.TestGetRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
862 assert.EqualValues(t, expected, actual)
865 func TestGetRanLoadInformationValidationFailure(t *testing.T) {
867 w, _ := initSdlInstanceMock()
868 getNb, er := w.GetRanLoadInformation(name)
871 assert.IsType(t, &common.ValidationError{}, er)
872 assert.EqualValues(t, "#utils.ValidateAndBuildRanLoadInformationKey - an empty inventory name received", er.Error())
875 func TestGetRanLoadInformationNotFoundFailure(t *testing.T) {
877 w, sdlInstanceMock := initSdlInstanceMock()
879 var ret map[string]interface{}
880 redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
882 t.Errorf("#rNibReader_test.TestGetRanLoadInformationNotFoundFailure - failed to validate key parameter")
884 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
885 getNb, er := w.GetRanLoadInformation(name)
888 assert.IsType(t, &common.ResourceNotFoundError{}, er)
889 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.RanLoadInformation not found. Key: LOAD:name", er.Error())
892 func TestGetRanLoadInformationUnmarshalFailure(t *testing.T) {
894 w, sdlInstanceMock := initSdlInstanceMock()
896 ret := make(map[string]interface{}, 1)
897 redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
899 t.Errorf("#rNibReader_test.TestGetRanLoadInformationUnmarshalFailure - failed to validate key parameter")
901 ret[redisKey] = "data"
902 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
903 getNb, er := w.GetRanLoadInformation(name)
906 assert.IsType(t, &common.InternalError{}, er)
907 assert.Contains(t, er.Error(), "proto:")
910 func TestGetRanLoadInformationSdlgoFailure(t *testing.T) {
912 errMsg := "expected Sdlgo error"
913 errMsgExpected := "expected Sdlgo error"
914 w, sdlInstanceMock := initSdlInstanceMock()
915 e := errors.New(errMsg)
916 var ret map[string]interface{}
917 redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
919 t.Errorf("#rNibReader_test.TestGetRanLoadInformationSdlgoFailure - failed to validate key parameter")
921 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
922 getNb, er := w.GetRanLoadInformation(name)
925 assert.IsType(t, &common.InternalError{}, er)
926 assert.EqualValues(t, errMsgExpected, er.Error())
929 func generateCellLoadInformation() *entities.CellLoadInformation {
930 cellLoadInformation := entities.CellLoadInformation{}
932 cellLoadInformation.CellId = "123"
934 ulInterferenceOverloadIndication := entities.UlInterferenceOverloadIndication_HIGH_INTERFERENCE
935 cellLoadInformation.UlInterferenceOverloadIndications = []entities.UlInterferenceOverloadIndication{ulInterferenceOverloadIndication}
937 ulHighInterferenceInformation := entities.UlHighInterferenceInformation{
939 UlHighInterferenceIndication: "xxx",
942 cellLoadInformation.UlHighInterferenceInfos = []*entities.UlHighInterferenceInformation{&ulHighInterferenceInformation}
944 cellLoadInformation.RelativeNarrowbandTxPower = &entities.RelativeNarrowbandTxPower{
946 RntpThreshold: entities.RntpThreshold_NEG_4,
947 NumberOfCellSpecificAntennaPorts: entities.NumberOfCellSpecificAntennaPorts_V1_ANT_PRT,
949 PdcchInterferenceImpact: 2,
950 EnhancedRntp: &entities.EnhancedRntp{
951 EnhancedRntpBitmap: "xxx",
952 RntpHighPowerThreshold: entities.RntpThreshold_NEG_2,
953 EnhancedRntpStartTime: &entities.StartTime{StartSfn: 500, StartSubframeNumber: 5},
957 cellLoadInformation.AbsInformation = &entities.AbsInformation{
958 Mode: entities.AbsInformationMode_ABS_INFO_FDD,
959 AbsPatternInfo: "xxx",
960 NumberOfCellSpecificAntennaPorts: entities.NumberOfCellSpecificAntennaPorts_V2_ANT_PRT,
961 MeasurementSubset: "xxx",
964 cellLoadInformation.InvokeIndication = entities.InvokeIndication_ABS_INFORMATION
966 cellLoadInformation.ExtendedUlInterferenceOverloadInfo = &entities.ExtendedUlInterferenceOverloadInfo{
967 AssociatedSubframes: "xxx",
968 ExtendedUlInterferenceOverloadIndications: cellLoadInformation.UlInterferenceOverloadIndications,
971 compInformationItem := &entities.CompInformationItem{
972 CompHypothesisSets: []*entities.CompHypothesisSet{{CellId: "789", CompHypothesis: "xxx"}},
976 cellLoadInformation.CompInformation = &entities.CompInformation{
977 CompInformationItems: []*entities.CompInformationItem{compInformationItem},
978 CompInformationStartTime: &entities.StartTime{StartSfn: 123, StartSubframeNumber: 456},
981 cellLoadInformation.DynamicDlTransmissionInformation = &entities.DynamicDlTransmissionInformation{
982 State: entities.NaicsState_NAICS_ACTIVE,
983 TransmissionModes: "xxx",
985 PAList: []entities.PA{entities.PA_DB_NEG_3},
988 return &cellLoadInformation
991 func generateRanLoadInformation() *entities.RanLoadInformation {
992 ranLoadInformation := entities.RanLoadInformation{}
994 ranLoadInformation.LoadTimestamp = uint64(time.Now().UnixNano())
996 cellLoadInformation := generateCellLoadInformation()
997 ranLoadInformation.CellLoadInfos = []*entities.CellLoadInformation{cellLoadInformation}
999 return &ranLoadInformation
1002 func TestGetE2TInstanceSuccess(t *testing.T) {
1003 address := "10.10.2.15:9800"
1004 redisKey, validationErr := common.ValidateAndBuildE2TInstanceKey(address)
1006 if validationErr != nil {
1007 t.Errorf("#rNibReader_test.TestGetE2TInstanceSuccess - Failed to build E2T Instance key. Error: %v", validationErr)
1010 w, sdlInstanceMock := initSdlInstanceMock()
1012 e2tInstance := generateE2tInstance(address)
1013 data, err := json.Marshal(e2tInstance)
1016 t.Errorf("#rNibReader_test.TestGetE2TInstanceSuccess - Failed to marshal E2tInstance entity. Error: %v", err)
1020 ret := map[string]interface{}{redisKey: string(data)}
1021 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
1023 res, rNibErr := w.GetE2TInstance(address)
1024 assert.Nil(t, rNibErr)
1025 assert.Equal(t, e2tInstance, res)
1028 func TestUnmarshal(t *testing.T) {
1029 e2tInstance := generateE2tInstance("10.0.2.15:5555")
1030 marshaled, _ := json.Marshal(e2tInstance)
1031 m := map[string]interface{}{
1032 "whatever": string(marshaled),
1034 var entity entities.E2TInstance
1035 err := json.Unmarshal([]byte(m["whatever"].(string)), &entity)
1039 func TestGetE2TInstanceEmptyAddressFailure(t *testing.T) {
1040 w, _ := initSdlInstanceMock()
1041 res, err := w.GetE2TInstance("")
1042 assert.NotNil(t, err)
1043 assert.IsType(t, &common.ValidationError{}, err)
1047 func TestGetE2TInstanceSdlError(t *testing.T) {
1048 address := "10.10.2.15:9800"
1049 redisKey, validationErr := common.ValidateAndBuildE2TInstanceKey(address)
1051 if validationErr != nil {
1052 t.Errorf("#rNibReader_test.TestGetE2TInstanceSuccess - Failed to build E2T Instance key. Error: %v", validationErr)
1055 w, sdlInstanceMock := initSdlInstanceMock()
1057 expectedErr := errors.New("expected error")
1058 var ret map[string]interface{}
1059 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, expectedErr)
1061 res, rNibErr := w.GetE2TInstance(address)
1062 assert.NotNil(t, rNibErr)
1066 func generateE2tInstance(address string) *entities.E2TInstance {
1067 e2tInstance := entities.NewE2TInstance(address,"")
1068 e2tInstance.AssociatedRanList = []string{"test1", "test2"}
1069 e2tInstance.DeletionTimestamp = time.Now().UnixNano()
1073 func TestGetE2TAddressesSdlError(t *testing.T) {
1074 w, sdlInstanceMock := initSdlInstanceMock()
1076 expectedErr := errors.New("expected error")
1077 var ret map[string]interface{}
1078 sdlInstanceMock.On("Get", []string{E2TAddressesKey}).Return(ret, expectedErr)
1080 res, rNibErr := w.GetE2TAddresses()
1081 assert.NotNil(t, rNibErr)
1085 func TestGetE2TAddressesSuccess(t *testing.T) {
1086 address := "10.10.2.15:9800"
1087 w, sdlInstanceMock := initSdlInstanceMock()
1089 e2tAddresses := []string{address}
1090 data, err := json.Marshal(e2tAddresses)
1093 t.Errorf("#rNibReader_test.TestGetE2TInfoListSuccess - Failed to marshal E2TInfoList. Error: %v", err)
1097 ret := map[string]interface{}{E2TAddressesKey: string(data)}
1098 sdlInstanceMock.On("Get", []string{E2TAddressesKey}).Return(ret, e)
1100 res, rNibErr := w.GetE2TAddresses()
1101 assert.Nil(t, rNibErr)
1102 assert.Equal(t, e2tAddresses, res)
1105 func TestGetE2TInstancesSuccess(t *testing.T) {
1106 address := "10.10.2.15:9800"
1107 address2 := "10.10.2.16:9800"
1108 redisKey, _ := common.ValidateAndBuildE2TInstanceKey(address)
1109 redisKey2, _ := common.ValidateAndBuildE2TInstanceKey(address2)
1111 w, sdlInstanceMock := initSdlInstanceMock()
1113 e2tInstance1 := generateE2tInstance(address)
1114 e2tInstance2 := generateE2tInstance(address2)
1116 data1, _ := json.Marshal(e2tInstance1)
1117 data2, _ := json.Marshal(e2tInstance2)
1120 ret := map[string]interface{}{redisKey: string(data1), redisKey2: string(data2)}
1121 sdlInstanceMock.On("Get", []string{redisKey, redisKey2}).Return(ret, e)
1123 res, err := w.GetE2TInstances([]string{address, address2})
1125 assert.Equal(t, []*entities.E2TInstance{e2tInstance1, e2tInstance2}, res)
1128 func TestGetE2TInstancesUnmarhalPartialSuccess(t *testing.T) {
1129 address := "10.10.2.15:9800"
1130 address2 := "10.10.2.16:9800"
1131 redisKey, _ := common.ValidateAndBuildE2TInstanceKey(address)
1132 redisKey2, _ := common.ValidateAndBuildE2TInstanceKey(address2)
1134 w, sdlInstanceMock := initSdlInstanceMock()
1136 e2tInstance1 := generateE2tInstance(address)
1137 data1, _ := json.Marshal(e2tInstance1)
1140 ret := map[string]interface{}{redisKey: string(data1), redisKey2: "abc"}
1141 sdlInstanceMock.On("Get", []string{redisKey, redisKey2}).Return(ret, e)
1143 res, err := w.GetE2TInstances([]string{address, address2})
1145 assert.Equal(t, []*entities.E2TInstance{e2tInstance1}, res)
1148 func TestGetE2TInstancesSdlFailure(t *testing.T) {
1149 address := "10.10.2.15:9800"
1150 address2 := "10.10.2.16:9800"
1151 redisKey, _ := common.ValidateAndBuildE2TInstanceKey(address)
1152 redisKey2, _ := common.ValidateAndBuildE2TInstanceKey(address2)
1154 w, sdlInstanceMock := initSdlInstanceMock()
1156 sdlInstanceMock.On("Get", []string{redisKey, redisKey2}).Return(map[string]interface{}{}, fmt.Errorf(""))
1157 _, err := w.GetE2TInstances([]string{address, address2})
1158 assert.IsType(t, &common.InternalError{}, err)
1161 func TestGetE2TInstancesEmptyData(t *testing.T) {
1162 address := "10.10.2.15:9800"
1163 address2 := "10.10.2.16:9800"
1164 redisKey, _ := common.ValidateAndBuildE2TInstanceKey(address)
1165 redisKey2, _ := common.ValidateAndBuildE2TInstanceKey(address2)
1167 w, sdlInstanceMock := initSdlInstanceMock()
1169 sdlInstanceMock.On("Get", []string{redisKey, redisKey2}).Return(map[string]interface{}{}, nil)
1170 _, err := w.GetE2TInstances([]string{address, address2})
1171 assert.IsType(t, &common.ResourceNotFoundError{}, err)
1174 func TestGetGeneralConfiguration(t *testing.T) {
1176 key := common.BuildGeneralConfigurationKey()
1177 w, sdlInstanceMock := initSdlInstanceMock()
1179 configurationData := "{\"enableRic\":true}"
1180 sdlInstanceMock.On("Get", []string{key}).Return(map[string]interface{}{key: configurationData}, nil)
1182 res, rNibErr := w.GetGeneralConfiguration()
1183 assert.Nil(t, rNibErr)
1184 assert.Equal(t, true, res.EnableRic)
1187 func TestGetGeneralConfigurationNotFound(t *testing.T) {
1189 key := common.BuildGeneralConfigurationKey()
1190 w, sdlInstanceMock := initSdlInstanceMock()
1192 sdlInstanceMock.On("Get", []string{key}).Return(map[string]interface{}{}, nil)
1194 _, rNibErr := w.GetGeneralConfiguration()
1196 assert.NotNil(t, rNibErr)
1197 assert.Equal(t, "#rNibReader.getByKeyAndUnmarshalJson - entity of type *entities.GeneralConfiguration not found. Key: GENERAL", rNibErr.Error())
1200 func TestGetGeneralConfigurationSdlFailure(t *testing.T) {
1202 key := common.BuildGeneralConfigurationKey()
1203 w, sdlInstanceMock := initSdlInstanceMock()
1205 sdlInstanceMock.On("Get", []string{key}).Return(map[string]interface{}{}, fmt.Errorf("sdl error"))
1207 _, rNibErr := w.GetGeneralConfiguration()
1209 assert.NotNil(t, rNibErr)
1211 assert.Equal(t, "sdl error", rNibErr.Error())
1214 func TestGetGeneralConfigurationUnmarshalError(t *testing.T) {
1216 key := common.BuildGeneralConfigurationKey()
1217 w, sdlInstanceMock := initSdlInstanceMock()
1219 configurationData := "{\"enableRic :true}"
1220 sdlInstanceMock.On("Get", []string{key}).Return(map[string]interface{}{key: configurationData}, nil)
1222 _, rNibErr := w.GetGeneralConfiguration()
1224 assert.NotNil(t, rNibErr)
1225 assert.Equal(t, rNibErr.Error(), "unexpected end of JSON input")
1230 //func TestGetEnbInteg(t *testing.T){
1231 // name := "nameEnb1"
1232 // Init("namespace", 1)
1233 // w := GetRNibReader()
1234 // nb, err := w.GetNodeb(name)
1238 // fmt.Printf("#TestGetEnbInteg - responding node type: %v\n", nb)
1242 //func TestGetEnbCellsInteg(t *testing.T){
1243 // name := "nameEnb1"
1244 // Init("namespace", 1)
1245 // w := GetRNibReader()
1246 // cells, err := w.GetCellList(name)
1249 // } else if cells != nil{
1250 // for _, cell := range cells.GetServedCellInfos().ServedCells{
1251 // fmt.Printf("responding node type Cell: %v\n", *cell)
1256 //func TestGetGnbInteg(t *testing.T){
1257 // name := "nameGnb1"
1258 // Init("namespace", 1)
1259 // w := GetRNibReader()
1260 // nb, err := w.GetNodeb(name)
1264 // fmt.Printf("#TestGetGnbInteg - responding node type: %v\n", nb)
1268 //func TestGetGnbCellsInteg(t *testing.T){
1269 // name := "nameGnb1"
1270 // Init("namespace", 1)
1271 // w := GetRNibReader()
1272 // cells, err := w.GetCellList(name)
1275 // } else if cells != nil{
1276 // for _, cell := range cells.GetServedNrCells().ServedCells{
1277 // fmt.Printf("responding node type NR Cell: %v\n", *cell)
1282 //func TestGetListEnbIdsInteg(t *testing.T) {
1283 // Init("namespace", 1)
1284 // w := GetRNibReader()
1285 // ids, err := w.GetListEnbIds()
1289 // for _, id := range ids{
1290 // fmt.Printf("#TestGetListEnbIdsInteg - ENB ID: %s\n", id)
1295 //func TestGetListGnbIdsInteg(t *testing.T) {
1296 // Init("namespace", 1)
1297 // w := GetRNibReader()
1298 // ids, err := w.GetListGnbIds()
1302 // for _, id := range ids{
1303 // fmt.Printf("#TestGetListGnbIdsInteg - GNB ID: %s\n", id)
1308 //func TestGetCountGnbListInteg(t *testing.T) {
1309 // Init("namespace", 1)
1310 // w := GetRNibReader()
1311 // count, err := w.GetCountGnbList()
1315 // fmt.Printf("#TestGetCountGnbListInteg - count Gnb list: %d\n", count)
1319 //func TestGetGnbCellInteg(t *testing.T){
1320 // name := "nameGnb7"
1322 // Init("namespace", 1)
1323 // w := GetRNibReader()
1324 // cell, err := w.GetCell(name, uint32(pci))
1327 // } else if cell != nil{
1328 // fmt.Printf("responding node type NR Cell: %v\n", cell.GetServedNrCell())
1332 //func TestGetEnbCellInteg(t *testing.T) {
1333 // name := "nameEnb1"
1335 // Init("namespace", 1)
1336 // w := GetRNibReader()
1337 // cell, err := w.GetCell(name, uint32(pci))
1340 // } else if cell != nil {
1341 // fmt.Printf("responding node type LTE Cell: %v\n", cell.GetServedCellInfo())
1345 //func TestGetEnbCellByIdInteg(t *testing.T){
1346 // Init("namespace", 1)
1347 // w := GetRNibReader()
1348 // cell, err := w.GetCellById(entities.Cell_NR_CELL, "45d")
1351 // } else if cell != nil{
1352 // fmt.Printf("responding node type NR Cell: %v\n", cell.GetServedNrCell())
1356 //func TestGetListNbIdsInteg(t *testing.T) {
1357 // Init("e2Manager", 1)
1358 // w := GetRNibReader()
1359 // ids, err := w.GetListNodebIds()
1363 // for _, id := range ids{
1364 // fmt.Printf("#TestGetListGnbIdsInteg - NB ID: %s\n", id)
1369 //func TestGetRanLoadInformationInteg(t *testing.T){
1370 // Init("e2Manager", 1)
1371 // w := GetRNibReader()
1372 // ranLoadInformation, err := w.GetRanLoadInformation("ran_integ")
1374 // t.Errorf("#rNibReader_test.TestGetRanLoadInformationInteg - Failed to get RanLoadInformation entity. Error: %v", err)
1376 // assert.NotNil(t, ranLoadInformation)
1377 // fmt.Printf("#rNibReader_test.TestGetRanLoadInformationInteg - GNB ID: %s\n", ranLoadInformation)
1380 //func TestGetE2TInstancesInteg(t *testing.T) {
1381 // db := sdlgo.NewDatabase()
1382 // sdl := sdlgo.NewSdlInstance("e2Manager", db)
1383 // rnibReader := GetRNibReader(sdl)
1384 // e2tInstances, _ := rnibReader.GetE2TInstances([]string{"e2t.att.com:38000","whatever"})
1385 // assert.Len(t, e2tInstances, 1)