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{}, e2managererrors.NewRnibDbError())
  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.Nil(t, 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.Nil(t, 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) {
 227         h, readerMock, writerMock, rmrMessengerMock, httpClientMock := setupDeleteAllRequestHandlerTest(t)
 228         e2tAddresses := []string{E2TAddress}
 229         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 230         mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, true)
 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         _, err := h.Handle(nil)
 248         assert.Nil(t, err)
 249         rmrMessengerMock.AssertCalled(t, "SendMsg", mbuf, true)
 250         readerMock.AssertExpectations(t)
 251         writerMock.AssertExpectations(t)
 252 }
 253
 254 //func TestOneRanTryShuttingDownSucceedsClearSucceedsRmrSucceedsRanStatusIsAlreadyShutdown(t *testing.T) {
 255 //      h, readerMock, writerMock, rmrMessengerMock, httpClientMock := setupDeleteAllRequestHandlerTest(t)
 256 //      e2tAddresses := []string{E2TAddress}
 257
 258 //      readerMock.On("GetE2TAddresses").Return(e2tAddresses , nil)
 259 //      mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses ,true)
 260 //      nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
 261 //      readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 262 //      nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_CONNECTED, AssociatedE2TInstanceAddress: E2TAddress}
 263 //      readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 264 //      updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 265 //      writerMock.On("UpdateNodebInfo", updatedNb1).Return(nil)
 266 //      readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
 267 //      e2tInstance := entities.E2TInstance{Address: E2TAddress, AssociatedRanList: []string{"RanName_1"}}
 268 //      readerMock.On("GetE2TInstances", []string{E2TAddress}).Return([]*entities.E2TInstance{&e2tInstance }, nil)
 269 //      updatedE2tInstance := e2tInstance
 270 //      updatedE2tInstance.AssociatedRanList = []string{}
 271 //      writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(nil)
 272 //
 273 //      rmrMessage := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
 274 //      mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction)
 275 //      rmrMessengerMock.On("SendMsg", mbuf, true).Return(mbuf, nil)
 276 //
 277 //      readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 278 //      nbAfterTimer := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
 279 //      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
 280 //      _, err := h.Handle(nil)
 281 //      assert.Nil(t, err)
 282 //      rmrMessengerMock.AssertCalled(t, "SendMsg",mbuf, true)
 283 //      readerMock.AssertExpectations(t)
 284 //      writerMock.AssertExpectations(t)
 285 //      writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 1)
 286 //}
 287
 288 func TestOneRanTryShuttingDownSucceedsClearSucceedsRmrSucceedsRanStatusIsShuttingDown(t *testing.T) {
 289         h, readerMock, writerMock, rmrMessengerMock, httpClientMock := setupDeleteAllRequestHandlerTest(t)
 290         e2tAddresses := []string{E2TAddress}
 291         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 292         mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, true)
 293         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
 294         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 295         //nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_CONNECTED, AssociatedE2TInstanceAddress: E2TAddress}
 296         //readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 297         updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 298         writerMock.On("UpdateNodebInfo", updatedNb1).Return(nil)
 299         readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
 300         e2tInstance := entities.E2TInstance{Address: E2TAddress, AssociatedRanList: []string{"RanName_1"}}
 301         readerMock.On("GetE2TInstances", []string{E2TAddress}).Return([]*entities.E2TInstance{&e2tInstance}, nil)
 302         updatedE2tInstance := e2tInstance
 303         updatedE2tInstance.AssociatedRanList = []string{}
 304         writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(nil)
 305
 306         rmrMessage := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
 307         mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction)
 308         rmrMessengerMock.On("SendMsg", mbuf, true).Return(mbuf, nil)
 309
 310         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 311         readerMock.On("GetNodeb", "RanName_1").Return(updatedNb1, nil)
 312         updatedNb2 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
 313         writerMock.On("UpdateNodebInfo", updatedNb2).Return(nil)
 314         _, err := h.Handle(nil)
 315         assert.Nil(t, err)
 316         rmrMessengerMock.AssertCalled(t, "SendMsg", mbuf, true)
 317         readerMock.AssertExpectations(t)
 318         writerMock.AssertExpectations(t)
 319         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 2)
 320 }
 321
 322 func TestSuccessTwoE2TInstancesSixRans(t *testing.T) {
 323         h, readerMock, writerMock, rmrMessengerMock, httpClientMock := setupDeleteAllRequestHandlerTest(t)
 324         e2tAddresses := []string{E2TAddress, E2TAddress2}
 325         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 326         mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, true)
 327         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}, {InventoryName: "RanName_2"}, {InventoryName: "RanName_3"}, {InventoryName: "RanName_4"}, {InventoryName: "RanName_5"}, {InventoryName: "RanName_6"}}
 328         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 329         //nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_CONNECTED, AssociatedE2TInstanceAddress: E2TAddress}
 330         //readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 331         //nb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_CONNECTED, AssociatedE2TInstanceAddress: E2TAddress}
 332         //readerMock.On("GetNodeb", "RanName_2").Return(nb2, nil)
 333         //nb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_CONNECTED, AssociatedE2TInstanceAddress: E2TAddress}
 334         //readerMock.On("GetNodeb", "RanName_3").Return(nb3, nil)
 335         //nb4 := &entities.NodebInfo{RanName: "RanName_4", ConnectionStatus: entities.ConnectionStatus_CONNECTED, AssociatedE2TInstanceAddress: E2TAddress2}
 336         //readerMock.On("GetNodeb", "RanName_4").Return(nb4, nil)
 337         //nb5 := &entities.NodebInfo{RanName: "RanName_5", ConnectionStatus: entities.ConnectionStatus_CONNECTED, AssociatedE2TInstanceAddress: E2TAddress2}
 338         //readerMock.On("GetNodeb", "RanName_5").Return(nb5, nil)
 339         //nb6 := &entities.NodebInfo{RanName: "RanName_6", ConnectionStatus: entities.ConnectionStatus_CONNECTED, AssociatedE2TInstanceAddress: E2TAddress2}
 340         //readerMock.On("GetNodeb", "RanName_6").Return(nb6, nil)
 341
 342         updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 343         writerMock.On("UpdateNodebInfo", updatedNb1).Return(nil)
 344         updatedNb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 345         writerMock.On("UpdateNodebInfo", updatedNb2).Return(nil)
 346         updatedNb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 347         writerMock.On("UpdateNodebInfo", updatedNb3).Return(nil)
 348         updatedNb4 := &entities.NodebInfo{RanName: "RanName_4", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 349         writerMock.On("UpdateNodebInfo", updatedNb4).Return(nil)
 350         updatedNb5 := &entities.NodebInfo{RanName: "RanName_5", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 351         writerMock.On("UpdateNodebInfo", updatedNb5).Return(nil)
 352         updatedNb6 := &entities.NodebInfo{RanName: "RanName_6", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 353         writerMock.On("UpdateNodebInfo", updatedNb6).Return(nil)
 354
 355         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 356         e2tInstance := entities.E2TInstance{Address: E2TAddress, AssociatedRanList: []string{"RanName_1", "RanName_2", "RanName_3"}}
 357         e2tInstance2 := entities.E2TInstance{Address: E2TAddress2, AssociatedRanList: []string{"RanName_4", "RanName_5", "RanName_6"}}
 358         readerMock.On("GetE2TInstances", e2tAddresses).Return([]*entities.E2TInstance{&e2tInstance, &e2tInstance2}, nil)
 359         updatedE2tInstance := e2tInstance
 360         updatedE2tInstance.AssociatedRanList = []string{}
 361         updatedE2tInstance2 := e2tInstance2
 362         updatedE2tInstance2.AssociatedRanList = []string{}
 363         writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(nil)
 364         writerMock.On("SaveE2TInstance", &updatedE2tInstance2).Return(nil)
 365
 366         rmrMessage := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
 367         mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction)
 368         rmrMessengerMock.On("SendMsg", mbuf, true).Return(mbuf, nil)
 369
 370         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 371         readerMock.On("GetNodeb", "RanName_1").Return(updatedNb1, nil)
 372         readerMock.On("GetNodeb", "RanName_2").Return(updatedNb2, nil)
 373         readerMock.On("GetNodeb", "RanName_3").Return(updatedNb3, nil)
 374         readerMock.On("GetNodeb", "RanName_4").Return(updatedNb4, nil)
 375         readerMock.On("GetNodeb", "RanName_5").Return(updatedNb5, nil)
 376         readerMock.On("GetNodeb", "RanName_6").Return(updatedNb6, nil)
 377
 378         updatedNb1AfterTimer := *updatedNb1
 379         updatedNb1AfterTimer.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
 380         writerMock.On("UpdateNodebInfo", &updatedNb1AfterTimer).Return(nil)
 381         updatedNb2AfterTimer := *updatedNb2
 382         updatedNb2AfterTimer.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
 383         writerMock.On("UpdateNodebInfo", &updatedNb2AfterTimer).Return(nil)
 384         updatedNb3AfterTimer := *updatedNb3
 385         updatedNb3AfterTimer.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
 386         writerMock.On("UpdateNodebInfo", &updatedNb3AfterTimer).Return(nil)
 387         updatedNb4AfterTimer := *updatedNb4
 388         updatedNb4AfterTimer.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
 389         writerMock.On("UpdateNodebInfo", &updatedNb4AfterTimer).Return(nil)
 390         updatedNb5AfterTimer := *updatedNb5
 391         updatedNb5AfterTimer.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
 392         writerMock.On("UpdateNodebInfo", &updatedNb5AfterTimer).Return(nil)
 393         updatedNb6AfterTimer := *updatedNb6
 394         updatedNb6AfterTimer.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
 395         writerMock.On("UpdateNodebInfo", &updatedNb6AfterTimer).Return(nil)
 396         _, err := h.Handle(nil)
 397         assert.Nil(t, err)
 398         rmrMessengerMock.AssertCalled(t, "SendMsg", mbuf, true)
 399         readerMock.AssertExpectations(t)
 400         writerMock.AssertExpectations(t)
 401         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 12)
 402 }
 403
 404 func initLog(t *testing.T) *logger.Logger {
 405         log, err := logger.InitLogger(logger.DebugLevel)
 406         if err != nil {
 407                 t.Errorf("#initLog test - failed to initialize logger, error: %s", err)
 408         }
 409         return log
 410 }
 411
 412 func getRmrSender(rmrMessengerMock *mocks.RmrMessengerMock, log *logger.Logger) *rmrsender.RmrSender {
 413         rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
 414         rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
 415         return rmrsender.NewRmrSender(log, rmrMessenger)
 416 }