E2Manager/services/rnib_data_service_test.go

   1 //
   2 // Copyright 2019 AT&T Intellectual Property
   3 // Copyright 2019 Nokia
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the "License");
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //      http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16
  17 //  This source code is part of the near-RT RIC (RAN Intelligent Controller)
  18 //  platform project (RICP).
  19
  20 package services
  21
  22 import (
  23         "e2mgr/configuration"
  24         "e2mgr/logger"
  25         "e2mgr/mocks"
  26         "fmt"
  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"
  30         "net"
  31         "strings"
  32         "testing"
  33 )
  34
  35 func setupRnibDataServiceTest(t *testing.T) (*rNibDataService, *mocks.RnibReaderMock, *mocks.RnibWriterMock) {
  36         return setupRnibDataServiceTestWithMaxAttempts(t, 3)
  37 }
  38
  39 func setupRnibDataServiceTestWithMaxAttempts(t *testing.T, maxAttempts int) (*rNibDataService, *mocks.RnibReaderMock, *mocks.RnibWriterMock) {
  40         logger, err := logger.InitLogger(logger.DebugLevel)
  41         if err != nil {
  42                 t.Errorf("#... - failed to initialize logger, error: %s", err)
  43         }
  44
  45         config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: maxAttempts, RnibWriter: configuration.RnibWriterConfig{RanManipulationMessageChannel: "RAN_MANIPULATION", StateChangeMessageChannel: "RAN_CONNECTION_STATUS_CHANGE"}}
  46
  47         readerMock := &mocks.RnibReaderMock{}
  48
  49         writerMock := &mocks.RnibWriterMock{}
  50
  51         rnibDataService := NewRnibDataService(logger, config, readerMock, writerMock)
  52         assert.NotNil(t, rnibDataService)
  53
  54         return rnibDataService, readerMock, writerMock
  55 }
  56
  57 func TestSuccessfulSaveNodeb(t *testing.T) {
  58         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
  59
  60         nodebInfo := &entities.NodebInfo{}
  61         writerMock.On("SaveNodeb", nodebInfo).Return(nil)
  62
  63         rnibDataService.SaveNodeb(nodebInfo)
  64         writerMock.AssertNumberOfCalls(t, "SaveNodeb", 1)
  65 }
  66
  67 func TestConnFailureSaveNodeb(t *testing.T) {
  68         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
  69
  70         nodebInfo := &entities.NodebInfo{}
  71         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
  72         writerMock.On("SaveNodeb", nodebInfo).Return(mockErr)
  73
  74         rnibDataService.SaveNodeb(nodebInfo)
  75         writerMock.AssertNumberOfCalls(t, "SaveNodeb", 3)
  76 }
  77
  78 func TestNonConnFailureSaveNodeb(t *testing.T) {
  79         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
  80
  81         nodebInfo := &entities.NodebInfo{}
  82         mockErr := &common.InternalError{Err: fmt.Errorf("non connection failure")}
  83         writerMock.On("SaveNodeb", nodebInfo).Return(mockErr)
  84
  85         rnibDataService.SaveNodeb(nodebInfo)
  86         writerMock.AssertNumberOfCalls(t, "SaveNodeb", 1)
  87 }
  88
  89 func TestSuccessfulUpdateNodebInfo(t *testing.T) {
  90         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
  91
  92         nodebInfo := &entities.NodebInfo{}
  93         writerMock.On("UpdateNodebInfo", nodebInfo).Return(nil)
  94
  95         rnibDataService.UpdateNodebInfo(nodebInfo)
  96         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 1)
  97 }
  98
  99 func TestConnFailureUpdateNodebInfo(t *testing.T) {
 100         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 101
 102         nodebInfo := &entities.NodebInfo{}
 103         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 104         writerMock.On("UpdateNodebInfo", nodebInfo).Return(mockErr)
 105
 106         rnibDataService.UpdateNodebInfo(nodebInfo)
 107         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 3)
 108 }
 109
 110 func TestSuccessfulUpdateNodebInfoAndPublish(t *testing.T) {
 111         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 112
 113         nodebInfo := &entities.NodebInfo{}
 114         writerMock.On("UpdateNodebInfoAndPublish", nodebInfo).Return(nil)
 115
 116         rnibDataService.UpdateNodebInfoAndPublish(nodebInfo)
 117         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfoAndPublish", 1)
 118 }
 119
 120 func TestConnFailureUpdateNodebInfoAndPublish(t *testing.T) {
 121         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 122
 123         nodebInfo := &entities.NodebInfo{}
 124         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 125         writerMock.On("UpdateNodebInfoAndPublish", nodebInfo).Return(mockErr)
 126
 127         rnibDataService.UpdateNodebInfoAndPublish(nodebInfo)
 128         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfoAndPublish", 3)
 129 }
 130
 131 func TestSuccessfulSaveRanLoadInformation(t *testing.T) {
 132         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 133
 134         var ranName string = "abcd"
 135         ranLoadInformation := &entities.RanLoadInformation{}
 136         writerMock.On("SaveRanLoadInformation", ranName, ranLoadInformation).Return(nil)
 137
 138         rnibDataService.SaveRanLoadInformation(ranName, ranLoadInformation)
 139         writerMock.AssertNumberOfCalls(t, "SaveRanLoadInformation", 1)
 140 }
 141
 142 func TestConnFailureSaveRanLoadInformation(t *testing.T) {
 143         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 144
 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)
 149
 150         rnibDataService.SaveRanLoadInformation(ranName, ranLoadInformation)
 151         writerMock.AssertNumberOfCalls(t, "SaveRanLoadInformation", 3)
 152 }
 153
 154 func TestSuccessfulGetNodeb(t *testing.T) {
 155         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 156
 157         invName := "abcd"
 158         nodebInfo := &entities.NodebInfo{}
 159         readerMock.On("GetNodeb", invName).Return(nodebInfo, nil)
 160
 161         res, err := rnibDataService.GetNodeb(invName)
 162         readerMock.AssertNumberOfCalls(t, "GetNodeb", 1)
 163         assert.Equal(t, nodebInfo, res)
 164         assert.Nil(t, err)
 165 }
 166
 167 func TestConnFailureGetNodeb(t *testing.T) {
 168         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 169
 170         invName := "abcd"
 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)
 174
 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)
 179 }
 180
 181 func TestSuccessfulGetNodebIdList(t *testing.T) {
 182         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 183
 184         nodeIds := []*entities.NbIdentity{}
 185         readerMock.On("GetListNodebIds").Return(nodeIds, nil)
 186
 187         res, err := rnibDataService.GetListNodebIds()
 188         readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 1)
 189         assert.Equal(t, nodeIds, res)
 190         assert.Nil(t, err)
 191 }
 192
 193 func TestConnFailureGetNodebIdList(t *testing.T) {
 194         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 195
 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)
 199
 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)
 204 }
 205
 206 func TestConnFailureTwiceGetNodebIdList(t *testing.T) {
 207         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 208
 209         invName := "abcd"
 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)
 215
 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)
 220
 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)
 225 }
 226
 227 func TestConnFailureWithAnotherConfig(t *testing.T) {
 228         rnibDataService, readerMock, _ := setupRnibDataServiceTestWithMaxAttempts(t, 5)
 229
 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)
 233
 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)
 238 }
 239
 240 func TestGetGeneralConfigurationConnFailure(t *testing.T) {
 241         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 242
 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)
 246
 247         res, err := rnibDataService.GetGeneralConfiguration()
 248         readerMock.AssertNumberOfCalls(t, "GetGeneralConfiguration", 3)
 249         assert.Nil(t, res)
 250         assert.NotNil(t, err)
 251 }
 252
 253 func TestGetGeneralConfigurationOkNoError(t *testing.T) {
 254         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 255
 256         config := &entities.GeneralConfiguration{}
 257         readerMock.On("GetGeneralConfiguration").Return(config, nil)
 258
 259         res, err := rnibDataService.GetGeneralConfiguration()
 260         readerMock.AssertNumberOfCalls(t, "GetGeneralConfiguration", 1)
 261         assert.Equal(t, config, res)
 262         assert.Nil(t, err)
 263 }
 264
 265 func TestGetGeneralConfigurationOtherError(t *testing.T) {
 266         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 267
 268         var config *entities.GeneralConfiguration = nil
 269         mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
 270         readerMock.On("GetGeneralConfiguration").Return(config, mockErr)
 271
 272         res, err := rnibDataService.GetGeneralConfiguration()
 273         readerMock.AssertNumberOfCalls(t, "GetGeneralConfiguration", 1)
 274         assert.Nil(t, res)
 275         assert.NotNil(t, err)
 276 }
 277
 278 func TestSaveGeneralConfigurationConnFailure(t *testing.T) {
 279         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 280
 281         config := &entities.GeneralConfiguration{}
 282         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 283         writerMock.On("SaveGeneralConfiguration", config).Return(mockErr)
 284
 285         err := rnibDataService.SaveGeneralConfiguration(config)
 286         writerMock.AssertNumberOfCalls(t, "SaveGeneralConfiguration", 3)
 287         assert.NotNil(t, err)
 288 }
 289
 290 func TestSaveGeneralConfigurationOkNoError(t *testing.T) {
 291         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 292
 293         config := &entities.GeneralConfiguration{}
 294         writerMock.On("SaveGeneralConfiguration", config).Return(nil)
 295
 296         err := rnibDataService.SaveGeneralConfiguration(config)
 297         writerMock.AssertNumberOfCalls(t, "SaveGeneralConfiguration", 1)
 298         assert.Nil(t, err)
 299 }
 300
 301 func TestSaveGeneralConfigurationOtherError(t *testing.T) {
 302         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 303
 304         config := &entities.GeneralConfiguration{}
 305         mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
 306         writerMock.On("SaveGeneralConfiguration", config).Return(mockErr)
 307
 308         err := rnibDataService.SaveGeneralConfiguration(config)
 309         writerMock.AssertNumberOfCalls(t, "SaveGeneralConfiguration", 1)
 310         assert.NotNil(t, err)
 311 }
 312
 313 func TestRemoveServedCellsConnFailure(t *testing.T) {
 314         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 315
 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)
 320
 321         err := rnibDataService.RemoveServedCells(ranName, cellIds)
 322         writerMock.AssertNumberOfCalls(t, "RemoveServedCells", 3)
 323         assert.NotNil(t, err)
 324 }
 325
 326 func TestRemoveServedCellsOkNoError(t *testing.T) {
 327         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 328
 329         var ranName string = "abcd"
 330         cellIds := []*entities.ServedCellInfo{}
 331         writerMock.On("RemoveServedCells", ranName, cellIds).Return(nil)
 332
 333         err := rnibDataService.RemoveServedCells(ranName, cellIds)
 334         writerMock.AssertNumberOfCalls(t, "RemoveServedCells", 1)
 335         assert.Nil(t, err)
 336 }
 337
 338 func TestRemoveServedCellsOtherError(t *testing.T) {
 339         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 340
 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)
 345
 346         err := rnibDataService.RemoveServedCells(ranName, cellIds)
 347         writerMock.AssertNumberOfCalls(t, "RemoveServedCells", 1)
 348         assert.NotNil(t, err)
 349 }
 350
 351 func TestUpdateEnbConnFailure(t *testing.T) {
 352         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 353
 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)
 358
 359         err := rnibDataService.UpdateEnb(nodebInfo, cellIds)
 360         writerMock.AssertNumberOfCalls(t, "UpdateEnb", 3)
 361         assert.NotNil(t, err)
 362 }
 363
 364 func TestUpdateEnbOkNoError(t *testing.T) {
 365         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 366
 367         nodebInfo := &entities.NodebInfo{}
 368         cellIds := []*entities.ServedCellInfo{}
 369         writerMock.On("UpdateEnb", nodebInfo, cellIds).Return(nil)
 370
 371         err := rnibDataService.UpdateEnb(nodebInfo, cellIds)
 372         writerMock.AssertNumberOfCalls(t, "UpdateEnb", 1)
 373         assert.Nil(t, err)
 374 }
 375
 376 func TestUpdateEnbOtherError(t *testing.T) {
 377         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 378
 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)
 383
 384         err := rnibDataService.UpdateEnb(nodebInfo, cellIds)
 385         writerMock.AssertNumberOfCalls(t, "UpdateEnb", 1)
 386         assert.NotNil(t, err)
 387 }
 388
 389 func TestAddEnbConnFailure(t *testing.T) {
 390         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 391
 392         nodebInfo := &entities.NodebInfo{}
 393         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 394         writerMock.On("AddEnb", nodebInfo).Return(mockErr)
 395
 396         err := rnibDataService.AddEnb(nodebInfo)
 397         writerMock.AssertNumberOfCalls(t, "AddEnb", 3)
 398         assert.NotNil(t, err)
 399 }
 400
 401 func TestAddEnbOkNoError(t *testing.T) {
 402         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 403
 404         nodebInfo := &entities.NodebInfo{}
 405         writerMock.On("AddEnb", nodebInfo).Return(nil)
 406
 407         err := rnibDataService.AddEnb(nodebInfo)
 408         writerMock.AssertNumberOfCalls(t, "AddEnb", 1)
 409         assert.Nil(t, err)
 410 }
 411
 412 func TestAddEnbOtherError(t *testing.T) {
 413         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 414
 415         nodebInfo := &entities.NodebInfo{}
 416         mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
 417         writerMock.On("AddEnb", nodebInfo).Return(mockErr)
 418
 419         err := rnibDataService.AddEnb(nodebInfo)
 420         writerMock.AssertNumberOfCalls(t, "AddEnb", 1)
 421         assert.NotNil(t, err)
 422 }
 423
 424 func TestUpdateNbIdentityConnFailure(t *testing.T) {
 425         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 426
 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)
 433
 434         err := rnibDataService.UpdateNbIdentity(gnbType, oldNodeId, newNodeId)
 435         writerMock.AssertNumberOfCalls(t, "UpdateNbIdentities", 3)
 436         assert.NotNil(t, err)
 437 }
 438
 439 func TestUpdateNbIdentityOkNoError(t *testing.T) {
 440         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 441
 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)
 447
 448         err := rnibDataService.UpdateNbIdentity(gnbType, oldNodeId, newNodeId)
 449         writerMock.AssertNumberOfCalls(t, "UpdateNbIdentities", 1)
 450         assert.Nil(t, err)
 451 }
 452
 453 func TestUpdateNbIdentityOtherError(t *testing.T) {
 454         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 455
 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)
 462
 463         err := rnibDataService.UpdateNbIdentity(gnbType, oldNodeId, newNodeId)
 464         writerMock.AssertNumberOfCalls(t, "UpdateNbIdentities", 1)
 465         assert.NotNil(t, err)
 466 }
 467
 468 func TestUpdateNbIdentitiesConnFailure(t *testing.T) {
 469         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 470
 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)
 476
 477         err := rnibDataService.UpdateNbIdentities(gnbType, oldNodeIds, newNodeIds)
 478         writerMock.AssertNumberOfCalls(t, "UpdateNbIdentities", 3)
 479         assert.NotNil(t, err)
 480 }
 481
 482 func TestUpdateNbIdentitiesOkNoError(t *testing.T) {
 483         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 484
 485         gnbType := entities.Node_GNB
 486         oldNodeIds := []*entities.NbIdentity{}
 487         newNodeIds := []*entities.NbIdentity{}
 488         writerMock.On("UpdateNbIdentities", gnbType, oldNodeIds, newNodeIds).Return(nil)
 489
 490         err := rnibDataService.UpdateNbIdentities(gnbType, oldNodeIds, newNodeIds)
 491         writerMock.AssertNumberOfCalls(t, "UpdateNbIdentities", 1)
 492         assert.Nil(t, err)
 493 }
 494
 495 func TestUpdateNbIdentitiesOtherError(t *testing.T) {
 496         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 497
 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)
 503
 504         err := rnibDataService.UpdateNbIdentities(gnbType, oldNodeIds, newNodeIds)
 505         writerMock.AssertNumberOfCalls(t, "UpdateNbIdentities", 1)
 506         assert.NotNil(t, err)
 507 }
 508
 509 func TestPingRnibConnFailure(t *testing.T) {
 510         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 511
 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)
 515
 516         res := rnibDataService.PingRnib()
 517         readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 3)
 518         assert.False(t, res)
 519 }
 520
 521 func TestPingRnibOkNoError(t *testing.T) {
 522         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 523
 524         var nodeIds []*entities.NbIdentity = nil
 525         readerMock.On("GetListNodebIds").Return(nodeIds, nil)
 526
 527         res := rnibDataService.PingRnib()
 528         readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 1)
 529         assert.True(t, res)
 530 }
 531
 532 func TestPingRnibOkOtherError(t *testing.T) {
 533         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 534
 535         var nodeIds []*entities.NbIdentity = nil
 536         mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
 537         readerMock.On("GetListNodebIds").Return(nodeIds, mockErr)
 538
 539         res := rnibDataService.PingRnib()
 540         readerMock.AssertNumberOfCalls(t, "GetListNodebIds", 1)
 541         assert.True(t, res)
 542 }
 543
 544 func TestSuccessfulUpdateNodebInfoOnConnectionStatusInversion(t *testing.T) {
 545         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 546         event := "event"
 547
 548         nodebInfo := &entities.NodebInfo{}
 549         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", nodebInfo, event).Return(nil)
 550
 551         rnibDataService.UpdateNodebInfoOnConnectionStatusInversion(nodebInfo, event)
 552         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfoOnConnectionStatusInversion", 1)
 553 }
 554
 555 func TestConnFailureUpdateNodebInfoOnConnectionStatusInversion(t *testing.T) {
 556         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 557         event := "event"
 558
 559         nodebInfo := &entities.NodebInfo{}
 560         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 561         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", nodebInfo, event).Return(mockErr)
 562
 563         rnibDataService.UpdateNodebInfoOnConnectionStatusInversion(nodebInfo, event)
 564         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfoOnConnectionStatusInversion", 3)
 565 }
 566
 567 func TestGetE2TInstanceConnFailure(t *testing.T) {
 568         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 569
 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)
 574
 575         res, err := rnibDataService.GetE2TInstance(address)
 576         readerMock.AssertNumberOfCalls(t, "GetE2TInstance", 3)
 577         assert.Nil(t, res)
 578         assert.NotNil(t, err)
 579 }
 580
 581 func TestGetE2TInstanceOkNoError(t *testing.T) {
 582         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 583
 584         address := "10.10.5.20:3200"
 585         e2tInstance := &entities.E2TInstance{}
 586         readerMock.On("GetE2TInstance", address).Return(e2tInstance, nil)
 587
 588         res, err := rnibDataService.GetE2TInstance(address)
 589         readerMock.AssertNumberOfCalls(t, "GetE2TInstance", 1)
 590         assert.Nil(t, err)
 591         assert.Equal(t, e2tInstance, res)
 592 }
 593
 594 func TestGetE2TInstanceOtherError(t *testing.T) {
 595         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 596
 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)
 601
 602         res, err := rnibDataService.GetE2TInstance(address)
 603         readerMock.AssertNumberOfCalls(t, "GetE2TInstance", 1)
 604         assert.Nil(t, res)
 605         assert.NotNil(t, err)
 606 }
 607
 608 func TestGetE2TInstanceNoLogsConnFailure(t *testing.T) {
 609         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 610
 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)
 615
 616         res, err := rnibDataService.GetE2TInstanceNoLogs(address)
 617         readerMock.AssertNumberOfCalls(t, "GetE2TInstance", 3)
 618         assert.Nil(t, res)
 619         assert.NotNil(t, err)
 620 }
 621
 622 func TestGetE2TInstanceNoLogsOkNoError(t *testing.T) {
 623         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 624
 625         address := "10.10.5.20:3200"
 626         e2tInstance := &entities.E2TInstance{}
 627         readerMock.On("GetE2TInstance", address).Return(e2tInstance, nil)
 628
 629         res, err := rnibDataService.GetE2TInstanceNoLogs(address)
 630         readerMock.AssertNumberOfCalls(t, "GetE2TInstance", 1)
 631         assert.Nil(t, err)
 632         assert.Equal(t, e2tInstance, res)
 633 }
 634
 635 func TestGetE2TInstanceNoLogsOtherError(t *testing.T) {
 636         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 637
 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)
 642
 643         res, err := rnibDataService.GetE2TInstanceNoLogs(address)
 644         readerMock.AssertNumberOfCalls(t, "GetE2TInstance", 1)
 645         assert.Nil(t, res)
 646         assert.NotNil(t, err)
 647 }
 648
 649 func TestGetE2TInstancesConnFailure(t *testing.T) {
 650         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 651
 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)
 656
 657         res, err := rnibDataService.GetE2TInstances(addresses)
 658         readerMock.AssertNumberOfCalls(t, "GetE2TInstances", 3)
 659         assert.Nil(t, res)
 660         assert.NotNil(t, err)
 661 }
 662
 663 func TestGetE2TInstancesOkNoError(t *testing.T) {
 664         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 665
 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)
 669
 670         res, err := rnibDataService.GetE2TInstances(addresses)
 671         readerMock.AssertNumberOfCalls(t, "GetE2TInstances", 1)
 672         assert.Nil(t, err)
 673         assert.Equal(t, e2tInstance, res)
 674 }
 675
 676 func TestGetE2TInstancesOtherError(t *testing.T) {
 677         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 678
 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)
 683
 684         res, err := rnibDataService.GetE2TInstances(addresses)
 685         readerMock.AssertNumberOfCalls(t, "GetE2TInstances", 1)
 686         assert.Nil(t, res)
 687         assert.NotNil(t, err)
 688 }
 689
 690 func TestGetE2TInstancesNoLogsConnFailure(t *testing.T) {
 691         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 692
 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)
 697
 698         res, err := rnibDataService.GetE2TInstancesNoLogs(addresses)
 699         readerMock.AssertNumberOfCalls(t, "GetE2TInstances", 3)
 700         assert.Nil(t, res)
 701         assert.NotNil(t, err)
 702 }
 703
 704 func TestGetE2TInstancesNoLogsOkNoError(t *testing.T) {
 705         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 706
 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)
 710
 711         res, err := rnibDataService.GetE2TInstancesNoLogs(addresses)
 712         readerMock.AssertNumberOfCalls(t, "GetE2TInstances", 1)
 713         assert.Nil(t, err)
 714         assert.Equal(t, e2tInstance, res)
 715 }
 716
 717 func TestGetE2TInstancesNoLogsOtherError(t *testing.T) {
 718         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 719
 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)
 724
 725         res, err := rnibDataService.GetE2TInstancesNoLogs(addresses)
 726         readerMock.AssertNumberOfCalls(t, "GetE2TInstances", 1)
 727         assert.Nil(t, res)
 728         assert.NotNil(t, err)
 729 }
 730
 731 func TestGetE2TAddressesConnFailure(t *testing.T) {
 732         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 733
 734         var addresses []string = nil
 735         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 736         readerMock.On("GetE2TAddresses").Return(addresses, mockErr)
 737
 738         res, err := rnibDataService.GetE2TAddresses()
 739         readerMock.AssertNumberOfCalls(t, "GetE2TAddresses", 3)
 740         assert.Nil(t, res)
 741         assert.NotNil(t, err)
 742 }
 743
 744 func TestGetE2TAddressesOkNoError(t *testing.T) {
 745         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 746
 747         addresses := []string{"10.10.5.20:3200", "10.10.5.21:3200"}
 748         readerMock.On("GetE2TAddresses").Return(addresses, nil)
 749
 750         res, err := rnibDataService.GetE2TAddresses()
 751         readerMock.AssertNumberOfCalls(t, "GetE2TAddresses", 1)
 752         assert.Nil(t, err)
 753         assert.Equal(t, addresses, res)
 754 }
 755
 756 func TestGetE2TAddressesOtherError(t *testing.T) {
 757         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 758
 759         var addresses []string = nil
 760         mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
 761         readerMock.On("GetE2TAddresses").Return(addresses, mockErr)
 762
 763         res, err := rnibDataService.GetE2TAddresses()
 764         readerMock.AssertNumberOfCalls(t, "GetE2TAddresses", 1)
 765         assert.Nil(t, res)
 766         assert.NotNil(t, err)
 767 }
 768
 769 func TestGetE2TAddressesNoLogsConnFailure(t *testing.T) {
 770         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 771
 772         var addresses []string = nil
 773         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 774         readerMock.On("GetE2TAddresses").Return(addresses, mockErr)
 775
 776         res, err := rnibDataService.GetE2TAddressesNoLogs()
 777         readerMock.AssertNumberOfCalls(t, "GetE2TAddresses", 3)
 778         assert.Nil(t, res)
 779         assert.NotNil(t, err)
 780 }
 781
 782 func TestGetE2TAddressesNoLogsOkNoError(t *testing.T) {
 783         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 784
 785         addresses := []string{"10.10.5.20:3200", "10.10.5.21:3200"}
 786         readerMock.On("GetE2TAddresses").Return(addresses, nil)
 787
 788         res, err := rnibDataService.GetE2TAddressesNoLogs()
 789         readerMock.AssertNumberOfCalls(t, "GetE2TAddresses", 1)
 790         assert.Nil(t, err)
 791         assert.Equal(t, addresses, res)
 792 }
 793
 794 func TestGetE2TAddressesNoLogsOtherError(t *testing.T) {
 795         rnibDataService, readerMock, _ := setupRnibDataServiceTest(t)
 796
 797         var addresses []string = nil
 798         mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
 799         readerMock.On("GetE2TAddresses").Return(addresses, mockErr)
 800
 801         res, err := rnibDataService.GetE2TAddressesNoLogs()
 802         readerMock.AssertNumberOfCalls(t, "GetE2TAddresses", 1)
 803         assert.Nil(t, res)
 804         assert.NotNil(t, err)
 805 }
 806
 807 func TestSaveE2TInstanceConnFailure(t *testing.T) {
 808         e2tInstance := &entities.E2TInstance{}
 809         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 810
 811         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 812
 813         writerMock.On("SaveE2TInstance", e2tInstance).Return(mockErr)
 814
 815         err := rnibDataService.SaveE2TInstance(e2tInstance)
 816         writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 3)
 817         assert.NotNil(t, err)
 818 }
 819
 820 func TestSaveE2TInstanceOkNoError(t *testing.T) {
 821         e2tInstance := &entities.E2TInstance{}
 822         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 823
 824         writerMock.On("SaveE2TInstance", e2tInstance).Return(nil)
 825
 826         err := rnibDataService.SaveE2TInstance(e2tInstance)
 827         writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 1)
 828         assert.Nil(t, err)
 829 }
 830
 831 func TestSaveE2TInstanceOtherError(t *testing.T) {
 832         e2tInstance := &entities.E2TInstance{}
 833         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 834
 835         mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
 836
 837         writerMock.On("SaveE2TInstance", e2tInstance).Return(mockErr)
 838
 839         err := rnibDataService.SaveE2TInstance(e2tInstance)
 840         writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 1)
 841
 842         assert.NotNil(t, err)
 843 }
 844
 845 func TestSaveE2TInstanceNoLogsConnFailure(t *testing.T) {
 846         e2tInstance := &entities.E2TInstance{}
 847         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 848
 849         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 850
 851         writerMock.On("SaveE2TInstance", e2tInstance).Return(mockErr)
 852
 853         err := rnibDataService.SaveE2TInstanceNoLogs(e2tInstance)
 854         writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 3)
 855         assert.NotNil(t, err)
 856 }
 857
 858 func TestSaveE2TInstanceNoLogsOkNoError(t *testing.T) {
 859         e2tInstance := &entities.E2TInstance{}
 860         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 861
 862         writerMock.On("SaveE2TInstance", e2tInstance).Return(nil)
 863
 864         err := rnibDataService.SaveE2TInstanceNoLogs(e2tInstance)
 865         writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 1)
 866         assert.Nil(t, err)
 867 }
 868
 869 func TestSaveE2TInstanceNoLogsOtherError(t *testing.T) {
 870         e2tInstance := &entities.E2TInstance{}
 871         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 872
 873         mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
 874
 875         writerMock.On("SaveE2TInstance", e2tInstance).Return(mockErr)
 876
 877         err := rnibDataService.SaveE2TInstanceNoLogs(e2tInstance)
 878         writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 1)
 879
 880         assert.NotNil(t, err)
 881 }
 882
 883 func TestSaveE2TAddressesConnFailure(t *testing.T) {
 884         addresses := []string{"10.10.5.20:3200", "10.10.5.21:3200"}
 885         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 886
 887         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 888
 889         writerMock.On("SaveE2TAddresses", addresses).Return(mockErr)
 890
 891         err := rnibDataService.SaveE2TAddresses(addresses)
 892         writerMock.AssertNumberOfCalls(t, "SaveE2TAddresses", 3)
 893         assert.NotNil(t, err)
 894 }
 895
 896 func TestSaveE2TAddressesOkNoError(t *testing.T) {
 897         addresses := []string{"10.10.5.20:3200", "10.10.5.21:3200"}
 898         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 899
 900         writerMock.On("SaveE2TAddresses", addresses).Return(nil)
 901
 902         err := rnibDataService.SaveE2TAddresses(addresses)
 903         writerMock.AssertNumberOfCalls(t, "SaveE2TAddresses", 1)
 904         assert.Nil(t, err)
 905 }
 906
 907 func TestSaveE2TAddressesOtherError(t *testing.T) {
 908         addresses := []string{"10.10.5.20:3200", "10.10.5.21:3200"}
 909         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 910
 911         mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
 912
 913         writerMock.On("SaveE2TAddresses", addresses).Return(mockErr)
 914
 915         err := rnibDataService.SaveE2TAddresses(addresses)
 916         writerMock.AssertNumberOfCalls(t, "SaveE2TAddresses", 1)
 917
 918         assert.NotNil(t, err)
 919 }
 920
 921 func TestRemoveE2TInstanceConnFailure(t *testing.T) {
 922         address := "10.10.5.20:3200"
 923         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 924
 925         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 926
 927         writerMock.On("RemoveE2TInstance", address).Return(mockErr)
 928
 929         err := rnibDataService.RemoveE2TInstance(address)
 930         writerMock.AssertNumberOfCalls(t, "RemoveE2TInstance", 3)
 931         assert.NotNil(t, err)
 932 }
 933
 934 func TestRemoveE2TInstanceOkNoError(t *testing.T) {
 935         address := "10.10.5.20:3200"
 936         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 937
 938         writerMock.On("RemoveE2TInstance", address).Return(nil)
 939
 940         err := rnibDataService.RemoveE2TInstance(address)
 941         writerMock.AssertNumberOfCalls(t, "RemoveE2TInstance", 1)
 942         assert.Nil(t, err)
 943 }
 944
 945 func TestRemoveE2TInstanceOtherError(t *testing.T) {
 946         address := "10.10.5.20:3200"
 947         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 948
 949         mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
 950
 951         writerMock.On("RemoveE2TInstance", address).Return(mockErr)
 952
 953         err := rnibDataService.RemoveE2TInstance(address)
 954         writerMock.AssertNumberOfCalls(t, "RemoveE2TInstance", 1)
 955
 956         assert.NotNil(t, err)
 957 }
 958
 959 func TestAddNbIdentityConnFailure(t *testing.T) {
 960         gnbType := entities.Node_GNB
 961         nbIdentity := &entities.NbIdentity{}
 962         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 963
 964         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
 965
 966         writerMock.On("AddNbIdentity", gnbType, nbIdentity).Return(mockErr)
 967
 968         err := rnibDataService.AddNbIdentity(gnbType, nbIdentity)
 969         writerMock.AssertNumberOfCalls(t, "AddNbIdentity", 3)
 970         assert.NotNil(t, err)
 971 }
 972
 973 func TestAddNbIdentityOkNoError(t *testing.T) {
 974         gnbType := entities.Node_GNB
 975         nbIdentity := &entities.NbIdentity{}
 976         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 977
 978         writerMock.On("AddNbIdentity", gnbType, nbIdentity).Return(nil)
 979
 980         err := rnibDataService.AddNbIdentity(gnbType, nbIdentity)
 981         writerMock.AssertNumberOfCalls(t, "AddNbIdentity", 1)
 982         assert.Nil(t, err)
 983 }
 984
 985 func TestAddNbIdentityOtherError(t *testing.T) {
 986         gnbType := entities.Node_GNB
 987         nbIdentity := &entities.NbIdentity{}
 988         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
 989
 990         mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
 991
 992         writerMock.On("AddNbIdentity", gnbType, nbIdentity).Return(mockErr)
 993
 994         err := rnibDataService.AddNbIdentity(gnbType, nbIdentity)
 995         writerMock.AssertNumberOfCalls(t, "AddNbIdentity", 1)
 996
 997         assert.NotNil(t, err)
 998 }
 999
