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
  21 package httpmsghandlers
  22
  23 import (
  24         "e2mgr/configuration"
  25         "e2mgr/e2managererrors"
  26         "e2mgr/logger"
  27         "e2mgr/mocks"
  28         "e2mgr/rmrCgo"
  29         "e2mgr/services"
  30         "e2mgr/services/rmrsender"
  31         "e2mgr/tests"
  32         "fmt"
  33         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
  34         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
  35         "github.com/stretchr/testify/assert"
  36         "github.com/stretchr/testify/mock"
  37         "reflect"
  38         "testing"
  39 )
  40
  41 func setupTest(t *testing.T) (*logger.Logger, *configuration.Configuration, *mocks.RnibReaderMock, *mocks.RnibWriterMock, services.RNibDataService, *mocks.RmrMessengerMock) {
  42         log := initLog(t)
  43         config := configuration.ParseConfiguration()
  44
  45         readerMock := &mocks.RnibReaderMock{}
  46
  47         writerMock := &mocks.RnibWriterMock{}
  48
  49         rnibDataService := services.NewRnibDataService(log, config, readerMock, writerMock)
  50         rmrMessengerMock := &mocks.RmrMessengerMock{}
  51         return log, config, readerMock, writerMock, rnibDataService, rmrMessengerMock
  52 }
  53
  54 func TestHandleBeforeTimerGetListNodebIdsFailedFlow(t *testing.T) {
  55         log, config, readerMock, _, rnibDataService, rmrMessengerMock := setupTest(t)
  56
  57         handler := NewDeleteAllRequestHandler(log, getRmrSender(rmrMessengerMock, log), config, rnibDataService)
  58
  59         rnibErr := &common.ResourceNotFoundError{}
  60         var nbIdentityList []*entities.NbIdentity
  61         readerMock.On("GetListNodebIds").Return(nbIdentityList, rnibErr)
  62
  63         expected := &e2managererrors.RnibDbError{}
  64         _, actual := handler.Handle(nil)
  65         if reflect.TypeOf(actual) != reflect.TypeOf(expected) {
  66                 t.Errorf("Error actual = %v, and Expected = %v.", actual, expected)
  67         }
  68 }
  69
  70 func TestHandleAfterTimerGetListNodebIdsFailedFlow(t *testing.T) {
  71         log, config, readerMock, writerMock, rnibDataService, rmrMessengerMock := setupTest(t)
  72
  73         config.BigRedButtonTimeoutSec = 1
  74
  75         handler := NewDeleteAllRequestHandler(log, getRmrSender(rmrMessengerMock, log), config, rnibDataService)
  76
  77         rnibErr := &common.ResourceNotFoundError{}
  78         //Before timer: Disconnected->ShutDown, ShuttingDown->Ignore, Connected->ShuttingDown
  79         nbIdentityList := createIdentityList()
  80
  81         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil).Return(nbIdentityList, rnibErr)
  82
  83         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,}
  84         nb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
  85         nb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_CONNECTED,}
  86         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
  87         readerMock.On("GetNodeb", "RanName_2").Return(nb2, nil)
  88         readerMock.On("GetNodeb", "RanName_3").Return(nb3, nil)
  89
  90         updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
  91         updatedNb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
  92         writerMock.On("SaveNodeb", mock.Anything, updatedNb1).Return(nil)
  93         writerMock.On("SaveNodeb", mock.Anything, updatedNb3).Return(nil)
  94
  95         expected := &e2managererrors.RnibDbError{}
  96         _, actual := handler.Handle(nil)
  97
  98         if reflect.TypeOf(actual) != reflect.TypeOf(expected) {
  99                 t.Errorf("Error actual = %v, and Expected = %v.", actual, expected)
 100         }
 101 }
 102
 103 func TestHandleSuccessFlow(t *testing.T) {
 104         log, config, readerMock, writerMock, rnibDataService, rmrMessengerMock := setupTest(t)
 105
 106         config.BigRedButtonTimeoutSec = 1
 107         handler := NewDeleteAllRequestHandler(log, getRmrSender(rmrMessengerMock, log), config, rnibDataService)
 108
 109         //Before timer: Disconnected->ShutDown, ShuttingDown->Ignore, Connected->ShuttingDown
 110         nbIdentityList := createIdentityList()
 111         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 112
 113         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,}
 114         nb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 115         nb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_CONNECTED,}
 116         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 117         readerMock.On("GetNodeb", "RanName_2").Return(nb2, nil)
 118         readerMock.On("GetNodeb", "RanName_3").Return(nb3, nil)
 119
 120         updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
 121         updatedNb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 122         writerMock.On("SaveNodeb", mock.Anything, updatedNb1).Return(nil)
 123         writerMock.On("SaveNodeb", mock.Anything, updatedNb3).Return(nil)
 124
 125         //after timer: ShutDown->Ignore, ShuttingDown->ShutDown
 126         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 127
 128         nb1AfterTimer := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
 129         nb2AfterTimer := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 130         nb3AfterTimer := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 131         readerMock.On("GetNodeb", "RanName_1").Return(nb1AfterTimer, nil)
 132         readerMock.On("GetNodeb", "RanName_2").Return(nb2AfterTimer, nil)
 133         readerMock.On("GetNodeb", "RanName_3").Return(nb3AfterTimer, nil)
 134
 135         updatedNb2AfterTimer := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
 136         updatedNb3AfterTimer := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
 137         writerMock.On("SaveNodeb", mock.Anything, updatedNb2AfterTimer).Return(nil)
 138         writerMock.On("SaveNodeb", mock.Anything, updatedNb3AfterTimer).Return(nil)
 139
 140         mbuf := rmrCgo.NewMBuf(tests.MessageType, tests.MaxMsgSize, "RanName", &tests.DummyPayload, &tests.DummyXAction)
 141         rmrMessengerMock.On("SendMsg", mock.AnythingOfType(fmt.Sprintf("%T", mbuf)), true).Return(mbuf, nil)
 142
 143         _, actual := handler.Handle(nil)
 144
 145         assert.Nil(t, actual)
 146 }
 147
 148 func TestHandleSuccessGetNextStatusFlow(t *testing.T) {
 149         log, config, readerMock, writerMock, rnibDataService, rmrMessengerMock := setupTest(t)
 150
 151         config.BigRedButtonTimeoutSec = 1
 152         handler := NewDeleteAllRequestHandler(log, getRmrSender(rmrMessengerMock, log), config, rnibDataService)
 153
 154         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
 155         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 156
 157         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_CONNECTED,}
 158         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 159
 160         updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 161         writerMock.On("SaveNodeb", mock.Anything, updatedNb1).Return(nil)
 162
 163         //after timer: ShutDown->Ignore, ShuttingDown->ShutDown
 164         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 165
 166         nb1AfterTimer := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 167         readerMock.On("GetNodeb", "RanName_1").Return(nb1AfterTimer, nil)
 168
 169         updatedNb1AfterTimer := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
 170         writerMock.On("SaveNodeb", mock.Anything, updatedNb1AfterTimer).Return(nil)
 171
 172         mbuf := rmrCgo.NewMBuf(tests.MessageType, tests.MaxMsgSize, "RanName", &tests.DummyPayload, &tests.DummyXAction)
 173         rmrMessengerMock.On("SendMsg", mock.AnythingOfType(fmt.Sprintf("%T", mbuf)), true).Return(mbuf, nil)
 174
 175         _, actual := handler.Handle(nil)
 176
 177         assert.Nil(t, actual)
 178 }
 179
 180 func TestHandleShuttingDownStatusFlow(t *testing.T) {
 181         log, config, readerMock, writerMock, rnibDataService, rmrMessengerMock := setupTest(t)
 182
 183         config.BigRedButtonTimeoutSec = 1
 184         handler := NewDeleteAllRequestHandler(log, getRmrSender(rmrMessengerMock, log), config, rnibDataService)
 185
 186         nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
 187         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 188
 189         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 190         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 191
 192         //after timer: ShutDown->Ignore, ShuttingDown->ShutDown
 193         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 194
 195         nb1AfterTimer := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 196         readerMock.On("GetNodeb", "RanName_1").Return(nb1AfterTimer, nil)
 197
 198         updatedNb1AfterTimer := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
 199         writerMock.On("SaveNodeb", mock.Anything, updatedNb1AfterTimer).Return(nil)
 200
 201         mbuf := rmrCgo.NewMBuf(tests.MessageType, tests.MaxMsgSize, "RanName", &tests.DummyPayload, &tests.DummyXAction)
 202         rmrMessengerMock.On("SendMsg", mock.AnythingOfType(fmt.Sprintf("%T", mbuf)), true).Return(mbuf, nil)
 203
 204         _, actual := handler.Handle(nil)
 205
 206         assert.Nil(t, actual)
 207 }
 208
 209 func TestHandleGetNodebFailedFlow(t *testing.T) {
 210         log, config, readerMock, writerMock, rnibDataService, rmrMessengerMock := setupTest(t)
 211
 212         config.BigRedButtonTimeoutSec = 1
 213         handler := NewDeleteAllRequestHandler(log, getRmrSender(rmrMessengerMock, log), config, rnibDataService)
 214
 215         //Before timer: Disconnected->ShutDown(will fail), ShuttingDown->Ignore, Connected->ShuttingDown
 216         nbIdentityList := createIdentityList()
 217         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 218
 219         errRnib := &common.ResourceNotFoundError{}
 220         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,}
 221         nb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 222         nb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_CONNECTED,}
 223         readerMock.On("GetNodeb", "RanName_1").Return(nb1, errRnib)
 224         readerMock.On("GetNodeb", "RanName_2").Return(nb2, nil)
 225         readerMock.On("GetNodeb", "RanName_3").Return(nb3, nil)
 226
 227         updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
 228         updatedNb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 229         writerMock.On("SaveNodeb", mock.Anything, updatedNb1).Return(errRnib)
 230         writerMock.On("SaveNodeb", mock.Anything, updatedNb3).Return(nil)
 231
 232         //after timer: ShutDown->Ignore, ShuttingDown->ShutDown
 233         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 234
 235         nb1AfterTimer := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
 236         nb2AfterTimer := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 237         nb3AfterTimer := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 238         readerMock.On("GetNodeb", "RanName_1").Return(nb1AfterTimer, errRnib)
 239         readerMock.On("GetNodeb", "RanName_2").Return(nb2AfterTimer, nil)
 240         readerMock.On("GetNodeb", "RanName_3").Return(nb3AfterTimer, nil)
 241
 242         updatedNb2AfterTimer := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
 243         updatedNb3AfterTimer := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
 244         writerMock.On("SaveNodeb", mock.Anything, updatedNb2AfterTimer).Return(nil)
 245         writerMock.On("SaveNodeb", mock.Anything, updatedNb3AfterTimer).Return(nil)
 246
 247         mbuf := rmrCgo.NewMBuf(tests.MessageType, tests.MaxMsgSize, "RanName", &tests.DummyPayload, &tests.DummyXAction)
 248         rmrMessengerMock.On("SendMsg", mock.AnythingOfType(fmt.Sprintf("%T", mbuf)), true).Return(mbuf, nil)
 249
 250         _, actual := handler.Handle(nil)
 251
 252         assert.Nil(t, actual)
 253 }
 254
 255 func TestHandleSaveFailedFlow(t *testing.T) {
 256         log, config, readerMock, writerMock, rnibDataService, rmrMessengerMock := setupTest(t)
 257
 258         config.BigRedButtonTimeoutSec = 1
 259         handler := NewDeleteAllRequestHandler(log, getRmrSender(rmrMessengerMock, log), config, rnibDataService)
 260
 261         //Before timer: Disconnected->ShutDown, ShuttingDown->Ignore, Connected->ShuttingDown(will fail)
 262         nbIdentityList := createIdentityList()
 263         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 264
 265         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,}
 266         nb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 267         nb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_CONNECTED,}
 268         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 269         readerMock.On("GetNodeb", "RanName_2").Return(nb2, nil)
 270         readerMock.On("GetNodeb", "RanName_3").Return(nb3, nil)
 271
 272         errRnib := &common.ResourceNotFoundError{}
 273         updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
 274         updatedNb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 275         writerMock.On("SaveNodeb", mock.Anything, updatedNb1).Return(nil)
 276         writerMock.On("SaveNodeb", mock.Anything, updatedNb3).Return(errRnib)
 277
 278         //after timer: ShutDown->Ignore, ShuttingDown->ShutDown(will fail)
 279         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 280
 281         nb1AfterTimer := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
 282         nb2AfterTimer := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 283         nb3AfterTimer := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 284         readerMock.On("GetNodeb", "RanName_1").Return(nb1AfterTimer, nil)
 285         readerMock.On("GetNodeb", "RanName_2").Return(nb2AfterTimer, nil)
 286         readerMock.On("GetNodeb", "RanName_3").Return(nb3AfterTimer, nil)
 287
 288         updatedNb2AfterTimer := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
 289         updatedNb3AfterTimer := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
 290         writerMock.On("SaveNodeb", mock.Anything, updatedNb2AfterTimer).Return(nil)
 291         writerMock.On("SaveNodeb", mock.Anything, updatedNb3AfterTimer).Return(errRnib)
 292
 293         mbuf := rmrCgo.NewMBuf(tests.MessageType, tests.MaxMsgSize, "RanName", &tests.DummyPayload, &tests.DummyXAction)
 294         rmrMessengerMock.On("SendMsg", mock.AnythingOfType(fmt.Sprintf("%T", mbuf)), true).Return(mbuf, nil)
 295
 296         _, actual := handler.Handle(nil)
 297
 298         assert.Nil(t, actual)
 299 }
 300
 301 func TestHandleSendRmrFailedFlow(t *testing.T) {
 302         log, config, readerMock, writerMock, rnibDataService, rmrMessengerMock := setupTest(t)
 303
 304         config.BigRedButtonTimeoutSec = 1
 305         handler := NewDeleteAllRequestHandler(log, getRmrSender(rmrMessengerMock, log), config, rnibDataService)
 306
 307         //Before timer: Disconnected->ShutDown, ShuttingDown->Ignore, Connected->ShuttingDown(will fail)
 308         nbIdentityList := createIdentityList()
 309         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 310
 311         nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,}
 312         nb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 313         nb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_CONNECTED,}
 314         readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
 315         readerMock.On("GetNodeb", "RanName_2").Return(nb2, nil)
 316         readerMock.On("GetNodeb", "RanName_3").Return(nb3, nil)
 317
 318         updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
 319         updatedNb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 320         writerMock.On("SaveNodeb", mock.Anything, updatedNb1).Return(nil)
 321         writerMock.On("SaveNodeb", mock.Anything, updatedNb3).Return(nil)
 322
 323         //after timer: ShutDown->Ignore, ShuttingDown->ShutDown(will fail)
 324         readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
 325
 326         nb1AfterTimer := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
 327         nb2AfterTimer := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 328         nb3AfterTimer := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
 329         readerMock.On("GetNodeb", "RanName_1").Return(nb1AfterTimer, nil)
 330         readerMock.On("GetNodeb", "RanName_2").Return(nb2AfterTimer, nil)
 331         readerMock.On("GetNodeb", "RanName_3").Return(nb3AfterTimer, nil)
 332
 333         updatedNb2AfterTimer := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
 334         updatedNb3AfterTimer := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
 335         writerMock.On("SaveNodeb", mock.Anything, updatedNb2AfterTimer).Return(nil)
 336         writerMock.On("SaveNodeb", mock.Anything, updatedNb3AfterTimer).Return(nil)
 337
 338         expected := e2managererrors.NewRmrError()
 339         mbuf := rmrCgo.NewMBuf(tests.MessageType, tests.MaxMsgSize, "RanName", &tests.DummyPayload, &tests.DummyXAction)
 340         rmrMessengerMock.On("SendMsg", mock.AnythingOfType(fmt.Sprintf("%T", mbuf)), true).Return(mbuf, expected)
 341
 342         _, actual := handler.Handle(nil)
 343
 344         if reflect.TypeOf(actual) != reflect.TypeOf(expected) {
 345                 t.Errorf("Error actual = %v, and Expected = %v.", actual, expected)
 346         }
 347 }
 348
 349 func TestHandleGetListEnbIdsEmptyFlow(t *testing.T) {
 350         log, config, readerMock, _, rnibDataService, rmrMessengerMock := setupTest(t)
 351
 352         handler := NewDeleteAllRequestHandler(log, getRmrSender(rmrMessengerMock, log), config, rnibDataService)
 353
 354         var rnibError error
 355         nbIdentityList := []*entities.NbIdentity{}
 356
 357         readerMock.On("GetListNodebIds").Return(nbIdentityList, rnibError)
 358
 359         _, actual := handler.Handle(nil)
 360         readerMock.AssertNumberOfCalls(t, "GetNodeb", 0)
 361         assert.Nil(t, actual)
 362 }
 363
 364 func createIdentityList() []*entities.NbIdentity {
 365         nbIdentity1 := entities.NbIdentity{InventoryName: "RanName_1"}
 366         nbIdentity2 := entities.NbIdentity{InventoryName: "RanName_2"}
 367         nbIdentity3 := entities.NbIdentity{InventoryName: "RanName_3"}
 368
 369         var nbIdentityList []*entities.NbIdentity
 370         nbIdentityList = append(nbIdentityList, &nbIdentity1)
 371         nbIdentityList = append(nbIdentityList, &nbIdentity2)
 372         nbIdentityList = append(nbIdentityList, &nbIdentity3)
 373
 374         return nbIdentityList
 375 }
 376
 377 func initLog(t *testing.T) *logger.Logger {
 378         log, err := logger.InitLogger(logger.InfoLevel)
 379         if err != nil {
 380                 t.Errorf("#initLog test - failed to initialize logger, error: %s", err)
 381         }
 382         return log
 383 }
 384
 385 func getRmrSender(rmrMessengerMock *mocks.RmrMessengerMock, log *logger.Logger) *rmrsender.RmrSender {
 386         rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
 387         rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
 388         return rmrsender.NewRmrSender(log, rmrMessenger)
 389 }