E2Manager/handlers/httpmsghandlers/delete_all_request_handler_test.go

   1 //
   2 // Copyright 2019 AT&T Intellectual Property
   3 // Copyright 2019 Nokia
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the "License");
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //      http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16
  17 //  This source code is part of the near-RT RIC (RAN Intelligent Controller)
  18 //  platform project (RICP).
  19
  20 package httpmsghandlers
  21
  22 import (
  23         "bytes"
  24         "e2mgr/clients"
  25         "e2mgr/configuration"
  26         "e2mgr/e2managererrors"
  27         "e2mgr/logger"
  28         "e2mgr/managers"
  29         "e2mgr/mocks"
  30         "e2mgr/models"
  31         "e2mgr/rmrCgo"
  32         "e2mgr/services"
  33         "e2mgr/services/rmrsender"
  34         "e2mgr/tests"
  35         "encoding/json"
  36         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
  37         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
  38         "github.com/pkg/errors"
  39         "github.com/stretchr/testify/assert"
  40         "io/ioutil"
  41         "net/http"
  42         "testing"
  43 )
  44
  45 const E2TAddress = "10.0.2.15:8989"
  46 const BaseRMUrl = "http://10.10.2.15:12020/routingmanager"
  47
  48 func setupDeleteAllRequestHandlerTest(t *testing.T) (*DeleteAllRequestHandler, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.RmrMessengerMock, *mocks.HttpClientMock) {
  49         log := initLog(t)
  50         config := &configuration.Configuration{RnibWriter: configuration.RnibWriterConfig{ StateChangeMessageChannel: "RAN_CONNECTION_STATUS_CHANGE"}}
  51         config.BigRedButtonTimeoutSec = 1
  52         config.RoutingManager.BaseUrl = BaseRMUrl
  53
  54         readerMock := &mocks.RnibReaderMock{}
  55         writerMock := &mocks.RnibWriterMock{}
  56         rnibDataService := services.NewRnibDataService(log, config, readerMock, writerMock)
  57
  58         rmrMessengerMock := &mocks.RmrMessengerMock{}
  59         rmrSender := getRmrSender(rmrMessengerMock, log)
  60
  61         e2tInstancesManager := managers.NewE2TInstancesManager(rnibDataService, log)
  62         httpClientMock := &mocks.HttpClientMock{}
  63         rmClient := clients.NewRoutingManagerClient(log, config, httpClientMock)
  64
  65         ranListManager := managers.NewRanListManager(log)
  66         ranAlarmService := services.NewRanAlarmService(log, config)
  67         ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(log, rnibDataService,ranListManager, ranAlarmService)
  68
  69         handler := NewDeleteAllRequestHandler(log, rmrSender, config, rnibDataService, e2tInstancesManager, rmClient, ranConnectStatusChangeManager)
  70         return handler, readerMock, writerMock, rmrMessengerMock, httpClientMock
  71 }
  72
  73 func mapE2TAddressesToE2DataList(e2tAddresses []string) models.RoutingManagerE2TDataList {
  74         e2tDataList := make(models.RoutingManagerE2TDataList, len(e2tAddresses))
  75
  76         for i, v := range e2tAddresses {
  77                 e2tDataList[i] = models.NewRoutingManagerE2TData(v)
  78         }
  79
  80         return e2tDataList
  81 }
  82
  83 func mockHttpClientDissociateAllRans(httpClientMock *mocks.HttpClientMock, e2tAddresses []string, ok bool) {
  84         data := mapE2TAddressesToE2DataList(e2tAddresses)
  85         marshaled, _ := json.Marshal(data)
  86         body := bytes.NewBuffer(marshaled)
  87         url := BaseRMUrl + clients.DissociateRanE2TInstanceApiSuffix
  88         respBody := ioutil.NopCloser(bytes.NewBufferString(""))
  89
  90         var status int
  91         if ok {
  92                 status = http.StatusOK
  93         } else {
  94                 status = http.StatusBadRequest
  95         }
  96         httpClientMock.On("Post", url, "application/json", body).Return(&http.Response{StatusCode: status, Body: respBody}, nil)
  97 }
  98
  99 func TestGetE2TAddressesFailure(t *testing.T) {
 100         h, readerMock, _, _, _ := setupDeleteAllRequestHandlerTest(t)
 101         readerMock.On("GetE2TAddresses").Return([]string{}, common.NewInternalError(errors.New("error")))
 102         _, err := h.Handle(nil)
 103         assert.IsType(t, &e2managererrors.RnibDbError{}, err)
 104         readerMock.AssertExpectations(t)
 105 }
 106
 107 func TestOneRanGetE2TAddressesEmptyList(t *testing.T) {
 108         h, readerMock, writerMock, _, _ := setupDeleteAllRequestHandlerTest(t)
 109         readerMock.On("GetE2TAddresses").Return([]string{}, nil)
 110         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
 111         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 112         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,}
 113         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 114         updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
 115         writerMock.On("UpdateNodebInfo", updatedNb1).Return(nil)
 116         _, err := h.Handle(nil)
 117         assert.Nil(t, err)
 118         readerMock.AssertExpectations(t)
 119         writerMock.AssertExpectations(t)
 120 }
 121
 122 func TestTwoRansGetE2TAddressesEmptyListOneGetNodebFailure(t *testing.T) {
 123         h, readerMock, writerMock, _, _ := setupDeleteAllRequestHandlerTest(t)
 124         readerMock.On("GetE2TAddresses").Return([]string{}, nil)
 125         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}, {InventoryName: "RanName_2"}}
 126         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 127         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,}
 128         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 129
 130         updatedNb1 := *nb1
 131         updatedNb1.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
 132         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", &updatedNb1, "RanName_1_DISCONNECTED").Return(nil)
 133
 134         nodeb1NotAssociated := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN}
 135         writerMock.On("UpdateNodebInfo", nodeb1NotAssociated).Return(nil)
 136
 137         var nb2 *entities.NodebInfo
 138         readerMock.On("GetNodeb", "RanName_2").Return(nb2, common.NewInternalError(errors.New("error")))
 139         _, err := h.Handle(nil)
 140         assert.IsType(t,&e2managererrors.RnibDbError{}, err)
 141         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 2)
 142         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfoOnConnectionStatusInversion", 0)
 143         readerMock.AssertExpectations(t)
 144 }
 145
 146 func TestUpdateNodebInfoOnConnectionStatusInversionFailure(t *testing.T) {
 147         h, readerMock, writerMock, _, _ := setupDeleteAllRequestHandlerTest(t)
 148         readerMock.On("GetE2TAddresses").Return([]string{}, nil)
 149         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}, {InventoryName: "RanName_2"}}
 150         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 151         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_CONNECTED}
 152         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 153
 154         updatedNb1 := *nb1
 155         updatedNb1.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
 156         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", &updatedNb1, "RanName_1_DISCONNECTED").Return(common.NewInternalError(errors.New("error")))
 157
 158         _, err := h.Handle(nil)
 159
 160         assert.IsType(t,&e2managererrors.RnibDbError{}, err)
 161         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 0)
 162         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfoOnConnectionStatusInversion", 1)
 163         readerMock.AssertExpectations(t)
 164 }
 165
 166 func TestTwoRansGetE2TAddressesEmptyListOneUpdateNodebInfoFailure(t *testing.T) {
 167         h, readerMock, writerMock, _, _ := setupDeleteAllRequestHandlerTest(t)
 168         readerMock.On("GetE2TAddresses").Return([]string{}, nil)
 169         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}, {InventoryName: "RanName_2"}}
 170         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 171
 172         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,}
 173         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 174         updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
 175         writerMock.On("UpdateNodebInfo", updatedNb1).Return(nil)
 176
 177         nb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,}
 178         readerMock.On("GetNodeb", "RanName_2").Return(nb2, nil)
 179         updatedNb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
 180         writerMock.On("UpdateNodebInfo", updatedNb2).Return(common.NewInternalError(errors.New("error")))
 181         _, err := h.Handle(nil)
 182         assert.IsType(t,&e2managererrors.RnibDbError{}, err)
 183         readerMock.AssertExpectations(t)
 184         writerMock.AssertExpectations(t)
 185 }
 186
 187 func TestOneRanDissociateSucceedsTryShuttingDownFailure(t *testing.T) {
 188         h, readerMock, writerMock, _, httpClientMock := setupDeleteAllRequestHandlerTest(t)
 189         e2tAddresses := []string{E2TAddress}
 190         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 191         mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, true)
 192         nbIdentityList := []*entities.NbIdentity{}
 193         readerMock.On("GetListNodebIds").Return(nbIdentityList, common.NewInternalError(errors.New("error")))
 194         _, err := h.Handle(nil)
 195         assert.IsType(t, &e2managererrors.RnibDbError{}, err)
 196         readerMock.AssertExpectations(t)
 197         writerMock.AssertExpectations(t)
 198 }
 199
 200 func TestOneRanDissociateFailsTryShuttingDownFailure(t *testing.T) {
 201         h, readerMock, writerMock, _, httpClientMock := setupDeleteAllRequestHandlerTest(t)
 202         e2tAddresses := []string{E2TAddress}
 203
 204         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 205         mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, false)
 206         nbIdentityList := []*entities.NbIdentity{}
 207         readerMock.On("GetListNodebIds").Return(nbIdentityList, common.NewInternalError(errors.New("error")))
 208         _, err := h.Handle(nil)
 209         assert.IsType(t, &e2managererrors.RnibDbError{}, err)
 210         readerMock.AssertExpectations(t)
 211         writerMock.AssertExpectations(t)
 212 }
 213
 214 func TestOneRanWithStateShutDown(t *testing.T) {
 215         h, readerMock, writerMock, rmrMessengerMock, httpClientMock := setupDeleteAllRequestHandlerTest(t)
 216         e2tAddresses := []string{E2TAddress}
 217         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 218         mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, true)
 219         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
 220         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 221
 222         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN}
 223         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 224         readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
 225
 226         e2tInstance := entities.E2TInstance{Address: E2TAddress, AssociatedRanList: []string{"RanName_1"}}
 227         readerMock.On("GetE2TInstances", []string{E2TAddress}).Return([]*entities.E2TInstance{&e2tInstance}, nil)
 228         updatedE2tInstance := e2tInstance
 229         updatedE2tInstance.AssociatedRanList = []string{}
 230         writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(nil)
 231
 232         rmrMessage := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
 233         mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction, rmrMessage.GetMsgSrc())
 234         rmrMessengerMock.On("SendMsg", mbuf, true).Return(mbuf, nil)
 235
 236         _, err := h.Handle(nil)
 237
 238         assert.Nil(t, err)
 239         rmrMessengerMock.AssertCalled(t, "SendMsg", mbuf, true)
 240         readerMock.AssertExpectations(t)
 241         writerMock.AssertExpectations(t)
 242 }
 243
 244 func TestOneRanShutDown(t *testing.T) {
 245         h, readerMock, writerMock, _, httpClientMock := setupDeleteAllRequestHandlerTest(t)
 246         e2tAddresses := []string{}
 247         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 248         mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, true)
 249         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
 250         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 251
 252         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN}
 253         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 254
 255         nodeb1NotAssociated := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
 256         writerMock.On("UpdateNodebInfo", nodeb1NotAssociated).Return(nil)
 257
 258         readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
 259
 260         _, err := h.Handle(nil)
 261
 262         assert.Nil(t, err)
 263         readerMock.AssertExpectations(t)
 264         writerMock.AssertExpectations(t)
 265 }
 266
 267 func TestOneRanTryShuttingDownSucceedsClearFails(t *testing.T) {
 268         h, readerMock, writerMock, _, httpClientMock := setupDeleteAllRequestHandlerTest(t)
 269         e2tAddresses := []string{E2TAddress}
 270         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 271         mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, true)
 272         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
 273         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 274
 275         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_CONNECTED, AssociatedE2TInstanceAddress: E2TAddress}
 276         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 277
 278         updatedNb1 := *nb1
 279         updatedNb1.ConnectionStatus = entities.ConnectionStatus_SHUTTING_DOWN
 280         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", &updatedNb1, "RanName_1_DISCONNECTED").Return(nil)
 281
 282         nodeb1NotAssociated := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 283         writerMock.On("UpdateNodebInfo", nodeb1NotAssociated).Return(nil)
 284
 285         readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
 286         readerMock.On("GetE2TInstances", []string{E2TAddress}).Return([]*entities.E2TInstance{}, common.NewInternalError(errors.New("error")))
 287         _, err := h.Handle(nil)
 288         assert.IsType(t, &e2managererrors.RnibDbError{}, err)
 289         readerMock.AssertExpectations(t)
 290         writerMock.AssertExpectations(t)
 291 }
 292
 293 func TestOneRanTryShuttingDownUpdateNodebError(t *testing.T) {
 294         h, readerMock, writerMock, _, httpClientMock := setupDeleteAllRequestHandlerTest(t)
 295         e2tAddresses := []string{E2TAddress}
 296         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 297         mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, true)
 298         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
 299         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 300
 301         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_CONNECTED, AssociatedE2TInstanceAddress: E2TAddress}
 302         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 303
 304         updatedNb1 := *nb1
 305         updatedNb1.ConnectionStatus = entities.ConnectionStatus_SHUTTING_DOWN
 306         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", &updatedNb1, "RanName_1_DISCONNECTED").Return(nil)
 307
 308         nodeb1NotAssociated := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 309         writerMock.On("UpdateNodebInfo", nodeb1NotAssociated).Return(common.NewInternalError(errors.New("error")))
 310
 311         _, err := h.Handle(nil)
 312
 313         assert.IsType(t, &e2managererrors.RnibDbError{}, err)
 314         readerMock.AssertExpectations(t)
 315         writerMock.AssertExpectations(t)
 316 }
 317
 318 func TestOneRanTryShuttingDownSucceedsClearSucceedsRmrSendFails(t *testing.T) {
 319         h, readerMock, writerMock, rmrMessengerMock, httpClientMock := setupDeleteAllRequestHandlerTest(t)
 320         e2tAddresses := []string{E2TAddress}
 321         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 322         mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, true)
 323         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
 324         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 325         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_CONNECTED, AssociatedE2TInstanceAddress: E2TAddress}
 326         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 327
 328         updatedNb1 := *nb1
 329         updatedNb1.ConnectionStatus = entities.ConnectionStatus_SHUTTING_DOWN
 330         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", &updatedNb1, "RanName_1_DISCONNECTED").Return(nil)
 331
 332         nodeb1NotAssociated := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 333         writerMock.On("UpdateNodebInfo", nodeb1NotAssociated).Return(nil)
 334
 335         readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
 336         e2tInstance := entities.E2TInstance{Address: E2TAddress, AssociatedRanList: []string{"RanName_1"}}
 337         readerMock.On("GetE2TInstances", []string{E2TAddress}).Return([]*entities.E2TInstance{&e2tInstance}, nil)
 338         updatedE2tInstance := e2tInstance
 339         updatedE2tInstance.AssociatedRanList = []string{}
 340         writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(nil)
 341
 342         rmrMessage := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
 343         mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction, rmrMessage.GetMsgSrc())
 344         rmrMessengerMock.On("SendMsg", mbuf, true).Return(mbuf, e2managererrors.NewRmrError())
 345         _, err := h.Handle(nil)
 346         assert.IsType(t, &e2managererrors.RmrError{}, err)
 347         rmrMessengerMock.AssertCalled(t, "SendMsg", mbuf, true)
 348         readerMock.AssertExpectations(t)
 349         writerMock.AssertExpectations(t)
 350 }
 351
 352 func testTwoRansTryShuttingDownSucceedsClearSucceedsRmrSucceedsAllRansAreShutdown(t *testing.T, partial bool) {
 353         h, readerMock, writerMock, rmrMessengerMock, httpClientMock := setupDeleteAllRequestHandlerTest(t)
 354         e2tAddresses := []string{E2TAddress}
 355         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 356         mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, !partial)
 357         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}, {InventoryName: "RanName_2"}}
 358         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 359         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN}
 360         nb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN}
 361         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 362         readerMock.On("GetNodeb", "RanName_2").Return(nb2, nil)
 363         readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
 364         e2tInstance := entities.E2TInstance{Address: E2TAddress, AssociatedRanList: []string{"RanName_1", "RanName_2"}}
 365         readerMock.On("GetE2TInstances", []string{E2TAddress}).Return([]*entities.E2TInstance{&e2tInstance}, nil)
 366         updatedE2tInstance := e2tInstance
 367         updatedE2tInstance.AssociatedRanList = []string{}
 368         writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(nil)
 369
 370         rmrMessage := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
 371         mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction, rmrMessage.GetMsgSrc())
 372         rmrMessengerMock.On("SendMsg", mbuf, true).Return(mbuf, nil)
 373         resp, err := h.Handle(nil)
 374         assert.Nil(t, err)
 375
 376         if partial {
 377                 assert.IsType(t, &models.RedButtonPartialSuccessResponseModel{}, resp)
 378         } else {
 379                 assert.Nil(t, resp)
 380         }
 381
 382         rmrMessengerMock.AssertCalled(t, "SendMsg", mbuf, true)
 383         readerMock.AssertExpectations(t)
 384         writerMock.AssertExpectations(t)
 385 }
 386
 387 func TestTwoRansTryShuttingDownSucceedsClearSucceedsRmrSucceedsAllRansAreShutdownSuccess(t *testing.T) {
 388         testTwoRansTryShuttingDownSucceedsClearSucceedsRmrSucceedsAllRansAreShutdown(t, false)
 389 }
 390
 391 func TestTwoRansTryShuttingDownSucceedsClearSucceedsRmrSucceedsAllRansAreShutdownPartialSuccess(t *testing.T) {
 392         testTwoRansTryShuttingDownSucceedsClearSucceedsRmrSucceedsAllRansAreShutdown(t, true)
 393 }
 394
 395 func TestOneRanTryShuttingDownSucceedsClearSucceedsRmrSucceedsRanStatusIsShuttingDownUpdateFailure(t *testing.T) {
 396         h, readerMock, writerMock, rmrMessengerMock, httpClientMock := setupDeleteAllRequestHandlerTest(t)
 397         e2tAddresses := []string{E2TAddress}
 398         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 399         mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, true)
 400         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
 401         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 402
 403         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN, AssociatedE2TInstanceAddress: E2TAddress}
 404         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 405
 406         updatedNb1 := *nb1 //&entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN, AssociatedE2TInstanceAddress: E2TAddress}
 407         writerMock.On("UpdateNodebInfo", &updatedNb1).Return(nil)
 408
 409         nodeb1NotAssociated := *nb1
 410         nodeb1NotAssociated.AssociatedE2TInstanceAddress = ""
 411         nodeb1NotAssociated.ConnectionStatus = entities.ConnectionStatus_SHUTTING_DOWN
 412         writerMock.On("UpdateNodebInfo", &nodeb1NotAssociated).Return(nil)
 413
 414         readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
 415         e2tInstance := entities.E2TInstance{Address: E2TAddress, AssociatedRanList: []string{"RanName_1"}}
 416         readerMock.On("GetE2TInstances", []string{E2TAddress}).Return([]*entities.E2TInstance{&e2tInstance}, nil)
 417         updatedE2tInstance := e2tInstance
 418         updatedE2tInstance.AssociatedRanList = []string{}
 419         writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(nil)
 420
 421         rmrMessage := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
 422         mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction, rmrMessage.GetMsgSrc())
 423         rmrMessengerMock.On("SendMsg", mbuf, true).Return(mbuf, nil)
 424
 425         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 426         readerMock.On("GetNodeb", "RanName_1").Return(updatedNb1, nil)
 427
 428         updatedNb2 := *nb1//&entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
 429         updatedNb2.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
 430         updatedNb2.AssociatedE2TInstanceAddress = ""
 431         writerMock.On("UpdateNodebInfo", &updatedNb2).Return(common.NewInternalError(errors.New("error")))
 432
 433         _, err := h.Handle(nil)
 434
 435         assert.IsType(t, &e2managererrors.RnibDbError{}, err)
 436         rmrMessengerMock.AssertCalled(t, "SendMsg", mbuf, true)
 437         readerMock.AssertExpectations(t)
 438         writerMock.AssertExpectations(t)
 439 }
 440
 441 func testOneRanTryShuttingDownSucceedsClearSucceedsRmrSucceedsRanStatusIsShuttingDown(t *testing.T, partial bool) {
 442         h, readerMock, writerMock, rmrMessengerMock, httpClientMock := setupDeleteAllRequestHandlerTest(t)
 443         e2tAddresses := []string{E2TAddress}
 444         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 445         mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, !partial)
 446         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
 447         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 448         updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 449         writerMock.On("UpdateNodebInfo", updatedNb1).Return(nil)
 450         readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
 451         e2tInstance := entities.E2TInstance{Address: E2TAddress, AssociatedRanList: []string{"RanName_1"}}
 452         readerMock.On("GetE2TInstances", []string{E2TAddress}).Return([]*entities.E2TInstance{&e2tInstance}, nil)
 453         updatedE2tInstance := e2tInstance
 454         updatedE2tInstance.AssociatedRanList = []string{}
 455         writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(nil)
 456
 457         rmrMessage := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
 458         mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction, rmrMessage.GetMsgSrc())
 459         rmrMessengerMock.On("SendMsg", mbuf, true).Return(mbuf, nil)
 460
 461         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 462         readerMock.On("GetNodeb", "RanName_1").Return(updatedNb1, nil)
 463         updatedNb2 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
 464         writerMock.On("UpdateNodebInfo", updatedNb2).Return(nil)
 465         _, err := h.Handle(nil)
 466         assert.Nil(t, err)
 467         rmrMessengerMock.AssertCalled(t, "SendMsg", mbuf, true)
 468         readerMock.AssertExpectations(t)
 469         writerMock.AssertExpectations(t)
 470         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 3)
 471 }
 472
 473 func TestOneRanTryShuttingDownSucceedsClearSucceedsRmrSucceedsRanStatusIsShuttingDownSuccess (t *testing.T) {
 474         testOneRanTryShuttingDownSucceedsClearSucceedsRmrSucceedsRanStatusIsShuttingDown(t, false)
 475 }
 476
 477 func TestOneRanTryShuttingDownSucceedsClearSucceedsRmrSucceedsRanStatusIsShuttingDownPartialSuccess (t *testing.T) {
 478         testOneRanTryShuttingDownSucceedsClearSucceedsRmrSucceedsRanStatusIsShuttingDown(t, true)
 479 }
 480
 481 func TestSuccessTwoE2TInstancesSixRans(t *testing.T) {
 482         h, readerMock, writerMock, rmrMessengerMock, httpClientMock := setupDeleteAllRequestHandlerTest(t)
 483         e2tAddresses := []string{E2TAddress, E2TAddress2}
 484         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 485         mockHttpClientDissociateAllRans(httpClientMock, e2tAddresses, true)
 486         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}, {InventoryName: "RanName_2"}, {InventoryName: "RanName_3"}, {InventoryName: "RanName_4"}, {InventoryName: "RanName_5"}, {InventoryName: "RanName_6"}}
 487         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 488
 489         updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 490         writerMock.On("UpdateNodebInfo", updatedNb1).Return(nil)
 491         updatedNb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 492         writerMock.On("UpdateNodebInfo", updatedNb2).Return(nil)
 493         updatedNb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 494         writerMock.On("UpdateNodebInfo", updatedNb3).Return(nil)
 495         updatedNb4 := &entities.NodebInfo{RanName: "RanName_4", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 496         writerMock.On("UpdateNodebInfo", updatedNb4).Return(nil)
 497         updatedNb5 := &entities.NodebInfo{RanName: "RanName_5", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 498         writerMock.On("UpdateNodebInfo", updatedNb5).Return(nil)
 499         updatedNb6 := &entities.NodebInfo{RanName: "RanName_6", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 500         writerMock.On("UpdateNodebInfo", updatedNb6).Return(nil)
 501
 502         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 503         e2tInstance := entities.E2TInstance{Address: E2TAddress, AssociatedRanList: []string{"RanName_1", "RanName_2", "RanName_3"}}
 504         e2tInstance2 := entities.E2TInstance{Address: E2TAddress2, AssociatedRanList: []string{"RanName_4", "RanName_5", "RanName_6"}}
 505         readerMock.On("GetE2TInstances", e2tAddresses).Return([]*entities.E2TInstance{&e2tInstance, &e2tInstance2}, nil)
 506         updatedE2tInstance := e2tInstance
 507         updatedE2tInstance.AssociatedRanList = []string{}
 508         updatedE2tInstance2 := e2tInstance2
 509         updatedE2tInstance2.AssociatedRanList = []string{}
 510         writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(nil)
 511         writerMock.On("SaveE2TInstance", &updatedE2tInstance2).Return(nil)
 512
 513         rmrMessage := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
 514         mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction, rmrMessage.GetMsgSrc())
 515         rmrMessengerMock.On("SendMsg", mbuf, true).Return(mbuf, nil)
 516
 517         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 518         readerMock.On("GetNodeb", "RanName_1").Return(updatedNb1, nil)
 519         readerMock.On("GetNodeb", "RanName_2").Return(updatedNb2, nil)
 520         readerMock.On("GetNodeb", "RanName_3").Return(updatedNb3, nil)
 521         readerMock.On("GetNodeb", "RanName_4").Return(updatedNb4, nil)
 522         readerMock.On("GetNodeb", "RanName_5").Return(updatedNb5, nil)
 523         readerMock.On("GetNodeb", "RanName_6").Return(updatedNb6, nil)
 524
 525         updatedNb1AfterTimer := *updatedNb1
 526         updatedNb1AfterTimer.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
 527         writerMock.On("UpdateNodebInfo", &updatedNb1AfterTimer).Return(nil)
 528         updatedNb2AfterTimer := *updatedNb2
 529         updatedNb2AfterTimer.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
 530         writerMock.On("UpdateNodebInfo", &updatedNb2AfterTimer).Return(nil)
 531         updatedNb3AfterTimer := *updatedNb3
 532         updatedNb3AfterTimer.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
 533         writerMock.On("UpdateNodebInfo", &updatedNb3AfterTimer).Return(nil)
 534         updatedNb4AfterTimer := *updatedNb4
 535         updatedNb4AfterTimer.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
 536         writerMock.On("UpdateNodebInfo", &updatedNb4AfterTimer).Return(nil)
 537         updatedNb5AfterTimer := *updatedNb5
 538         updatedNb5AfterTimer.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
 539         writerMock.On("UpdateNodebInfo", &updatedNb5AfterTimer).Return(nil)
 540         updatedNb6AfterTimer := *updatedNb6
 541         updatedNb6AfterTimer.ConnectionStatus = entities.ConnectionStatus_SHUT_DOWN
 542         writerMock.On("UpdateNodebInfo", &updatedNb6AfterTimer).Return(nil)
 543         _, err := h.Handle(nil)
 544         assert.Nil(t, err)
 545         rmrMessengerMock.AssertCalled(t, "SendMsg", mbuf, true)
 546         readerMock.AssertExpectations(t)
 547         writerMock.AssertExpectations(t)
 548         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 18)
 549 }
 550
 551 func initLog(t *testing.T) *logger.Logger {
 552         log, err := logger.InitLogger(logger.DebugLevel)
 553         if err != nil {
 554                 t.Errorf("#initLog test - failed to initialize logger, error: %s", err)
 555         }
 556         return log
 557 }
 558
 559 func getRmrSender(rmrMessengerMock *mocks.RmrMessengerMock, log *logger.Logger) *rmrsender.RmrSender {
 560         rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
 561         rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
 562         return rmrsender.NewRmrSender(log, rmrMessenger)
 563 }