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