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