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) {
41 logger, err := logger.InitLogger(DebugLevel)
43 t.Errorf("#... - failed to initialize logger, error: %s", err)
46 config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: maxAttempts, RnibWriter: configuration.RnibWriterConfig{RanManipulationMessageChannel: "RAN_MANIPULATION", StateChangeMessageChannel: "RAN_CONNECTION_STATUS_CHANGE"}}
48 readerMock := &mocks.RnibReaderMock{}
50 writerMock := &mocks.RnibWriterMock{}
52 rnibDataService := NewRnibDataService(logger, config, readerMock, writerMock)
53 assert.NotNil(t, rnibDataService)
55 return rnibDataService, readerMock, writerMock
58 func TestSuccessfulSaveNodeb(t *testing.T) {
59 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
61 nodebInfo := &entities.NodebInfo{}
62 writerMock.On("SaveNodeb", nodebInfo).Return(nil)
64 rnibDataService.SaveNodeb(nodebInfo)
65 writerMock.AssertNumberOfCalls(t, "SaveNodeb", 1)
68 func TestConnFailureSaveNodeb(t *testing.T) {
69 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
71 nodebInfo := &entities.NodebInfo{}
72 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
73 writerMock.On("SaveNodeb", nodebInfo).Return(mockErr)
75 rnibDataService.SaveNodeb(nodebInfo)
76 writerMock.AssertNumberOfCalls(t, "SaveNodeb", 3)
79 func TestNonConnFailureSaveNodeb(t *testing.T) {
80 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
82 nodebInfo := &entities.NodebInfo{}
83 mockErr := &common.InternalError{Err: fmt.Errorf("non connection failure")}
84 writerMock.On("SaveNodeb", nodebInfo).Return(mockErr)
86 rnibDataService.SaveNodeb(nodebInfo)
87 writerMock.AssertNumberOfCalls(t, "SaveNodeb", 1)
90 func TestSuccessfulUpdateNodebInfo(t *testing.T) {
91 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
93 nodebInfo := &entities.NodebInfo{}
94 writerMock.On("UpdateNodebInfo", nodebInfo).Return(nil)
96 rnibDataService.UpdateNodebInfo(nodebInfo)
97 writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 1)
100 func TestConnFailureUpdateNodebInfo(t *testing.T) {
101 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
103 nodebInfo := &entities.NodebInfo{}
104 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
105 writerMock.On("UpdateNodebInfo", nodebInfo).Return(mockErr)
107 rnibDataService.UpdateNodebInfo(nodebInfo)
108 writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 3)
111 func TestSuccessfulUpdateNodebInfoAndPublish(t *testing.T) {
112 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
114 nodebInfo := &entities.NodebInfo{}
115 writerMock.On("UpdateNodebInfoAndPublish", nodebInfo).Return(nil)
117 rnibDataService.UpdateNodebInfoAndPublish(nodebInfo)
118 writerMock.AssertNumberOfCalls(t, "UpdateNodebInfoAndPublish", 1)
121 func TestConnFailureUpdateNodebInfoAndPublish(t *testing.T) {
122 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
124 nodebInfo := &entities.NodebInfo{}
125 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
126 writerMock.On("UpdateNodebInfoAndPublish", nodebInfo).Return(mockErr)
128 rnibDataService.UpdateNodebInfoAndPublish(nodebInfo)
129 writerMock.AssertNumberOfCalls(t, "UpdateNodebInfoAndPublish", 3)
132 func TestSuccessfulSaveRanLoadInformation(t *testing.T) {
133 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
135 var ranName string = "abcd"
136 ranLoadInformation := &entities.RanLoadInformation{}
137 writerMock.On("SaveRanLoadInformation", ranName, ranLoadInformation).Return(nil)
139 rnibDataService.SaveRanLoadInformation(ranName, ranLoadInformation)
140 writerMock.AssertNumberOfCalls(t, "SaveRanLoadInformation", 1)
143 func TestConnFailureSaveRanLoadInformation(t *testing.T) {
144 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
146 var ranName string = "abcd"
147 ranLoadInformation := &entities.RanLoadInformation{}
148 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
149 writerMock.On("SaveRanLoadInformation", ranName, ranLoadInformation).Return(mockErr)
151 rnibDataService.SaveRanLoadInformation(ranName, ranLoadInformation)
152 writerMock.AssertNumberOfCalls(t, "SaveRanLoadInformation", 3)
155 func TestSuccessfulGetNodeb(t *testing.T) {
156 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
159 nodebInfo := &entities.NodebInfo{}
160 readerMock.On("GetNodeb", invName).Return(nodebInfo, nil)
162 res, err := rnibDataService.GetNodeb(invName)
163 readerMock.AssertNumberOfCalls(t, "GetNodeb", 1)
164 assert.Equal(t, nodebInfo, res)
168 func TestConnFailureGetNodeb(t *testing.T) {
169 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
172 var nodeb *entities.NodebInfo = nil
173 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
174 readerMock.On("GetNodeb", invName).Return(nodeb, mockErr)
176 res, err := rnibDataService.GetNodeb(invName)
177 readerMock.AssertNumberOfCalls(t, "GetNodeb", 3)
178 assert.True(t, strings.Contains(err.Error(), "connection error"))
179 assert.Equal(t, nodeb, res)
182 func TestSuccessfulGetNodebIdList(t *testing.T) {
183 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
185 nodeIds := []*entities.NbIdentity{}
186 readerMock.On("GetListNodebIds").Return(nodeIds, nil)
188 res, err := rnibDataService.GetListNodebIds()
189 readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 1)
190 assert.Equal(t, nodeIds, res)
194 func TestConnFailureGetNodebIdList(t *testing.T) {
195 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
197 var nodeIds []*entities.NbIdentity = nil
198 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
199 readerMock.On("GetListNodebIds").Return(nodeIds, mockErr)
201 res, err := rnibDataService.GetListNodebIds()
202 readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 3)
203 assert.True(t, strings.Contains(err.Error(), "connection error"))
204 assert.Equal(t, nodeIds, res)
207 func TestConnFailureTwiceGetNodebIdList(t *testing.T) {
208 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
211 var nodeb *entities.NodebInfo = nil
212 var nodeIds []*entities.NbIdentity = nil
213 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
214 readerMock.On("GetNodeb", invName).Return(nodeb, mockErr)
215 readerMock.On("GetListNodebIds").Return(nodeIds, mockErr)
217 res, err := rnibDataService.GetListNodebIds()
218 readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 3)
219 assert.True(t, strings.Contains(err.Error(), "connection error"))
220 assert.Equal(t, nodeIds, res)
222 res2, err := rnibDataService.GetNodeb(invName)
223 readerMock.AssertNumberOfCalls(t, "GetNodeb", 3)
224 assert.True(t, strings.Contains(err.Error(), "connection error"))
225 assert.Equal(t, nodeb, res2)
228 func TestConnFailureWithAnotherConfig(t *testing.T) {
229 rnibDataService, readerMock, _ := setupRnibDataServiceTestWithMaxAttempts(t, 5)
231 var nodeIds []*entities.NbIdentity = nil
232 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
233 readerMock.On("GetListNodebIds").Return(nodeIds, mockErr)
235 res, err := rnibDataService.GetListNodebIds()
236 readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 5)
237 assert.True(t, strings.Contains(err.Error(), "connection error"))
238 assert.Equal(t, nodeIds, res)
241 func TestGetGeneralConfigurationConnFailure(t *testing.T) {
242 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
244 var config *entities.GeneralConfiguration = nil
245 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
246 readerMock.On("GetGeneralConfiguration").Return(config, mockErr)
248 res, err := rnibDataService.GetGeneralConfiguration()
249 readerMock.AssertNumberOfCalls(t, "GetGeneralConfiguration", 3)
251 assert.NotNil(t, err)
254 func TestGetGeneralConfigurationOkNoError(t *testing.T) {
255 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
257 config := &entities.GeneralConfiguration{}
258 readerMock.On("GetGeneralConfiguration").Return(config, nil)
260 res, err := rnibDataService.GetGeneralConfiguration()
261 readerMock.AssertNumberOfCalls(t, "GetGeneralConfiguration", 1)
262 assert.Equal(t, config, res)
266 func TestGetGeneralConfigurationOtherError(t *testing.T) {
267 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
269 var config *entities.GeneralConfiguration = nil
270 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
271 readerMock.On("GetGeneralConfiguration").Return(config, mockErr)
273 res, err := rnibDataService.GetGeneralConfiguration()
274 readerMock.AssertNumberOfCalls(t, "GetGeneralConfiguration", 1)
276 assert.NotNil(t, err)
279 func TestSaveGeneralConfigurationConnFailure(t *testing.T) {
280 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
282 config := &entities.GeneralConfiguration{}
283 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
284 writerMock.On("SaveGeneralConfiguration", config).Return(mockErr)
286 err := rnibDataService.SaveGeneralConfiguration(config)
287 writerMock.AssertNumberOfCalls(t, "SaveGeneralConfiguration", 3)
288 assert.NotNil(t, err)
291 func TestSaveGeneralConfigurationOkNoError(t *testing.T) {
292 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
294 config := &entities.GeneralConfiguration{}
295 writerMock.On("SaveGeneralConfiguration", config).Return(nil)
297 err := rnibDataService.SaveGeneralConfiguration(config)
298 writerMock.AssertNumberOfCalls(t, "SaveGeneralConfiguration", 1)
302 func TestSaveGeneralConfigurationOtherError(t *testing.T) {
303 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
305 config := &entities.GeneralConfiguration{}
306 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
307 writerMock.On("SaveGeneralConfiguration", config).Return(mockErr)
309 err := rnibDataService.SaveGeneralConfiguration(config)
310 writerMock.AssertNumberOfCalls(t, "SaveGeneralConfiguration", 1)
311 assert.NotNil(t, err)
314 func TestRemoveServedCellsConnFailure(t *testing.T) {
315 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
317 var ranName string = "abcd"
318 cellIds := []*entities.ServedCellInfo{}
319 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
320 writerMock.On("RemoveServedCells", ranName, cellIds).Return(mockErr)
322 err := rnibDataService.RemoveServedCells(ranName, cellIds)
323 writerMock.AssertNumberOfCalls(t, "RemoveServedCells", 3)
324 assert.NotNil(t, err)
327 func TestRemoveServedCellsOkNoError(t *testing.T) {
328 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
330 var ranName string = "abcd"
331 cellIds := []*entities.ServedCellInfo{}
332 writerMock.On("RemoveServedCells", ranName, cellIds).Return(nil)
334 err := rnibDataService.RemoveServedCells(ranName, cellIds)
335 writerMock.AssertNumberOfCalls(t, "RemoveServedCells", 1)
339 func TestRemoveServedCellsOtherError(t *testing.T) {
340 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
342 var ranName string = "abcd"
343 cellIds := []*entities.ServedCellInfo{}
344 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
345 writerMock.On("RemoveServedCells", ranName, cellIds).Return(mockErr)
347 err := rnibDataService.RemoveServedCells(ranName, cellIds)
348 writerMock.AssertNumberOfCalls(t, "RemoveServedCells", 1)
349 assert.NotNil(t, err)
352 func TestUpdateEnbConnFailure(t *testing.T) {
353 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
355 nodebInfo := &entities.NodebInfo{}
356 cellIds := []*entities.ServedCellInfo{}
357 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
358 writerMock.On("UpdateEnb", nodebInfo, cellIds).Return(mockErr)
360 err := rnibDataService.UpdateEnb(nodebInfo, cellIds)
361 writerMock.AssertNumberOfCalls(t, "UpdateEnb", 3)
362 assert.NotNil(t, err)
365 func TestUpdateEnbOkNoError(t *testing.T) {
366 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
368 nodebInfo := &entities.NodebInfo{}
369 cellIds := []*entities.ServedCellInfo{}
370 writerMock.On("UpdateEnb", nodebInfo, cellIds).Return(nil)
372 err := rnibDataService.UpdateEnb(nodebInfo, cellIds)
373 writerMock.AssertNumberOfCalls(t, "UpdateEnb", 1)
377 func TestUpdateEnbOtherError(t *testing.T) {
378 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
380 nodebInfo := &entities.NodebInfo{}
381 cellIds := []*entities.ServedCellInfo{}
382 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
383 writerMock.On("UpdateEnb", nodebInfo, cellIds).Return(mockErr)
385 err := rnibDataService.UpdateEnb(nodebInfo, cellIds)
386 writerMock.AssertNumberOfCalls(t, "UpdateEnb", 1)
387 assert.NotNil(t, err)
390 func TestAddEnbConnFailure(t *testing.T) {
391 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
393 nodebInfo := &entities.NodebInfo{}
394 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
395 writerMock.On("AddEnb", nodebInfo).Return(mockErr)
397 err := rnibDataService.AddEnb(nodebInfo)
398 writerMock.AssertNumberOfCalls(t, "AddEnb", 3)
399 assert.NotNil(t, err)
402 func TestAddEnbOkNoError(t *testing.T) {
403 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
405 nodebInfo := &entities.NodebInfo{}
406 writerMock.On("AddEnb", nodebInfo).Return(nil)
408 err := rnibDataService.AddEnb(nodebInfo)
409 writerMock.AssertNumberOfCalls(t, "AddEnb", 1)
413 func TestAddEnbOtherError(t *testing.T) {
414 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
416 nodebInfo := &entities.NodebInfo{}
417 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
418 writerMock.On("AddEnb", nodebInfo).Return(mockErr)
420 err := rnibDataService.AddEnb(nodebInfo)
421 writerMock.AssertNumberOfCalls(t, "AddEnb", 1)
422 assert.NotNil(t, err)
425 func TestUpdateNbIdentityConnFailure(t *testing.T) {
426 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
428 gnbType := entities.Node_GNB
429 oldNodeId := &entities.NbIdentity{}
430 newNodeId := &entities.NbIdentity{}
431 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
432 writerMock.On("UpdateNbIdentities", gnbType, []*entities.NbIdentity{oldNodeId},
433 []*entities.NbIdentity{newNodeId}).Return(mockErr)
435 err := rnibDataService.UpdateNbIdentity(gnbType, oldNodeId, newNodeId)
436 writerMock.AssertNumberOfCalls(t, "UpdateNbIdentities", 3)
437 assert.NotNil(t, err)
440 func TestUpdateNbIdentityOkNoError(t *testing.T) {
441 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
443 gnbType := entities.Node_GNB
444 oldNodeId := &entities.NbIdentity{}
445 newNodeId := &entities.NbIdentity{}
446 writerMock.On("UpdateNbIdentities", gnbType, []*entities.NbIdentity{oldNodeId},
447 []*entities.NbIdentity{newNodeId}).Return(nil)
449 err := rnibDataService.UpdateNbIdentity(gnbType, oldNodeId, newNodeId)
450 writerMock.AssertNumberOfCalls(t, "UpdateNbIdentities", 1)
454 func TestUpdateNbIdentityOtherError(t *testing.T) {
455 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
457 gnbType := entities.Node_GNB
458 oldNodeId := &entities.NbIdentity{}
459 newNodeId := &entities.NbIdentity{}
460 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
461 writerMock.On("UpdateNbIdentities", gnbType, []*entities.NbIdentity{oldNodeId},
462 []*entities.NbIdentity{newNodeId}).Return(mockErr)
464 err := rnibDataService.UpdateNbIdentity(gnbType, oldNodeId, newNodeId)
465 writerMock.AssertNumberOfCalls(t, "UpdateNbIdentities", 1)
466 assert.NotNil(t, err)
469 func TestUpdateNbIdentitiesConnFailure(t *testing.T) {
470 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
472 gnbType := entities.Node_GNB
473 oldNodeIds := []*entities.NbIdentity{}
474 newNodeIds := []*entities.NbIdentity{}
475 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
476 writerMock.On("UpdateNbIdentities", gnbType, oldNodeIds, newNodeIds).Return(mockErr)
478 err := rnibDataService.UpdateNbIdentities(gnbType, oldNodeIds, newNodeIds)
479 writerMock.AssertNumberOfCalls(t, "UpdateNbIdentities", 3)
480 assert.NotNil(t, err)
483 func TestUpdateNbIdentitiesOkNoError(t *testing.T) {
484 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
486 gnbType := entities.Node_GNB
487 oldNodeIds := []*entities.NbIdentity{}
488 newNodeIds := []*entities.NbIdentity{}
489 writerMock.On("UpdateNbIdentities", gnbType, oldNodeIds, newNodeIds).Return(nil)
491 err := rnibDataService.UpdateNbIdentities(gnbType, oldNodeIds, newNodeIds)
492 writerMock.AssertNumberOfCalls(t, "UpdateNbIdentities", 1)
496 func TestUpdateNbIdentitiesOtherError(t *testing.T) {
497 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
499 gnbType := entities.Node_GNB
500 oldNodeIds := []*entities.NbIdentity{}
501 newNodeIds := []*entities.NbIdentity{}
502 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
503 writerMock.On("UpdateNbIdentities", gnbType, oldNodeIds, newNodeIds).Return(mockErr)
505 err := rnibDataService.UpdateNbIdentities(gnbType, oldNodeIds, newNodeIds)
506 writerMock.AssertNumberOfCalls(t, "UpdateNbIdentities", 1)
507 assert.NotNil(t, err)
510 func TestPingRnibConnFailure(t *testing.T) {
511 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
513 var nodeIds []*entities.NbIdentity = nil
514 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
515 readerMock.On("GetListNodebIds").Return(nodeIds, mockErr)
517 res := rnibDataService.PingRnib()
518 readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 3)
522 func TestPingRnibOkNoError(t *testing.T) {
523 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
525 var nodeIds []*entities.NbIdentity = nil
526 readerMock.On("GetListNodebIds").Return(nodeIds, nil)
528 res := rnibDataService.PingRnib()
529 readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 1)
533 func TestPingRnibOkOtherError(t *testing.T) {
534 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
536 var nodeIds []*entities.NbIdentity = nil
537 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
538 readerMock.On("GetListNodebIds").Return(nodeIds, mockErr)
540 res := rnibDataService.PingRnib()
541 readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 1)
545 func TestSuccessfulUpdateNodebInfoOnConnectionStatusInversion(t *testing.T) {
546 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
549 nodebInfo := &entities.NodebInfo{}
550 writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", nodebInfo, event).Return(nil)
552 rnibDataService.UpdateNodebInfoOnConnectionStatusInversion(nodebInfo, event)
553 writerMock.AssertNumberOfCalls(t, "UpdateNodebInfoOnConnectionStatusInversion", 1)
556 func TestConnFailureUpdateNodebInfoOnConnectionStatusInversion(t *testing.T) {
557 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
560 nodebInfo := &entities.NodebInfo{}
561 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
562 writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", nodebInfo, event).Return(mockErr)
564 rnibDataService.UpdateNodebInfoOnConnectionStatusInversion(nodebInfo, event)
565 writerMock.AssertNumberOfCalls(t, "UpdateNodebInfoOnConnectionStatusInversion", 3)
568 func TestGetE2TInstanceConnFailure(t *testing.T) {
569 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
571 address := "10.10.5.20:3200"
572 var e2tInstance *entities.E2TInstance = nil
573 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
574 readerMock.On("GetE2TInstance", address).Return(e2tInstance, mockErr)
576 res, err := rnibDataService.GetE2TInstance(address)
577 readerMock.AssertNumberOfCalls(t, "GetE2TInstance", 3)
579 assert.NotNil(t, err)
582 func TestGetE2TInstanceOkNoError(t *testing.T) {
583 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
585 address := "10.10.5.20:3200"
586 e2tInstance := &entities.E2TInstance{}
587 readerMock.On("GetE2TInstance", address).Return(e2tInstance, nil)
589 res, err := rnibDataService.GetE2TInstance(address)
590 readerMock.AssertNumberOfCalls(t, "GetE2TInstance", 1)
592 assert.Equal(t, e2tInstance, res)
595 func TestGetE2TInstanceOtherError(t *testing.T) {
596 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
598 address := "10.10.5.20:3200"
599 var e2tInstance *entities.E2TInstance = nil
600 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
601 readerMock.On("GetE2TInstance", address).Return(e2tInstance, mockErr)
603 res, err := rnibDataService.GetE2TInstance(address)
604 readerMock.AssertNumberOfCalls(t, "GetE2TInstance", 1)
606 assert.NotNil(t, err)
609 func TestGetE2TInstanceNoLogsConnFailure(t *testing.T) {
610 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
612 address := "10.10.5.20:3200"
613 var e2tInstance *entities.E2TInstance = nil
614 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
615 readerMock.On("GetE2TInstance", address).Return(e2tInstance, mockErr)
617 res, err := rnibDataService.GetE2TInstanceNoLogs(address)
618 readerMock.AssertNumberOfCalls(t, "GetE2TInstance", 3)
620 assert.NotNil(t, err)
623 func TestGetE2TInstanceNoLogsOkNoError(t *testing.T) {
624 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
626 address := "10.10.5.20:3200"
627 e2tInstance := &entities.E2TInstance{}
628 readerMock.On("GetE2TInstance", address).Return(e2tInstance, nil)
630 res, err := rnibDataService.GetE2TInstanceNoLogs(address)
631 readerMock.AssertNumberOfCalls(t, "GetE2TInstance", 1)
633 assert.Equal(t, e2tInstance, res)
636 func TestGetE2TInstanceNoLogsOtherError(t *testing.T) {
637 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
639 address := "10.10.5.20:3200"
640 var e2tInstance *entities.E2TInstance = nil
641 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
642 readerMock.On("GetE2TInstance", address).Return(e2tInstance, mockErr)
644 res, err := rnibDataService.GetE2TInstanceNoLogs(address)
645 readerMock.AssertNumberOfCalls(t, "GetE2TInstance", 1)
647 assert.NotNil(t, err)
650 func TestGetE2TInstancesConnFailure(t *testing.T) {
651 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
653 addresses := []string{"10.10.5.20:3200", "10.10.5.21:3200"}
654 var e2tInstances []*entities.E2TInstance = nil
655 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
656 readerMock.On("GetE2TInstances", addresses).Return(e2tInstances, mockErr)
658 res, err := rnibDataService.GetE2TInstances(addresses)
659 readerMock.AssertNumberOfCalls(t, "GetE2TInstances", 3)
661 assert.NotNil(t, err)
664 func TestGetE2TInstancesOkNoError(t *testing.T) {
665 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
667 addresses := []string{"10.10.5.20:3200", "10.10.5.21:3200"}
668 e2tInstance := []*entities.E2TInstance{}
669 readerMock.On("GetE2TInstances", addresses).Return(e2tInstance, nil)
671 res, err := rnibDataService.GetE2TInstances(addresses)
672 readerMock.AssertNumberOfCalls(t, "GetE2TInstances", 1)
674 assert.Equal(t, e2tInstance, res)
677 func TestGetE2TInstancesOtherError(t *testing.T) {
678 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
680 addresses := []string{"10.10.5.20:3200", "10.10.5.21:3200"}
681 var e2tInstances []*entities.E2TInstance = nil
682 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
683 readerMock.On("GetE2TInstances", addresses).Return(e2tInstances, mockErr)
685 res, err := rnibDataService.GetE2TInstances(addresses)
686 readerMock.AssertNumberOfCalls(t, "GetE2TInstances", 1)
688 assert.NotNil(t, err)
691 func TestGetE2TInstancesNoLogsConnFailure(t *testing.T) {
692 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
694 addresses := []string{"10.10.5.20:3200", "10.10.5.21:3200"}
695 var e2tInstances []*entities.E2TInstance = nil
696 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
697 readerMock.On("GetE2TInstances", addresses).Return(e2tInstances, mockErr)
699 res, err := rnibDataService.GetE2TInstancesNoLogs(addresses)
700 readerMock.AssertNumberOfCalls(t, "GetE2TInstances", 3)
702 assert.NotNil(t, err)
705 func TestGetE2TInstancesNoLogsOkNoError(t *testing.T) {
706 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
708 addresses := []string{"10.10.5.20:3200", "10.10.5.21:3200"}
709 e2tInstance := []*entities.E2TInstance{}
710 readerMock.On("GetE2TInstances", addresses).Return(e2tInstance, nil)
712 res, err := rnibDataService.GetE2TInstancesNoLogs(addresses)
713 readerMock.AssertNumberOfCalls(t, "GetE2TInstances", 1)
715 assert.Equal(t, e2tInstance, res)
718 func TestGetE2TInstancesNoLogsOtherError(t *testing.T) {
719 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
721 addresses := []string{"10.10.5.20:3200", "10.10.5.21:3200"}
722 var e2tInstances []*entities.E2TInstance = nil
723 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
724 readerMock.On("GetE2TInstances", addresses).Return(e2tInstances, mockErr)
726 res, err := rnibDataService.GetE2TInstancesNoLogs(addresses)
727 readerMock.AssertNumberOfCalls(t, "GetE2TInstances", 1)
729 assert.NotNil(t, err)
732 func TestGetE2TAddressesConnFailure(t *testing.T) {
733 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
735 var addresses []string = nil
736 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
737 readerMock.On("GetE2TAddresses").Return(addresses, mockErr)
739 res, err := rnibDataService.GetE2TAddresses()
740 readerMock.AssertNumberOfCalls(t, "GetE2TAddresses", 3)
742 assert.NotNil(t, err)
745 func TestGetE2TAddressesOkNoError(t *testing.T) {
746 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
748 addresses := []string{"10.10.5.20:3200", "10.10.5.21:3200"}
749 readerMock.On("GetE2TAddresses").Return(addresses, nil)
751 res, err := rnibDataService.GetE2TAddresses()
752 readerMock.AssertNumberOfCalls(t, "GetE2TAddresses", 1)
754 assert.Equal(t, addresses, res)
757 func TestGetE2TAddressesOtherError(t *testing.T) {
758 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
760 var addresses []string = nil
761 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
762 readerMock.On("GetE2TAddresses").Return(addresses, mockErr)
764 res, err := rnibDataService.GetE2TAddresses()
765 readerMock.AssertNumberOfCalls(t, "GetE2TAddresses", 1)
767 assert.NotNil(t, err)
770 func TestGetE2TAddressesNoLogsConnFailure(t *testing.T) {
771 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
773 var addresses []string = nil
774 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
775 readerMock.On("GetE2TAddresses").Return(addresses, mockErr)
777 res, err := rnibDataService.GetE2TAddressesNoLogs()
778 readerMock.AssertNumberOfCalls(t, "GetE2TAddresses", 3)
780 assert.NotNil(t, err)
783 func TestGetE2TAddressesNoLogsOkNoError(t *testing.T) {
784 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
786 addresses := []string{"10.10.5.20:3200", "10.10.5.21:3200"}
787 readerMock.On("GetE2TAddresses").Return(addresses, nil)
789 res, err := rnibDataService.GetE2TAddressesNoLogs()
790 readerMock.AssertNumberOfCalls(t, "GetE2TAddresses", 1)
792 assert.Equal(t, addresses, res)
795 func TestGetE2TAddressesNoLogsOtherError(t *testing.T) {
796 rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
798 var addresses []string = nil
799 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
800 readerMock.On("GetE2TAddresses").Return(addresses, mockErr)
802 res, err := rnibDataService.GetE2TAddressesNoLogs()
803 readerMock.AssertNumberOfCalls(t, "GetE2TAddresses", 1)
805 assert.NotNil(t, err)
808 func TestSaveE2TInstanceConnFailure(t *testing.T) {
809 e2tInstance := &entities.E2TInstance{}
810 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
812 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
814 writerMock.On("SaveE2TInstance", e2tInstance).Return(mockErr)
816 err := rnibDataService.SaveE2TInstance(e2tInstance)
817 writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 3)
818 assert.NotNil(t, err)
821 func TestSaveE2TInstanceOkNoError(t *testing.T) {
822 e2tInstance := &entities.E2TInstance{}
823 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
825 writerMock.On("SaveE2TInstance", e2tInstance).Return(nil)
827 err := rnibDataService.SaveE2TInstance(e2tInstance)
828 writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 1)
832 func TestSaveE2TInstanceOtherError(t *testing.T) {
833 e2tInstance := &entities.E2TInstance{}
834 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
836 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
838 writerMock.On("SaveE2TInstance", e2tInstance).Return(mockErr)
840 err := rnibDataService.SaveE2TInstance(e2tInstance)
841 writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 1)
843 assert.NotNil(t, err)
846 func TestSaveE2TInstanceNoLogsConnFailure(t *testing.T) {
847 e2tInstance := &entities.E2TInstance{}
848 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
850 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
852 writerMock.On("SaveE2TInstance", e2tInstance).Return(mockErr)
854 err := rnibDataService.SaveE2TInstanceNoLogs(e2tInstance)
855 writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 3)
856 assert.NotNil(t, err)
859 func TestSaveE2TInstanceNoLogsOkNoError(t *testing.T) {
860 e2tInstance := &entities.E2TInstance{}
861 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
863 writerMock.On("SaveE2TInstance", e2tInstance).Return(nil)
865 err := rnibDataService.SaveE2TInstanceNoLogs(e2tInstance)
866 writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 1)
870 func TestSaveE2TInstanceNoLogsOtherError(t *testing.T) {
871 e2tInstance := &entities.E2TInstance{}
872 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
874 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
876 writerMock.On("SaveE2TInstance", e2tInstance).Return(mockErr)
878 err := rnibDataService.SaveE2TInstanceNoLogs(e2tInstance)
879 writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 1)
881 assert.NotNil(t, err)
884 func TestSaveE2TAddressesConnFailure(t *testing.T) {
885 addresses := []string{"10.10.5.20:3200", "10.10.5.21:3200"}
886 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
888 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
890 writerMock.On("SaveE2TAddresses", addresses).Return(mockErr)
892 err := rnibDataService.SaveE2TAddresses(addresses)
893 writerMock.AssertNumberOfCalls(t, "SaveE2TAddresses", 3)
894 assert.NotNil(t, err)
897 func TestSaveE2TAddressesOkNoError(t *testing.T) {
898 addresses := []string{"10.10.5.20:3200", "10.10.5.21:3200"}
899 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
901 writerMock.On("SaveE2TAddresses", addresses).Return(nil)
903 err := rnibDataService.SaveE2TAddresses(addresses)
904 writerMock.AssertNumberOfCalls(t, "SaveE2TAddresses", 1)
908 func TestSaveE2TAddressesOtherError(t *testing.T) {
909 addresses := []string{"10.10.5.20:3200", "10.10.5.21:3200"}
910 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
912 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
914 writerMock.On("SaveE2TAddresses", addresses).Return(mockErr)
916 err := rnibDataService.SaveE2TAddresses(addresses)
917 writerMock.AssertNumberOfCalls(t, "SaveE2TAddresses", 1)
919 assert.NotNil(t, err)
922 func TestRemoveE2TInstanceConnFailure(t *testing.T) {
923 address := "10.10.5.20:3200"
924 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
926 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
928 writerMock.On("RemoveE2TInstance", address).Return(mockErr)
930 err := rnibDataService.RemoveE2TInstance(address)
931 writerMock.AssertNumberOfCalls(t, "RemoveE2TInstance", 3)
932 assert.NotNil(t, err)
935 func TestRemoveE2TInstanceOkNoError(t *testing.T) {
936 address := "10.10.5.20:3200"
937 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
939 writerMock.On("RemoveE2TInstance", address).Return(nil)
941 err := rnibDataService.RemoveE2TInstance(address)
942 writerMock.AssertNumberOfCalls(t, "RemoveE2TInstance", 1)
946 func TestRemoveE2TInstanceOtherError(t *testing.T) {
947 address := "10.10.5.20:3200"
948 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
950 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
952 writerMock.On("RemoveE2TInstance", address).Return(mockErr)
954 err := rnibDataService.RemoveE2TInstance(address)
955 writerMock.AssertNumberOfCalls(t, "RemoveE2TInstance", 1)
957 assert.NotNil(t, err)
960 func TestAddNbIdentityConnFailure(t *testing.T) {
961 gnbType := entities.Node_GNB
962 nbIdentity := &entities.NbIdentity{}
963 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
965 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
967 writerMock.On("AddNbIdentity", gnbType, nbIdentity).Return(mockErr)
969 err := rnibDataService.AddNbIdentity(gnbType, nbIdentity)
970 writerMock.AssertNumberOfCalls(t, "AddNbIdentity", 3)
971 assert.NotNil(t, err)
974 func TestAddNbIdentityOkNoError(t *testing.T) {
975 gnbType := entities.Node_GNB
976 nbIdentity := &entities.NbIdentity{}
977 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
979 writerMock.On("AddNbIdentity", gnbType, nbIdentity).Return(nil)
981 err := rnibDataService.AddNbIdentity(gnbType, nbIdentity)
982 writerMock.AssertNumberOfCalls(t, "AddNbIdentity", 1)
986 func TestAddNbIdentityOtherError(t *testing.T) {
987 gnbType := entities.Node_GNB
988 nbIdentity := &entities.NbIdentity{}
989 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
991 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
993 writerMock.On("AddNbIdentity", gnbType, nbIdentity).Return(mockErr)
995 err := rnibDataService.AddNbIdentity(gnbType, nbIdentity)
996 writerMock.AssertNumberOfCalls(t, "AddNbIdentity", 1)
998 assert.NotNil(t, err)
1001 func TestRemoveNbIdentityConnFailure(t *testing.T) {
1002 gnbType := entities.Node_GNB
1003 nbIdentity := &entities.NbIdentity{}
1004 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
1006 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
1008 writerMock.On("RemoveNbIdentity", gnbType, nbIdentity).Return(mockErr)
1010 err := rnibDataService.RemoveNbIdentity(gnbType, nbIdentity)
1011 writerMock.AssertNumberOfCalls(t, "RemoveNbIdentity", 3)
1012 assert.NotNil(t, err)
1015 func TestRemoveNbIdentityOkNoError(t *testing.T) {
1016 gnbType := entities.Node_GNB
1017 nbIdentity := &entities.NbIdentity{}
1018 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
1020 writerMock.On("RemoveNbIdentity", gnbType, nbIdentity).Return(nil)
1022 err := rnibDataService.RemoveNbIdentity(gnbType, nbIdentity)
1023 writerMock.AssertNumberOfCalls(t, "RemoveNbIdentity", 1)
1027 func TestRemoveNbIdentityOtherError(t *testing.T) {
1028 gnbType := entities.Node_GNB
1029 nbIdentity := &entities.NbIdentity{}
1030 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
1032 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
1034 writerMock.On("RemoveNbIdentity", gnbType, nbIdentity).Return(mockErr)
1036 err := rnibDataService.RemoveNbIdentity(gnbType, nbIdentity)
1037 writerMock.AssertNumberOfCalls(t, "RemoveNbIdentity", 1)
1038 assert.NotNil(t, err)
1041 func TestRemoveServedNrCellsConnFailure(t *testing.T) {
1042 var ranName string = "abcd"
1043 var servedNrCells []*entities.ServedNRCell
1044 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
1046 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
1048 writerMock.On("RemoveServedNrCells", ranName, servedNrCells).Return(mockErr)
1050 err := rnibDataService.RemoveServedNrCells(ranName, servedNrCells)
1051 writerMock.AssertNumberOfCalls(t, "RemoveServedNrCells", 3)
1052 assert.NotNil(t, err)
1055 func TestRemoveServedNrCellsOkNoError(t *testing.T) {
1056 var ranName string = "abcd"
1057 var servedNrCells []*entities.ServedNRCell
1058 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
1060 writerMock.On("RemoveServedNrCells", ranName, servedNrCells).Return(nil)
1062 err := rnibDataService.RemoveServedNrCells(ranName, servedNrCells)
1063 writerMock.AssertNumberOfCalls(t, "RemoveServedNrCells", 1)
1067 func TestRemoveServedNrCellsOtherError(t *testing.T) {
1068 var ranName string = "abcd"
1069 var servedNrCells []*entities.ServedNRCell
1070 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
1072 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
1074 writerMock.On("RemoveServedNrCells", ranName, servedNrCells).Return(mockErr)
1076 err := rnibDataService.RemoveServedNrCells(ranName, servedNrCells)
1077 writerMock.AssertNumberOfCalls(t, "RemoveServedNrCells", 1)
1078 assert.NotNil(t, err)
1081 func TestRemoveEnbConnFailure(t *testing.T) {
1082 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
1084 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
1085 nodebInfo := &entities.NodebInfo{}
1086 writerMock.On("RemoveEnb", nodebInfo).Return(mockErr)
1088 err := rnibDataService.RemoveEnb(nodebInfo)
1089 writerMock.AssertNumberOfCalls(t, "RemoveEnb", 3)
1090 assert.NotNil(t, err)
1093 func TestRemoveEnbOkNoError(t *testing.T) {
1094 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
1096 nodebInfo := &entities.NodebInfo{}
1097 writerMock.On("RemoveEnb", nodebInfo).Return(nil)
1099 err := rnibDataService.RemoveEnb(nodebInfo)
1100 writerMock.AssertNumberOfCalls(t, "RemoveEnb", 1)
1104 func TestRemoveEnbOtherError(t *testing.T) {
1105 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
1107 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
1108 nodebInfo := &entities.NodebInfo{}
1109 writerMock.On("RemoveEnb", nodebInfo).Return(mockErr)
1111 err := rnibDataService.RemoveEnb(nodebInfo)
1112 writerMock.AssertNumberOfCalls(t, "RemoveEnb", 1)
1113 assert.NotNil(t, err)
1116 func TestUpdateGnbCellsConnFailure(t *testing.T) {
1117 var servedNrCells []*entities.ServedNRCell
1118 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
1120 mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
1121 nodebInfo := &entities.NodebInfo{}
1122 writerMock.On("UpdateGnbCells", nodebInfo, servedNrCells).Return(mockErr)
1124 err := rnibDataService.UpdateGnbCells(nodebInfo, servedNrCells)
1125 writerMock.AssertNumberOfCalls(t, "UpdateGnbCells", 3)
1126 assert.NotNil(t, err)
1129 func TestUpdateGnbCellsOkNoError(t *testing.T) {
1130 var servedNrCells []*entities.ServedNRCell
1131 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
1133 nodebInfo := &entities.NodebInfo{}
1134 writerMock.On("UpdateGnbCells", nodebInfo, servedNrCells).Return(nil)
1136 err := rnibDataService.UpdateGnbCells(nodebInfo, servedNrCells)
1137 writerMock.AssertNumberOfCalls(t, "UpdateGnbCells", 1)
1141 func TestUpdateGnbCellsOtherError(t *testing.T) {
1142 var servedNrCells []*entities.ServedNRCell
1143 rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
1145 mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
1146 nodebInfo := &entities.NodebInfo{}
1147 writerMock.On("UpdateGnbCells", nodebInfo, servedNrCells).Return(mockErr)
1149 err := rnibDataService.UpdateGnbCells(nodebInfo, servedNrCells)
1150 writerMock.AssertNumberOfCalls(t, "UpdateGnbCells", 1)
1151 assert.NotNil(t, err)