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         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
  37         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
  38         "github.com/pkg/errors"
  39         "github.com/stretchr/testify/mock"
  40         "io/ioutil"
  41         "net/http"
  42         "testing"
  43 )
  44
  45 const e2tInitPayload = "{\"address\":\"10.0.2.15\", \"fqdn\":\"\"}"
  46
  47 func initRanLostConnectionTest(t *testing.T) (*logger.Logger, E2TermInitNotificationHandler, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.E2TInstancesManagerMock, *mocks.RoutingManagerClientMock) {
  48
  49         logger := initLog(t)
  50         config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3}
  51
  52         readerMock := &mocks.RnibReaderMock{}
  53
  54         writerMock := &mocks.RnibWriterMock{}
  55
  56         routingManagerClientMock := &mocks.RoutingManagerClientMock{}
  57
  58         rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock)
  59
  60         e2tInstancesManagerMock := &mocks.E2TInstancesManagerMock{}
  61         e2tAssociationManager := managers.NewE2TAssociationManager(logger, rnibDataService, e2tInstancesManagerMock, routingManagerClientMock)
  62
  63         ranDisconnectionManager := managers.NewRanDisconnectionManager(logger, configuration.ParseConfiguration(), rnibDataService, e2tAssociationManager)
  64         handler := NewE2TermInitNotificationHandler(logger, ranDisconnectionManager, e2tInstancesManagerMock, routingManagerClientMock)
  65
  66         return logger, handler, readerMock, writerMock, e2tInstancesManagerMock, routingManagerClientMock
  67 }
  68
  69 func initRanLostConnectionTestWithRealE2tInstanceManager(t *testing.T) (*logger.Logger, *configuration.Configuration, E2TermInitNotificationHandler, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.HttpClientMock) {
  70
  71         logger := initLog(t)
  72         config := configuration.ParseConfiguration()
  73
  74         readerMock := &mocks.RnibReaderMock{}
  75
  76         writerMock := &mocks.RnibWriterMock{}
  77         httpClientMock := &mocks.HttpClientMock{}
  78
  79         routingManagerClient := clients.NewRoutingManagerClient(logger, config, httpClientMock)
  80         rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock)
  81
  82         e2tInstancesManager := managers.NewE2TInstancesManager(rnibDataService, logger)
  83         e2tAssociationManager := managers.NewE2TAssociationManager(logger, rnibDataService, e2tInstancesManager, routingManagerClient)
  84         ranDisconnectionManager := managers.NewRanDisconnectionManager(logger, configuration.ParseConfiguration(), rnibDataService, e2tAssociationManager)
  85         handler := NewE2TermInitNotificationHandler(logger, ranDisconnectionManager, e2tInstancesManager, routingManagerClient)
  86         return logger, config, handler, readerMock, writerMock, httpClientMock
  87 }
  88
  89 func TestE2TermInitUnmarshalPayloadFailure(t *testing.T) {
  90         _, handler, _, _, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
  91         notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte("asd")}
  92         handler.Handle(notificationRequest)
  93         e2tInstancesManagerMock.AssertNotCalled(t, "GetE2TInstance")
  94         e2tInstancesManagerMock.AssertNotCalled(t, "AddE2TInstance")
  95 }
  96
  97 func TestE2TermInitEmptyE2TAddress(t *testing.T) {
  98         _, handler, _, _, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
  99         notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte("{\"address\":\"\"}")}
 100         handler.Handle(notificationRequest)
 101         e2tInstancesManagerMock.AssertNotCalled(t, "GetE2TInstance")
 102         e2tInstancesManagerMock.AssertNotCalled(t, "AddE2TInstance")
 103 }
 104
 105 func TestE2TermInitGetE2TInstanceFailure(t *testing.T) {
 106         _, handler, _, _, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
 107         var e2tInstance *entities.E2TInstance
 108         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, common.NewInternalError(fmt.Errorf("internal error")))
 109         notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
 110         handler.Handle(notificationRequest)
 111         e2tInstancesManagerMock.AssertNotCalled(t, "AddE2TInstance")
 112 }
 113
 114 func TestE2TermInitGetE2TInstanceDbFailure(t *testing.T) {
 115         _, _, handler, readerMock, writerMock, _ := initRanLostConnectionTestWithRealE2tInstanceManager(t)
 116         var e2tInstance *entities.E2TInstance
 117         readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, common.NewInternalError(fmt.Errorf("internal error")))
 118         notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
 119         handler.Handle(notificationRequest)
 120         writerMock.AssertNotCalled(t, "UpdateNodebInfo")
 121 }
 122
 123 func TestE2TermInitNewE2TInstance(t *testing.T) {
 124         _, config, handler, readerMock, writerMock, httpClientMock := initRanLostConnectionTestWithRealE2tInstanceManager(t)
 125         var e2tInstance *entities.E2TInstance
 126
 127         readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, common.NewResourceNotFoundError("not found"))
 128         writerMock.On("SaveE2TInstance", mock.Anything).Return(nil)
 129
 130         respBody := ioutil.NopCloser(bytes.NewBufferString(""))
 131         url := config.RoutingManager.BaseUrl + clients.AddE2TInstanceApiSuffix
 132         httpClientMock.On("Post", url, mock.Anything, mock.Anything).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil)
 133
 134         e2tAddresses := []string{}
 135         readerMock.On("GetE2TAddresses").Return(e2tAddresses, common.NewResourceNotFoundError(""))
 136
 137         e2tAddresses = append(e2tAddresses, e2tInstanceAddress)
 138         writerMock.On("SaveE2TAddresses", e2tAddresses).Return(nil)
 139
 140         notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
 141         handler.Handle(notificationRequest)
 142
 143         httpClientMock.AssertCalled(t, "Post", url, mock.Anything, mock.Anything)
 144         writerMock.AssertCalled(t, "SaveE2TInstance", mock.Anything)
 145         writerMock.AssertCalled(t, "SaveE2TAddresses", e2tAddresses)
 146 }
 147
 148 func TestE2TermInitNewE2TInstance__RoutingManagerError(t *testing.T) {
 149         _, config, handler, readerMock, writerMock, httpClientMock := initRanLostConnectionTestWithRealE2tInstanceManager(t)
 150
 151         var e2tInstance *entities.E2TInstance
 152
 153         readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, common.NewResourceNotFoundError("not found"))
 154
 155         url := config.RoutingManager.BaseUrl + clients.AddE2TInstanceApiSuffix
 156         httpClientMock.On("Post", url, mock.Anything, mock.Anything).Return(&http.Response{}, errors.New("error"))
 157
 158         notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
 159         handler.Handle(notificationRequest)
 160
 161         writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 0)
 162 }
 163
 164 func TestE2TermInitExistingE2TInstanceNoAssociatedRans(t *testing.T) {
 165         _, handler, _, _, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
 166         e2tInstance := entities.NewE2TInstance(e2tInstanceAddress)
 167         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil)
 168         notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
 169         handler.Handle(notificationRequest)
 170         e2tInstancesManagerMock.AssertCalled(t, "GetE2TInstance", e2tInstanceAddress)
 171 }
 172
 173 func TestE2TermInitHandlerSuccessOneRan(t *testing.T) {
 174         _, config, handler, readerMock, writerMock, httpClientMock := initRanLostConnectionTestWithRealE2tInstanceManager(t)
 175
 176         var rnibErr error
 177         var initialNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
 178         readerMock.On("GetNodeb", RanName).Return(initialNodeb, rnibErr)
 179
 180         var argNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
 181         writerMock.On("UpdateNodebInfo", argNodeb).Return(rnibErr)
 182
 183         var disconnectedNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
 184         readerMock.On("GetNodeb", RanName).Return(disconnectedNodeb, rnibErr)
 185
 186         var updatedNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: ""}
 187         writerMock.On("UpdateNodebInfo", updatedNodeb).Return(rnibErr)
 188
 189         e2tInstance := entities.NewE2TInstance(e2tInstanceAddress)
 190         e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
 191         readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil).Return(e2tInstance, nil)
 192         writerMock.On("SaveE2TInstance", mock.Anything).Return(nil)
 193
 194         respBody := ioutil.NopCloser(bytes.NewBufferString(""))
 195         url := config.RoutingManager.BaseUrl + clients.DissociateRanE2TInstanceApiSuffix
 196         httpClientMock.On("Post", url, mock.Anything, mock.Anything).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil)
 197
 198         notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
 199
 200         handler.Handle(notificationRequest)
 201
 202         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 2)
 203         writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 1)
 204         httpClientMock.AssertNumberOfCalls(t, "Post", 1)
 205 }
 206
 207 func TestE2TermInitHandlerSuccessOneRan_RoutingManagerError(t *testing.T) {
 208         _, config, handler, readerMock, writerMock, httpClientMock := initRanLostConnectionTestWithRealE2tInstanceManager(t)
 209
 210         var rnibErr error
 211         var initialNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
 212         readerMock.On("GetNodeb", RanName).Return(initialNodeb, rnibErr)
 213
 214         var argNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
 215         writerMock.On("UpdateNodebInfo", argNodeb).Return(rnibErr)
 216
 217         var disconnectedNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
 218         readerMock.On("GetNodeb", RanName).Return(disconnectedNodeb, rnibErr)
 219
 220         var updatedNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: ""}
 221         writerMock.On("UpdateNodebInfo", updatedNodeb).Return(rnibErr)
 222
 223         e2tInstance := entities.NewE2TInstance(e2tInstanceAddress)
 224         e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
 225         readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil).Return(e2tInstance, nil)
 226         writerMock.On("SaveE2TInstance", mock.Anything).Return(nil)
 227
 228         url := config.RoutingManager.BaseUrl + clients.DissociateRanE2TInstanceApiSuffix
 229         httpClientMock.On("Post", url, mock.Anything, mock.Anything).Return(&http.Response{}, errors.New("error"))
 230
 231         notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
 232
 233         handler.Handle(notificationRequest)
 234
 235         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 2)
 236         writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 1)
 237         httpClientMock.AssertNumberOfCalls(t, "Post", 1)
 238 }
 239
 240 func TestE2TermInitHandlerSuccessOneRanShuttingdown(t *testing.T) {
 241         _, _, handler, readerMock, writerMock, _ := initRanLostConnectionTestWithRealE2tInstanceManager(t)
 242         var rnibErr error
 243
 244         var initialNodeb = &entities.NodebInfo{RanName: RanName, ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
 245         readerMock.On("GetNodeb", RanName).Return(initialNodeb, rnibErr)
 246
 247         var argNodeb = &entities.NodebInfo{RanName: RanName, ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST, ConnectionAttempts: 0}
 248         writerMock.On("UpdateNodebInfo", argNodeb).Return(rnibErr)
 249
 250         e2tInstance := entities.NewE2TInstance(e2tInstanceAddress)
 251         e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
 252         readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil)
 253         notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
 254
 255         handler.Handle(notificationRequest)
 256
 257         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 1)
 258 }
 259
 260 func TestE2TermInitHandlerSuccessOneRan_ToBeDeleted(t *testing.T) {
 261         _, _, handler, readerMock, writerMock, httpClientMock := initRanLostConnectionTestWithRealE2tInstanceManager(t)
 262         var rnibErr error
 263
 264         var initialNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
 265         readerMock.On("GetNodeb", RanName).Return(initialNodeb, rnibErr)
 266
 267         var argNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTING, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST, ConnectionAttempts: 1}
 268         writerMock.On("UpdateNodebInfo", argNodeb).Return(rnibErr)
 269
 270         e2tInstance := entities.NewE2TInstance(e2tInstanceAddress)
 271         e2tInstance.State = entities.ToBeDeleted
 272         e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
 273
 274         readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil)
 275         notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
 276
 277         handler.Handle(notificationRequest)
 278
 279         httpClientMock.AssertNotCalled(t, "Post", mock.Anything, mock.Anything, mock.Anything)
 280         writerMock.AssertNotCalled(t, "UpdateNodebInfo")
 281 }
 282
 283 func TestE2TermInitHandlerSuccessTwoRans(t *testing.T) {
 284
 285         _, config, handler, readerMock, writerMock, httpClientMock := initRanLostConnectionTestWithRealE2tInstanceManager(t)
 286
 287         var rnibErr error
 288         test2 := "test2"
 289
 290         //First RAN
 291         var firstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
 292         var disconnectedFirstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
 293         readerMock.On("GetNodeb", RanName).Return(firstRan, rnibErr).Return(disconnectedFirstRan, rnibErr)
 294
 295         var updatedFirstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
 296         writerMock.On("UpdateNodebInfo", updatedFirstRan).Return(rnibErr)
 297
 298         var updatedDisconnectedFirstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: ""}
 299         writerMock.On("UpdateNodebInfo", updatedDisconnectedFirstRan).Return(rnibErr)
 300
 301         //Second RAN
 302         var secondRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, RanName: test2, AssociatedE2TInstanceAddress: "10.0.2.15"}
 303         var disconnectedSecondRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: test2, AssociatedE2TInstanceAddress: "10.0.2.15"}
 304         readerMock.On("GetNodeb", test2).Return(secondRan, rnibErr).Return(disconnectedSecondRan, rnibErr)
 305
 306         var updatedSecondRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: test2, AssociatedE2TInstanceAddress: "10.0.2.15"}
 307         writerMock.On("UpdateNodebInfo", updatedSecondRan).Return(rnibErr)
 308
 309         var updatedDisconnectedSecondRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: test2, AssociatedE2TInstanceAddress: ""}
 310         writerMock.On("UpdateNodebInfo", updatedDisconnectedSecondRan).Return(rnibErr)
 311
 312         e2tInstance := entities.NewE2TInstance(e2tInstanceAddress)
 313         e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
 314         e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, test2)
 315         readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil).Return(e2tInstance, nil)
 316         writerMock.On("SaveE2TInstance", mock.Anything).Return(nil)
 317
 318         respBody := ioutil.NopCloser(bytes.NewBufferString(""))
 319         url := config.RoutingManager.BaseUrl + clients.DissociateRanE2TInstanceApiSuffix
 320         httpClientMock.On("Post", url, mock.Anything, mock.Anything).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil)
 321
 322         notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
 323
 324         handler.Handle(notificationRequest)
 325
 326         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 4)
 327         writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 2)
 328         httpClientMock.AssertNumberOfCalls(t, "Post", 2)
 329 }
 330
 331 func TestE2TermInitHandlerSuccessTwoRansSecondRanShutdown(t *testing.T) {
 332         _, config, handler, readerMock, writerMock, httpClientMock := initRanLostConnectionTestWithRealE2tInstanceManager(t)
 333
 334         var rnibErr error
 335         test2 := "test2"
 336
 337         //First RAN
 338         var firstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
 339         var disconnectedFirstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
 340         readerMock.On("GetNodeb", RanName).Return(firstRan, rnibErr).Return(disconnectedFirstRan, rnibErr)
 341
 342         var updatedFirstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
 343         writerMock.On("UpdateNodebInfo", updatedFirstRan).Return(rnibErr)
 344
 345         var updatedDisconnectedFirstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: ""}
 346         writerMock.On("UpdateNodebInfo", updatedDisconnectedFirstRan).Return(rnibErr)
 347
 348         //Second RAN
 349         var secondRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN, RanName: test2, AssociatedE2TInstanceAddress: "10.0.2.15"}
 350         readerMock.On("GetNodeb", test2).Return(secondRan, rnibErr)
 351
 352         e2tInstance := entities.NewE2TInstance(e2tInstanceAddress)
 353         e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
 354         readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil).Return(e2tInstance, nil)
 355         writerMock.On("SaveE2TInstance", mock.Anything).Return(nil)
 356
 357         respBody := ioutil.NopCloser(bytes.NewBufferString(""))
 358         url := config.RoutingManager.BaseUrl + clients.DissociateRanE2TInstanceApiSuffix
 359         httpClientMock.On("Post", url, mock.Anything, mock.Anything).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil)
 360
 361         notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
 362
 363         handler.Handle(notificationRequest)
 364
 365         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 2)
 366         writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 1)
 367         httpClientMock.AssertNumberOfCalls(t, "Post", 1)
 368 }
 369
 370 func TestE2TermInitHandlerSuccessTwoRansFirstNotFoundFailure(t *testing.T) {
 371         _, config, handler, readerMock, writerMock, httpClientMock := initRanLostConnectionTestWithRealE2tInstanceManager(t)
 372
 373         var rnibErr error
 374         test2 := "test2"
 375
 376         //First RAN
 377         var firstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
 378         readerMock.On("GetNodeb", RanName).Return(firstRan, common.NewResourceNotFoundError("not found"))
 379
 380         //Second RAN
 381         var secondRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, RanName: test2, AssociatedE2TInstanceAddress: "10.0.2.15"}
 382         var disconnectedSecondRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: test2, AssociatedE2TInstanceAddress: "10.0.2.15"}
 383         readerMock.On("GetNodeb", test2).Return(secondRan, rnibErr).Return(disconnectedSecondRan, rnibErr)
 384
 385         var updatedSecondRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: test2, AssociatedE2TInstanceAddress: "10.0.2.15"}
 386         writerMock.On("UpdateNodebInfo", updatedSecondRan).Return(rnibErr)
 387
 388         var updatedDisconnectedSecondRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, RanName: test2, AssociatedE2TInstanceAddress: ""}
 389         writerMock.On("UpdateNodebInfo", updatedDisconnectedSecondRan).Return(rnibErr)
 390
 391         e2tInstance := entities.NewE2TInstance(e2tInstanceAddress)
 392         e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
 393         e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, test2)
 394         readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil).Return(e2tInstance, nil)
 395         writerMock.On("SaveE2TInstance", mock.Anything).Return(nil)
 396
 397         respBody := ioutil.NopCloser(bytes.NewBufferString(""))
 398         url := config.RoutingManager.BaseUrl + clients.DissociateRanE2TInstanceApiSuffix
 399         httpClientMock.On("Post", url, mock.Anything, mock.Anything).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil)
 400
 401         notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
 402
 403         handler.Handle(notificationRequest)
 404
 405         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 2)
 406         writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 1)
 407         httpClientMock.AssertNumberOfCalls(t, "Post", 1)
 408 }
 409
 410 func TestE2TermInitHandlerSuccessTwoRansFirstRnibInternalErrorFailure(t *testing.T) {
 411         _, _, handler, readerMock, writerMock, httpClientMock := initRanLostConnectionTestWithRealE2tInstanceManager(t)
 412
 413         test2 := "test2"
 414
 415         //First RAN
 416         var firstRan = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, RanName: RanName, AssociatedE2TInstanceAddress: "10.0.2.15"}
 417         readerMock.On("GetNodeb", RanName).Return(firstRan, common.NewInternalError(fmt.Errorf("internal error")))
 418
 419         e2tInstance := entities.NewE2TInstance(e2tInstanceAddress)
 420         e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
 421         e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, test2)
 422         readerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil).Return(e2tInstance, nil)
 423
 424         notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
 425
 426         handler.Handle(notificationRequest)
 427
 428         writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 0)
 429         writerMock.AssertNumberOfCalls(t, "SaveE2TInstance", 0)
 430         httpClientMock.AssertNumberOfCalls(t, "Post", 0)
 431 }
 432
 433 func TestE2TermInitHandlerSuccessZeroRans(t *testing.T) {
 434         _, handler, _, writerMock, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
 435
 436         e2tInstance := entities.NewE2TInstance(e2tInstanceAddress)
 437         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil)
 438         notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
 439
 440         handler.Handle(notificationRequest)
 441
 442         writerMock.AssertNotCalled(t, "UpdateNodebInfo")
 443 }
 444
 445 func TestE2TermInitHandlerFailureGetNodebInternalError(t *testing.T) {
 446         _, handler, readerMock, writerMock, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
 447
 448         var nodebInfo *entities.NodebInfo
 449         readerMock.On("GetNodeb", "test1").Return(nodebInfo, common.NewInternalError(fmt.Errorf("internal error")))
 450
 451         e2tInstance := entities.NewE2TInstance(e2tInstanceAddress)
 452         e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, "test1")
 453         e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil)
 454         notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
 455         handler.Handle(notificationRequest)
 456
 457         writerMock.AssertNotCalled(t, "UpdateNodebInfo")
 458 }
 459
 460 // TODO: extract to test_utils
 461 func initRmrSender(rmrMessengerMock *mocks.RmrMessengerMock, log *logger.Logger) *rmrsender.RmrSender {
 462         rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
 463         rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
 464         return rmrsender.NewRmrSender(log, rmrMessenger)
 465 }
 466
 467 // TODO: extract to test_utils
 468 func initLog(t *testing.T) *logger.Logger {
 469         log, err := logger.InitLogger(logger.InfoLevel)
 470         if err != nil {
 471                 t.Errorf("#delete_all_request_handler_test.TestHandleSuccessFlow - failed to initialize logger, error: %s", err)
 472         }
 473         return log
 474 }