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