1000 func TestRemoveNbIdentityConnFailure(t *testing.T) {
1001         gnbType := entities.Node_GNB
1002         nbIdentity := &entities.NbIdentity{}
1003         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
1004
1005         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
1006
1007         writerMock.On("RemoveNbIdentity", gnbType, nbIdentity).Return(mockErr)
1008
1009         err := rnibDataService.RemoveNbIdentity(gnbType, nbIdentity)
1010         writerMock.AssertNumberOfCalls(t, "RemoveNbIdentity", 3)
1011         assert.NotNil(t, err)
1012 }
1013
1014 func TestRemoveNbIdentityOkNoError(t *testing.T) {
1015         gnbType := entities.Node_GNB
1016         nbIdentity := &entities.NbIdentity{}
1017         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
1018
1019         writerMock.On("RemoveNbIdentity", gnbType, nbIdentity).Return(nil)
1020
1021         err := rnibDataService.RemoveNbIdentity(gnbType, nbIdentity)
1022         writerMock.AssertNumberOfCalls(t, "RemoveNbIdentity", 1)
1023         assert.Nil(t, err)
1024 }
1025
1026 func TestRemoveNbIdentityOtherError(t *testing.T) {
1027         gnbType := entities.Node_GNB
1028         nbIdentity := &entities.NbIdentity{}
1029         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
1030
1031         mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
1032
1033         writerMock.On("RemoveNbIdentity", gnbType, nbIdentity).Return(mockErr)
1034
1035         err := rnibDataService.RemoveNbIdentity(gnbType, nbIdentity)
1036         writerMock.AssertNumberOfCalls(t, "RemoveNbIdentity", 1)
1037         assert.NotNil(t, err)
1038 }
1039
1040 func TestRemoveServedNrCellsConnFailure(t *testing.T) {
1041         var ranName string = "abcd"
1042         var servedNrCells []*entities.ServedNRCell
1043         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
1044
1045         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
1046
1047         writerMock.On("RemoveServedNrCells", ranName, servedNrCells).Return(mockErr)
1048
1049         err := rnibDataService.RemoveServedNrCells(ranName, servedNrCells)
1050         writerMock.AssertNumberOfCalls(t, "RemoveServedNrCells", 3)
1051         assert.NotNil(t, err)
1052 }
1053
1054 func TestRemoveServedNrCellsOkNoError(t *testing.T) {
1055         var ranName string = "abcd"
1056         var servedNrCells []*entities.ServedNRCell
1057         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
1058
1059         writerMock.On("RemoveServedNrCells", ranName, servedNrCells).Return(nil)
1060
1061         err := rnibDataService.RemoveServedNrCells(ranName, servedNrCells)
1062         writerMock.AssertNumberOfCalls(t, "RemoveServedNrCells", 1)
1063         assert.Nil(t, err)
1064 }
1065
1066 func TestRemoveServedNrCellsOtherError(t *testing.T) {
1067         var ranName string = "abcd"
1068         var servedNrCells []*entities.ServedNRCell
1069         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
1070
1071         mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
1072
1073         writerMock.On("RemoveServedNrCells", ranName, servedNrCells).Return(mockErr)
1074
1075         err := rnibDataService.RemoveServedNrCells(ranName, servedNrCells)
1076         writerMock.AssertNumberOfCalls(t, "RemoveServedNrCells", 1)
1077         assert.NotNil(t, err)
1078 }
1079
1080 func TestRemoveEnbConnFailure(t *testing.T) {
1081         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
1082
1083         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
1084         nodebInfo := &entities.NodebInfo{}
1085         writerMock.On("RemoveEnb", nodebInfo).Return(mockErr)
1086
1087         err := rnibDataService.RemoveEnb(nodebInfo)
1088         writerMock.AssertNumberOfCalls(t, "RemoveEnb", 3)
1089         assert.NotNil(t, err)
1090 }
1091
1092 func TestRemoveEnbOkNoError(t *testing.T) {
1093         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
1094
1095         nodebInfo := &entities.NodebInfo{}
1096         writerMock.On("RemoveEnb", nodebInfo).Return(nil)
1097
1098         err := rnibDataService.RemoveEnb(nodebInfo)
1099         writerMock.AssertNumberOfCalls(t, "RemoveEnb", 1)
1100         assert.Nil(t, err)
1101 }
1102
1103 func TestRemoveEnbOtherError(t *testing.T) {
1104         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
1105
1106         mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
1107         nodebInfo := &entities.NodebInfo{}
1108         writerMock.On("RemoveEnb", nodebInfo).Return(mockErr)
1109
1110         err := rnibDataService.RemoveEnb(nodebInfo)
1111         writerMock.AssertNumberOfCalls(t, "RemoveEnb", 1)
1112         assert.NotNil(t, err)
1113 }
1114
1115 func TestUpdateGnbCellsConnFailure(t *testing.T) {
1116         var servedNrCells []*entities.ServedNRCell
1117         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
1118
1119         mockErr := &common.InternalError{Err: &net.OpError{Err: fmt.Errorf("connection error")}}
1120         nodebInfo := &entities.NodebInfo{}
1121         writerMock.On("UpdateGnbCells", nodebInfo, servedNrCells).Return(mockErr)
1122
1123         err := rnibDataService.UpdateGnbCells(nodebInfo, servedNrCells)
1124         writerMock.AssertNumberOfCalls(t, "UpdateGnbCells", 3)
1125         assert.NotNil(t, err)
1126 }
1127
1128 func TestUpdateGnbCellsOkNoError(t *testing.T) {
1129         var servedNrCells []*entities.ServedNRCell
1130         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
1131
1132         nodebInfo := &entities.NodebInfo{}
1133         writerMock.On("UpdateGnbCells", nodebInfo, servedNrCells).Return(nil)
1134
1135         err := rnibDataService.UpdateGnbCells(nodebInfo, servedNrCells)
1136         writerMock.AssertNumberOfCalls(t, "UpdateGnbCells", 1)
1137         assert.Nil(t, err)
1138 }
1139
1140 func TestUpdateGnbCellsOtherError(t *testing.T) {
1141         var servedNrCells []*entities.ServedNRCell
1142         rnibDataService, _, writerMock := setupRnibDataServiceTest(t)
1143
1144         mockErr := &common.InternalError{Err: fmt.Errorf("non connection error")}
1145         nodebInfo := &entities.NodebInfo{}
1146         writerMock.On("UpdateGnbCells", nodebInfo, servedNrCells).Return(mockErr)
1147
1148         err := rnibDataService.UpdateGnbCells(nodebInfo, servedNrCells)
1149         writerMock.AssertNumberOfCalls(t, "UpdateGnbCells", 1)
1150         assert.NotNil(t, err)
1151 }