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 TestInit(t *testing.T) {
35 assert.NotNil(t, readerPool)
36 assert.NotNil(t, readerPool.New)
37 assert.NotNil(t, readerPool.Destroy)
38 available, created := readerPool.Stats()
39 assert.Equal(t, 0, available, "number of available objects in the readerPool should be 0")
40 assert.Equal(t, 0, created, "number of created objects in the readerPool should be 0")
43 func TestInitPool(t *testing.T) {
45 sdlInstanceMock := new(MockSdlInstance)
46 initPool(1, func() interface{} {
47 sdlI := common.ISdlInstance(sdlInstanceMock)
48 return &rNibReaderInstance{sdl: &sdlI, namespace: namespace}
50 func(obj interface{}) {
53 assert.NotNil(t, readerPool)
54 assert.NotNil(t, readerPool.New)
55 assert.NotNil(t, readerPool.Destroy)
56 available, created := readerPool.Stats()
57 assert.Equal(t, 0, available, "number of available objects in the readerPool should be 0")
58 assert.Equal(t, 0, created, "number of created objects in the readerPool should be 0")
61 func initSdlInstanceMock(namespace string, poolSize int) *MockSdlInstance {
62 sdlInstanceMock := new(MockSdlInstance)
63 initPool(poolSize, func() interface{} {
64 sdlI := common.ISdlInstance(sdlInstanceMock)
65 return &rNibReaderInstance{sdl: &sdlI, namespace: namespace}
67 func(obj interface{}) {
70 return sdlInstanceMock
73 func TestGetNodeB(t *testing.T) {
76 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
77 w := &rNibReaderInstance{}
78 nb := entities.NodebInfo{}
79 nb.ConnectionStatus = 1
83 cell := entities.ServedCellInfo{Tac: "tac"}
84 enb.ServedCells = []*entities.ServedCellInfo{&cell}
85 nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
87 data, err := proto.Marshal(&nb)
89 t.Errorf("#rNibReader_test.TestGetNb - Failed to marshal ENB instance. Error: %v", err)
91 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
93 t.Errorf("#rNibReader_test.TestGetNodeB - failed to validate key parameter")
95 ret := map[string]interface{}{redisKey: string(data)}
96 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
97 getNb, er := w.GetNodeb(name)
99 assert.Equal(t, getNb.Ip, nb.Ip)
100 assert.Equal(t, getNb.Port, nb.Port)
101 assert.Equal(t, getNb.ConnectionStatus, nb.ConnectionStatus)
102 assert.Len(t, getNb.GetEnb().GetServedCells(), 1)
103 assert.Equal(t, getNb.GetEnb().GetServedCells()[0].Tac, nb.GetEnb().GetServedCells()[0].Tac)
106 func TestGetNodeBNotFoundFailure(t *testing.T) {
109 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
110 w := &rNibReaderInstance{}
112 var ret map[string]interface{}
113 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
115 t.Errorf("#rNibReader_test.TestGetNodeBNotFoundFailure - 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.ResourceNotFoundError{}, er)
122 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.NodebInfo not found. Key: RAN:name", er.Error())
125 func TestGetNodeBUnmarshalFailure(t *testing.T) {
128 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
129 w := &rNibReaderInstance{}
131 ret := make(map[string]interface{}, 1)
132 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
134 t.Errorf("#rNibReader_test.TestGetNodeBUnmarshalFailure - failed to validate key parameter")
136 ret[redisKey] = "data"
137 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
138 getNb, er := w.GetNodeb(name)
141 assert.IsType(t, &common.InternalError{}, er)
142 assert.EqualValues(t, "proto: can't skip unknown wire type 4", er.Error())
145 func TestGetNodeBSdlgoFailure(t *testing.T) {
147 errMsg := "expected Sdlgo error"
148 errMsgExpected := "expected Sdlgo error"
150 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
151 w := &rNibReaderInstance{}
152 e := errors.New(errMsg)
153 var ret map[string]interface{}
154 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
156 t.Errorf("#rNibReader_test.TestGetNodeBSdlgoFailure - failed to validate key parameter")
158 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
159 getNb, er := w.GetNodeb(name)
162 assert.IsType(t, &common.InternalError{}, er)
163 assert.EqualValues(t, errMsgExpected, er.Error())
166 func TestGetNodeBCellsListEnb(t *testing.T) {
169 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
170 w := &rNibReaderInstance{}
171 nb := entities.NodebInfo{}
172 nb.ConnectionStatus = 1
175 enb := entities.Enb{}
176 cell := entities.ServedCellInfo{Tac: "tac"}
177 enb.ServedCells = []*entities.ServedCellInfo{&cell}
178 nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
180 data, err := proto.Marshal(&nb)
182 t.Errorf("#rNibReader_test.GetNodeBCellsList - Failed to marshal ENB instance. Error: %v", err)
184 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
186 t.Errorf("#rNibReader_test.TestGetNodeBCellsListEnb - failed to validate key parameter")
188 ret := map[string]interface{}{redisKey: string(data)}
189 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
190 cells, er := w.GetCellList(name)
192 assert.NotNil(t, cells)
193 assert.Len(t, cells.GetServedCellInfos().GetServedCells(), 1)
194 retCell := cells.GetServedCellInfos().GetServedCells()[0]
195 assert.Equal(t, retCell.Tac, "tac")
198 func TestGetNodeBCellsListGnb(t *testing.T) {
201 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
202 w := &rNibReaderInstance{}
203 nb := entities.NodebInfo{}
204 nb.ConnectionStatus = 1
207 nb.NodeType = entities.Node_GNB
208 gnb := entities.Gnb{}
209 cell := entities.ServedNRCell{ServedNrCellInformation: &entities.ServedNRCellInformation{NrPci: 10}}
210 gnb.ServedNrCells = []*entities.ServedNRCell{&cell}
211 nb.Configuration = &entities.NodebInfo_Gnb{Gnb: &gnb}
213 data, err := proto.Marshal(&nb)
215 t.Errorf("#rNibReader_test.GetNodeBCellsList - Failed to marshal GNB instance. Error: %v", err)
217 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
219 t.Errorf("#rNibReader_test.TestGetNodeBCellsListGnb - failed to validate key parameter")
221 ret := map[string]interface{}{redisKey: string(data)}
222 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
223 cells, er := w.GetCellList(name)
225 assert.NotNil(t, cells)
226 assert.Len(t, cells.GetServedNrCells().GetServedCells(), 1)
227 retCell := cells.GetServedNrCells().GetServedCells()[0]
228 assert.Equal(t, retCell.GetServedNrCellInformation().GetNrPci(), uint32(10))
231 func TestGetNodeBCellsListNodeUnmarshalFailure(t *testing.T) {
234 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
235 w := &rNibReaderInstance{}
237 ret := make(map[string]interface{}, 1)
238 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
240 t.Errorf("#rNibReader_test.TestGetNodeBCellsListNodeUnmarshalFailure - failed to validate key parameter")
242 ret[redisKey] = "data"
243 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
244 cells, er := w.GetCellList(name)
247 assert.IsType(t, &common.InternalError{}, er)
248 assert.EqualValues(t, "proto: can't skip unknown wire type 4", er.Error())
251 func TestGetNodeBCellsListNodeNotFoundFailure(t *testing.T) {
254 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
255 w := &rNibReaderInstance{}
257 var ret map[string]interface{}
258 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
260 t.Errorf("#rNibReader_test.TestGetNodeBCellsListNodeNotFoundFailure - failed to validate key parameter")
262 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
263 cells, er := w.GetCellList(name)
266 assert.IsType(t, &common.ResourceNotFoundError{}, er)
267 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.NodebInfo not found. Key: RAN:name", er.Error())
270 func TestGetNodeBCellsListNotFoundFailureEnb(t *testing.T) {
273 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
274 w := &rNibReaderInstance{}
275 nb := entities.NodebInfo{}
276 nb.ConnectionStatus = 1
279 enb := entities.Enb{}
280 nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
282 data, err := proto.Marshal(&nb)
284 t.Errorf("#rNibReader_test.TestGetNbCellsListNotFoundFailure - Failed to marshal ENB instance. Error: %v", err)
286 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
288 t.Errorf("#rNibReader_test.TestGetNodeBCellsListNotFoundFailureEnb - failed to validate key parameter")
290 ret := map[string]interface{}{redisKey: string(data)}
291 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
292 _, er := w.GetCellList(name)
294 assert.EqualValues(t, "#rNibReader.GetCellList - served cells not found. Responding node RAN name: name.", er.Error())
297 func TestGetNodeBCellsListNotFoundFailureGnb(t *testing.T) {
300 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
301 w := &rNibReaderInstance{}
302 nb := entities.NodebInfo{}
303 nb.ConnectionStatus = 1
306 gnb := entities.Gnb{}
307 nb.Configuration = &entities.NodebInfo_Gnb{Gnb: &gnb}
309 data, err := proto.Marshal(&nb)
311 t.Errorf("#rNibReader_test.TestGetNodeBCellsListNotFoundFailureGnb - Failed to marshal ENB instance. Error: %v", err)
313 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
315 t.Errorf("#rNibReader_test.TestGetNodeBCellsListNotFoundFailureGnb - failed to validate key parameter")
317 ret := map[string]interface{}{redisKey: string(data)}
318 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
319 _, er := w.GetCellList(name)
321 assert.EqualValues(t, "#rNibReader.GetCellList - served cells not found. Responding node RAN name: name.", er.Error())
324 func TestCloseOnClosedPoolFailure(t *testing.T) {
326 instanceMock := initSdlInstanceMock(namespace, 1)
327 w1 := &rNibReaderInstance{}
328 _, err := w1.GetNodeb("")
330 t.Errorf("#rNibReader_test.TestCloseOnClosedPoolFailure - failed to validate key parameter")
333 available, created := readerPool.Stats()
334 assert.Equal(t, 1, available, "number of available objects in the readerPool should be 1")
335 assert.Equal(t, 1, created, "number of created objects in the readerPool should be 1")
337 instanceMock.On("Close").Return(e)
339 assert.Panics(t, func() { Close() })
342 func TestCloseFailure(t *testing.T) {
344 instanceMock := initSdlInstanceMock(namespace, 2)
345 w1 := &rNibReaderInstance{}
346 _, err := w1.GetNodeb("")
348 t.Errorf("#rNibReader_test.TestCloseFailure - failed to validate key parameter")
350 available, created := readerPool.Stats()
351 assert.Equal(t, 1, available, "number of available objects in the readerPool should be 2")
352 assert.Equal(t, 1, created, "number of created objects in the readerPool should be 1")
353 e := errors.New("expected error")
354 instanceMock.On("Close").Return(e)
356 available, created = readerPool.Stats()
357 assert.Equal(t, 0, available, "number of available objects in the readerPool should be 0")
358 assert.Equal(t, 0, created, "number of created objects in the readerPool should be 0")
361 func TestGetListGnbIdsUnmarshalFailure(t *testing.T) {
363 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
364 w := &rNibReaderInstance{}
366 sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return([]string{"data"}, e)
367 ids, er := w.GetListGnbIds()
370 assert.IsType(t, &common.InternalError{}, er)
371 assert.Equal(t, "proto: can't skip unknown wire type 4", er.Error())
374 func TestGetListGnbIdsSdlgoFailure(t *testing.T) {
375 errMsg := "expected Sdlgo error"
376 errMsgExpected := "expected Sdlgo error"
378 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
379 w := &rNibReaderInstance{}
380 e := errors.New(errMsg)
382 sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return(data, e)
383 ids, er := w.GetListGnbIds()
386 assert.IsType(t, &common.InternalError{}, er)
387 assert.EqualValues(t, errMsgExpected, er.Error())
390 func TestGetListNodesIdsGnbSdlgoFailure(t *testing.T) {
393 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
394 w := &rNibReaderInstance{}
399 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
401 data, err := proto.Marshal(nbIdentity)
403 t.Errorf("#rNibReader_test.TestGetListNodesIdsGnbSdlgoFailure - Failed to marshal nodeb identity entity. Error: %v", err)
405 sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{string(data)}, nilError)
407 errMsg := "expected Sdlgo error"
408 errMsgExpected := "expected Sdlgo error"
409 expectedError := errors.New(errMsg)
411 sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return(nilData, expectedError)
413 ids, er := w.GetListNodebIds()
416 assert.IsType(t, &common.InternalError{}, er)
417 assert.EqualValues(t, errMsgExpected, er.Error())
420 func TestGetListNodesIdsEnbSdlgoFailure(t *testing.T) {
423 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
424 w := &rNibReaderInstance{}
429 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
431 data, err := proto.Marshal(nbIdentity)
433 t.Errorf("#rNibReader_test.TestGetListNodesIdsEnbSdlgoFailure - Failed to marshal nodeb identity entity. Error: %v", err)
435 sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return([]string{string(data)}, nilError)
437 errMsg := "expected Sdlgo error"
438 errMsgExpected := "expected Sdlgo error"
439 expectedError := errors.New(errMsg)
441 sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return(nilData, expectedError)
443 ids, er := w.GetListNodebIds()
446 assert.IsType(t, &common.InternalError{}, er)
447 assert.EqualValues(t, errMsgExpected, er.Error())
450 func TestGetListNodesIdsSuccess(t *testing.T) {
453 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
454 w := &rNibReaderInstance{}
460 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
461 data, err := proto.Marshal(nbIdentity)
463 t.Errorf("#rNibReader_test.TestGetListNodesIdsSuccess - Failed to marshal nodeb identity entity. Error: %v", err)
469 nbIdentity1 := &entities.NbIdentity{InventoryName: name1, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId1, NbId: nbId1}}
470 data1, err := proto.Marshal(nbIdentity1)
472 t.Errorf("#rNibReader_test.TestGetListNodesIdsSuccess - Failed to marshal nodeb identity entity. Error: %v", err)
476 nbIdentity2 := &entities.NbIdentity{InventoryName: name2}
477 data2, err := proto.Marshal(nbIdentity2)
479 t.Errorf("#rNibReader_test.TestGetListNodesIdsSuccess - Failed to marshal nodeb identity entity. Error: %v", err)
482 sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return([]string{string(data)}, nilError)
483 sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{string(data1)}, nilError)
484 sdlInstanceMock.On("GetMembers", entities.Node_UNKNOWN.String()).Return([]string{string(data2)}, nilError)
486 ids, er := w.GetListNodebIds()
488 assert.NotNil(t, ids)
489 assert.Len(t, ids, 3)
492 func TestGetListEnbIdsUnmarshalFailure(t *testing.T) {
494 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
495 w := &rNibReaderInstance{}
497 sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{"data"}, e)
498 ids, er := w.GetListEnbIds()
501 assert.IsType(t, &common.InternalError{}, er)
502 assert.Equal(t, "proto: can't skip unknown wire type 4", er.Error())
505 func TestGetListEnbIdsOneId(t *testing.T) {
510 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
511 w := &rNibReaderInstance{}
512 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
514 data, err := proto.Marshal(nbIdentity)
516 t.Errorf("#rNibReader_test.TestGetListEnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
518 sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{string(data)}, e)
519 ids, er := w.GetListEnbIds()
521 assert.Len(t, ids, 1)
522 assert.Equal(t, (ids)[0].GetInventoryName(), name)
523 assert.Equal(t, (ids)[0].GetGlobalNbId().GetPlmnId(), nbIdentity.GetGlobalNbId().GetPlmnId())
524 assert.Equal(t, (ids)[0].GetGlobalNbId().GetNbId(), nbIdentity.GetGlobalNbId().GetNbId())
527 func TestGetListEnbIdsNoIds(t *testing.T) {
529 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
530 w := &rNibReaderInstance{}
532 sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{}, e)
533 ids, er := w.GetListEnbIds()
535 assert.Len(t, ids, 0)
538 func TestGetListEnbIds(t *testing.T) {
544 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
545 w := &rNibReaderInstance{}
546 idsData := make([]string, listSize)
547 idsEntities := make([]*entities.NbIdentity, listSize)
548 for i := 0; i < listSize; i++ {
549 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: string(plmnId + i), NbId: string(nbId + i)}}
550 data, err := proto.Marshal(nbIdentity)
552 t.Errorf("#rNibReader_test.TestGetListEnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
554 idsData[i] = string(data)
555 idsEntities[i] = nbIdentity
558 sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return(idsData, e)
559 ids, er := w.GetListEnbIds()
561 assert.Len(t, ids, listSize)
562 for i, id := range ids {
563 assert.Equal(t, id.GetInventoryName(), name)
564 assert.Equal(t, id.GetGlobalNbId().GetPlmnId(), idsEntities[i].GetGlobalNbId().GetPlmnId())
565 assert.Equal(t, id.GetGlobalNbId().GetNbId(), idsEntities[i].GetGlobalNbId().GetNbId())
569 func TestGetListGnbIdsOneId(t *testing.T) {
574 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
575 w := &rNibReaderInstance{}
576 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
578 data, err := proto.Marshal(nbIdentity)
580 t.Errorf("#rNibReader_test.TestGetListGnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
582 sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return([]string{string(data)}, e)
583 ids, er := w.GetListGnbIds()
585 assert.Len(t, ids, 1)
586 assert.Equal(t, (ids)[0].GetInventoryName(), name)
587 assert.Equal(t, (ids)[0].GetGlobalNbId().GetPlmnId(), nbIdentity.GetGlobalNbId().GetPlmnId())
588 assert.Equal(t, (ids)[0].GetGlobalNbId().GetNbId(), nbIdentity.GetGlobalNbId().GetNbId())
591 func TestGetListGnbIdsNoIds(t *testing.T) {
593 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
594 w := &rNibReaderInstance{}
596 sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return([]string{}, e)
597 ids, er := w.GetListGnbIds()
599 assert.Len(t, ids, 0)
602 func TestGetListGnbIds(t *testing.T) {
608 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
609 w := &rNibReaderInstance{}
610 idsData := make([]string, listSize)
611 idsEntities := make([]*entities.NbIdentity, listSize)
612 for i := 0; i < listSize; i++ {
613 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: string(plmnId + i), NbId: string(nbId + i)}}
614 data, err := proto.Marshal(nbIdentity)
616 t.Errorf("#rNibReader_test.TestGetListGnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
618 idsData[i] = string(data)
619 idsEntities[i] = nbIdentity
622 sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return(idsData, e)
623 ids, er := w.GetListGnbIds()
625 assert.Len(t, ids, listSize)
626 for i, id := range ids {
627 assert.Equal(t, id.GetInventoryName(), name)
628 assert.Equal(t, id.GetGlobalNbId().GetPlmnId(), idsEntities[i].GetGlobalNbId().GetPlmnId())
629 assert.Equal(t, id.GetGlobalNbId().GetNbId(), idsEntities[i].GetGlobalNbId().GetNbId())
633 func TestGetListEnbIdsSdlgoFailure(t *testing.T) {
634 errMsg := "expected Sdlgo error"
635 errMsgExpected := "expected Sdlgo error"
637 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
638 w := &rNibReaderInstance{}
639 e := errors.New(errMsg)
641 sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return(data, e)
642 ids, er := w.GetListEnbIds()
645 assert.IsType(t, &common.InternalError{}, er)
646 assert.EqualValues(t, errMsgExpected, er.Error())
649 func TestGetCountGnbListOneId(t *testing.T) {
651 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
652 w := &rNibReaderInstance{}
654 sdlInstanceMock.On("GroupSize", entities.Node_GNB.String()).Return(1, e)
655 count, er := w.GetCountGnbList()
657 assert.Equal(t, count, 1)
660 func TestGetCountGnbList(t *testing.T) {
662 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
663 w := &rNibReaderInstance{}
665 sdlInstanceMock.On("GroupSize", entities.Node_GNB.String()).Return(3, e)
666 count, er := w.GetCountGnbList()
668 assert.Equal(t, count, 3)
671 func TestGetCountGnbListSdlgoFailure(t *testing.T) {
672 errMsg := "expected Sdlgo error"
673 errMsgExpected := "expected Sdlgo error"
675 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
676 w := &rNibReaderInstance{}
677 e := errors.New(errMsg)
679 sdlInstanceMock.On("GroupSize", entities.Node_GNB.String()).Return(count, e)
680 count, er := w.GetCountGnbList()
682 assert.Equal(t, 0, count)
683 assert.IsType(t, &common.InternalError{}, er)
684 assert.EqualValues(t, errMsgExpected, er.Error())
687 func TestGetCell(t *testing.T) {
691 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
692 w := &rNibReaderInstance{}
693 cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: &entities.ServedCellInfo{Pci: pci}}}
694 cellData, err := proto.Marshal(&cellEntity)
696 t.Errorf("#rNibReader_test.TestGetCell - Failed to marshal Cell entity. Error: %v", err)
699 key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
701 t.Errorf("#rNibReader_test.TestGetCell - failed to validate key parameter")
703 ret := map[string]interface{}{key: string(cellData)}
704 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
705 cell, er := w.GetCell(name, pci)
707 assert.NotNil(t, cell)
708 assert.Equal(t, cell.Type, entities.Cell_LTE_CELL)
709 assert.NotNil(t, cell.GetServedCellInfo())
710 assert.Equal(t, cell.GetServedCellInfo().GetPci(), pci)
713 func TestGetCellNotFoundFailure(t *testing.T) {
717 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
718 w := &rNibReaderInstance{}
720 var ret map[string]interface{}
721 key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
723 t.Errorf("#rNibReader_test.TestGetCellNotFoundFailure - failed to validate key parameter")
725 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
726 cell, er := w.GetCell(name, pci)
729 assert.IsType(t, &common.ResourceNotFoundError{}, er)
730 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.Cell not found. Key: PCI:name:00", er.Error())
733 func TestGetCellUnmarshalFailure(t *testing.T) {
737 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
738 w := &rNibReaderInstance{}
740 ret := make(map[string]interface{}, 1)
741 key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
743 t.Errorf("#rNibReader_test.TestGetCellUnmarshalFailure - failed to validate key parameter")
746 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
747 cell, er := w.GetCell(name, pci)
750 assert.IsType(t, &common.InternalError{}, er)
751 assert.EqualValues(t, "proto: can't skip unknown wire type 4", er.Error())
754 func TestGetCellSdlgoFailure(t *testing.T) {
757 errMsg := "expected Sdlgo error"
758 errMsgExpected := "expected Sdlgo error"
760 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
761 w := &rNibReaderInstance{}
762 e := errors.New(errMsg)
763 var ret map[string]interface{}
764 key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
766 t.Errorf("#rNibReader_test.TestGetCellSdlgoFailure - failed to validate key parameter")
768 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
769 cell, er := w.GetCell(name, pci)
772 assert.IsType(t, &common.InternalError{}, er)
773 assert.EqualValues(t, errMsgExpected, er.Error())
776 func TestGetNodebById(t *testing.T) {
778 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
779 w := &rNibReaderInstance{}
780 nb := entities.NodebInfo{NodeType: entities.Node_ENB}
781 nb.ConnectionStatus = 1
784 enb := entities.Enb{}
785 cell := entities.ServedCellInfo{Tac: "tac"}
786 enb.ServedCells = []*entities.ServedCellInfo{&cell}
787 nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
789 data, err := proto.Marshal(&nb)
791 t.Errorf("#rNibReader_test.TestGetNodebById - Failed to marshal ENB instance. Error: %v", err)
796 key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_ENB.String(), plmnId, nbId)
798 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
800 ret := map[string]interface{}{key: string(data)}
801 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
802 globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
803 getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
805 assert.Equal(t, getNb.Ip, nb.Ip)
806 assert.Equal(t, getNb.Port, nb.Port)
807 assert.Equal(t, getNb.ConnectionStatus, nb.ConnectionStatus)
808 assert.Len(t, getNb.GetEnb().GetServedCells(), 1)
809 assert.Equal(t, getNb.GetEnb().GetServedCells()[0].Tac, nb.GetEnb().GetServedCells()[0].Tac)
812 func TestGetNodebByIdNotFoundFailureEnb(t *testing.T) {
816 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
817 w := &rNibReaderInstance{}
819 key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_ENB.String(), plmnId, nbId)
821 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
823 var ret map[string]interface{}
824 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
825 globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
826 getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
829 assert.IsType(t, &common.ResourceNotFoundError{}, er)
830 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.NodebInfo not found. Key: ENB:02f829:4a952a0a", er.Error())
833 func TestGetNodebByIdNotFoundFailureGnb(t *testing.T) {
837 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
838 w := &rNibReaderInstance{}
840 key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_GNB.String(), plmnId, nbId)
842 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
844 var ret map[string]interface{}
845 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
846 globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
847 getNb, er := w.GetNodebByGlobalNbId(entities.Node_GNB, globalNbId)
850 assert.IsType(t, &common.ResourceNotFoundError{}, er)
851 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.NodebInfo not found. Key: GNB:02f829:4a952a0a", er.Error())
854 func TestGetNodeByIdUnmarshalFailure(t *testing.T) {
858 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
859 w := &rNibReaderInstance{}
860 key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_ENB.String(), plmnId, nbId)
862 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
865 ret := make(map[string]interface{}, 1)
867 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
868 globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
869 getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
872 assert.IsType(t, &common.InternalError{}, er)
873 assert.EqualValues(t, "proto: can't skip unknown wire type 4", er.Error())
876 func TestGetNodeByIdSdlgoFailure(t *testing.T) {
879 errMsg := "expected Sdlgo error"
880 errMsgExpected := "expected Sdlgo error"
882 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
883 w := &rNibReaderInstance{}
884 key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_GNB.String(), plmnId, nbId)
886 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
888 e := errors.New(errMsg)
889 var ret map[string]interface{}
890 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
891 globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
892 getNb, er := w.GetNodebByGlobalNbId(entities.Node_GNB, globalNbId)
895 assert.IsType(t, &common.InternalError{}, er)
896 assert.EqualValues(t, errMsgExpected, er.Error())
899 func TestGetCellById(t *testing.T) {
903 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
904 w := &rNibReaderInstance{}
905 cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: &entities.ServedCellInfo{Pci: pci}}}
906 cellData, err := proto.Marshal(&cellEntity)
908 t.Errorf("#rNibReader_test.TestGetCellById - Failed to marshal Cell entity. Error: %v", err)
911 key, rNibErr := common.ValidateAndBuildCellIdKey(cellId)
913 t.Errorf("#rNibReader_test.TestGetCellById - failed to validate key parameter")
915 ret := map[string]interface{}{key: string(cellData)}
916 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
917 cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
919 assert.NotNil(t, cell)
920 assert.Equal(t, cell.Type, entities.Cell_LTE_CELL)
921 assert.NotNil(t, cell.GetServedCellInfo())
922 assert.Equal(t, cell.GetServedCellInfo().GetPci(), pci)
925 func TestGetCellByIdNotFoundFailureEnb(t *testing.T) {
928 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
929 w := &rNibReaderInstance{}
931 var ret map[string]interface{}
932 key, rNibErr := common.ValidateAndBuildCellIdKey(cellId)
934 t.Errorf("#rNibReader_test.TestGetCellByIdNotFoundFailure - failed to validate key parameter")
936 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
937 cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
940 assert.IsType(t, &common.ResourceNotFoundError{}, er)
941 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.Cell not found. Key: CELL:bbbb", er.Error())
944 func TestGetCellByIdNotFoundFailureGnb(t *testing.T) {
947 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
948 w := &rNibReaderInstance{}
950 var ret map[string]interface{}
951 key, rNibErr := common.ValidateAndBuildNrCellIdKey(cellId)
953 t.Errorf("#rNibReader_test.TestGetCellByIdNotFoundFailure - failed to validate key parameter")
955 sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
956 cell, er := w.GetCellById(entities.Cell_NR_CELL, cellId)
959 assert.IsType(t, &common.ResourceNotFoundError{}, er)
960 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.Cell not found. Key: NRCELL:bbbb", er.Error())
963 func TestGetCellByIdTypeValidationFailure(t *testing.T) {
966 initSdlInstanceMock(namespace, 1)
967 w := &rNibReaderInstance{}
968 cell, er := w.GetCellById(5, cellId)
971 assert.IsType(t, &common.ValidationError{}, er)
972 assert.EqualValues(t, "#rNibReader.GetCellById - invalid cell type: 5", er.Error())
975 func TestGetCellByIdValidationFailureGnb(t *testing.T) {
978 initSdlInstanceMock(namespace, 1)
979 w := &rNibReaderInstance{}
980 cell, er := w.GetCellById(entities.Cell_NR_CELL, cellId)
983 assert.IsType(t, &common.ValidationError{}, er)
984 assert.EqualValues(t, "#utils.ValidateAndBuildNrCellIdKey - an empty cell id received", er.Error())
987 func TestGetCellByIdValidationFailureEnb(t *testing.T) {
990 initSdlInstanceMock(namespace, 1)
991 w := &rNibReaderInstance{}
992 cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
995 assert.IsType(t, &common.ValidationError{}, er)
996 assert.EqualValues(t, "#utils.ValidateAndBuildCellIdKey - an empty cell id received", er.Error())
999 func TestGetRanLoadInformation(t *testing.T) {
1002 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
1003 w := &rNibReaderInstance{}
1004 loadInfo := generateRanLoadInformation()
1006 data, err := proto.Marshal(loadInfo)
1008 t.Errorf("#rNibReader_test.TestGetRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
1010 redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
1012 t.Errorf("#rNibReader_test.TestGetRanLoadInformationNotFoundFailure - failed to validate key parameter")
1014 ret := map[string]interface{}{redisKey: string(data)}
1015 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
1016 getLoadInfo, er := w.GetRanLoadInformation(name)
1018 assert.NotNil(t, getLoadInfo)
1019 expected, err := json.Marshal(loadInfo)
1021 t.Errorf("#rNibReader_test.TestGetRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
1023 actual, err := json.Marshal(getLoadInfo)
1025 t.Errorf("#rNibReader_test.TestGetRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
1027 assert.EqualValues(t, expected, actual)
1030 func TestGetRanLoadInformationValidationFailure(t *testing.T) {
1033 initSdlInstanceMock(namespace, 1)
1034 w := &rNibReaderInstance{}
1035 getNb, er := w.GetRanLoadInformation(name)
1036 assert.NotNil(t, er)
1037 assert.Nil(t, getNb)
1038 assert.IsType(t, &common.ValidationError{}, er)
1039 assert.EqualValues(t, "#utils.ValidateAndBuildRanLoadInformationKey - an empty inventory name received", er.Error())
1042 func TestGetRanLoadInformationNotFoundFailure(t *testing.T) {
1045 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
1046 w := &rNibReaderInstance{}
1048 var ret map[string]interface{}
1049 redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
1051 t.Errorf("#rNibReader_test.TestGetRanLoadInformationNotFoundFailure - failed to validate key parameter")
1053 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
1054 getNb, er := w.GetRanLoadInformation(name)
1055 assert.NotNil(t, er)
1056 assert.Nil(t, getNb)
1057 assert.IsType(t, &common.ResourceNotFoundError{}, er)
1058 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.RanLoadInformation not found. Key: LOAD:name", er.Error())
1061 func TestGetRanLoadInformationUnmarshalFailure(t *testing.T) {
1064 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
1065 w := &rNibReaderInstance{}
1067 ret := make(map[string]interface{}, 1)
1068 redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
1070 t.Errorf("#rNibReader_test.TestGetRanLoadInformationUnmarshalFailure - failed to validate key parameter")
1072 ret[redisKey] = "data"
1073 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
1074 getNb, er := w.GetRanLoadInformation(name)
1075 assert.NotNil(t, er)
1076 assert.Nil(t, getNb)
1077 assert.IsType(t, &common.InternalError{}, er)
1078 assert.EqualValues(t, "proto: can't skip unknown wire type 4", er.Error())
1081 func TestGetRanLoadInformationSdlgoFailure(t *testing.T) {
1083 errMsg := "expected Sdlgo error"
1084 errMsgExpected := "expected Sdlgo error"
1086 sdlInstanceMock := initSdlInstanceMock(namespace, 1)
1087 w := &rNibReaderInstance{}
1088 e := errors.New(errMsg)
1089 var ret map[string]interface{}
1090 redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
1092 t.Errorf("#rNibReader_test.TestGetRanLoadInformationSdlgoFailure - failed to validate key parameter")
1094 sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
1095 getNb, er := w.GetRanLoadInformation(name)
1096 assert.NotNil(t, er)
1097 assert.Nil(t, getNb)
1098 assert.IsType(t, &common.InternalError{}, er)
1099 assert.EqualValues(t, errMsgExpected, er.Error())
1102 func generateCellLoadInformation() *entities.CellLoadInformation {
1103 cellLoadInformation := entities.CellLoadInformation{}
1105 cellLoadInformation.CellId = "123"
1107 ulInterferenceOverloadIndication := entities.UlInterferenceOverloadIndication_HIGH_INTERFERENCE
1108 cellLoadInformation.UlInterferenceOverloadIndications = []entities.UlInterferenceOverloadIndication{ulInterferenceOverloadIndication}
1110 ulHighInterferenceInformation := entities.UlHighInterferenceInformation{
1112 UlHighInterferenceIndication:"xxx",
1115 cellLoadInformation.UlHighInterferenceInfos = []*entities.UlHighInterferenceInformation{&ulHighInterferenceInformation }
1117 cellLoadInformation.RelativeNarrowbandTxPower = &entities.RelativeNarrowbandTxPower{
1119 RntpThreshold:entities.RntpThreshold_NEG_4,
1120 NumberOfCellSpecificAntennaPorts: entities.NumberOfCellSpecificAntennaPorts_V1_ANT_PRT,
1122 PdcchInterferenceImpact:2,
1123 EnhancedRntp: &entities.EnhancedRntp{
1124 EnhancedRntpBitmap:"xxx",
1125 RntpHighPowerThreshold:entities.RntpThreshold_NEG_2,
1126 EnhancedRntpStartTime: &entities.StartTime{StartSfn:500,StartSubframeNumber:5},
1130 cellLoadInformation.AbsInformation = &entities.AbsInformation{
1131 Mode: entities.AbsInformationMode_ABS_INFO_FDD,
1132 AbsPatternInfo:"xxx",
1133 NumberOfCellSpecificAntennaPorts:entities.NumberOfCellSpecificAntennaPorts_V2_ANT_PRT,
1134 MeasurementSubset:"xxx",
1137 cellLoadInformation.InvokeIndication = entities.InvokeIndication_ABS_INFORMATION
1139 cellLoadInformation.ExtendedUlInterferenceOverloadInfo = &entities.ExtendedUlInterferenceOverloadInfo{
1140 AssociatedSubframes:"xxx",
1141 ExtendedUlInterferenceOverloadIndications:cellLoadInformation.UlInterferenceOverloadIndications,
1144 compInformationItem := &entities.CompInformationItem{
1145 CompHypothesisSets: []*entities.CompHypothesisSet{{CellId: "789", CompHypothesis: "xxx"}},
1149 cellLoadInformation.CompInformation = &entities.CompInformation{
1150 CompInformationItems:[]*entities.CompInformationItem{compInformationItem},
1151 CompInformationStartTime:&entities.StartTime{StartSfn:123,StartSubframeNumber:456},
1154 cellLoadInformation.DynamicDlTransmissionInformation = &entities.DynamicDlTransmissionInformation{
1155 State: entities.NaicsState_NAICS_ACTIVE,
1156 TransmissionModes:"xxx",
1158 PAList:[]entities.PA{entities.PA_DB_NEG_3},
1161 return &cellLoadInformation
1164 func generateRanLoadInformation() *entities.RanLoadInformation {
1165 ranLoadInformation := entities.RanLoadInformation{}
1167 ranLoadInformation.LoadTimestamp = uint64(time.Now().UnixNano())
1169 cellLoadInformation := generateCellLoadInformation()
1170 ranLoadInformation.CellLoadInfos = []*entities.CellLoadInformation{cellLoadInformation}
1172 return &ranLoadInformation
1177 //func TestGetEnbInteg(t *testing.T){
1178 // name := "nameEnb1"
1179 // Init("namespace", 1)
1180 // w := &rNibReaderInstance{}
1181 // nb, err := w.GetNodeb(name)
1185 // fmt.Printf("#TestGetEnbInteg - responding node type: %v\n", nb)
1189 //func TestGetEnbCellsInteg(t *testing.T){
1190 // name := "nameEnb1"
1191 // Init("namespace", 1)
1192 // w := &rNibReaderInstance{}
1193 // cells, err := w.GetCellList(name)
1196 // } else if cells != nil{
1197 // for _, cell := range cells.GetServedCellInfos().ServedCells{
1198 // fmt.Printf("responding node type Cell: %v\n", *cell)
1203 //func TestGetGnbInteg(t *testing.T){
1204 // name := "nameGnb1"
1205 // Init("namespace", 1)
1206 // w := &rNibReaderInstance{}
1207 // nb, err := w.GetNodeb(name)
1211 // fmt.Printf("#TestGetGnbInteg - responding node type: %v\n", nb)
1215 //func TestGetGnbCellsInteg(t *testing.T){
1216 // name := "nameGnb1"
1217 // Init("namespace", 1)
1218 // w := &rNibReaderInstance{}
1219 // cells, err := w.GetCellList(name)
1222 // } else if cells != nil{
1223 // for _, cell := range cells.GetServedNrCells().ServedCells{
1224 // fmt.Printf("responding node type NR Cell: %v\n", *cell)
1229 //func TestGetListEnbIdsInteg(t *testing.T) {
1230 // Init("namespace", 1)
1231 // w := &rNibReaderInstance{}
1232 // ids, err := w.GetListEnbIds()
1236 // for _, id := range ids{
1237 // fmt.Printf("#TestGetListEnbIdsInteg - ENB ID: %s\n", id)
1242 //func TestGetListGnbIdsInteg(t *testing.T) {
1243 // Init("namespace", 1)
1244 // w := &rNibReaderInstance{}
1245 // ids, err := w.GetListGnbIds()
1249 // for _, id := range ids{
1250 // fmt.Printf("#TestGetListGnbIdsInteg - GNB ID: %s\n", id)
1255 //func TestGetCountGnbListInteg(t *testing.T) {
1256 // Init("namespace", 1)
1257 // w := &rNibReaderInstance{}
1258 // count, err := w.GetCountGnbList()
1262 // fmt.Printf("#TestGetCountGnbListInteg - count Gnb list: %d\n", count)
1266 //func TestGetGnbCellInteg(t *testing.T){
1267 // name := "nameGnb7"
1269 // Init("namespace", 1)
1270 // w := &rNibReaderInstance{}
1271 // cell, err := w.GetCell(name, uint32(pci))
1274 // } else if cell != nil{
1275 // fmt.Printf("responding node type NR Cell: %v\n", cell.GetServedNrCell())
1279 //func TestGetEnbCellInteg(t *testing.T) {
1280 // name := "nameEnb1"
1282 // Init("namespace", 1)
1283 // w := &rNibReaderInstance{}
1284 // cell, err := w.GetCell(name, uint32(pci))
1287 // } else if cell != nil {
1288 // fmt.Printf("responding node type LTE Cell: %v\n", cell.GetServedCellInfo())
1292 //func TestGetEnbCellByIdInteg(t *testing.T){
1293 // Init("namespace", 1)
1294 // w := &rNibReaderInstance{}
1295 // cell, err := w.GetCellById(entities.Cell_NR_CELL, "45d")
1298 // } else if cell != nil{
1299 // fmt.Printf("responding node type NR Cell: %v\n", cell.GetServedNrCell())
1303 //func TestGetListNbIdsInteg(t *testing.T) {
1304 // Init("e2Manager", 1)
1305 // w := &rNibReaderInstance{}
1306 // ids, err := w.GetListNodebIds()
1310 // for _, id := range ids{
1311 // fmt.Printf("#TestGetListGnbIdsInteg - NB ID: %s\n", id)
1316 //func TestGetRanLoadInformationInteg(t *testing.T){
1317 // Init("e2Manager", 1)
1318 // w := &rNibReaderInstance{}
1319 // ranLoadInformation, err := w.GetRanLoadInformation("ran_integ")
1321 // t.Errorf("#rNibReader_test.TestGetRanLoadInformationInteg - Failed to get RanLoadInformation entity. Error: %v", err)
1323 // assert.NotNil(t, ranLoadInformation)
1324 // fmt.Printf("#rNibReader_test.TestGetRanLoadInformationInteg - GNB ID: %s\n", ranLoadInformation)