2 // Copyright 2019 AT&T Intellectual Property
3 // Copyright 2019 Nokia
5 // Licensed under the Apache License, Version 2.0 (the "License");
6 // you may not use this file except in compliance with the License.
7 // You may obtain a copy of the License at
9 // http://www.apache.org/licenses/LICENSE-2.0
11 // Unless required by applicable law or agreed to in writing, software
12 // distributed under the License is distributed on an "AS IS" BASIS,
13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 // See the License for the specific language governing permissions and
15 // limitations under the License.
17 // This source code is part of the near-RT RIC (RAN Intelligent Controller)
18 // platform project (RICP).
25 "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
26 "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
27 "github.com/golang/protobuf/proto"
28 "github.com/pkg/errors"
29 "github.com/stretchr/testify/assert"
34 func initSdlSyncStorageMock() (w RNibReader, sdlStorageMock *MockSdlSyncStorage) {
35 sdlStorageMock = new(MockSdlSyncStorage)
36 w = GetNewRNibReader(sdlStorageMock)
40 func TestGetRNibNamespace(t *testing.T) {
41 ns := common.GetRNibNamespace()
42 assert.Equal(t, "e2Manager", ns)
45 func TestGetNodeB(t *testing.T) {
47 w, sdlInstanceMock := initSdlSyncStorageMock()
48 nb := entities.NodebInfo{}
49 nb.ConnectionStatus = 1
53 cell := entities.ServedCellInfo{Tac: "tac"}
54 enb.ServedCells = []*entities.ServedCellInfo{&cell}
55 nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
57 data, err := proto.Marshal(&nb)
59 t.Errorf("#rNibReader_test.TestGetNb - Failed to marshal ENB instance. Error: %v", err)
61 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
63 t.Errorf("#rNibReader_test.TestGetNodeB - failed to validate key parameter")
65 ret := map[string]interface{}{redisKey: string(data)}
66 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
67 getNb, er := w.GetNodeb(name)
69 assert.Equal(t, getNb.Ip, nb.Ip)
70 assert.Equal(t, getNb.Port, nb.Port)
71 assert.Equal(t, getNb.ConnectionStatus, nb.ConnectionStatus)
72 assert.Len(t, getNb.GetEnb().GetServedCells(), 1)
73 assert.Equal(t, getNb.GetEnb().GetServedCells()[0].Tac, nb.GetEnb().GetServedCells()[0].Tac)
76 func TestGetNodeBNotFoundFailure(t *testing.T) {
78 w, sdlInstanceMock := initSdlSyncStorageMock()
80 var ret map[string]interface{}
81 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
83 t.Errorf("#rNibReader_test.TestGetNodeBNotFoundFailure - failed to validate key parameter")
85 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
86 getNb, er := w.GetNodeb(name)
89 assert.IsType(t, &common.ResourceNotFoundError{}, er)
90 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.NodebInfo not found. Key: RAN:name", er.Error())
93 func TestGetNodeBUnmarshalFailure(t *testing.T) {
95 w, sdlInstanceMock := initSdlSyncStorageMock()
97 ret := make(map[string]interface{}, 1)
98 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
100 t.Errorf("#rNibReader_test.TestGetNodeBUnmarshalFailure - failed to validate key parameter")
102 ret[redisKey] = "data"
103 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
104 getNb, er := w.GetNodeb(name)
107 assert.IsType(t, &common.InternalError{}, er)
108 assert.Contains(t, er.Error(), "proto:")
111 func TestGetNodeBSdlgoFailure(t *testing.T) {
113 errMsg := "expected Sdlgo error"
114 errMsgExpected := "expected Sdlgo error"
115 w, sdlInstanceMock := initSdlSyncStorageMock()
116 e := errors.New(errMsg)
117 var ret map[string]interface{}
118 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
120 t.Errorf("#rNibReader_test.TestGetNodeBSdlgoFailure - failed to validate key parameter")
122 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
123 getNb, er := w.GetNodeb(name)
126 assert.IsType(t, &common.InternalError{}, er)
127 assert.EqualValues(t, errMsgExpected, er.Error())
130 func TestGetNodeBCellsListEnb(t *testing.T) {
132 w, sdlInstanceMock := initSdlSyncStorageMock()
133 nb := entities.NodebInfo{}
134 nb.ConnectionStatus = 1
137 enb := entities.Enb{}
138 cell := entities.ServedCellInfo{Tac: "tac"}
139 enb.ServedCells = []*entities.ServedCellInfo{&cell}
140 nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
142 data, err := proto.Marshal(&nb)
144 t.Errorf("#rNibReader_test.GetNodeBCellsList - Failed to marshal ENB instance. Error: %v", err)
146 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
148 t.Errorf("#rNibReader_test.TestGetNodeBCellsListEnb - failed to validate key parameter")
150 ret := map[string]interface{}{redisKey: string(data)}
151 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
152 cells, er := w.GetCellList(name)
154 assert.NotNil(t, cells)
155 assert.Len(t, cells.GetServedCellInfos().GetServedCells(), 1)
156 retCell := cells.GetServedCellInfos().GetServedCells()[0]
157 assert.Equal(t, retCell.Tac, "tac")
160 func TestGetNodeBCellsListGnb(t *testing.T) {
162 w, sdlInstanceMock := initSdlSyncStorageMock()
163 nb := entities.NodebInfo{}
164 nb.ConnectionStatus = 1
167 nb.NodeType = entities.Node_GNB
168 gnb := entities.Gnb{}
169 cell := entities.ServedNRCell{ServedNrCellInformation: &entities.ServedNRCellInformation{NrPci: 10}}
170 gnb.ServedNrCells = []*entities.ServedNRCell{&cell}
171 nb.Configuration = &entities.NodebInfo_Gnb{Gnb: &gnb}
173 data, err := proto.Marshal(&nb)
175 t.Errorf("#rNibReader_test.GetNodeBCellsList - Failed to marshal GNB instance. Error: %v", err)
177 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
179 t.Errorf("#rNibReader_test.TestGetNodeBCellsListGnb - failed to validate key parameter")
181 ret := map[string]interface{}{redisKey: string(data)}
182 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
183 cells, er := w.GetCellList(name)
185 assert.NotNil(t, cells)
186 assert.Len(t, cells.GetServedNrCells().GetServedCells(), 1)
187 retCell := cells.GetServedNrCells().GetServedCells()[0]
188 assert.Equal(t, retCell.GetServedNrCellInformation().GetNrPci(), uint32(10))
191 func TestGetNodeBCellsListNodeUnmarshalFailure(t *testing.T) {
193 w, sdlInstanceMock := initSdlSyncStorageMock()
195 ret := make(map[string]interface{}, 1)
196 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
198 t.Errorf("#rNibReader_test.TestGetNodeBCellsListNodeUnmarshalFailure - failed to validate key parameter")
200 ret[redisKey] = "data"
201 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
202 cells, er := w.GetCellList(name)
205 assert.IsType(t, &common.InternalError{}, er)
206 assert.Contains(t, er.Error(), "proto:")
209 func TestGetNodeBCellsListNodeNotFoundFailure(t *testing.T) {
211 w, sdlInstanceMock := initSdlSyncStorageMock()
213 var ret map[string]interface{}
214 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
216 t.Errorf("#rNibReader_test.TestGetNodeBCellsListNodeNotFoundFailure - failed to validate key parameter")
218 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
219 cells, er := w.GetCellList(name)
222 assert.IsType(t, &common.ResourceNotFoundError{}, er)
223 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.NodebInfo not found. Key: RAN:name", er.Error())
226 func TestGetNodeBCellsListNotFoundFailureEnb(t *testing.T) {
228 w, sdlInstanceMock := initSdlSyncStorageMock()
229 nb := entities.NodebInfo{}
230 nb.ConnectionStatus = 1
233 enb := entities.Enb{}
234 nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
236 data, err := proto.Marshal(&nb)
238 t.Errorf("#rNibReader_test.TestGetNbCellsListNotFoundFailure - Failed to marshal ENB instance. Error: %v", err)
240 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
242 t.Errorf("#rNibReader_test.TestGetNodeBCellsListNotFoundFailureEnb - failed to validate key parameter")
244 ret := map[string]interface{}{redisKey: string(data)}
245 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
246 _, er := w.GetCellList(name)
248 assert.EqualValues(t, "#rNibReader.GetCellList - served cells not found. Responding node RAN name: name.", er.Error())
251 func TestGetNodeBCellsListNotFoundFailureGnb(t *testing.T) {
253 w, sdlInstanceMock := initSdlSyncStorageMock()
254 nb := entities.NodebInfo{}
255 nb.ConnectionStatus = 1
258 gnb := entities.Gnb{}
259 nb.Configuration = &entities.NodebInfo_Gnb{Gnb: &gnb}
261 data, err := proto.Marshal(&nb)
263 t.Errorf("#rNibReader_test.TestGetNodeBCellsListNotFoundFailureGnb - Failed to marshal ENB instance. Error: %v", err)
265 redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
267 t.Errorf("#rNibReader_test.TestGetNodeBCellsListNotFoundFailureGnb - failed to validate key parameter")
269 ret := map[string]interface{}{redisKey: string(data)}
270 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
271 _, er := w.GetCellList(name)
273 assert.EqualValues(t, "#rNibReader.GetCellList - served cells not found. Responding node RAN name: name.", er.Error())
276 func TestGetListGnbIdsUnmarshalFailure(t *testing.T) {
277 w, sdlInstanceMock := initSdlSyncStorageMock()
279 sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_GNB.String()).Return([]string{"data"}, e)
280 ids, er := w.GetListGnbIds()
283 assert.IsType(t, &common.InternalError{}, er)
284 assert.Contains(t, er.Error(), "proto:")
287 func TestGetListGnbIdsSdlgoFailure(t *testing.T) {
288 errMsg := "expected Sdlgo error"
289 errMsgExpected := "expected Sdlgo error"
290 w, sdlInstanceMock := initSdlSyncStorageMock()
291 e := errors.New(errMsg)
293 sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_GNB.String()).Return(data, e)
294 ids, er := w.GetListGnbIds()
297 assert.IsType(t, &common.InternalError{}, er)
298 assert.EqualValues(t, errMsgExpected, er.Error())
301 func TestGetListNodesIdsGnbSdlgoFailure(t *testing.T) {
302 w, sdlInstanceMock := initSdlSyncStorageMock()
307 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
309 data, err := proto.Marshal(nbIdentity)
311 t.Errorf("#rNibReader_test.TestGetListNodesIdsGnbSdlgoFailure - Failed to marshal nodeb identity entity. Error: %v", err)
313 sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_ENB.String()).Return([]string{string(data)}, nilError)
315 errMsg := "expected Sdlgo error"
316 errMsgExpected := "expected Sdlgo error"
317 expectedError := errors.New(errMsg)
319 sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_GNB.String()).Return(nilData, expectedError)
321 ids, er := w.GetListNodebIds()
324 assert.IsType(t, &common.InternalError{}, er)
325 assert.EqualValues(t, errMsgExpected, er.Error())
328 func TestGetListNodesIdsEnbSdlgoFailure(t *testing.T) {
329 w, sdlInstanceMock := initSdlSyncStorageMock()
334 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
336 data, err := proto.Marshal(nbIdentity)
338 t.Errorf("#rNibReader_test.TestGetListNodesIdsEnbSdlgoFailure - Failed to marshal nodeb identity entity. Error: %v", err)
340 sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_GNB.String()).Return([]string{string(data)}, nilError)
342 errMsg := "expected Sdlgo error"
343 errMsgExpected := "expected Sdlgo error"
344 expectedError := errors.New(errMsg)
346 sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_ENB.String()).Return(nilData, expectedError)
348 ids, er := w.GetListNodebIds()
351 assert.IsType(t, &common.InternalError{}, er)
352 assert.EqualValues(t, errMsgExpected, er.Error())
355 func TestGetListNodesIdsSuccess(t *testing.T) {
356 w, sdlInstanceMock := initSdlSyncStorageMock()
362 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
363 data, err := proto.Marshal(nbIdentity)
365 t.Errorf("#rNibReader_test.TestGetListNodesIdsSuccess - Failed to marshal nodeb identity entity. Error: %v", err)
371 nbIdentity1 := &entities.NbIdentity{InventoryName: name1, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId1, NbId: nbId1}}
372 data1, err := proto.Marshal(nbIdentity1)
374 t.Errorf("#rNibReader_test.TestGetListNodesIdsSuccess - Failed to marshal nodeb identity entity. Error: %v", err)
377 sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_GNB.String()).Return([]string{string(data)}, nilError)
378 sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_ENB.String()).Return([]string{string(data1)}, nilError)
380 ids, er := w.GetListNodebIds()
382 assert.NotNil(t, ids)
383 assert.Len(t, ids, 2)
386 func TestGetListEnbIdsUnmarshalFailure(t *testing.T) {
387 w, sdlInstanceMock := initSdlSyncStorageMock()
389 sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_ENB.String()).Return([]string{"data"}, e)
390 ids, er := w.GetListEnbIds()
393 assert.IsType(t, &common.InternalError{}, er)
394 assert.Contains(t, er.Error(), "proto:")
397 func TestGetListEnbIdsOneId(t *testing.T) {
401 w, sdlInstanceMock := initSdlSyncStorageMock()
402 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
404 data, err := proto.Marshal(nbIdentity)
406 t.Errorf("#rNibReader_test.TestGetListEnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
408 sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_ENB.String()).Return([]string{string(data)}, e)
409 ids, er := w.GetListEnbIds()
411 assert.Len(t, ids, 1)
412 assert.Equal(t, (ids)[0].GetInventoryName(), name)
413 assert.Equal(t, (ids)[0].GetGlobalNbId().GetPlmnId(), nbIdentity.GetGlobalNbId().GetPlmnId())
414 assert.Equal(t, (ids)[0].GetGlobalNbId().GetNbId(), nbIdentity.GetGlobalNbId().GetNbId())
417 func TestGetListEnbIdsNoIds(t *testing.T) {
418 w, sdlInstanceMock := initSdlSyncStorageMock()
420 sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_ENB.String()).Return([]string{}, e)
421 ids, er := w.GetListEnbIds()
423 assert.Len(t, ids, 0)
426 func TestGetListEnbIds(t *testing.T) {
431 w, sdlInstanceMock := initSdlSyncStorageMock()
432 idsData := make([]string, listSize)
433 idsEntities := make([]*entities.NbIdentity, listSize)
434 for i := 0; i < listSize; i++ {
435 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: string(plmnId + i), NbId: string(nbId + i)}}
436 data, err := proto.Marshal(nbIdentity)
438 t.Errorf("#rNibReader_test.TestGetListEnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
440 idsData[i] = string(data)
441 idsEntities[i] = nbIdentity
444 sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_ENB.String()).Return(idsData, e)
445 ids, er := w.GetListEnbIds()
447 assert.Len(t, ids, listSize)
448 for i, id := range ids {
449 assert.Equal(t, id.GetInventoryName(), name)
450 assert.Equal(t, id.GetGlobalNbId().GetPlmnId(), idsEntities[i].GetGlobalNbId().GetPlmnId())
451 assert.Equal(t, id.GetGlobalNbId().GetNbId(), idsEntities[i].GetGlobalNbId().GetNbId())
455 func TestGetListGnbIdsOneId(t *testing.T) {
459 w, sdlInstanceMock := initSdlSyncStorageMock()
460 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
462 data, err := proto.Marshal(nbIdentity)
464 t.Errorf("#rNibReader_test.TestGetListGnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
466 sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_GNB.String()).Return([]string{string(data)}, e)
467 ids, er := w.GetListGnbIds()
469 assert.Len(t, ids, 1)
470 assert.Equal(t, (ids)[0].GetInventoryName(), name)
471 assert.Equal(t, (ids)[0].GetGlobalNbId().GetPlmnId(), nbIdentity.GetGlobalNbId().GetPlmnId())
472 assert.Equal(t, (ids)[0].GetGlobalNbId().GetNbId(), nbIdentity.GetGlobalNbId().GetNbId())
475 func TestGetListGnbIdsNoIds(t *testing.T) {
476 w, sdlInstanceMock := initSdlSyncStorageMock()
478 sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_GNB.String()).Return([]string{}, e)
479 ids, er := w.GetListGnbIds()
481 assert.Len(t, ids, 0)
484 func TestGetListGnbIds(t *testing.T) {
489 w, sdlInstanceMock := initSdlSyncStorageMock()
490 idsData := make([]string, listSize)
491 idsEntities := make([]*entities.NbIdentity, listSize)
492 for i := 0; i < listSize; i++ {
493 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: string(plmnId + i), NbId: string(nbId + i)}}
494 data, err := proto.Marshal(nbIdentity)
496 t.Errorf("#rNibReader_test.TestGetListGnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
498 idsData[i] = string(data)
499 idsEntities[i] = nbIdentity
502 sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_GNB.String()).Return(idsData, e)
503 ids, er := w.GetListGnbIds()
505 assert.Len(t, ids, listSize)
506 for i, id := range ids {
507 assert.Equal(t, id.GetInventoryName(), name)
508 assert.Equal(t, id.GetGlobalNbId().GetPlmnId(), idsEntities[i].GetGlobalNbId().GetPlmnId())
509 assert.Equal(t, id.GetGlobalNbId().GetNbId(), idsEntities[i].GetGlobalNbId().GetNbId())
513 func TestGetListEnbIdsSdlgoFailure(t *testing.T) {
514 errMsg := "expected Sdlgo error"
515 errMsgExpected := "expected Sdlgo error"
516 w, sdlInstanceMock := initSdlSyncStorageMock()
517 e := errors.New(errMsg)
519 sdlInstanceMock.On("GetMembers", common.GetRNibNamespace(), entities.Node_ENB.String()).Return(data, e)
520 ids, er := w.GetListEnbIds()
523 assert.IsType(t, &common.InternalError{}, er)
524 assert.EqualValues(t, errMsgExpected, er.Error())
527 func TestGetCountGnbListOneId(t *testing.T) {
528 w, sdlInstanceMock := initSdlSyncStorageMock()
530 sdlInstanceMock.On("GroupSize", common.GetRNibNamespace(), entities.Node_GNB.String()).Return(1, e)
531 count, er := w.GetCountGnbList()
533 assert.Equal(t, count, 1)
536 func TestGetCountGnbList(t *testing.T) {
537 w, sdlInstanceMock := initSdlSyncStorageMock()
539 sdlInstanceMock.On("GroupSize", common.GetRNibNamespace(), entities.Node_GNB.String()).Return(3, e)
540 count, er := w.GetCountGnbList()
542 assert.Equal(t, count, 3)
545 func TestGetCountGnbListSdlgoFailure(t *testing.T) {
546 errMsg := "expected Sdlgo error"
547 errMsgExpected := "expected Sdlgo error"
548 w, sdlInstanceMock := initSdlSyncStorageMock()
549 e := errors.New(errMsg)
551 sdlInstanceMock.On("GroupSize", common.GetRNibNamespace(), entities.Node_GNB.String()).Return(count, e)
552 count, er := w.GetCountGnbList()
554 assert.Equal(t, 0, count)
555 assert.IsType(t, &common.InternalError{}, er)
556 assert.EqualValues(t, errMsgExpected, er.Error())
559 func TestGetCell(t *testing.T) {
562 w, sdlInstanceMock := initSdlSyncStorageMock()
563 cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: &entities.ServedCellInfo{Pci: pci}}}
564 cellData, err := proto.Marshal(&cellEntity)
566 t.Errorf("#rNibReader_test.TestGetCell - Failed to marshal Cell entity. Error: %v", err)
569 key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
571 t.Errorf("#rNibReader_test.TestGetCell - failed to validate key parameter")
573 ret := map[string]interface{}{key: string(cellData)}
574 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
575 cell, er := w.GetCell(name, pci)
577 assert.NotNil(t, cell)
578 assert.Equal(t, cell.Type, entities.Cell_LTE_CELL)
579 assert.NotNil(t, cell.GetServedCellInfo())
580 assert.Equal(t, cell.GetServedCellInfo().GetPci(), pci)
583 func TestGetCellNotFoundFailure(t *testing.T) {
586 w, sdlInstanceMock := initSdlSyncStorageMock()
588 var ret map[string]interface{}
589 key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
591 t.Errorf("#rNibReader_test.TestGetCellNotFoundFailure - failed to validate key parameter")
593 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
594 cell, er := w.GetCell(name, pci)
597 assert.IsType(t, &common.ResourceNotFoundError{}, er)
598 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.Cell not found. Key: PCI:name:00", er.Error())
601 func TestGetCellUnmarshalFailure(t *testing.T) {
604 w, sdlInstanceMock := initSdlSyncStorageMock()
606 ret := make(map[string]interface{}, 1)
607 key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
609 t.Errorf("#rNibReader_test.TestGetCellUnmarshalFailure - failed to validate key parameter")
612 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
613 cell, er := w.GetCell(name, pci)
616 assert.IsType(t, &common.InternalError{}, er)
617 assert.Contains(t, er.Error(), "proto:")
620 func TestGetCellSdlgoFailure(t *testing.T) {
623 errMsg := "expected Sdlgo error"
624 errMsgExpected := "expected Sdlgo error"
625 w, sdlInstanceMock := initSdlSyncStorageMock()
626 e := errors.New(errMsg)
627 var ret map[string]interface{}
628 key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
630 t.Errorf("#rNibReader_test.TestGetCellSdlgoFailure - failed to validate key parameter")
632 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
633 cell, er := w.GetCell(name, pci)
636 assert.IsType(t, &common.InternalError{}, er)
637 assert.EqualValues(t, errMsgExpected, er.Error())
640 func TestGetNodebById(t *testing.T) {
641 w, sdlInstanceMock := initSdlSyncStorageMock()
642 nb := entities.NodebInfo{NodeType: entities.Node_ENB}
643 nb.ConnectionStatus = 1
646 enb := entities.Enb{}
647 cell := entities.ServedCellInfo{Tac: "tac"}
648 enb.ServedCells = []*entities.ServedCellInfo{&cell}
649 nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
651 data, err := proto.Marshal(&nb)
653 t.Errorf("#rNibReader_test.TestGetNodebById - Failed to marshal ENB instance. Error: %v", err)
658 key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_ENB.String(), plmnId, nbId)
660 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
662 ret := map[string]interface{}{key: string(data)}
663 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
664 globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
665 getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
667 assert.Equal(t, getNb.Ip, nb.Ip)
668 assert.Equal(t, getNb.Port, nb.Port)
669 assert.Equal(t, getNb.ConnectionStatus, nb.ConnectionStatus)
670 assert.Len(t, getNb.GetEnb().GetServedCells(), 1)
671 assert.Equal(t, getNb.GetEnb().GetServedCells()[0].Tac, nb.GetEnb().GetServedCells()[0].Tac)
674 func TestGetNodebByIdNotFoundFailureEnb(t *testing.T) {
677 w, sdlInstanceMock := initSdlSyncStorageMock()
679 key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_ENB.String(), plmnId, nbId)
681 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
683 var ret map[string]interface{}
684 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
685 globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
686 getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
689 assert.IsType(t, &common.ResourceNotFoundError{}, er)
690 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.NodebInfo not found. Key: ENB:02f829:4a952a0a", er.Error())
693 func TestGetNodebByIdNotFoundFailureGnb(t *testing.T) {
696 w, sdlInstanceMock := initSdlSyncStorageMock()
698 key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_GNB.String(), plmnId, nbId)
700 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
702 var ret map[string]interface{}
703 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
704 globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
705 getNb, er := w.GetNodebByGlobalNbId(entities.Node_GNB, globalNbId)
708 assert.IsType(t, &common.ResourceNotFoundError{}, er)
709 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.NodebInfo not found. Key: GNB:02f829:4a952a0a", er.Error())
712 func TestGetNodeByIdUnmarshalFailure(t *testing.T) {
715 w, sdlInstanceMock := initSdlSyncStorageMock()
716 key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_ENB.String(), plmnId, nbId)
718 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
721 ret := make(map[string]interface{}, 1)
723 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
724 globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
725 getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
728 assert.IsType(t, &common.InternalError{}, er)
729 assert.Contains(t, er.Error(), "proto:")
732 func TestGetNodeByIdSdlgoFailure(t *testing.T) {
735 errMsg := "expected Sdlgo error"
736 errMsgExpected := "expected Sdlgo error"
737 w, sdlInstanceMock := initSdlSyncStorageMock()
738 key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_GNB.String(), plmnId, nbId)
740 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
742 e := errors.New(errMsg)
743 var ret map[string]interface{}
744 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
745 globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
746 getNb, er := w.GetNodebByGlobalNbId(entities.Node_GNB, globalNbId)
749 assert.IsType(t, &common.InternalError{}, er)
750 assert.EqualValues(t, errMsgExpected, er.Error())
753 func TestGetCellById(t *testing.T) {
756 w, sdlInstanceMock := initSdlSyncStorageMock()
757 cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: &entities.ServedCellInfo{Pci: pci}}}
758 cellData, err := proto.Marshal(&cellEntity)
760 t.Errorf("#rNibReader_test.TestGetCellById - Failed to marshal Cell entity. Error: %v", err)
763 key, rNibErr := common.ValidateAndBuildCellIdKey(cellId)
765 t.Errorf("#rNibReader_test.TestGetCellById - failed to validate key parameter")
767 ret := map[string]interface{}{key: string(cellData)}
768 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
769 cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
771 assert.NotNil(t, cell)
772 assert.Equal(t, cell.Type, entities.Cell_LTE_CELL)
773 assert.NotNil(t, cell.GetServedCellInfo())
774 assert.Equal(t, cell.GetServedCellInfo().GetPci(), pci)
777 func TestGetCellByIdNotFoundFailureEnb(t *testing.T) {
779 w, sdlInstanceMock := initSdlSyncStorageMock()
781 var ret map[string]interface{}
782 key, rNibErr := common.ValidateAndBuildCellIdKey(cellId)
784 t.Errorf("#rNibReader_test.TestGetCellByIdNotFoundFailure - failed to validate key parameter")
786 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
787 cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
790 assert.IsType(t, &common.ResourceNotFoundError{}, er)
791 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.Cell not found. Key: CELL:bbbb", er.Error())
794 func TestGetCellByIdNotFoundFailureGnb(t *testing.T) {
796 w, sdlInstanceMock := initSdlSyncStorageMock()
798 var ret map[string]interface{}
799 key, rNibErr := common.ValidateAndBuildNrCellIdKey(cellId)
801 t.Errorf("#rNibReader_test.TestGetCellByIdNotFoundFailure - failed to validate key parameter")
803 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(ret, e)
804 cell, er := w.GetCellById(entities.Cell_NR_CELL, cellId)
807 assert.IsType(t, &common.ResourceNotFoundError{}, er)
808 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.Cell not found. Key: NRCELL:bbbb", er.Error())
811 func TestGetCellByIdTypeValidationFailure(t *testing.T) {
813 w, _ := initSdlSyncStorageMock()
814 cell, er := w.GetCellById(5, cellId)
817 assert.IsType(t, &common.ValidationError{}, er)
818 assert.EqualValues(t, "#rNibReader.GetCellById - invalid cell type: 5", er.Error())
821 func TestGetCellByIdValidationFailureGnb(t *testing.T) {
823 w, _ := initSdlSyncStorageMock()
824 cell, er := w.GetCellById(entities.Cell_NR_CELL, cellId)
827 assert.IsType(t, &common.ValidationError{}, er)
828 assert.EqualValues(t, "#utils.ValidateAndBuildNrCellIdKey - an empty cell id received", er.Error())
831 func TestGetCellByIdValidationFailureEnb(t *testing.T) {
833 w, _ := initSdlSyncStorageMock()
834 cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
837 assert.IsType(t, &common.ValidationError{}, er)
838 assert.EqualValues(t, "#utils.ValidateAndBuildCellIdKey - an empty cell id received", er.Error())
841 func TestGetRanLoadInformation(t *testing.T) {
843 w, sdlInstanceMock := initSdlSyncStorageMock()
844 loadInfo := generateRanLoadInformation()
846 data, err := proto.Marshal(loadInfo)
848 t.Errorf("#rNibReader_test.TestGetRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
850 redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
852 t.Errorf("#rNibReader_test.TestGetRanLoadInformationNotFoundFailure - failed to validate key parameter")
854 ret := map[string]interface{}{redisKey: string(data)}
855 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
856 getLoadInfo, er := w.GetRanLoadInformation(name)
858 assert.NotNil(t, getLoadInfo)
859 expected, err := json.Marshal(loadInfo)
861 t.Errorf("#rNibReader_test.TestGetRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
863 actual, err := json.Marshal(getLoadInfo)
865 t.Errorf("#rNibReader_test.TestGetRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
867 assert.EqualValues(t, expected, actual)
870 func TestGetRanLoadInformationValidationFailure(t *testing.T) {
872 w, _ := initSdlSyncStorageMock()
873 getNb, er := w.GetRanLoadInformation(name)
876 assert.IsType(t, &common.ValidationError{}, er)
877 assert.EqualValues(t, "#utils.ValidateAndBuildRanLoadInformationKey - an empty inventory name received", er.Error())
880 func TestGetRanLoadInformationNotFoundFailure(t *testing.T) {
882 w, sdlInstanceMock := initSdlSyncStorageMock()
884 var ret map[string]interface{}
885 redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
887 t.Errorf("#rNibReader_test.TestGetRanLoadInformationNotFoundFailure - failed to validate key parameter")
889 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
890 getNb, er := w.GetRanLoadInformation(name)
893 assert.IsType(t, &common.ResourceNotFoundError{}, er)
894 assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.RanLoadInformation not found. Key: LOAD:name", er.Error())
897 func TestGetRanLoadInformationUnmarshalFailure(t *testing.T) {
899 w, sdlInstanceMock := initSdlSyncStorageMock()
901 ret := make(map[string]interface{}, 1)
902 redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
904 t.Errorf("#rNibReader_test.TestGetRanLoadInformationUnmarshalFailure - failed to validate key parameter")
906 ret[redisKey] = "data"
907 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
908 getNb, er := w.GetRanLoadInformation(name)
911 assert.IsType(t, &common.InternalError{}, er)
912 assert.Contains(t, er.Error(), "proto:")
915 func TestGetRanLoadInformationSdlgoFailure(t *testing.T) {
917 errMsg := "expected Sdlgo error"
918 errMsgExpected := "expected Sdlgo error"
919 w, sdlInstanceMock := initSdlSyncStorageMock()
920 e := errors.New(errMsg)
921 var ret map[string]interface{}
922 redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
924 t.Errorf("#rNibReader_test.TestGetRanLoadInformationSdlgoFailure - failed to validate key parameter")
926 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
927 getNb, er := w.GetRanLoadInformation(name)
930 assert.IsType(t, &common.InternalError{}, er)
931 assert.EqualValues(t, errMsgExpected, er.Error())
934 func generateCellLoadInformation() *entities.CellLoadInformation {
935 cellLoadInformation := entities.CellLoadInformation{}
937 cellLoadInformation.CellId = "123"
939 ulInterferenceOverloadIndication := entities.UlInterferenceOverloadIndication_HIGH_INTERFERENCE
940 cellLoadInformation.UlInterferenceOverloadIndications = []entities.UlInterferenceOverloadIndication{ulInterferenceOverloadIndication}
942 ulHighInterferenceInformation := entities.UlHighInterferenceInformation{
944 UlHighInterferenceIndication: "xxx",
947 cellLoadInformation.UlHighInterferenceInfos = []*entities.UlHighInterferenceInformation{&ulHighInterferenceInformation}
949 cellLoadInformation.RelativeNarrowbandTxPower = &entities.RelativeNarrowbandTxPower{
951 RntpThreshold: entities.RntpThreshold_NEG_4,
952 NumberOfCellSpecificAntennaPorts: entities.NumberOfCellSpecificAntennaPorts_V1_ANT_PRT,
954 PdcchInterferenceImpact: 2,
955 EnhancedRntp: &entities.EnhancedRntp{
956 EnhancedRntpBitmap: "xxx",
957 RntpHighPowerThreshold: entities.RntpThreshold_NEG_2,
958 EnhancedRntpStartTime: &entities.StartTime{StartSfn: 500, StartSubframeNumber: 5},
962 cellLoadInformation.AbsInformation = &entities.AbsInformation{
963 Mode: entities.AbsInformationMode_ABS_INFO_FDD,
964 AbsPatternInfo: "xxx",
965 NumberOfCellSpecificAntennaPorts: entities.NumberOfCellSpecificAntennaPorts_V2_ANT_PRT,
966 MeasurementSubset: "xxx",
969 cellLoadInformation.InvokeIndication = entities.InvokeIndication_ABS_INFORMATION
971 cellLoadInformation.ExtendedUlInterferenceOverloadInfo = &entities.ExtendedUlInterferenceOverloadInfo{
972 AssociatedSubframes: "xxx",
973 ExtendedUlInterferenceOverloadIndications: cellLoadInformation.UlInterferenceOverloadIndications,
976 compInformationItem := &entities.CompInformationItem{
977 CompHypothesisSets: []*entities.CompHypothesisSet{{CellId: "789", CompHypothesis: "xxx"}},
981 cellLoadInformation.CompInformation = &entities.CompInformation{
982 CompInformationItems: []*entities.CompInformationItem{compInformationItem},
983 CompInformationStartTime: &entities.StartTime{StartSfn: 123, StartSubframeNumber: 456},
986 cellLoadInformation.DynamicDlTransmissionInformation = &entities.DynamicDlTransmissionInformation{
987 State: entities.NaicsState_NAICS_ACTIVE,
988 TransmissionModes: "xxx",
990 PAList: []entities.PA{entities.PA_DB_NEG_3},
993 return &cellLoadInformation
996 func generateRanLoadInformation() *entities.RanLoadInformation {
997 ranLoadInformation := entities.RanLoadInformation{}
999 ranLoadInformation.LoadTimestamp = uint64(time.Now().UnixNano())
1001 cellLoadInformation := generateCellLoadInformation()
1002 ranLoadInformation.CellLoadInfos = []*entities.CellLoadInformation{cellLoadInformation}
1004 return &ranLoadInformation
1007 func TestGetE2TInstanceSuccess(t *testing.T) {
1008 address := "10.10.2.15:9800"
1009 redisKey, validationErr := common.ValidateAndBuildE2TInstanceKey(address)
1011 if validationErr != nil {
1012 t.Errorf("#rNibReader_test.TestGetE2TInstanceSuccess - Failed to build E2T Instance key. Error: %v", validationErr)
1015 w, sdlInstanceMock := initSdlSyncStorageMock()
1017 e2tInstance := generateE2tInstance(address)
1018 data, err := json.Marshal(e2tInstance)
1021 t.Errorf("#rNibReader_test.TestGetE2TInstanceSuccess - Failed to marshal E2tInstance entity. Error: %v", err)
1025 ret := map[string]interface{}{redisKey: string(data)}
1026 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, e)
1028 res, rNibErr := w.GetE2TInstance(address)
1029 assert.Nil(t, rNibErr)
1030 assert.Equal(t, e2tInstance, res)
1033 func TestUnmarshal(t *testing.T) {
1034 e2tInstance := generateE2tInstance("10.0.2.15:5555")
1035 marshaled, _ := json.Marshal(e2tInstance)
1036 m := map[string]interface{}{
1037 "whatever": string(marshaled),
1039 var entity entities.E2TInstance
1040 err := json.Unmarshal([]byte(m["whatever"].(string)), &entity)
1044 func TestGetE2TInstanceEmptyAddressFailure(t *testing.T) {
1045 w, _ := initSdlSyncStorageMock()
1046 res, err := w.GetE2TInstance("")
1047 assert.NotNil(t, err)
1048 assert.IsType(t, &common.ValidationError{}, err)
1052 func TestGetE2TInstanceSdlError(t *testing.T) {
1053 address := "10.10.2.15:9800"
1054 redisKey, validationErr := common.ValidateAndBuildE2TInstanceKey(address)
1056 if validationErr != nil {
1057 t.Errorf("#rNibReader_test.TestGetE2TInstanceSuccess - Failed to build E2T Instance key. Error: %v", validationErr)
1060 w, sdlInstanceMock := initSdlSyncStorageMock()
1062 expectedErr := errors.New("expected error")
1063 var ret map[string]interface{}
1064 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey}).Return(ret, expectedErr)
1066 res, rNibErr := w.GetE2TInstance(address)
1067 assert.NotNil(t, rNibErr)
1071 func generateE2tInstance(address string) *entities.E2TInstance {
1072 e2tInstance := entities.NewE2TInstance(address,"")
1073 e2tInstance.AssociatedRanList = []string{"test1", "test2"}
1074 e2tInstance.DeletionTimestamp = time.Now().UnixNano()
1078 func TestGetE2TAddressesSdlError(t *testing.T) {
1079 w, sdlInstanceMock := initSdlSyncStorageMock()
1081 expectedErr := errors.New("expected error")
1082 var ret map[string]interface{}
1083 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{E2TAddressesKey}).Return(ret, expectedErr)
1085 res, rNibErr := w.GetE2TAddresses()
1086 assert.NotNil(t, rNibErr)
1090 func TestGetE2TAddressesSuccess(t *testing.T) {
1091 address := "10.10.2.15:9800"
1092 w, sdlInstanceMock := initSdlSyncStorageMock()
1094 e2tAddresses := []string{address}
1095 data, err := json.Marshal(e2tAddresses)
1098 t.Errorf("#rNibReader_test.TestGetE2TInfoListSuccess - Failed to marshal E2TInfoList. Error: %v", err)
1102 ret := map[string]interface{}{E2TAddressesKey: string(data)}
1103 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{E2TAddressesKey}).Return(ret, e)
1105 res, rNibErr := w.GetE2TAddresses()
1106 assert.Nil(t, rNibErr)
1107 assert.Equal(t, e2tAddresses, res)
1110 func TestGetE2TInstancesSuccess(t *testing.T) {
1111 address := "10.10.2.15:9800"
1112 address2 := "10.10.2.16:9800"
1113 redisKey, _ := common.ValidateAndBuildE2TInstanceKey(address)
1114 redisKey2, _ := common.ValidateAndBuildE2TInstanceKey(address2)
1116 w, sdlInstanceMock := initSdlSyncStorageMock()
1118 e2tInstance1 := generateE2tInstance(address)
1119 e2tInstance2 := generateE2tInstance(address2)
1121 data1, _ := json.Marshal(e2tInstance1)
1122 data2, _ := json.Marshal(e2tInstance2)
1125 ret := map[string]interface{}{redisKey: string(data1), redisKey2: string(data2)}
1126 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey, redisKey2}).Return(ret, e)
1128 res, err := w.GetE2TInstances([]string{address, address2})
1130 assert.Equal(t, []*entities.E2TInstance{e2tInstance1, e2tInstance2}, res)
1133 func TestGetE2TInstancesUnmarhalPartialSuccess(t *testing.T) {
1134 address := "10.10.2.15:9800"
1135 address2 := "10.10.2.16:9800"
1136 redisKey, _ := common.ValidateAndBuildE2TInstanceKey(address)
1137 redisKey2, _ := common.ValidateAndBuildE2TInstanceKey(address2)
1139 w, sdlInstanceMock := initSdlSyncStorageMock()
1141 e2tInstance1 := generateE2tInstance(address)
1142 data1, _ := json.Marshal(e2tInstance1)
1145 ret := map[string]interface{}{redisKey: string(data1), redisKey2: "abc"}
1146 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey, redisKey2}).Return(ret, e)
1148 res, err := w.GetE2TInstances([]string{address, address2})
1150 assert.Equal(t, []*entities.E2TInstance{e2tInstance1}, res)
1153 func TestGetE2TInstancesSdlFailure(t *testing.T) {
1154 address := "10.10.2.15:9800"
1155 address2 := "10.10.2.16:9800"
1156 redisKey, _ := common.ValidateAndBuildE2TInstanceKey(address)
1157 redisKey2, _ := common.ValidateAndBuildE2TInstanceKey(address2)
1159 w, sdlInstanceMock := initSdlSyncStorageMock()
1161 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{redisKey, redisKey2}).Return(map[string]interface{}{}, fmt.Errorf(""))
1162 _, err := w.GetE2TInstances([]string{address, address2})
1163 assert.IsType(t, &common.InternalError{}, err)
1166 func TestGetE2TInstancesEmptyData(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{}{}, nil)
1175 _, err := w.GetE2TInstances([]string{address, address2})
1176 assert.IsType(t, &common.ResourceNotFoundError{}, err)
1179 func TestGetGeneralConfiguration(t *testing.T) {
1181 key := common.BuildGeneralConfigurationKey()
1182 w, sdlInstanceMock := initSdlSyncStorageMock()
1184 configurationData := "{\"enableRic\":true}"
1185 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(map[string]interface{}{key: configurationData}, nil)
1187 res, rNibErr := w.GetGeneralConfiguration()
1188 assert.Nil(t, rNibErr)
1189 assert.Equal(t, true, res.EnableRic)
1192 func TestGetGeneralConfigurationNotFound(t *testing.T) {
1194 key := common.BuildGeneralConfigurationKey()
1195 w, sdlInstanceMock := initSdlSyncStorageMock()
1197 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(map[string]interface{}{}, nil)
1199 _, rNibErr := w.GetGeneralConfiguration()
1201 assert.NotNil(t, rNibErr)
1202 assert.Equal(t, "#rNibReader.getByKeyAndUnmarshalJson - entity of type *entities.GeneralConfiguration not found. Key: GENERAL", rNibErr.Error())
1205 func TestGetGeneralConfigurationSdlFailure(t *testing.T) {
1207 key := common.BuildGeneralConfigurationKey()
1208 w, sdlInstanceMock := initSdlSyncStorageMock()
1210 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(map[string]interface{}{}, fmt.Errorf("sdl error"))
1212 _, rNibErr := w.GetGeneralConfiguration()
1214 assert.NotNil(t, rNibErr)
1216 assert.Equal(t, "sdl error", rNibErr.Error())
1219 func TestGetGeneralConfigurationUnmarshalError(t *testing.T) {
1221 key := common.BuildGeneralConfigurationKey()
1222 w, sdlInstanceMock := initSdlSyncStorageMock()
1224 configurationData := "{\"enableRic :true}"
1225 sdlInstanceMock.On("Get", common.GetRNibNamespace(), []string{key}).Return(map[string]interface{}{key: configurationData}, nil)
1227 _, rNibErr := w.GetGeneralConfiguration()
1229 assert.NotNil(t, rNibErr)
1230 assert.Equal(t, rNibErr.Error(), "unexpected end of JSON input")
1235 //func TestGetEnbInteg(t *testing.T){
1236 // name := "nameEnb1"
1237 // Init("namespace", 1)
1238 // w := GetRNibReader()
1239 // nb, err := w.GetNodeb(name)
1243 // fmt.Printf("#TestGetEnbInteg - responding node type: %v\n", nb)
1247 //func TestGetEnbCellsInteg(t *testing.T){
1248 // name := "nameEnb1"
1249 // Init("namespace", 1)
1250 // w := GetRNibReader()
1251 // cells, err := w.GetCellList(name)
1254 // } else if cells != nil{
1255 // for _, cell := range cells.GetServedCellInfos().ServedCells{
1256 // fmt.Printf("responding node type Cell: %v\n", *cell)
1261 //func TestGetGnbInteg(t *testing.T){
1262 // name := "nameGnb1"
1263 // Init("namespace", 1)
1264 // w := GetRNibReader()
1265 // nb, err := w.GetNodeb(name)
1269 // fmt.Printf("#TestGetGnbInteg - responding node type: %v\n", nb)
1273 //func TestGetGnbCellsInteg(t *testing.T){
1274 // name := "nameGnb1"
1275 // Init("namespace", 1)
1276 // w := GetRNibReader()
1277 // cells, err := w.GetCellList(name)
1280 // } else if cells != nil{
1281 // for _, cell := range cells.GetServedNrCells().ServedCells{
1282 // fmt.Printf("responding node type NR Cell: %v\n", *cell)
1287 //func TestGetListEnbIdsInteg(t *testing.T) {
1288 // Init("namespace", 1)
1289 // w := GetRNibReader()
1290 // ids, err := w.GetListEnbIds()
1294 // for _, id := range ids{
1295 // fmt.Printf("#TestGetListEnbIdsInteg - ENB ID: %s\n", id)
1300 //func TestGetListGnbIdsInteg(t *testing.T) {
1301 // Init("namespace", 1)
1302 // w := GetRNibReader()
1303 // ids, err := w.GetListGnbIds()
1307 // for _, id := range ids{
1308 // fmt.Printf("#TestGetListGnbIdsInteg - GNB ID: %s\n", id)
1313 //func TestGetCountGnbListInteg(t *testing.T) {
1314 // Init("namespace", 1)
1315 // w := GetRNibReader()
1316 // count, err := w.GetCountGnbList()
1320 // fmt.Printf("#TestGetCountGnbListInteg - count Gnb list: %d\n", count)
1324 //func TestGetGnbCellInteg(t *testing.T){
1325 // name := "nameGnb7"
1327 // Init("namespace", 1)
1328 // w := GetRNibReader()
1329 // cell, err := w.GetCell(name, uint32(pci))
1332 // } else if cell != nil{
1333 // fmt.Printf("responding node type NR Cell: %v\n", cell.GetServedNrCell())
1337 //func TestGetEnbCellInteg(t *testing.T) {
1338 // name := "nameEnb1"
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 LTE Cell: %v\n", cell.GetServedCellInfo())
1350 //func TestGetEnbCellByIdInteg(t *testing.T){
1351 // Init("namespace", 1)
1352 // w := GetRNibReader()
1353 // cell, err := w.GetCellById(entities.Cell_NR_CELL, "45d")
1356 // } else if cell != nil{
1357 // fmt.Printf("responding node type NR Cell: %v\n", cell.GetServedNrCell())
1361 //func TestGetListNbIdsInteg(t *testing.T) {
1362 // Init("e2Manager", 1)
1363 // w := GetRNibReader()
1364 // ids, err := w.GetListNodebIds()
1368 // for _, id := range ids{
1369 // fmt.Printf("#TestGetListGnbIdsInteg - NB ID: %s\n", id)
1374 //func TestGetRanLoadInformationInteg(t *testing.T){
1375 // Init("e2Manager", 1)
1376 // w := GetRNibReader()
1377 // ranLoadInformation, err := w.GetRanLoadInformation("ran_integ")
1379 // t.Errorf("#rNibReader_test.TestGetRanLoadInformationInteg - Failed to get RanLoadInformation entity. Error: %v", err)
1381 // assert.NotNil(t, ranLoadInformation)
1382 // fmt.Printf("#rNibReader_test.TestGetRanLoadInformationInteg - GNB ID: %s\n", ranLoadInformation)
1385 //func TestGetE2TInstancesInteg(t *testing.T) {
1386 // db := sdlgo.NewDatabase()
1387 // sdl := sdlgo.NewSdlInstance("e2Manager", db)
1388 // rnibReader := GetRNibReader(sdl)
1389 // e2tInstances, _ := rnibReader.GetE2TInstances([]string{"e2t.att.com:38000","whatever"})
1390 // assert.Len(t, e2tInstances, 1)