E2Manager/managers/e2t_instances_manager_test.go

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