E2Manager/handlers/httpmsghandlers/delete_all_request_handler_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 httpmsghandlers
  21
  22 import (
  23         "bytes"
  24         "e2mgr/clients"
  25         "e2mgr/configuration"
  26         "e2mgr/e2managererrors"
  27         "e2mgr/logger"
  28         "e2mgr/managers"
  29         "e2mgr/mocks"
  30         "e2mgr/models"
  31         "e2mgr/rmrCgo"
  32         "e2mgr/services"
  33         "e2mgr/services/rmrsender"
  34         "e2mgr/tests"
  35         "encoding/json"
  36         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
  37         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
  38         "github.com/pkg/errors"
  39         "github.com/stretchr/testify/assert"
  40         "io/ioutil"
  41         "net/http"
  42         "testing"
  43 )
  44
  45 const E2TAddress = "10.0.2.15:8989"
  46 const BaseRMUrl = "http://10.10.2.15:12020/routingmanager"
  47
  48 func setupDeleteAllRequestHandlerTest(t *testing.T) (*DeleteAllRequestHandler, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.RmrMessengerMock, *mocks.HttpClientMock, managers.RanListManager) {
  49         log := initLog(t)
  50         config := &configuration.Configuration{RnibWriter: configuration.RnibWriterConfig{StateChangeMessageChannel: "RAN_CONNECTION_STATUS_CHANGE"}}
  51         config.BigRedButtonTimeoutSec = 1
  52         config.RoutingManager.BaseUrl = BaseRMUrl
  53
  54         readerMock := &mocks.RnibReaderMock{}
  55         writerMock := &mocks.RnibWriterMock{}
  56         rnibDataService := services.NewRnibDataService(log, config, readerMock, writerMock)
  57
  58         rmrMessengerMock := &mocks.RmrMessengerMock{}
  59         rmrSender := getRmrSender(rmrMessengerMock, log)
  60
  61         e2tInstancesManager := managers.NewE2TInstancesManager(rnibDataService, log)
  62         httpClientMock := &mocks.HttpClientMock{}
  63         rmClient := clients.NewRoutingManagerClient(log, config, httpClientMock)
  64
  65         ranListManager := managers.NewRanListManager(log, rnibDataService)
  66         ranAlarmService := services.NewRanAlarmService(log, config)
  67         ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(log, rnibDataService, ranListManager, ranAlarmService)
  68
  69         handler := NewDeleteAllRequestHandler(log, rmrSender, config, rnibDataService, e2tInstancesManager, rmClient, ranConnectStatusChangeManager, ranListManager)
  70         return handler, readerMock, writerMock, rmrMessengerMock, httpClientMock, ranListManager
  71 }
  72
  73 func mapE2TAddressesToE2DataList(e2tAddresses []string) models.RoutingManagerE2TDataList {
  74         e2tDataList := make(models.RoutingManagerE2TDataList, len(e2tAddresses))
  75
  76         for i, v := range e2tAddresses {
  77                 e2tDataList[i] = models.NewRoutingManagerE2TData(v)
  78         }
  79
  80         return e2tDataList
  81 }
  82
  83 func mockHttpClientDissociateAllRans(httpClientMock *mocks.HttpClientMock, e2tAddresses []string, ok bool) {
  84         data := mapE2TAddressesToE2DataList(e2tAddresses)
  85         marshaled, _ := json.Marshal(data)
  86         body := bytes.NewBuffer(marshaled)
  87         url := BaseRMUrl + clients.DissociateRanE2TInstanceApiSuffix
  88         respBody := ioutil.NopCloser(bytes.NewBufferString(""))
  89
  90         var status int
  91         if ok {
  92                 status = http.StatusOK
  93         } else {
  94                 status = http.StatusBadRequest
  95         }
  96         httpClientMock.On("Post", url, "application/json", body).Return(&http.Response{StatusCode: status, Body: respBody}, nil)
  97 }
  98
  99 func TestGetE2TAddressesFailure(t *testing.T) {
 100         h, readerMock, _, _, _, _ := setupDeleteAllRequestHandlerTest(t)
 101         readerMock.On("GetE2TAddresses").Return([]string{}, common.NewInternalError(errors.New("error")))
 102         _, err := h.Handle(nil)
 103         assert.IsType(t, &e2managererrors.RnibDbError{}, err)
 104         readerMock.AssertExpectations(t)
 105 }
 106
 107 func TestOneRanGetE2TAddressesEmptyList(t *testing.T) {
 108         h, readerMock, writerMock, _, _, ranListManager := setupDeleteAllRequestHandlerTest(t)
 109
 110         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
 111         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 112
 113         err := ranListManager.InitNbIdentityMap()
 114         if err != nil {
 115                 t.Errorf("Error cannot init identity")
 116         }
 117
 118         readerMock.On("GetE2TAddresses").Return([]string{}, nil)
 119         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED}
 120         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 121         updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN}
 122         writerMock.On("UpdateNodebInfo", updatedNb1).Return(nil)
 123         _, err = h.Handle(nil)
 124         assert.Nil(t, err)
 125         readerMock.AssertExpectations(t)
 126         writerMock.AssertExpectations(t)
 127 }
 128
 129 func TestTwoRansGetE2TAddressesEmptyListOneGetNodebFailure(t *testing.T) {
 130         h, readerMock, writerMock, _, _, ranListManager := setupDeleteAllRequestHandlerTest(t)
 131
 132         readerMock.On("GetE2TAddresses").Return([]string{}, nil)
 133         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}, {InventoryName: "RanName_2"}}
 134         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 135
 136         _ = ranListManager.InitNbIdentityMap()
 137
 138         var err error
 139         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED}
 140         readerMock.On("GetNodeb", "RanName_1").Return(nb1, err)
 141
 142         updatedNb1 := *nb1
 143         updatedNb1.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
 144         writerMock.On("UpdateNodebInfo", &updatedNb1).Return(nil)
 145
 146         var nb2 *entities.NodebInfo
 147         readerMock.On("GetNodeb", "RanName_2").Return(nb2, common.NewInternalError(errors.New("error")))
 148         _, err = h.Handle(nil)
 149         assert.IsType(t, &e2managererrors.RnibDbError{}, err)
 150         writerMock.AssertNotCalled(t, "UpdateNodebInfo", nb2)
 151         readerMock.AssertCalled(t, "GetE2TAddresses")
 152         readerMock.AssertCalled(t, "GetListNodebIds")
 153         readerMock.AssertCalled(t, "GetNodeb", "RanName_2")
 154 }
 155
 156 func TestUpdateNodebInfoOnConnectionStatusInversionFailure(t *testing.T) {
 157         h, readerMock, writerMock, _, _, ranListManager := setupDeleteAllRequestHandlerTest(t)
 158
 159         readerMock.On("GetE2TAddresses").Return([]string{}, nil)
 160         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}, {InventoryName: "RanName_2"}}
 161         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 162
 163         _ = ranListManager.InitNbIdentityMap()
 164
 165         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_CONNECTED}
 166         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 167
 168         nb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN}
 169         readerMock.On("GetNodeb", "RanName_2").Return(nb2, nil)
 170         writerMock.On("UpdateNodebInfo", nb2).Return(nil)
 171
 172         updatedNb1 := *nb1
 173         updatedNb1.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
 174         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", &updatedNb1, "RanName_1_DISCONNECTED").Return(common.NewInternalError(errors.New("error")))
 175
 176         _, err := h.Handle(nil)
 177
 178         assert.IsType(t, &e2managererrors.RnibDbError{}, err)
 179         writerMock.AssertCalled(t, "UpdateNodebInfoOnConnectionStatusInversion", &updatedNb1, "RanName_1_DISCONNECTED")
 180         readerMock.AssertCalled(t, "GetE2TAddresses")
 181         readerMock.AssertCalled(t, "GetListNodebIds")
 182         readerMock.AssertCalled(t, "GetNodeb", "RanName_1")
 183 }
 184
 185 func TestTwoRansGetE2TAddressesEmptyListOneUpdateNodebInfoFailure(t *testing.T) {
 186         h, readerMock, writerMock, _, _, ranListManager := setupDeleteAllRequestHandlerTest(t)
 187
 188         readerMock.On("GetE2TAddresses").Return([]string{}, nil)
 189         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}, {InventoryName: "RanName_2"}}
 190         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 191
 192         err := ranListManager.InitNbIdentityMap()
 193         if err != nil {
 194                 t.Errorf("Error cannot init identity")
 195         }
 196
 197         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED}
 198         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 199         updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN}
 200         writerMock.On("UpdateNodebInfo", updatedNb1).Return(nil)
 201
 202         nb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED}
 203         readerMock.On("GetNodeb", "RanName_2").Return(nb2, nil)
 204         updatedNb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN}
 205         writerMock.On("UpdateNodebInfo", updatedNb2).Return(common.NewInternalError(errors.New("error")))
 206         _, err = h.Handle(nil)
 207         assert.IsType(t, &e2managererrors.RnibDbError{}, err)
 208         readerMock.AssertCalled(t, "GetE2TAddresses")
 209         readerMock.AssertCalled(t, "GetListNodebIds")
 210         readerMock.AssertCalled(t, "GetNodeb", "RanName_2")
 211         writerMock.AssertCalled(t, "UpdateNodebInfo", updatedNb2)
 212 }
 213
 214 func TestOneRanWithStateShutDown(t *testing.T) {
 215         h, readerMock, writerMock, rmrMessengerMock, httpClientMock, ranListManager := setupDeleteAllRequestHandlerTest(t)
 216         e2tAddresses := []string{E2TAddress}
 217         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 218         mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, true)
 219         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
 220         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 221
 222         err := ranListManager.InitNbIdentityMap()
 223         if err != nil {
 224                 t.Errorf("Error cannot init identity")
 225         }
 226
 227         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN}
 228         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 229         readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
 230
 231         e2tInstance := entities.E2TInstance{Address: E2TAddress, AssociatedRanList: []string{"RanName_1"}}
 232         readerMock.On("GetE2TInstances", []string{E2TAddress}).Return([]*entities.E2TInstance{&e2tInstance}, nil)
 233         updatedE2tInstance := e2tInstance
 234         updatedE2tInstance.AssociatedRanList = []string{}
 235         writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(nil)
 236
 237         rmrMessage := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
 238         mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction, rmrMessage.GetMsgSrc())
 239         rmrMessengerMock.On("SendMsg", mbuf, true).Return(mbuf, nil)
 240
 241         _, err = h.Handle(nil)
 242
 243         assert.Nil(t, err)
 244         rmrMessengerMock.AssertCalled(t, "SendMsg", mbuf, true)
 245         readerMock.AssertExpectations(t)
 246         writerMock.AssertExpectations(t)
 247 }
 248
 249 func TestOneRanShutDown(t *testing.T) {
 250         h, readerMock, writerMock, _, httpClientMock, ranListManager := setupDeleteAllRequestHandlerTest(t)
 251         e2tAddresses := []string{}
 252         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 253         mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, true)
 254         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
 255         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 256
 257         err := ranListManager.InitNbIdentityMap()
 258         if err != nil {
 259                 t.Errorf("Error cannot init identity")
 260         }
 261
 262         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN}
 263         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 264
 265         nodeb1NotAssociated := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN}
 266         writerMock.On("UpdateNodebInfo", nodeb1NotAssociated).Return(nil)
 267
 268         readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
 269
 270         _, err = h.Handle(nil)
 271
 272         assert.Nil(t, err)
 273         readerMock.AssertExpectations(t)
 274         writerMock.AssertExpectations(t)
 275 }
 276
 277 func TestOneRanTryShuttingDownSucceedsClearFails(t *testing.T) {
 278         h, readerMock, writerMock, _, httpClientMock, ranListManager := setupDeleteAllRequestHandlerTest(t)
 279
 280         e2tAddresses := []string{E2TAddress}
 281         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 282         mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, true)
 283         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
 284         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 285
 286         err := ranListManager.InitNbIdentityMap()
 287         if err != nil {
 288                 t.Errorf("Error cannot init identity")
 289         }
 290
 291         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_CONNECTED, AssociatedE2TInstanceAddress: E2TAddress}
 292         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 293
 294         updatedNb1 := *nb1
 295         updatedNb1.ConnectionStatus = entities.ConnectionStatus_SHUTTING_DOWN
 296         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", &updatedNb1, "RanName_1_DISCONNECTED").Return(nil)
 297
 298         nodeb1NotAssociated := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN}
 299         writerMock.On("UpdateNodebInfo", nodeb1NotAssociated).Return(nil)
 300
 301         readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
 302         readerMock.On("GetE2TInstances", []string{E2TAddress}).Return([]*entities.E2TInstance{}, common.NewInternalError(errors.New("error")))
 303         _, err = h.Handle(nil)
 304         assert.IsType(t, &e2managererrors.RnibDbError{}, err)
 305         readerMock.AssertExpectations(t)
 306         writerMock.AssertExpectations(t)
 307 }
 308
 309 func TestOneRanTryShuttingDownUpdateNodebError(t *testing.T) {
 310         h, readerMock, writerMock, _, httpClientMock, ranListManager := setupDeleteAllRequestHandlerTest(t)
 311
 312         e2tAddresses := []string{E2TAddress}
 313         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 314         mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, true)
 315         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
 316         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 317
 318         err := ranListManager.InitNbIdentityMap()
 319         if err != nil {
 320                 t.Errorf("Error cannot init identity")
 321         }
 322
 323         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_CONNECTED, AssociatedE2TInstanceAddress: E2TAddress}
 324         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 325
 326         updatedNb1 := *nb1
 327         updatedNb1.ConnectionStatus = entities.ConnectionStatus_SHUTTING_DOWN
 328         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", &updatedNb1, "RanName_1_DISCONNECTED").Return(nil)
 329
 330         nodeb1NotAssociated := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN}
 331         writerMock.On("UpdateNodebInfo", nodeb1NotAssociated).Return(common.NewInternalError(errors.New("error")))
 332
 333         _, err = h.Handle(nil)
 334
 335         assert.IsType(t, &e2managererrors.RnibDbError{}, err)
 336         readerMock.AssertExpectations(t)
 337         writerMock.AssertExpectations(t)
 338 }
 339
 340 func TestOneRanTryShuttingDownSucceedsClearSucceedsRmrSendFails(t *testing.T) {
 341         h, readerMock, writerMock, rmrMessengerMock, httpClientMock, ranListManager := setupDeleteAllRequestHandlerTest(t)
 342
 343         e2tAddresses := []string{E2TAddress}
 344         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 345         mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, true)
 346         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
 347         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 348
 349         err := ranListManager.InitNbIdentityMap()
 350         if err != nil {
 351                 t.Errorf("Error cannot init identity")
 352         }
 353
 354         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_CONNECTED, AssociatedE2TInstanceAddress: E2TAddress}
 355         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 356
 357         updatedNb1 := *nb1
 358         updatedNb1.ConnectionStatus = entities.ConnectionStatus_SHUTTING_DOWN
 359         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", &updatedNb1, "RanName_1_DISCONNECTED").Return(nil)
 360
 361         nodeb1NotAssociated := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN}
 362         writerMock.On("UpdateNodebInfo", nodeb1NotAssociated).Return(nil)
 363
 364         readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
 365         e2tInstance := entities.E2TInstance{Address: E2TAddress, AssociatedRanList: []string{"RanName_1"}}
 366         readerMock.On("GetE2TInstances", []string{E2TAddress}).Return([]*entities.E2TInstance{&e2tInstance}, nil)
 367         updatedE2tInstance := e2tInstance
 368         updatedE2tInstance.AssociatedRanList = []string{}
 369         writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(nil)
 370
 371         rmrMessage := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
 372         mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction, rmrMessage.GetMsgSrc())
 373         rmrMessengerMock.On("SendMsg", mbuf, true).Return(mbuf, e2managererrors.NewRmrError())
 374         _, err = h.Handle(nil)
 375         assert.IsType(t, &e2managererrors.RmrError{}, err)
 376         rmrMessengerMock.AssertCalled(t, "SendMsg", mbuf, true)
 377         readerMock.AssertExpectations(t)
 378         writerMock.AssertExpectations(t)
 379 }
 380
 381 func testTwoRansTryShuttingDownSucceedsClearSucceedsRmrSucceedsAllRansAreShutdown(t *testing.T, partial bool) {
 382         h, readerMock, writerMock, rmrMessengerMock, httpClientMock, ranListManager := setupDeleteAllRequestHandlerTest(t)
 383
 384         e2tAddresses := []string{E2TAddress}
 385         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 386         mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, !partial)
 387         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}, {InventoryName: "RanName_2"}}
 388         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 389
 390         err := ranListManager.InitNbIdentityMap()
 391         if err != nil {
 392                 t.Errorf("Error cannot init identity")
 393         }
 394
 395         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN}
 396         nb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN}
 397         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 398         readerMock.On("GetNodeb", "RanName_2").Return(nb2, nil)
 399         readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
 400         e2tInstance := entities.E2TInstance{Address: E2TAddress, AssociatedRanList: []string{"RanName_1", "RanName_2"}}
 401         readerMock.On("GetE2TInstances", []string{E2TAddress}).Return([]*entities.E2TInstance{&e2tInstance}, nil)
 402         updatedE2tInstance := e2tInstance
 403         updatedE2tInstance.AssociatedRanList = []string{}
 404         writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(nil)
 405
 406         rmrMessage := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
 407         mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction, rmrMessage.GetMsgSrc())
 408         rmrMessengerMock.On("SendMsg", mbuf, true).Return(mbuf, nil)
 409         resp, err := h.Handle(nil)
 410         assert.Nil(t, err)
 411
 412         if partial {
 413                 assert.IsType(t, &models.RedButtonPartialSuccessResponseModel{}, resp)
 414         } else {
 415                 assert.Nil(t, resp)
 416         }
 417
 418         rmrMessengerMock.AssertCalled(t, "SendMsg", mbuf, true)
 419         readerMock.AssertExpectations(t)
 420         writerMock.AssertExpectations(t)
 421 }
 422
 423 func TestTwoRansTryShuttingDownSucceedsClearSucceedsRmrSucceedsAllRansAreShutdownSuccess(t *testing.T) {
 424         testTwoRansTryShuttingDownSucceedsClearSucceedsRmrSucceedsAllRansAreShutdown(t, false)
 425 }
 426
 427 func TestTwoRansTryShuttingDownSucceedsClearSucceedsRmrSucceedsAllRansAreShutdownPartialSuccess(t *testing.T) {
 428         testTwoRansTryShuttingDownSucceedsClearSucceedsRmrSucceedsAllRansAreShutdown(t, true)
 429 }
 430
 431 func TestOneRanTryShuttingDownSucceedsClearSucceedsRmrSucceedsRanStatusIsShuttingDownUpdateFailure(t *testing.T) {
 432         h, readerMock, writerMock, rmrMessengerMock, httpClientMock, ranListManager := setupDeleteAllRequestHandlerTest(t)
 433         e2tAddresses := []string{E2TAddress}
 434         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 435         mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, true)
 436         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
 437         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 438
 439         err := ranListManager.InitNbIdentityMap()
 440         if err != nil {
 441                 t.Errorf("Error cannot init identity")
 442         }
 443
 444         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN, AssociatedE2TInstanceAddress: E2TAddress}
 445         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 446
 447         updatedNb1 := *nb1 //&entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN, AssociatedE2TInstanceAddress: E2TAddress}
 448         writerMock.On("UpdateNodebInfo", &updatedNb1).Return(nil)
 449
 450         nodeb1NotAssociated := *nb1
 451         nodeb1NotAssociated.AssociatedE2TInstanceAddress = ""
 452         nodeb1NotAssociated.ConnectionStatus = entities.ConnectionStatus_SHUTTING_DOWN
 453         writerMock.On("UpdateNodebInfo", &nodeb1NotAssociated).Return(nil)
 454
 455         readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
 456         e2tInstance := entities.E2TInstance{Address: E2TAddress, AssociatedRanList: []string{"RanName_1"}}
 457         readerMock.On("GetE2TInstances", []string{E2TAddress}).Return([]*entities.E2TInstance{&e2tInstance}, nil)
 458         updatedE2tInstance := e2tInstance
 459         updatedE2tInstance.AssociatedRanList = []string{}
 460         writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(nil)
 461
 462         rmrMessage := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
 463         mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction, rmrMessage.GetMsgSrc())
 464         rmrMessengerMock.On("SendMsg", mbuf, true).Return(mbuf, nil)
 465
 466         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 467         readerMock.On("GetNodeb", "RanName_1").Return(updatedNb1, nil)
 468
 469         updatedNb2 := *nb1 //&entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
 470         updatedNb2.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
 471         updatedNb2.AssociatedE2TInstanceAddress = ""
 472         writerMock.On("UpdateNodebInfo", &updatedNb2).Return(common.NewInternalError(errors.New("error")))
 473
 474         _, err = h.Handle(nil)
 475
 476         assert.IsType(t, &e2managererrors.RnibDbError{}, err)
 477         rmrMessengerMock.AssertCalled(t, "SendMsg", mbuf, true)
 478         readerMock.AssertExpectations(t)
 479         writerMock.AssertExpectations(t)
 480 }
 481
 482 func testOneRanTryShuttingDownSucceedsClearSucceedsRmrSucceedsRanStatusIsShuttingDown(t *testing.T, partial bool) {
 483         h, readerMock, writerMock, rmrMessengerMock, httpClientMock, ranListManager := setupDeleteAllRequestHandlerTest(t)
 484         e2tAddresses := []string{E2TAddress}
 485         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 486         mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, !partial)
 487         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
 488         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 489
 490         err := ranListManager.InitNbIdentityMap()
 491         if err != nil {
 492                 t.Errorf("Error cannot init identity")
 493         }
 494
 495         updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN}
 496         writerMock.On("UpdateNodebInfo", updatedNb1).Return(nil)
 497         readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
 498         e2tInstance := entities.E2TInstance{Address: E2TAddress, AssociatedRanList: []string{"RanName_1"}}
 499         readerMock.On("GetE2TInstances", []string{E2TAddress}).Return([]*entities.E2TInstance{&e2tInstance}, nil)
 500         updatedE2tInstance := e2tInstance
 501         updatedE2tInstance.AssociatedRanList = []string{}
 502         writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(nil)
 503
 504         rmrMessage := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
 505         mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction, rmrMessage.GetMsgSrc())
 506         rmrMessengerMock.On("SendMsg", mbuf, true).Return(mbuf, nil)
 507
 508         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 509         readerMock.On("GetNodeb", "RanName_1").Return(updatedNb1, nil)
 510         updatedNb2 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN}
 511         writerMock.On("UpdateNodebInfo", updatedNb2).Return(nil)
 512         _, err = h.Handle(nil)
 513         assert.Nil(t, err)
 514         rmrMessengerMock.AssertCalled(t, "SendMsg", mbuf, true)
 515         readerMock.AssertExpectations(t)
 516         writerMock.AssertExpectations(t)
 517         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 3)
 518 }
 519
 520 func TestOneRanTryShuttingDownSucceedsClearSucceedsRmrSucceedsRanStatusIsShuttingDownSuccess(t *testing.T) {
 521         testOneRanTryShuttingDownSucceedsClearSucceedsRmrSucceedsRanStatusIsShuttingDown(t, false)
 522 }
 523
 524 func TestOneRanTryShuttingDownSucceedsClearSucceedsRmrSucceedsRanStatusIsShuttingDownPartialSuccess(t *testing.T) {
 525         testOneRanTryShuttingDownSucceedsClearSucceedsRmrSucceedsRanStatusIsShuttingDown(t, true)
 526 }
 527
 528 func TestSuccessTwoE2TInstancesSixRans(t *testing.T) {
 529         h, readerMock, writerMock, rmrMessengerMock, httpClientMock, ranListManager := setupDeleteAllRequestHandlerTest(t)
 530         e2tAddresses := []string{E2TAddress, E2TAddress2}
 531         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 532         mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, true)
 533         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}, {InventoryName: "RanName_2"}, {InventoryName: "RanName_3"}, {InventoryName: "RanName_4"}, {InventoryName: "RanName_5"}, {InventoryName: "RanName_6"}}
 534         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 535
 536         err := ranListManager.InitNbIdentityMap()
 537         if err != nil {
 538                 t.Errorf("Error cannot init identity")
 539         }
 540
 541         updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN}
 542         writerMock.On("UpdateNodebInfo", updatedNb1).Return(nil)
 543         updatedNb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN}
 544         writerMock.On("UpdateNodebInfo", updatedNb2).Return(nil)
 545         updatedNb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN}
 546         writerMock.On("UpdateNodebInfo", updatedNb3).Return(nil)
 547         updatedNb4 := &entities.NodebInfo{RanName: "RanName_4", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN}
 548         writerMock.On("UpdateNodebInfo", updatedNb4).Return(nil)
 549         updatedNb5 := &entities.NodebInfo{RanName: "RanName_5", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN}
 550         writerMock.On("UpdateNodebInfo", updatedNb5).Return(nil)
 551         updatedNb6 := &entities.NodebInfo{RanName: "RanName_6", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN}
 552         writerMock.On("UpdateNodebInfo", updatedNb6).Return(nil)
 553
 554         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 555         e2tInstance := entities.E2TInstance{Address: E2TAddress, AssociatedRanList: []string{"RanName_1", "RanName_2", "RanName_3"}}
 556         e2tInstance2 := entities.E2TInstance{Address: E2TAddress2, AssociatedRanList: []string{"RanName_4", "RanName_5", "RanName_6"}}
 557         readerMock.On("GetE2TInstances", e2tAddresses).Return([]*entities.E2TInstance{&e2tInstance, &e2tInstance2}, nil)
 558         updatedE2tInstance := e2tInstance
 559         updatedE2tInstance.AssociatedRanList = []string{}
 560         updatedE2tInstance2 := e2tInstance2
 561         updatedE2tInstance2.AssociatedRanList = []string{}
 562         writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(nil)
 563         writerMock.On("SaveE2TInstance", &updatedE2tInstance2).Return(nil)
 564
 565         rmrMessage := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
 566         mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction, rmrMessage.GetMsgSrc())
 567         rmrMessengerMock.On("SendMsg", mbuf, true).Return(mbuf, nil)
 568
 569         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 570         readerMock.On("GetNodeb", "RanName_1").Return(updatedNb1, nil)
 571         readerMock.On("GetNodeb", "RanName_2").Return(updatedNb2, nil)
 572         readerMock.On("GetNodeb", "RanName_3").Return(updatedNb3, nil)
 573         readerMock.On("GetNodeb", "RanName_4").Return(updatedNb4, nil)
 574         readerMock.On("GetNodeb", "RanName_5").Return(updatedNb5, nil)
 575         readerMock.On("GetNodeb", "RanName_6").Return(updatedNb6, nil)
 576
 577         updatedNb1AfterTimer := *updatedNb1
 578         updatedNb1AfterTimer.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
 579         writerMock.On("UpdateNodebInfo", &updatedNb1AfterTimer).Return(nil)
 580         updatedNb2AfterTimer := *updatedNb2
 581         updatedNb2AfterTimer.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
 582         writerMock.On("UpdateNodebInfo", &updatedNb2AfterTimer).Return(nil)
 583         updatedNb3AfterTimer := *updatedNb3
 584         updatedNb3AfterTimer.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
 585         writerMock.On("UpdateNodebInfo", &updatedNb3AfterTimer).Return(nil)
 586         updatedNb4AfterTimer := *updatedNb4
 587         updatedNb4AfterTimer.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
 588         writerMock.On("UpdateNodebInfo", &updatedNb4AfterTimer).Return(nil)
 589         updatedNb5AfterTimer := *updatedNb5
 590         updatedNb5AfterTimer.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
 591         writerMock.On("UpdateNodebInfo", &updatedNb5AfterTimer).Return(nil)
 592         updatedNb6AfterTimer := *updatedNb6
 593         updatedNb6AfterTimer.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
 594         writerMock.On("UpdateNodebInfo", &updatedNb6AfterTimer).Return(nil)
 595         _, err = h.Handle(nil)
 596         assert.Nil(t, err)
 597         rmrMessengerMock.AssertCalled(t, "SendMsg", mbuf, true)
 598         readerMock.AssertExpectations(t)
 599         writerMock.AssertExpectations(t)
 600         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 18)
 601 }
 602
 603 func initLog(t *testing.T) *logger.Logger {
 604         log, err := logger.InitLogger(logger.DebugLevel)
 605         if err != nil {
 606                 t.Errorf("#initLog test - failed to initialize logger, error: %s", err)
 607         }
 608         return log
 609 }
 610
 611 func getRmrSender(rmrMessengerMock *mocks.RmrMessengerMock, log *logger.Logger) *rmrsender.RmrSender {
 612         rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
 613         rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
 614         return rmrsender.NewRmrSender(log, rmrMessenger)
 615 }