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, "GetE2TAddresses")
  46 }
  47
  48 func TestAddNewE2TInstanceGetE2TAddressesInternalFailure(t *testing.T) {
  49         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
  50         rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
  51         e2tAddresses := []string{}
  52         rnibReaderMock.On("GetE2TAddresses").Return(e2tAddresses, common.NewInternalError(errors.New("Error")))
  53         err := e2tInstancesManager.AddE2TInstance(E2TAddress)
  54         assert.NotNil(t, err)
  55         rnibReaderMock.AssertNotCalled(t, "SaveE2TAddresses")
  56 }
  57
  58 func TestAddNewE2TInstanceNoE2TAddresses(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.NewResourceNotFoundError(""))
  63         e2tAddresses = append(e2tAddresses, E2TAddress)
  64         rnibWriterMock.On("SaveE2TAddresses", e2tAddresses).Return(nil)
  65         err := e2tInstancesManager.AddE2TInstance(E2TAddress)
  66         assert.Nil(t, err)
  67         rnibWriterMock.AssertCalled(t, "SaveE2TAddresses", e2tAddresses)
  68 }
  69
  70 func TestAddNewE2TInstanceEmptyE2TAddresses(t *testing.T) {
  71         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
  72         rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
  73         e2tAddresses := []string{}
  74         rnibReaderMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
  75         e2tAddresses = append(e2tAddresses, E2TAddress)
  76         rnibWriterMock.On("SaveE2TAddresses", e2tAddresses).Return(nil)
  77         err := e2tInstancesManager.AddE2TInstance(E2TAddress)
  78         assert.Nil(t, err)
  79         rnibWriterMock.AssertCalled(t, "SaveE2TAddresses", e2tAddresses)
  80 }
  81
  82 func TestAddNewE2TInstanceSaveE2TAddressesFailure(t *testing.T) {
  83         rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
  84         rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
  85         E2TAddresses := []string{}
  86         rnibReaderMock.On("GetE2TAddresses").Return(E2TAddresses, nil)
  87         E2TAddresses = append(E2TAddresses, E2TAddress)
  88         rnibWriterMock.On("SaveE2TAddresses", E2TAddresses).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("SaveE2TAddresses", 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, "SaveE2TAddresses")
 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("SaveE2TAddresses", 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("SaveE2TAddresses", 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("SaveE2TAddresses", 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("SaveE2TAddresses", 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.DissociateRan("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.DissociateRan("test1", address1)
 259 //      assert.Nil(t, err)
 260 //      rnibWriterMock.AssertNotCalled(t, "SaveE2TAddresses")
 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.DissociateRan("test1", address1)
 274 //      assert.NotNil(t, err)
 275 //      rnibWriterMock.AssertNotCalled(t, "SaveE2TAddresses")
 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("SaveE2TAddresses", e2tInfoList).Return(common.NewInternalError(fmt.Errorf("for test")))
 293 //
 294 //      err := e2tInstancesManager.DissociateRan("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("SaveE2TAddresses", 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.DissociateRan("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("SaveE2TAddresses", 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.DissociateRan("test1", address1)
 343 //      assert.NotNil(t, err)
 344 //      rnibReaderMock.AssertExpectations(t)
 345 //      rnibWriterMock.AssertExpectations(t)
 346 //}
 347
 348 func TestRemoveE2TInstance(t *testing.T) {
 349         _, _, e2tInstancesManager := initE2TInstancesManagerTest(t)
 350         address1 := "10.10.2.15:9800"
 351         e2tInstance1  := entities.NewE2TInstance(address1)
 352         err := e2tInstancesManager.RemoveE2TInstance(e2tInstance1)
 353         assert.Nil(t, err)
 354 }