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 TestAddNewE2TInstanceNoE2TAddresses(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, common.NewResourceNotFoundError(""))
  57         e2tAddresses = append(e2tAddresses, E2TAddress)
  58         rnibWriterMock.On("SaveE2TAddresses", e2tAddresses).Return(nil)
  59         err := e2tInstancesManager.AddE2TInstance(E2TAddress)
  60         assert.Nil(t, err)
  61         rnibWriterMock.AssertCalled(t, "SaveE2TAddresses", e2tAddresses)
  62 }
  63
  64 func TestAddNewE2TInstanceEmptyE2TAddresses(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, nil)
  69         e2tAddresses = append(e2tAddresses, E2TAddress)
  70         rnibWriterMock.On("SaveE2TAddresses", e2tAddresses).Return(nil)
  71         err := e2tInstancesManager.AddE2TInstance(E2TAddress)
  72         assert.Nil(t, err)
  73         rnibWriterMock.AssertCalled(t, "SaveE2TAddresses", e2tAddresses)
  74 }
  75
  76 func TestAddNewE2TInstanceSaveE2TAddressesFailure(t *testing.T) {
  77         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
  78         rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
  79         E2TAddresses := []string{}
  80         rnibReaderMock.On("GetE2TAddresses").Return(E2TAddresses, nil)
  81         E2TAddresses = append(E2TAddresses, E2TAddress)
  82         rnibWriterMock.On("SaveE2TAddresses", E2TAddresses).Return(common.NewResourceNotFoundError(""))
  83         err := e2tInstancesManager.AddE2TInstance(E2TAddress)
  84         assert.NotNil(t, err)
  85 }
  86
  87 func TestGetE2TInstanceSuccess(t *testing.T) {
  88         rnibReaderMock, _, e2tInstancesManager := initE2TInstancesManagerTest(t)
  89         address := "10.10.2.15:9800"
  90         e2tInstance := entities.NewE2TInstance(address)
  91         rnibReaderMock.On("GetE2TInstance", address).Return(e2tInstance, nil)
  92         res, err := e2tInstancesManager.GetE2TInstance(address)
  93         assert.Nil(t, err)
  94         assert.Equal(t, e2tInstance, res)
  95 }
  96
  97 func TestGetE2TInstanceFailure(t *testing.T) {
  98         rnibReaderMock, _, e2tInstancesManager := initE2TInstancesManagerTest(t)
  99         var e2tInstance *entities.E2TInstance
 100         rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance, common.NewInternalError(fmt.Errorf("for test")))
 101         res, err := e2tInstancesManager.GetE2TInstance(E2TAddress)
 102         assert.NotNil(t, err)
 103         assert.Nil(t, res)
 104 }
 105
 106 func TestAssociateRanSuccess(t *testing.T) {
 107         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 108         e2tInstance  := entities.NewE2TInstance(E2TAddress)
 109         rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance, nil)
 110
 111         updateE2TInstance := *e2tInstance
 112         updateE2TInstance.AssociatedRanList = append(updateE2TInstance.AssociatedRanList, "test1")
 113
 114         rnibWriterMock.On("SaveE2TInstance", &updateE2TInstance).Return(nil)
 115
 116         err := e2tInstancesManager.AssociateRan("test1", E2TAddress)
 117         assert.Nil(t, err)
 118         rnibReaderMock.AssertExpectations(t)
 119         rnibWriterMock.AssertExpectations(t)
 120 }
 121
 122 func TestAssociateRanGetInstanceFailure(t *testing.T) {
 123         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 124
 125         var e2tInstance1 *entities.E2TInstance
 126         rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, common.NewInternalError(fmt.Errorf("for test")))
 127
 128         err := e2tInstancesManager.AssociateRan("test1", E2TAddress)
 129         assert.NotNil(t, err)
 130         rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
 131 }
 132
 133 func TestAssociateRanSaveInstanceFailure(t *testing.T) {
 134         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 135         e2tInstance1  := entities.NewE2TInstance(E2TAddress)
 136         rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, nil)
 137         rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(common.NewInternalError(fmt.Errorf("for test")))
 138
 139         err := e2tInstancesManager.AssociateRan("test1", E2TAddress)
 140         assert.NotNil(t, err)
 141         rnibReaderMock.AssertExpectations(t)
 142         rnibWriterMock.AssertExpectations(t)
 143 }
 144
 145 func TestDissociateRanSuccess(t *testing.T) {
 146         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 147
 148         e2tInstance := entities.NewE2TInstance(E2TAddress)
 149         e2tInstance.AssociatedRanList = []string{"test0","test1"}
 150         updatedE2TInstance := *e2tInstance
 151         updatedE2TInstance.AssociatedRanList = []string{"test0"}
 152         rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance, nil)
 153         rnibWriterMock.On("SaveE2TInstance", &updatedE2TInstance).Return(nil)
 154
 155         err := e2tInstancesManager.DissociateRan("test1", E2TAddress)
 156         assert.Nil(t, err)
 157         rnibReaderMock.AssertExpectations(t)
 158         rnibWriterMock.AssertExpectations(t)
 159 }
 160
 161 func TestDissociateRanGetInstanceFailure(t *testing.T) {
 162         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 163
 164         var e2tInstance1 *entities.E2TInstance
 165         rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, common.NewInternalError(fmt.Errorf("for test")))
 166         err := e2tInstancesManager.DissociateRan("test1", E2TAddress)
 167         assert.NotNil(t, err)
 168         rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
 169 }
 170
 171 func TestDissociateRanSaveInstanceFailure(t *testing.T) {
 172         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 173
 174         e2tInstance1  := entities.NewE2TInstance(E2TAddress)
 175         rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, nil)
 176         rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(common.NewInternalError(fmt.Errorf("for test")))
 177
 178         err := e2tInstancesManager.DissociateRan("test1", E2TAddress)
 179         assert.NotNil(t, err)
 180         rnibReaderMock.AssertExpectations(t)
 181         rnibWriterMock.AssertExpectations(t)
 182 }
 183
 184 func TestSelectE2TInstancesGetE2TAddressesFailure(t *testing.T) {
 185         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 186
 187         rnibReaderMock.On("GetE2TAddresses").Return([]string{}, common.NewInternalError(fmt.Errorf("for test")))
 188         address, err := e2tInstancesManager.SelectE2TInstance()
 189         assert.NotNil(t, err)
 190         assert.Empty(t, address)
 191         rnibReaderMock.AssertExpectations(t)
 192         rnibWriterMock.AssertNotCalled(t, "GetE2TInstances")
 193 }
 194
 195 func TestSelectE2TInstancesEmptyE2TAddressList(t *testing.T) {
 196         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 197
 198         rnibReaderMock.On("GetE2TAddresses").Return([]string{}, nil)
 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 TestSelectE2TInstancesGetE2TInstancesFailure(t *testing.T) {
 207         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 208
 209         addresses := []string{E2TAddress}
 210         rnibReaderMock.On("GetE2TAddresses").Return(addresses, nil)
 211         rnibReaderMock.On("GetE2TInstances",addresses ).Return([]*entities.E2TInstance{}, common.NewInternalError(fmt.Errorf("for test")))
 212         address, err := e2tInstancesManager.SelectE2TInstance()
 213         assert.NotNil(t, err)
 214         assert.Empty(t, address)
 215         rnibReaderMock.AssertExpectations(t)
 216         rnibWriterMock.AssertExpectations(t)
 217 }
 218
 219 func TestSelectE2TInstancesEmptyE2TInstancesList(t *testing.T) {
 220         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 221
 222         addresses := []string{E2TAddress}
 223         rnibReaderMock.On("GetE2TAddresses").Return(addresses, nil)
 224         rnibReaderMock.On("GetE2TInstances",addresses ).Return([]*entities.E2TInstance{}, nil)
 225         address, err := e2tInstancesManager.SelectE2TInstance()
 226         assert.NotNil(t, err)
 227         assert.Empty(t, address)
 228         rnibReaderMock.AssertExpectations(t)
 229         rnibWriterMock.AssertExpectations(t)
 230 }
 231
 232 func TestSelectE2TInstancesNoActiveE2TInstance(t *testing.T) {
 233         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 234         addresses := []string{E2TAddress,E2TAddress2}
 235         e2tInstance1 := entities.NewE2TInstance(E2TAddress)
 236         e2tInstance1.State = entities.ToBeDeleted
 237         e2tInstance1.AssociatedRanList = []string{"test1","test2","test3"}
 238         e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
 239         e2tInstance2.State = entities.ToBeDeleted
 240         e2tInstance2.AssociatedRanList = []string{"test4","test5","test6", "test7"}
 241
 242         rnibReaderMock.On("GetE2TAddresses").Return(addresses, nil)
 243         rnibReaderMock.On("GetE2TInstances",addresses).Return([]*entities.E2TInstance{e2tInstance1, e2tInstance2}, nil)
 244         address, err := e2tInstancesManager.SelectE2TInstance()
 245         assert.NotNil(t, err)
 246         assert.Equal(t, "", address)
 247         rnibReaderMock.AssertExpectations(t)
 248         rnibWriterMock.AssertExpectations(t)
 249 }
 250
 251 func TestSelectE2TInstancesSuccess(t *testing.T) {
 252         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 253         addresses := []string{E2TAddress,E2TAddress2}
 254         e2tInstance1 := entities.NewE2TInstance(E2TAddress)
 255         e2tInstance1.AssociatedRanList = []string{"test1","test2","test3"}
 256         e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
 257         e2tInstance2.AssociatedRanList = []string{"test4","test5","test6", "test7"}
 258
 259         rnibReaderMock.On("GetE2TAddresses").Return(addresses, nil)
 260         rnibReaderMock.On("GetE2TInstances",addresses).Return([]*entities.E2TInstance{e2tInstance1, e2tInstance2}, nil)
 261         address, err := e2tInstancesManager.SelectE2TInstance()
 262         assert.Nil(t, err)
 263         assert.Equal(t, E2TAddress, address)
 264         rnibReaderMock.AssertExpectations(t)
 265         rnibWriterMock.AssertExpectations(t)
 266 }
 267
 268 func TestRemoveE2TInstance(t *testing.T) {
 269         _, _, e2tInstancesManager := initE2TInstancesManagerTest(t)
 270         e2tInstance1  := entities.NewE2TInstance(E2TAddress)
 271         err := e2tInstancesManager.RemoveE2TInstance(e2tInstance1)
 272         assert.Nil(t, err)
 273 }