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