E2Manager/handlers/rmrmsghandlers/e2_term_init_notification_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 //  This source code is part of the near-RT RIC (RAN Intelligent Controller)
  19 //  platform project (RICP).
  20
  21 package rmrmsghandlers
  22
  23 import (
  24         "bytes"
  25         "e2mgr/clients"
  26         "e2mgr/configuration"
  27         "e2mgr/logger"
  28         "e2mgr/managers"
  29         "e2mgr/mocks"
  30         "e2mgr/models"
  31         "e2mgr/rmrCgo"
  32         "e2mgr/services"
  33         "e2mgr/services/rmrsender"
  34         "e2mgr/tests"
  35         "fmt"
  36         "io/ioutil"
  37         "net/http"
  38         "testing"
  39         "time"
  40
  41         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
  42         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
  43         "github.com/pkg/errors"
  44         "github.com/stretchr/testify/mock"
  45 )
  46
  47 const (
  48         e2tInitPayload     = "{\"address\":\"10.0.2.15\", \"fqdn\":\"\"}"
  49         e2tInstanceAddress = "10.0.2.15"
  50         podName            = "podNAme_test"
  51 )
  52
  53 func initRanLostConnectionTest(t *testing.T) (*logger.Logger, E2TermInitNotificationHandler, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.E2TInstancesManagerMock, *mocks.RoutingManagerClientMock) {
  54
  55         logger := initLog(t)
  56         config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3}
  57
  58         readerMock := &mocks.RnibReaderMock{}
  59
  60         writerMock := &mocks.RnibWriterMock{}
  61
  62         routingManagerClientMock := &mocks.RoutingManagerClientMock{}
  63
  64         rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock)
  65
  66         e2tInstancesManagerMock := &mocks.E2TInstancesManagerMock{}
  67
  68         ranListManager := managers.NewRanListManager(logger, rnibDataService)
  69         ranAlarmService := &mocks.RanAlarmServiceMock{}
  70         ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(logger, rnibDataService, ranListManager, ranAlarmService)
  71         e2tAssociationManager := managers.NewE2TAssociationManager(logger, rnibDataService, e2tInstancesManagerMock, routingManagerClientMock, ranConnectStatusChangeManager)
  72
  73         ranDisconnectionManager := managers.NewRanDisconnectionManager(logger, configuration.ParseConfiguration(), rnibDataService, e2tAssociationManager, ranConnectStatusChangeManager)
  74         handler := NewE2TermInitNotificationHandler(logger, ranDisconnectionManager, e2tInstancesManagerMock, routingManagerClientMock)
  75
  76         return logger, handler, readerMock, writerMock, e2tInstancesManagerMock, routingManagerClientMock
  77 }
  78
  79 func initRanLostConnectionTestWithRealE2tInstanceManager(t *testing.T) (*logger.Logger, *configuration.Configuration, E2TermInitNotificationHandler, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.HttpClientMock, managers.RanListManager) {
  80
  81         logger := initLog(t)
  82         config := configuration.ParseConfiguration()
  83
  84         readerMock := &mocks.RnibReaderMock{}
  85
  86         writerMock := &mocks.RnibWriterMock{}
  87         httpClientMock := &mocks.HttpClientMock{}
  88
  89         routingManagerClient := clients.NewRoutingManagerClient(logger, config, httpClientMock)
  90         rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock)
  91
  92         e2tInstancesManager := managers.NewE2TInstancesManager(rnibDataService, logger)
  93         ranListManager := managers.NewRanListManager(logger, rnibDataService)
  94         ranAlarmService := services.NewRanAlarmService(logger, config)
  95         ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(logger, rnibDataService, ranListManager, ranAlarmService)
  96         e2tAssociationManager := managers.NewE2TAssociationManager(logger, rnibDataService, e2tInstancesManager, routingManagerClient, ranConnectStatusChangeManager)
  97         ranDisconnectionManager := managers.NewRanDisconnectionManager(logger, configuration.ParseConfiguration(), rnibDataService, e2tAssociationManager, ranConnectStatusChangeManager)
  98         handler := NewE2TermInitNotificationHandler(logger, ranDisconnectionManager, e2tInstancesManager, routingManagerClient)
  99         return logger, config, handler, readerMock, writerMock, httpClientMock, ranListManager
 100 }
 101
 102 func TestE2TermInitUnmarshalPayloadFailure(t *testing.T) {
 103         _, handler, _, _, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
 104         notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte("asd")}
 105         handler.Handle(notificationRequest)
 106         e2tInstancesManagerMock.AssertNotCalled(t, "GetE2TInstance")
 107         e2tInstancesManagerMock.AssertNotCalled(t, "AddE2TInstance")
 108 }
 109
 110 func TestE2TermInitEmptyE2TAddress(t *testing.T) {
 111         _, handler, _, _, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
 112         notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte("{\"address\":\"\"}")}
 113         handler.Handle(notificationRequest)
 114         e2tInstancesManagerMock.AssertNotCalled(t, "GetE2TInstance")
 115         e2tInstancesManagerMock.AssertNotCalled(t, "AddE2TInstance")
 116 }
 117
 118 func TestE2TermInitGetE2TInstanceFailure(t *testing.T) {
 119         _, handler, _, _, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
 120         var e2tInstance *entities.E2TInstance
 121         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, common.NewInternalError(fmt.Errorf("internal error")))
 122         notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
 123         handler.Handle(notificationRequest)
 124         e2tInstancesManagerMock.AssertNotCalled(t, "AddE2TInstance")
 125 }
 126
 127 func TestE2TermInitGetE2TInstanceDbFailure(t *testing.T) {
 128         _, _, handler, readerMock, writerMock, _, _ := initRanLostConnectionTestWithRealE2tInstanceManager(t)
 129         var e2tInstance *entities.E2TInstance
 130         readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, common.NewInternalError(fmt.Errorf("internal error")))
 131         notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
 132         handler.Handle(notificationRequest)
 133         writerMock.AssertNotCalled(t, "UpdateNodebInfo")
 134 }
 135
 136 func TestE2TermInitNewE2TInstance(t *testing.T) {
 137         _, config, handler, readerMock, writerMock, httpClientMock, _ := initRanLostConnectionTestWithRealE2tInstanceManager(t)
 138         var e2tInstance *entities.E2TInstance
 139
 140         readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, common.NewResourceNotFoundError("not found"))
 141         writerMock.On("SaveE2TInstance", mock.Anything).Return(nil)
 142
 143         respBody := ioutil.NopCloser(bytes.NewBufferString(""))
 144         url := config.RoutingManager.BaseUrl + clients.AddE2TInstanceApiSuffix
 145         httpClientMock.On("Post", url, mock.Anything, mock.Anything).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil)
 146
 147         var e2tAddresses []string
 148         readerMock.On("GetE2TAddresses").Return(e2tAddresses, common.NewResourceNotFoundError(""))
 149
 150         e2tAddresses = append(e2tAddresses, e2tInstanceAddress)
 151         writerMock.On("SaveE2TAddresses", e2tAddresses).Return(nil)
 152
 153         notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
 154         handler.Handle(notificationRequest)
 155
 156         httpClientMock.AssertCalled(t, "Post", url, mock.Anything, mock.Anything)
 157         writerMock.AssertCalled(t, "SaveE2TInstance", mock.Anything)
 158         writerMock.AssertCalled(t, "SaveE2TAddresses", e2tAddresses)
 159 }
 160
 161 func TestE2TermInitNewE2TInstance__RoutingManagerError(t *testing.T) {
 162         _, config, handler, readerMock, writerMock, httpClientMock, _ := initRanLostConnectionTestWithRealE2tInstanceManager(t)
 163
 164         var e2tInstance *entities.E2TInstance
 165
 166         readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, common.NewResourceNotFoundError("not found"))
 167
 168         url := config.RoutingManager.BaseUrl + clients.AddE2TInstanceApiSuffix
 169         httpClientMock.On("Post", url, mock.Anything, mock.Anything).Return(&http.Response{}, errors.New("error"))
 170
 171         notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
 172         handler.Handle(notificationRequest)
 173
 174         writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 0)
 175 }
 176
 177 func TestE2TermInitExistingE2TInstanceNoAssociatedRans(t *testing.T) {
 178         _, handler, _, _, e2tInstancesManagerMock, routingManagerClientMock := initRanLostConnectionTest(t)
 179         e2tInstance := entities.NewE2TInstance(e2tInstanceAddress, podName)
 180         var rtmgrErr error
 181         e2tInstancesManagerMock.On("ResetKeepAliveTimestamp", e2tInstanceAddress).Return(nil)
 182         routingManagerClientMock.On("AddE2TInstance", e2tInstanceAddress).Return(rtmgrErr, nil)
 183         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil)
 184         notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
 185         handler.Handle(notificationRequest)
 186         e2tInstancesManagerMock.AssertCalled(t, "GetE2TInstance", e2tInstanceAddress)
 187 }
 188
 189 func TestE2TermInitHandlerSuccessOneRan(t *testing.T) {
 190         _, config, handler, readerMock, writerMock, httpClientMock, ranListManager := initRanLostConnectionTestWithRealE2tInstanceManager(t)
 191
 192         oldNbIdentity := &entities.NbIdentity{InventoryName: RanName, ConnectionStatus: entities.ConnectionStatus_CONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
 193         readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{oldNbIdentity}, nil)
 194         err := ranListManager.InitNbIdentityMap()
 195         if err != nil {
 196                 t.Errorf("Error cannot init identity")
 197         }
 198
 199         var rnibErr error
 200         var initialNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
 201         readerMock.On("GetNodeb", RanName).Return(initialNodeb, rnibErr)
 202
 203         var argNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
 204         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", mock.Anything, "test_DISCONNECTED").Return(nil)
 205
 206         newNbIdentity := &entities.NbIdentity{InventoryName: RanName, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
 207         writerMock.On("UpdateNbIdentities", argNodeb.GetNodeType(), []*entities.NbIdentity{oldNbIdentity}, []*entities.NbIdentity{newNbIdentity}).Return(nil)
 208
 209         var disconnectedNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
 210         readerMock.On("GetNodeb", RanName).Return(disconnectedNodeb, rnibErr)
 211
 212         var updatedNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: ""}
 213         updatedNodeb.StatusUpdateTimeStamp = uint64(time.Now().UnixNano())
 214         writerMock.On("UpdateNodebInfo", mock.Anything).Return(rnibErr)
 215
 216         e2tInstance := entities.NewE2TInstance(e2tInstanceAddress, podName)
 217         e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
 218         readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil).Return(e2tInstance, nil)
 219         writerMock.On("SaveE2TInstance", mock.Anything).Return(nil)
 220
 221         respBody := ioutil.NopCloser(bytes.NewBufferString(""))
 222         url := config.RoutingManager.BaseUrl + clients.DissociateRanE2TInstanceApiSuffix
 223         httpClientMock.On("Post", url, mock.Anything, mock.Anything).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil)
 224
 225         notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
 226
 227         handler.Handle(notificationRequest)
 228
 229         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 1)
 230         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfoOnConnectionStatusInversion", 1)
 231         writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 1)
 232         httpClientMock.AssertNumberOfCalls(t, "Post", 1)
 233 }
 234
 235 func TestE2TermInitHandlerSuccessOneRan_RoutingManagerError(t *testing.T) {
 236         _, config, handler, readerMock, writerMock, httpClientMock, ranListManager := initRanLostConnectionTestWithRealE2tInstanceManager(t)
 237
 238         oldNbIdentity := &entities.NbIdentity{InventoryName: RanName, ConnectionStatus: entities.ConnectionStatus_CONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
 239         readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{oldNbIdentity}, nil)
 240         err := ranListManager.InitNbIdentityMap()
 241         if err != nil {
 242                 t.Errorf("Error cannot init identity")
 243         }
 244         var rnibErr error
 245         var initialNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
 246         readerMock.On("GetNodeb", RanName).Return(initialNodeb, rnibErr)
 247
 248         var argNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
 249         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", mock.Anything, "test_DISCONNECTED").Return(nil)
 250
 251         newNbIdentity := &entities.NbIdentity{InventoryName: RanName, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
 252         writerMock.On("UpdateNbIdentities", argNodeb.GetNodeType(), []*entities.NbIdentity{oldNbIdentity}, []*entities.NbIdentity{newNbIdentity}).Return(nil)
 253
 254         var disconnectedNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
 255         readerMock.On("GetNodeb", RanName).Return(disconnectedNodeb, rnibErr)
 256
 257         var updatedNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: ""}
 258         updatedNodeb.StatusUpdateTimeStamp = uint64(time.Now().UnixNano())
 259         writerMock.On("UpdateNodebInfo", mock.Anything).Return(rnibErr)
 260
 261         e2tInstance := entities.NewE2TInstance(e2tInstanceAddress, podName)
 262         e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
 263         readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil).Return(e2tInstance, nil)
 264         writerMock.On("SaveE2TInstance", mock.Anything).Return(nil)
 265
 266         url := config.RoutingManager.BaseUrl + clients.DissociateRanE2TInstanceApiSuffix
 267         httpClientMock.On("Post", url, mock.Anything, mock.Anything).Return(&http.Response{}, errors.New("error"))
 268
 269         notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
 270
 271         handler.Handle(notificationRequest)
 272
 273         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 1)
 274         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfoOnConnectionStatusInversion", 1)
 275         writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 1)
 276         httpClientMock.AssertNumberOfCalls(t, "Post", 1)
 277 }
 278
 279 func TestE2TermInitHandlerSuccessOneRanShuttingdown(t *testing.T) {
 280         _, _, handler, readerMock, writerMock, _, ranListManager := initRanLostConnectionTestWithRealE2tInstanceManager(t)
 281         var rnibErr error
 282
 283         oldNbIdentity := &entities.NbIdentity{InventoryName: RanName, ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
 284         readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{oldNbIdentity}, nil)
 285         err := ranListManager.InitNbIdentityMap()
 286         if err != nil {
 287                 t.Errorf("Error cannot init identity")
 288         }
 289         var initialNodeb = &entities.NodebInfo{RanName: RanName, ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
 290         readerMock.On("GetNodeb", RanName).Return(initialNodeb, rnibErr)
 291
 292         var argNodeb = &entities.NodebInfo{RanName: RanName, ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
 293         writerMock.On("UpdateNodebInfo", mock.Anything).Return(rnibErr)
 294
 295         newNbIdentity := &entities.NbIdentity{InventoryName: RanName, ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
 296         writerMock.On("UpdateNbIdentities", argNodeb.GetNodeType(), []*entities.NbIdentity{oldNbIdentity}, []*entities.NbIdentity{newNbIdentity}).Return(nil)
 297
 298         e2tInstance := entities.NewE2TInstance(e2tInstanceAddress, podName)
 299         e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
 300         readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil)
 301         notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
 302
 303         handler.Handle(notificationRequest)
 304
 305         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 1)
 306 }
 307
 308 func TestE2TermInitHandlerSuccessOneRan_ToBeDeleted(t *testing.T) {
 309         _, _, handler, readerMock, writerMock, httpClientMock, _ := initRanLostConnectionTestWithRealE2tInstanceManager(t)
 310         var rnibErr error
 311
 312         var initialNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
 313         readerMock.On("GetNodeb", RanName).Return(initialNodeb, rnibErr)
 314
 315         var argNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTING, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
 316         argNodeb.StatusUpdateTimeStamp = uint64(time.Now().UnixNano())
 317         writerMock.On("UpdateNodebInfo", mock.Anything).Return(rnibErr)
 318
 319         e2tInstance := entities.NewE2TInstance(e2tInstanceAddress, podName)
 320         e2tInstance.State = entities.ToBeDeleted
 321         e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
 322
 323         readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil)
 324         notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
 325
 326         handler.Handle(notificationRequest)
 327
 328         httpClientMock.AssertNotCalled(t, "Post", mock.Anything, mock.Anything, mock.Anything)
 329         writerMock.AssertNotCalled(t, "UpdateNodebInfo")
 330 }
 331
 332 func TestE2TermInitHandlerSuccessTwoRans(t *testing.T) {
 333
 334         _, config, handler, readerMock, writerMock, httpClientMock, ranListManager := initRanLostConnectionTestWithRealE2tInstanceManager(t)
 335         test2 := "test2"
 336         oldNbIdentity1 := &entities.NbIdentity{InventoryName: RanName, ConnectionStatus: entities.ConnectionStatus_CONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
 337         oldNbIdentity2 := &entities.NbIdentity{InventoryName: test2, ConnectionStatus: entities.ConnectionStatus_CONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId2", NbId: "nbId2"}}
 338         oldNbIdentityList := []*entities.NbIdentity{oldNbIdentity1, oldNbIdentity2}
 339         readerMock.On("GetListNodebIds").Return(oldNbIdentityList, nil)
 340
 341         err := ranListManager.InitNbIdentityMap()
 342         if err != nil {
 343                 t.Errorf("Error cannot init identity")
 344         }
 345         var rnibErr error
 346
 347         //First RAN
 348         var firstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
 349         var disconnectedFirstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
 350         readerMock.On("GetNodeb", RanName).Return(firstRan, rnibErr).Return(disconnectedFirstRan, rnibErr)
 351
 352         var updatedFirstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
 353         writerMock.On("UpdateNodebInfo", mock.Anything).Return(rnibErr)
 354         newNbIdentity := &entities.NbIdentity{InventoryName: RanName, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
 355         writerMock.On("UpdateNbIdentities", updatedFirstRan.GetNodeType(), []*entities.NbIdentity{oldNbIdentity1}, []*entities.NbIdentity{newNbIdentity}).Return(nil)
 356
 357         var updatedDisconnectedFirstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: ""}
 358         updatedDisconnectedFirstRan.StatusUpdateTimeStamp = uint64(time.Now().UnixNano())
 359         writerMock.On("UpdateNodebInfo", mock.Anything).Return(rnibErr)
 360
 361         //Second RAN
 362         var secondRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, RanName: test2, AssociatedE2TInstanceAddress: "10.0.2.15"}
 363         var disconnectedSecondRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: test2, AssociatedE2TInstanceAddress: "10.0.2.15"}
 364         readerMock.On("GetNodeb", test2).Return(secondRan, rnibErr).Return(disconnectedSecondRan, rnibErr)
 365
 366         var updatedSecondRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: test2, AssociatedE2TInstanceAddress: "10.0.2.15"}
 367         updatedSecondRan.StatusUpdateTimeStamp = uint64(time.Now().UnixNano())
 368         writerMock.On("UpdateNodebInfo", mock.Anything).Return(rnibErr)
 369         newNbIdentity2 := &entities.NbIdentity{InventoryName: test2, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId2", NbId: "nbId2"}}
 370         writerMock.On("UpdateNbIdentities", updatedFirstRan.GetNodeType(), []*entities.NbIdentity{oldNbIdentity2}, []*entities.NbIdentity{newNbIdentity2}).Return(nil)
 371
 372         var updatedDisconnectedSecondRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: test2, AssociatedE2TInstanceAddress: ""}
 373         updatedDisconnectedSecondRan.StatusUpdateTimeStamp = uint64(time.Now().UnixNano())
 374         writerMock.On("UpdateNodebInfo", mock.Anything).Return(rnibErr)
 375
 376         e2tInstance := entities.NewE2TInstance(e2tInstanceAddress, podName)
 377         e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
 378         e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, test2)
 379         readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil).Return(e2tInstance, nil)
 380         writerMock.On("SaveE2TInstance", mock.Anything).Return(nil)
 381
 382         respBody := ioutil.NopCloser(bytes.NewBufferString(""))
 383         url := config.RoutingManager.BaseUrl + clients.DissociateRanE2TInstanceApiSuffix
 384         httpClientMock.On("Post", url, mock.Anything, mock.Anything).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil)
 385
 386         notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
 387
 388         handler.Handle(notificationRequest)
 389
 390         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 4)
 391         writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 2)
 392         httpClientMock.AssertNumberOfCalls(t, "Post", 2)
 393 }
 394
 395 func TestE2TermInitHandlerSuccessTwoRansSecondRanShutdown(t *testing.T) {
 396         _, config, handler, readerMock, writerMock, httpClientMock, ranListManager := initRanLostConnectionTestWithRealE2tInstanceManager(t)
 397
 398         oldNbIdentity := &entities.NbIdentity{InventoryName: RanName, ConnectionStatus: entities.ConnectionStatus_CONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
 399         readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{oldNbIdentity}, nil)
 400         err := ranListManager.InitNbIdentityMap()
 401         if err != nil {
 402                 t.Errorf("Error cannot init identity")
 403         }
 404         var rnibErr error
 405         test2 := "test2"
 406
 407         //First RAN
 408         var firstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
 409         var disconnectedFirstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
 410         readerMock.On("GetNodeb", RanName).Return(firstRan, rnibErr).Return(disconnectedFirstRan, rnibErr)
 411
 412         var updatedFirstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
 413         writerMock.On("UpdateNodebInfo", mock.Anything).Return(rnibErr)
 414         newNbIdentity := &entities.NbIdentity{InventoryName: RanName, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
 415         writerMock.On("UpdateNbIdentities", updatedFirstRan.GetNodeType(), []*entities.NbIdentity{oldNbIdentity}, []*entities.NbIdentity{newNbIdentity}).Return(nil)
 416
 417         var updatedDisconnectedFirstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: ""}
 418         updatedDisconnectedFirstRan.StatusUpdateTimeStamp = uint64(time.Now().UnixNano())
 419         writerMock.On("UpdateNodebInfo", mock.Anything).Return(rnibErr)
 420
 421         //Second RAN
 422         var secondRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN, RanName: test2, AssociatedE2TInstanceAddress: "10.0.2.15"}
 423         readerMock.On("GetNodeb", test2).Return(secondRan, rnibErr)
 424
 425         e2tInstance := entities.NewE2TInstance(e2tInstanceAddress, podName)
 426         e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
 427         readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil).Return(e2tInstance, nil)
 428         writerMock.On("SaveE2TInstance", mock.Anything).Return(nil)
 429
 430         respBody := ioutil.NopCloser(bytes.NewBufferString(""))
 431         url := config.RoutingManager.BaseUrl + clients.DissociateRanE2TInstanceApiSuffix
 432         httpClientMock.On("Post", url, mock.Anything, mock.Anything).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil)
 433
 434         notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
 435
 436         handler.Handle(notificationRequest)
 437
 438         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 2)
 439         writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 1)
 440         httpClientMock.AssertNumberOfCalls(t, "Post", 1)
 441 }
 442
 443 func TestE2TermInitHandlerSuccessTwoRansFirstNotFoundFailure(t *testing.T) {
 444         _, config, handler, readerMock, writerMock, httpClientMock, ranListManager := initRanLostConnectionTestWithRealE2tInstanceManager(t)
 445
 446         test2 := "test2"
 447         oldNbIdentity := &entities.NbIdentity{InventoryName: test2, ConnectionStatus: entities.ConnectionStatus_CONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
 448         readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{oldNbIdentity}, nil)
 449         err := ranListManager.InitNbIdentityMap()
 450         if err != nil {
 451                 t.Errorf("Error cannot init identity")
 452         }
 453         var rnibErr error
 454
 455         //First RAN
 456         var firstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
 457         readerMock.On("GetNodeb", RanName).Return(firstRan, common.NewResourceNotFoundError("not found"))
 458
 459         //Second RAN
 460         var secondRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, RanName: test2, AssociatedE2TInstanceAddress: "10.0.2.15"}
 461         var disconnectedSecondRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: test2, AssociatedE2TInstanceAddress: "10.0.2.15"}
 462         readerMock.On("GetNodeb", test2).Return(secondRan, rnibErr).Return(disconnectedSecondRan, rnibErr)
 463
 464         var updatedSecondRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: test2, AssociatedE2TInstanceAddress: "10.0.2.15"}
 465         writerMock.On("UpdateNodebInfo", mock.Anything).Return(rnibErr)
 466
 467         var updatedDisconnectedSecondRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: test2, AssociatedE2TInstanceAddress: ""}
 468         updatedDisconnectedSecondRan.StatusUpdateTimeStamp = uint64(time.Now().UnixNano())
 469         writerMock.On("UpdateNodebInfo", mock.Anything).Return(rnibErr)
 470
 471         newNbIdentity := &entities.NbIdentity{InventoryName: test2, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
 472         writerMock.On("UpdateNbIdentities", updatedSecondRan.GetNodeType(), []*entities.NbIdentity{oldNbIdentity}, []*entities.NbIdentity{newNbIdentity}).Return(nil)
 473
 474         e2tInstance := entities.NewE2TInstance(e2tInstanceAddress, podName)
 475         e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
 476         e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, test2)
 477         readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil).Return(e2tInstance, nil)
 478         writerMock.On("SaveE2TInstance", mock.Anything).Return(nil)
 479
 480         respBody := ioutil.NopCloser(bytes.NewBufferString(""))
 481         url := config.RoutingManager.BaseUrl + clients.DissociateRanE2TInstanceApiSuffix
 482         httpClientMock.On("Post", url, mock.Anything, mock.Anything).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil)
 483
 484         notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
 485
 486         handler.Handle(notificationRequest)
 487
 488         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 2)
 489         writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 1)
 490         httpClientMock.AssertNumberOfCalls(t, "Post", 1)
 491 }
 492
 493 func TestE2TermInitHandlerSuccessTwoRansFirstRnibInternalErrorFailure(t *testing.T) {
 494         _, _, handler, readerMock, writerMock, httpClientMock, _ := initRanLostConnectionTestWithRealE2tInstanceManager(t)
 495
 496         test2 := "test2"
 497
 498         //First RAN
 499         var firstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
 500         readerMock.On("GetNodeb", RanName).Return(firstRan, common.NewInternalError(fmt.Errorf("internal error")))
 501
 502         e2tInstance := entities.NewE2TInstance(e2tInstanceAddress, podName)
 503         e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
 504         e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, test2)
 505         readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil).Return(e2tInstance, nil)
 506
 507         notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
 508
 509         handler.Handle(notificationRequest)
 510
 511         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 0)
 512         writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 0)
 513         httpClientMock.AssertNumberOfCalls(t, "Post", 0)
 514 }
 515
 516 func TestE2TermInitHandlerSuccessZeroRans(t *testing.T) {
 517         _, handler, _, writerMock, e2tInstancesManagerMock, routingManagerClientMock := initRanLostConnectionTest(t)
 518
 519         e2tInstance := entities.NewE2TInstance(e2tInstanceAddress, podName)
 520         var rtmgrErr error
 521         e2tInstancesManagerMock.On("ResetKeepAliveTimestamp", e2tInstanceAddress).Return(nil)
 522         routingManagerClientMock.On("AddE2TInstance", e2tInstanceAddress).Return(rtmgrErr, nil)
 523         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil)
 524         notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
 525
 526         handler.Handle(notificationRequest)
 527
 528         writerMock.AssertNotCalled(t, "UpdateNodebInfo")
 529 }
 530
 531 func TestE2TermInitHandlerFailureGetNodebInternalError(t *testing.T) {
 532         _, handler, readerMock, writerMock, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
 533
 534         var nodebInfo *entities.NodebInfo
 535         readerMock.On("GetNodeb", "test1").Return(nodebInfo, common.NewInternalError(fmt.Errorf("internal error")))
 536
 537         e2tInstance := entities.NewE2TInstance(e2tInstanceAddress, podName)
 538         e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, "test1")
 539         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil)
 540         notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
 541         handler.Handle(notificationRequest)
 542
 543         writerMock.AssertNotCalled(t, "UpdateNodebInfo")
 544 }
 545
 546 func TestE2TermInitHandlerOneRanNoRanInNbIdentityMap(t *testing.T) {
 547         _, config, handler, readerMock, writerMock, httpClientMock, _ := initRanLostConnectionTestWithRealE2tInstanceManager(t)
 548
 549         var rnibErr error
 550         var initialNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
 551         readerMock.On("GetNodeb", RanName).Return(initialNodeb, rnibErr)
 552
 553         var argNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
 554         argNodeb.StatusUpdateTimeStamp = uint64(time.Now().UnixNano())
 555         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", mock.Anything, "test_DISCONNECTED").Return(nil)
 556
 557         var disconnectedNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
 558         readerMock.On("GetNodeb", RanName).Return(disconnectedNodeb, rnibErr)
 559
 560         var updatedNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: ""}
 561         updatedNodeb.StatusUpdateTimeStamp = uint64(time.Now().UnixNano())
 562         writerMock.On("UpdateNodebInfo", mock.Anything).Return(rnibErr)
 563
 564         e2tInstance := entities.NewE2TInstance(e2tInstanceAddress, podName)
 565         e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
 566         readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil).Return(e2tInstance, nil)
 567         writerMock.On("SaveE2TInstance", mock.Anything).Return(nil)
 568
 569         respBody := ioutil.NopCloser(bytes.NewBufferString(""))
 570         url := config.RoutingManager.BaseUrl + clients.DissociateRanE2TInstanceApiSuffix
 571         httpClientMock.On("Post", url, mock.Anything, mock.Anything).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil)
 572
 573         notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
 574
 575         handler.Handle(notificationRequest)
 576
 577         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 1)
 578         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfoOnConnectionStatusInversion", 1)
 579         writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 1)
 580         httpClientMock.AssertNumberOfCalls(t, "Post", 1)
 581 }
 582
 583 func TestE2TermInitHandlerOneRanUpdateNbIdentitiesFailure(t *testing.T) {
 584         _, config, handler, readerMock, writerMock, httpClientMock, ranListManager := initRanLostConnectionTestWithRealE2tInstanceManager(t)
 585
 586         oldNbIdentity := &entities.NbIdentity{InventoryName: RanName, ConnectionStatus: entities.ConnectionStatus_CONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
 587         readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{oldNbIdentity}, nil)
 588         err := ranListManager.InitNbIdentityMap()
 589         if err != nil {
 590                 t.Errorf("Error cannot init identity")
 591         }
 592
 593         var rnibErr error
 594         var initialNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
 595         readerMock.On("GetNodeb", RanName).Return(initialNodeb, rnibErr)
 596
 597         var argNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
 598         writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", mock.Anything, "test_DISCONNECTED").Return(nil)
 599
 600         newNbIdentity := &entities.NbIdentity{InventoryName: RanName, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
 601         writerMock.On("UpdateNbIdentities", argNodeb.GetNodeType(), []*entities.NbIdentity{oldNbIdentity}, []*entities.NbIdentity{newNbIdentity}).Return(common.NewInternalError(fmt.Errorf("internal error")))
 602
 603         var disconnectedNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
 604         readerMock.On("GetNodeb", RanName).Return(disconnectedNodeb, rnibErr)
 605
 606         var updatedNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: ""}
 607         updatedNodeb.StatusUpdateTimeStamp = uint64(time.Now().UnixNano())
 608         writerMock.On("UpdateNodebInfo", mock.Anything).Return(rnibErr)
 609
 610         e2tInstance := entities.NewE2TInstance(e2tInstanceAddress, podName)
 611         e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
 612         readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil).Return(e2tInstance, nil)
 613         writerMock.On("SaveE2TInstance", mock.Anything).Return(nil)
 614
 615         respBody := ioutil.NopCloser(bytes.NewBufferString(""))
 616         url := config.RoutingManager.BaseUrl + clients.DissociateRanE2TInstanceApiSuffix
 617         httpClientMock.On("Post", url, mock.Anything, mock.Anything).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil)
 618
 619         notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
 620
 621         handler.Handle(notificationRequest)
 622
 623         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 1)
 624         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfoOnConnectionStatusInversion", 1)
 625         writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 1)
 626         httpClientMock.AssertNumberOfCalls(t, "Post", 1)
 627 }
 628
 629 // TODO: extract to test_utils
 630 func initRmrSender(rmrMessengerMock *mocks.RmrMessengerMock, log *logger.Logger) *rmrsender.RmrSender {
 631         rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
 632         rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
 633         return rmrsender.NewRmrSender(log, rmrMessenger)
 634 }
 635
 636 // TODO: extract to test_utils
 637 func initLog(t *testing.T) *logger.Logger {
 638         log, err := logger.InitLogger(logger.InfoLevel)
 639         if err != nil {
 640                 t.Errorf("#delete_all_request_handler_test.TestHandleSuccessFlow - failed to initialize logger, error: %s", err)
 641         }
 642         return log
 643 }