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