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