35e9cb9b266a4025b815bc931e6cca4600542c94
[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 package reader
18
19 import (
20         "errors"
21         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
22         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
23         "github.com/golang/protobuf/proto"
24         "github.com/stretchr/testify/assert"
25         "testing"
26 )
27
28 var namespace = "namespace"
29
30 func TestInit(t *testing.T) {
31         readerPool = nil
32         Init("", 1)
33         assert.NotNil(t, readerPool)
34         assert.NotNil(t, readerPool.New)
35         assert.NotNil(t, readerPool.Destroy)
36         available, created := readerPool.Stats()
37         assert.Equal(t, 0, available, "number of available objects in the readerPool should be 0")
38         assert.Equal(t, 0, created, "number of created objects in the readerPool should be 0")
39 }
40
41 func TestInitPool(t *testing.T) {
42         readerPool = nil
43         sdlInstanceMock := new(MockSdlInstance)
44         initPool(1, func() interface{} {
45                 sdlI := common.ISdlInstance(sdlInstanceMock)
46                 return &rNibReaderInstance{sdl: &sdlI, namespace: namespace}
47         },
48                 func(obj interface{}) {
49                 },
50         )
51         assert.NotNil(t, readerPool)
52         assert.NotNil(t, readerPool.New)
53         assert.NotNil(t, readerPool.Destroy)
54         available, created := readerPool.Stats()
55         assert.Equal(t, 0, available, "number of available objects in the readerPool should be 0")
56         assert.Equal(t, 0, created, "number of created objects in the readerPool should be 0")
57 }
58
59 func initSdlInstanceMock(namespace string, poolSize int) *MockSdlInstance {
60         sdlInstanceMock := new(MockSdlInstance)
61         initPool(poolSize, func() interface{} {
62                 sdlI := common.ISdlInstance(sdlInstanceMock)
63                 return &rNibReaderInstance{sdl: &sdlI, namespace: namespace}
64         },
65                 func(obj interface{}) {
66                 },
67         )
68         return sdlInstanceMock
69 }
70
71 func TestGetNodeB(t *testing.T) {
72         name := "name"
73         readerPool = nil
74         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
75         w := GetRNibReader()
76         nb := entities.NodebInfo{}
77         nb.ConnectionStatus = 1
78         nb.Ip = "localhost"
79         nb.Port = 5656
80         enb := entities.Enb{}
81         cell := entities.ServedCellInfo{Tac: "tac"}
82         enb.ServedCells = []*entities.ServedCellInfo{&cell}
83         nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
84         var e error
85         data, err := proto.Marshal(&nb)
86         if err != nil {
87                 t.Errorf("#rNibReader_test.TestGetNb - Failed to marshal ENB instance. Error: %v", err)
88         }
89         ret := map[string]interface{}{"RAN:" + name: string(data)}
90         sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
91         getNb, er := w.GetNodeb(name)
92         assert.Nil(t, er)
93         assert.Equal(t, getNb.Ip, nb.Ip)
94         assert.Equal(t, getNb.Port, nb.Port)
95         assert.Equal(t, getNb.ConnectionStatus, nb.ConnectionStatus)
96         assert.Len(t, getNb.GetEnb().GetServedCells(), 1)
97         assert.Equal(t, getNb.GetEnb().GetServedCells()[0].Tac, nb.GetEnb().GetServedCells()[0].Tac)
98 }
99
100 func TestGetNodeBNotFoundFailure(t *testing.T) {
101         name := "name"
102         readerPool = nil
103         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
104         w := GetRNibReader()
105         var e error
106         var ret map[string]interface{}
107         sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
108         getNb, er := w.GetNodeb(name)
109         assert.NotNil(t, er)
110         assert.Nil(t, getNb)
111         assert.Equal(t, 1, er.GetCode())
112         assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.getNodeb - responding node not found. Key: RAN:name", er.Error())
113 }
114
115 func TestGetNodeBUnmarshalFailure(t *testing.T) {
116         name := "name"
117         readerPool = nil
118         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
119         w := GetRNibReader()
120         var e error
121         ret := make(map[string]interface{}, 1)
122         ret["RAN:"+name] = "data"
123         sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
124         getNb, er := w.GetNodeb(name)
125         assert.NotNil(t, er)
126         assert.Nil(t, getNb)
127         assert.Equal(t, 2, er.GetCode())
128         assert.EqualValues(t, "2 INTERNAL_ERROR - proto: can't skip unknown wire type 4", er.Error())
129 }
130
131 func TestGetNodeBSdlgoFailure(t *testing.T) {
132         name := "name"
133         errMsg := "expected Sdlgo error"
134         errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
135         readerPool = nil
136         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
137         w := GetRNibReader()
138         e := errors.New(errMsg)
139         var ret map[string]interface{}
140         sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
141         getNb, er := w.GetNodeb(name)
142         assert.NotNil(t, er)
143         assert.Nil(t, getNb)
144         assert.Equal(t, 2, er.GetCode())
145         assert.EqualValues(t, errMsgExpected, er.Error())
146 }
147
148 func TestGetNodeBCellsListEnb(t *testing.T) {
149         name := "name"
150         readerPool = nil
151         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
152         w := GetRNibReader()
153         nb := entities.NodebInfo{}
154         nb.ConnectionStatus = 1
155         nb.Ip = "localhost"
156         nb.Port = 5656
157         enb := entities.Enb{}
158         cell := entities.ServedCellInfo{Tac: "tac"}
159         enb.ServedCells = []*entities.ServedCellInfo{&cell}
160         nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
161         var e error
162         data, err := proto.Marshal(&nb)
163         if err != nil {
164                 t.Errorf("#rNibReader_test.GetNodeBCellsList - Failed to marshal ENB instance. Error: %v", err)
165         }
166         ret := map[string]interface{}{"RAN:" + name: string(data)}
167         sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
168         cells, er := w.GetCellList(name)
169         assert.Nil(t, er)
170         assert.NotNil(t, cells)
171         assert.Len(t, cells.GetServedCellInfos().GetServedCells(), 1)
172         retCell := cells.GetServedCellInfos().GetServedCells()[0]
173         assert.Equal(t, retCell.Tac, "tac")
174 }
175
176 func TestGetNodeBCellsListGnb(t *testing.T) {
177         name := "name"
178         readerPool = nil
179         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
180         w := GetRNibReader()
181         nb := entities.NodebInfo{}
182         nb.ConnectionStatus = 1
183         nb.Ip = "localhost"
184         nb.Port = 5656
185         nb.NodeType = entities.Node_GNB
186         gnb := entities.Gnb{}
187         cell := entities.ServedNRCell{ServedNrCellInformation: &entities.ServedNRCellInformation{NrPci: 10}}
188         gnb.ServedNrCells = []*entities.ServedNRCell{&cell}
189         nb.Configuration = &entities.NodebInfo_Gnb{Gnb: &gnb}
190         var e error
191         data, err := proto.Marshal(&nb)
192         if err != nil {
193                 t.Errorf("#rNibReader_test.GetNodeBCellsList - Failed to marshal GNB instance. Error: %v", err)
194         }
195         ret := map[string]interface{}{"RAN:" + name: string(data)}
196         sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
197         cells, er := w.GetCellList(name)
198         assert.Nil(t, er)
199         assert.NotNil(t, cells)
200         assert.Len(t, cells.GetServedNrCells().GetServedCells(), 1)
201         retCell := cells.GetServedNrCells().GetServedCells()[0]
202         assert.Equal(t, retCell.GetServedNrCellInformation().GetNrPci(), uint32(10))
203 }
204
205 func TestGetNodeBCellsListNodeUnmarshalFailure(t *testing.T) {
206         name := "name"
207         readerPool = nil
208         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
209         w := GetRNibReader()
210         var e error
211         ret := make(map[string]interface{}, 1)
212         ret["RAN:"+name] = "data"
213         sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
214         cells, er := w.GetCellList(name)
215         assert.NotNil(t, er)
216         assert.Nil(t, cells)
217         assert.Equal(t, 2, er.GetCode())
218         assert.EqualValues(t, "2 INTERNAL_ERROR - proto: can't skip unknown wire type 4", er.Error())
219 }
220
221 func TestGetNodeBCellsListNodeNotFoundFailure(t *testing.T) {
222         name := "name"
223         readerPool = nil
224         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
225         w := GetRNibReader()
226         var e error
227         var ret map[string]interface{}
228         sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
229         cells, er := w.GetCellList(name)
230         assert.NotNil(t, er)
231         assert.Nil(t, cells)
232         assert.Equal(t, 1, er.GetCode())
233         assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.getNodeb - responding node not found. Key: RAN:name", er.Error())
234 }
235
236 func TestGetNodeBCellsListNotFoundFailureEnb(t *testing.T) {
237         name := "name"
238         readerPool = nil
239         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
240         w := GetRNibReader()
241         nb := entities.NodebInfo{}
242         nb.ConnectionStatus = 1
243         nb.Ip = "localhost"
244         nb.Port = 5656
245         enb := entities.Enb{}
246         nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
247         var e error
248         data, err := proto.Marshal(&nb)
249         if err != nil {
250                 t.Errorf("#rNibReader_test.TestGetNbCellsListNotFoundFailure - Failed to marshal ENB instance. Error: %v", err)
251         }
252         ret := map[string]interface{}{"RAN:" + name: string(data)}
253         sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
254         _, er := w.GetCellList(name)
255         assert.NotNil(t, er)
256         assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.GetCellList - served cells not found. Responding node RAN name: name.", er.Error())
257 }
258
259 func TestGetNodeBCellsListNotFoundFailureGnb(t *testing.T) {
260         name := "name"
261         readerPool = nil
262         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
263         w := GetRNibReader()
264         nb := entities.NodebInfo{}
265         nb.ConnectionStatus = 1
266         nb.Ip = "localhost"
267         nb.Port = 5656
268         gnb := entities.Gnb{}
269         nb.Configuration = &entities.NodebInfo_Gnb{Gnb: &gnb}
270         var e error
271         data, err := proto.Marshal(&nb)
272         if err != nil {
273                 t.Errorf("#rNibReader_test.TestGetNbCellsListNotFoundFailure - Failed to marshal ENB instance. Error: %v", err)
274         }
275         ret := map[string]interface{}{"RAN:" + name: string(data)}
276         sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
277         _, er := w.GetCellList(name)
278         assert.NotNil(t, er)
279         assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.GetCellList - served cells not found. Responding node RAN name: name.", er.Error())
280 }
281
282 func TestCloseOnClosedPoolFailure(t *testing.T) {
283         readerPool = nil
284         instanceMock := initSdlInstanceMock(namespace, 1)
285         w1 := GetRNibReader()
286         readerPool.Put(w1)
287         available, created := readerPool.Stats()
288         assert.Equal(t, 1, available, "number of available objects in the readerPool should be 1")
289         assert.Equal(t, 1, created, "number of created objects in the readerPool should be 1")
290         var e error
291         instanceMock.On("Close").Return(e)
292         Close()
293         assert.Panics(t, func() { Close() })
294 }
295
296 func TestCloseFailure(t *testing.T) {
297         readerPool = nil
298         instanceMock := initSdlInstanceMock(namespace, 2)
299         w1 := GetRNibReader()
300         readerPool.Put(w1)
301         available, created := readerPool.Stats()
302         assert.Equal(t, 1, available, "number of available objects in the readerPool should be 1")
303         assert.Equal(t, 1, created, "number of created objects in the readerPool should be 1")
304         e := errors.New("expected error")
305         instanceMock.On("Close").Return(e)
306         Close()
307         available, created = readerPool.Stats()
308         assert.Equal(t, 0, available, "number of available objects in the readerPool should be 0")
309         assert.Equal(t, 0, created, "number of created objects in the readerPool should be 0")
310 }
311
312 func TestGetListGnbIdsUnmarshalFailure(t *testing.T) {
313         readerPool = nil
314         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
315         w := GetRNibReader()
316         var e error
317         sdlInstanceMock.On("GetMembers", GnbType).Return([]string{"data"}, e)
318         ids, er := w.GetListGnbIds()
319         assert.NotNil(t, er)
320         assert.Nil(t, ids)
321         assert.Equal(t, 2, er.GetCode())
322         assert.Equal(t, "2 INTERNAL_ERROR - proto: can't skip unknown wire type 4", er.Error())
323 }
324
325 func TestGetListGnbIdsSdlgoFailure(t *testing.T) {
326         errMsg := "expected Sdlgo error"
327         errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
328         readerPool = nil
329         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
330         w := GetRNibReader()
331         e := errors.New(errMsg)
332         var data []string
333         sdlInstanceMock.On("GetMembers", GnbType).Return(data, e)
334         ids, er := w.GetListGnbIds()
335         assert.NotNil(t, er)
336         assert.Nil(t, ids)
337         assert.Equal(t, 2, er.GetCode())
338         assert.EqualValues(t, errMsgExpected, er.Error())
339 }
340
341 func TestGetListNodesIdsGnbSdlgoFailure(t *testing.T) {
342
343         readerPool = nil
344         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
345         w := GetRNibReader()
346
347         name := "name"
348         plmnId := "02f829"
349         nbId := "4a952a0a"
350         nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
351         var nilError error
352         data, err := proto.Marshal(nbIdentity)
353         if err != nil {
354                 t.Errorf("#rNibReader_test.TestGetListNodesIdsGnbSdlgoFailure - Failed to marshal nodeb identity entity. Error: %v", err)
355         }
356         sdlInstanceMock.On("GetMembers", EnbType).Return([]string{string(data)}, nilError)
357
358         errMsg := "expected Sdlgo error"
359         errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
360         expectedError := errors.New(errMsg)
361         var nilData []string
362         sdlInstanceMock.On("GetMembers", GnbType).Return(nilData, expectedError)
363
364         ids, er := w.GetListNodebIds()
365         assert.NotNil(t, er)
366         assert.Nil(t, ids)
367         assert.Equal(t, 2, er.GetCode())
368         assert.EqualValues(t, errMsgExpected, er.Error())
369 }
370
371 func TestGetListNodesIdsEnbSdlgoFailure(t *testing.T) {
372
373         readerPool = nil
374         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
375         w := GetRNibReader()
376
377         name := "name"
378         plmnId := "02f829"
379         nbId := "4a952a0a"
380         nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
381         var nilError error
382         data, err := proto.Marshal(nbIdentity)
383         if err != nil {
384                 t.Errorf("#rNibReader_test.TestGetListNodesIdsEnbSdlgoFailure - Failed to marshal nodeb identity entity. Error: %v", err)
385         }
386         sdlInstanceMock.On("GetMembers", GnbType).Return([]string{string(data)}, nilError)
387
388         errMsg := "expected Sdlgo error"
389         errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
390         expectedError := errors.New(errMsg)
391         var nilData []string
392         sdlInstanceMock.On("GetMembers", EnbType).Return(nilData, expectedError)
393
394         ids, er := w.GetListNodebIds()
395         assert.NotNil(t, er)
396         assert.Nil(t, ids)
397         assert.Equal(t, 2, er.GetCode())
398         assert.EqualValues(t, errMsgExpected, er.Error())
399 }
400
401 func TestGetListNodesIdsEnbSdlgoSuccess(t *testing.T) {
402
403         readerPool = nil
404         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
405         w := GetRNibReader()
406
407         name := "name"
408         plmnId := "02f829"
409         nbId := "4a952a0a"
410         nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
411         var nilError error
412         data, err := proto.Marshal(nbIdentity)
413         if err != nil {
414                 t.Errorf("#rNibReader_test.TestGetListNodesIdsEnbSdlgoFailure - Failed to marshal nodeb identity entity. Error: %v", err)
415         }
416         sdlInstanceMock.On("GetMembers", GnbType).Return([]string{string(data)}, nilError)
417         sdlInstanceMock.On("GetMembers", EnbType).Return([]string{string(data)}, nilError)
418
419         ids, er := w.GetListNodebIds()
420         assert.Nil(t, er)
421         assert.NotNil(t, ids)
422         assert.Len(t, ids, 2)
423 }
424
425 func TestGetListEnbIdsUnmarshalFailure(t *testing.T) {
426         readerPool = nil
427         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
428         w := GetRNibReader()
429         var e error
430         sdlInstanceMock.On("GetMembers", EnbType).Return([]string{"data"}, e)
431         ids, er := w.GetListEnbIds()
432         assert.NotNil(t, er)
433         assert.Nil(t, ids)
434         assert.Equal(t, 2, er.GetCode())
435         assert.Equal(t, "2 INTERNAL_ERROR - proto: can't skip unknown wire type 4", er.Error())
436 }
437
438 func TestGetListEnbIdsOneId(t *testing.T) {
439         name := "name"
440         plmnId := "02f829"
441         nbId := "4a952a0a"
442         readerPool = nil
443         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
444         w := GetRNibReader()
445         nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
446         var e error
447         data, err := proto.Marshal(nbIdentity)
448         if err != nil {
449                 t.Errorf("#rNibReader_test.TestGetListEnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
450         }
451         sdlInstanceMock.On("GetMembers", EnbType).Return([]string{string(data)}, e)
452         ids, er := w.GetListEnbIds()
453         assert.Nil(t, er)
454         assert.Len(t, *ids, 1)
455         assert.Equal(t, (*ids)[0].GetInventoryName(), name)
456         assert.Equal(t, (*ids)[0].GetGlobalNbId().GetPlmnId(), nbIdentity.GetGlobalNbId().GetPlmnId())
457         assert.Equal(t, (*ids)[0].GetGlobalNbId().GetNbId(), nbIdentity.GetGlobalNbId().GetNbId())
458 }
459
460 func TestGetListEnbIdsNoIds(t *testing.T) {
461         readerPool = nil
462         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
463         w := GetRNibReader()
464         var e error
465         sdlInstanceMock.On("GetMembers", EnbType).Return([]string{}, e)
466         ids, er := w.GetListEnbIds()
467         assert.Nil(t, er)
468         assert.Len(t, *ids, 0)
469 }
470
471 func TestGetListEnbIds(t *testing.T) {
472         name := "name"
473         plmnId := 0x02f829
474         nbId := 0x4a952a0a
475         listSize := 3
476         readerPool = nil
477         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
478         w := GetRNibReader()
479         idsData := make([]string, listSize)
480         idsEntities := make([]*entities.NbIdentity, listSize)
481         for i := 0; i < listSize; i++ {
482                 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: string(plmnId + i), NbId: string(nbId + i)}}
483                 data, err := proto.Marshal(nbIdentity)
484                 if err != nil {
485                         t.Errorf("#rNibReader_test.TestGetListEnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
486                 }
487                 idsData[i] = string(data)
488                 idsEntities[i] = nbIdentity
489         }
490         var e error
491         sdlInstanceMock.On("GetMembers", EnbType).Return(idsData, e)
492         ids, er := w.GetListEnbIds()
493         assert.Nil(t, er)
494         assert.Len(t, *ids, listSize)
495         for i, id := range *ids {
496                 assert.Equal(t, id.GetInventoryName(), name)
497                 assert.Equal(t, id.GetGlobalNbId().GetPlmnId(), idsEntities[i].GetGlobalNbId().GetPlmnId())
498                 assert.Equal(t, id.GetGlobalNbId().GetNbId(), idsEntities[i].GetGlobalNbId().GetNbId())
499         }
500 }
501
502 func TestGetListGnbIdsOneId(t *testing.T) {
503         name := "name"
504         plmnId := "02f829"
505         nbId := "4a952a0a"
506         readerPool = nil
507         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
508         w := GetRNibReader()
509         nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}}
510         var e error
511         data, err := proto.Marshal(nbIdentity)
512         if err != nil {
513                 t.Errorf("#rNibReader_test.TestGetListGnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
514         }
515         sdlInstanceMock.On("GetMembers", GnbType).Return([]string{string(data)}, e)
516         ids, er := w.GetListGnbIds()
517         assert.Nil(t, er)
518         assert.Len(t, *ids, 1)
519         assert.Equal(t, (*ids)[0].GetInventoryName(), name)
520         assert.Equal(t, (*ids)[0].GetGlobalNbId().GetPlmnId(), nbIdentity.GetGlobalNbId().GetPlmnId())
521         assert.Equal(t, (*ids)[0].GetGlobalNbId().GetNbId(), nbIdentity.GetGlobalNbId().GetNbId())
522 }
523
524 func TestGetListGnbIdsNoIds(t *testing.T) {
525         readerPool = nil
526         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
527         w := GetRNibReader()
528         var e error
529         sdlInstanceMock.On("GetMembers", GnbType).Return([]string{}, e)
530         ids, er := w.GetListGnbIds()
531         assert.Nil(t, er)
532         assert.Len(t, *ids, 0)
533 }
534
535 func TestGetListGnbIds(t *testing.T) {
536         name := "name"
537         plmnId := 0x02f829
538         nbId := 0x4a952a0a
539         listSize := 3
540         readerPool = nil
541         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
542         w := GetRNibReader()
543         idsData := make([]string, listSize)
544         idsEntities := make([]*entities.NbIdentity, listSize)
545         for i := 0; i < listSize; i++ {
546                 nbIdentity := &entities.NbIdentity{InventoryName: name, GlobalNbId: &entities.GlobalNbId{PlmnId: string(plmnId + i), NbId: string(nbId + i)}}
547                 data, err := proto.Marshal(nbIdentity)
548                 if err != nil {
549                         t.Errorf("#rNibReader_test.TestGetListGnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
550                 }
551                 idsData[i] = string(data)
552                 idsEntities[i] = nbIdentity
553         }
554         var e error
555         sdlInstanceMock.On("GetMembers", GnbType).Return(idsData, e)
556         ids, er := w.GetListGnbIds()
557         assert.Nil(t, er)
558         assert.Len(t, *ids, listSize)
559         for i, id := range *ids {
560                 assert.Equal(t, id.GetInventoryName(), name)
561                 assert.Equal(t, id.GetGlobalNbId().GetPlmnId(), idsEntities[i].GetGlobalNbId().GetPlmnId())
562                 assert.Equal(t, id.GetGlobalNbId().GetNbId(), idsEntities[i].GetGlobalNbId().GetNbId())
563         }
564 }
565
566 func TestGetListEnbIdsSdlgoFailure(t *testing.T) {
567         errMsg := "expected Sdlgo error"
568         errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
569         readerPool = nil
570         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
571         w := GetRNibReader()
572         e := errors.New(errMsg)
573         var data []string
574         sdlInstanceMock.On("GetMembers", EnbType).Return(data, e)
575         ids, er := w.GetListEnbIds()
576         assert.NotNil(t, er)
577         assert.Nil(t, ids)
578         assert.Equal(t, 2, er.GetCode())
579         assert.EqualValues(t, errMsgExpected, er.Error())
580 }
581
582 func TestGetCountGnbListOneId(t *testing.T) {
583         readerPool = nil
584         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
585         w := GetRNibReader()
586         var e error
587         sdlInstanceMock.On("GroupSize", GnbType).Return(1, e)
588         count, er := w.GetCountGnbList()
589         assert.Nil(t, er)
590         assert.Equal(t, count, 1)
591 }
592
593 func TestGetCountGnbList(t *testing.T) {
594         readerPool = nil
595         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
596         w := GetRNibReader()
597         var e error
598         sdlInstanceMock.On("GroupSize", GnbType).Return(3, e)
599         count, er := w.GetCountGnbList()
600         assert.Nil(t, er)
601         assert.Equal(t, count, 3)
602 }
603
604 func TestGetCountGnbListSdlgoFailure(t *testing.T) {
605         errMsg := "expected Sdlgo error"
606         errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
607         readerPool = nil
608         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
609         w := GetRNibReader()
610         e := errors.New(errMsg)
611         var count int
612         sdlInstanceMock.On("GroupSize", GnbType).Return(count, e)
613         count, er := w.GetCountGnbList()
614         assert.NotNil(t, er)
615         assert.Equal(t, 0, count)
616         assert.Equal(t, 2, er.GetCode())
617         assert.EqualValues(t, errMsgExpected, er.Error())
618 }
619
620 func TestGetCell(t *testing.T) {
621         name := "name"
622         var pci uint32 = 10
623         readerPool = nil
624         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
625         w := GetRNibReader()
626         cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: &entities.ServedCellInfo{Pci: pci}}}
627         cellData, err := proto.Marshal(&cellEntity)
628         if err != nil {
629                 t.Errorf("#rNibReader_test.TestGetCell - Failed to marshal Cell entity. Error: %v", err)
630         }
631         var e error
632         key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
633         if rNibErr != nil {
634                 t.Errorf("#rNibReader_test.TestGetCell - failed to validate key parameter")
635         }
636         ret := map[string]interface{}{key: string(cellData)}
637         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
638         cell, er := w.GetCell(name, pci)
639         assert.Nil(t, er)
640         assert.NotNil(t, cell)
641         assert.Equal(t, cell.Type, entities.Cell_LTE_CELL)
642         assert.NotNil(t, cell.GetServedCellInfo())
643         assert.Equal(t, cell.GetServedCellInfo().GetPci(), pci)
644 }
645
646 func TestGetCellNotFoundFailure(t *testing.T) {
647         name := "name"
648         var pci uint32
649         readerPool = nil
650         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
651         w := GetRNibReader()
652         var e error
653         var ret map[string]interface{}
654         key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
655         if rNibErr != nil {
656                 t.Errorf("#rNibReader_test.TestGetCellNotFoundFailure - failed to validate key parameter")
657         }
658         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
659         cell, er := w.GetCell(name, pci)
660         assert.NotNil(t, er)
661         assert.Nil(t, cell)
662         assert.Equal(t, 1, er.GetCode())
663         assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.getCellByKey - cell not found, key: PCI:name:00", er.Error())
664 }
665
666 func TestGetCellUnmarshalFailure(t *testing.T) {
667         name := "name"
668         var pci uint32
669         readerPool = nil
670         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
671         w := GetRNibReader()
672         var e error
673         ret := make(map[string]interface{}, 1)
674         key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
675         if rNibErr != nil {
676                 t.Errorf("#rNibReader_test.TestGetCellUnmarshalFailure - failed to validate key parameter")
677         }
678         ret[key] = "data"
679         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
680         cell, er := w.GetCell(name, pci)
681         assert.NotNil(t, er)
682         assert.Nil(t, cell)
683         assert.Equal(t, 2, er.GetCode())
684         assert.EqualValues(t, "2 INTERNAL_ERROR - proto: can't skip unknown wire type 4", er.Error())
685 }
686
687 func TestGetCellSdlgoFailure(t *testing.T) {
688         name := "name"
689         var pci uint32
690         errMsg := "expected Sdlgo error"
691         errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
692         readerPool = nil
693         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
694         w := GetRNibReader()
695         e := errors.New(errMsg)
696         var ret map[string]interface{}
697         key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
698         if rNibErr != nil {
699                 t.Errorf("#rNibReader_test.TestGetCellSdlgoFailure - failed to validate key parameter")
700         }
701         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
702         cell, er := w.GetCell(name, pci)
703         assert.NotNil(t, er)
704         assert.Nil(t, cell)
705         assert.Equal(t, 2, er.GetCode())
706         assert.EqualValues(t, errMsgExpected, er.Error())
707 }
708
709 func TestGetNodebById(t *testing.T) {
710         readerPool = nil
711         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
712         w := GetRNibReader()
713         nb := entities.NodebInfo{NodeType: entities.Node_ENB}
714         nb.ConnectionStatus = 1
715         nb.Ip = "localhost"
716         nb.Port = 5656
717         enb := entities.Enb{}
718         cell := entities.ServedCellInfo{Tac: "tac"}
719         enb.ServedCells = []*entities.ServedCellInfo{&cell}
720         nb.Configuration = &entities.NodebInfo_Enb{Enb: &enb}
721         var e error
722         data, err := proto.Marshal(&nb)
723         if err != nil {
724                 t.Errorf("#rNibReader_test.TestGetNodebById - Failed to marshal ENB instance. Error: %v", err)
725         }
726
727         plmnId := "02f829"
728         nbId := "4a952a0a"
729         key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_ENB.String(), plmnId, nbId)
730         if rNibErr != nil {
731                 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
732         }
733         ret := map[string]interface{}{key: string(data)}
734         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
735         globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
736         getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
737         assert.Nil(t, er)
738         assert.Equal(t, getNb.Ip, nb.Ip)
739         assert.Equal(t, getNb.Port, nb.Port)
740         assert.Equal(t, getNb.ConnectionStatus, nb.ConnectionStatus)
741         assert.Len(t, getNb.GetEnb().GetServedCells(), 1)
742         assert.Equal(t, getNb.GetEnb().GetServedCells()[0].Tac, nb.GetEnb().GetServedCells()[0].Tac)
743 }
744
745 func TestGetNodebByIdNotFoundFailureEnb(t *testing.T) {
746         plmnId := "02f829"
747         nbId := "4a952a0a"
748         readerPool = nil
749         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
750         w := GetRNibReader()
751         var e error
752         key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_ENB.String(), plmnId, nbId)
753         if rNibErr != nil {
754                 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
755         }
756         var ret map[string]interface{}
757         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
758         globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
759         getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
760         assert.NotNil(t, er)
761         assert.Nil(t, getNb)
762         assert.Equal(t, 1, er.GetCode())
763         assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.getNodeb - responding node not found. Key: ENB:02f829:4a952a0a", er.Error())
764 }
765
766 func TestGetNodebByIdNotFoundFailureGnb(t *testing.T) {
767         plmnId := "02f829"
768         nbId := "4a952a0a"
769         readerPool = nil
770         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
771         w := GetRNibReader()
772         var e error
773         key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_GNB.String(), plmnId, nbId)
774         if rNibErr != nil {
775                 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
776         }
777         var ret map[string]interface{}
778         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
779         globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
780         getNb, er := w.GetNodebByGlobalNbId(entities.Node_GNB, globalNbId)
781         assert.NotNil(t, er)
782         assert.Nil(t, getNb)
783         assert.Equal(t, 1, er.GetCode())
784         assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.getNodeb - responding node not found. Key: GNB:02f829:4a952a0a", er.Error())
785 }
786
787 func TestGetNodeByIdUnmarshalFailure(t *testing.T) {
788         plmnId := "02f829"
789         nbId := "4a952a0a"
790         readerPool = nil
791         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
792         w := GetRNibReader()
793         key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_ENB.String(), plmnId, nbId)
794         if rNibErr != nil {
795                 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
796         }
797         var e error
798         ret := make(map[string]interface{}, 1)
799         ret[key] = "data"
800         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
801         globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
802         getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
803         assert.NotNil(t, er)
804         assert.Nil(t, getNb)
805         assert.Equal(t, 2, er.GetCode())
806         assert.EqualValues(t, "2 INTERNAL_ERROR - proto: can't skip unknown wire type 4", er.Error())
807 }
808
809 func TestGetNodeByIdSdlgoFailure(t *testing.T) {
810         plmnId := "02f829"
811         nbId := "4a952a0a"
812         errMsg := "expected Sdlgo error"
813         errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
814         readerPool = nil
815         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
816         w := GetRNibReader()
817         key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_GNB.String(), plmnId, nbId)
818         if rNibErr != nil {
819                 t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
820         }
821         e := errors.New(errMsg)
822         var ret map[string]interface{}
823         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
824         globalNbId := &entities.GlobalNbId{PlmnId: plmnId, NbId: nbId}
825         getNb, er := w.GetNodebByGlobalNbId(entities.Node_GNB, globalNbId)
826         assert.NotNil(t, er)
827         assert.Nil(t, getNb)
828         assert.Equal(t, 2, er.GetCode())
829         assert.EqualValues(t, errMsgExpected, er.Error())
830 }
831
832 func TestGetCellById(t *testing.T) {
833         cellId := "aaaa"
834         var pci uint32 = 10
835         readerPool = nil
836         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
837         w := GetRNibReader()
838         cellEntity := entities.Cell{Type: entities.Cell_LTE_CELL, Cell: &entities.Cell_ServedCellInfo{ServedCellInfo: &entities.ServedCellInfo{Pci: pci}}}
839         cellData, err := proto.Marshal(&cellEntity)
840         if err != nil {
841                 t.Errorf("#rNibReader_test.TestGetCellById - Failed to marshal Cell entity. Error: %v", err)
842         }
843         var e error
844         key, rNibErr := common.ValidateAndBuildCellIdKey(cellId)
845         if rNibErr != nil {
846                 t.Errorf("#rNibReader_test.TestGetCellById - failed to validate key parameter")
847         }
848         ret := map[string]interface{}{key: string(cellData)}
849         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
850         cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
851         assert.Nil(t, er)
852         assert.NotNil(t, cell)
853         assert.Equal(t, cell.Type, entities.Cell_LTE_CELL)
854         assert.NotNil(t, cell.GetServedCellInfo())
855         assert.Equal(t, cell.GetServedCellInfo().GetPci(), pci)
856 }
857
858 func TestGetCellByIdNotFoundFailureEnb(t *testing.T) {
859         cellId := "bbbb"
860         readerPool = nil
861         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
862         w := GetRNibReader()
863         var e error
864         var ret map[string]interface{}
865         key, rNibErr := common.ValidateAndBuildCellIdKey(cellId)
866         if rNibErr != nil {
867                 t.Errorf("#rNibReader_test.TestGetCellByIdNotFoundFailure - failed to validate key parameter")
868         }
869         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
870         cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
871         assert.NotNil(t, er)
872         assert.Nil(t, cell)
873         assert.Equal(t, 1, er.GetCode())
874         assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.getCellByKey - cell not found, key: CELL:bbbb", er.Error())
875 }
876
877 func TestGetCellByIdNotFoundFailureGnb(t *testing.T) {
878         cellId := "bbbb"
879         readerPool = nil
880         sdlInstanceMock := initSdlInstanceMock(namespace, 1)
881         w := GetRNibReader()
882         var e error
883         var ret map[string]interface{}
884         key, rNibErr := common.ValidateAndBuildNrCellIdKey(cellId)
885         if rNibErr != nil {
886                 t.Errorf("#rNibReader_test.TestGetCellByIdNotFoundFailure - failed to validate key parameter")
887         }
888         sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
889         cell, er := w.GetCellById(entities.Cell_NR_CELL, cellId)
890         assert.NotNil(t, er)
891         assert.Nil(t, cell)
892         assert.Equal(t, 1, er.GetCode())
893         assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.getCellByKey - cell not found, key: NRCELL:bbbb", er.Error())
894 }
895
896 func TestGetCellByIdTypeValidationFailure(t *testing.T) {
897         cellId := "dddd"
898         readerPool = nil
899         initSdlInstanceMock(namespace, 1)
900         w := GetRNibReader()
901         cell, er := w.GetCellById(5, cellId)
902         assert.NotNil(t, er)
903         assert.Nil(t, cell)
904         assert.Equal(t, 3, er.GetCode())
905         assert.EqualValues(t, "3 VALIDATION_ERROR - #rNibReader.GetCellById - invalid cell type: 5", er.Error())
906 }
907
908 func TestGetCellByIdValidationFailureGnb(t *testing.T) {
909         cellId := ""
910         readerPool = nil
911         initSdlInstanceMock(namespace, 1)
912         w := GetRNibReader()
913         cell, er := w.GetCellById(entities.Cell_NR_CELL, cellId)
914         assert.NotNil(t, er)
915         assert.Nil(t, cell)
916         assert.Equal(t, 3, er.GetCode())
917         assert.EqualValues(t, "3 VALIDATION_ERROR - #utils.ValidateAndBuildNrCellIdKey - an empty cell id received", er.Error())
918 }
919
920 func TestGetCellByIdValidationFailureEnb(t *testing.T) {
921         cellId := ""
922         readerPool = nil
923         initSdlInstanceMock(namespace, 1)
924         w := GetRNibReader()
925         cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
926         assert.NotNil(t, er)
927         assert.Nil(t, cell)
928         assert.Equal(t, 3, er.GetCode())
929         assert.EqualValues(t, "3 VALIDATION_ERROR - #utils.ValidateAndBuildCellIdKey - an empty cell id received", er.Error())
930 }
931
932 //integration tests
933
934 //func TestGetEnbInteg(t *testing.T){
935 //      name := "nameEnb1"
936 //      Init("namespace", 1)
937 //      w := GetRNibReader()
938 //      nb, err := w.GetNodeb(name)
939 //      if err != nil{
940 //              fmt.Println(err)
941 //      } else {
942 //              fmt.Printf("#TestGetEnbInteg - responding node type: %v\n", nb)
943 //      }
944 //}
945 //
946 //func TestGetEnbCellsInteg(t *testing.T){
947 //      name := "nameEnb1"
948 //      Init("namespace", 1)
949 //      w := GetRNibReader()
950 //      cells, err := w.GetCellList(name)
951 //      if err != nil{
952 //              fmt.Println(err)
953 //      } else if cells != nil{
954 //              for _, cell := range cells.GetServedCellInfos().ServedCells{
955 //                      fmt.Printf("responding node type Cell: %v\n", *cell)
956 //              }
957 //      }
958 //}
959 //
960 //func TestGetGnbInteg(t *testing.T){
961 //      name := "nameGnb1"
962 //      Init("namespace", 1)
963 //      w := GetRNibReader()
964 //      nb, err := w.GetNodeb(name)
965 //      if err != nil{
966 //              fmt.Println(err)
967 //      } else {
968 //              fmt.Printf("#TestGetGnbInteg - responding node type: %v\n", nb)
969 //      }
970 //}
971 //
972 //func TestGetGnbCellsInteg(t *testing.T){
973 //      name := "nameGnb1"
974 //      Init("namespace", 1)
975 //      w := GetRNibReader()
976 //      cells, err := w.GetCellList(name)
977 //      if err != nil{
978 //              fmt.Println(err)
979 //      } else if cells != nil{
980 //              for _, cell := range cells.GetServedNrCells().ServedCells{
981 //                      fmt.Printf("responding node type NR Cell: %v\n", *cell)
982 //              }
983 //      }
984 //}
985 //
986 //func TestGetListEnbIdsInteg(t *testing.T) {
987 //      Init("namespace", 1)
988 //      w := GetRNibReader()
989 //      ids, err := w.GetListEnbIds()
990 //      if err != nil{
991 //              fmt.Println(err)
992 //      } else {
993 //              for _, id := range *ids{
994 //                      fmt.Printf("#TestGetListEnbIdsInteg - ENB ID: %s\n", id)
995 //              }
996 //      }
997 //}
998 //
999 //func TestGetListGnbIdsInteg(t *testing.T) {
1000 //      Init("namespace", 1)
1001 //      w := GetRNibReader()
1002 //      ids, err := w.GetListGnbIds()
1003 //      if err != nil{
1004 //              fmt.Println(err)
1005 //      } else {
1006 //              for _, id := range *ids{
1007 //                      fmt.Printf("#TestGetListGnbIdsInteg - GNB ID: %s\n", id)
1008 //              }
1009 //      }
1010 //}
1011 //
1012 //func TestGetCountGnbListInteg(t *testing.T) {
1013 //      Init("namespace", 1)
1014 //      w := GetRNibReader()
1015 //      count, err := w.GetCountGnbList()
1016 //      if err != nil{
1017 //              fmt.Println(err)
1018 //      } else {
1019 //              fmt.Printf("#TestGetCountGnbListInteg - count Gnb list: %d\n", count)
1020 //      }
1021 //}
1022 //
1023 //func TestGetGnbCellInteg(t *testing.T){
1024 //      name := "nameGnb7"
1025 //      pci := 0x0a
1026 //      Init("namespace", 1)
1027 //      w := GetRNibReader()
1028 //      cell, err := w.GetCell(name, uint32(pci))
1029 //      if err != nil{
1030 //              fmt.Println(err)
1031 //      } else if cell != nil{
1032 //              fmt.Printf("responding node type NR Cell: %v\n", cell.GetServedNrCell())
1033 //      }
1034 //}
1035 //
1036 //func TestGetEnbCellInteg(t *testing.T) {
1037 //      name := "nameEnb1"
1038 //      pci := 0x22
1039 //      Init("namespace", 1)
1040 //      w := GetRNibReader()
1041 //      cell, err := w.GetCell(name, uint32(pci))
1042 //      if err != nil {
1043 //              fmt.Println(err)
1044 //      } else if cell != nil {
1045 //              fmt.Printf("responding node type LTE Cell: %v\n", cell.GetServedCellInfo())
1046 //      }
1047 //}
1048 //
1049 //func TestGetEnbCellByIdInteg(t *testing.T){
1050 //      Init("namespace", 1)
1051 //      w := GetRNibReader()
1052 //      cell, err := w.GetCellById(entities.Cell_NR_CELL, "45d")
1053 //      if err != nil{
1054 //              fmt.Println(err)
1055 //      } else if cell != nil{
1056 //              fmt.Printf("responding node type NR Cell: %v\n", cell.GetServedNrCell())
1057 //      }
1058 //}