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