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.AssertExpectations(t)
 151         readerMock.AssertExpectations(t)
 152 }
 153
 154 func TestUpdateNodebInfoOnConnectionStatusInversionFailure(t *testing.T) {
 155         h, readerMock, writerMock, _, _, ranListManager := setupDeleteAllRequestHandlerTest(t)
 156
 157         readerMock.On("GetE2TAddresses").Return([]string{}, nil)
 158         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}, {InventoryName: "RanName_2"}}
 159         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 160
 161         _ = ranListManager.InitNbIdentityMap()
 162
 163         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_CONNECTED}
 164         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 165
 166         updatedNb1 := *nb1
 167         updatedNb1.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
 168         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", &updatedNb1, "RanName_1_DISCONNECTED").Return(common.NewInternalError(errors.New("error")))
 169
 170         _, err := h.Handle(nil)
 171
 172         assert.IsType(t, &e2managererrors.RnibDbError{}, err)
 173         writerMock.AssertExpectations(t)
 174         readerMock.AssertExpectations(t)
 175 }
 176
 177 func TestTwoRansGetE2TAddressesEmptyListOneUpdateNodebInfoFailure(t *testing.T) {
 178         h, readerMock, writerMock, _, _, ranListManager := setupDeleteAllRequestHandlerTest(t)
 179
 180         readerMock.On("GetE2TAddresses").Return([]string{}, nil)
 181         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}, {InventoryName: "RanName_2"}}
 182         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 183
 184         err := ranListManager.InitNbIdentityMap()
 185         if err != nil {
 186                 t.Errorf("Error cannot init identity")
 187         }
 188
 189         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED}
 190         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 191         updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN}
 192         writerMock.On("UpdateNodebInfo", updatedNb1).Return(nil)
 193
 194         nb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED}
 195         readerMock.On("GetNodeb", "RanName_2").Return(nb2, nil)
 196         updatedNb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN}
 197         writerMock.On("UpdateNodebInfo", updatedNb2).Return(common.NewInternalError(errors.New("error")))
 198         _, err = h.Handle(nil)
 199         assert.IsType(t, &e2managererrors.RnibDbError{}, err)
 200         readerMock.AssertExpectations(t)
 201         writerMock.AssertExpectations(t)
 202 }
 203
 204 func TestOneRanWithStateShutDown(t *testing.T) {
 205         h, readerMock, writerMock, rmrMessengerMock, httpClientMock, ranListManager := setupDeleteAllRequestHandlerTest(t)
 206         e2tAddresses := []string{E2TAddress}
 207         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 208         mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, true)
 209         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
 210         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 211
 212         err := ranListManager.InitNbIdentityMap()
 213         if err != nil {
 214                 t.Errorf("Error cannot init identity")
 215         }
 216
 217         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN}
 218         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 219         readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
 220
 221         e2tInstance := entities.E2TInstance{Address: E2TAddress, AssociatedRanList: []string{"RanName_1"}}
 222         readerMock.On("GetE2TInstances", []string{E2TAddress}).Return([]*entities.E2TInstance{&e2tInstance}, nil)
 223         updatedE2tInstance := e2tInstance
 224         updatedE2tInstance.AssociatedRanList = []string{}
 225         writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(nil)
 226
 227         rmrMessage := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
 228         mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction, rmrMessage.GetMsgSrc())
 229         rmrMessengerMock.On("SendMsg", mbuf, true).Return(mbuf, nil)
 230
 231         _, err = h.Handle(nil)
 232
 233         assert.Nil(t, err)
 234         rmrMessengerMock.AssertCalled(t, "SendMsg", mbuf, true)
 235         readerMock.AssertExpectations(t)
 236         writerMock.AssertExpectations(t)
 237 }
 238
 239 func TestOneRanShutDown(t *testing.T) {
 240         h, readerMock, writerMock, _, httpClientMock, ranListManager := setupDeleteAllRequestHandlerTest(t)
 241         e2tAddresses := []string{}
 242         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 243         mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, true)
 244         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
 245         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 246
 247         err := ranListManager.InitNbIdentityMap()
 248         if err != nil {
 249                 t.Errorf("Error cannot init identity")
 250         }
 251
 252         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN}
 253         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 254
 255         nodeb1NotAssociated := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN}
 256         writerMock.On("UpdateNodebInfo", nodeb1NotAssociated).Return(nil)
 257
 258         readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
 259
 260         _, err = h.Handle(nil)
 261
 262         assert.Nil(t, err)
 263         readerMock.AssertExpectations(t)
 264         writerMock.AssertExpectations(t)
 265 }
 266
 267 func TestOneRanTryShuttingDownSucceedsClearFails(t *testing.T) {
 268         h, readerMock, writerMock, _, httpClientMock, ranListManager := setupDeleteAllRequestHandlerTest(t)
 269
 270         e2tAddresses := []string{E2TAddress}
 271         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 272         mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, true)
 273         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
 274         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 275
 276         err := ranListManager.InitNbIdentityMap()
 277         if err != nil {
 278                 t.Errorf("Error cannot init identity")
 279         }
 280
 281         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_CONNECTED, AssociatedE2TInstanceAddress: E2TAddress}
 282         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 283
 284         updatedNb1 := *nb1
 285         updatedNb1.ConnectionStatus = entities.ConnectionStatus_SHUTTING_DOWN
 286         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", &updatedNb1, "RanName_1_DISCONNECTED").Return(nil)
 287
 288         nodeb1NotAssociated := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN}
 289         writerMock.On("UpdateNodebInfo", nodeb1NotAssociated).Return(nil)
 290
 291         readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
 292         readerMock.On("GetE2TInstances", []string{E2TAddress}).Return([]*entities.E2TInstance{}, common.NewInternalError(errors.New("error")))
 293         _, err = h.Handle(nil)
 294         assert.IsType(t, &e2managererrors.RnibDbError{}, err)
 295         readerMock.AssertExpectations(t)
 296         writerMock.AssertExpectations(t)
 297 }
 298
 299 func TestOneRanTryShuttingDownUpdateNodebError(t *testing.T) {
 300         h, readerMock, writerMock, _, httpClientMock, ranListManager := setupDeleteAllRequestHandlerTest(t)
 301
 302         e2tAddresses := []string{E2TAddress}
 303         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 304         mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, true)
 305         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
 306         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 307
 308         err := ranListManager.InitNbIdentityMap()
 309         if err != nil {
 310                 t.Errorf("Error cannot init identity")
 311         }
 312
 313         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_CONNECTED, AssociatedE2TInstanceAddress: E2TAddress}
 314         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 315
 316         updatedNb1 := *nb1
 317         updatedNb1.ConnectionStatus = entities.ConnectionStatus_SHUTTING_DOWN
 318         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", &updatedNb1, "RanName_1_DISCONNECTED").Return(nil)
 319
 320         nodeb1NotAssociated := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN}
 321         writerMock.On("UpdateNodebInfo", nodeb1NotAssociated).Return(common.NewInternalError(errors.New("error")))
 322
 323         _, err = h.Handle(nil)
 324
 325         assert.IsType(t, &e2managererrors.RnibDbError{}, err)
 326         readerMock.AssertExpectations(t)
 327         writerMock.AssertExpectations(t)
 328 }
 329
 330 func TestOneRanTryShuttingDownSucceedsClearSucceedsRmrSendFails(t *testing.T) {
 331         h, readerMock, writerMock, rmrMessengerMock, httpClientMock, ranListManager := setupDeleteAllRequestHandlerTest(t)
 332
 333         e2tAddresses := []string{E2TAddress}
 334         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 335         mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, true)
 336         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
 337         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 338
 339         err := ranListManager.InitNbIdentityMap()
 340         if err != nil {
 341                 t.Errorf("Error cannot init identity")
 342         }
 343
 344         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_CONNECTED, AssociatedE2TInstanceAddress: E2TAddress}
 345         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 346
 347         updatedNb1 := *nb1
 348         updatedNb1.ConnectionStatus = entities.ConnectionStatus_SHUTTING_DOWN
 349         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", &updatedNb1, "RanName_1_DISCONNECTED").Return(nil)
 350
 351         nodeb1NotAssociated := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN}
 352         writerMock.On("UpdateNodebInfo", nodeb1NotAssociated).Return(nil)
 353
 354         readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
 355         e2tInstance := entities.E2TInstance{Address: E2TAddress, AssociatedRanList: []string{"RanName_1"}}
 356         readerMock.On("GetE2TInstances", []string{E2TAddress}).Return([]*entities.E2TInstance{&e2tInstance}, nil)
 357         updatedE2tInstance := e2tInstance
 358         updatedE2tInstance.AssociatedRanList = []string{}
 359         writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(nil)
 360
 361         rmrMessage := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
 362         mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction, rmrMessage.GetMsgSrc())
 363         rmrMessengerMock.On("SendMsg", mbuf, true).Return(mbuf, e2managererrors.NewRmrError())
 364         _, err = h.Handle(nil)
 365         assert.IsType(t, &e2managererrors.RmrError{}, err)
 366         rmrMessengerMock.AssertCalled(t, "SendMsg", mbuf, true)
 367         readerMock.AssertExpectations(t)
 368         writerMock.AssertExpectations(t)
 369 }
 370
 371 func testTwoRansTryShuttingDownSucceedsClearSucceedsRmrSucceedsAllRansAreShutdown(t *testing.T, partial bool) {
 372         h, readerMock, writerMock, rmrMessengerMock, httpClientMock, ranListManager := setupDeleteAllRequestHandlerTest(t)
 373
 374         e2tAddresses := []string{E2TAddress}
 375         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 376         mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, !partial)
 377         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}, {InventoryName: "RanName_2"}}
 378         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 379
 380         err := ranListManager.InitNbIdentityMap()
 381         if err != nil {
 382                 t.Errorf("Error cannot init identity")
 383         }
 384
 385         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN}
 386         nb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN}
 387         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 388         readerMock.On("GetNodeb", "RanName_2").Return(nb2, nil)
 389         readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
 390         e2tInstance := entities.E2TInstance{Address: E2TAddress, AssociatedRanList: []string{"RanName_1", "RanName_2"}}
 391         readerMock.On("GetE2TInstances", []string{E2TAddress}).Return([]*entities.E2TInstance{&e2tInstance}, nil)
 392         updatedE2tInstance := e2tInstance
 393         updatedE2tInstance.AssociatedRanList = []string{}
 394         writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(nil)
 395
 396         rmrMessage := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
 397         mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction, rmrMessage.GetMsgSrc())
 398         rmrMessengerMock.On("SendMsg", mbuf, true).Return(mbuf, nil)
 399         resp, err := h.Handle(nil)
 400         assert.Nil(t, err)
 401
 402         if partial {
 403                 assert.IsType(t, &models.RedButtonPartialSuccessResponseModel{}, resp)
 404         } else {
 405                 assert.Nil(t, resp)
 406         }
 407
 408         rmrMessengerMock.AssertCalled(t, "SendMsg", mbuf, true)
 409         readerMock.AssertExpectations(t)
 410         writerMock.AssertExpectations(t)
 411 }
 412
 413 func TestTwoRansTryShuttingDownSucceedsClearSucceedsRmrSucceedsAllRansAreShutdownSuccess(t *testing.T) {
 414         testTwoRansTryShuttingDownSucceedsClearSucceedsRmrSucceedsAllRansAreShutdown(t, false)
 415 }
 416
 417 func TestTwoRansTryShuttingDownSucceedsClearSucceedsRmrSucceedsAllRansAreShutdownPartialSuccess(t *testing.T) {
 418         testTwoRansTryShuttingDownSucceedsClearSucceedsRmrSucceedsAllRansAreShutdown(t, true)
 419 }
 420
 421 func TestOneRanTryShuttingDownSucceedsClearSucceedsRmrSucceedsRanStatusIsShuttingDownUpdateFailure(t *testing.T) {
 422         h, readerMock, writerMock, rmrMessengerMock, httpClientMock, ranListManager := setupDeleteAllRequestHandlerTest(t)
 423         e2tAddresses := []string{E2TAddress}
 424         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 425         mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, true)
 426         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
 427         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 428
 429         err := ranListManager.InitNbIdentityMap()
 430         if err != nil {
 431                 t.Errorf("Error cannot init identity")
 432         }
 433
 434         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN, AssociatedE2TInstanceAddress: E2TAddress}
 435         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 436
 437         updatedNb1 := *nb1 //&entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN, AssociatedE2TInstanceAddress: E2TAddress}
 438         writerMock.On("UpdateNodebInfo", &updatedNb1).Return(nil)
 439
 440         nodeb1NotAssociated := *nb1
 441         nodeb1NotAssociated.AssociatedE2TInstanceAddress = ""
 442         nodeb1NotAssociated.ConnectionStatus = entities.ConnectionStatus_SHUTTING_DOWN
 443         writerMock.On("UpdateNodebInfo", &nodeb1NotAssociated).Return(nil)
 444
 445         readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
 446         e2tInstance := entities.E2TInstance{Address: E2TAddress, AssociatedRanList: []string{"RanName_1"}}
 447         readerMock.On("GetE2TInstances", []string{E2TAddress}).Return([]*entities.E2TInstance{&e2tInstance}, nil)
 448         updatedE2tInstance := e2tInstance
 449         updatedE2tInstance.AssociatedRanList = []string{}
 450         writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(nil)
 451
 452         rmrMessage := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
 453         mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction, rmrMessage.GetMsgSrc())
 454         rmrMessengerMock.On("SendMsg", mbuf, true).Return(mbuf, nil)
 455
 456         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 457         readerMock.On("GetNodeb", "RanName_1").Return(updatedNb1, nil)
 458
 459         updatedNb2 := *nb1 //&entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
 460         updatedNb2.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
 461         updatedNb2.AssociatedE2TInstanceAddress = ""
 462         writerMock.On("UpdateNodebInfo", &updatedNb2).Return(common.NewInternalError(errors.New("error")))
 463
 464         _, err = h.Handle(nil)
 465
 466         assert.IsType(t, &e2managererrors.RnibDbError{}, err)
 467         rmrMessengerMock.AssertCalled(t, "SendMsg", mbuf, true)
 468         readerMock.AssertExpectations(t)
 469         writerMock.AssertExpectations(t)
 470 }
 471
 472 func testOneRanTryShuttingDownSucceedsClearSucceedsRmrSucceedsRanStatusIsShuttingDown(t *testing.T, partial bool) {
 473         h, readerMock, writerMock, rmrMessengerMock, httpClientMock, ranListManager := setupDeleteAllRequestHandlerTest(t)
 474         e2tAddresses := []string{E2TAddress}
 475         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 476         mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, !partial)
 477         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
 478         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 479
 480         err := ranListManager.InitNbIdentityMap()
 481         if err != nil {
 482                 t.Errorf("Error cannot init identity")
 483         }
 484
 485         updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN}
 486         writerMock.On("UpdateNodebInfo", updatedNb1).Return(nil)
 487         readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
 488         e2tInstance := entities.E2TInstance{Address: E2TAddress, AssociatedRanList: []string{"RanName_1"}}
 489         readerMock.On("GetE2TInstances", []string{E2TAddress}).Return([]*entities.E2TInstance{&e2tInstance}, nil)
 490         updatedE2tInstance := e2tInstance
 491         updatedE2tInstance.AssociatedRanList = []string{}
 492         writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(nil)
 493
 494         rmrMessage := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
 495         mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction, rmrMessage.GetMsgSrc())
 496         rmrMessengerMock.On("SendMsg", mbuf, true).Return(mbuf, nil)
 497
 498         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 499         readerMock.On("GetNodeb", "RanName_1").Return(updatedNb1, nil)
 500         updatedNb2 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN}
 501         writerMock.On("UpdateNodebInfo", updatedNb2).Return(nil)
 502         _, err = h.Handle(nil)
 503         assert.Nil(t, err)
 504         rmrMessengerMock.AssertCalled(t, "SendMsg", mbuf, true)
 505         readerMock.AssertExpectations(t)
 506         writerMock.AssertExpectations(t)
 507         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 3)
 508 }
 509
 510 func TestOneRanTryShuttingDownSucceedsClearSucceedsRmrSucceedsRanStatusIsShuttingDownSuccess(t *testing.T) {
 511         testOneRanTryShuttingDownSucceedsClearSucceedsRmrSucceedsRanStatusIsShuttingDown(t, false)
 512 }
 513
 514 func TestOneRanTryShuttingDownSucceedsClearSucceedsRmrSucceedsRanStatusIsShuttingDownPartialSuccess(t *testing.T) {
 515         testOneRanTryShuttingDownSucceedsClearSucceedsRmrSucceedsRanStatusIsShuttingDown(t, true)
 516 }
 517
 518 func TestSuccessTwoE2TInstancesSixRans(t *testing.T) {
 519         h, readerMock, writerMock, rmrMessengerMock, httpClientMock, ranListManager := setupDeleteAllRequestHandlerTest(t)
 520         e2tAddresses := []string{E2TAddress, E2TAddress2}
 521         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 522         mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, true)
 523         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}, {InventoryName: "RanName_2"}, {InventoryName: "RanName_3"}, {InventoryName: "RanName_4"}, {InventoryName: "RanName_5"}, {InventoryName: "RanName_6"}}
 524         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 525
 526         err := ranListManager.InitNbIdentityMap()
 527         if err != nil {
 528                 t.Errorf("Error cannot init identity")
 529         }
 530
 531         updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN}
 532         writerMock.On("UpdateNodebInfo", updatedNb1).Return(nil)
 533         updatedNb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN}
 534         writerMock.On("UpdateNodebInfo", updatedNb2).Return(nil)
 535         updatedNb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN}
 536         writerMock.On("UpdateNodebInfo", updatedNb3).Return(nil)
 537         updatedNb4 := &entities.NodebInfo{RanName: "RanName_4", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN}
 538         writerMock.On("UpdateNodebInfo", updatedNb4).Return(nil)
 539         updatedNb5 := &entities.NodebInfo{RanName: "RanName_5", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN}
 540         writerMock.On("UpdateNodebInfo", updatedNb5).Return(nil)
 541         updatedNb6 := &entities.NodebInfo{RanName: "RanName_6", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN}
 542         writerMock.On("UpdateNodebInfo", updatedNb6).Return(nil)
 543
 544         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 545         e2tInstance := entities.E2TInstance{Address: E2TAddress, AssociatedRanList: []string{"RanName_1", "RanName_2", "RanName_3"}}
 546         e2tInstance2 := entities.E2TInstance{Address: E2TAddress2, AssociatedRanList: []string{"RanName_4", "RanName_5", "RanName_6"}}
 547         readerMock.On("GetE2TInstances", e2tAddresses).Return([]*entities.E2TInstance{&e2tInstance, &e2tInstance2}, nil)
 548         updatedE2tInstance := e2tInstance
 549         updatedE2tInstance.AssociatedRanList = []string{}
 550         updatedE2tInstance2 := e2tInstance2
 551         updatedE2tInstance2.AssociatedRanList = []string{}
 552         writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(nil)
 553         writerMock.On("SaveE2TInstance", &updatedE2tInstance2).Return(nil)
 554
 555         rmrMessage := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
 556         mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction, rmrMessage.GetMsgSrc())
 557         rmrMessengerMock.On("SendMsg", mbuf, true).Return(mbuf, nil)
 558
 559         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 560         readerMock.On("GetNodeb", "RanName_1").Return(updatedNb1, nil)
 561         readerMock.On("GetNodeb", "RanName_2").Return(updatedNb2, nil)
 562         readerMock.On("GetNodeb", "RanName_3").Return(updatedNb3, nil)
 563         readerMock.On("GetNodeb", "RanName_4").Return(updatedNb4, nil)
 564         readerMock.On("GetNodeb", "RanName_5").Return(updatedNb5, nil)
 565         readerMock.On("GetNodeb", "RanName_6").Return(updatedNb6, nil)
 566
 567         updatedNb1AfterTimer := *updatedNb1
 568         updatedNb1AfterTimer.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
 569         writerMock.On("UpdateNodebInfo", &updatedNb1AfterTimer).Return(nil)
 570         updatedNb2AfterTimer := *updatedNb2
 571         updatedNb2AfterTimer.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
 572         writerMock.On("UpdateNodebInfo", &updatedNb2AfterTimer).Return(nil)
 573         updatedNb3AfterTimer := *updatedNb3
 574         updatedNb3AfterTimer.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
 575         writerMock.On("UpdateNodebInfo", &updatedNb3AfterTimer).Return(nil)
 576         updatedNb4AfterTimer := *updatedNb4
 577         updatedNb4AfterTimer.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
 578         writerMock.On("UpdateNodebInfo", &updatedNb4AfterTimer).Return(nil)
 579         updatedNb5AfterTimer := *updatedNb5
 580         updatedNb5AfterTimer.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
 581         writerMock.On("UpdateNodebInfo", &updatedNb5AfterTimer).Return(nil)
 582         updatedNb6AfterTimer := *updatedNb6
 583         updatedNb6AfterTimer.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
 584         writerMock.On("UpdateNodebInfo", &updatedNb6AfterTimer).Return(nil)
 585         _, err = h.Handle(nil)
 586         assert.Nil(t, err)
 587         rmrMessengerMock.AssertCalled(t, "SendMsg", mbuf, true)
 588         readerMock.AssertExpectations(t)
 589         writerMock.AssertExpectations(t)
 590         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 18)
 591 }
 592
 593 func initLog(t *testing.T) *logger.Logger {
 594         log, err := logger.InitLogger(logger.DebugLevel)
 595         if err != nil {
 596                 t.Errorf("#initLog test - failed to initialize logger, error: %s", err)
 597         }
 598         return log
 599 }
 600
 601 func getRmrSender(rmrMessengerMock *mocks.RmrMessengerMock, log *logger.Logger) *rmrsender.RmrSender {
 602         rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
 603         rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
 604         return rmrsender.NewRmrSender(log, rmrMessenger)
 605 }