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