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