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