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