E2Manager/managers/e2t_instances_manager_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 managers
  21
  22 import (
  23         "e2mgr/configuration"
  24         "e2mgr/logger"
  25         "e2mgr/mocks"
  26         "e2mgr/services"
  27         "fmt"
  28         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
  29         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
  30         "github.com/pkg/errors"
  31         "github.com/stretchr/testify/assert"
  32         "github.com/stretchr/testify/mock"
  33         "testing"
  34 )
  35
  36 const E2TAddress = "10.10.2.15:9800"
  37 const E2TAddress2 = "10.10.2.16:9800"
  38
  39 func initE2TInstancesManagerTest(t *testing.T) (*mocks.RnibReaderMock, *mocks.RnibWriterMock, *E2TInstancesManager) {
  40         logger, err := logger.InitLogger(logger.DebugLevel)
  41         if err != nil {
  42                 t.Errorf("#... - failed to initialize logger, error: %s", err)
  43         }
  44         config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3}
  45
  46         readerMock := &mocks.RnibReaderMock{}
  47         writerMock := &mocks.RnibWriterMock{}
  48         rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock)
  49         e2tInstancesManager := NewE2TInstancesManager(rnibDataService, logger)
  50         return readerMock, writerMock, e2tInstancesManager
  51 }
  52
  53 func TestAddNewE2TInstanceSaveE2TInstanceFailure(t *testing.T) {
  54         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
  55         rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(common.NewInternalError(errors.New("Error")))
  56         err := e2tInstancesManager.AddE2TInstance(E2TAddress)
  57         assert.NotNil(t, err)
  58         rnibReaderMock.AssertNotCalled(t, "GetE2TAddresses")
  59 }
  60
  61 func TestAddNewE2TInstanceGetE2TAddressesInternalFailure(t *testing.T) {
  62         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
  63         rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
  64         e2tAddresses := []string{}
  65         rnibReaderMock.On("GetE2TAddresses").Return(e2tAddresses, common.NewInternalError(errors.New("Error")))
  66         err := e2tInstancesManager.AddE2TInstance(E2TAddress)
  67         assert.NotNil(t, err)
  68         rnibReaderMock.AssertNotCalled(t, "SaveE2TAddresses")
  69 }
  70
  71 func TestAddNewE2TInstanceSaveE2TAddressesFailure(t *testing.T) {
  72         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
  73         rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
  74         E2TAddresses := []string{}
  75         rnibReaderMock.On("GetE2TAddresses").Return(E2TAddresses, nil)
  76         E2TAddresses = append(E2TAddresses, E2TAddress)
  77         rnibWriterMock.On("SaveE2TAddresses", E2TAddresses).Return(common.NewResourceNotFoundError(""))
  78         err := e2tInstancesManager.AddE2TInstance(E2TAddress)
  79         assert.NotNil(t, err)
  80 }
  81
  82 func TestAddNewE2TInstanceNoE2TAddressesSuccess(t *testing.T) {
  83         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
  84         rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
  85         e2tAddresses := []string{}
  86         rnibReaderMock.On("GetE2TAddresses").Return(e2tAddresses, common.NewResourceNotFoundError(""))
  87         e2tAddresses = append(e2tAddresses, E2TAddress)
  88         rnibWriterMock.On("SaveE2TAddresses", e2tAddresses).Return(nil)
  89         err := e2tInstancesManager.AddE2TInstance(E2TAddress)
  90         assert.Nil(t, err)
  91         rnibWriterMock.AssertCalled(t, "SaveE2TAddresses", e2tAddresses)
  92 }
  93
  94 func TestAddNewE2TInstanceEmptyE2TAddressesSuccess(t *testing.T) {
  95         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
  96         rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
  97         e2tAddresses := []string{}
  98         rnibReaderMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
  99         e2tAddresses = append(e2tAddresses, E2TAddress)
 100         rnibWriterMock.On("SaveE2TAddresses", e2tAddresses).Return(nil)
 101         err := e2tInstancesManager.AddE2TInstance(E2TAddress)
 102         assert.Nil(t, err)
 103         rnibWriterMock.AssertCalled(t, "SaveE2TAddresses", e2tAddresses)
 104 }
 105
 106 func TestAddNewE2TInstanceExistingE2TAddressesSuccess(t *testing.T) {
 107         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 108         rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
 109         E2TAddresses := []string{"10.0.1.15:3030"}
 110         rnibReaderMock.On("GetE2TAddresses").Return(E2TAddresses, nil)
 111         E2TAddresses = append(E2TAddresses, E2TAddress)
 112         rnibWriterMock.On("SaveE2TAddresses", E2TAddresses).Return(nil)
 113         err := e2tInstancesManager.AddE2TInstance(E2TAddress)
 114         assert.Nil(t, err)
 115 }
 116
 117 func TestGetE2TInstanceFailure(t *testing.T) {
 118         rnibReaderMock, _, e2tInstancesManager := initE2TInstancesManagerTest(t)
 119         var e2tInstance *entities.E2TInstance
 120         rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance, common.NewInternalError(fmt.Errorf("for test")))
 121         res, err := e2tInstancesManager.GetE2TInstance(E2TAddress)
 122         assert.NotNil(t, err)
 123         assert.Nil(t, res)
 124 }
 125
 126 func TestGetE2TInstanceSuccess(t *testing.T) {
 127         rnibReaderMock, _, e2tInstancesManager := initE2TInstancesManagerTest(t)
 128         address := "10.10.2.15:9800"
 129         e2tInstance := entities.NewE2TInstance(address)
 130         rnibReaderMock.On("GetE2TInstance", address).Return(e2tInstance, nil)
 131         res, err := e2tInstancesManager.GetE2TInstance(address)
 132         assert.Nil(t, err)
 133         assert.Equal(t, e2tInstance, res)
 134 }
 135
 136 func TestAddRanToInstanceGetInstanceFailure(t *testing.T) {
 137         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 138
 139         var e2tInstance1 *entities.E2TInstance
 140         rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, common.NewInternalError(fmt.Errorf("for test")))
 141
 142         err := e2tInstancesManager.AddRanToInstance("test1", E2TAddress)
 143         assert.NotNil(t, err)
 144         rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
 145 }
 146
 147 func TestAddRanToInstanceSaveInstanceFailure(t *testing.T) {
 148         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 149         e2tInstance1 := entities.NewE2TInstance(E2TAddress)
 150         rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, nil)
 151         rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(common.NewInternalError(fmt.Errorf("for test")))
 152
 153         err := e2tInstancesManager.AddRanToInstance("test1", E2TAddress)
 154         assert.NotNil(t, err)
 155         rnibReaderMock.AssertExpectations(t)
 156         rnibWriterMock.AssertExpectations(t)
 157 }
 158
 159 func TestAddRanToInstanceSuccess(t *testing.T) {
 160         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 161         e2tInstance := entities.NewE2TInstance(E2TAddress)
 162         rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance, nil)
 163
 164         updateE2TInstance := *e2tInstance
 165         updateE2TInstance.AssociatedRanList = append(updateE2TInstance.AssociatedRanList, "test1")
 166
 167         rnibWriterMock.On("SaveE2TInstance", &updateE2TInstance).Return(nil)
 168
 169         err := e2tInstancesManager.AddRanToInstance("test1", E2TAddress)
 170         assert.Nil(t, err)
 171         rnibReaderMock.AssertExpectations(t)
 172         rnibWriterMock.AssertExpectations(t)
 173 }
 174
 175 func TestRemoveRanFromInstanceGetInstanceFailure(t *testing.T) {
 176         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 177
 178         var e2tInstance1 *entities.E2TInstance
 179         rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, common.NewInternalError(fmt.Errorf("for test")))
 180         err := e2tInstancesManager.RemoveRanFromInstance("test1", E2TAddress)
 181         assert.NotNil(t, err)
 182         rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
 183 }
 184
 185 func TestRemoveRanFromInstanceSaveInstanceFailure(t *testing.T) {
 186         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 187
 188         e2tInstance1 := entities.NewE2TInstance(E2TAddress)
 189         rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, nil)
 190         rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(common.NewInternalError(fmt.Errorf("for test")))
 191
 192         err := e2tInstancesManager.RemoveRanFromInstance("test1", E2TAddress)
 193         assert.NotNil(t, err)
 194         rnibReaderMock.AssertExpectations(t)
 195         rnibWriterMock.AssertExpectations(t)
 196 }
 197
 198 func TestRemoveRanFromInstanceSuccess(t *testing.T) {
 199         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 200
 201         e2tInstance := entities.NewE2TInstance(E2TAddress)
 202         e2tInstance.AssociatedRanList = []string{"test0", "test1"}
 203         updatedE2TInstance := *e2tInstance
 204         updatedE2TInstance.AssociatedRanList = []string{"test0"}
 205         rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance, nil)
 206         rnibWriterMock.On("SaveE2TInstance", &updatedE2TInstance).Return(nil)
 207
 208         err := e2tInstancesManager.RemoveRanFromInstance("test1", E2TAddress)
 209         assert.Nil(t, err)
 210         rnibReaderMock.AssertExpectations(t)
 211         rnibWriterMock.AssertExpectations(t)
 212 }
 213
 214 func TestSelectE2TInstancesGetE2TAddressesFailure(t *testing.T) {
 215         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 216
 217         rnibReaderMock.On("GetE2TAddresses").Return([]string{}, common.NewInternalError(fmt.Errorf("for test")))
 218         address, err := e2tInstancesManager.SelectE2TInstance()
 219         assert.NotNil(t, err)
 220         assert.Empty(t, address)
 221         rnibReaderMock.AssertExpectations(t)
 222         rnibWriterMock.AssertNotCalled(t, "GetE2TInstances")
 223 }
 224
 225 func TestSelectE2TInstancesEmptyE2TAddressList(t *testing.T) {
 226         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 227
 228         rnibReaderMock.On("GetE2TAddresses").Return([]string{}, nil)
 229         address, err := e2tInstancesManager.SelectE2TInstance()
 230         assert.NotNil(t, err)
 231         assert.Empty(t, address)
 232         rnibReaderMock.AssertExpectations(t)
 233         rnibWriterMock.AssertNotCalled(t, "GetE2TInstances")
 234 }
 235
 236 func TestSelectE2TInstancesGetE2TInstancesFailure(t *testing.T) {
 237         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 238
 239         addresses := []string{E2TAddress}
 240         rnibReaderMock.On("GetE2TAddresses").Return(addresses, nil)
 241         rnibReaderMock.On("GetE2TInstances", addresses).Return([]*entities.E2TInstance{}, common.NewInternalError(fmt.Errorf("for test")))
 242         address, err := e2tInstancesManager.SelectE2TInstance()
 243         assert.NotNil(t, err)
 244         assert.Empty(t, address)
 245         rnibReaderMock.AssertExpectations(t)
 246         rnibWriterMock.AssertExpectations(t)
 247 }
 248
 249 func TestSelectE2TInstancesEmptyE2TInstancesList(t *testing.T) {
 250         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 251
 252         addresses := []string{E2TAddress}
 253         rnibReaderMock.On("GetE2TAddresses").Return(addresses, nil)
 254         rnibReaderMock.On("GetE2TInstances", addresses).Return([]*entities.E2TInstance{}, nil)
 255         address, err := e2tInstancesManager.SelectE2TInstance()
 256         assert.NotNil(t, err)
 257         assert.Empty(t, address)
 258         rnibReaderMock.AssertExpectations(t)
 259         rnibWriterMock.AssertExpectations(t)
 260 }
 261
 262 func TestSelectE2TInstancesNoActiveE2TInstance(t *testing.T) {
 263         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 264         addresses := []string{E2TAddress, E2TAddress2}
 265         e2tInstance1 := entities.NewE2TInstance(E2TAddress)
 266         e2tInstance1.State = entities.ToBeDeleted
 267         e2tInstance1.AssociatedRanList = []string{"test1", "test2", "test3"}
 268         e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
 269         e2tInstance2.State = entities.ToBeDeleted
 270         e2tInstance2.AssociatedRanList = []string{"test4", "test5", "test6", "test7"}
 271
 272         rnibReaderMock.On("GetE2TAddresses").Return(addresses, nil)
 273         rnibReaderMock.On("GetE2TInstances", addresses).Return([]*entities.E2TInstance{e2tInstance1, e2tInstance2}, nil)
 274         address, err := e2tInstancesManager.SelectE2TInstance()
 275         assert.NotNil(t, err)
 276         assert.Equal(t, "", address)
 277         rnibReaderMock.AssertExpectations(t)
 278         rnibWriterMock.AssertExpectations(t)
 279 }
 280
 281 func TestSelectE2TInstancesSuccess(t *testing.T) {
 282         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 283         addresses := []string{E2TAddress, E2TAddress2}
 284         e2tInstance1 := entities.NewE2TInstance(E2TAddress)
 285         e2tInstance1.AssociatedRanList = []string{"test1", "test2", "test3"}
 286         e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
 287         e2tInstance2.AssociatedRanList = []string{"test4", "test5", "test6", "test7"}
 288
 289         rnibReaderMock.On("GetE2TAddresses").Return(addresses, nil)
 290         rnibReaderMock.On("GetE2TInstances", addresses).Return([]*entities.E2TInstance{e2tInstance1, e2tInstance2}, nil)
 291         address, err := e2tInstancesManager.SelectE2TInstance()
 292         assert.Nil(t, err)
 293         assert.Equal(t, E2TAddress, address)
 294         rnibReaderMock.AssertExpectations(t)
 295         rnibWriterMock.AssertExpectations(t)
 296 }
 297
 298 func TestActivateE2TInstanceSuccess(t *testing.T) {
 299         _, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 300
 301         e2tInstance1 := entities.NewE2TInstance(E2TAddress)
 302         e2tInstance1.State = entities.RoutingManagerFailure
 303         e2tInstance1.AssociatedRanList = []string{"test1","test2","test3"}
 304
 305         rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
 306
 307         err := e2tInstancesManager.ActivateE2TInstance(e2tInstance1)
 308         assert.Nil(t, err)
 309         assert.Equal(t, entities.Active, e2tInstance1.State)
 310         rnibWriterMock.AssertExpectations(t)
 311 }
 312
 313 func TestActivateE2TInstance_RnibError(t *testing.T) {
 314         _, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 315
 316         e2tInstance1 := entities.NewE2TInstance(E2TAddress)
 317         e2tInstance1.State = entities.RoutingManagerFailure
 318         e2tInstance1.AssociatedRanList = []string{"test1","test2","test3"}
 319
 320         rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(common.NewInternalError(errors.New("Error")))
 321
 322         err := e2tInstancesManager.ActivateE2TInstance(e2tInstance1)
 323         assert.NotNil(t, err)
 324 }
 325
 326 func TestActivateE2TInstance_NoInstance(t *testing.T) {
 327         _, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 328
 329         err := e2tInstancesManager.ActivateE2TInstance(nil)
 330
 331         assert.NotNil(t, err)
 332         rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
 333 }
 334
 335 func TestResetKeepAliveTimestampGetInternalFailure(t *testing.T) {
 336         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 337
 338         address := "10.10.2.15:9800"
 339         e2tInstance := entities.NewE2TInstance(address)
 340         rnibReaderMock.On("GetE2TInstance", address).Return(e2tInstance, common.NewInternalError(errors.New("Error")))
 341         rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
 342
 343         err := e2tInstancesManager.ResetKeepAliveTimestamp(address)
 344         assert.NotNil(t, err)
 345         rnibReaderMock.AssertNotCalled(t, "SaveE2TInstance")
 346 }
 347
 348 func TestAResetKeepAliveTimestampSaveInternalFailure(t *testing.T) {
 349         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 350
 351         address := "10.10.2.15:9800"
 352         e2tInstance := entities.NewE2TInstance(address)
 353         rnibReaderMock.On("GetE2TInstance", address).Return(e2tInstance, nil)
 354         rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(common.NewInternalError(errors.New("Error")))
 355
 356         err := e2tInstancesManager.ResetKeepAliveTimestamp(address)
 357         assert.NotNil(t, err)
 358 }
 359
 360 func TestResetKeepAliveTimestampSuccess(t *testing.T) {
 361         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 362
 363         address := "10.10.2.15:9800"
 364         e2tInstance := entities.NewE2TInstance(address)
 365         rnibReaderMock.On("GetE2TInstance", address).Return(e2tInstance, nil)
 366         rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
 367
 368         err := e2tInstancesManager.ResetKeepAliveTimestamp(address)
 369         assert.Nil(t, err)
 370         rnibReaderMock.AssertCalled(t, "GetE2TInstance", address)
 371         rnibWriterMock.AssertNumberOfCalls(t, "SaveE2TInstance", 1)
 372 }
 373
 374 func TestResetKeepAliveTimestampToBeDeleted(t *testing.T) {
 375         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 376
 377         address := "10.10.2.15:9800"
 378         e2tInstance := entities.NewE2TInstance(address)
 379         e2tInstance.State = entities.ToBeDeleted
 380         rnibReaderMock.On("GetE2TInstance", address).Return(e2tInstance, nil)
 381
 382         err := e2tInstancesManager.ResetKeepAliveTimestamp(address)
 383         assert.Nil(t, err)
 384         rnibReaderMock.AssertCalled(t, "GetE2TInstance", address)
 385         rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
 386 }
 387
 388 func TestResetKeepAliveTimestampRoutingManagerFailure(t *testing.T) {
 389         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 390
 391         address := "10.10.2.15:9800"
 392         e2tInstance := entities.NewE2TInstance(address)
 393         e2tInstance.State = entities.RoutingManagerFailure
 394         rnibReaderMock.On("GetE2TInstance", address).Return(e2tInstance, nil)
 395
 396         err := e2tInstancesManager.ResetKeepAliveTimestamp(address)
 397         assert.Nil(t, err)
 398         rnibReaderMock.AssertCalled(t, "GetE2TInstance", address)
 399         rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
 400 }
 401
 402 func TestRemoveE2TInstance(t *testing.T) {
 403         _, _, e2tInstancesManager := initE2TInstancesManagerTest(t)
 404         e2tInstance1 := entities.NewE2TInstance(E2TAddress)
 405         err := e2tInstancesManager.RemoveE2TInstance(e2tInstance1)
 406         assert.Nil(t, err)
 407 }
 408
 409 func TestResetKeepAliveTimestampsForAllE2TInstancesGetE2TInstancesFailure(t *testing.T) {
 410         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 411         rnibReaderMock.On("GetE2TAddresses").Return([]string{}, common.NewInternalError(errors.New("Error")))
 412         e2tInstancesManager.ResetKeepAliveTimestampsForAllE2TInstances()
 413         rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
 414 }
 415
 416 func TestResetKeepAliveTimestampsForAllE2TInstancesNoInstances(t *testing.T) {
 417         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 418         rnibReaderMock.On("GetE2TAddresses").Return([]string{}, nil)
 419         e2tInstancesManager.ResetKeepAliveTimestampsForAllE2TInstances()
 420         rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
 421 }
 422
 423 func TestResetKeepAliveTimestampsForAllE2TInstancesNoActiveInstances(t *testing.T) {
 424         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 425         e2tAddresses := []string{E2TAddress, E2TAddress2}
 426         rnibReaderMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 427         e2tInstance1 := entities.NewE2TInstance(E2TAddress)
 428         e2tInstance1.State = entities.ToBeDeleted
 429         e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
 430         e2tInstance2.State = entities.RoutingManagerFailure
 431         rnibReaderMock.On("GetE2TInstances", e2tAddresses).Return([]*entities.E2TInstance{e2tInstance1, e2tInstance2}, nil)
 432         e2tInstancesManager.ResetKeepAliveTimestampsForAllE2TInstances()
 433         rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
 434 }
 435
 436 func TestResetKeepAliveTimestampsForAllE2TInstancesOneActiveInstance(t *testing.T) {
 437         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 438         e2tAddresses := []string{E2TAddress, E2TAddress2}
 439         rnibReaderMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 440         e2tInstance1 := entities.NewE2TInstance(E2TAddress)
 441         e2tInstance1.State = entities.Active
 442         e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
 443         e2tInstance2.State = entities.ToBeDeleted
 444         rnibReaderMock.On("GetE2TInstances", e2tAddresses).Return([]*entities.E2TInstance{e2tInstance1, e2tInstance2}, nil)
 445         rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
 446         e2tInstancesManager.ResetKeepAliveTimestampsForAllE2TInstances()
 447         rnibWriterMock.AssertNumberOfCalls(t, "SaveE2TInstance",1)
 448 }
 449
 450 func TestResetKeepAliveTimestampsForAllE2TInstancesSaveE2TInstanceFailure(t *testing.T) {
 451         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 452         e2tAddresses := []string{E2TAddress, E2TAddress2}
 453         rnibReaderMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 454         e2tInstance1 := entities.NewE2TInstance(E2TAddress)
 455         e2tInstance1.State = entities.Active
 456         e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
 457         e2tInstance2.State = entities.ToBeDeleted
 458         rnibReaderMock.On("GetE2TInstances", e2tAddresses).Return([]*entities.E2TInstance{e2tInstance1, e2tInstance2}, nil)
 459         rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(common.NewInternalError(errors.New("Error")))
 460         e2tInstancesManager.ResetKeepAliveTimestampsForAllE2TInstances()
 461         rnibWriterMock.AssertNumberOfCalls(t, "SaveE2TInstance",1)
 462 }