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"
35 func initSdlSyncStorageMock() (w RNibReader, sdlStorageMock *MockSdlSyncStorage) {
36 sdlStorageMock = new(MockSdlSyncStorage)
37 w = GetNewRNibReader(sdlStorageMock)
41 func TestGetRNibNamespace(t *testing.T) {
42 ns := common.GetRNibNamespace()
43 assert.Equal(t, "e2Manager", ns)
46 func TestGetNodeB(t *testing.T) {
48 w, sdlInstanceMock := initSdlSyncStorageMock()
49 nb := entities.NodebInfo{}
50 nb.ConnectionStatus = 1
54 cell := entities.ServedCellInfo{Tac: "tac"}
55 enb.ServedCells = []*entities.ServedCellInfo{&cell}
56 nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
58 data, err := proto.Marshal(&nb)
60 t.Errorf("#rNibReader_test.TestGetNb - Failed to marshal ENB instance. Error: %v", err)
62 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
64 t.Errorf("#rNibReader_test.TestGetNodeB - failed to validate key parameter")
66 ret := map[string]interface{}{redisKey: string(data)}
67 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
68 getNb, er := w.GetNodeb(name)
70 assert.Equal(t, getNb.Ip, nb.Ip)
71 assert.Equal(t, getNb.Port, nb.Port)
72 assert.Equal(t, getNb.ConnectionStatus, nb.ConnectionStatus)
73 assert.Len(t, getNb.GetEnb().GetServedCells(), 1)
74 assert.Equal(t, getNb.GetEnb().GetServedCells()[0].Tac, nb.GetEnb().GetServedCells()[0].Tac)
77 func TestGetNodeBNotFoundFailure(t *testing.T) {
79 w, sdlInstanceMock := initSdlSyncStorageMock()
81 var ret map[string]interface{}
82 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
84 t.Errorf("#rNibReader_test.TestGetNodeBNotFoundFailure - failed to validate key parameter")
86 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
87 getNb, er := w.GetNodeb(name)
90 assert.IsType(t, &common.ResourceNotFoundError{}, er)
91 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.NodebInfo not found. Key: RAN:name", er.Error())
94 func TestGetNodeBUnmarshalFailure(t *testing.T) {
96 w, sdlInstanceMock := initSdlSyncStorageMock()
98 ret := make(map[string]interface{}, 1)
99 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
101 t.Errorf("#rNibReader_test.TestGetNodeBUnmarshalFailure - failed to validate key parameter")
103 ret[redisKey] = "data"
104 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
105 getNb, er := w.GetNodeb(name)
108 assert.IsType(t, &common.InternalError{}, er)
109 assert.Contains(t, er.Error(), "proto:")
112 func TestGetNodeBSdlgoFailure(t *testing.T) {
114 errMsg := "expected Sdlgo error"
115 errMsgExpected := "expected Sdlgo error"
116 w, sdlInstanceMock := initSdlSyncStorageMock()
117 e := errors.New(errMsg)
118 var ret map[string]interface{}
119 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
121 t.Errorf("#rNibReader_test.TestGetNodeBSdlgoFailure - failed to validate key parameter")
123 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
124 getNb, er := w.GetNodeb(name)
127 assert.IsType(t, &common.InternalError{}, er)
128 assert.EqualValues(t, errMsgExpected, er.Error())
131 func TestGetNodeBCellsListEnb(t *testing.T) {
133 w, sdlInstanceMock := initSdlSyncStorageMock()
134 nb := entities.NodebInfo{}
135 nb.ConnectionStatus = 1
138 enb := entities.Enb{}
139 cell := entities.ServedCellInfo{Tac: "tac"}
140 enb.ServedCells = []*entities.ServedCellInfo{&cell}
141 nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
143 data, err := proto.Marshal(&nb)
145 t.Errorf("#rNibReader_test.GetNodeBCellsList - Failed to marshal ENB instance. Error: %v", err)
147 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
149 t.Errorf("#rNibReader_test.TestGetNodeBCellsListEnb - failed to validate key parameter")
151 ret := map[string]interface{}{redisKey: string(data)}
152 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
153 cells, er := w.GetCellList(name)
155 assert.NotNil(t, cells)
156 assert.Len(t, cells.GetServedCellInfos().GetServedCells(), 1)
157 retCell := cells.GetServedCellInfos().GetServedCells()[0]
158 assert.Equal(t, retCell.Tac, "tac")
161 func TestGetNodeBCellsListGnb(t *testing.T) {
163 w, sdlInstanceMock := initSdlSyncStorageMock()
164 nb := entities.NodebInfo{}
165 nb.ConnectionStatus = 1
168 nb.NodeType = entities.Node_GNB
169 gnb := entities.Gnb{}
170 cell := entities.ServedNRCell{ServedNrCellInformation: &entities.ServedNRCellInformation{NrPci: 10}}
171 gnb.ServedNrCells = []*entities.ServedNRCell{&cell}
172 nb.Configuration = &entities.NodebInfo_Gnb{Gnb: &gnb}
174 data, err := proto.Marshal(&nb)
176 t.Errorf("#rNibReader_test.GetNodeBCellsList - Failed to marshal GNB instance. Error: %v", err)
178 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
180 t.Errorf("#rNibReader_test.TestGetNodeBCellsListGnb - failed to validate key parameter")
182 ret := map[string]interface{}{redisKey: string(data)}
183 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
184 cells, er := w.GetCellList(name)
186 assert.NotNil(t, cells)
187 assert.Len(t, cells.GetServedNrCells().GetServedCells(), 1)
188 retCell := cells.GetServedNrCells().GetServedCells()[0]
189 assert.Equal(t, retCell.GetServedNrCellInformation().GetNrPci(), uint32(10))
192 func TestGetNodeBCellsListNodeUnmarshalFailure(t *testing.T) {
194 w, sdlInstanceMock := initSdlSyncStorageMock()
196 ret := make(map[string]interface{}, 1)
197 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
199 t.Errorf("#rNibReader_test.TestGetNodeBCellsListNodeUnmarshalFailure - failed to validate key parameter")
201 ret[redisKey] = "data"
202 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
203 cells, er := w.GetCellList(name)
206 assert.IsType(t, &common.InternalError{}, er)
207 assert.Contains(t, er.Error(), "proto:")
210 func TestGetNodeBCellsListNodeNotFoundFailure(t *testing.T) {
212 w, sdlInstanceMock := initSdlSyncStorageMock()
214 var ret map[string]interface{}
215 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
217 t.Errorf("#rNibReader_test.TestGetNodeBCellsListNodeNotFoundFailure - failed to validate key parameter")
219 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
220 cells, er := w.GetCellList(name)
223 assert.IsType(t, &common.ResourceNotFoundError{}, er)
224 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.NodebInfo not found. Key: RAN:name", er.Error())
227 func TestGetNodeBCellsListNotFoundFailureEnb(t *testing.T) {
229 w, sdlInstanceMock := initSdlSyncStorageMock()
230 nb := entities.NodebInfo{}
231 nb.ConnectionStatus = 1
234 enb := entities.Enb{}
235 nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
237 data, err := proto.Marshal(&nb)
239 t.Errorf("#rNibReader_test.TestGetNbCellsListNotFoundFailure - Failed to marshal ENB instance. Error: %v", err)
241 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
243 t.Errorf("#rNibReader_test.TestGetNodeBCellsListNotFoundFailureEnb - failed to validate key parameter")
245 ret := map[string]interface{}{redisKey: string(data)}
246 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
247 _, er := w.GetCellList(name)
249 assert.EqualValues(t, "#rNibReader.GetCellList - served cells not found. Responding node RAN name: name.", er.Error())
252 func TestGetNodeBCellsListNotFoundFailureGnb(t *testing.T) {
254 w, sdlInstanceMock := initSdlSyncStorageMock()
255 nb := entities.NodebInfo{}
256 nb.ConnectionStatus = 1
259 gnb := entities.Gnb{}
260 nb.Configuration = &entities.NodebInfo_Gnb{Gnb: &gnb}
262 data, err := proto.Marshal(&nb)
264 t.Errorf("#rNibReader_test.TestGetNodeBCellsListNotFoundFailureGnb - Failed to marshal ENB instance. Error: %v", err)
266 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
268 t.Errorf("#rNibReader_test.TestGetNodeBCellsListNotFoundFailureGnb - failed to validate key parameter")
270 ret := map[string]interface{}{redisKey: string(data)}
271 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
272 _, er := w.GetCellList(name)
274 assert.EqualValues(t, "#rNibReader.GetCellList - served cells not found. Responding node RAN name: name.", er.Error())
277 func TestGetListGnbIdsUnmarshalFailure(t *testing.T) {
278 w, sdlInstanceMock := initSdlSyncStorageMock()
280 sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_GNB.String()).Return([]string{"data"}, e)
281 ids, er := w.GetListGnbIds()
284 assert.IsType(t, &common.InternalError{}, er)
285 assert.Contains(t, er.Error(), "proto:")
288 func TestGetListGnbIdsSdlgoFailure(t *testing.T) {
289 errMsg := "expected Sdlgo error"
290 errMsgExpected := "expected Sdlgo error"
291 w, sdlInstanceMock := initSdlSyncStorageMock()
292 e := errors.New(errMsg)
294 sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_GNB.String()).Return(data, e)
295 ids, er := w.GetListGnbIds()
298 assert.IsType(t, &common.InternalError{}, er)
299 assert.EqualValues(t, errMsgExpected, er.Error())
302 func TestGetListNodesIdsGnbSdlgoFailure(t *testing.T) {
303 w, sdlInstanceMock := initSdlSyncStorageMock()
308 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
310 data, err := proto.Marshal(nbIdentity)
312 t.Errorf("#rNibReader_test.TestGetListNodesIdsGnbSdlgoFailure - Failed to marshal nodeb identity entity. Error: %v", err)
314 sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_ENB.String()).Return([]string{string(data)}, nilError)
316 errMsg := "expected Sdlgo error"
317 errMsgExpected := "expected Sdlgo error"
318 expectedError := errors.New(errMsg)
320 sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_GNB.String()).Return(nilData, expectedError)
322 ids, er := w.GetListNodebIds()
325 assert.IsType(t, &common.InternalError{}, er)
326 assert.EqualValues(t, errMsgExpected, er.Error())
329 func TestGetListNodesIdsEnbSdlgoFailure(t *testing.T) {
330 w, sdlInstanceMock := initSdlSyncStorageMock()
335 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
337 data, err := proto.Marshal(nbIdentity)
339 t.Errorf("#rNibReader_test.TestGetListNodesIdsEnbSdlgoFailure - Failed to marshal nodeb identity entity. Error: %v", err)
341 sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_GNB.String()).Return([]string{string(data)}, nilError)
343 errMsg := "expected Sdlgo error"
344 errMsgExpected := "expected Sdlgo error"
345 expectedError := errors.New(errMsg)
347 sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_ENB.String()).Return(nilData, expectedError)
349 ids, er := w.GetListNodebIds()
352 assert.IsType(t, &common.InternalError{}, er)
353 assert.EqualValues(t, errMsgExpected, er.Error())
356 func TestGetListNodesIdsSuccess(t *testing.T) {
357 w, sdlInstanceMock := initSdlSyncStorageMock()
363 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
364 data, err := proto.Marshal(nbIdentity)
366 t.Errorf("#rNibReader_test.TestGetListNodesIdsSuccess - Failed to marshal nodeb identity entity. Error: %v", err)
372 nbIdentity1 := &entities.NbIdentity{InventoryName: name1, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId1, NbId: nbId1}}
373 data1, err := proto.Marshal(nbIdentity1)
375 t.Errorf("#rNibReader_test.TestGetListNodesIdsSuccess - Failed to marshal nodeb identity entity. Error: %v", err)
378 sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_GNB.String()).Return([]string{string(data)}, nilError)
379 sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_ENB.String()).Return([]string{string(data1)}, nilError)
381 ids, er := w.GetListNodebIds()
383 assert.NotNil(t, ids)
384 assert.Len(t, ids, 2)
387 func TestGetListEnbIdsUnmarshalFailure(t *testing.T) {
388 w, sdlInstanceMock := initSdlSyncStorageMock()
390 sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_ENB.String()).Return([]string{"data"}, e)
391 ids, er := w.GetListEnbIds()
394 assert.IsType(t, &common.InternalError{}, er)
395 assert.Contains(t, er.Error(), "proto:")
398 func TestGetListEnbIdsOneId(t *testing.T) {
402 w, sdlInstanceMock := initSdlSyncStorageMock()
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", common.GetRNibNamespace(), 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 := initSdlSyncStorageMock()
421 sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), 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 := initSdlSyncStorageMock()
433 idsData := make([]string, listSize)
434 idsEntities := make([]*entities.NbIdentity, listSize)
435 for i := 0; i < listSize; i++ {
436 nbIdentity := &entities.NbIdentity{
438 GlobalNbId: &entities.GlobalNbId{
439 PlmnId: strconv.FormatInt(int64(plmnId+i), 16),
440 NbId: strconv.FormatInt(int64(nbId+i), 16),
443 data, err := proto.Marshal(nbIdentity)
445 t.Errorf("#rNibReader_test.TestGetListEnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
447 idsData[i] = string(data)
448 idsEntities[i] = nbIdentity
451 sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_ENB.String()).Return(idsData, e)
452 ids, er := w.GetListEnbIds()
454 assert.Len(t, ids, listSize)
455 for i, id := range ids {
456 assert.Equal(t, id.GetInventoryName(), name)
457 assert.Equal(t, id.GetGlobalNbId().GetPlmnId(), idsEntities[i].GetGlobalNbId().GetPlmnId())
458 assert.Equal(t, id.GetGlobalNbId().GetNbId(), idsEntities[i].GetGlobalNbId().GetNbId())
462 func TestGetListGnbIdsOneId(t *testing.T) {
466 w, sdlInstanceMock := initSdlSyncStorageMock()
467 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
469 data, err := proto.Marshal(nbIdentity)
471 t.Errorf("#rNibReader_test.TestGetListGnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
473 sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_GNB.String()).Return([]string{string(data)}, e)
474 ids, er := w.GetListGnbIds()
476 assert.Len(t, ids, 1)
477 assert.Equal(t, (ids)[0].GetInventoryName(), name)
478 assert.Equal(t, (ids)[0].GetGlobalNbId().GetPlmnId(), nbIdentity.GetGlobalNbId().GetPlmnId())
479 assert.Equal(t, (ids)[0].GetGlobalNbId().GetNbId(), nbIdentity.GetGlobalNbId().GetNbId())
482 func TestGetListGnbIdsNoIds(t *testing.T) {
483 w, sdlInstanceMock := initSdlSyncStorageMock()
485 sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_GNB.String()).Return([]string{}, e)
486 ids, er := w.GetListGnbIds()
488 assert.Len(t, ids, 0)
491 func TestGetListGnbIds(t *testing.T) {
496 w, sdlInstanceMock := initSdlSyncStorageMock()
497 idsData := make([]string, listSize)
498 idsEntities := make([]*entities.NbIdentity, listSize)
499 for i := 0; i < listSize; i++ {
500 nbIdentity := &entities.NbIdentity{
502 GlobalNbId: &entities.GlobalNbId{
503 PlmnId: strconv.FormatInt(int64(plmnId+i), 16),
504 NbId: strconv.FormatInt(int64(nbId+i), 16),
507 data, err := proto.Marshal(nbIdentity)
509 t.Errorf("#rNibReader_test.TestGetListGnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
511 idsData[i] = string(data)
512 idsEntities[i] = nbIdentity
515 sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_GNB.String()).Return(idsData, e)
516 ids, er := w.GetListGnbIds()
518 assert.Len(t, ids, listSize)
519 for i, id := range ids {
520 assert.Equal(t, id.GetInventoryName(), name)
521 assert.Equal(t, id.GetGlobalNbId().GetPlmnId(), idsEntities[i].GetGlobalNbId().GetPlmnId())
522 assert.Equal(t, id.GetGlobalNbId().GetNbId(), idsEntities[i].GetGlobalNbId().GetNbId())
526 func TestGetListEnbIdsSdlgoFailure(t *testing.T) {
527 errMsg := "expected Sdlgo error"
528 errMsgExpected := "expected Sdlgo error"
529 w, sdlInstanceMock := initSdlSyncStorageMock()
530 e := errors.New(errMsg)
532 sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_ENB.String()).Return(data, e)
533 ids, er := w.GetListEnbIds()
536 assert.IsType(t, &common.InternalError{}, er)
537 assert.EqualValues(t, errMsgExpected, er.Error())
540 func TestGetCountGnbListOneId(t *testing.T) {
541 w, sdlInstanceMock := initSdlSyncStorageMock()
543 sdlInstanceMock.On("GroupSize", common.GetRNibNamespace(), entities.Node_GNB.String()).Return(1, e)
544 count, er := w.GetCountGnbList()
546 assert.Equal(t, count, 1)
549 func TestGetCountGnbList(t *testing.T) {
550 w, sdlInstanceMock := initSdlSyncStorageMock()
552 sdlInstanceMock.On("GroupSize", common.GetRNibNamespace(), entities.Node_GNB.String()).Return(3, e)
553 count, er := w.GetCountGnbList()
555 assert.Equal(t, count, 3)
558 func TestGetCountGnbListSdlgoFailure(t *testing.T) {
559 errMsg := "expected Sdlgo error"
560 errMsgExpected := "expected Sdlgo error"
561 w, sdlInstanceMock := initSdlSyncStorageMock()
562 e := errors.New(errMsg)
564 sdlInstanceMock.On("GroupSize", common.GetRNibNamespace(), entities.Node_GNB.String()).Return(count, e)
565 count, er := w.GetCountGnbList()
567 assert.Equal(t, 0, count)
568 assert.IsType(t, &common.InternalError{}, er)
569 assert.EqualValues(t, errMsgExpected, er.Error())
572 func TestGetCell(t *testing.T) {
575 w, sdlInstanceMock := initSdlSyncStorageMock()
576 cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: &entities.ServedCellInfo{Pci: pci}}}
577 cellData, err := proto.Marshal(&cellEntity)
579 t.Errorf("#rNibReader_test.TestGetCell - Failed to marshal Cell entity. Error: %v", err)
582 key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
584 t.Errorf("#rNibReader_test.TestGetCell - failed to validate key parameter")
586 ret := map[string]interface{}{key: string(cellData)}
587 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
588 cell, er := w.GetCell(name, pci)
590 assert.NotNil(t, cell)
591 assert.Equal(t, cell.Type, entities.Cell_LTE_CELL)
592 assert.NotNil(t, cell.GetServedCellInfo())
593 assert.Equal(t, cell.GetServedCellInfo().GetPci(), pci)
596 func TestGetCellNotFoundFailure(t *testing.T) {
599 w, sdlInstanceMock := initSdlSyncStorageMock()
601 var ret map[string]interface{}
602 key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
604 t.Errorf("#rNibReader_test.TestGetCellNotFoundFailure - failed to validate key parameter")
606 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
607 cell, er := w.GetCell(name, pci)
610 assert.IsType(t, &common.ResourceNotFoundError{}, er)
611 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.Cell not found. Key: PCI:name:00", er.Error())
614 func TestGetCellUnmarshalFailure(t *testing.T) {
617 w, sdlInstanceMock := initSdlSyncStorageMock()
619 ret := make(map[string]interface{}, 1)
620 key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
622 t.Errorf("#rNibReader_test.TestGetCellUnmarshalFailure - failed to validate key parameter")
625 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
626 cell, er := w.GetCell(name, pci)
629 assert.IsType(t, &common.InternalError{}, er)
630 assert.Contains(t, er.Error(), "proto:")
633 func TestGetCellSdlgoFailure(t *testing.T) {
636 errMsg := "expected Sdlgo error"
637 errMsgExpected := "expected Sdlgo error"
638 w, sdlInstanceMock := initSdlSyncStorageMock()
639 e := errors.New(errMsg)
640 var ret map[string]interface{}
641 key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
643 t.Errorf("#rNibReader_test.TestGetCellSdlgoFailure - failed to validate key parameter")
645 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
646 cell, er := w.GetCell(name, pci)
649 assert.IsType(t, &common.InternalError{}, er)
650 assert.EqualValues(t, errMsgExpected, er.Error())
653 func TestGetNodebById(t *testing.T) {
654 w, sdlInstanceMock := initSdlSyncStorageMock()
655 nb := entities.NodebInfo{NodeType: entities.Node_ENB}
656 nb.ConnectionStatus = 1
659 enb := entities.Enb{}
660 cell := entities.ServedCellInfo{Tac: "tac"}
661 enb.ServedCells = []*entities.ServedCellInfo{&cell}
662 nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
664 data, err := proto.Marshal(&nb)
666 t.Errorf("#rNibReader_test.TestGetNodebById - Failed to marshal ENB instance. Error: %v", err)
671 key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_ENB.String(), plmnId, nbId)
673 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
675 ret := map[string]interface{}{key: string(data)}
676 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
677 globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
678 getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
680 assert.Equal(t, getNb.Ip, nb.Ip)
681 assert.Equal(t, getNb.Port, nb.Port)
682 assert.Equal(t, getNb.ConnectionStatus, nb.ConnectionStatus)
683 assert.Len(t, getNb.GetEnb().GetServedCells(), 1)
684 assert.Equal(t, getNb.GetEnb().GetServedCells()[0].Tac, nb.GetEnb().GetServedCells()[0].Tac)
687 func TestGetNodebByIdNotFoundFailureEnb(t *testing.T) {
690 w, sdlInstanceMock := initSdlSyncStorageMock()
692 key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_ENB.String(), plmnId, nbId)
694 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
696 var ret map[string]interface{}
697 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
698 globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
699 getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
702 assert.IsType(t, &common.ResourceNotFoundError{}, er)
703 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.NodebInfo not found. Key: ENB:02f829:4a952a0a", er.Error())
706 func TestGetNodebByIdNotFoundFailureGnb(t *testing.T) {
709 w, sdlInstanceMock := initSdlSyncStorageMock()
711 key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_GNB.String(), plmnId, nbId)
713 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
715 var ret map[string]interface{}
716 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
717 globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
718 getNb, er := w.GetNodebByGlobalNbId(entities.Node_GNB, globalNbId)
721 assert.IsType(t, &common.ResourceNotFoundError{}, er)
722 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.NodebInfo not found. Key: GNB:02f829:4a952a0a", er.Error())
725 func TestGetNodeByIdUnmarshalFailure(t *testing.T) {
728 w, sdlInstanceMock := initSdlSyncStorageMock()
729 key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_ENB.String(), plmnId, nbId)
731 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
734 ret := make(map[string]interface{}, 1)
736 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
737 globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
738 getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
741 assert.IsType(t, &common.InternalError{}, er)
742 assert.Contains(t, er.Error(), "proto:")
745 func TestGetNodeByIdSdlgoFailure(t *testing.T) {
748 errMsg := "expected Sdlgo error"
749 errMsgExpected := "expected Sdlgo error"
750 w, sdlInstanceMock := initSdlSyncStorageMock()
751 key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_GNB.String(), plmnId, nbId)
753 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
755 e := errors.New(errMsg)
756 var ret map[string]interface{}
757 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
758 globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
759 getNb, er := w.GetNodebByGlobalNbId(entities.Node_GNB, globalNbId)
762 assert.IsType(t, &common.InternalError{}, er)
763 assert.EqualValues(t, errMsgExpected, er.Error())
766 func TestGetCellById(t *testing.T) {
769 w, sdlInstanceMock := initSdlSyncStorageMock()
770 cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: &entities.ServedCellInfo{Pci: pci}}}
771 cellData, err := proto.Marshal(&cellEntity)
773 t.Errorf("#rNibReader_test.TestGetCellById - Failed to marshal Cell entity. Error: %v", err)
776 key, rNibErr := common.ValidateAndBuildCellIdKey(cellId)
778 t.Errorf("#rNibReader_test.TestGetCellById - failed to validate key parameter")
780 ret := map[string]interface{}{key: string(cellData)}
781 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
782 cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
784 assert.NotNil(t, cell)
785 assert.Equal(t, cell.Type, entities.Cell_LTE_CELL)
786 assert.NotNil(t, cell.GetServedCellInfo())
787 assert.Equal(t, cell.GetServedCellInfo().GetPci(), pci)
790 func TestGetCellByIdNotFoundFailureEnb(t *testing.T) {
792 w, sdlInstanceMock := initSdlSyncStorageMock()
794 var ret map[string]interface{}
795 key, rNibErr := common.ValidateAndBuildCellIdKey(cellId)
797 t.Errorf("#rNibReader_test.TestGetCellByIdNotFoundFailure - failed to validate key parameter")
799 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
800 cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
803 assert.IsType(t, &common.ResourceNotFoundError{}, er)
804 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.Cell not found. Key: CELL:bbbb", er.Error())
807 func TestGetCellByIdNotFoundFailureGnb(t *testing.T) {
809 w, sdlInstanceMock := initSdlSyncStorageMock()
811 var ret map[string]interface{}
812 key, rNibErr := common.ValidateAndBuildNrCellIdKey(cellId)
814 t.Errorf("#rNibReader_test.TestGetCellByIdNotFoundFailure - failed to validate key parameter")
816 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
817 cell, er := w.GetCellById(entities.Cell_NR_CELL, cellId)
820 assert.IsType(t, &common.ResourceNotFoundError{}, er)
821 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.Cell not found. Key: NRCELL:bbbb", er.Error())
824 func TestGetCellByIdTypeValidationFailure(t *testing.T) {
826 w, _ := initSdlSyncStorageMock()
827 cell, er := w.GetCellById(5, cellId)
830 assert.IsType(t, &common.ValidationError{}, er)
831 assert.EqualValues(t, "#rNibReader.GetCellById - invalid cell type: 5", er.Error())
834 func TestGetCellByIdValidationFailureGnb(t *testing.T) {
836 w, _ := initSdlSyncStorageMock()
837 cell, er := w.GetCellById(entities.Cell_NR_CELL, cellId)
840 assert.IsType(t, &common.ValidationError{}, er)
841 assert.EqualValues(t, "#utils.ValidateAndBuildNrCellIdKey - an empty cell id received", er.Error())
844 func TestGetCellByIdValidationFailureEnb(t *testing.T) {
846 w, _ := initSdlSyncStorageMock()
847 cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
850 assert.IsType(t, &common.ValidationError{}, er)
851 assert.EqualValues(t, "#utils.ValidateAndBuildCellIdKey - an empty cell id received", er.Error())
854 func TestGetRanLoadInformation(t *testing.T) {
856 w, sdlInstanceMock := initSdlSyncStorageMock()
857 loadInfo := generateRanLoadInformation()
859 data, err := proto.Marshal(loadInfo)
861 t.Errorf("#rNibReader_test.TestGetRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
863 redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
865 t.Errorf("#rNibReader_test.TestGetRanLoadInformationNotFoundFailure - failed to validate key parameter")
867 ret := map[string]interface{}{redisKey: string(data)}
868 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
869 getLoadInfo, er := w.GetRanLoadInformation(name)
871 assert.NotNil(t, getLoadInfo)
872 expected, err := json.Marshal(loadInfo)
874 t.Errorf("#rNibReader_test.TestGetRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
876 actual, err := json.Marshal(getLoadInfo)
878 t.Errorf("#rNibReader_test.TestGetRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
880 assert.EqualValues(t, expected, actual)
883 func TestGetRanLoadInformationValidationFailure(t *testing.T) {
885 w, _ := initSdlSyncStorageMock()
886 getNb, er := w.GetRanLoadInformation(name)
889 assert.IsType(t, &common.ValidationError{}, er)
890 assert.EqualValues(t, "#utils.ValidateAndBuildRanLoadInformationKey - an empty inventory name received", er.Error())
893 func TestGetRanLoadInformationNotFoundFailure(t *testing.T) {
895 w, sdlInstanceMock := initSdlSyncStorageMock()
897 var ret map[string]interface{}
898 redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
900 t.Errorf("#rNibReader_test.TestGetRanLoadInformationNotFoundFailure - failed to validate key parameter")
902 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
903 getNb, er := w.GetRanLoadInformation(name)
906 assert.IsType(t, &common.ResourceNotFoundError{}, er)
907 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.RanLoadInformation not found. Key: LOAD:name", er.Error())
910 func TestGetRanLoadInformationUnmarshalFailure(t *testing.T) {
912 w, sdlInstanceMock := initSdlSyncStorageMock()
914 ret := make(map[string]interface{}, 1)
915 redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
917 t.Errorf("#rNibReader_test.TestGetRanLoadInformationUnmarshalFailure - failed to validate key parameter")
919 ret[redisKey] = "data"
920 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
921 getNb, er := w.GetRanLoadInformation(name)
924 assert.IsType(t, &common.InternalError{}, er)
925 assert.Contains(t, er.Error(), "proto:")
928 func TestGetRanLoadInformationSdlgoFailure(t *testing.T) {
930 errMsg := "expected Sdlgo error"
931 errMsgExpected := "expected Sdlgo error"
932 w, sdlInstanceMock := initSdlSyncStorageMock()
933 e := errors.New(errMsg)
934 var ret map[string]interface{}
935 redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
937 t.Errorf("#rNibReader_test.TestGetRanLoadInformationSdlgoFailure - failed to validate key parameter")
939 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
940 getNb, er := w.GetRanLoadInformation(name)
943 assert.IsType(t, &common.InternalError{}, er)
944 assert.EqualValues(t, errMsgExpected, er.Error())
947 func generateCellLoadInformation() *entities.CellLoadInformation {
948 cellLoadInformation := entities.CellLoadInformation{}
950 cellLoadInformation.CellId = "123"
952 ulInterferenceOverloadIndication := entities.UlInterferenceOverloadIndication_HIGH_INTERFERENCE
953 cellLoadInformation.UlInterferenceOverloadIndications = []entities.UlInterferenceOverloadIndication{ulInterferenceOverloadIndication}
955 ulHighInterferenceInformation := entities.UlHighInterferenceInformation{
957 UlHighInterferenceIndication: "xxx",
960 cellLoadInformation.UlHighInterferenceInfos = []*entities.UlHighInterferenceInformation{&ulHighInterferenceInformation}
962 cellLoadInformation.RelativeNarrowbandTxPower = &entities.RelativeNarrowbandTxPower{
964 RntpThreshold: entities.RntpThreshold_NEG_4,
965 NumberOfCellSpecificAntennaPorts: entities.NumberOfCellSpecificAntennaPorts_V1_ANT_PRT,
967 PdcchInterferenceImpact: 2,
968 EnhancedRntp: &entities.EnhancedRntp{
969 EnhancedRntpBitmap: "xxx",
970 RntpHighPowerThreshold: entities.RntpThreshold_NEG_2,
971 EnhancedRntpStartTime: &entities.StartTime{StartSfn: 500, StartSubframeNumber: 5},
975 cellLoadInformation.AbsInformation = &entities.AbsInformation{
976 Mode: entities.AbsInformationMode_ABS_INFO_FDD,
977 AbsPatternInfo: "xxx",
978 NumberOfCellSpecificAntennaPorts: entities.NumberOfCellSpecificAntennaPorts_V2_ANT_PRT,
979 MeasurementSubset: "xxx",
982 cellLoadInformation.InvokeIndication = entities.InvokeIndication_ABS_INFORMATION
984 cellLoadInformation.ExtendedUlInterferenceOverloadInfo = &entities.ExtendedUlInterferenceOverloadInfo{
985 AssociatedSubframes: "xxx",
986 ExtendedUlInterferenceOverloadIndications: cellLoadInformation.UlInterferenceOverloadIndications,
989 compInformationItem := &entities.CompInformationItem{
990 CompHypothesisSets: []*entities.CompHypothesisSet{{CellId: "789", CompHypothesis: "xxx"}},
994 cellLoadInformation.CompInformation = &entities.CompInformation{
995 CompInformationItems: []*entities.CompInformationItem{compInformationItem},
996 CompInformationStartTime: &entities.StartTime{StartSfn: 123, StartSubframeNumber: 456},
999 cellLoadInformation.DynamicDlTransmissionInformation = &entities.DynamicDlTransmissionInformation{
1000 State: entities.NaicsState_NAICS_ACTIVE,
1001 TransmissionModes: "xxx",
1003 PAList: []entities.PA{entities.PA_DB_NEG_3},
1006 return &cellLoadInformation
1009 func generateRanLoadInformation() *entities.RanLoadInformation {
1010 ranLoadInformation := entities.RanLoadInformation{}
1012 ranLoadInformation.LoadTimestamp = uint64(time.Now().UnixNano())
1014 cellLoadInformation := generateCellLoadInformation()
1015 ranLoadInformation.CellLoadInfos = []*entities.CellLoadInformation{cellLoadInformation}
1017 return &ranLoadInformation
1020 func TestGetE2TInstanceSuccess(t *testing.T) {
1021 address := "10.10.2.15:9800"
1022 redisKey, validationErr := common.ValidateAndBuildE2TInstanceKey(address)
1024 if validationErr != nil {
1025 t.Errorf("#rNibReader_test.TestGetE2TInstanceSuccess - Failed to build E2T Instance key. Error: %v", validationErr)
1028 w, sdlInstanceMock := initSdlSyncStorageMock()
1030 e2tInstance := generateE2tInstance(address)
1031 data, err := json.Marshal(e2tInstance)
1034 t.Errorf("#rNibReader_test.TestGetE2TInstanceSuccess - Failed to marshal E2tInstance entity. Error: %v", err)
1038 ret := map[string]interface{}{redisKey: string(data)}
1039 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
1041 res, rNibErr := w.GetE2TInstance(address)
1042 assert.Nil(t, rNibErr)
1043 assert.Equal(t, e2tInstance, res)
1046 func TestUnmarshal(t *testing.T) {
1047 e2tInstance := generateE2tInstance("10.0.2.15:5555")
1048 marshaled, _ := json.Marshal(e2tInstance)
1049 m := map[string]interface{}{
1050 "whatever": string(marshaled),
1052 var entity entities.E2TInstance
1053 err := json.Unmarshal([]byte(m["whatever"].(string)), &entity)
1057 func TestGetE2TInstanceEmptyAddressFailure(t *testing.T) {
1058 w, _ := initSdlSyncStorageMock()
1059 res, err := w.GetE2TInstance("")
1060 assert.NotNil(t, err)
1061 assert.IsType(t, &common.ValidationError{}, err)
1065 func TestGetE2TInstanceSdlError(t *testing.T) {
1066 address := "10.10.2.15:9800"
1067 redisKey, validationErr := common.ValidateAndBuildE2TInstanceKey(address)
1069 if validationErr != nil {
1070 t.Errorf("#rNibReader_test.TestGetE2TInstanceSuccess - Failed to build E2T Instance key. Error: %v", validationErr)
1073 w, sdlInstanceMock := initSdlSyncStorageMock()
1075 expectedErr := errors.New("expected error")
1076 var ret map[string]interface{}
1077 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, expectedErr)
1079 res, rNibErr := w.GetE2TInstance(address)
1080 assert.NotNil(t, rNibErr)
1084 func generateE2tInstance(address string) *entities.E2TInstance {
1085 e2tInstance := entities.NewE2TInstance(address,"")
1086 e2tInstance.AssociatedRanList = []string{"test1", "test2"}
1087 e2tInstance.DeletionTimestamp = time.Now().UnixNano()
1091 func TestGetE2TAddressesSdlError(t *testing.T) {
1092 w, sdlInstanceMock := initSdlSyncStorageMock()
1094 expectedErr := errors.New("expected error")
1095 var ret map[string]interface{}
1096 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{E2TAddressesKey}).Return(ret, expectedErr)
1098 res, rNibErr := w.GetE2TAddresses()
1099 assert.NotNil(t, rNibErr)
1103 func TestGetE2TAddressesSuccess(t *testing.T) {
1104 address := "10.10.2.15:9800"
1105 w, sdlInstanceMock := initSdlSyncStorageMock()
1107 e2tAddresses := []string{address}
1108 data, err := json.Marshal(e2tAddresses)
1111 t.Errorf("#rNibReader_test.TestGetE2TInfoListSuccess - Failed to marshal E2TInfoList. Error: %v", err)
1115 ret := map[string]interface{}{E2TAddressesKey: string(data)}
1116 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{E2TAddressesKey}).Return(ret, e)
1118 res, rNibErr := w.GetE2TAddresses()
1119 assert.Nil(t, rNibErr)
1120 assert.Equal(t, e2tAddresses, res)
1123 func TestGetE2TInstancesSuccess(t *testing.T) {
1124 address := "10.10.2.15:9800"
1125 address2 := "10.10.2.16:9800"
1126 redisKey, _ := common.ValidateAndBuildE2TInstanceKey(address)
1127 redisKey2, _ := common.ValidateAndBuildE2TInstanceKey(address2)
1129 w, sdlInstanceMock := initSdlSyncStorageMock()
1131 e2tInstance1 := generateE2tInstance(address)
1132 e2tInstance2 := generateE2tInstance(address2)
1134 data1, _ := json.Marshal(e2tInstance1)
1135 data2, _ := json.Marshal(e2tInstance2)
1138 ret := map[string]interface{}{redisKey: string(data1), redisKey2: string(data2)}
1139 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey, redisKey2}).Return(ret, e)
1141 res, err := w.GetE2TInstances([]string{address, address2})
1143 assert.Equal(t, []*entities.E2TInstance{e2tInstance1, e2tInstance2}, res)
1146 func TestGetE2TInstancesUnmarhalPartialSuccess(t *testing.T) {
1147 address := "10.10.2.15:9800"
1148 address2 := "10.10.2.16:9800"
1149 redisKey, _ := common.ValidateAndBuildE2TInstanceKey(address)
1150 redisKey2, _ := common.ValidateAndBuildE2TInstanceKey(address2)
1152 w, sdlInstanceMock := initSdlSyncStorageMock()
1154 e2tInstance1 := generateE2tInstance(address)
1155 data1, _ := json.Marshal(e2tInstance1)
1158 ret := map[string]interface{}{redisKey: string(data1), redisKey2: "abc"}
1159 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey, redisKey2}).Return(ret, e)
1161 res, err := w.GetE2TInstances([]string{address, address2})
1163 assert.Equal(t, []*entities.E2TInstance{e2tInstance1}, res)
1166 func TestGetE2TInstancesSdlFailure(t *testing.T) {
1167 address := "10.10.2.15:9800"
1168 address2 := "10.10.2.16:9800"
1169 redisKey, _ := common.ValidateAndBuildE2TInstanceKey(address)
1170 redisKey2, _ := common.ValidateAndBuildE2TInstanceKey(address2)
1172 w, sdlInstanceMock := initSdlSyncStorageMock()
1174 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey, redisKey2}).Return(map[string]interface{}{}, fmt.Errorf(""))
1175 _, err := w.GetE2TInstances([]string{address, address2})
1176 assert.IsType(t, &common.InternalError{}, err)
1179 func TestGetE2TInstancesEmptyData(t *testing.T) {
1180 address := "10.10.2.15:9800"
1181 address2 := "10.10.2.16:9800"
1182 redisKey, _ := common.ValidateAndBuildE2TInstanceKey(address)
1183 redisKey2, _ := common.ValidateAndBuildE2TInstanceKey(address2)
1185 w, sdlInstanceMock := initSdlSyncStorageMock()
1187 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey, redisKey2}).Return(map[string]interface{}{}, nil)
1188 _, err := w.GetE2TInstances([]string{address, address2})
1189 assert.IsType(t, &common.ResourceNotFoundError{}, err)
1192 func TestGetGeneralConfiguration(t *testing.T) {
1194 key := common.BuildGeneralConfigurationKey()
1195 w, sdlInstanceMock := initSdlSyncStorageMock()
1197 configurationData := "{\"enableRic\":true}"
1198 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(map[string]interface{}{key: configurationData}, nil)
1200 res, rNibErr := w.GetGeneralConfiguration()
1201 assert.Nil(t, rNibErr)
1202 assert.Equal(t, true, res.EnableRic)
1205 func TestGetGeneralConfigurationNotFound(t *testing.T) {
1207 key := common.BuildGeneralConfigurationKey()
1208 w, sdlInstanceMock := initSdlSyncStorageMock()
1210 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(map[string]interface{}{}, nil)
1212 _, rNibErr := w.GetGeneralConfiguration()
1214 assert.NotNil(t, rNibErr)
1215 assert.Equal(t, "#rNibReader.getByKeyAndUnmarshalJson - entity of type *entities.GeneralConfiguration not found. Key: GENERAL", rNibErr.Error())
1218 func TestGetGeneralConfigurationSdlFailure(t *testing.T) {
1220 key := common.BuildGeneralConfigurationKey()
1221 w, sdlInstanceMock := initSdlSyncStorageMock()
1223 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(map[string]interface{}{}, fmt.Errorf("sdl error"))
1225 _, rNibErr := w.GetGeneralConfiguration()
1227 assert.NotNil(t, rNibErr)
1229 assert.Equal(t, "sdl error", rNibErr.Error())
1232 func TestGetGeneralConfigurationUnmarshalError(t *testing.T) {
1234 key := common.BuildGeneralConfigurationKey()
1235 w, sdlInstanceMock := initSdlSyncStorageMock()
1237 configurationData := "{\"enableRic :true}"
1238 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(map[string]interface{}{key: configurationData}, nil)
1240 _, rNibErr := w.GetGeneralConfiguration()
1242 assert.NotNil(t, rNibErr)
1243 assert.Equal(t, rNibErr.Error(), "unexpected end of JSON input")
1248 //func TestGetEnbInteg(t *testing.T){
1249 // name := "nameEnb1"
1250 // Init("namespace", 1)
1251 // w := GetRNibReader()
1252 // nb, err := w.GetNodeb(name)
1256 // fmt.Printf("#TestGetEnbInteg - responding node type: %v\n", nb)
1260 //func TestGetEnbCellsInteg(t *testing.T){
1261 // name := "nameEnb1"
1262 // Init("namespace", 1)
1263 // w := GetRNibReader()
1264 // cells, err := w.GetCellList(name)
1267 // } else if cells != nil{
1268 // for _, cell := range cells.GetServedCellInfos().ServedCells{
1269 // fmt.Printf("responding node type Cell: %v\n", *cell)
1274 //func TestGetGnbInteg(t *testing.T){
1275 // name := "nameGnb1"
1276 // Init("namespace", 1)
1277 // w := GetRNibReader()
1278 // nb, err := w.GetNodeb(name)
1282 // fmt.Printf("#TestGetGnbInteg - responding node type: %v\n", nb)
1286 //func TestGetGnbCellsInteg(t *testing.T){
1287 // name := "nameGnb1"
1288 // Init("namespace", 1)
1289 // w := GetRNibReader()
1290 // cells, err := w.GetCellList(name)
1293 // } else if cells != nil{
1294 // for _, cell := range cells.GetServedNrCells().ServedCells{
1295 // fmt.Printf("responding node type NR Cell: %v\n", *cell)
1300 //func TestGetListEnbIdsInteg(t *testing.T) {
1301 // Init("namespace", 1)
1302 // w := GetRNibReader()
1303 // ids, err := w.GetListEnbIds()
1307 // for _, id := range ids{
1308 // fmt.Printf("#TestGetListEnbIdsInteg - ENB ID: %s\n", id)
1313 //func TestGetListGnbIdsInteg(t *testing.T) {
1314 // Init("namespace", 1)
1315 // w := GetRNibReader()
1316 // ids, err := w.GetListGnbIds()
1320 // for _, id := range ids{
1321 // fmt.Printf("#TestGetListGnbIdsInteg - GNB ID: %s\n", id)
1326 //func TestGetCountGnbListInteg(t *testing.T) {
1327 // Init("namespace", 1)
1328 // w := GetRNibReader()
1329 // count, err := w.GetCountGnbList()
1333 // fmt.Printf("#TestGetCountGnbListInteg - count Gnb list: %d\n", count)
1337 //func TestGetGnbCellInteg(t *testing.T){
1338 // name := "nameGnb7"
1340 // Init("namespace", 1)
1341 // w := GetRNibReader()
1342 // cell, err := w.GetCell(name, uint32(pci))
1345 // } else if cell != nil{
1346 // fmt.Printf("responding node type NR Cell: %v\n", cell.GetServedNrCell())
1350 //func TestGetEnbCellInteg(t *testing.T) {
1351 // name := "nameEnb1"
1353 // Init("namespace", 1)
1354 // w := GetRNibReader()
1355 // cell, err := w.GetCell(name, uint32(pci))
1358 // } else if cell != nil {
1359 // fmt.Printf("responding node type LTE Cell: %v\n", cell.GetServedCellInfo())
1363 //func TestGetEnbCellByIdInteg(t *testing.T){
1364 // Init("namespace", 1)
1365 // w := GetRNibReader()
1366 // cell, err := w.GetCellById(entities.Cell_NR_CELL, "45d")
1369 // } else if cell != nil{
1370 // fmt.Printf("responding node type NR Cell: %v\n", cell.GetServedNrCell())
1374 //func TestGetListNbIdsInteg(t *testing.T) {
1375 // Init("e2Manager", 1)
1376 // w := GetRNibReader()
1377 // ids, err := w.GetListNodebIds()
1381 // for _, id := range ids{
1382 // fmt.Printf("#TestGetListGnbIdsInteg - NB ID: %s\n", id)
1387 //func TestGetRanLoadInformationInteg(t *testing.T){
1388 // Init("e2Manager", 1)
1389 // w := GetRNibReader()
1390 // ranLoadInformation, err := w.GetRanLoadInformation("ran_integ")
1392 // t.Errorf("#rNibReader_test.TestGetRanLoadInformationInteg - Failed to get RanLoadInformation entity. Error: %v", err)
1394 // assert.NotNil(t, ranLoadInformation)
1395 // fmt.Printf("#rNibReader_test.TestGetRanLoadInformationInteg - GNB ID: %s\n", ranLoadInformation)
1398 //func TestGetE2TInstancesInteg(t *testing.T) {
1399 // db := sdlgo.NewDatabase()
1400 // sdl := sdlgo.NewSdlInstance("e2Manager", db)
1401 // rnibReader := GetRNibReader(sdl)
1402 // e2tInstances, _ := rnibReader.GetE2TInstances([]string{"e2t.att.com:38000","whatever"})
1403 // assert.Len(t, e2tInstances, 1)