2 // Copyright 2019 AT&T Intellectual Property
3 // Copyright 2019 Nokia
5 // Licensed under the Apache License, Version 2.0 (the "License");
6 // you may not use this file except in compliance with the License.
7 // You may obtain a copy of the License at
9 // http://www.apache.org/licenses/LICENSE-2.0
11 // Unless required by applicable law or agreed to in writing, software
12 // distributed under the License is distributed on an "AS IS" BASIS,
13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 // See the License for the specific language governing permissions and
15 // limitations under the License.
17 // This source code is part of the near-RT RIC (RAN Intelligent Controller)
18 // platform project (RICP).
27 "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
28 "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
29 "github.com/stretchr/testify/assert"
35 func setupRnibDataServiceTest(t *testing.T) (*rNibDataService, *mocks.RnibReaderMock, *mocks.RnibWriterMock) {
36 return setupRnibDataServiceTestWithMaxAttempts(t, 3)
39 func setupRnibDataServiceTestWithMaxAttempts(t *testing.T, maxAttempts int) (*rNibDataService, *mocks.RnibReaderMock, *mocks.RnibWriterMock) {
40 logger, err := logger.InitLogger(logger.DebugLevel)
42 t.Errorf("#... - failed to initialize logger, error: %s", err)
45 config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: maxAttempts, RnibWriter: configuration.RnibWriterConfig{RanManipulationMessageChannel: "RAN_MANIPULATION", StateChangeMessageChannel: "RAN_CONNECTION_STATUS_CHANGE"}}
47 readerMock := &mocks.RnibReaderMock{}
49 writerMock := &mocks.RnibWriterMock{}
51 rnibDataService := NewRnibDataService(logger, config, readerMock, writerMock)
52 assert.NotNil(t, rnibDataService)
54 return rnibDataService, readerMock, writerMock
57 func TestSuccessfulSaveNodeb(t *testing.T) {
58 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
60 nodebInfo := &entities.NodebInfo{}
61 writerMock.On("SaveNodeb", nodebInfo).Return(nil)
63 rnibDataService.SaveNodeb(nodebInfo)
64 writerMock.AssertNumberOfCalls(t, "SaveNodeb", 1)
67 func TestConnFailureSaveNodeb(t *testing.T) {
68 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
70 nodebInfo := &entities.NodebInfo{}
71 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
72 writerMock.On("SaveNodeb", nodebInfo).Return(mockErr)
74 rnibDataService.SaveNodeb(nodebInfo)
75 writerMock.AssertNumberOfCalls(t, "SaveNodeb", 3)
78 func TestNonConnFailureSaveNodeb(t *testing.T) {
79 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
81 nodebInfo := &entities.NodebInfo{}
82 mockErr := &common.InternalError{Err: fmt.Errorf("non connection failure")}
83 writerMock.On("SaveNodeb", nodebInfo).Return(mockErr)
85 rnibDataService.SaveNodeb(nodebInfo)
86 writerMock.AssertNumberOfCalls(t, "SaveNodeb", 1)
89 func TestSuccessfulUpdateNodebInfo(t *testing.T) {
90 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
92 nodebInfo := &entities.NodebInfo{}
93 writerMock.On("UpdateNodebInfo", nodebInfo).Return(nil)
95 rnibDataService.UpdateNodebInfo(nodebInfo)
96 writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 1)
99 func TestConnFailureUpdateNodebInfo(t *testing.T) {
100 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
102 nodebInfo := &entities.NodebInfo{}
103 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
104 writerMock.On("UpdateNodebInfo", nodebInfo).Return(mockErr)
106 rnibDataService.UpdateNodebInfo(nodebInfo)
107 writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 3)
110 func TestSuccessfulUpdateNodebInfoAndPublish(t *testing.T) {
111 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
113 nodebInfo := &entities.NodebInfo{}
114 writerMock.On("UpdateNodebInfoAndPublish", nodebInfo).Return(nil)
116 rnibDataService.UpdateNodebInfoAndPublish(nodebInfo)
117 writerMock.AssertNumberOfCalls(t, "UpdateNodebInfoAndPublish", 1)
120 func TestConnFailureUpdateNodebInfoAndPublish(t *testing.T) {
121 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
123 nodebInfo := &entities.NodebInfo{}
124 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
125 writerMock.On("UpdateNodebInfoAndPublish", nodebInfo).Return(mockErr)
127 rnibDataService.UpdateNodebInfoAndPublish(nodebInfo)
128 writerMock.AssertNumberOfCalls(t, "UpdateNodebInfoAndPublish", 3)
131 func TestSuccessfulSaveRanLoadInformation(t *testing.T) {
132 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
134 var ranName string = "abcd"
135 ranLoadInformation := &entities.RanLoadInformation{}
136 writerMock.On("SaveRanLoadInformation", ranName, ranLoadInformation).Return(nil)
138 rnibDataService.SaveRanLoadInformation(ranName, ranLoadInformation)
139 writerMock.AssertNumberOfCalls(t, "SaveRanLoadInformation", 1)
142 func TestConnFailureSaveRanLoadInformation(t *testing.T) {
143 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
145 var ranName string = "abcd"
146 ranLoadInformation := &entities.RanLoadInformation{}
147 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
148 writerMock.On("SaveRanLoadInformation", ranName, ranLoadInformation).Return(mockErr)
150 rnibDataService.SaveRanLoadInformation(ranName, ranLoadInformation)
151 writerMock.AssertNumberOfCalls(t, "SaveRanLoadInformation", 3)
154 func TestSuccessfulGetNodeb(t *testing.T) {
155 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
158 nodebInfo := &entities.NodebInfo{}
159 readerMock.On("GetNodeb", invName).Return(nodebInfo, nil)
161 res, err := rnibDataService.GetNodeb(invName)
162 readerMock.AssertNumberOfCalls(t, "GetNodeb", 1)
163 assert.Equal(t, nodebInfo, res)
167 func TestConnFailureGetNodeb(t *testing.T) {
168 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
171 var nodeb *entities.NodebInfo = nil
172 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
173 readerMock.On("GetNodeb", invName).Return(nodeb, mockErr)
175 res, err := rnibDataService.GetNodeb(invName)
176 readerMock.AssertNumberOfCalls(t, "GetNodeb", 3)
177 assert.True(t, strings.Contains(err.Error(), "connection error"))
178 assert.Equal(t, nodeb, res)
181 func TestSuccessfulGetNodebIdList(t *testing.T) {
182 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
184 nodeIds := []*entities.NbIdentity{}
185 readerMock.On("GetListNodebIds").Return(nodeIds, nil)
187 res, err := rnibDataService.GetListNodebIds()
188 readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 1)
189 assert.Equal(t, nodeIds, res)
193 func TestConnFailureGetNodebIdList(t *testing.T) {
194 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
196 var nodeIds []*entities.NbIdentity = nil
197 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
198 readerMock.On("GetListNodebIds").Return(nodeIds, mockErr)
200 res, err := rnibDataService.GetListNodebIds()
201 readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 3)
202 assert.True(t, strings.Contains(err.Error(), "connection error"))
203 assert.Equal(t, nodeIds, res)
206 func TestConnFailureTwiceGetNodebIdList(t *testing.T) {
207 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
210 var nodeb *entities.NodebInfo = nil
211 var nodeIds []*entities.NbIdentity = nil
212 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
213 readerMock.On("GetNodeb", invName).Return(nodeb, mockErr)
214 readerMock.On("GetListNodebIds").Return(nodeIds, mockErr)
216 res, err := rnibDataService.GetListNodebIds()
217 readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 3)
218 assert.True(t, strings.Contains(err.Error(), "connection error"))
219 assert.Equal(t, nodeIds, res)
221 res2, err := rnibDataService.GetNodeb(invName)
222 readerMock.AssertNumberOfCalls(t, "GetNodeb", 3)
223 assert.True(t, strings.Contains(err.Error(), "connection error"))
224 assert.Equal(t, nodeb, res2)
227 func TestConnFailureWithAnotherConfig(t *testing.T) {
228 rnibDataService, readerMock, _ := setupRnibDataServiceTestWithMaxAttempts(t, 5)
230 var nodeIds []*entities.NbIdentity = nil
231 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
232 readerMock.On("GetListNodebIds").Return(nodeIds, mockErr)
234 res, err := rnibDataService.GetListNodebIds()
235 readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 5)
236 assert.True(t, strings.Contains(err.Error(), "connection error"))
237 assert.Equal(t, nodeIds, res)
240 func TestGetGeneralConfigurationConnFailure(t *testing.T) {
241 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
243 var config *entities.GeneralConfiguration = nil
244 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
245 readerMock.On("GetGeneralConfiguration").Return(config, mockErr)
247 res, err := rnibDataService.GetGeneralConfiguration()
248 readerMock.AssertNumberOfCalls(t, "GetGeneralConfiguration", 3)
250 assert.NotNil(t, err)
253 func TestGetGeneralConfigurationOkNoError(t *testing.T) {
254 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
256 config := &entities.GeneralConfiguration{}
257 readerMock.On("GetGeneralConfiguration").Return(config, nil)
259 res, err := rnibDataService.GetGeneralConfiguration()
260 readerMock.AssertNumberOfCalls(t, "GetGeneralConfiguration", 1)
261 assert.Equal(t, config, res)
265 func TestGetGeneralConfigurationOtherError(t *testing.T) {
266 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
268 var config *entities.GeneralConfiguration = nil
269 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
270 readerMock.On("GetGeneralConfiguration").Return(config, mockErr)
272 res, err := rnibDataService.GetGeneralConfiguration()
273 readerMock.AssertNumberOfCalls(t, "GetGeneralConfiguration", 1)
275 assert.NotNil(t, err)
278 func TestSaveGeneralConfigurationConnFailure(t *testing.T) {
279 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
281 config := &entities.GeneralConfiguration{}
282 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
283 writerMock.On("SaveGeneralConfiguration", config).Return(mockErr)
285 err := rnibDataService.SaveGeneralConfiguration(config)
286 writerMock.AssertNumberOfCalls(t, "SaveGeneralConfiguration", 3)
287 assert.NotNil(t, err)
290 func TestSaveGeneralConfigurationOkNoError(t *testing.T) {
291 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
293 config := &entities.GeneralConfiguration{}
294 writerMock.On("SaveGeneralConfiguration", config).Return(nil)
296 err := rnibDataService.SaveGeneralConfiguration(config)
297 writerMock.AssertNumberOfCalls(t, "SaveGeneralConfiguration", 1)
301 func TestSaveGeneralConfigurationOtherError(t *testing.T) {
302 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
304 config := &entities.GeneralConfiguration{}
305 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
306 writerMock.On("SaveGeneralConfiguration", config).Return(mockErr)
308 err := rnibDataService.SaveGeneralConfiguration(config)
309 writerMock.AssertNumberOfCalls(t, "SaveGeneralConfiguration", 1)
310 assert.NotNil(t, err)
313 func TestRemoveServedCellsConnFailure(t *testing.T) {
314 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
316 var ranName string = "abcd"
317 cellIds := []*entities.ServedCellInfo{}
318 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
319 writerMock.On("RemoveServedCells", ranName, cellIds).Return(mockErr)
321 err := rnibDataService.RemoveServedCells(ranName, cellIds)
322 writerMock.AssertNumberOfCalls(t, "RemoveServedCells", 3)
323 assert.NotNil(t, err)
326 func TestRemoveServedCellsOkNoError(t *testing.T) {
327 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
329 var ranName string = "abcd"
330 cellIds := []*entities.ServedCellInfo{}
331 writerMock.On("RemoveServedCells", ranName, cellIds).Return(nil)
333 err := rnibDataService.RemoveServedCells(ranName, cellIds)
334 writerMock.AssertNumberOfCalls(t, "RemoveServedCells", 1)
338 func TestRemoveServedCellsOtherError(t *testing.T) {
339 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
341 var ranName string = "abcd"
342 cellIds := []*entities.ServedCellInfo{}
343 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
344 writerMock.On("RemoveServedCells", ranName, cellIds).Return(mockErr)
346 err := rnibDataService.RemoveServedCells(ranName, cellIds)
347 writerMock.AssertNumberOfCalls(t, "RemoveServedCells", 1)
348 assert.NotNil(t, err)
351 func TestUpdateEnbConnFailure(t *testing.T) {
352 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
354 nodebInfo := &entities.NodebInfo{}
355 cellIds := []*entities.ServedCellInfo{}
356 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
357 writerMock.On("UpdateEnb", nodebInfo, cellIds).Return(mockErr)
359 err := rnibDataService.UpdateEnb(nodebInfo, cellIds)
360 writerMock.AssertNumberOfCalls(t, "UpdateEnb", 3)
361 assert.NotNil(t, err)
364 func TestUpdateEnbOkNoError(t *testing.T) {
365 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
367 nodebInfo := &entities.NodebInfo{}
368 cellIds := []*entities.ServedCellInfo{}
369 writerMock.On("UpdateEnb", nodebInfo, cellIds).Return(nil)
371 err := rnibDataService.UpdateEnb(nodebInfo, cellIds)
372 writerMock.AssertNumberOfCalls(t, "UpdateEnb", 1)
376 func TestUpdateEnbOtherError(t *testing.T) {
377 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
379 nodebInfo := &entities.NodebInfo{}
380 cellIds := []*entities.ServedCellInfo{}
381 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
382 writerMock.On("UpdateEnb", nodebInfo, cellIds).Return(mockErr)
384 err := rnibDataService.UpdateEnb(nodebInfo, cellIds)
385 writerMock.AssertNumberOfCalls(t, "UpdateEnb", 1)
386 assert.NotNil(t, err)
389 func TestAddEnbConnFailure(t *testing.T) {
390 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
392 nodebInfo := &entities.NodebInfo{}
393 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
394 writerMock.On("AddEnb", nodebInfo).Return(mockErr)
396 err := rnibDataService.AddEnb(nodebInfo)
397 writerMock.AssertNumberOfCalls(t, "AddEnb", 3)
398 assert.NotNil(t, err)
401 func TestAddEnbOkNoError(t *testing.T) {
402 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
404 nodebInfo := &entities.NodebInfo{}
405 writerMock.On("AddEnb", nodebInfo).Return(nil)
407 err := rnibDataService.AddEnb(nodebInfo)
408 writerMock.AssertNumberOfCalls(t, "AddEnb", 1)
412 func TestAddEnbOtherError(t *testing.T) {
413 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
415 nodebInfo := &entities.NodebInfo{}
416 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
417 writerMock.On("AddEnb", nodebInfo).Return(mockErr)
419 err := rnibDataService.AddEnb(nodebInfo)
420 writerMock.AssertNumberOfCalls(t, "AddEnb", 1)
421 assert.NotNil(t, err)
424 func TestUpdateNbIdentityConnFailure(t *testing.T) {
425 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
427 gnbType := entities.Node_GNB
428 oldNodeId := &entities.NbIdentity{}
429 newNodeId := &entities.NbIdentity{}
430 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
431 writerMock.On("UpdateNbIdentities", gnbType, []*entities.NbIdentity{oldNodeId},
432 []*entities.NbIdentity{newNodeId}).Return(mockErr)
434 err := rnibDataService.UpdateNbIdentity(gnbType, oldNodeId, newNodeId)
435 writerMock.AssertNumberOfCalls(t, "UpdateNbIdentities", 3)
436 assert.NotNil(t, err)
439 func TestUpdateNbIdentityOkNoError(t *testing.T) {
440 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
442 gnbType := entities.Node_GNB
443 oldNodeId := &entities.NbIdentity{}
444 newNodeId := &entities.NbIdentity{}
445 writerMock.On("UpdateNbIdentities", gnbType, []*entities.NbIdentity{oldNodeId},
446 []*entities.NbIdentity{newNodeId}).Return(nil)
448 err := rnibDataService.UpdateNbIdentity(gnbType, oldNodeId, newNodeId)
449 writerMock.AssertNumberOfCalls(t, "UpdateNbIdentities", 1)
453 func TestUpdateNbIdentityOtherError(t *testing.T) {
454 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
456 gnbType := entities.Node_GNB
457 oldNodeId := &entities.NbIdentity{}
458 newNodeId := &entities.NbIdentity{}
459 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
460 writerMock.On("UpdateNbIdentities", gnbType, []*entities.NbIdentity{oldNodeId},
461 []*entities.NbIdentity{newNodeId}).Return(mockErr)
463 err := rnibDataService.UpdateNbIdentity(gnbType, oldNodeId, newNodeId)
464 writerMock.AssertNumberOfCalls(t, "UpdateNbIdentities", 1)
465 assert.NotNil(t, err)
468 func TestUpdateNbIdentitiesConnFailure(t *testing.T) {
469 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
471 gnbType := entities.Node_GNB
472 oldNodeIds := []*entities.NbIdentity{}
473 newNodeIds := []*entities.NbIdentity{}
474 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
475 writerMock.On("UpdateNbIdentities", gnbType, oldNodeIds, newNodeIds).Return(mockErr)
477 err := rnibDataService.UpdateNbIdentities(gnbType, oldNodeIds, newNodeIds)
478 writerMock.AssertNumberOfCalls(t, "UpdateNbIdentities", 3)
479 assert.NotNil(t, err)
482 func TestUpdateNbIdentitiesOkNoError(t *testing.T) {
483 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
485 gnbType := entities.Node_GNB
486 oldNodeIds := []*entities.NbIdentity{}
487 newNodeIds := []*entities.NbIdentity{}
488 writerMock.On("UpdateNbIdentities", gnbType, oldNodeIds, newNodeIds).Return(nil)
490 err := rnibDataService.UpdateNbIdentities(gnbType, oldNodeIds, newNodeIds)
491 writerMock.AssertNumberOfCalls(t, "UpdateNbIdentities", 1)
495 func TestUpdateNbIdentitiesOtherError(t *testing.T) {
496 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
498 gnbType := entities.Node_GNB
499 oldNodeIds := []*entities.NbIdentity{}
500 newNodeIds := []*entities.NbIdentity{}
501 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
502 writerMock.On("UpdateNbIdentities", gnbType, oldNodeIds, newNodeIds).Return(mockErr)
504 err := rnibDataService.UpdateNbIdentities(gnbType, oldNodeIds, newNodeIds)
505 writerMock.AssertNumberOfCalls(t, "UpdateNbIdentities", 1)
506 assert.NotNil(t, err)
509 func TestPingRnibConnFailure(t *testing.T) {
510 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
512 var nodeIds []*entities.NbIdentity = nil
513 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
514 readerMock.On("GetListNodebIds").Return(nodeIds, mockErr)
516 res := rnibDataService.PingRnib()
517 readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 3)
521 func TestPingRnibOkNoError(t *testing.T) {
522 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
524 var nodeIds []*entities.NbIdentity = nil
525 readerMock.On("GetListNodebIds").Return(nodeIds, nil)
527 res := rnibDataService.PingRnib()
528 readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 1)
532 func TestPingRnibOkOtherError(t *testing.T) {
533 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
535 var nodeIds []*entities.NbIdentity = nil
536 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
537 readerMock.On("GetListNodebIds").Return(nodeIds, mockErr)
539 res := rnibDataService.PingRnib()
540 readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 1)
544 func TestSuccessfulUpdateNodebInfoOnConnectionStatusInversion(t *testing.T) {
545 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
548 nodebInfo := &entities.NodebInfo{}
549 writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", nodebInfo, event).Return(nil)
551 rnibDataService.UpdateNodebInfoOnConnectionStatusInversion(nodebInfo, event)
552 writerMock.AssertNumberOfCalls(t, "UpdateNodebInfoOnConnectionStatusInversion", 1)
555 func TestConnFailureUpdateNodebInfoOnConnectionStatusInversion(t *testing.T) {
556 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
559 nodebInfo := &entities.NodebInfo{}
560 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
561 writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", nodebInfo, event).Return(mockErr)
563 rnibDataService.UpdateNodebInfoOnConnectionStatusInversion(nodebInfo, event)
564 writerMock.AssertNumberOfCalls(t, "UpdateNodebInfoOnConnectionStatusInversion", 3)
567 func TestGetE2TInstanceConnFailure(t *testing.T) {
568 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
570 address := "10.10.5.20:3200"
571 var e2tInstance *entities.E2TInstance = nil
572 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
573 readerMock.On("GetE2TInstance", address).Return(e2tInstance, mockErr)
575 res, err := rnibDataService.GetE2TInstance(address)
576 readerMock.AssertNumberOfCalls(t, "GetE2TInstance", 3)
578 assert.NotNil(t, err)
581 func TestGetE2TInstanceOkNoError(t *testing.T) {
582 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
584 address := "10.10.5.20:3200"
585 e2tInstance := &entities.E2TInstance{}
586 readerMock.On("GetE2TInstance", address).Return(e2tInstance, nil)
588 res, err := rnibDataService.GetE2TInstance(address)
589 readerMock.AssertNumberOfCalls(t, "GetE2TInstance", 1)
591 assert.Equal(t, e2tInstance, res)
594 func TestGetE2TInstanceOtherError(t *testing.T) {
595 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
597 address := "10.10.5.20:3200"
598 var e2tInstance *entities.E2TInstance = nil
599 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
600 readerMock.On("GetE2TInstance", address).Return(e2tInstance, mockErr)
602 res, err := rnibDataService.GetE2TInstance(address)
603 readerMock.AssertNumberOfCalls(t, "GetE2TInstance", 1)
605 assert.NotNil(t, err)
608 func TestGetE2TInstanceNoLogsConnFailure(t *testing.T) {
609 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
611 address := "10.10.5.20:3200"
612 var e2tInstance *entities.E2TInstance = nil
613 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
614 readerMock.On("GetE2TInstance", address).Return(e2tInstance, mockErr)
616 res, err := rnibDataService.GetE2TInstanceNoLogs(address)
617 readerMock.AssertNumberOfCalls(t, "GetE2TInstance", 3)
619 assert.NotNil(t, err)
622 func TestGetE2TInstanceNoLogsOkNoError(t *testing.T) {
623 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
625 address := "10.10.5.20:3200"
626 e2tInstance := &entities.E2TInstance{}
627 readerMock.On("GetE2TInstance", address).Return(e2tInstance, nil)
629 res, err := rnibDataService.GetE2TInstanceNoLogs(address)
630 readerMock.AssertNumberOfCalls(t, "GetE2TInstance", 1)
632 assert.Equal(t, e2tInstance, res)
635 func TestGetE2TInstanceNoLogsOtherError(t *testing.T) {
636 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
638 address := "10.10.5.20:3200"
639 var e2tInstance *entities.E2TInstance = nil
640 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
641 readerMock.On("GetE2TInstance", address).Return(e2tInstance, mockErr)
643 res, err := rnibDataService.GetE2TInstanceNoLogs(address)
644 readerMock.AssertNumberOfCalls(t, "GetE2TInstance", 1)
646 assert.NotNil(t, err)
649 func TestGetE2TInstancesConnFailure(t *testing.T) {
650 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
652 addresses := []string{"10.10.5.20:3200", "10.10.5.21:3200"}
653 var e2tInstances []*entities.E2TInstance = nil
654 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
655 readerMock.On("GetE2TInstances", addresses).Return(e2tInstances, mockErr)
657 res, err := rnibDataService.GetE2TInstances(addresses)
658 readerMock.AssertNumberOfCalls(t, "GetE2TInstances", 3)
660 assert.NotNil(t, err)
663 func TestGetE2TInstancesOkNoError(t *testing.T) {
664 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
666 addresses := []string{"10.10.5.20:3200", "10.10.5.21:3200"}
667 e2tInstance := []*entities.E2TInstance{}
668 readerMock.On("GetE2TInstances", addresses).Return(e2tInstance, nil)
670 res, err := rnibDataService.GetE2TInstances(addresses)
671 readerMock.AssertNumberOfCalls(t, "GetE2TInstances", 1)
673 assert.Equal(t, e2tInstance, res)
676 func TestGetE2TInstancesOtherError(t *testing.T) {
677 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
679 addresses := []string{"10.10.5.20:3200", "10.10.5.21:3200"}
680 var e2tInstances []*entities.E2TInstance = nil
681 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
682 readerMock.On("GetE2TInstances", addresses).Return(e2tInstances, mockErr)
684 res, err := rnibDataService.GetE2TInstances(addresses)
685 readerMock.AssertNumberOfCalls(t, "GetE2TInstances", 1)
687 assert.NotNil(t, err)
690 func TestGetE2TInstancesNoLogsConnFailure(t *testing.T) {
691 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
693 addresses := []string{"10.10.5.20:3200", "10.10.5.21:3200"}
694 var e2tInstances []*entities.E2TInstance = nil
695 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
696 readerMock.On("GetE2TInstances", addresses).Return(e2tInstances, mockErr)
698 res, err := rnibDataService.GetE2TInstancesNoLogs(addresses)
699 readerMock.AssertNumberOfCalls(t, "GetE2TInstances", 3)
701 assert.NotNil(t, err)
704 func TestGetE2TInstancesNoLogsOkNoError(t *testing.T) {
705 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
707 addresses := []string{"10.10.5.20:3200", "10.10.5.21:3200"}
708 e2tInstance := []*entities.E2TInstance{}
709 readerMock.On("GetE2TInstances", addresses).Return(e2tInstance, nil)
711 res, err := rnibDataService.GetE2TInstancesNoLogs(addresses)
712 readerMock.AssertNumberOfCalls(t, "GetE2TInstances", 1)
714 assert.Equal(t, e2tInstance, res)
717 func TestGetE2TInstancesNoLogsOtherError(t *testing.T) {
718 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
720 addresses := []string{"10.10.5.20:3200", "10.10.5.21:3200"}
721 var e2tInstances []*entities.E2TInstance = nil
722 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
723 readerMock.On("GetE2TInstances", addresses).Return(e2tInstances, mockErr)
725 res, err := rnibDataService.GetE2TInstancesNoLogs(addresses)
726 readerMock.AssertNumberOfCalls(t, "GetE2TInstances", 1)
728 assert.NotNil(t, err)
731 func TestGetE2TAddressesConnFailure(t *testing.T) {
732 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
734 var addresses []string = nil
735 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
736 readerMock.On("GetE2TAddresses").Return(addresses, mockErr)
738 res, err := rnibDataService.GetE2TAddresses()
739 readerMock.AssertNumberOfCalls(t, "GetE2TAddresses", 3)
741 assert.NotNil(t, err)
744 func TestGetE2TAddressesOkNoError(t *testing.T) {
745 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
747 addresses := []string{"10.10.5.20:3200", "10.10.5.21:3200"}
748 readerMock.On("GetE2TAddresses").Return(addresses, nil)
750 res, err := rnibDataService.GetE2TAddresses()
751 readerMock.AssertNumberOfCalls(t, "GetE2TAddresses", 1)
753 assert.Equal(t, addresses, res)
756 func TestGetE2TAddressesOtherError(t *testing.T) {
757 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
759 var addresses []string = nil
760 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
761 readerMock.On("GetE2TAddresses").Return(addresses, mockErr)
763 res, err := rnibDataService.GetE2TAddresses()
764 readerMock.AssertNumberOfCalls(t, "GetE2TAddresses", 1)
766 assert.NotNil(t, err)
769 func TestGetE2TAddressesNoLogsConnFailure(t *testing.T) {
770 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
772 var addresses []string = nil
773 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
774 readerMock.On("GetE2TAddresses").Return(addresses, mockErr)
776 res, err := rnibDataService.GetE2TAddressesNoLogs()
777 readerMock.AssertNumberOfCalls(t, "GetE2TAddresses", 3)
779 assert.NotNil(t, err)
782 func TestGetE2TAddressesNoLogsOkNoError(t *testing.T) {
783 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
785 addresses := []string{"10.10.5.20:3200", "10.10.5.21:3200"}
786 readerMock.On("GetE2TAddresses").Return(addresses, nil)
788 res, err := rnibDataService.GetE2TAddressesNoLogs()
789 readerMock.AssertNumberOfCalls(t, "GetE2TAddresses", 1)
791 assert.Equal(t, addresses, res)
794 func TestGetE2TAddressesNoLogsOtherError(t *testing.T) {
795 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
797 var addresses []string = nil
798 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
799 readerMock.On("GetE2TAddresses").Return(addresses, mockErr)
801 res, err := rnibDataService.GetE2TAddressesNoLogs()
802 readerMock.AssertNumberOfCalls(t, "GetE2TAddresses", 1)
804 assert.NotNil(t, err)
807 func TestSaveE2TInstanceConnFailure(t *testing.T) {
808 e2tInstance := &entities.E2TInstance{}
809 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
811 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
813 writerMock.On("SaveE2TInstance", e2tInstance).Return(mockErr)
815 err := rnibDataService.SaveE2TInstance(e2tInstance)
816 writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 3)
817 assert.NotNil(t, err)
820 func TestSaveE2TInstanceOkNoError(t *testing.T) {
821 e2tInstance := &entities.E2TInstance{}
822 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
824 writerMock.On("SaveE2TInstance", e2tInstance).Return(nil)
826 err := rnibDataService.SaveE2TInstance(e2tInstance)
827 writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 1)
831 func TestSaveE2TInstanceOtherError(t *testing.T) {
832 e2tInstance := &entities.E2TInstance{}
833 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
835 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
837 writerMock.On("SaveE2TInstance", e2tInstance).Return(mockErr)
839 err := rnibDataService.SaveE2TInstance(e2tInstance)
840 writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 1)
842 assert.NotNil(t, err)
845 func TestSaveE2TInstanceNoLogsConnFailure(t *testing.T) {
846 e2tInstance := &entities.E2TInstance{}
847 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
849 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
851 writerMock.On("SaveE2TInstance", e2tInstance).Return(mockErr)
853 err := rnibDataService.SaveE2TInstanceNoLogs(e2tInstance)
854 writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 3)
855 assert.NotNil(t, err)
858 func TestSaveE2TInstanceNoLogsOkNoError(t *testing.T) {
859 e2tInstance := &entities.E2TInstance{}
860 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
862 writerMock.On("SaveE2TInstance", e2tInstance).Return(nil)
864 err := rnibDataService.SaveE2TInstanceNoLogs(e2tInstance)
865 writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 1)
869 func TestSaveE2TInstanceNoLogsOtherError(t *testing.T) {
870 e2tInstance := &entities.E2TInstance{}
871 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
873 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
875 writerMock.On("SaveE2TInstance", e2tInstance).Return(mockErr)
877 err := rnibDataService.SaveE2TInstanceNoLogs(e2tInstance)
878 writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 1)
880 assert.NotNil(t, err)
883 func TestSaveE2TAddressesConnFailure(t *testing.T) {
884 addresses := []string{"10.10.5.20:3200", "10.10.5.21:3200"}
885 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
887 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
889 writerMock.On("SaveE2TAddresses", addresses).Return(mockErr)
891 err := rnibDataService.SaveE2TAddresses(addresses)
892 writerMock.AssertNumberOfCalls(t, "SaveE2TAddresses", 3)
893 assert.NotNil(t, err)
896 func TestSaveE2TAddressesOkNoError(t *testing.T) {
897 addresses := []string{"10.10.5.20:3200", "10.10.5.21:3200"}
898 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
900 writerMock.On("SaveE2TAddresses", addresses).Return(nil)
902 err := rnibDataService.SaveE2TAddresses(addresses)
903 writerMock.AssertNumberOfCalls(t, "SaveE2TAddresses", 1)
907 func TestSaveE2TAddressesOtherError(t *testing.T) {
908 addresses := []string{"10.10.5.20:3200", "10.10.5.21:3200"}
909 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
911 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
913 writerMock.On("SaveE2TAddresses", addresses).Return(mockErr)
915 err := rnibDataService.SaveE2TAddresses(addresses)
916 writerMock.AssertNumberOfCalls(t, "SaveE2TAddresses", 1)
918 assert.NotNil(t, err)
921 func TestRemoveE2TInstanceConnFailure(t *testing.T) {
922 address := "10.10.5.20:3200"
923 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
925 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
927 writerMock.On("RemoveE2TInstance", address).Return(mockErr)
929 err := rnibDataService.RemoveE2TInstance(address)
930 writerMock.AssertNumberOfCalls(t, "RemoveE2TInstance", 3)
931 assert.NotNil(t, err)
934 func TestRemoveE2TInstanceOkNoError(t *testing.T) {
935 address := "10.10.5.20:3200"
936 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
938 writerMock.On("RemoveE2TInstance", address).Return(nil)
940 err := rnibDataService.RemoveE2TInstance(address)
941 writerMock.AssertNumberOfCalls(t, "RemoveE2TInstance", 1)
945 func TestRemoveE2TInstanceOtherError(t *testing.T) {
946 address := "10.10.5.20:3200"
947 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
949 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
951 writerMock.On("RemoveE2TInstance", address).Return(mockErr)
953 err := rnibDataService.RemoveE2TInstance(address)
954 writerMock.AssertNumberOfCalls(t, "RemoveE2TInstance", 1)
956 assert.NotNil(t, err)
959 func TestAddNbIdentityConnFailure(t *testing.T) {
960 gnbType := entities.Node_GNB
961 nbIdentity := &entities.NbIdentity{}
962 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
964 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
966 writerMock.On("AddNbIdentity", gnbType, nbIdentity).Return(mockErr)
968 err := rnibDataService.AddNbIdentity(gnbType, nbIdentity)
969 writerMock.AssertNumberOfCalls(t, "AddNbIdentity", 3)
970 assert.NotNil(t, err)
973 func TestAddNbIdentityOkNoError(t *testing.T) {
974 gnbType := entities.Node_GNB
975 nbIdentity := &entities.NbIdentity{}
976 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
978 writerMock.On("AddNbIdentity", gnbType, nbIdentity).Return(nil)
980 err := rnibDataService.AddNbIdentity(gnbType, nbIdentity)
981 writerMock.AssertNumberOfCalls(t, "AddNbIdentity", 1)
985 func TestAddNbIdentityOtherError(t *testing.T) {
986 gnbType := entities.Node_GNB
987 nbIdentity := &entities.NbIdentity{}
988 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
990 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
992 writerMock.On("AddNbIdentity", gnbType, nbIdentity).Return(mockErr)
994 err := rnibDataService.AddNbIdentity(gnbType, nbIdentity)
995 writerMock.AssertNumberOfCalls(t, "AddNbIdentity", 1)
997 assert.NotNil(t, err)
1000 func TestRemoveNbIdentityConnFailure(t *testing.T) {
1001 gnbType := entities.Node_GNB
1002 nbIdentity := &entities.NbIdentity{}
1003 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
1005 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
1007 writerMock.On("RemoveNbIdentity", gnbType, nbIdentity).Return(mockErr)
1009 err := rnibDataService.RemoveNbIdentity(gnbType, nbIdentity)
1010 writerMock.AssertNumberOfCalls(t, "RemoveNbIdentity", 3)
1011 assert.NotNil(t, err)
1014 func TestRemoveNbIdentityOkNoError(t *testing.T) {
1015 gnbType := entities.Node_GNB
1016 nbIdentity := &entities.NbIdentity{}
1017 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
1019 writerMock.On("RemoveNbIdentity", gnbType, nbIdentity).Return(nil)
1021 err := rnibDataService.RemoveNbIdentity(gnbType, nbIdentity)
1022 writerMock.AssertNumberOfCalls(t, "RemoveNbIdentity", 1)
1026 func TestRemoveNbIdentityOtherError(t *testing.T) {
1027 gnbType := entities.Node_GNB
1028 nbIdentity := &entities.NbIdentity{}
1029 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
1031 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
1033 writerMock.On("RemoveNbIdentity", gnbType, nbIdentity).Return(mockErr)
1035 err := rnibDataService.RemoveNbIdentity(gnbType, nbIdentity)
1036 writerMock.AssertNumberOfCalls(t, "RemoveNbIdentity", 1)
1037 assert.NotNil(t, err)
1040 func TestRemoveServedNrCellsConnFailure(t *testing.T) {
1041 var ranName string = "abcd"
1042 var servedNrCells []*entities.ServedNRCell
1043 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
1045 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
1047 writerMock.On("RemoveServedNrCells", ranName, servedNrCells).Return(mockErr)
1049 err := rnibDataService.RemoveServedNrCells(ranName, servedNrCells)
1050 writerMock.AssertNumberOfCalls(t, "RemoveServedNrCells", 3)
1051 assert.NotNil(t, err)
1054 func TestRemoveServedNrCellsOkNoError(t *testing.T) {
1055 var ranName string = "abcd"
1056 var servedNrCells []*entities.ServedNRCell
1057 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
1059 writerMock.On("RemoveServedNrCells", ranName, servedNrCells).Return(nil)
1061 err := rnibDataService.RemoveServedNrCells(ranName, servedNrCells)
1062 writerMock.AssertNumberOfCalls(t, "RemoveServedNrCells", 1)
1066 func TestRemoveServedNrCellsOtherError(t *testing.T) {
1067 var ranName string = "abcd"
1068 var servedNrCells []*entities.ServedNRCell
1069 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
1071 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
1073 writerMock.On("RemoveServedNrCells", ranName, servedNrCells).Return(mockErr)
1075 err := rnibDataService.RemoveServedNrCells(ranName, servedNrCells)
1076 writerMock.AssertNumberOfCalls(t, "RemoveServedNrCells", 1)
1077 assert.NotNil(t, err)
1080 func TestRemoveEnbConnFailure(t *testing.T) {
1081 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
1083 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
1084 nodebInfo := &entities.NodebInfo{}
1085 writerMock.On("RemoveEnb", nodebInfo).Return(mockErr)
1087 err := rnibDataService.RemoveEnb(nodebInfo)
1088 writerMock.AssertNumberOfCalls(t, "RemoveEnb", 3)
1089 assert.NotNil(t, err)
1092 func TestRemoveEnbOkNoError(t *testing.T) {
1093 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
1095 nodebInfo := &entities.NodebInfo{}
1096 writerMock.On("RemoveEnb", nodebInfo).Return(nil)
1098 err := rnibDataService.RemoveEnb(nodebInfo)
1099 writerMock.AssertNumberOfCalls(t, "RemoveEnb", 1)
1103 func TestRemoveEnbOtherError(t *testing.T) {
1104 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
1106 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
1107 nodebInfo := &entities.NodebInfo{}
1108 writerMock.On("RemoveEnb", nodebInfo).Return(mockErr)
1110 err := rnibDataService.RemoveEnb(nodebInfo)
1111 writerMock.AssertNumberOfCalls(t, "RemoveEnb", 1)
1112 assert.NotNil(t, err)
1115 func TestUpdateGnbCellsConnFailure(t *testing.T) {
1116 var servedNrCells []*entities.ServedNRCell
1117 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
1119 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
1120 nodebInfo := &entities.NodebInfo{}
1121 writerMock.On("UpdateGnbCells", nodebInfo, servedNrCells).Return(mockErr)
1123 err := rnibDataService.UpdateGnbCells(nodebInfo, servedNrCells)
1124 writerMock.AssertNumberOfCalls(t, "UpdateGnbCells", 3)
1125 assert.NotNil(t, err)
1128 func TestUpdateGnbCellsOkNoError(t *testing.T) {
1129 var servedNrCells []*entities.ServedNRCell
1130 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
1132 nodebInfo := &entities.NodebInfo{}
1133 writerMock.On("UpdateGnbCells", nodebInfo, servedNrCells).Return(nil)
1135 err := rnibDataService.UpdateGnbCells(nodebInfo, servedNrCells)
1136 writerMock.AssertNumberOfCalls(t, "UpdateGnbCells", 1)
1140 func TestUpdateGnbCellsOtherError(t *testing.T) {
1141 var servedNrCells []*entities.ServedNRCell
1142 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
1144 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
1145 nodebInfo := &entities.NodebInfo{}
1146 writerMock.On("UpdateGnbCells", nodebInfo, servedNrCells).Return(mockErr)
1148 err := rnibDataService.UpdateGnbCells(nodebInfo, servedNrCells)
1149 writerMock.AssertNumberOfCalls(t, "UpdateGnbCells", 1)
1150 assert.NotNil(t, err)