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) {
  49         log := initLog(t)
  50         config := configuration.ParseConfiguration()
  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         handler := NewDeleteAllRequestHandler(log, rmrSender, config, rnibDataService, e2tInstancesManager, rmClient)
  65         return handler, readerMock, writerMock, rmrMessengerMock, httpClientMock
  66 }
  67
  68 func mapE2TAddressesToE2DataList(e2tAddresses []string) models.RoutingManagerE2TDataList {
  69         e2tDataList := make(models.RoutingManagerE2TDataList, len(e2tAddresses))
  70
  71         for i, v := range e2tAddresses {
  72                 e2tDataList[i] = models.NewRoutingManagerE2TData(v)
  73         }
  74
  75         return e2tDataList
  76 }
  77
  78 func mockHttpClientDissociateAllRans(httpClientMock *mocks.HttpClientMock, e2tAddresses []string, ok bool) {
  79         data := mapE2TAddressesToE2DataList(e2tAddresses)
  80         marshaled, _ := json.Marshal(data)
  81         body := bytes.NewBuffer(marshaled)
  82         url := BaseRMUrl + clients.DissociateRanE2TInstanceApiSuffix
  83         respBody := ioutil.NopCloser(bytes.NewBufferString(""))
  84
  85         var status int
  86         if ok {
  87                 status = http.StatusOK
  88         } else {
  89                 status = http.StatusBadRequest
  90         }
  91         httpClientMock.On("Post", url, "application/json", body).Return(&http.Response{StatusCode: status, Body: respBody}, nil)
  92 }
  93
  94 func TestGetE2TAddressesFailure(t *testing.T) {
  95         h, readerMock, _, _, _ := setupDeleteAllRequestHandlerTest(t)
  96         readerMock.On("GetE2TAddresses").Return([]string{}, common.NewInternalError(errors.New("error")))
  97         _, err := h.Handle(nil)
  98         assert.IsType(t, &e2managererrors.RnibDbError{}, err)
  99         readerMock.AssertExpectations(t)
 100 }
 101
 102 func TestOneRanGetE2TAddressesEmptyList(t *testing.T) {
 103         h, readerMock, writerMock, _, _ := setupDeleteAllRequestHandlerTest(t)
 104         readerMock.On("GetE2TAddresses").Return([]string{}, nil)
 105         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
 106         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 107         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,}
 108         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 109         updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
 110         writerMock.On("UpdateNodebInfo", updatedNb1).Return(nil)
 111         _, err := h.Handle(nil)
 112         assert.Nil(t, err)
 113         readerMock.AssertExpectations(t)
 114         writerMock.AssertExpectations(t)
 115 }
 116
 117 func TestTwoRansGetE2TAddressesEmptyListOneGetNodebFailure(t *testing.T) {
 118         h, readerMock, writerMock, _, _ := setupDeleteAllRequestHandlerTest(t)
 119         readerMock.On("GetE2TAddresses").Return([]string{}, nil)
 120         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}, {InventoryName: "RanName_2"}}
 121         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 122         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,}
 123         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 124         updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
 125         writerMock.On("UpdateNodebInfo", updatedNb1).Return(nil)
 126         var nb2 *entities.NodebInfo
 127         readerMock.On("GetNodeb", "RanName_2").Return(nb2, common.NewInternalError(errors.New("error")))
 128         _, err := h.Handle(nil)
 129         assert.IsType(t,&e2managererrors.RnibDbError{}, err)
 130         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 1)
 131         readerMock.AssertExpectations(t)
 132 }
 133
 134 func TestTwoRansGetE2TAddressesEmptyListOneUpdateNodebInfoFailure(t *testing.T) {
 135         h, readerMock, writerMock, _, _ := setupDeleteAllRequestHandlerTest(t)
 136         readerMock.On("GetE2TAddresses").Return([]string{}, nil)
 137         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}, {InventoryName: "RanName_2"}}
 138         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 139
 140         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,}
 141         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 142         updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
 143         writerMock.On("UpdateNodebInfo", updatedNb1).Return(nil)
 144
 145         nb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,}
 146         readerMock.On("GetNodeb", "RanName_2").Return(nb2, nil)
 147         updatedNb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
 148         writerMock.On("UpdateNodebInfo", updatedNb2).Return(common.NewInternalError(errors.New("error")))
 149         _, err := h.Handle(nil)
 150         assert.IsType(t,&e2managererrors.RnibDbError{}, err)
 151         readerMock.AssertExpectations(t)
 152         writerMock.AssertExpectations(t)
 153 }
 154
 155 func TestOneRanDissociateSucceedsTryShuttingDownFailure(t *testing.T) {
 156         h, readerMock, writerMock, _, httpClientMock := setupDeleteAllRequestHandlerTest(t)
 157         e2tAddresses := []string{E2TAddress}
 158         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 159         mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, true)
 160         nbIdentityList := []*entities.NbIdentity{}
 161         readerMock.On("GetListNodebIds").Return(nbIdentityList, common.NewInternalError(errors.New("error")))
 162         _, err := h.Handle(nil)
 163         assert.IsType(t, &e2managererrors.RnibDbError{}, err)
 164         readerMock.AssertExpectations(t)
 165         writerMock.AssertExpectations(t)
 166 }
 167
 168 func TestOneRanDissociateFailsTryShuttingDownFailure(t *testing.T) {
 169         h, readerMock, writerMock, _, httpClientMock := setupDeleteAllRequestHandlerTest(t)
 170         e2tAddresses := []string{E2TAddress}
 171
 172         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 173         mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, false)
 174         nbIdentityList := []*entities.NbIdentity{}
 175         readerMock.On("GetListNodebIds").Return(nbIdentityList, common.NewInternalError(errors.New("error")))
 176         _, err := h.Handle(nil)
 177         assert.IsType(t, &e2managererrors.RnibDbError{}, err)
 178         readerMock.AssertExpectations(t)
 179         writerMock.AssertExpectations(t)
 180 }
 181
 182 func TestOneRanTryShuttingDownSucceedsClearFails(t *testing.T) {
 183         h, readerMock, writerMock, _, httpClientMock := setupDeleteAllRequestHandlerTest(t)
 184         e2tAddresses := []string{E2TAddress}
 185         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 186         mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, true)
 187         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
 188         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 189         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_CONNECTED, AssociatedE2TInstanceAddress: E2TAddress}
 190         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 191         updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 192         writerMock.On("UpdateNodebInfo", updatedNb1).Return(nil)
 193         readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
 194         readerMock.On("GetE2TInstances", []string{E2TAddress}).Return([]*entities.E2TInstance{}, common.NewInternalError(errors.New("error")))
 195         _, err := h.Handle(nil)
 196         assert.IsType(t, &e2managererrors.RnibDbError{}, err)
 197         readerMock.AssertExpectations(t)
 198         writerMock.AssertExpectations(t)
 199 }
 200
 201 func TestOneRanTryShuttingDownSucceedsClearSucceedsRmrSendFails(t *testing.T) {
 202         h, readerMock, writerMock, rmrMessengerMock, httpClientMock := setupDeleteAllRequestHandlerTest(t)
 203         e2tAddresses := []string{E2TAddress}
 204         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 205         mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, true)
 206         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
 207         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 208         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_CONNECTED, AssociatedE2TInstanceAddress: E2TAddress}
 209         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 210         updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 211         writerMock.On("UpdateNodebInfo", updatedNb1).Return(nil)
 212         readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
 213         e2tInstance := entities.E2TInstance{Address: E2TAddress, AssociatedRanList: []string{"RanName_1"}}
 214         readerMock.On("GetE2TInstances", []string{E2TAddress}).Return([]*entities.E2TInstance{&e2tInstance}, nil)
 215         updatedE2tInstance := e2tInstance
 216         updatedE2tInstance.AssociatedRanList = []string{}
 217         writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(nil)
 218
 219         rmrMessage := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
 220         mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction, rmrMessage.GetMsgSrc())
 221         rmrMessengerMock.On("SendMsg", mbuf, true).Return(mbuf, e2managererrors.NewRmrError())
 222         _, err := h.Handle(nil)
 223         assert.IsType(t, &e2managererrors.RmrError{}, err)
 224         rmrMessengerMock.AssertCalled(t, "SendMsg", mbuf, true)
 225         readerMock.AssertExpectations(t)
 226         writerMock.AssertExpectations(t)
 227 }
 228
 229 func testTwoRansTryShuttingDownSucceedsClearSucceedsRmrSucceedsAllRansAreShutdown(t *testing.T, partial bool) {
 230         h, readerMock, writerMock, rmrMessengerMock, httpClientMock := setupDeleteAllRequestHandlerTest(t)
 231         e2tAddresses := []string{E2TAddress}
 232         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 233         mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, !partial)
 234         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}, {InventoryName: "RanName_2"}}
 235         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 236         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN}
 237         nb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN}
 238         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 239         readerMock.On("GetNodeb", "RanName_2").Return(nb2, nil)
 240         readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
 241         e2tInstance := entities.E2TInstance{Address: E2TAddress, AssociatedRanList: []string{"RanName_1", "RanName_2"}}
 242         readerMock.On("GetE2TInstances", []string{E2TAddress}).Return([]*entities.E2TInstance{&e2tInstance}, nil)
 243         updatedE2tInstance := e2tInstance
 244         updatedE2tInstance.AssociatedRanList = []string{}
 245         writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(nil)
 246
 247         rmrMessage := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
 248         mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction, rmrMessage.GetMsgSrc())
 249         rmrMessengerMock.On("SendMsg", mbuf, true).Return(mbuf, nil)
 250         resp, err := h.Handle(nil)
 251         assert.Nil(t, err)
 252
 253         if partial {
 254                 assert.IsType(t, &models.RedButtonPartialSuccessResponseModel{}, resp)
 255         } else {
 256                 assert.Nil(t, resp)
 257         }
 258
 259         rmrMessengerMock.AssertCalled(t, "SendMsg", mbuf, true)
 260         readerMock.AssertExpectations(t)
 261         writerMock.AssertExpectations(t)
 262 }
 263
 264 func TestTwoRansTryShuttingDownSucceedsClearSucceedsRmrSucceedsAllRansAreShutdownSuccess(t *testing.T) {
 265         testTwoRansTryShuttingDownSucceedsClearSucceedsRmrSucceedsAllRansAreShutdown(t, false)
 266 }
 267
 268 func TestTwoRansTryShuttingDownSucceedsClearSucceedsRmrSucceedsAllRansAreShutdownPartialSuccess(t *testing.T) {
 269         testTwoRansTryShuttingDownSucceedsClearSucceedsRmrSucceedsAllRansAreShutdown(t, true)
 270 }
 271
 272 //func TestOneRanTryShuttingDownSucceedsClearSucceedsRmrSucceedsRanStatusIsAlreadyShutdown(t *testing.T) {
 273 //      h, readerMock, writerMock, rmrMessengerMock, httpClientMock := setupDeleteAllRequestHandlerTest(t)
 274 //      e2tAddresses := []string{E2TAddress}
 275
 276 //      readerMock.On("GetE2TAddresses").Return(e2tAddresses , nil)
 277 //      mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses ,true)
 278 //      nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
 279 //      readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 280 //      nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_CONNECTED, AssociatedE2TInstanceAddress: E2TAddress}
 281 //      readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 282 //      updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 283 //      writerMock.On("UpdateNodebInfo", updatedNb1).Return(nil)
 284 //      readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
 285 //      e2tInstance := entities.E2TInstance{Address: E2TAddress, AssociatedRanList: []string{"RanName_1"}}
 286 //      readerMock.On("GetE2TInstances", []string{E2TAddress}).Return([]*entities.E2TInstance{&e2tInstance }, nil)
 287 //      updatedE2tInstance := e2tInstance
 288 //      updatedE2tInstance.AssociatedRanList = []string{}
 289 //      writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(nil)
 290 //
 291 //      rmrMessage := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
 292 //      mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction)
 293 //      rmrMessengerMock.On("SendMsg", mbuf, true).Return(mbuf, nil)
 294 //
 295 //      readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 296 //      nbAfterTimer := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
 297 //      readerMock.On("GetNodeb", /*"RanName_1"*/mock.Anything).Return(nbAfterTimer , nil) // Since this is a second call with same arguments we send mock.Anything due to mock limitations
 298 //      _, err := h.Handle(nil)
 299 //      assert.Nil(t, err)
 300 //      rmrMessengerMock.AssertCalled(t, "SendMsg",mbuf, true)
 301 //      readerMock.AssertExpectations(t)
 302 //      writerMock.AssertExpectations(t)
 303 //      writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 1)
 304 //}
 305
 306 //func TestOneRanTryShuttingDownSucceedsClearSucceedsRmrSucceedsRanStatusIsShuttingDownUpdateFailure(t *testing.T) {
 307 //      h, readerMock, writerMock, rmrMessengerMock, httpClientMock := setupDeleteAllRequestHandlerTest(t)
 308 //      e2tAddresses := []string{E2TAddress}
 309 //      readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 310 //      mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, true)
 311 //      nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
 312 //      readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 313 //      //nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_CONNECTED, AssociatedE2TInstanceAddress: E2TAddress}
 314 //      //readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 315 //      updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 316 //      writerMock.On("UpdateNodebInfo", updatedNb1).Return(nil)
 317 //      readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
 318 //      e2tInstance := entities.E2TInstance{Address: E2TAddress, AssociatedRanList: []string{"RanName_1"}}
 319 //      readerMock.On("GetE2TInstances", []string{E2TAddress}).Return([]*entities.E2TInstance{&e2tInstance}, nil)
 320 //      updatedE2tInstance := e2tInstance
 321 //      updatedE2tInstance.AssociatedRanList = []string{}
 322 //      writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(nil)
 323 //
 324 //      rmrMessage := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
 325 //      mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction)
 326 //      rmrMessengerMock.On("SendMsg", mbuf, true).Return(mbuf, nil)
 327 //
 328 //      readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 329 //      readerMock.On("GetNodeb", "RanName_1").Return(updatedNb1, nil)
 330 //      updatedNb2 := *updatedNb1
 331 //      updatedNb2.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
 332 //      writerMock.On("UpdateNodebInfo", &updatedNb2).Return(common.NewInternalError(errors.New("error")))
 333 //      _, err := h.Handle(nil)
 334 //      assert.IsType(t,&e2managererrors.RnibDbError{}, err)
 335 //      rmrMessengerMock.AssertCalled(t, "SendMsg", mbuf, true)
 336 //      readerMock.AssertExpectations(t)
 337 //      writerMock.AssertExpectations(t)
 338 //}
 339
 340 func testOneRanTryShuttingDownSucceedsClearSucceedsRmrSucceedsRanStatusIsShuttingDown(t *testing.T, partial bool) {
 341         h, readerMock, writerMock, rmrMessengerMock, httpClientMock := setupDeleteAllRequestHandlerTest(t)
 342         e2tAddresses := []string{E2TAddress}
 343         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 344         mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, !partial)
 345         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
 346         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 347         //nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_CONNECTED, AssociatedE2TInstanceAddress: E2TAddress}
 348         //readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 349         updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 350         writerMock.On("UpdateNodebInfo", updatedNb1).Return(nil)
 351         readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
 352         e2tInstance := entities.E2TInstance{Address: E2TAddress, AssociatedRanList: []string{"RanName_1"}}
 353         readerMock.On("GetE2TInstances", []string{E2TAddress}).Return([]*entities.E2TInstance{&e2tInstance}, nil)
 354         updatedE2tInstance := e2tInstance
 355         updatedE2tInstance.AssociatedRanList = []string{}
 356         writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(nil)
 357
 358         rmrMessage := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
 359         mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction, rmrMessage.GetMsgSrc())
 360         rmrMessengerMock.On("SendMsg", mbuf, true).Return(mbuf, nil)
 361
 362         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 363         readerMock.On("GetNodeb", "RanName_1").Return(updatedNb1, nil)
 364         updatedNb2 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
 365         writerMock.On("UpdateNodebInfo", updatedNb2).Return(nil)
 366         _, err := h.Handle(nil)
 367         assert.Nil(t, err)
 368         rmrMessengerMock.AssertCalled(t, "SendMsg", mbuf, true)
 369         readerMock.AssertExpectations(t)
 370         writerMock.AssertExpectations(t)
 371         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 2)
 372 }
 373
 374 func TestOneRanTryShuttingDownSucceedsClearSucceedsRmrSucceedsRanStatusIsShuttingDownSuccess (t *testing.T) {
 375         testOneRanTryShuttingDownSucceedsClearSucceedsRmrSucceedsRanStatusIsShuttingDown(t, false)
 376 }
 377
 378 func TestOneRanTryShuttingDownSucceedsClearSucceedsRmrSucceedsRanStatusIsShuttingDownPartialSuccess (t *testing.T) {
 379         testOneRanTryShuttingDownSucceedsClearSucceedsRmrSucceedsRanStatusIsShuttingDown(t, true)
 380 }
 381
 382 func TestSuccessTwoE2TInstancesSixRans(t *testing.T) {
 383         h, readerMock, writerMock, rmrMessengerMock, httpClientMock := setupDeleteAllRequestHandlerTest(t)
 384         e2tAddresses := []string{E2TAddress, E2TAddress2}
 385         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 386         mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, true)
 387         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}, {InventoryName: "RanName_2"}, {InventoryName: "RanName_3"}, {InventoryName: "RanName_4"}, {InventoryName: "RanName_5"}, {InventoryName: "RanName_6"}}
 388         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 389         //nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_CONNECTED, AssociatedE2TInstanceAddress: E2TAddress}
 390         //readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 391         //nb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_CONNECTED, AssociatedE2TInstanceAddress: E2TAddress}
 392         //readerMock.On("GetNodeb", "RanName_2").Return(nb2, nil)
 393         //nb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_CONNECTED, AssociatedE2TInstanceAddress: E2TAddress}
 394         //readerMock.On("GetNodeb", "RanName_3").Return(nb3, nil)
 395         //nb4 := &entities.NodebInfo{RanName: "RanName_4", ConnectionStatus: entities.ConnectionStatus_CONNECTED, AssociatedE2TInstanceAddress: E2TAddress2}
 396         //readerMock.On("GetNodeb", "RanName_4").Return(nb4, nil)
 397         //nb5 := &entities.NodebInfo{RanName: "RanName_5", ConnectionStatus: entities.ConnectionStatus_CONNECTED, AssociatedE2TInstanceAddress: E2TAddress2}
 398         //readerMock.On("GetNodeb", "RanName_5").Return(nb5, nil)
 399         //nb6 := &entities.NodebInfo{RanName: "RanName_6", ConnectionStatus: entities.ConnectionStatus_CONNECTED, AssociatedE2TInstanceAddress: E2TAddress2}
 400         //readerMock.On("GetNodeb", "RanName_6").Return(nb6, nil)
 401
 402         updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 403         writerMock.On("UpdateNodebInfo", updatedNb1).Return(nil)
 404         updatedNb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 405         writerMock.On("UpdateNodebInfo", updatedNb2).Return(nil)
 406         updatedNb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 407         writerMock.On("UpdateNodebInfo", updatedNb3).Return(nil)
 408         updatedNb4 := &entities.NodebInfo{RanName: "RanName_4", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 409         writerMock.On("UpdateNodebInfo", updatedNb4).Return(nil)
 410         updatedNb5 := &entities.NodebInfo{RanName: "RanName_5", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 411         writerMock.On("UpdateNodebInfo", updatedNb5).Return(nil)
 412         updatedNb6 := &entities.NodebInfo{RanName: "RanName_6", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 413         writerMock.On("UpdateNodebInfo", updatedNb6).Return(nil)
 414
 415         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 416         e2tInstance := entities.E2TInstance{Address: E2TAddress, AssociatedRanList: []string{"RanName_1", "RanName_2", "RanName_3"}}
 417         e2tInstance2 := entities.E2TInstance{Address: E2TAddress2, AssociatedRanList: []string{"RanName_4", "RanName_5", "RanName_6"}}
 418         readerMock.On("GetE2TInstances", e2tAddresses).Return([]*entities.E2TInstance{&e2tInstance, &e2tInstance2}, nil)
 419         updatedE2tInstance := e2tInstance
 420         updatedE2tInstance.AssociatedRanList = []string{}
 421         updatedE2tInstance2 := e2tInstance2
 422         updatedE2tInstance2.AssociatedRanList = []string{}
 423         writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(nil)
 424         writerMock.On("SaveE2TInstance", &updatedE2tInstance2).Return(nil)
 425
 426         rmrMessage := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
 427         mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction, rmrMessage.GetMsgSrc())
 428         rmrMessengerMock.On("SendMsg", mbuf, true).Return(mbuf, nil)
 429
 430         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 431         readerMock.On("GetNodeb", "RanName_1").Return(updatedNb1, nil)
 432         readerMock.On("GetNodeb", "RanName_2").Return(updatedNb2, nil)
 433         readerMock.On("GetNodeb", "RanName_3").Return(updatedNb3, nil)
 434         readerMock.On("GetNodeb", "RanName_4").Return(updatedNb4, nil)
 435         readerMock.On("GetNodeb", "RanName_5").Return(updatedNb5, nil)
 436         readerMock.On("GetNodeb", "RanName_6").Return(updatedNb6, nil)
 437
 438         updatedNb1AfterTimer := *updatedNb1
 439         updatedNb1AfterTimer.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
 440         writerMock.On("UpdateNodebInfo", &updatedNb1AfterTimer).Return(nil)
 441         updatedNb2AfterTimer := *updatedNb2
 442         updatedNb2AfterTimer.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
 443         writerMock.On("UpdateNodebInfo", &updatedNb2AfterTimer).Return(nil)
 444         updatedNb3AfterTimer := *updatedNb3
 445         updatedNb3AfterTimer.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
 446         writerMock.On("UpdateNodebInfo", &updatedNb3AfterTimer).Return(nil)
 447         updatedNb4AfterTimer := *updatedNb4
 448         updatedNb4AfterTimer.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
 449         writerMock.On("UpdateNodebInfo", &updatedNb4AfterTimer).Return(nil)
 450         updatedNb5AfterTimer := *updatedNb5
 451         updatedNb5AfterTimer.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
 452         writerMock.On("UpdateNodebInfo", &updatedNb5AfterTimer).Return(nil)
 453         updatedNb6AfterTimer := *updatedNb6
 454         updatedNb6AfterTimer.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
 455         writerMock.On("UpdateNodebInfo", &updatedNb6AfterTimer).Return(nil)
 456         _, err := h.Handle(nil)
 457         assert.Nil(t, err)
 458         rmrMessengerMock.AssertCalled(t, "SendMsg", mbuf, true)
 459         readerMock.AssertExpectations(t)
 460         writerMock.AssertExpectations(t)
 461         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 12)
 462 }
 463
 464 func initLog(t *testing.T) *logger.Logger {
 465         log, err := logger.InitLogger(logger.DebugLevel)
 466         if err != nil {
 467                 t.Errorf("#initLog test - failed to initialize logger, error: %s", err)
 468         }
 469         return log
 470 }
 471
 472 func getRmrSender(rmrMessengerMock *mocks.RmrMessengerMock, log *logger.Logger) *rmrsender.RmrSender {
 473         rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
 474         rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
 475         return rmrsender.NewRmrSender(log, rmrMessenger)
 476 }