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.
21 "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
22 "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
23 "github.com/golang/protobuf/proto"
24 "github.com/pkg/errors"
25 "github.com/stretchr/testify/assert"
30 var namespace = "namespace"
32 func initSdlInstanceMock(namespace string) (w RNibReader, sdlInstanceMock *MockSdlInstance) {
33 sdlInstanceMock = new(MockSdlInstance)
34 w = GetRNibReader(sdlInstanceMock)
38 func TestGetNodeB(t *testing.T) {
40 w, sdlInstanceMock := initSdlInstanceMock(namespace)
41 nb := entities.NodebInfo{}
42 nb.ConnectionStatus = 1
46 cell := entities.ServedCellInfo{Tac: "tac"}
47 enb.ServedCells = []*entities.ServedCellInfo{&cell}
48 nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
50 data, err := proto.Marshal(&nb)
52 t.Errorf("#rNibReader_test.TestGetNb - Failed to marshal ENB instance. Error: %v", err)
54 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
56 t.Errorf("#rNibReader_test.TestGetNodeB - failed to validate key parameter")
58 ret := map[string]interface{}{redisKey: string(data)}
59 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
60 getNb, er := w.GetNodeb(name)
62 assert.Equal(t, getNb.Ip, nb.Ip)
63 assert.Equal(t, getNb.Port, nb.Port)
64 assert.Equal(t, getNb.ConnectionStatus, nb.ConnectionStatus)
65 assert.Len(t, getNb.GetEnb().GetServedCells(), 1)
66 assert.Equal(t, getNb.GetEnb().GetServedCells()[0].Tac, nb.GetEnb().GetServedCells()[0].Tac)
69 func TestGetNodeBNotFoundFailure(t *testing.T) {
71 w, sdlInstanceMock := initSdlInstanceMock(namespace)
73 var ret map[string]interface{}
74 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
76 t.Errorf("#rNibReader_test.TestGetNodeBNotFoundFailure - failed to validate key parameter")
78 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
79 getNb, er := w.GetNodeb(name)
82 assert.IsType(t, &common.ResourceNotFoundError{}, er)
83 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.NodebInfo not found. Key: RAN:name", er.Error())
86 func TestGetNodeBUnmarshalFailure(t *testing.T) {
88 w, sdlInstanceMock := initSdlInstanceMock(namespace)
90 ret := make(map[string]interface{}, 1)
91 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
93 t.Errorf("#rNibReader_test.TestGetNodeBUnmarshalFailure - failed to validate key parameter")
95 ret[redisKey] = "data"
96 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
97 getNb, er := w.GetNodeb(name)
100 assert.IsType(t, &common.InternalError{}, er)
101 assert.EqualValues(t, "proto: can't skip unknown wire type 4", er.Error())
104 func TestGetNodeBSdlgoFailure(t *testing.T) {
106 errMsg := "expected Sdlgo error"
107 errMsgExpected := "expected Sdlgo error"
108 w, sdlInstanceMock := initSdlInstanceMock(namespace)
109 e := errors.New(errMsg)
110 var ret map[string]interface{}
111 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
113 t.Errorf("#rNibReader_test.TestGetNodeBSdlgoFailure - failed to validate key parameter")
115 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
116 getNb, er := w.GetNodeb(name)
119 assert.IsType(t, &common.InternalError{}, er)
120 assert.EqualValues(t, errMsgExpected, er.Error())
123 func TestGetNodeBCellsListEnb(t *testing.T) {
125 w, sdlInstanceMock := initSdlInstanceMock(namespace)
126 nb := entities.NodebInfo{}
127 nb.ConnectionStatus = 1
130 enb := entities.Enb{}
131 cell := entities.ServedCellInfo{Tac: "tac"}
132 enb.ServedCells = []*entities.ServedCellInfo{&cell}
133 nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
135 data, err := proto.Marshal(&nb)
137 t.Errorf("#rNibReader_test.GetNodeBCellsList - Failed to marshal ENB instance. Error: %v", err)
139 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
141 t.Errorf("#rNibReader_test.TestGetNodeBCellsListEnb - failed to validate key parameter")
143 ret := map[string]interface{}{redisKey: string(data)}
144 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
145 cells, er := w.GetCellList(name)
147 assert.NotNil(t, cells)
148 assert.Len(t, cells.GetServedCellInfos().GetServedCells(), 1)
149 retCell := cells.GetServedCellInfos().GetServedCells()[0]
150 assert.Equal(t, retCell.Tac, "tac")
153 func TestGetNodeBCellsListGnb(t *testing.T) {
155 w, sdlInstanceMock := initSdlInstanceMock(namespace)
156 nb := entities.NodebInfo{}
157 nb.ConnectionStatus = 1
160 nb.NodeType = entities.Node_GNB
161 gnb := entities.Gnb{}
162 cell := entities.ServedNRCell{ServedNrCellInformation: &entities.ServedNRCellInformation{NrPci: 10}}
163 gnb.ServedNrCells = []*entities.ServedNRCell{&cell}
164 nb.Configuration = &entities.NodebInfo_Gnb{Gnb: &gnb}
166 data, err := proto.Marshal(&nb)
168 t.Errorf("#rNibReader_test.GetNodeBCellsList - Failed to marshal GNB instance. Error: %v", err)
170 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
172 t.Errorf("#rNibReader_test.TestGetNodeBCellsListGnb - failed to validate key parameter")
174 ret := map[string]interface{}{redisKey: string(data)}
175 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
176 cells, er := w.GetCellList(name)
178 assert.NotNil(t, cells)
179 assert.Len(t, cells.GetServedNrCells().GetServedCells(), 1)
180 retCell := cells.GetServedNrCells().GetServedCells()[0]
181 assert.Equal(t, retCell.GetServedNrCellInformation().GetNrPci(), uint32(10))
184 func TestGetNodeBCellsListNodeUnmarshalFailure(t *testing.T) {
186 w, sdlInstanceMock := initSdlInstanceMock(namespace)
188 ret := make(map[string]interface{}, 1)
189 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
191 t.Errorf("#rNibReader_test.TestGetNodeBCellsListNodeUnmarshalFailure - failed to validate key parameter")
193 ret[redisKey] = "data"
194 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
195 cells, er := w.GetCellList(name)
198 assert.IsType(t, &common.InternalError{}, er)
199 assert.EqualValues(t, "proto: can't skip unknown wire type 4", er.Error())
202 func TestGetNodeBCellsListNodeNotFoundFailure(t *testing.T) {
204 w, sdlInstanceMock := initSdlInstanceMock(namespace)
206 var ret map[string]interface{}
207 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
209 t.Errorf("#rNibReader_test.TestGetNodeBCellsListNodeNotFoundFailure - failed to validate key parameter")
211 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
212 cells, er := w.GetCellList(name)
215 assert.IsType(t, &common.ResourceNotFoundError{}, er)
216 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.NodebInfo not found. Key: RAN:name", er.Error())
219 func TestGetNodeBCellsListNotFoundFailureEnb(t *testing.T) {
221 w, sdlInstanceMock := initSdlInstanceMock(namespace)
222 nb := entities.NodebInfo{}
223 nb.ConnectionStatus = 1
226 enb := entities.Enb{}
227 nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
229 data, err := proto.Marshal(&nb)
231 t.Errorf("#rNibReader_test.TestGetNbCellsListNotFoundFailure - Failed to marshal ENB instance. Error: %v", err)
233 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
235 t.Errorf("#rNibReader_test.TestGetNodeBCellsListNotFoundFailureEnb - failed to validate key parameter")
237 ret := map[string]interface{}{redisKey: string(data)}
238 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
239 _, er := w.GetCellList(name)
241 assert.EqualValues(t, "#rNibReader.GetCellList - served cells not found. Responding node RAN name: name.", er.Error())
244 func TestGetNodeBCellsListNotFoundFailureGnb(t *testing.T) {
246 w, sdlInstanceMock := initSdlInstanceMock(namespace)
247 nb := entities.NodebInfo{}
248 nb.ConnectionStatus = 1
251 gnb := entities.Gnb{}
252 nb.Configuration = &entities.NodebInfo_Gnb{Gnb: &gnb}
254 data, err := proto.Marshal(&nb)
256 t.Errorf("#rNibReader_test.TestGetNodeBCellsListNotFoundFailureGnb - Failed to marshal ENB instance. Error: %v", err)
258 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
260 t.Errorf("#rNibReader_test.TestGetNodeBCellsListNotFoundFailureGnb - failed to validate key parameter")
262 ret := map[string]interface{}{redisKey: string(data)}
263 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
264 _, er := w.GetCellList(name)
266 assert.EqualValues(t, "#rNibReader.GetCellList - served cells not found. Responding node RAN name: name.", er.Error())
269 func TestGetListGnbIdsUnmarshalFailure(t *testing.T) {
270 w, sdlInstanceMock := initSdlInstanceMock(namespace)
272 sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return([]string{"data"}, e)
273 ids, er := w.GetListGnbIds()
276 assert.IsType(t, &common.InternalError{}, er)
277 assert.Equal(t, "proto: can't skip unknown wire type 4", er.Error())
280 func TestGetListGnbIdsSdlgoFailure(t *testing.T) {
281 errMsg := "expected Sdlgo error"
282 errMsgExpected := "expected Sdlgo error"
283 w, sdlInstanceMock := initSdlInstanceMock(namespace)
284 e := errors.New(errMsg)
286 sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return(data, e)
287 ids, er := w.GetListGnbIds()
290 assert.IsType(t, &common.InternalError{}, er)
291 assert.EqualValues(t, errMsgExpected, er.Error())
294 func TestGetListNodesIdsGnbSdlgoFailure(t *testing.T) {
295 w, sdlInstanceMock := initSdlInstanceMock(namespace)
300 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
302 data, err := proto.Marshal(nbIdentity)
304 t.Errorf("#rNibReader_test.TestGetListNodesIdsGnbSdlgoFailure - Failed to marshal nodeb identity entity. Error: %v", err)
306 sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{string(data)}, nilError)
308 errMsg := "expected Sdlgo error"
309 errMsgExpected := "expected Sdlgo error"
310 expectedError := errors.New(errMsg)
312 sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return(nilData, expectedError)
314 ids, er := w.GetListNodebIds()
317 assert.IsType(t, &common.InternalError{}, er)
318 assert.EqualValues(t, errMsgExpected, er.Error())
321 func TestGetListNodesIdsEnbSdlgoFailure(t *testing.T) {
322 w, sdlInstanceMock := initSdlInstanceMock(namespace)
327 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
329 data, err := proto.Marshal(nbIdentity)
331 t.Errorf("#rNibReader_test.TestGetListNodesIdsEnbSdlgoFailure - Failed to marshal nodeb identity entity. Error: %v", err)
333 sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return([]string{string(data)}, nilError)
335 errMsg := "expected Sdlgo error"
336 errMsgExpected := "expected Sdlgo error"
337 expectedError := errors.New(errMsg)
339 sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return(nilData, expectedError)
341 ids, er := w.GetListNodebIds()
344 assert.IsType(t, &common.InternalError{}, er)
345 assert.EqualValues(t, errMsgExpected, er.Error())
348 func TestGetListNodesIdsSuccess(t *testing.T) {
349 w, sdlInstanceMock := initSdlInstanceMock(namespace)
355 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
356 data, err := proto.Marshal(nbIdentity)
358 t.Errorf("#rNibReader_test.TestGetListNodesIdsSuccess - Failed to marshal nodeb identity entity. Error: %v", err)
364 nbIdentity1 := &entities.NbIdentity{InventoryName: name1, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId1, NbId: nbId1}}
365 data1, err := proto.Marshal(nbIdentity1)
367 t.Errorf("#rNibReader_test.TestGetListNodesIdsSuccess - Failed to marshal nodeb identity entity. Error: %v", err)
371 nbIdentity2 := &entities.NbIdentity{InventoryName: name2}
372 data2, err := proto.Marshal(nbIdentity2)
374 t.Errorf("#rNibReader_test.TestGetListNodesIdsSuccess - Failed to marshal nodeb identity entity. Error: %v", err)
377 sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return([]string{string(data)}, nilError)
378 sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{string(data1)}, nilError)
379 sdlInstanceMock.On("GetMembers", entities.Node_UNKNOWN.String()).Return([]string{string(data2)}, nilError)
381 ids, er := w.GetListNodebIds()
383 assert.NotNil(t, ids)
384 assert.Len(t, ids, 3)
387 func TestGetListEnbIdsUnmarshalFailure(t *testing.T) {
388 w, sdlInstanceMock := initSdlInstanceMock(namespace)
390 sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{"data"}, e)
391 ids, er := w.GetListEnbIds()
394 assert.IsType(t, &common.InternalError{}, er)
395 assert.Equal(t, "proto: can't skip unknown wire type 4", er.Error())
398 func TestGetListEnbIdsOneId(t *testing.T) {
402 w, sdlInstanceMock := initSdlInstanceMock(namespace)
403 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
405 data, err := proto.Marshal(nbIdentity)
407 t.Errorf("#rNibReader_test.TestGetListEnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
409 sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{string(data)}, e)
410 ids, er := w.GetListEnbIds()
412 assert.Len(t, ids, 1)
413 assert.Equal(t, (ids)[0].GetInventoryName(), name)
414 assert.Equal(t, (ids)[0].GetGlobalNbId().GetPlmnId(), nbIdentity.GetGlobalNbId().GetPlmnId())
415 assert.Equal(t, (ids)[0].GetGlobalNbId().GetNbId(), nbIdentity.GetGlobalNbId().GetNbId())
418 func TestGetListEnbIdsNoIds(t *testing.T) {
419 w, sdlInstanceMock := initSdlInstanceMock(namespace)
421 sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{}, e)
422 ids, er := w.GetListEnbIds()
424 assert.Len(t, ids, 0)
427 func TestGetListEnbIds(t *testing.T) {
432 w, sdlInstanceMock := initSdlInstanceMock(namespace)
433 idsData := make([]string, listSize)
434 idsEntities := make([]*entities.NbIdentity, listSize)
435 for i := 0; i < listSize; i++ {
436 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: string(plmnId + i), NbId: string(nbId + i)}}
437 data, err := proto.Marshal(nbIdentity)
439 t.Errorf("#rNibReader_test.TestGetListEnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
441 idsData[i] = string(data)
442 idsEntities[i] = nbIdentity
445 sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return(idsData, e)
446 ids, er := w.GetListEnbIds()
448 assert.Len(t, ids, listSize)
449 for i, id := range ids {
450 assert.Equal(t, id.GetInventoryName(), name)
451 assert.Equal(t, id.GetGlobalNbId().GetPlmnId(), idsEntities[i].GetGlobalNbId().GetPlmnId())
452 assert.Equal(t, id.GetGlobalNbId().GetNbId(), idsEntities[i].GetGlobalNbId().GetNbId())
456 func TestGetListGnbIdsOneId(t *testing.T) {
460 w, sdlInstanceMock := initSdlInstanceMock(namespace)
461 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
463 data, err := proto.Marshal(nbIdentity)
465 t.Errorf("#rNibReader_test.TestGetListGnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
467 sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return([]string{string(data)}, e)
468 ids, er := w.GetListGnbIds()
470 assert.Len(t, ids, 1)
471 assert.Equal(t, (ids)[0].GetInventoryName(), name)
472 assert.Equal(t, (ids)[0].GetGlobalNbId().GetPlmnId(), nbIdentity.GetGlobalNbId().GetPlmnId())
473 assert.Equal(t, (ids)[0].GetGlobalNbId().GetNbId(), nbIdentity.GetGlobalNbId().GetNbId())
476 func TestGetListGnbIdsNoIds(t *testing.T) {
477 w, sdlInstanceMock := initSdlInstanceMock(namespace)
479 sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return([]string{}, e)
480 ids, er := w.GetListGnbIds()
482 assert.Len(t, ids, 0)
485 func TestGetListGnbIds(t *testing.T) {
490 w, sdlInstanceMock := initSdlInstanceMock(namespace)
491 idsData := make([]string, listSize)
492 idsEntities := make([]*entities.NbIdentity, listSize)
493 for i := 0; i < listSize; i++ {
494 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: string(plmnId + i), NbId: string(nbId + i)}}
495 data, err := proto.Marshal(nbIdentity)
497 t.Errorf("#rNibReader_test.TestGetListGnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
499 idsData[i] = string(data)
500 idsEntities[i] = nbIdentity
503 sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return(idsData, e)
504 ids, er := w.GetListGnbIds()
506 assert.Len(t, ids, listSize)
507 for i, id := range ids {
508 assert.Equal(t, id.GetInventoryName(), name)
509 assert.Equal(t, id.GetGlobalNbId().GetPlmnId(), idsEntities[i].GetGlobalNbId().GetPlmnId())
510 assert.Equal(t, id.GetGlobalNbId().GetNbId(), idsEntities[i].GetGlobalNbId().GetNbId())
514 func TestGetListEnbIdsSdlgoFailure(t *testing.T) {
515 errMsg := "expected Sdlgo error"
516 errMsgExpected := "expected Sdlgo error"
517 w, sdlInstanceMock := initSdlInstanceMock(namespace)
518 e := errors.New(errMsg)
520 sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return(data, e)
521 ids, er := w.GetListEnbIds()
524 assert.IsType(t, &common.InternalError{}, er)
525 assert.EqualValues(t, errMsgExpected, er.Error())
528 func TestGetCountGnbListOneId(t *testing.T) {
529 w, sdlInstanceMock := initSdlInstanceMock(namespace)
531 sdlInstanceMock.On("GroupSize", entities.Node_GNB.String()).Return(1, e)
532 count, er := w.GetCountGnbList()
534 assert.Equal(t, count, 1)
537 func TestGetCountGnbList(t *testing.T) {
538 w, sdlInstanceMock := initSdlInstanceMock(namespace)
540 sdlInstanceMock.On("GroupSize", entities.Node_GNB.String()).Return(3, e)
541 count, er := w.GetCountGnbList()
543 assert.Equal(t, count, 3)
546 func TestGetCountGnbListSdlgoFailure(t *testing.T) {
547 errMsg := "expected Sdlgo error"
548 errMsgExpected := "expected Sdlgo error"
549 w, sdlInstanceMock := initSdlInstanceMock(namespace)
550 e := errors.New(errMsg)
552 sdlInstanceMock.On("GroupSize", entities.Node_GNB.String()).Return(count, e)
553 count, er := w.GetCountGnbList()
555 assert.Equal(t, 0, count)
556 assert.IsType(t, &common.InternalError{}, er)
557 assert.EqualValues(t, errMsgExpected, er.Error())
560 func TestGetCell(t *testing.T) {
563 w, sdlInstanceMock := initSdlInstanceMock(namespace)
564 cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: &entities.ServedCellInfo{Pci: pci}}}
565 cellData, err := proto.Marshal(&cellEntity)
567 t.Errorf("#rNibReader_test.TestGetCell - Failed to marshal Cell entity. Error: %v", err)
570 key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
572 t.Errorf("#rNibReader_test.TestGetCell - failed to validate key parameter")
574 ret := map[string]interface{}{key: string(cellData)}
575 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
576 cell, er := w.GetCell(name, pci)
578 assert.NotNil(t, cell)
579 assert.Equal(t, cell.Type, entities.Cell_LTE_CELL)
580 assert.NotNil(t, cell.GetServedCellInfo())
581 assert.Equal(t, cell.GetServedCellInfo().GetPci(), pci)
584 func TestGetCellNotFoundFailure(t *testing.T) {
587 w, sdlInstanceMock := initSdlInstanceMock(namespace)
589 var ret map[string]interface{}
590 key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
592 t.Errorf("#rNibReader_test.TestGetCellNotFoundFailure - failed to validate key parameter")
594 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
595 cell, er := w.GetCell(name, pci)
598 assert.IsType(t, &common.ResourceNotFoundError{}, er)
599 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.Cell not found. Key: PCI:name:00", er.Error())
602 func TestGetCellUnmarshalFailure(t *testing.T) {
605 w, sdlInstanceMock := initSdlInstanceMock(namespace)
607 ret := make(map[string]interface{}, 1)
608 key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
610 t.Errorf("#rNibReader_test.TestGetCellUnmarshalFailure - failed to validate key parameter")
613 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
614 cell, er := w.GetCell(name, pci)
617 assert.IsType(t, &common.InternalError{}, er)
618 assert.EqualValues(t, "proto: can't skip unknown wire type 4", er.Error())
621 func TestGetCellSdlgoFailure(t *testing.T) {
624 errMsg := "expected Sdlgo error"
625 errMsgExpected := "expected Sdlgo error"
626 w, sdlInstanceMock := initSdlInstanceMock(namespace)
627 e := errors.New(errMsg)
628 var ret map[string]interface{}
629 key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
631 t.Errorf("#rNibReader_test.TestGetCellSdlgoFailure - failed to validate key parameter")
633 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
634 cell, er := w.GetCell(name, pci)
637 assert.IsType(t, &common.InternalError{}, er)
638 assert.EqualValues(t, errMsgExpected, er.Error())
641 func TestGetNodebById(t *testing.T) {
642 w, sdlInstanceMock := initSdlInstanceMock(namespace)
643 nb := entities.NodebInfo{NodeType: entities.Node_ENB}
644 nb.ConnectionStatus = 1
647 enb := entities.Enb{}
648 cell := entities.ServedCellInfo{Tac: "tac"}
649 enb.ServedCells = []*entities.ServedCellInfo{&cell}
650 nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
652 data, err := proto.Marshal(&nb)
654 t.Errorf("#rNibReader_test.TestGetNodebById - Failed to marshal ENB instance. Error: %v", err)
659 key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_ENB.String(), plmnId, nbId)
661 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
663 ret := map[string]interface{}{key: string(data)}
664 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
665 globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
666 getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
668 assert.Equal(t, getNb.Ip, nb.Ip)
669 assert.Equal(t, getNb.Port, nb.Port)
670 assert.Equal(t, getNb.ConnectionStatus, nb.ConnectionStatus)
671 assert.Len(t, getNb.GetEnb().GetServedCells(), 1)
672 assert.Equal(t, getNb.GetEnb().GetServedCells()[0].Tac, nb.GetEnb().GetServedCells()[0].Tac)
675 func TestGetNodebByIdNotFoundFailureEnb(t *testing.T) {
678 w, sdlInstanceMock := initSdlInstanceMock(namespace)
680 key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_ENB.String(), plmnId, nbId)
682 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
684 var ret map[string]interface{}
685 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
686 globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
687 getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
690 assert.IsType(t, &common.ResourceNotFoundError{}, er)
691 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.NodebInfo not found. Key: ENB:02f829:4a952a0a", er.Error())
694 func TestGetNodebByIdNotFoundFailureGnb(t *testing.T) {
697 w, sdlInstanceMock := initSdlInstanceMock(namespace)
699 key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_GNB.String(), plmnId, nbId)
701 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
703 var ret map[string]interface{}
704 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
705 globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
706 getNb, er := w.GetNodebByGlobalNbId(entities.Node_GNB, globalNbId)
709 assert.IsType(t, &common.ResourceNotFoundError{}, er)
710 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.NodebInfo not found. Key: GNB:02f829:4a952a0a", er.Error())
713 func TestGetNodeByIdUnmarshalFailure(t *testing.T) {
716 w, sdlInstanceMock := initSdlInstanceMock(namespace)
717 key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_ENB.String(), plmnId, nbId)
719 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
722 ret := make(map[string]interface{}, 1)
724 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
725 globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
726 getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
729 assert.IsType(t, &common.InternalError{}, er)
730 assert.EqualValues(t, "proto: can't skip unknown wire type 4", er.Error())
733 func TestGetNodeByIdSdlgoFailure(t *testing.T) {
736 errMsg := "expected Sdlgo error"
737 errMsgExpected := "expected Sdlgo error"
738 w, sdlInstanceMock := initSdlInstanceMock(namespace)
739 key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_GNB.String(), plmnId, nbId)
741 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
743 e := errors.New(errMsg)
744 var ret map[string]interface{}
745 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
746 globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
747 getNb, er := w.GetNodebByGlobalNbId(entities.Node_GNB, globalNbId)
750 assert.IsType(t, &common.InternalError{}, er)
751 assert.EqualValues(t, errMsgExpected, er.Error())
754 func TestGetCellById(t *testing.T) {
757 w, sdlInstanceMock := initSdlInstanceMock(namespace)
758 cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: &entities.ServedCellInfo{Pci: pci}}}
759 cellData, err := proto.Marshal(&cellEntity)
761 t.Errorf("#rNibReader_test.TestGetCellById - Failed to marshal Cell entity. Error: %v", err)
764 key, rNibErr := common.ValidateAndBuildCellIdKey(cellId)
766 t.Errorf("#rNibReader_test.TestGetCellById - failed to validate key parameter")
768 ret := map[string]interface{}{key: string(cellData)}
769 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
770 cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
772 assert.NotNil(t, cell)
773 assert.Equal(t, cell.Type, entities.Cell_LTE_CELL)
774 assert.NotNil(t, cell.GetServedCellInfo())
775 assert.Equal(t, cell.GetServedCellInfo().GetPci(), pci)
778 func TestGetCellByIdNotFoundFailureEnb(t *testing.T) {
780 w, sdlInstanceMock := initSdlInstanceMock(namespace)
782 var ret map[string]interface{}
783 key, rNibErr := common.ValidateAndBuildCellIdKey(cellId)
785 t.Errorf("#rNibReader_test.TestGetCellByIdNotFoundFailure - failed to validate key parameter")
787 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
788 cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
791 assert.IsType(t, &common.ResourceNotFoundError{}, er)
792 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.Cell not found. Key: CELL:bbbb", er.Error())
795 func TestGetCellByIdNotFoundFailureGnb(t *testing.T) {
797 w, sdlInstanceMock := initSdlInstanceMock(namespace)
799 var ret map[string]interface{}
800 key, rNibErr := common.ValidateAndBuildNrCellIdKey(cellId)
802 t.Errorf("#rNibReader_test.TestGetCellByIdNotFoundFailure - failed to validate key parameter")
804 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
805 cell, er := w.GetCellById(entities.Cell_NR_CELL, cellId)
808 assert.IsType(t, &common.ResourceNotFoundError{}, er)
809 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.Cell not found. Key: NRCELL:bbbb", er.Error())
812 func TestGetCellByIdTypeValidationFailure(t *testing.T) {
814 w, _ := initSdlInstanceMock(namespace)
815 cell, er := w.GetCellById(5, cellId)
818 assert.IsType(t, &common.ValidationError{}, er)
819 assert.EqualValues(t, "#rNibReader.GetCellById - invalid cell type: 5", er.Error())
822 func TestGetCellByIdValidationFailureGnb(t *testing.T) {
824 w, _ := initSdlInstanceMock(namespace)
825 cell, er := w.GetCellById(entities.Cell_NR_CELL, cellId)
828 assert.IsType(t, &common.ValidationError{}, er)
829 assert.EqualValues(t, "#utils.ValidateAndBuildNrCellIdKey - an empty cell id received", er.Error())
832 func TestGetCellByIdValidationFailureEnb(t *testing.T) {
834 w, _ := initSdlInstanceMock(namespace)
835 cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
838 assert.IsType(t, &common.ValidationError{}, er)
839 assert.EqualValues(t, "#utils.ValidateAndBuildCellIdKey - an empty cell id received", er.Error())
842 func TestGetRanLoadInformation(t *testing.T) {
844 w, sdlInstanceMock := initSdlInstanceMock(namespace)
845 loadInfo := generateRanLoadInformation()
847 data, err := proto.Marshal(loadInfo)
849 t.Errorf("#rNibReader_test.TestGetRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
851 redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
853 t.Errorf("#rNibReader_test.TestGetRanLoadInformationNotFoundFailure - failed to validate key parameter")
855 ret := map[string]interface{}{redisKey: string(data)}
856 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
857 getLoadInfo, er := w.GetRanLoadInformation(name)
859 assert.NotNil(t, getLoadInfo)
860 expected, err := json.Marshal(loadInfo)
862 t.Errorf("#rNibReader_test.TestGetRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
864 actual, err := json.Marshal(getLoadInfo)
866 t.Errorf("#rNibReader_test.TestGetRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
868 assert.EqualValues(t, expected, actual)
871 func TestGetRanLoadInformationValidationFailure(t *testing.T) {
873 w, _ := initSdlInstanceMock(namespace)
874 getNb, er := w.GetRanLoadInformation(name)
877 assert.IsType(t, &common.ValidationError{}, er)
878 assert.EqualValues(t, "#utils.ValidateAndBuildRanLoadInformationKey - an empty inventory name received", er.Error())
881 func TestGetRanLoadInformationNotFoundFailure(t *testing.T) {
883 w, sdlInstanceMock := initSdlInstanceMock(namespace)
885 var ret map[string]interface{}
886 redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
888 t.Errorf("#rNibReader_test.TestGetRanLoadInformationNotFoundFailure - failed to validate key parameter")
890 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
891 getNb, er := w.GetRanLoadInformation(name)
894 assert.IsType(t, &common.ResourceNotFoundError{}, er)
895 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.RanLoadInformation not found. Key: LOAD:name", er.Error())
898 func TestGetRanLoadInformationUnmarshalFailure(t *testing.T) {
900 w, sdlInstanceMock := initSdlInstanceMock(namespace)
902 ret := make(map[string]interface{}, 1)
903 redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
905 t.Errorf("#rNibReader_test.TestGetRanLoadInformationUnmarshalFailure - failed to validate key parameter")
907 ret[redisKey] = "data"
908 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
909 getNb, er := w.GetRanLoadInformation(name)
912 assert.IsType(t, &common.InternalError{}, er)
913 assert.EqualValues(t, "proto: can't skip unknown wire type 4", er.Error())
916 func TestGetRanLoadInformationSdlgoFailure(t *testing.T) {
918 errMsg := "expected Sdlgo error"
919 errMsgExpected := "expected Sdlgo error"
920 w, sdlInstanceMock := initSdlInstanceMock(namespace)
921 e := errors.New(errMsg)
922 var ret map[string]interface{}
923 redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
925 t.Errorf("#rNibReader_test.TestGetRanLoadInformationSdlgoFailure - failed to validate key parameter")
927 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
928 getNb, er := w.GetRanLoadInformation(name)
931 assert.IsType(t, &common.InternalError{}, er)
932 assert.EqualValues(t, errMsgExpected, er.Error())
935 func generateCellLoadInformation() *entities.CellLoadInformation {
936 cellLoadInformation := entities.CellLoadInformation{}
938 cellLoadInformation.CellId = "123"
940 ulInterferenceOverloadIndication := entities.UlInterferenceOverloadIndication_HIGH_INTERFERENCE
941 cellLoadInformation.UlInterferenceOverloadIndications = []entities.UlInterferenceOverloadIndication{ulInterferenceOverloadIndication}
943 ulHighInterferenceInformation := entities.UlHighInterferenceInformation{
945 UlHighInterferenceIndication: "xxx",
948 cellLoadInformation.UlHighInterferenceInfos = []*entities.UlHighInterferenceInformation{&ulHighInterferenceInformation}
950 cellLoadInformation.RelativeNarrowbandTxPower = &entities.RelativeNarrowbandTxPower{
952 RntpThreshold: entities.RntpThreshold_NEG_4,
953 NumberOfCellSpecificAntennaPorts: entities.NumberOfCellSpecificAntennaPorts_V1_ANT_PRT,
955 PdcchInterferenceImpact: 2,
956 EnhancedRntp: &entities.EnhancedRntp{
957 EnhancedRntpBitmap: "xxx",
958 RntpHighPowerThreshold: entities.RntpThreshold_NEG_2,
959 EnhancedRntpStartTime: &entities.StartTime{StartSfn: 500, StartSubframeNumber: 5},
963 cellLoadInformation.AbsInformation = &entities.AbsInformation{
964 Mode: entities.AbsInformationMode_ABS_INFO_FDD,
965 AbsPatternInfo: "xxx",
966 NumberOfCellSpecificAntennaPorts: entities.NumberOfCellSpecificAntennaPorts_V2_ANT_PRT,
967 MeasurementSubset: "xxx",
970 cellLoadInformation.InvokeIndication = entities.InvokeIndication_ABS_INFORMATION
972 cellLoadInformation.ExtendedUlInterferenceOverloadInfo = &entities.ExtendedUlInterferenceOverloadInfo{
973 AssociatedSubframes: "xxx",
974 ExtendedUlInterferenceOverloadIndications: cellLoadInformation.UlInterferenceOverloadIndications,
977 compInformationItem := &entities.CompInformationItem{
978 CompHypothesisSets: []*entities.CompHypothesisSet{{CellId: "789", CompHypothesis: "xxx"}},
982 cellLoadInformation.CompInformation = &entities.CompInformation{
983 CompInformationItems: []*entities.CompInformationItem{compInformationItem},
984 CompInformationStartTime: &entities.StartTime{StartSfn: 123, StartSubframeNumber: 456},
987 cellLoadInformation.DynamicDlTransmissionInformation = &entities.DynamicDlTransmissionInformation{
988 State: entities.NaicsState_NAICS_ACTIVE,
989 TransmissionModes: "xxx",
991 PAList: []entities.PA{entities.PA_DB_NEG_3},
994 return &cellLoadInformation
997 func generateRanLoadInformation() *entities.RanLoadInformation {
998 ranLoadInformation := entities.RanLoadInformation{}
1000 ranLoadInformation.LoadTimestamp = uint64(time.Now().UnixNano())
1002 cellLoadInformation := generateCellLoadInformation()
1003 ranLoadInformation.CellLoadInfos = []*entities.CellLoadInformation{cellLoadInformation}
1005 return &ranLoadInformation
1010 //func TestGetEnbInteg(t *testing.T){
1011 // name := "nameEnb1"
1012 // Init("namespace", 1)
1013 // w := GetRNibReader()
1014 // nb, err := w.GetNodeb(name)
1018 // fmt.Printf("#TestGetEnbInteg - responding node type: %v\n", nb)
1022 //func TestGetEnbCellsInteg(t *testing.T){
1023 // name := "nameEnb1"
1024 // Init("namespace", 1)
1025 // w := GetRNibReader()
1026 // cells, err := w.GetCellList(name)
1029 // } else if cells != nil{
1030 // for _, cell := range cells.GetServedCellInfos().ServedCells{
1031 // fmt.Printf("responding node type Cell: %v\n", *cell)
1036 //func TestGetGnbInteg(t *testing.T){
1037 // name := "nameGnb1"
1038 // Init("namespace", 1)
1039 // w := GetRNibReader()
1040 // nb, err := w.GetNodeb(name)
1044 // fmt.Printf("#TestGetGnbInteg - responding node type: %v\n", nb)
1048 //func TestGetGnbCellsInteg(t *testing.T){
1049 // name := "nameGnb1"
1050 // Init("namespace", 1)
1051 // w := GetRNibReader()
1052 // cells, err := w.GetCellList(name)
1055 // } else if cells != nil{
1056 // for _, cell := range cells.GetServedNrCells().ServedCells{
1057 // fmt.Printf("responding node type NR Cell: %v\n", *cell)
1062 //func TestGetListEnbIdsInteg(t *testing.T) {
1063 // Init("namespace", 1)
1064 // w := GetRNibReader()
1065 // ids, err := w.GetListEnbIds()
1069 // for _, id := range ids{
1070 // fmt.Printf("#TestGetListEnbIdsInteg - ENB ID: %s\n", id)
1075 //func TestGetListGnbIdsInteg(t *testing.T) {
1076 // Init("namespace", 1)
1077 // w := GetRNibReader()
1078 // ids, err := w.GetListGnbIds()
1082 // for _, id := range ids{
1083 // fmt.Printf("#TestGetListGnbIdsInteg - GNB ID: %s\n", id)
1088 //func TestGetCountGnbListInteg(t *testing.T) {
1089 // Init("namespace", 1)
1090 // w := GetRNibReader()
1091 // count, err := w.GetCountGnbList()
1095 // fmt.Printf("#TestGetCountGnbListInteg - count Gnb list: %d\n", count)
1099 //func TestGetGnbCellInteg(t *testing.T){
1100 // name := "nameGnb7"
1102 // Init("namespace", 1)
1103 // w := GetRNibReader()
1104 // cell, err := w.GetCell(name, uint32(pci))
1107 // } else if cell != nil{
1108 // fmt.Printf("responding node type NR Cell: %v\n", cell.GetServedNrCell())
1112 //func TestGetEnbCellInteg(t *testing.T) {
1113 // name := "nameEnb1"
1115 // Init("namespace", 1)
1116 // w := GetRNibReader()
1117 // cell, err := w.GetCell(name, uint32(pci))
1120 // } else if cell != nil {
1121 // fmt.Printf("responding node type LTE Cell: %v\n", cell.GetServedCellInfo())
1125 //func TestGetEnbCellByIdInteg(t *testing.T){
1126 // Init("namespace", 1)
1127 // w := GetRNibReader()
1128 // cell, err := w.GetCellById(entities.Cell_NR_CELL, "45d")
1131 // } else if cell != nil{
1132 // fmt.Printf("responding node type NR Cell: %v\n", cell.GetServedNrCell())
1136 //func TestGetListNbIdsInteg(t *testing.T) {
1137 // Init("e2Manager", 1)
1138 // w := GetRNibReader()
1139 // ids, err := w.GetListNodebIds()
1143 // for _, id := range ids{
1144 // fmt.Printf("#TestGetListGnbIdsInteg - NB ID: %s\n", id)
1149 //func TestGetRanLoadInformationInteg(t *testing.T){
1150 // Init("e2Manager", 1)
1151 // w := GetRNibReader()
1152 // ranLoadInformation, err := w.GetRanLoadInformation("ran_integ")
1154 // t.Errorf("#rNibReader_test.TestGetRanLoadInformationInteg - Failed to get RanLoadInformation entity. Error: %v", err)
1156 // assert.NotNil(t, ranLoadInformation)
1157 // fmt.Printf("#rNibReader_test.TestGetRanLoadInformationInteg - GNB ID: %s\n", ranLoadInformation)