E2Manager/managers/e2t_association_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 //  This source code is part of the near-RT RIC (RAN Intelligent Controller)
  18 //  platform project (RICP).
  19
  20 package managers
  21
  22 import (
  23         "bytes"
  24         "e2mgr/clients"
  25         "e2mgr/configuration"
  26         "e2mgr/e2managererrors"
  27         "e2mgr/mocks"
  28         "e2mgr/models"
  29         "e2mgr/services"
  30         "encoding/json"
  31         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
  32         "github.com/pkg/errors"
  33         "github.com/stretchr/testify/assert"
  34         "github.com/stretchr/testify/mock"
  35         "io/ioutil"
  36         "net/http"
  37         "testing"
  38 )
  39
  40 const RanName = "test"
  41
  42 func initE2TAssociationManagerTest(t *testing.T) (*E2TAssociationManager, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.HttpClientMock) {
  43         log := initLog(t)
  44         config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3}
  45
  46         readerMock := &mocks.RnibReaderMock{}
  47         writerMock := &mocks.RnibWriterMock{}
  48         rnibDataService := services.NewRnibDataService(log, config, readerMock, writerMock)
  49
  50         e2tInstancesManager := NewE2TInstancesManager(rnibDataService, log)
  51         httpClientMock := &mocks.HttpClientMock{}
  52         rmClient := clients.NewRoutingManagerClient(log, config, httpClientMock)
  53         manager := NewE2TAssociationManager(log, rnibDataService, e2tInstancesManager, rmClient)
  54
  55         return manager, readerMock, writerMock, httpClientMock
  56 }
  57
  58 func mockHttpClient(httpClientMock *mocks.HttpClientMock, apiSuffix string, isSuccessful bool) {
  59         data := models.RoutingManagerE2TDataList{models.NewRoutingManagerE2TData(E2TAddress, RanName)}
  60         marshaled, _ := json.Marshal(data)
  61         body := bytes.NewBuffer(marshaled)
  62         respBody := ioutil.NopCloser(bytes.NewBufferString(""))
  63         var respStatusCode int
  64         if isSuccessful {
  65                 respStatusCode = http.StatusCreated
  66         } else {
  67                 respStatusCode = http.StatusBadRequest
  68         }
  69         httpClientMock.On("Post", apiSuffix, "application/json", body).Return(&http.Response{StatusCode: respStatusCode, Body: respBody}, nil)
  70 }
  71
  72 func TestAssociateRanSuccess(t *testing.T) {
  73         manager, readerMock, writerMock, httpClientMock := initE2TAssociationManagerTest(t)
  74         mockHttpClient(httpClientMock, clients.AssociateRanToE2TInstanceApiSuffix, true)
  75         nb := &entities.NodebInfo{RanName: RanName, AssociatedE2TInstanceAddress: "", ConnectionAttempts: 1}
  76         updatedNb := *nb
  77         updatedNb.ConnectionAttempts = 0
  78         updatedNb.AssociatedE2TInstanceAddress = E2TAddress
  79         writerMock.On("UpdateNodebInfo", &updatedNb).Return(nil)
  80         e2tInstance := &entities.E2TInstance{Address: E2TAddress}
  81         readerMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance, nil)
  82         updatedE2tInstance := *e2tInstance
  83         updatedE2tInstance.AssociatedRanList = append(updatedE2tInstance.AssociatedRanList, RanName)
  84         writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(nil)
  85
  86         err := manager.AssociateRan(E2TAddress, nb)
  87
  88         assert.Nil(t, err)
  89         readerMock.AssertExpectations(t)
  90         writerMock.AssertExpectations(t)
  91         httpClientMock.AssertExpectations(t)
  92 }
  93
  94 func TestAssociateRanRoutingManagerError(t *testing.T) {
  95         manager, readerMock, writerMock, httpClientMock := initE2TAssociationManagerTest(t)
  96         mockHttpClient(httpClientMock, clients.AssociateRanToE2TInstanceApiSuffix, false)
  97
  98         nb := &entities.NodebInfo{RanName: RanName, AssociatedE2TInstanceAddress: "", ConnectionAttempts: 1}
  99         err := manager.AssociateRan(E2TAddress, nb)
 100
 101         assert.NotNil(t, err)
 102         assert.IsType(t, &e2managererrors.RoutingManagerError{}, err)
 103         readerMock.AssertExpectations(t)
 104         writerMock.AssertExpectations(t)
 105         httpClientMock.AssertExpectations(t)
 106 }
 107
 108 func TestAssociateRanUpdateNodebError(t *testing.T) {
 109         manager, readerMock, writerMock, httpClientMock := initE2TAssociationManagerTest(t)
 110         mockHttpClient(httpClientMock, clients.AssociateRanToE2TInstanceApiSuffix, true)
 111         nb := &entities.NodebInfo{RanName: RanName, AssociatedE2TInstanceAddress: "", ConnectionAttempts: 1}
 112         updatedNb := *nb
 113         updatedNb.ConnectionAttempts = 0
 114         updatedNb.AssociatedE2TInstanceAddress = E2TAddress
 115         writerMock.On("UpdateNodebInfo", &updatedNb).Return(e2managererrors.NewRnibDbError())
 116
 117         err := manager.AssociateRan(E2TAddress, nb)
 118
 119         assert.NotNil(t, err)
 120         assert.IsType(t, &e2managererrors.RnibDbError{}, err)
 121         readerMock.AssertExpectations(t)
 122         writerMock.AssertExpectations(t)
 123         httpClientMock.AssertExpectations(t)
 124 }
 125
 126 func TestAssociateRanGetE2tInstanceError(t *testing.T) {
 127         manager, readerMock, writerMock, httpClientMock := initE2TAssociationManagerTest(t)
 128         mockHttpClient(httpClientMock, clients.AssociateRanToE2TInstanceApiSuffix, true)
 129         nb := &entities.NodebInfo{RanName: RanName, AssociatedE2TInstanceAddress: "", ConnectionAttempts: 1}
 130         updatedNb := *nb
 131         updatedNb.ConnectionAttempts = 0
 132         updatedNb.AssociatedE2TInstanceAddress = E2TAddress
 133         writerMock.On("UpdateNodebInfo", &updatedNb).Return(nil)
 134         var e2tInstance *entities.E2TInstance
 135         readerMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance, errors.New("test"))
 136
 137         err := manager.AssociateRan(E2TAddress, nb)
 138
 139         assert.NotNil(t, err)
 140         assert.IsType(t, &e2managererrors.RnibDbError{}, err)
 141         readerMock.AssertExpectations(t)
 142         writerMock.AssertExpectations(t)
 143         httpClientMock.AssertExpectations(t)
 144 }
 145
 146 func TestAssociateRanSaveE2tInstanceError(t *testing.T) {
 147         manager, readerMock, writerMock, httpClientMock := initE2TAssociationManagerTest(t)
 148         mockHttpClient(httpClientMock, clients.AssociateRanToE2TInstanceApiSuffix, true)
 149         nb := &entities.NodebInfo{RanName: RanName, AssociatedE2TInstanceAddress: "", ConnectionAttempts: 1}
 150         updatedNb := *nb
 151         updatedNb.ConnectionAttempts = 0
 152         updatedNb.AssociatedE2TInstanceAddress = E2TAddress
 153         writerMock.On("UpdateNodebInfo", &updatedNb).Return(nil)
 154         e2tInstance := &entities.E2TInstance{Address: E2TAddress}
 155         readerMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance, nil)
 156         updatedE2tInstance := *e2tInstance
 157         updatedE2tInstance.AssociatedRanList = append(updatedE2tInstance.AssociatedRanList, RanName)
 158         writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(errors.New("test"))
 159
 160         err := manager.AssociateRan(E2TAddress, nb)
 161
 162         assert.NotNil(t, err)
 163         assert.IsType(t, &e2managererrors.RnibDbError{}, err)
 164         readerMock.AssertExpectations(t)
 165         writerMock.AssertExpectations(t)
 166         httpClientMock.AssertExpectations(t)
 167 }
 168
 169 func TestDissociateRanSuccess(t *testing.T) {
 170         manager, readerMock, writerMock, httpClientMock := initE2TAssociationManagerTest(t)
 171         mockHttpClient(httpClientMock, clients.DissociateRanE2TInstanceApiSuffix, true)
 172         nb := &entities.NodebInfo{RanName: RanName, AssociatedE2TInstanceAddress: E2TAddress, ConnectionAttempts: 1}
 173         readerMock.On("GetNodeb", RanName).Return(nb, nil)
 174         updatedNb := *nb
 175         updatedNb.AssociatedE2TInstanceAddress = ""
 176         writerMock.On("UpdateNodebInfo", &updatedNb).Return(nil)
 177         e2tInstance := &entities.E2TInstance{Address: E2TAddress}
 178         e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
 179         readerMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance, nil)
 180         updatedE2tInstance := *e2tInstance
 181         updatedE2tInstance.AssociatedRanList = []string{}
 182         writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(nil)
 183
 184         err := manager.DissociateRan(E2TAddress, RanName)
 185
 186         assert.Nil(t, err)
 187         readerMock.AssertExpectations(t)
 188         writerMock.AssertExpectations(t)
 189         httpClientMock.AssertExpectations(t)
 190 }
 191
 192 func TestDissociateRanGetNodebError(t *testing.T) {
 193         manager, readerMock, writerMock, httpClientMock := initE2TAssociationManagerTest(t)
 194         var nb *entities.NodebInfo
 195         readerMock.On("GetNodeb", RanName).Return(nb, e2managererrors.NewRnibDbError())
 196
 197         err := manager.DissociateRan(E2TAddress, RanName)
 198
 199         assert.NotNil(t, err)
 200         assert.IsType(t, &e2managererrors.RnibDbError{}, err)
 201         readerMock.AssertExpectations(t)
 202         writerMock.AssertExpectations(t)
 203         httpClientMock.AssertExpectations(t)
 204 }
 205
 206 func TestDissociateRanUpdateNodebError(t *testing.T) {
 207         manager, readerMock, writerMock, httpClientMock := initE2TAssociationManagerTest(t)
 208         nb := &entities.NodebInfo{RanName: RanName, AssociatedE2TInstanceAddress: E2TAddress, ConnectionAttempts: 1}
 209         readerMock.On("GetNodeb", RanName).Return(nb, nil)
 210         updatedNb := *nb
 211         updatedNb.AssociatedE2TInstanceAddress = ""
 212         writerMock.On("UpdateNodebInfo", &updatedNb).Return(e2managererrors.NewRnibDbError())
 213
 214         err := manager.DissociateRan(E2TAddress, RanName)
 215
 216         assert.NotNil(t, err)
 217         assert.IsType(t, &e2managererrors.RnibDbError{}, err)
 218         readerMock.AssertExpectations(t)
 219         writerMock.AssertExpectations(t)
 220         httpClientMock.AssertExpectations(t)
 221 }
 222
 223 func TestDissociateRanGetE2tInstanceError(t *testing.T) {
 224         manager, readerMock, writerMock, httpClientMock := initE2TAssociationManagerTest(t)
 225         nb := &entities.NodebInfo{RanName: RanName, AssociatedE2TInstanceAddress: E2TAddress, ConnectionAttempts: 1}
 226         readerMock.On("GetNodeb", RanName).Return(nb, nil)
 227         updatedNb := *nb
 228         updatedNb.AssociatedE2TInstanceAddress = ""
 229         writerMock.On("UpdateNodebInfo", &updatedNb).Return(nil)
 230         var e2tInstance *entities.E2TInstance
 231         readerMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance, errors.New("test"))
 232
 233         err := manager.DissociateRan(E2TAddress, RanName)
 234
 235         assert.NotNil(t, err)
 236         assert.IsType(t, &e2managererrors.RnibDbError{}, err)
 237         readerMock.AssertExpectations(t)
 238         writerMock.AssertExpectations(t)
 239         httpClientMock.AssertExpectations(t)
 240 }
 241
 242 func TestDissociateRanSaveE2tInstanceError(t *testing.T) {
 243         manager, readerMock, writerMock, httpClientMock := initE2TAssociationManagerTest(t)
 244         nb := &entities.NodebInfo{RanName: RanName, AssociatedE2TInstanceAddress: E2TAddress, ConnectionAttempts: 1}
 245         readerMock.On("GetNodeb", RanName).Return(nb, nil)
 246         updatedNb := *nb
 247         updatedNb.AssociatedE2TInstanceAddress = ""
 248         writerMock.On("UpdateNodebInfo", &updatedNb).Return(nil)
 249         e2tInstance := &entities.E2TInstance{Address: E2TAddress}
 250         e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
 251         readerMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance, nil)
 252         updatedE2tInstance := *e2tInstance
 253         updatedE2tInstance.AssociatedRanList = []string{}
 254         writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(errors.New("test"))
 255
 256         err := manager.DissociateRan(E2TAddress, RanName)
 257
 258         assert.NotNil(t, err)
 259         assert.IsType(t, &e2managererrors.RnibDbError{}, err)
 260         readerMock.AssertExpectations(t)
 261         writerMock.AssertExpectations(t)
 262         httpClientMock.AssertExpectations(t)
 263 }
 264
 265 func TestDissociateRanRoutingManagerError(t *testing.T) {
 266         manager, readerMock, writerMock, httpClientMock := initE2TAssociationManagerTest(t)
 267         mockHttpClient(httpClientMock, clients.DissociateRanE2TInstanceApiSuffix, false)
 268         nb := &entities.NodebInfo{RanName: RanName, AssociatedE2TInstanceAddress: E2TAddress, ConnectionAttempts: 1}
 269         readerMock.On("GetNodeb", RanName).Return(nb, nil)
 270         updatedNb := *nb
 271         updatedNb.AssociatedE2TInstanceAddress = ""
 272         writerMock.On("UpdateNodebInfo", &updatedNb).Return(nil)
 273         e2tInstance := &entities.E2TInstance{Address: E2TAddress}
 274         e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
 275         readerMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance, nil)
 276         updatedE2tInstance := *e2tInstance
 277         updatedE2tInstance.AssociatedRanList = []string{}
 278         writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(nil)
 279
 280         err := manager.DissociateRan(E2TAddress, RanName)
 281
 282         assert.Nil(t, err)
 283         readerMock.AssertExpectations(t)
 284         writerMock.AssertExpectations(t)
 285         httpClientMock.AssertExpectations(t)
 286 }
 287
 288 func TestRemoveE2tInstanceSuccess(t *testing.T) {
 289         manager, readerMock, writerMock, httpClientMock := initE2TAssociationManagerTest(t)
 290
 291         e2tDataList := models.RoutingManagerE2TDataList{models.NewRoutingManagerE2TData(E2TAddress2, RanName), models.NewRoutingManagerE2TData(E2TAddress3, "test1")}
 292         data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, nil, e2tDataList)
 293         mockHttpClientDelete(httpClientMock, data, true)
 294
 295         writerMock.On("RemoveE2TInstance", E2TAddress).Return(nil)
 296         e2tAddresses := []string{E2TAddress, E2TAddress2, E2TAddress3}
 297         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 298         e2tAddressesNew := []string{E2TAddress2, E2TAddress3}
 299         writerMock.On("SaveE2TAddresses", e2tAddressesNew).Return(nil)
 300
 301         e2tInstance1 := &entities.E2TInstance{Address: E2TAddress}
 302         e2tInstance2 := &entities.E2TInstance{Address: E2TAddress2}
 303         readerMock.On("GetE2TInstance", E2TAddress2).Return(e2tInstance2, nil)
 304         e2tInstance3 := &entities.E2TInstance{Address: E2TAddress3}
 305         readerMock.On("GetE2TInstance", E2TAddress3).Return(e2tInstance3, nil)
 306
 307         e2tInstance2updated := *e2tInstance2
 308         e2tInstance2updated.AssociatedRanList = []string{RanName}
 309         writerMock.On("SaveE2TInstance", &e2tInstance2updated).Return(nil)
 310         e2tInstance3updated := *e2tInstance3
 311         e2tInstance3updated.AssociatedRanList = []string{"test1"}
 312         writerMock.On("SaveE2TInstance", &e2tInstance3updated).Return(nil)
 313
 314         ranNamesToBeAssociated := make(map[string][]string)
 315         ranNamesToBeAssociated[E2TAddress2] = []string{RanName}
 316         ranNamesToBeAssociated[E2TAddress3] = []string{"test1"}
 317         err := manager.RemoveE2tInstance(e2tInstance1, nil, ranNamesToBeAssociated)
 318
 319         assert.Nil(t, err)
 320         readerMock.AssertExpectations(t)
 321         writerMock.AssertExpectations(t)
 322         httpClientMock.AssertExpectations(t)
 323 }
 324
 325 func TestRemoveE2tInstanceSuccessWithOrphans(t *testing.T) {
 326         manager, readerMock, writerMock, httpClientMock := initE2TAssociationManagerTest(t)
 327
 328         ranNamesToBeDissociated := []string{RanName, "test1"}
 329         data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, ranNamesToBeDissociated, nil)
 330         mockHttpClientDelete(httpClientMock, data, true)
 331
 332         writerMock.On("RemoveE2TInstance", E2TAddress).Return(nil)
 333         e2tAddresses := []string{E2TAddress}
 334         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 335         e2tAddressesNew := []string{}
 336         writerMock.On("SaveE2TAddresses", e2tAddressesNew).Return(nil)
 337
 338         e2tInstance1 := &entities.E2TInstance{Address: E2TAddress}
 339         err := manager.RemoveE2tInstance(e2tInstance1, ranNamesToBeDissociated, nil)
 340
 341         assert.Nil(t, err)
 342         readerMock.AssertExpectations(t)
 343         writerMock.AssertExpectations(t)
 344         httpClientMock.AssertExpectations(t)
 345 }
 346
 347 func TestRemoveE2tInstanceFailureRoutingManager(t *testing.T) {
 348         manager, readerMock, writerMock, httpClientMock := initE2TAssociationManagerTest(t)
 349
 350         e2tDataList := models.RoutingManagerE2TDataList{models.NewRoutingManagerE2TData(E2TAddress, RanName)}
 351         data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, []string{"test1"}, e2tDataList)
 352         mockHttpClientDelete(httpClientMock, data, false)
 353
 354         e2tInstance1 := entities.NewE2TInstance(E2TAddress)
 355         e2tInstance1.State = entities.Active
 356         readerMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, nil)
 357         e2tInstance2 := *e2tInstance1
 358         e2tInstance2.State = entities.RoutingManagerFailure
 359         writerMock.On("SaveE2TInstance", &e2tInstance2).Return(nil)
 360         ranNamesToBeAssociated := make(map[string][]string)
 361         ranNamesToBeAssociated[E2TAddress] = []string{"test"}
 362         err := manager.RemoveE2tInstance(e2tInstance1, []string{"test1"}, ranNamesToBeAssociated)
 363
 364         assert.NotNil(t, err)
 365         readerMock.AssertExpectations(t)
 366         writerMock.AssertExpectations(t)
 367         httpClientMock.AssertExpectations(t)
 368 }
 369
 370 func TestRemoveE2tInstanceFailureRoutingManagerAndGetInstance(t *testing.T) {
 371         manager, readerMock, writerMock, httpClientMock := initE2TAssociationManagerTest(t)
 372
 373         e2tDataList := models.RoutingManagerE2TDataList{models.NewRoutingManagerE2TData(E2TAddress, RanName)}
 374         data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, []string{"test1"}, e2tDataList)
 375         mockHttpClientDelete(httpClientMock, data, false)
 376
 377         e2tInstance1 := &entities.E2TInstance{Address: E2TAddress}
 378         readerMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, e2managererrors.NewRnibDbError())
 379         ranNamesToBeAssociated := make(map[string][]string)
 380         ranNamesToBeAssociated[E2TAddress] = []string{"test"}
 381         err := manager.RemoveE2tInstance(e2tInstance1, []string{"test1"}, ranNamesToBeAssociated)
 382
 383         assert.NotNil(t, err)
 384         readerMock.AssertExpectations(t)
 385         writerMock.AssertExpectations(t)
 386         httpClientMock.AssertExpectations(t)
 387 }
 388
 389 func TestRemoveE2tInstanceFailureRoutingManagerAndSetInstanceState(t *testing.T) {
 390         manager, readerMock, writerMock, httpClientMock := initE2TAssociationManagerTest(t)
 391
 392         e2tDataList := models.RoutingManagerE2TDataList{models.NewRoutingManagerE2TData(E2TAddress, RanName)}
 393         data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, []string{"test1"}, e2tDataList)
 394         mockHttpClientDelete(httpClientMock, data, false)
 395
 396         e2tInstance1 := entities.NewE2TInstance(E2TAddress)
 397         e2tInstance1.State = entities.Active
 398         readerMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, nil)
 399         e2tInstance2 := *e2tInstance1
 400         e2tInstance2.State = entities.RoutingManagerFailure
 401         writerMock.On("SaveE2TInstance", &e2tInstance2).Return(e2managererrors.NewRnibDbError())
 402         ranNamesToBeAssociated := make(map[string][]string)
 403         ranNamesToBeAssociated[E2TAddress] = []string{"test"}
 404         err := manager.RemoveE2tInstance(e2tInstance1, []string{"test1"}, ranNamesToBeAssociated)
 405
 406         assert.NotNil(t, err)
 407         readerMock.AssertExpectations(t)
 408         writerMock.AssertExpectations(t)
 409         httpClientMock.AssertExpectations(t)
 410 }
 411
 412 func TestRemoveE2tInstanceFailureInE2TInstanceManager(t *testing.T) {
 413
 414         e2tDataList := models.RoutingManagerE2TDataList{models.NewRoutingManagerE2TData(E2TAddress, RanName)}
 415         data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, []string{"test1"}, e2tDataList)
 416         manager, readerMock, writerMock, httpClientMock := initE2TAssociationManagerTest(t)
 417         mockHttpClientDelete(httpClientMock, data, true)
 418
 419         writerMock.On("RemoveE2TInstance", E2TAddress).Return(nil)
 420         var e2tAddresses []string
 421         readerMock.On("GetE2TAddresses").Return(e2tAddresses, e2managererrors.NewRnibDbError())
 422
 423         ranNamesToBeAssociated := make(map[string][]string)
 424         ranNamesToBeAssociated[E2TAddress] = []string{"test"}
 425         e2tInstance1 := &entities.E2TInstance{Address: E2TAddress}
 426         err := manager.RemoveE2tInstance(e2tInstance1, []string{"test1"}, ranNamesToBeAssociated)
 427
 428         assert.NotNil(t, err)
 429         readerMock.AssertExpectations(t)
 430         writerMock.AssertExpectations(t)
 431         httpClientMock.AssertExpectations(t)
 432 }
 433
 434 func TestRemoveE2tInstanceFailureInE2tInstanceAddRansToInstance(t *testing.T) {
 435         manager, readerMock, writerMock, httpClientMock := initE2TAssociationManagerTest(t)
 436
 437         e2tDataList := models.RoutingManagerE2TDataList{models.NewRoutingManagerE2TData(E2TAddress2, RanName), models.NewRoutingManagerE2TData(E2TAddress3, "test1")}
 438         data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, nil, e2tDataList)
 439         mockHttpClientDelete(httpClientMock, data, true)
 440
 441         writerMock.On("RemoveE2TInstance", E2TAddress).Return(nil)
 442         e2tAddresses := []string{E2TAddress, E2TAddress2, E2TAddress3}
 443         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 444         e2tAddressesNew := []string{E2TAddress2, E2TAddress3}
 445         writerMock.On("SaveE2TAddresses", e2tAddressesNew).Return(nil)
 446
 447         var e2tInstance2 *entities.E2TInstance
 448         readerMock.On("GetE2TInstance", mock.Anything).Return(e2tInstance2, e2managererrors.NewRnibDbError())
 449
 450         ranNamesToBeAssociated := make(map[string][]string)
 451         ranNamesToBeAssociated[E2TAddress2] = []string{RanName}
 452         ranNamesToBeAssociated[E2TAddress3] = []string{"test1"}
 453
 454         e2tInstance1 := &entities.E2TInstance{Address: E2TAddress}
 455         err := manager.RemoveE2tInstance(e2tInstance1, nil, ranNamesToBeAssociated)
 456
 457         assert.NotNil(t, err)
 458         readerMock.AssertExpectations(t)
 459         writerMock.AssertExpectations(t)
 460         httpClientMock.AssertExpectations(t)
 461 }
 462
 463 func mockHttpClientDelete(httpClientMock *mocks.HttpClientMock, data *models.RoutingManagerDeleteRequestModel, isSuccessful bool) {
 464
 465         marshaled, _ := json.Marshal(data)
 466         body := bytes.NewBuffer(marshaled)
 467         respBody := ioutil.NopCloser(bytes.NewBufferString(""))
 468         var respStatusCode int
 469         if isSuccessful {
 470                 respStatusCode = http.StatusCreated
 471         } else {
 472                 respStatusCode = http.StatusBadRequest
 473         }
 474         httpClientMock.On("Delete", "e2t", "application/json", body).Return(&http.Response{StatusCode: respStatusCode, Body: respBody}, nil)
 475 }