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