92cce392012103c616a8622cdf5da3c9c1527771
[ric-plt/nodeb-rnib.git] / reader / rNibReader_test.go
1 //
2 // Copyright 2019 AT&T Intellectual Property
3 // Copyright 2019 Nokia
4 //
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
8 //
9 //      http://www.apache.org/licenses/LICENSE-2.0
10 //
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.
16
17 //  This source code is part of the near-RT RIC (RAN Intelligent Controller)
18 //  platform project (RICP).
19
20 package reader
21
22 import (
23         "encoding/json"
24         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
25         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
26         "github.com/golang/protobuf/proto"
27         "github.com/pkg/errors"
28         "github.com/stretchr/testify/assert"
29         "testing"
30         "time"
31 )
32
33 var namespace = "namespace"
34
35 func initSdlInstanceMock(namespace string) (w RNibReader, sdlInstanceMock *MockSdlInstance) {
36         sdlInstanceMock = new(MockSdlInstance)
37         w = GetRNibReader(sdlInstanceMock)
38         return
39 }
40
41 func TestGetNodeB(t *testing.T) {
42         name := "name"
43         w, sdlInstanceMock := initSdlInstanceMock(namespace)
44         nb := entities.NodebInfo{}
45         nb.ConnectionStatus = 1
46         nb.Ip = "localhost"
47         nb.Port = 5656
48         enb := entities.Enb{}
49         cell := entities.ServedCellInfo{Tac: "tac"}
50         enb.ServedCells = []*entities.ServedCellInfo{&cell}
51         nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
52         var e error
53         data, err := proto.Marshal(&nb)
54         if err != nil {
55                 t.Errorf("#rNibReader_test.TestGetNb - Failed to marshal ENB instance. Error: %v", err)
56         }
57         redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
58         if rNibErr != nil {
59                 t.Errorf("#rNibReader_test.TestGetNodeB - failed to validate key parameter")
60         }
61         ret := map[string]interface{}{redisKey: string(data)}
62         sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
63         getNb, er := w.GetNodeb(name)
64         assert.Nil(t, er)
65         assert.Equal(t, getNb.Ip, nb.Ip)
66         assert.Equal(t, getNb.Port, nb.Port)
67         assert.Equal(t, getNb.ConnectionStatus, nb.ConnectionStatus)
68         assert.Len(t, getNb.GetEnb().GetServedCells(), 1)
69         assert.Equal(t, getNb.GetEnb().GetServedCells()[0].Tac, nb.GetEnb().GetServedCells()[0].Tac)
70 }
71
72 func TestGetNodeBNotFoundFailure(t *testing.T) {
73         name := "name"
74         w, sdlInstanceMock := initSdlInstanceMock(namespace)
75         var e error
76         var ret map[string]interface{}
77         redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
78         if rNibErr != nil {
79                 t.Errorf("#rNibReader_test.TestGetNodeBNotFoundFailure - failed to validate key parameter")
80         }
81         sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
82         getNb, er := w.GetNodeb(name)
83         assert.NotNil(t, er)
84         assert.Nil(t, getNb)
85         assert.IsType(t, &common.ResourceNotFoundError{}, er)
86         assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.NodebInfo not found. Key: RAN:name", er.Error())
87 }
88
89 func TestGetNodeBUnmarshalFailure(t *testing.T) {
90         name := "name"
91         w, sdlInstanceMock := initSdlInstanceMock(namespace)
92         var e error
93         ret := make(map[string]interface{}, 1)
94         redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
95         if rNibErr != nil {
96                 t.Errorf("#rNibReader_test.TestGetNodeBUnmarshalFailure - failed to validate key parameter")
97         }
98         ret[redisKey] = "data"
99         sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
100         getNb, er := w.GetNodeb(name)
101         assert.NotNil(t, er)
102         assert.Nil(t, getNb)
103         assert.IsType(t, &common.InternalError{}, er)
104         assert.EqualValues(t, "proto: can't skip unknown wire type 4", er.Error())
105 }
106
107 func TestGetNodeBSdlgoFailure(t *testing.T) {
108         name := "name"
109         errMsg := "expected Sdlgo error"
110         errMsgExpected := "expected Sdlgo error"
111         w, sdlInstanceMock := initSdlInstanceMock(namespace)
112         e := errors.New(errMsg)
113         var ret map[string]interface{}
114         redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
115         if rNibErr != nil {
116                 t.Errorf("#rNibReader_test.TestGetNodeBSdlgoFailure - failed to validate key parameter")
117         }
118         sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
119         getNb, er := w.GetNodeb(name)
120         assert.NotNil(t, er)
121         assert.Nil(t, getNb)
122         assert.IsType(t, &common.InternalError{}, er)
123         assert.EqualValues(t, errMsgExpected, er.Error())
124 }
125
126 func TestGetNodeBCellsListEnb(t *testing.T) {
127         name := "name"
128         w, sdlInstanceMock := initSdlInstanceMock(namespace)
129         nb := entities.NodebInfo{}
130         nb.ConnectionStatus = 1
131         nb.Ip = "localhost"
132         nb.Port = 5656
133         enb := entities.Enb{}
134         cell := entities.ServedCellInfo{Tac: "tac"}
135         enb.ServedCells = []*entities.ServedCellInfo{&cell}
136         nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
137         var e error
138         data, err := proto.Marshal(&nb)
139         if err != nil {
140                 t.Errorf("#rNibReader_test.GetNodeBCellsList - Failed to marshal ENB instance. Error: %v", err)
141         }
142         redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
143         if rNibErr != nil {
144                 t.Errorf("#rNibReader_test.TestGetNodeBCellsListEnb - failed to validate key parameter")
145         }
146         ret := map[string]interface{}{redisKey: string(data)}
147         sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
148         cells, er := w.GetCellList(name)
149         assert.Nil(t, er)
150         assert.NotNil(t, cells)
151         assert.Len(t, cells.GetServedCellInfos().GetServedCells(), 1)
152         retCell := cells.GetServedCellInfos().GetServedCells()[0]
153         assert.Equal(t, retCell.Tac, "tac")
154 }
155
156 func TestGetNodeBCellsListGnb(t *testing.T) {
157         name := "name"
158         w, sdlInstanceMock := initSdlInstanceMock(namespace)
159         nb := entities.NodebInfo{}
160         nb.ConnectionStatus = 1
161         nb.Ip = "localhost"
162         nb.Port = 5656
163         nb.NodeType = entities.Node_GNB
164         gnb := entities.Gnb{}
165         cell := entities.ServedNRCell{ServedNrCellInformation: &entities.ServedNRCellInformation{NrPci: 10}}
166         gnb.ServedNrCells = []*entities.ServedNRCell{&cell}
167         nb.Configuration = &entities.NodebInfo_Gnb{Gnb: &gnb}
168         var e error
169         data, err := proto.Marshal(&nb)
170         if err != nil {
171                 t.Errorf("#rNibReader_test.GetNodeBCellsList - Failed to marshal GNB instance. Error: %v", err)
172         }
173         redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
174         if rNibErr != nil {
175                 t.Errorf("#rNibReader_test.TestGetNodeBCellsListGnb - failed to validate key parameter")
176         }
177         ret := map[string]interface{}{redisKey: string(data)}
178         sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
179         cells, er := w.GetCellList(name)
180         assert.Nil(t, er)
181         assert.NotNil(t, cells)
182         assert.Len(t, cells.GetServedNrCells().GetServedCells(), 1)
183         retCell := cells.GetServedNrCells().GetServedCells()[0]
184         assert.Equal(t, retCell.GetServedNrCellInformation().GetNrPci(), uint32(10))
185 }
186
187 func TestGetNodeBCellsListNodeUnmarshalFailure(t *testing.T) {
188         name := "name"
189         w, sdlInstanceMock := initSdlInstanceMock(namespace)
190         var e error
191         ret := make(map[string]interface{}, 1)
192         redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
193         if rNibErr != nil {
194                 t.Errorf("#rNibReader_test.TestGetNodeBCellsListNodeUnmarshalFailure - failed to validate key parameter")
195         }
196         ret[redisKey] = "data"
197         sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
198         cells, er := w.GetCellList(name)
199         assert.NotNil(t, er)
200         assert.Nil(t, cells)
201         assert.IsType(t, &common.InternalError{}, er)
202         assert.EqualValues(t, "proto: can't skip unknown wire type 4", er.Error())
203 }
204
205 func TestGetNodeBCellsListNodeNotFoundFailure(t *testing.T) {
206         name := "name"
207         w, sdlInstanceMock := initSdlInstanceMock(namespace)
208         var e error
209         var ret map[string]interface{}
210         redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
211         if rNibErr != nil {
212                 t.Errorf("#rNibReader_test.TestGetNodeBCellsListNodeNotFoundFailure - failed to validate key parameter")
213         }
214         sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
215         cells, er := w.GetCellList(name)
216         assert.NotNil(t, er)
217         assert.Nil(t, cells)
218         assert.IsType(t, &common.ResourceNotFoundError{}, er)
219         assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.NodebInfo not found. Key: RAN:name", er.Error())
220 }
221
222 func TestGetNodeBCellsListNotFoundFailureEnb(t *testing.T) {
223         name := "name"
224         w, sdlInstanceMock := initSdlInstanceMock(namespace)
225         nb := entities.NodebInfo{}
226         nb.ConnectionStatus = 1
227         nb.Ip = "localhost"
228         nb.Port = 5656
229         enb := entities.Enb{}
230         nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
231         var e error
232         data, err := proto.Marshal(&nb)
233         if err != nil {
234                 t.Errorf("#rNibReader_test.TestGetNbCellsListNotFoundFailure - Failed to marshal ENB instance. Error: %v", err)
235         }
236         redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
237         if rNibErr != nil {
238                 t.Errorf("#rNibReader_test.TestGetNodeBCellsListNotFoundFailureEnb - failed to validate key parameter")
239         }
240         ret := map[string]interface{}{redisKey: string(data)}
241         sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
242         _, er := w.GetCellList(name)
243         assert.NotNil(t, er)
244         assert.EqualValues(t, "#rNibReader.GetCellList - served cells not found. Responding node RAN name: name.", er.Error())
245 }
246
247 func TestGetNodeBCellsListNotFoundFailureGnb(t *testing.T) {
248         name := "name"
249         w, sdlInstanceMock := initSdlInstanceMock(namespace)
250         nb := entities.NodebInfo{}
251         nb.ConnectionStatus = 1
252         nb.Ip = "localhost"
253         nb.Port = 5656
254         gnb := entities.Gnb{}
255         nb.Configuration = &entities.NodebInfo_Gnb{Gnb: &gnb}
256         var e error
257         data, err := proto.Marshal(&nb)
258         if err != nil {
259                 t.Errorf("#rNibReader_test.TestGetNodeBCellsListNotFoundFailureGnb - Failed to marshal ENB instance. Error: %v", err)
260         }
261         redisKey, rNibErr := common.ValidateAndBuildNodeBNameKey(name)
262         if rNibErr != nil {
263                 t.Errorf("#rNibReader_test.TestGetNodeBCellsListNotFoundFailureGnb - failed to validate key parameter")
264         }
265         ret := map[string]interface{}{redisKey: string(data)}
266         sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
267         _, er := w.GetCellList(name)
268         assert.NotNil(t, er)
269         assert.EqualValues(t, "#rNibReader.GetCellList - served cells not found. Responding node RAN name: name.", er.Error())
270 }
271
272 func TestGetListGnbIdsUnmarshalFailure(t *testing.T) {
273         w, sdlInstanceMock := initSdlInstanceMock(namespace)
274         var e error
275         sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return([]string{"data"}, e)
276         ids, er := w.GetListGnbIds()
277         assert.NotNil(t, er)
278         assert.Nil(t, ids)
279         assert.IsType(t, &common.InternalError{}, er)
280         assert.Equal(t, "proto: can't skip unknown wire type 4", er.Error())
281 }
282
283 func TestGetListGnbIdsSdlgoFailure(t *testing.T) {
284         errMsg := "expected Sdlgo error"
285         errMsgExpected := "expected Sdlgo error"
286         w, sdlInstanceMock := initSdlInstanceMock(namespace)
287         e := errors.New(errMsg)
288         var data []string
289         sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return(data, e)
290         ids, er := w.GetListGnbIds()
291         assert.NotNil(t, er)
292         assert.Nil(t, ids)
293         assert.IsType(t, &common.InternalError{}, er)
294         assert.EqualValues(t, errMsgExpected, er.Error())
295 }
296
297 func TestGetListNodesIdsGnbSdlgoFailure(t *testing.T) {
298         w, sdlInstanceMock := initSdlInstanceMock(namespace)
299
300         name := "name"
301         plmnId := "02f829"
302         nbId := "4a952a0a"
303         nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
304         var nilError error
305         data, err := proto.Marshal(nbIdentity)
306         if err != nil {
307                 t.Errorf("#rNibReader_test.TestGetListNodesIdsGnbSdlgoFailure - Failed to marshal nodeb identity entity. Error: %v", err)
308         }
309         sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{string(data)}, nilError)
310
311         errMsg := "expected Sdlgo error"
312         errMsgExpected := "expected Sdlgo error"
313         expectedError := errors.New(errMsg)
314         var nilData []string
315         sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return(nilData, expectedError)
316
317         ids, er := w.GetListNodebIds()
318         assert.NotNil(t, er)
319         assert.Nil(t, ids)
320         assert.IsType(t, &common.InternalError{}, er)
321         assert.EqualValues(t, errMsgExpected, er.Error())
322 }
323
324 func TestGetListNodesIdsEnbSdlgoFailure(t *testing.T) {
325         w, sdlInstanceMock := initSdlInstanceMock(namespace)
326
327         name := "name"
328         plmnId := "02f829"
329         nbId := "4a952a0a"
330         nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
331         var nilError error
332         data, err := proto.Marshal(nbIdentity)
333         if err != nil {
334                 t.Errorf("#rNibReader_test.TestGetListNodesIdsEnbSdlgoFailure - Failed to marshal nodeb identity entity. Error: %v", err)
335         }
336         sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return([]string{string(data)}, nilError)
337
338         errMsg := "expected Sdlgo error"
339         errMsgExpected := "expected Sdlgo error"
340         expectedError := errors.New(errMsg)
341         var nilData []string
342         sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return(nilData, expectedError)
343
344         ids, er := w.GetListNodebIds()
345         assert.NotNil(t, er)
346         assert.Nil(t, ids)
347         assert.IsType(t, &common.InternalError{}, er)
348         assert.EqualValues(t, errMsgExpected, er.Error())
349 }
350
351 func TestGetListNodesIdsSuccess(t *testing.T) {
352         w, sdlInstanceMock := initSdlInstanceMock(namespace)
353         var nilError error
354
355         name := "name"
356         plmnId := "02f829"
357         nbId := "4a952a0a"
358         nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
359         data, err := proto.Marshal(nbIdentity)
360         if err != nil {
361                 t.Errorf("#rNibReader_test.TestGetListNodesIdsSuccess - Failed to marshal nodeb identity entity. Error: %v", err)
362         }
363
364         name1 := "name1"
365         plmnId1 := "02f845"
366         nbId1 := "4a952a75"
367         nbIdentity1 := &entities.NbIdentity{InventoryName: name1, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId1, NbId: nbId1}}
368         data1, err := proto.Marshal(nbIdentity1)
369         if err != nil {
370                 t.Errorf("#rNibReader_test.TestGetListNodesIdsSuccess - Failed to marshal nodeb identity entity. Error: %v", err)
371         }
372
373         name2 := "name2"
374         nbIdentity2 := &entities.NbIdentity{InventoryName: name2}
375         data2, err := proto.Marshal(nbIdentity2)
376         if err != nil {
377                 t.Errorf("#rNibReader_test.TestGetListNodesIdsSuccess - Failed to marshal nodeb identity entity. Error: %v", err)
378         }
379
380         sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return([]string{string(data)}, nilError)
381         sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{string(data1)}, nilError)
382         sdlInstanceMock.On("GetMembers", entities.Node_UNKNOWN.String()).Return([]string{string(data2)}, nilError)
383
384         ids, er := w.GetListNodebIds()
385         assert.Nil(t, er)
386         assert.NotNil(t, ids)
387         assert.Len(t, ids, 3)
388 }
389
390 func TestGetListEnbIdsUnmarshalFailure(t *testing.T) {
391         w, sdlInstanceMock := initSdlInstanceMock(namespace)
392         var e error
393         sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{"data"}, e)
394         ids, er := w.GetListEnbIds()
395         assert.NotNil(t, er)
396         assert.Nil(t, ids)
397         assert.IsType(t, &common.InternalError{}, er)
398         assert.Equal(t, "proto: can't skip unknown wire type 4", er.Error())
399 }
400
401 func TestGetListEnbIdsOneId(t *testing.T) {
402         name := "name"
403         plmnId := "02f829"
404         nbId := "4a952a0a"
405         w, sdlInstanceMock := initSdlInstanceMock(namespace)
406         nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
407         var e error
408         data, err := proto.Marshal(nbIdentity)
409         if err != nil {
410                 t.Errorf("#rNibReader_test.TestGetListEnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
411         }
412         sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{string(data)}, e)
413         ids, er := w.GetListEnbIds()
414         assert.Nil(t, er)
415         assert.Len(t, ids, 1)
416         assert.Equal(t, (ids)[0].GetInventoryName(), name)
417         assert.Equal(t, (ids)[0].GetGlobalNbId().GetPlmnId(), nbIdentity.GetGlobalNbId().GetPlmnId())
418         assert.Equal(t, (ids)[0].GetGlobalNbId().GetNbId(), nbIdentity.GetGlobalNbId().GetNbId())
419 }
420
421 func TestGetListEnbIdsNoIds(t *testing.T) {
422         w, sdlInstanceMock := initSdlInstanceMock(namespace)
423         var e error
424         sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return([]string{}, e)
425         ids, er := w.GetListEnbIds()
426         assert.Nil(t, er)
427         assert.Len(t, ids, 0)
428 }
429
430 func TestGetListEnbIds(t *testing.T) {
431         name := "name"
432         plmnId := 0x02f829
433         nbId := 0x4a952a0a
434         listSize := 3
435         w, sdlInstanceMock := initSdlInstanceMock(namespace)
436         idsData := make([]string, listSize)
437         idsEntities := make([]*entities.NbIdentity, listSize)
438         for i := 0; i < listSize; i++ {
439                 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: string(plmnId + i), NbId: string(nbId + i)}}
440                 data, err := proto.Marshal(nbIdentity)
441                 if err != nil {
442                         t.Errorf("#rNibReader_test.TestGetListEnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
443                 }
444                 idsData[i] = string(data)
445                 idsEntities[i] = nbIdentity
446         }
447         var e error
448         sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return(idsData, e)
449         ids, er := w.GetListEnbIds()
450         assert.Nil(t, er)
451         assert.Len(t, ids, listSize)
452         for i, id := range ids {
453                 assert.Equal(t, id.GetInventoryName(), name)
454                 assert.Equal(t, id.GetGlobalNbId().GetPlmnId(), idsEntities[i].GetGlobalNbId().GetPlmnId())
455                 assert.Equal(t, id.GetGlobalNbId().GetNbId(), idsEntities[i].GetGlobalNbId().GetNbId())
456         }
457 }
458
459 func TestGetListGnbIdsOneId(t *testing.T) {
460         name := "name"
461         plmnId := "02f829"
462         nbId := "4a952a0a"
463         w, sdlInstanceMock := initSdlInstanceMock(namespace)
464         nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
465         var e error
466         data, err := proto.Marshal(nbIdentity)
467         if err != nil {
468                 t.Errorf("#rNibReader_test.TestGetListGnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
469         }
470         sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return([]string{string(data)}, e)
471         ids, er := w.GetListGnbIds()
472         assert.Nil(t, er)
473         assert.Len(t, ids, 1)
474         assert.Equal(t, (ids)[0].GetInventoryName(), name)
475         assert.Equal(t, (ids)[0].GetGlobalNbId().GetPlmnId(), nbIdentity.GetGlobalNbId().GetPlmnId())
476         assert.Equal(t, (ids)[0].GetGlobalNbId().GetNbId(), nbIdentity.GetGlobalNbId().GetNbId())
477 }
478
479 func TestGetListGnbIdsNoIds(t *testing.T) {
480         w, sdlInstanceMock := initSdlInstanceMock(namespace)
481         var e error
482         sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return([]string{}, e)
483         ids, er := w.GetListGnbIds()
484         assert.Nil(t, er)
485         assert.Len(t, ids, 0)
486 }
487
488 func TestGetListGnbIds(t *testing.T) {
489         name := "name"
490         plmnId := 0x02f829
491         nbId := 0x4a952a0a
492         listSize := 3
493         w, sdlInstanceMock := initSdlInstanceMock(namespace)
494         idsData := make([]string, listSize)
495         idsEntities := make([]*entities.NbIdentity, listSize)
496         for i := 0; i < listSize; i++ {
497                 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: string(plmnId + i), NbId: string(nbId + i)}}
498                 data, err := proto.Marshal(nbIdentity)
499                 if err != nil {
500                         t.Errorf("#rNibReader_test.TestGetListGnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
501                 }
502                 idsData[i] = string(data)
503                 idsEntities[i] = nbIdentity
504         }
505         var e error
506         sdlInstanceMock.On("GetMembers", entities.Node_GNB.String()).Return(idsData, e)
507         ids, er := w.GetListGnbIds()
508         assert.Nil(t, er)
509         assert.Len(t, ids, listSize)
510         for i, id := range ids {
511                 assert.Equal(t, id.GetInventoryName(), name)
512                 assert.Equal(t, id.GetGlobalNbId().GetPlmnId(), idsEntities[i].GetGlobalNbId().GetPlmnId())
513                 assert.Equal(t, id.GetGlobalNbId().GetNbId(), idsEntities[i].GetGlobalNbId().GetNbId())
514         }
515 }
516
517 func TestGetListEnbIdsSdlgoFailure(t *testing.T) {
518         errMsg := "expected Sdlgo error"
519         errMsgExpected := "expected Sdlgo error"
520         w, sdlInstanceMock := initSdlInstanceMock(namespace)
521         e := errors.New(errMsg)
522         var data []string
523         sdlInstanceMock.On("GetMembers", entities.Node_ENB.String()).Return(data, e)
524         ids, er := w.GetListEnbIds()
525         assert.NotNil(t, er)
526         assert.Nil(t, ids)
527         assert.IsType(t, &common.InternalError{}, er)
528         assert.EqualValues(t, errMsgExpected, er.Error())
529 }
530
531 func TestGetCountGnbListOneId(t *testing.T) {
532         w, sdlInstanceMock := initSdlInstanceMock(namespace)
533         var e error
534         sdlInstanceMock.On("GroupSize", entities.Node_GNB.String()).Return(1, e)
535         count, er := w.GetCountGnbList()
536         assert.Nil(t, er)
537         assert.Equal(t, count, 1)
538 }
539
540 func TestGetCountGnbList(t *testing.T) {
541         w, sdlInstanceMock := initSdlInstanceMock(namespace)
542         var e error
543         sdlInstanceMock.On("GroupSize", entities.Node_GNB.String()).Return(3, e)
544         count, er := w.GetCountGnbList()
545         assert.Nil(t, er)
546         assert.Equal(t, count, 3)
547 }
548
549 func TestGetCountGnbListSdlgoFailure(t *testing.T) {
550         errMsg := "expected Sdlgo error"
551         errMsgExpected := "expected Sdlgo error"
552         w, sdlInstanceMock := initSdlInstanceMock(namespace)
553         e := errors.New(errMsg)
554         var count int
555         sdlInstanceMock.On("GroupSize", entities.Node_GNB.String()).Return(count, e)
556         count, er := w.GetCountGnbList()
557         assert.NotNil(t, er)
558         assert.Equal(t, 0, count)
559         assert.IsType(t, &common.InternalError{}, er)
560         assert.EqualValues(t, errMsgExpected, er.Error())
561 }
562
563 func TestGetCell(t *testing.T) {
564         name := "name"
565         var pci uint32 = 10
566         w, sdlInstanceMock := initSdlInstanceMock(namespace)
567         cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: &entities.ServedCellInfo{Pci: pci}}}
568         cellData, err := proto.Marshal(&cellEntity)
569         if err != nil {
570                 t.Errorf("#rNibReader_test.TestGetCell - Failed to marshal Cell entity. Error: %v", err)
571         }
572         var e error
573         key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
574         if rNibErr != nil {
575                 t.Errorf("#rNibReader_test.TestGetCell - failed to validate key parameter")
576         }
577         ret := map[string]interface{}{key: string(cellData)}
578         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
579         cell, er := w.GetCell(name, pci)
580         assert.Nil(t, er)
581         assert.NotNil(t, cell)
582         assert.Equal(t, cell.Type, entities.Cell_LTE_CELL)
583         assert.NotNil(t, cell.GetServedCellInfo())
584         assert.Equal(t, cell.GetServedCellInfo().GetPci(), pci)
585 }
586
587 func TestGetCellNotFoundFailure(t *testing.T) {
588         name := "name"
589         var pci uint32
590         w, sdlInstanceMock := initSdlInstanceMock(namespace)
591         var e error
592         var ret map[string]interface{}
593         key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
594         if rNibErr != nil {
595                 t.Errorf("#rNibReader_test.TestGetCellNotFoundFailure - failed to validate key parameter")
596         }
597         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
598         cell, er := w.GetCell(name, pci)
599         assert.NotNil(t, er)
600         assert.Nil(t, cell)
601         assert.IsType(t, &common.ResourceNotFoundError{}, er)
602         assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.Cell not found. Key: PCI:name:00", er.Error())
603 }
604
605 func TestGetCellUnmarshalFailure(t *testing.T) {
606         name := "name"
607         var pci uint32
608         w, sdlInstanceMock := initSdlInstanceMock(namespace)
609         var e error
610         ret := make(map[string]interface{}, 1)
611         key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
612         if rNibErr != nil {
613                 t.Errorf("#rNibReader_test.TestGetCellUnmarshalFailure - failed to validate key parameter")
614         }
615         ret[key] = "data"
616         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
617         cell, er := w.GetCell(name, pci)
618         assert.NotNil(t, er)
619         assert.Nil(t, cell)
620         assert.IsType(t, &common.InternalError{}, er)
621         assert.EqualValues(t, "proto: can't skip unknown wire type 4", er.Error())
622 }
623
624 func TestGetCellSdlgoFailure(t *testing.T) {
625         name := "name"
626         var pci uint32
627         errMsg := "expected Sdlgo error"
628         errMsgExpected := "expected Sdlgo error"
629         w, sdlInstanceMock := initSdlInstanceMock(namespace)
630         e := errors.New(errMsg)
631         var ret map[string]interface{}
632         key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
633         if rNibErr != nil {
634                 t.Errorf("#rNibReader_test.TestGetCellSdlgoFailure - failed to validate key parameter")
635         }
636         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
637         cell, er := w.GetCell(name, pci)
638         assert.NotNil(t, er)
639         assert.Nil(t, cell)
640         assert.IsType(t, &common.InternalError{}, er)
641         assert.EqualValues(t, errMsgExpected, er.Error())
642 }
643
644 func TestGetNodebById(t *testing.T) {
645         w, sdlInstanceMock := initSdlInstanceMock(namespace)
646         nb := entities.NodebInfo{NodeType: entities.Node_ENB}
647         nb.ConnectionStatus = 1
648         nb.Ip = "localhost"
649         nb.Port = 5656
650         enb := entities.Enb{}
651         cell := entities.ServedCellInfo{Tac: "tac"}
652         enb.ServedCells = []*entities.ServedCellInfo{&cell}
653         nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
654         var e error
655         data, err := proto.Marshal(&nb)
656         if err != nil {
657                 t.Errorf("#rNibReader_test.TestGetNodebById - Failed to marshal ENB instance. Error: %v", err)
658         }
659
660         plmnId := "02f829"
661         nbId := "4a952a0a"
662         key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_ENB.String(), plmnId, nbId)
663         if rNibErr != nil {
664                 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
665         }
666         ret := map[string]interface{}{key: string(data)}
667         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
668         globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
669         getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
670         assert.Nil(t, er)
671         assert.Equal(t, getNb.Ip, nb.Ip)
672         assert.Equal(t, getNb.Port, nb.Port)
673         assert.Equal(t, getNb.ConnectionStatus, nb.ConnectionStatus)
674         assert.Len(t, getNb.GetEnb().GetServedCells(), 1)
675         assert.Equal(t, getNb.GetEnb().GetServedCells()[0].Tac, nb.GetEnb().GetServedCells()[0].Tac)
676 }
677
678 func TestGetNodebByIdNotFoundFailureEnb(t *testing.T) {
679         plmnId := "02f829"
680         nbId := "4a952a0a"
681         w, sdlInstanceMock := initSdlInstanceMock(namespace)
682         var e error
683         key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_ENB.String(), plmnId, nbId)
684         if rNibErr != nil {
685                 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
686         }
687         var ret map[string]interface{}
688         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
689         globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
690         getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
691         assert.NotNil(t, er)
692         assert.Nil(t, getNb)
693         assert.IsType(t, &common.ResourceNotFoundError{}, er)
694         assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.NodebInfo not found. Key: ENB:02f829:4a952a0a", er.Error())
695 }
696
697 func TestGetNodebByIdNotFoundFailureGnb(t *testing.T) {
698         plmnId := "02f829"
699         nbId := "4a952a0a"
700         w, sdlInstanceMock := initSdlInstanceMock(namespace)
701         var e error
702         key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_GNB.String(), plmnId, nbId)
703         if rNibErr != nil {
704                 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
705         }
706         var ret map[string]interface{}
707         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
708         globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
709         getNb, er := w.GetNodebByGlobalNbId(entities.Node_GNB, globalNbId)
710         assert.NotNil(t, er)
711         assert.Nil(t, getNb)
712         assert.IsType(t, &common.ResourceNotFoundError{}, er)
713         assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.NodebInfo not found. Key: GNB:02f829:4a952a0a", er.Error())
714 }
715
716 func TestGetNodeByIdUnmarshalFailure(t *testing.T) {
717         plmnId := "02f829"
718         nbId := "4a952a0a"
719         w, sdlInstanceMock := initSdlInstanceMock(namespace)
720         key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_ENB.String(), plmnId, nbId)
721         if rNibErr != nil {
722                 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
723         }
724         var e error
725         ret := make(map[string]interface{}, 1)
726         ret[key] = "data"
727         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
728         globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
729         getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
730         assert.NotNil(t, er)
731         assert.Nil(t, getNb)
732         assert.IsType(t, &common.InternalError{}, er)
733         assert.EqualValues(t, "proto: can't skip unknown wire type 4", er.Error())
734 }
735
736 func TestGetNodeByIdSdlgoFailure(t *testing.T) {
737         plmnId := "02f829"
738         nbId := "4a952a0a"
739         errMsg := "expected Sdlgo error"
740         errMsgExpected := "expected Sdlgo error"
741         w, sdlInstanceMock := initSdlInstanceMock(namespace)
742         key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_GNB.String(), plmnId, nbId)
743         if rNibErr != nil {
744                 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
745         }
746         e := errors.New(errMsg)
747         var ret map[string]interface{}
748         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
749         globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
750         getNb, er := w.GetNodebByGlobalNbId(entities.Node_GNB, globalNbId)
751         assert.NotNil(t, er)
752         assert.Nil(t, getNb)
753         assert.IsType(t, &common.InternalError{}, er)
754         assert.EqualValues(t, errMsgExpected, er.Error())
755 }
756
757 func TestGetCellById(t *testing.T) {
758         cellId := "aaaa"
759         var pci uint32 = 10
760         w, sdlInstanceMock := initSdlInstanceMock(namespace)
761         cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: &entities.ServedCellInfo{Pci: pci}}}
762         cellData, err := proto.Marshal(&cellEntity)
763         if err != nil {
764                 t.Errorf("#rNibReader_test.TestGetCellById - Failed to marshal Cell entity. Error: %v", err)
765         }
766         var e error
767         key, rNibErr := common.ValidateAndBuildCellIdKey(cellId)
768         if rNibErr != nil {
769                 t.Errorf("#rNibReader_test.TestGetCellById - failed to validate key parameter")
770         }
771         ret := map[string]interface{}{key: string(cellData)}
772         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
773         cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
774         assert.Nil(t, er)
775         assert.NotNil(t, cell)
776         assert.Equal(t, cell.Type, entities.Cell_LTE_CELL)
777         assert.NotNil(t, cell.GetServedCellInfo())
778         assert.Equal(t, cell.GetServedCellInfo().GetPci(), pci)
779 }
780
781 func TestGetCellByIdNotFoundFailureEnb(t *testing.T) {
782         cellId := "bbbb"
783         w, sdlInstanceMock := initSdlInstanceMock(namespace)
784         var e error
785         var ret map[string]interface{}
786         key, rNibErr := common.ValidateAndBuildCellIdKey(cellId)
787         if rNibErr != nil {
788                 t.Errorf("#rNibReader_test.TestGetCellByIdNotFoundFailure - failed to validate key parameter")
789         }
790         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
791         cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
792         assert.NotNil(t, er)
793         assert.Nil(t, cell)
794         assert.IsType(t, &common.ResourceNotFoundError{}, er)
795         assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.Cell not found. Key: CELL:bbbb", er.Error())
796 }
797
798 func TestGetCellByIdNotFoundFailureGnb(t *testing.T) {
799         cellId := "bbbb"
800         w, sdlInstanceMock := initSdlInstanceMock(namespace)
801         var e error
802         var ret map[string]interface{}
803         key, rNibErr := common.ValidateAndBuildNrCellIdKey(cellId)
804         if rNibErr != nil {
805                 t.Errorf("#rNibReader_test.TestGetCellByIdNotFoundFailure - failed to validate key parameter")
806         }
807         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
808         cell, er := w.GetCellById(entities.Cell_NR_CELL, cellId)
809         assert.NotNil(t, er)
810         assert.Nil(t, cell)
811         assert.IsType(t, &common.ResourceNotFoundError{}, er)
812         assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.Cell not found. Key: NRCELL:bbbb", er.Error())
813 }
814
815 func TestGetCellByIdTypeValidationFailure(t *testing.T) {
816         cellId := "dddd"
817         w, _ := initSdlInstanceMock(namespace)
818         cell, er := w.GetCellById(5, cellId)
819         assert.NotNil(t, er)
820         assert.Nil(t, cell)
821         assert.IsType(t, &common.ValidationError{}, er)
822         assert.EqualValues(t, "#rNibReader.GetCellById - invalid cell type: 5", er.Error())
823 }
824
825 func TestGetCellByIdValidationFailureGnb(t *testing.T) {
826         cellId := ""
827         w, _ := initSdlInstanceMock(namespace)
828         cell, er := w.GetCellById(entities.Cell_NR_CELL, cellId)
829         assert.NotNil(t, er)
830         assert.Nil(t, cell)
831         assert.IsType(t, &common.ValidationError{}, er)
832         assert.EqualValues(t, "#utils.ValidateAndBuildNrCellIdKey - an empty cell id received", er.Error())
833 }
834
835 func TestGetCellByIdValidationFailureEnb(t *testing.T) {
836         cellId := ""
837         w, _ := initSdlInstanceMock(namespace)
838         cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
839         assert.NotNil(t, er)
840         assert.Nil(t, cell)
841         assert.IsType(t, &common.ValidationError{}, er)
842         assert.EqualValues(t, "#utils.ValidateAndBuildCellIdKey - an empty cell id received", er.Error())
843 }
844
845 func TestGetRanLoadInformation(t *testing.T) {
846         name := "name"
847         w, sdlInstanceMock := initSdlInstanceMock(namespace)
848         loadInfo := generateRanLoadInformation()
849         var e error
850         data, err := proto.Marshal(loadInfo)
851         if err != nil {
852                 t.Errorf("#rNibReader_test.TestGetRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
853         }
854         redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
855         if rNibErr != nil {
856                 t.Errorf("#rNibReader_test.TestGetRanLoadInformationNotFoundFailure - failed to validate key parameter")
857         }
858         ret := map[string]interface{}{redisKey: string(data)}
859         sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
860         getLoadInfo, er := w.GetRanLoadInformation(name)
861         assert.Nil(t, er)
862         assert.NotNil(t, getLoadInfo)
863         expected, err := json.Marshal(loadInfo)
864         if err != nil {
865                 t.Errorf("#rNibReader_test.TestGetRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
866         }
867         actual, err := json.Marshal(getLoadInfo)
868         if err != nil {
869                 t.Errorf("#rNibReader_test.TestGetRanLoadInformation - Failed to marshal RanLoadInformation entity. Error: %v", err)
870         }
871         assert.EqualValues(t, expected, actual)
872 }
873
874 func TestGetRanLoadInformationValidationFailure(t *testing.T) {
875         name := ""
876         w, _ := initSdlInstanceMock(namespace)
877         getNb, er := w.GetRanLoadInformation(name)
878         assert.NotNil(t, er)
879         assert.Nil(t, getNb)
880         assert.IsType(t, &common.ValidationError{}, er)
881         assert.EqualValues(t, "#utils.ValidateAndBuildRanLoadInformationKey - an empty inventory name received", er.Error())
882 }
883
884 func TestGetRanLoadInformationNotFoundFailure(t *testing.T) {
885         name := "name"
886         w, sdlInstanceMock := initSdlInstanceMock(namespace)
887         var e error
888         var ret map[string]interface{}
889         redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
890         if rNibErr != nil {
891                 t.Errorf("#rNibReader_test.TestGetRanLoadInformationNotFoundFailure - failed to validate key parameter")
892         }
893         sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
894         getNb, er := w.GetRanLoadInformation(name)
895         assert.NotNil(t, er)
896         assert.Nil(t, getNb)
897         assert.IsType(t, &common.ResourceNotFoundError{}, er)
898         assert.EqualValues(t, "#rNibReader.getByKeyAndUnmarshal - entity of type *entities.RanLoadInformation not found. Key: LOAD:name", er.Error())
899 }
900
901 func TestGetRanLoadInformationUnmarshalFailure(t *testing.T) {
902         name := "name"
903         w, sdlInstanceMock := initSdlInstanceMock(namespace)
904         var e error
905         ret := make(map[string]interface{}, 1)
906         redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
907         if rNibErr != nil {
908                 t.Errorf("#rNibReader_test.TestGetRanLoadInformationUnmarshalFailure - failed to validate key parameter")
909         }
910         ret[redisKey] = "data"
911         sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
912         getNb, er := w.GetRanLoadInformation(name)
913         assert.NotNil(t, er)
914         assert.Nil(t, getNb)
915         assert.IsType(t, &common.InternalError{}, er)
916         assert.EqualValues(t, "proto: can't skip unknown wire type 4", er.Error())
917 }
918
919 func TestGetRanLoadInformationSdlgoFailure(t *testing.T) {
920         name := "name"
921         errMsg := "expected Sdlgo error"
922         errMsgExpected := "expected Sdlgo error"
923         w, sdlInstanceMock := initSdlInstanceMock(namespace)
924         e := errors.New(errMsg)
925         var ret map[string]interface{}
926         redisKey, rNibErr := common.ValidateAndBuildRanLoadInformationKey(name)
927         if rNibErr != nil {
928                 t.Errorf("#rNibReader_test.TestGetRanLoadInformationSdlgoFailure - failed to validate key parameter")
929         }
930         sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
931         getNb, er := w.GetRanLoadInformation(name)
932         assert.NotNil(t, er)
933         assert.Nil(t, getNb)
934         assert.IsType(t, &common.InternalError{}, er)
935         assert.EqualValues(t, errMsgExpected, er.Error())
936 }
937
938 func generateCellLoadInformation() *entities.CellLoadInformation {
939         cellLoadInformation := entities.CellLoadInformation{}
940
941         cellLoadInformation.CellId = "123"
942
943         ulInterferenceOverloadIndication := entities.UlInterferenceOverloadIndication_HIGH_INTERFERENCE
944         cellLoadInformation.UlInterferenceOverloadIndications = []entities.UlInterferenceOverloadIndication{ulInterferenceOverloadIndication}
945
946         ulHighInterferenceInformation := entities.UlHighInterferenceInformation{
947                 TargetCellId:                 "456",
948                 UlHighInterferenceIndication: "xxx",
949         }
950
951         cellLoadInformation.UlHighInterferenceInfos = []*entities.UlHighInterferenceInformation{&ulHighInterferenceInformation}
952
953         cellLoadInformation.RelativeNarrowbandTxPower = &entities.RelativeNarrowbandTxPower{
954                 RntpPerPrb:                       "xxx",
955                 RntpThreshold:                    entities.RntpThreshold_NEG_4,
956                 NumberOfCellSpecificAntennaPorts: entities.NumberOfCellSpecificAntennaPorts_V1_ANT_PRT,
957                 PB:                               1,
958                 PdcchInterferenceImpact:          2,
959                 EnhancedRntp: &entities.EnhancedRntp{
960                         EnhancedRntpBitmap:     "xxx",
961                         RntpHighPowerThreshold: entities.RntpThreshold_NEG_2,
962                         EnhancedRntpStartTime:  &entities.StartTime{StartSfn: 500, StartSubframeNumber: 5},
963                 },
964         }
965
966         cellLoadInformation.AbsInformation = &entities.AbsInformation{
967                 Mode:                             entities.AbsInformationMode_ABS_INFO_FDD,
968                 AbsPatternInfo:                   "xxx",
969                 NumberOfCellSpecificAntennaPorts: entities.NumberOfCellSpecificAntennaPorts_V2_ANT_PRT,
970                 MeasurementSubset:                "xxx",
971         }
972
973         cellLoadInformation.InvokeIndication = entities.InvokeIndication_ABS_INFORMATION
974
975         cellLoadInformation.ExtendedUlInterferenceOverloadInfo = &entities.ExtendedUlInterferenceOverloadInfo{
976                 AssociatedSubframes:                       "xxx",
977                 ExtendedUlInterferenceOverloadIndications: cellLoadInformation.UlInterferenceOverloadIndications,
978         }
979
980         compInformationItem := &entities.CompInformationItem{
981                 CompHypothesisSets: []*entities.CompHypothesisSet{{CellId: "789", CompHypothesis: "xxx"}},
982                 BenefitMetric:      50,
983         }
984
985         cellLoadInformation.CompInformation = &entities.CompInformation{
986                 CompInformationItems:     []*entities.CompInformationItem{compInformationItem},
987                 CompInformationStartTime: &entities.StartTime{StartSfn: 123, StartSubframeNumber: 456},
988         }
989
990         cellLoadInformation.DynamicDlTransmissionInformation = &entities.DynamicDlTransmissionInformation{
991                 State:             entities.NaicsState_NAICS_ACTIVE,
992                 TransmissionModes: "xxx",
993                 PB:                2,
994                 PAList:            []entities.PA{entities.PA_DB_NEG_3},
995         }
996
997         return &cellLoadInformation
998 }
999
1000 func generateRanLoadInformation() *entities.RanLoadInformation {
1001         ranLoadInformation := entities.RanLoadInformation{}
1002
1003         ranLoadInformation.LoadTimestamp = uint64(time.Now().UnixNano())
1004
1005         cellLoadInformation := generateCellLoadInformation()
1006         ranLoadInformation.CellLoadInfos = []*entities.CellLoadInformation{cellLoadInformation}
1007
1008         return &ranLoadInformation
1009 }
1010
1011 func TestGetE2TInstanceSuccess(t *testing.T) {
1012         address := "10.10.2.15:9800"
1013         redisKey, validationErr := common.ValidateAndBuildE2TInstanceKey(address)
1014
1015         if validationErr != nil {
1016                 t.Errorf("#rNibReader_test.TestGetE2TInstanceSuccess - Failed to build E2T Instance key. Error: %v", validationErr)
1017         }
1018
1019         w, sdlInstanceMock := initSdlInstanceMock(namespace)
1020
1021         e2tInstance := generateE2tInstance(address)
1022         data, err := json.Marshal(e2tInstance)
1023
1024         if err != nil {
1025                 t.Errorf("#rNibReader_test.TestGetE2TInstanceSuccess - Failed to marshal E2tInstance entity. Error: %v", err)
1026         }
1027
1028         var e error
1029         ret := map[string]interface{}{redisKey: string(data)}
1030         sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, e)
1031
1032         res, rNibErr := w.GetE2TInstance(address)
1033         assert.Nil(t, rNibErr)
1034         assert.Equal(t, e2tInstance, res)
1035 }
1036
1037 func TestGetE2TInstanceEmptyAddressFailure(t *testing.T) {
1038         w, _ := initSdlInstanceMock(namespace)
1039         res, err := w.GetE2TInstance("")
1040         assert.NotNil(t, err)
1041         assert.IsType(t, &common.ValidationError{}, err)
1042         assert.Nil(t, res)
1043 }
1044
1045 func TestGetE2TInstanceSdlError(t *testing.T) {
1046         address := "10.10.2.15:9800"
1047         redisKey, validationErr := common.ValidateAndBuildE2TInstanceKey(address)
1048
1049         if validationErr != nil {
1050                 t.Errorf("#rNibReader_test.TestGetE2TInstanceSuccess - Failed to build E2T Instance key. Error: %v", validationErr)
1051         }
1052
1053         w, sdlInstanceMock := initSdlInstanceMock(namespace)
1054
1055         expectedErr := errors.New("expected error")
1056         var ret map[string]interface{}
1057         sdlInstanceMock.On("Get", []string{redisKey}).Return(ret, expectedErr)
1058
1059         res, rNibErr := w.GetE2TInstance(address)
1060         assert.NotNil(t, rNibErr)
1061         assert.Nil(t, res)
1062 }
1063
1064 func generateE2tInstance(address string) *entities.E2TInstance {
1065         e2tInstance := entities.NewE2TInstance(address)
1066         e2tInstance.AssociatedRanList = []string{"test1", "test2"}
1067         return e2tInstance
1068 }
1069
1070 func TestGetE2TInfoListSuccess(t *testing.T) {
1071         address := "10.10.2.15:9800"
1072         w, sdlInstanceMock := initSdlInstanceMock(namespace)
1073
1074         e2tInfo := entities.NewE2TInstanceInfo(address)
1075         e2tInfoList := []*entities.E2TInstanceInfo{e2tInfo}
1076         data, err := json.Marshal(e2tInfoList)
1077
1078         if err != nil {
1079                 t.Errorf("#rNibReader_test.TestGetE2TInfoListSuccess - Failed to marshal E2TInfoList. Error: %v", err)
1080         }
1081
1082         var e error
1083         ret := map[string]interface{}{E2TInfoListKey: string(data)}
1084         sdlInstanceMock.On("Get", []string{E2TInfoListKey}).Return(ret, e)
1085
1086         res, rNibErr := w.GetE2TInfoList()
1087         assert.Nil(t, rNibErr)
1088         assert.Equal(t, e2tInfoList, res)
1089 }
1090
1091 func TestGetE2TInfoListSdlError(t *testing.T) {
1092         w, sdlInstanceMock := initSdlInstanceMock(namespace)
1093
1094         expectedErr := errors.New("expected error")
1095         var ret map[string]interface{}
1096         sdlInstanceMock.On("Get", []string{E2TInfoListKey}).Return(ret, expectedErr)
1097
1098         res, rNibErr := w.GetE2TInfoList()
1099         assert.NotNil(t, rNibErr)
1100         assert.Nil(t, res)
1101 }
1102
1103 //integration tests
1104 //
1105 //func TestGetEnbInteg(t *testing.T){
1106 //      name := "nameEnb1"
1107 //      Init("namespace", 1)
1108 //      w := GetRNibReader()
1109 //      nb, err := w.GetNodeb(name)
1110 //      if err != nil{
1111 //              fmt.Println(err)
1112 //      } else {
1113 //              fmt.Printf("#TestGetEnbInteg - responding node type: %v\n", nb)
1114 //      }
1115 //}
1116 //
1117 //func TestGetEnbCellsInteg(t *testing.T){
1118 //      name := "nameEnb1"
1119 //      Init("namespace", 1)
1120 //      w := GetRNibReader()
1121 //      cells, err := w.GetCellList(name)
1122 //      if err != nil{
1123 //              fmt.Println(err)
1124 //      } else if cells != nil{
1125 //              for _, cell := range cells.GetServedCellInfos().ServedCells{
1126 //                      fmt.Printf("responding node type Cell: %v\n", *cell)
1127 //              }
1128 //      }
1129 //}
1130 //
1131 //func TestGetGnbInteg(t *testing.T){
1132 //      name := "nameGnb1"
1133 //      Init("namespace", 1)
1134 //      w := GetRNibReader()
1135 //      nb, err := w.GetNodeb(name)
1136 //      if err != nil{
1137 //              fmt.Println(err)
1138 //      } else {
1139 //              fmt.Printf("#TestGetGnbInteg - responding node type: %v\n", nb)
1140 //      }
1141 //}
1142 //
1143 //func TestGetGnbCellsInteg(t *testing.T){
1144 //      name := "nameGnb1"
1145 //      Init("namespace", 1)
1146 //      w := GetRNibReader()
1147 //      cells, err := w.GetCellList(name)
1148 //      if err != nil{
1149 //              fmt.Println(err)
1150 //      } else if cells != nil{
1151 //              for _, cell := range cells.GetServedNrCells().ServedCells{
1152 //                      fmt.Printf("responding node type NR Cell: %v\n", *cell)
1153 //              }
1154 //      }
1155 //}
1156 //
1157 //func TestGetListEnbIdsInteg(t *testing.T) {
1158 //      Init("namespace", 1)
1159 //      w := GetRNibReader()
1160 //      ids, err := w.GetListEnbIds()
1161 //      if err != nil{
1162 //              fmt.Println(err)
1163 //      } else {
1164 //              for _, id := range ids{
1165 //                      fmt.Printf("#TestGetListEnbIdsInteg - ENB ID: %s\n", id)
1166 //              }
1167 //      }
1168 //}
1169 //
1170 //func TestGetListGnbIdsInteg(t *testing.T) {
1171 //      Init("namespace", 1)
1172 //      w := GetRNibReader()
1173 //      ids, err := w.GetListGnbIds()
1174 //      if err != nil{
1175 //              fmt.Println(err)
1176 //      } else {
1177 //              for _, id := range ids{
1178 //                      fmt.Printf("#TestGetListGnbIdsInteg - GNB ID: %s\n", id)
1179 //              }
1180 //      }
1181 //}
1182 //
1183 //func TestGetCountGnbListInteg(t *testing.T) {
1184 //      Init("namespace", 1)
1185 //      w := GetRNibReader()
1186 //      count, err := w.GetCountGnbList()
1187 //      if err != nil{
1188 //              fmt.Println(err)
1189 //      } else {
1190 //              fmt.Printf("#TestGetCountGnbListInteg - count Gnb list: %d\n", count)
1191 //      }
1192 //}
1193 //
1194 //func TestGetGnbCellInteg(t *testing.T){
1195 //      name := "nameGnb7"
1196 //      pci := 0x0a
1197 //      Init("namespace", 1)
1198 //      w := GetRNibReader()
1199 //      cell, err := w.GetCell(name, uint32(pci))
1200 //      if err != nil{
1201 //              fmt.Println(err)
1202 //      } else if cell != nil{
1203 //              fmt.Printf("responding node type NR Cell: %v\n", cell.GetServedNrCell())
1204 //      }
1205 //}
1206 //
1207 //func TestGetEnbCellInteg(t *testing.T) {
1208 //      name := "nameEnb1"
1209 //      pci := 0x22
1210 //      Init("namespace", 1)
1211 //      w := GetRNibReader()
1212 //      cell, err := w.GetCell(name, uint32(pci))
1213 //      if err != nil {
1214 //              fmt.Println(err)
1215 //      } else if cell != nil {
1216 //              fmt.Printf("responding node type LTE Cell: %v\n", cell.GetServedCellInfo())
1217 //      }
1218 //}
1219 //
1220 //func TestGetEnbCellByIdInteg(t *testing.T){
1221 //      Init("namespace", 1)
1222 //      w := GetRNibReader()
1223 //      cell, err := w.GetCellById(entities.Cell_NR_CELL, "45d")
1224 //      if err != nil{
1225 //              fmt.Println(err)
1226 //      } else if cell != nil{
1227 //              fmt.Printf("responding node type NR Cell: %v\n", cell.GetServedNrCell())
1228 //      }
1229 //}
1230 //
1231 //func TestGetListNbIdsInteg(t *testing.T) {
1232 //      Init("e2Manager", 1)
1233 //      w := GetRNibReader()
1234 //      ids, err := w.GetListNodebIds()
1235 //      if err != nil{
1236 //              fmt.Println(err)
1237 //      } else {
1238 //              for _, id := range ids{
1239 //                      fmt.Printf("#TestGetListGnbIdsInteg - NB ID: %s\n", id)
1240 //              }
1241 //      }
1242 //}
1243 //
1244 //func TestGetRanLoadInformationInteg(t *testing.T){
1245 //      Init("e2Manager", 1)
1246 //      w := GetRNibReader()
1247 //      ranLoadInformation, err := w.GetRanLoadInformation("ran_integ")
1248 //      if err != nil{
1249 //              t.Errorf("#rNibReader_test.TestGetRanLoadInformationInteg - Failed to get RanLoadInformation entity. Error: %v", err)
1250 //      }
1251 //      assert.NotNil(t, ranLoadInformation)
1252 //      fmt.Printf("#rNibReader_test.TestGetRanLoadInformationInteg - GNB ID: %s\n", ranLoadInformation)
1253 //}