E2Manager/controllers/nodeb_controller_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 //  This source code is part of the near-RT RIC (RAN Intelligent Controller)
  18 //  platform project (RICP).
  19
  20 package controllers
  21
  22 import (
  23         "bytes"
  24         "e2mgr/clients"
  25         "e2mgr/configuration"
  26         "e2mgr/e2managererrors"
  27         "e2mgr/logger"
  28         "e2mgr/managers"
  29         "e2mgr/mocks"
  30         "e2mgr/models"
  31         "e2mgr/providers/httpmsghandlerprovider"
  32         "e2mgr/rmrCgo"
  33         "e2mgr/services"
  34         "e2mgr/services/rmrsender"
  35         "e2mgr/tests"
  36         "encoding/json"
  37         "fmt"
  38         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
  39         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
  40         "github.com/golang/protobuf/jsonpb"
  41         "github.com/gorilla/mux"
  42         "github.com/pkg/errors"
  43         "github.com/stretchr/testify/assert"
  44         "github.com/stretchr/testify/mock"
  45         "io"
  46         "io/ioutil"
  47         "net/http"
  48         "net/http/httptest"
  49         "strings"
  50         "testing"
  51         "unsafe"
  52 )
  53
  54 const (
  55         RanName                      = "test"
  56         AssociatedE2TInstanceAddress = "10.0.2.15:38000"
  57         CorruptedJson                = "{\"errorCode\":401,\"errorMessage\":\"corrupted json\"}"
  58         ValidationFailureJson        = "{\"errorCode\":402,\"errorMessage\":\"Validation error\"}"
  59         ResourceNotFoundJson         = "{\"errorCode\":404,\"errorMessage\":\"Resource not found\"}"
  60         NodebExistsJson              = "{\"errorCode\":406,\"errorMessage\":\"Nodeb already exists\"}"
  61         RnibErrorJson                = "{\"errorCode\":500,\"errorMessage\":\"RNIB error\"}"
  62         InternalErrorJson            = "{\"errorCode\":501,\"errorMessage\":\"Internal Server Error. Please try again later\"}"
  63         AddEnbUrl                    = "/nodeb/enb"
  64 )
  65
  66 var (
  67         ServedNrCellInformationRequiredFields = []string{"cellId", "choiceNrMode", "nrMode", "servedPlmns"}
  68         NrNeighbourInformationRequiredFields  = []string{"nrCgi", "choiceNrMode", "nrMode"}
  69         AddEnbRequestRequiredFields           = []string{"ranName", "enb", "globalNbId"}
  70         UpdateEnbRequestRequiredFields        = []string{"enb"}
  71         GlobalIdRequiredFields                = []string{"plmnId", "nbId"}
  72         EnbRequiredFields                     = []string{"enbType", "servedCells"}
  73         ServedCellRequiredFields              = []string{"broadcastPlmns", "cellId", "choiceEutraMode", "eutraMode", "tac"}
  74 )
  75
  76 type controllerGetNodebTestContext struct {
  77         ranName              string
  78         nodebInfo            *entities.NodebInfo
  79         rnibError            error
  80         expectedStatusCode   int
  81         expectedJsonResponse string
  82 }
  83
  84 type controllerGetNodebIdListTestContext struct {
  85         nodebIdList          []*entities.NbIdentity
  86         rnibError            error
  87         expectedStatusCode   int
  88         expectedJsonResponse string
  89 }
  90
  91 type getNodebInfoResult struct {
  92         nodebInfo *entities.NodebInfo
  93         rnibError error
  94 }
  95
  96 type updateGnbCellsParams struct {
  97         err error
  98 }
  99
 100 type updateEnbCellsParams struct {
 101         err error
 102 }
 103
 104 type saveNodebParams struct {
 105         nodebInfo  *entities.NodebInfo
 106         nbIdentity *entities.NbIdentity
 107         err        error
 108 }
 109
 110 type removeServedCellsParams struct {
 111         servedCellInfo []*entities.ServedCellInfo
 112         err            error
 113 }
 114
 115 type removeServedNrCellsParams struct {
 116         servedNrCells []*entities.ServedNRCell
 117         err           error
 118 }
 119
 120 type controllerUpdateEnbTestContext struct {
 121         getNodebInfoResult      *getNodebInfoResult
 122         removeServedCellsParams *removeServedCellsParams
 123         updateEnbCellsParams    *updateEnbCellsParams
 124         requestBody             map[string]interface{}
 125         expectedStatusCode      int
 126         expectedJsonResponse    string
 127 }
 128
 129 type controllerUpdateGnbTestContext struct {
 130         getNodebInfoResult        *getNodebInfoResult
 131         removeServedNrCellsParams *removeServedNrCellsParams
 132         updateGnbCellsParams      *updateGnbCellsParams
 133         requestBody               map[string]interface{}
 134         expectedStatusCode        int
 135         expectedJsonResponse      string
 136 }
 137
 138 type controllerAddEnbTestContext struct {
 139         getNodebInfoResult   *getNodebInfoResult
 140         saveNodebParams      *saveNodebParams
 141         requestBody          map[string]interface{}
 142         expectedStatusCode   int
 143         expectedJsonResponse string
 144 }
 145
 146 type controllerDeleteEnbTestContext struct {
 147         getNodebInfoResult   *getNodebInfoResult
 148         expectedStatusCode   int
 149         expectedJsonResponse string
 150 }
 151
 152 func generateServedNrCells(cellIds ...string) []*entities.ServedNRCell {
 153
 154         servedNrCells := []*entities.ServedNRCell{}
 155
 156         for _, v := range cellIds {
 157                 servedNrCells = append(servedNrCells, &entities.ServedNRCell{ServedNrCellInformation: &entities.ServedNRCellInformation{
 158                         CellId: v,
 159                         ChoiceNrMode: &entities.ServedNRCellInformation_ChoiceNRMode{
 160                                 Fdd: &entities.ServedNRCellInformation_ChoiceNRMode_FddInfo{
 161
 162                                 },
 163                         },
 164                         NrMode:      entities.Nr_FDD,
 165                         NrPci:       5,
 166                         ServedPlmns: []string{"whatever"},
 167                 }})
 168         }
 169
 170         return servedNrCells
 171 }
 172
 173 func generateServedCells(cellIds ...string) []*entities.ServedCellInfo {
 174
 175         var servedCells []*entities.ServedCellInfo
 176
 177         for i, v := range cellIds {
 178                 servedCells = append(servedCells, &entities.ServedCellInfo{
 179                         CellId: v,
 180                         ChoiceEutraMode: &entities.ChoiceEUTRAMode{
 181                                 Fdd: &entities.FddInfo{},
 182                         },
 183                         Pci:            uint32(i + 1),
 184                         BroadcastPlmns: []string{"whatever"},
 185                 })
 186         }
 187
 188         return servedCells
 189 }
 190
 191 func buildNrNeighbourInformation(propToOmit string) map[string]interface{} {
 192         ret := map[string]interface{}{
 193                 "nrCgi": "whatever",
 194                 "choiceNrMode": map[string]interface{}{
 195                         "tdd": map[string]interface{}{},
 196                 },
 197                 "nrMode": 1,
 198                 "nrPci":  1,
 199         }
 200
 201         if len(propToOmit) != 0 {
 202                 delete(ret, propToOmit)
 203         }
 204
 205         return ret
 206 }
 207
 208 func buildServedNrCellInformation(propToOmit string) map[string]interface{} {
 209         ret := map[string]interface{}{
 210                 "cellId": "whatever",
 211                 "choiceNrMode": map[string]interface{}{
 212                         "fdd": map[string]interface{}{},
 213                 },
 214                 "nrMode": 1,
 215                 "nrPci":  1,
 216                 "servedPlmns": []interface{}{
 217                         "whatever",
 218                 },
 219         }
 220
 221         if len(propToOmit) != 0 {
 222                 delete(ret, propToOmit)
 223         }
 224
 225         return ret
 226 }
 227
 228 func buildServedCell(propToOmit string) map[string]interface{} {
 229         ret := map[string]interface{}{
 230                 "cellId": "whatever",
 231                 "choiceEutraMode": map[string]interface{}{
 232                         "fdd": map[string]interface{}{},
 233                 },
 234                 "eutraMode": 1,
 235                 "pci":       1,
 236                 "tac":       "whatever3",
 237                 "broadcastPlmns": []interface{}{
 238                         "whatever",
 239                 },
 240         }
 241
 242         if len(propToOmit) != 0 {
 243                 delete(ret, propToOmit)
 244         }
 245
 246         return ret
 247 }
 248
 249 func getUpdateEnbRequest(propToOmit string) map[string]interface{} {
 250         ret := map[string]interface{}{
 251                 "enb":        buildEnb(propToOmit),
 252         }
 253
 254         if len(propToOmit) != 0 {
 255                 delete(ret, propToOmit)
 256         }
 257
 258         return ret
 259 }
 260
 261
 262 func getAddEnbRequest(propToOmit string) map[string]interface{} {
 263         ret := map[string]interface{}{
 264                 "ranName":    RanName,
 265                 "globalNbId": buildGlobalNbId(""),
 266                 "enb":        buildEnb(""),
 267         }
 268
 269         if len(propToOmit) != 0 {
 270                 delete(ret, propToOmit)
 271         }
 272
 273         return ret
 274 }
 275
 276 func buildEnb(propToOmit string) map[string]interface{} {
 277         ret := map[string]interface{}{
 278                 "enbType": 1,
 279                 "servedCells": []interface{}{
 280                         buildServedCell(""),
 281                 }}
 282
 283         if len(propToOmit) != 0 {
 284                 delete(ret, propToOmit)
 285         }
 286
 287         return ret
 288 }
 289
 290 func buildGlobalNbId(propToOmit string) map[string]interface{} {
 291         ret := map[string]interface{}{
 292                 "plmnId": "whatever",
 293                 "nbId":   "whatever2",
 294         }
 295
 296         if len(propToOmit) != 0 {
 297                 delete(ret, propToOmit)
 298         }
 299
 300         return ret
 301 }
 302
 303 func setupControllerTest(t *testing.T) (*NodebController, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.RmrMessengerMock, *mocks.E2TInstancesManagerMock) {
 304         log := initLog(t)
 305         config := configuration.ParseConfiguration()
 306
 307         rmrMessengerMock := &mocks.RmrMessengerMock{}
 308         readerMock := &mocks.RnibReaderMock{}
 309
 310         writerMock := &mocks.RnibWriterMock{}
 311
 312         rnibDataService := services.NewRnibDataService(log, config, readerMock, writerMock)
 313         rmrSender := getRmrSender(rmrMessengerMock, log)
 314         e2tInstancesManager := &mocks.E2TInstancesManagerMock{}
 315         httpClientMock := &mocks.HttpClientMock{}
 316         rmClient := clients.NewRoutingManagerClient(log, config, httpClientMock)
 317         ranListManager := &mocks.RanListManagerMock{}
 318         ranAlarmService := &mocks.RanAlarmServiceMock{}
 319         ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(log, rnibDataService, ranListManager, ranAlarmService)
 320         nodebValidator := managers.NewNodebValidator()
 321         updateEnbManager := managers.NewUpdateEnbManager(log, rnibDataService, nodebValidator)
 322
 323         handlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(log, rmrSender, config, rnibDataService, e2tInstancesManager, rmClient, ranConnectStatusChangeManager, nodebValidator, updateEnbManager)
 324         controller := NewNodebController(log, handlerProvider)
 325         return controller, readerMock, writerMock, rmrMessengerMock, e2tInstancesManager
 326 }
 327
 328 func TestShutdownHandlerRnibError(t *testing.T) {
 329         controller, _, _, _, e2tInstancesManagerMock := setupControllerTest(t)
 330         e2tInstancesManagerMock.On("GetE2TAddresses").Return([]string{}, e2managererrors.NewRnibDbError())
 331
 332         writer := httptest.NewRecorder()
 333
 334         controller.Shutdown(writer, tests.GetHttpRequest())
 335
 336         var errorResponse = parseJsonRequest(t, writer.Body)
 337
 338         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
 339         assert.Equal(t, errorResponse.Code, e2managererrors.NewRnibDbError().Code)
 340 }
 341
 342 func TestSetGeneralConfigurationHandlerRnibError(t *testing.T) {
 343         controller, readerMock, _, _, _ := setupControllerTest(t)
 344
 345         configuration := &entities.GeneralConfiguration{}
 346         readerMock.On("GetGeneralConfiguration").Return(configuration, e2managererrors.NewRnibDbError())
 347
 348         writer := httptest.NewRecorder()
 349
 350         httpRequest, _ := http.NewRequest("PUT", "https://localhost:3800/v1/nodeb/parameters", strings.NewReader("{\"enableRic\":false}"))
 351
 352         controller.SetGeneralConfiguration(writer, httpRequest)
 353
 354         var errorResponse = parseJsonRequest(t, writer.Body)
 355
 356         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
 357         assert.Equal(t, e2managererrors.NewRnibDbError().Code, errorResponse.Code)
 358 }
 359
 360 func TestSetGeneralConfigurationInvalidJson(t *testing.T) {
 361         controller, _, _, _, _ := setupControllerTest(t)
 362
 363         writer := httptest.NewRecorder()
 364
 365         httpRequest, _ := http.NewRequest("PUT", "https://localhost:3800/v1/nodeb/parameters", strings.NewReader("{\"enableRic\":false, \"someValue\":false}"))
 366
 367         controller.SetGeneralConfiguration(writer, httpRequest)
 368
 369         var errorResponse = parseJsonRequest(t, writer.Body)
 370
 371         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
 372         assert.Equal(t, e2managererrors.NewInvalidJsonError().Code, errorResponse.Code)
 373 }
 374
 375 func controllerGetNodebTestExecuter(t *testing.T, context *controllerGetNodebTestContext) {
 376         controller, readerMock, _, _, _ := setupControllerTest(t)
 377         writer := httptest.NewRecorder()
 378         readerMock.On("GetNodeb", context.ranName).Return(context.nodebInfo, context.rnibError)
 379         req, _ := http.NewRequest(http.MethodGet, "/nodeb", nil)
 380         req = mux.SetURLVars(req, map[string]string{"ranName": context.ranName})
 381         controller.GetNodeb(writer, req)
 382         assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
 383         bodyBytes, _ := ioutil.ReadAll(writer.Body)
 384         assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
 385 }
 386
 387 func controllerGetNodebIdListTestExecuter(t *testing.T, context *controllerGetNodebIdListTestContext) {
 388         controller, readerMock, _, _, _ := setupControllerTest(t)
 389         writer := httptest.NewRecorder()
 390         readerMock.On("GetListNodebIds").Return(context.nodebIdList, context.rnibError)
 391         req, _ := http.NewRequest(http.MethodGet, "/nodeb/ids", nil)
 392         controller.GetNodebIdList(writer, req)
 393         assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
 394         bodyBytes, _ := ioutil.ReadAll(writer.Body)
 395         assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
 396 }
 397
 398 func activateControllerUpdateEnbMocks(context *controllerUpdateEnbTestContext, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock,updateEnbRequest *models.UpdateEnbRequest) {
 399         if context.getNodebInfoResult != nil {
 400                 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
 401         }
 402
 403         if context.removeServedCellsParams != nil {
 404                 writerMock.On("RemoveServedCells", RanName, context.removeServedCellsParams.servedCellInfo).Return(context.removeServedCellsParams.err)
 405         }
 406
 407         if context.updateEnbCellsParams != nil {
 408                 updatedNodebInfo := *context.getNodebInfoResult.nodebInfo
 409                 updatedNodebInfo.Configuration = &entities.NodebInfo_Enb{Enb: updateEnbRequest.Enb}
 410
 411                 writerMock.On("UpdateEnb", &updatedNodebInfo, updateEnbRequest.Enb.ServedCells).Return(context.updateEnbCellsParams.err)
 412         }
 413 }
 414
 415 func activateControllerUpdateGnbMocks(context *controllerUpdateGnbTestContext, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
 416         if context.getNodebInfoResult != nil {
 417                 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
 418         }
 419
 420         if context.removeServedNrCellsParams != nil {
 421                 writerMock.On("RemoveServedNrCells", RanName, context.removeServedNrCellsParams.servedNrCells).Return(context.removeServedNrCellsParams.err)
 422         }
 423
 424         if context.updateGnbCellsParams != nil {
 425                 updatedNodebInfo := *context.getNodebInfoResult.nodebInfo
 426                 gnb := entities.Gnb{}
 427                 _ = jsonpb.Unmarshal(getJsonRequestAsBuffer(context.requestBody), &gnb)
 428                 updatedGnb := *updatedNodebInfo.GetGnb()
 429                 updatedGnb.ServedNrCells = gnb.ServedNrCells
 430                 writerMock.On("UpdateGnbCells", &updatedNodebInfo, gnb.ServedNrCells).Return(context.updateGnbCellsParams.err)
 431         }
 432 }
 433
 434 func assertControllerUpdateGnb(t *testing.T, context *controllerUpdateGnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
 435         assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
 436         bodyBytes, _ := ioutil.ReadAll(writer.Body)
 437         assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
 438         readerMock.AssertExpectations(t)
 439         writerMock.AssertExpectations(t)
 440 }
 441
 442 func assertControllerUpdateEnb(t *testing.T, context *controllerUpdateEnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
 443         assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
 444         bodyBytes, _ := ioutil.ReadAll(writer.Body)
 445         assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
 446         readerMock.AssertExpectations(t)
 447         writerMock.AssertExpectations(t)
 448 }
 449
 450 func assertControllerAddEnb(t *testing.T, context *controllerAddEnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
 451         assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
 452         bodyBytes, _ := ioutil.ReadAll(writer.Body)
 453         assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
 454         readerMock.AssertExpectations(t)
 455         writerMock.AssertExpectations(t)
 456 }
 457
 458 func assertControllerDeleteEnb(t *testing.T, context *controllerDeleteEnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
 459         assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
 460         bodyBytes, _ := ioutil.ReadAll(writer.Body)
 461         assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
 462         readerMock.AssertExpectations(t)
 463         writerMock.AssertExpectations(t)
 464 }
 465
 466 func buildUpdateEnbRequest(context *controllerUpdateEnbTestContext) *http.Request {
 467         updateEnbUrl := fmt.Sprintf("/nodeb/enb/%s", RanName)
 468         requestBody := getJsonRequestAsBuffer(context.requestBody)
 469         req, _ := http.NewRequest(http.MethodPut, updateEnbUrl, requestBody)
 470         req.Header.Set("Content-Type", "application/json")
 471         req = mux.SetURLVars(req, map[string]string{"ranName": RanName})
 472         return req
 473 }
 474
 475 func buildUpdateGnbRequest(context *controllerUpdateGnbTestContext) *http.Request {
 476         updateGnbUrl := fmt.Sprintf("/nodeb/%s/update", RanName)
 477         requestBody := getJsonRequestAsBuffer(context.requestBody)
 478         req, _ := http.NewRequest(http.MethodPut, updateGnbUrl, requestBody)
 479         req.Header.Set("Content-Type", "application/json")
 480         req = mux.SetURLVars(req, map[string]string{"ranName": RanName})
 481         return req
 482 }
 483
 484 func buildAddEnbRequest(context *controllerAddEnbTestContext) *http.Request {
 485         requestBody := getJsonRequestAsBuffer(context.requestBody)
 486         req, _ := http.NewRequest(http.MethodPost, AddEnbUrl, requestBody)
 487         req.Header.Set("Content-Type", "application/json")
 488         return req
 489 }
 490
 491 func controllerUpdateEnbTestExecuter(t *testing.T, context *controllerUpdateEnbTestContext) {
 492         controller, readerMock, writerMock, _, _ := setupControllerTest(t)
 493         writer := httptest.NewRecorder()
 494
 495         r := buildUpdateEnbRequest(context)
 496         body, _ := ioutil.ReadAll(io.LimitReader(r.Body, LimitRequest))
 497
 498         updateEnbRequest := models.UpdateEnbRequest{}
 499         _ = json.Unmarshal(body, &updateEnbRequest)
 500
 501         activateControllerUpdateEnbMocks(context, readerMock, writerMock, &updateEnbRequest)
 502         r = buildUpdateEnbRequest(context)
 503         defer r.Body.Close()
 504
 505         controller.UpdateEnb(writer, r)
 506
 507         assertControllerUpdateEnb(t, context, writer, readerMock, writerMock)
 508 }
 509
 510 func controllerUpdateGnbTestExecuter(t *testing.T, context *controllerUpdateGnbTestContext) {
 511         controller, readerMock, writerMock, _, _ := setupControllerTest(t)
 512         writer := httptest.NewRecorder()
 513
 514         activateControllerUpdateGnbMocks(context, readerMock, writerMock)
 515         req := buildUpdateGnbRequest(context)
 516         controller.UpdateGnb(writer, req)
 517         assertControllerUpdateGnb(t, context, writer, readerMock, writerMock)
 518 }
 519
 520 func activateControllerAddEnbMocks(context *controllerAddEnbTestContext, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock, addEnbRequest *models.AddEnbRequest) {
 521         if context.getNodebInfoResult != nil {
 522                 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
 523         }
 524
 525         if context.saveNodebParams != nil {
 526                 nodebInfo := entities.NodebInfo{
 527                         RanName:          addEnbRequest.RanName,
 528                         Ip:               addEnbRequest.Ip,
 529                         Port:             addEnbRequest.Port,
 530                         NodeType:         entities.Node_ENB,
 531                         GlobalNbId:       addEnbRequest.GlobalNbId,
 532                         Configuration:    &entities.NodebInfo_Enb{Enb: addEnbRequest.Enb},
 533                         ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,
 534                 }
 535
 536                 nbIdentity := entities.NbIdentity{InventoryName: addEnbRequest.RanName, GlobalNbId: addEnbRequest.GlobalNbId}
 537
 538                 writerMock.On("SaveNodeb", &nbIdentity, &nodebInfo).Return(context.saveNodebParams.err)
 539         }
 540 }
 541
 542 func controllerAddEnbTestExecuter(t *testing.T, context *controllerAddEnbTestContext) {
 543         controller, readerMock, writerMock, _, _ := setupControllerTest(t)
 544         writer := httptest.NewRecorder()
 545         r := buildAddEnbRequest(context)
 546         body, _ := ioutil.ReadAll(io.LimitReader(r.Body, LimitRequest))
 547
 548         addEnbRequest := models.AddEnbRequest{}
 549
 550         _ = json.Unmarshal(body, &addEnbRequest)
 551         activateControllerAddEnbMocks(context, readerMock, writerMock, &addEnbRequest)
 552         r = buildAddEnbRequest(context)
 553         defer r.Body.Close()
 554         controller.AddEnb(writer, r)
 555         assertControllerAddEnb(t, context, writer, readerMock, writerMock)
 556 }
 557
 558 func controllerDeleteEnbTestExecuter(t *testing.T, context *controllerDeleteEnbTestContext) {
 559         controller, readerMock, writerMock, _, _ := setupControllerTest(t)
 560         readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
 561         if context.getNodebInfoResult.rnibError == nil && context.getNodebInfoResult.nodebInfo.GetNodeType() == entities.Node_ENB {
 562                 writerMock.On("RemoveEnb", context.getNodebInfoResult.nodebInfo).Return(nil)
 563         }
 564         writer := httptest.NewRecorder()
 565         r, _ := http.NewRequest(http.MethodDelete, AddEnbUrl+"/"+RanName, nil)
 566         r.Header.Set("Content-Type", "application/json")
 567         r = mux.SetURLVars(r, map[string]string{"ranName": RanName})
 568         controller.DeleteEnb(writer, r)
 569         assertControllerDeleteEnb(t, context, writer, readerMock, writerMock)
 570 }
 571
 572 func TestControllerUpdateGnbEmptyServedNrCells(t *testing.T) {
 573         context := controllerUpdateGnbTestContext{
 574                 getNodebInfoResult: nil,
 575                 requestBody: map[string]interface{}{
 576                         "servedNrCells": []interface{}{
 577                         },
 578                 },
 579                 expectedStatusCode:   http.StatusBadRequest,
 580                 expectedJsonResponse: ValidationFailureJson,
 581         }
 582
 583         controllerUpdateGnbTestExecuter(t, &context)
 584 }
 585
 586 func TestControllerUpdateGnbMissingServedNrCellInformation(t *testing.T) {
 587         context := controllerUpdateGnbTestContext{
 588                 getNodebInfoResult: nil,
 589                 requestBody: map[string]interface{}{
 590                         "servedNrCells": []interface{}{
 591                                 map[string]interface{}{
 592                                         "servedNrCellInformation": nil,
 593                                 },
 594                         },
 595                 },
 596                 expectedStatusCode:   http.StatusBadRequest,
 597                 expectedJsonResponse: ValidationFailureJson,
 598         }
 599
 600         controllerUpdateGnbTestExecuter(t, &context)
 601 }
 602
 603 func TestControllerUpdateGnbMissingServedNrCellRequiredProp(t *testing.T) {
 604
 605         for _, v := range ServedNrCellInformationRequiredFields {
 606                 context := controllerUpdateGnbTestContext{
 607                         getNodebInfoResult: nil,
 608                         requestBody: map[string]interface{}{
 609                                 "servedNrCells": []interface{}{
 610                                         map[string]interface{}{
 611                                                 "servedNrCellInformation": buildServedNrCellInformation(v),
 612                                         },
 613                                 },
 614                         },
 615                         expectedStatusCode:   http.StatusBadRequest,
 616                         expectedJsonResponse: ValidationFailureJson,
 617                 }
 618
 619                 controllerUpdateGnbTestExecuter(t, &context)
 620         }
 621 }
 622
 623 func TestControllerUpdateGnbMissingServedNrCellFddOrTdd(t *testing.T) {
 624
 625         servedNrCellInformation := buildServedNrCellInformation("")
 626         servedNrCellInformation["choiceNrMode"] = map[string]interface{}{}
 627
 628         context := controllerUpdateGnbTestContext{
 629                 getNodebInfoResult: nil,
 630                 requestBody: map[string]interface{}{
 631                         "servedNrCells": []interface{}{
 632                                 map[string]interface{}{
 633                                         "servedNrCellInformation": servedNrCellInformation,
 634                                 },
 635                         },
 636                 },
 637                 expectedStatusCode:   http.StatusBadRequest,
 638                 expectedJsonResponse: ValidationFailureJson,
 639         }
 640
 641         controllerUpdateGnbTestExecuter(t, &context)
 642 }
 643
 644 func TestControllerUpdateGnbMissingNeighbourInfoFddOrTdd(t *testing.T) {
 645
 646         nrNeighbourInfo := buildNrNeighbourInformation("")
 647         nrNeighbourInfo["choiceNrMode"] = map[string]interface{}{}
 648
 649         context := controllerUpdateGnbTestContext{
 650                 getNodebInfoResult: nil,
 651                 requestBody: map[string]interface{}{
 652                         "servedNrCells": []interface{}{
 653                                 map[string]interface{}{
 654                                         "servedNrCellInformation": buildServedNrCellInformation(""),
 655                                         "nrNeighbourInfos": []interface{}{
 656                                                 nrNeighbourInfo,
 657                                         },
 658                                 },
 659                         },
 660                 },
 661                 expectedStatusCode:   http.StatusBadRequest,
 662                 expectedJsonResponse: ValidationFailureJson,
 663         }
 664
 665         controllerUpdateGnbTestExecuter(t, &context)
 666 }
 667
 668 func TestControllerUpdateGnbMissingNrNeighbourInformationRequiredProp(t *testing.T) {
 669
 670         for _, v := range NrNeighbourInformationRequiredFields {
 671                 context := controllerUpdateGnbTestContext{
 672                         getNodebInfoResult: nil,
 673                         requestBody: map[string]interface{}{
 674                                 "servedNrCells": []interface{}{
 675                                         map[string]interface{}{
 676                                                 "servedNrCellInformation": buildServedNrCellInformation(""),
 677                                                 "nrNeighbourInfos": []interface{}{
 678                                                         buildNrNeighbourInformation(v),
 679                                                 },
 680                                         },
 681                                 },
 682                         },
 683                         expectedStatusCode:   http.StatusBadRequest,
 684                         expectedJsonResponse: ValidationFailureJson,
 685                 }
 686
 687                 controllerUpdateGnbTestExecuter(t, &context)
 688         }
 689 }
 690
 691 func TestControllerUpdateGnbValidServedNrCellInformationGetNodebNotFound(t *testing.T) {
 692         context := controllerUpdateGnbTestContext{
 693                 getNodebInfoResult: &getNodebInfoResult{
 694                         nodebInfo: nil,
 695                         rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
 696                 },
 697                 requestBody: map[string]interface{}{
 698                         "servedNrCells": []interface{}{
 699                                 map[string]interface{}{
 700                                         "servedNrCellInformation": buildServedNrCellInformation(""),
 701                                 },
 702                         },
 703                 },
 704                 expectedStatusCode:   http.StatusNotFound,
 705                 expectedJsonResponse: ResourceNotFoundJson,
 706         }
 707
 708         controllerUpdateGnbTestExecuter(t, &context)
 709 }
 710
 711 func TestControllerUpdateGnbValidServedNrCellInformationGetNodebInternalError(t *testing.T) {
 712         context := controllerUpdateGnbTestContext{
 713                 getNodebInfoResult: &getNodebInfoResult{
 714                         nodebInfo: nil,
 715                         rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
 716                 },
 717                 requestBody: map[string]interface{}{
 718                         "servedNrCells": []interface{}{
 719                                 map[string]interface{}{
 720                                         "servedNrCellInformation": buildServedNrCellInformation(""),
 721                                 },
 722                         },
 723                 },
 724                 expectedStatusCode:   http.StatusInternalServerError,
 725                 expectedJsonResponse: RnibErrorJson,
 726         }
 727
 728         controllerUpdateGnbTestExecuter(t, &context)
 729 }
 730
 731 func TestControllerUpdateGnbGetNodebSuccessInvalidGnbConfiguration(t *testing.T) {
 732         context := controllerUpdateGnbTestContext{
 733                 getNodebInfoResult: &getNodebInfoResult{
 734                         nodebInfo: &entities.NodebInfo{
 735                                 RanName:                      RanName,
 736                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
 737                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
 738                         },
 739                         rnibError: nil,
 740                 },
 741                 requestBody: map[string]interface{}{
 742                         "servedNrCells": []interface{}{
 743                                 map[string]interface{}{
 744                                         "servedNrCellInformation": buildServedNrCellInformation(""),
 745                                         "nrNeighbourInfos": []interface{}{
 746                                                 buildNrNeighbourInformation(""),
 747                                         },
 748                                 },
 749                         },
 750                 },
 751                 expectedStatusCode:   http.StatusInternalServerError,
 752                 expectedJsonResponse: InternalErrorJson,
 753         }
 754
 755         controllerUpdateGnbTestExecuter(t, &context)
 756 }
 757
 758 func TestControllerUpdateGnbGetNodebSuccessRemoveServedNrCellsFailure(t *testing.T) {
 759         oldServedNrCells := generateServedNrCells("whatever1", "whatever2")
 760         context := controllerUpdateGnbTestContext{
 761                 removeServedNrCellsParams: &removeServedNrCellsParams{
 762                         err:           common.NewInternalError(errors.New("#writer.UpdateGnbCells - Internal Error")),
 763                         servedNrCells: oldServedNrCells,
 764                 },
 765                 getNodebInfoResult: &getNodebInfoResult{
 766                         nodebInfo: &entities.NodebInfo{
 767                                 RanName:                      RanName,
 768                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
 769                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
 770                                 Configuration:                &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{ServedNrCells: oldServedNrCells}},
 771                         },
 772                         rnibError: nil,
 773                 },
 774                 requestBody: map[string]interface{}{
 775                         "servedNrCells": []interface{}{
 776                                 map[string]interface{}{
 777                                         "servedNrCellInformation": buildServedNrCellInformation(""),
 778                                         "nrNeighbourInfos": []interface{}{
 779                                                 buildNrNeighbourInformation(""),
 780                                         },
 781                                 },
 782                         },
 783                 },
 784                 expectedStatusCode:   http.StatusInternalServerError,
 785                 expectedJsonResponse: RnibErrorJson,
 786         }
 787
 788         controllerUpdateGnbTestExecuter(t, &context)
 789 }
 790
 791 func TestControllerUpdateGnbGetNodebSuccessUpdateGnbCellsFailure(t *testing.T) {
 792         oldServedNrCells := generateServedNrCells("whatever1", "whatever2")
 793         context := controllerUpdateGnbTestContext{
 794                 removeServedNrCellsParams: &removeServedNrCellsParams{
 795                         err:           nil,
 796                         servedNrCells: oldServedNrCells,
 797                 },
 798                 updateGnbCellsParams: &updateGnbCellsParams{
 799                         err: common.NewInternalError(errors.New("#writer.UpdateGnbCells - Internal Error")),
 800                 },
 801                 getNodebInfoResult: &getNodebInfoResult{
 802                         nodebInfo: &entities.NodebInfo{
 803                                 RanName:                      RanName,
 804                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
 805                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
 806                                 Configuration:                &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{ServedNrCells: oldServedNrCells}},
 807                         },
 808                         rnibError: nil,
 809                 },
 810                 requestBody: map[string]interface{}{
 811                         "servedNrCells": []interface{}{
 812                                 map[string]interface{}{
 813                                         "servedNrCellInformation": buildServedNrCellInformation(""),
 814                                         "nrNeighbourInfos": []interface{}{
 815                                                 buildNrNeighbourInformation(""),
 816                                         },
 817                                 },
 818                         },
 819                 },
 820                 expectedStatusCode:   http.StatusInternalServerError,
 821                 expectedJsonResponse: RnibErrorJson,
 822         }
 823
 824         controllerUpdateGnbTestExecuter(t, &context)
 825 }
 826
 827 func TestControllerUpdateGnbSuccess(t *testing.T) {
 828         context := controllerUpdateGnbTestContext{
 829                 updateGnbCellsParams: &updateGnbCellsParams{
 830                         err: nil,
 831                 },
 832                 getNodebInfoResult: &getNodebInfoResult{
 833                         nodebInfo: &entities.NodebInfo{
 834                                 RanName:                      RanName,
 835                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
 836                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
 837                                 Configuration:                &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{}},
 838                         },
 839                         rnibError: nil,
 840                 },
 841                 requestBody: map[string]interface{}{
 842                         "servedNrCells": []interface{}{
 843                                 map[string]interface{}{
 844                                         "servedNrCellInformation": buildServedNrCellInformation(""),
 845                                         "nrNeighbourInfos": []interface{}{
 846                                                 buildNrNeighbourInformation(""),
 847                                         },
 848                                 },
 849                         },
 850                 },
 851                 expectedStatusCode:   http.StatusOK,
 852                 expectedJsonResponse: "{\"ranName\":\"test\",\"connectionStatus\":\"CONNECTED\",\"gnb\":{\"servedNrCells\":[{\"servedNrCellInformation\":{\"nrPci\":1,\"cellId\":\"whatever\",\"servedPlmns\":[\"whatever\"],\"nrMode\":\"FDD\",\"choiceNrMode\":{\"fdd\":{}}},\"nrNeighbourInfos\":[{\"nrPci\":1,\"nrCgi\":\"whatever\",\"nrMode\":\"FDD\",\"choiceNrMode\":{\"tdd\":{}}}]}]},\"associatedE2tInstanceAddress\":\"10.0.2.15:38000\"}",
 853         }
 854
 855         controllerUpdateGnbTestExecuter(t, &context)
 856 }
 857
 858 func TestControllerUpdateEnbInvalidRequest(t *testing.T) {
 859         controller, _, _, _, _ := setupControllerTest(t)
 860
 861         writer := httptest.NewRecorder()
 862         invalidJson := strings.NewReader("{enb:\"whatever\"")
 863
 864         updateEnbUrl := fmt.Sprintf("/nodeb/enb/%s", RanName)
 865         req, _ := http.NewRequest(http.MethodPut, updateEnbUrl, invalidJson)
 866         req.Header.Set("Content-Type", "application/json")
 867         req = mux.SetURLVars(req, map[string]string{"ranName": RanName})
 868
 869         controller.UpdateEnb(writer, req)
 870
 871         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
 872         bodyBytes, _ := ioutil.ReadAll(writer.Body)
 873         assert.Equal(t, CorruptedJson, string(bodyBytes))
 874 }
 875
 876 func TestControllerUpdateEnbEmptyEnbType(t *testing.T) {
 877         context := controllerUpdateEnbTestContext{
 878                 getNodebInfoResult: nil,
 879                 requestBody: getUpdateEnbRequest(EnbRequiredFields[0]),
 880                 expectedStatusCode:   http.StatusBadRequest,
 881                 expectedJsonResponse: ValidationFailureJson,
 882         }
 883
 884         controllerUpdateEnbTestExecuter(t, &context)
 885 }
 886
 887 func TestControllerUpdateEnbEmptyServedCells(t *testing.T) {
 888         context := controllerUpdateEnbTestContext{
 889                 getNodebInfoResult: nil,
 890                 requestBody: getUpdateEnbRequest(EnbRequiredFields[1]),
 891                 expectedStatusCode:   http.StatusBadRequest,
 892                 expectedJsonResponse: ValidationFailureJson,
 893         }
 894
 895         controllerUpdateEnbTestExecuter(t, &context)
 896 }
 897
 898 func TestControllerUpdateEnbMissingEnb(t *testing.T) {
 899         context := controllerUpdateEnbTestContext{
 900                 getNodebInfoResult: nil,
 901                 requestBody: getUpdateEnbRequest(UpdateEnbRequestRequiredFields[0]),
 902                 expectedStatusCode:   http.StatusBadRequest,
 903                 expectedJsonResponse: ValidationFailureJson,
 904         }
 905
 906         controllerUpdateEnbTestExecuter(t, &context)
 907 }
 908
 909 func TestControllerUpdateEnbValidServedCellsGetNodebNotFound(t *testing.T) {
 910         context := controllerUpdateEnbTestContext{
 911                 getNodebInfoResult: &getNodebInfoResult{
 912                         nodebInfo: nil,
 913                         rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
 914                 },
 915                 requestBody: getUpdateEnbRequest(""),
 916                 expectedStatusCode:   http.StatusNotFound,
 917                 expectedJsonResponse: ResourceNotFoundJson,
 918         }
 919
 920         controllerUpdateEnbTestExecuter(t, &context)
 921 }
 922
 923 func TestControllerUpdateEnbValidServedCellsGetNodebInternalError(t *testing.T) {
 924         context := controllerUpdateEnbTestContext{
 925                 getNodebInfoResult: &getNodebInfoResult{
 926                         nodebInfo: nil,
 927                         rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
 928                 },
 929                 requestBody: getUpdateEnbRequest(""),
 930                 expectedStatusCode:   http.StatusInternalServerError,
 931                 expectedJsonResponse: RnibErrorJson,
 932         }
 933
 934         controllerUpdateEnbTestExecuter(t, &context)
 935 }
 936
 937 func TestControllerUpdateEnbGetNodebSuccessGnbTypeFailure(t *testing.T) {
 938         oldServedCells := generateServedCells("whatever1", "whatever2")
 939         context := controllerUpdateEnbTestContext{
 940                 getNodebInfoResult: &getNodebInfoResult{
 941                         nodebInfo: &entities.NodebInfo{
 942                                 RanName:                      RanName,
 943                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
 944                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
 945                                 NodeType:                     entities.Node_GNB,
 946                                 Configuration:                &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells}},
 947                         },
 948                         rnibError: nil,
 949                 },
 950                 requestBody: getUpdateEnbRequest(""),
 951                 expectedStatusCode:   http.StatusBadRequest,
 952                 expectedJsonResponse: ValidationFailureJson,
 953         }
 954
 955         controllerUpdateEnbTestExecuter(t, &context)
 956 }
 957
 958 func TestControllerUpdateEnbGetNodebSuccessRemoveServedCellsFailure(t *testing.T) {
 959         oldServedCells := generateServedCells("whatever1", "whatever2")
 960         context := controllerUpdateEnbTestContext{
 961                 removeServedCellsParams: &removeServedCellsParams{
 962                         err:            common.NewInternalError(errors.New("#writer.RemoveServedCells - Internal Error")),
 963                         servedCellInfo: oldServedCells,
 964                 },
 965                 getNodebInfoResult: &getNodebInfoResult{
 966                         nodebInfo: &entities.NodebInfo{
 967                                 RanName:                      RanName,
 968                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
 969                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
 970                                 NodeType:                     entities.Node_ENB,
 971                                 Configuration:                &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells}},
 972                         },
 973                         rnibError: nil,
 974                 },
 975                 requestBody: getUpdateEnbRequest(""),
 976                 expectedStatusCode:   http.StatusInternalServerError,
 977                 expectedJsonResponse: RnibErrorJson,
 978         }
 979
 980         controllerUpdateEnbTestExecuter(t, &context)
 981 }
 982
 983 func TestControllerUpdateEnbGetNodebSuccessUpdateEnbFailure(t *testing.T) {
 984         oldServedCells := generateServedCells("whatever1", "whatever2")
 985         context := controllerUpdateEnbTestContext{
 986                 removeServedCellsParams: &removeServedCellsParams{
 987                         err:           nil,
 988                         servedCellInfo: oldServedCells,
 989                 },
 990                 updateEnbCellsParams: &updateEnbCellsParams{
 991                         err: common.NewInternalError(errors.New("#writer.UpdateEnb - Internal Error")),
 992                 },
 993                 getNodebInfoResult: &getNodebInfoResult{
 994                         nodebInfo: &entities.NodebInfo{
 995                                 RanName:                      RanName,
 996                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
 997                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
 998                                 NodeType:                     entities.Node_ENB,
 999                                 Configuration:                &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells, EnbType: entities.EnbType_MACRO_ENB}},
1000                         },
1001                         rnibError: nil,
1002                 },
1003                 requestBody: getUpdateEnbRequest(""),
1004                 expectedStatusCode:   http.StatusInternalServerError,
1005                 expectedJsonResponse: RnibErrorJson,
1006         }
1007
1008         controllerUpdateEnbTestExecuter(t, &context)
1009 }
1010
1011 func TestControllerUpdateEnbSuccess(t *testing.T) {
1012         oldServedCells := generateServedCells("whatever1", "whatever2")
1013         context := controllerUpdateEnbTestContext{
1014                 removeServedCellsParams: &removeServedCellsParams{
1015                         err:           nil,
1016                         servedCellInfo: oldServedCells,
1017                 },
1018                 updateEnbCellsParams: &updateEnbCellsParams{
1019                         err: nil,
1020                 },
1021                 getNodebInfoResult: &getNodebInfoResult{
1022                         nodebInfo: &entities.NodebInfo{
1023                                 RanName:                      RanName,
1024                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
1025                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1026                                 NodeType:                     entities.Node_ENB,
1027                                 Configuration:                &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells, EnbType: entities.EnbType_MACRO_ENB}},
1028                         },
1029                         rnibError: nil,
1030                 },
1031                 requestBody: getUpdateEnbRequest(""),
1032                 expectedStatusCode:   http.StatusOK,
1033                 expectedJsonResponse: "{\"ranName\":\"test\",\"connectionStatus\":\"CONNECTED\",\"nodeType\":\"ENB\",\"enb\":{\"enbType\":\"MACRO_ENB\",\"servedCells\":[{\"pci\":1,\"cellId\":\"whatever\",\"tac\":\"whatever3\",\"broadcastPlmns\":[\"whatever\"],\"choiceEutraMode\":{\"fdd\":{}},\"eutraMode\":\"FDD\"}]},\"associatedE2tInstanceAddress\":\"10.0.2.15:38000\"}",
1034         }
1035
1036         controllerUpdateEnbTestExecuter(t, &context)
1037 }
1038
1039 func TestControllerAddEnbGetNodebInternalError(t *testing.T) {
1040         context := controllerAddEnbTestContext{
1041                 getNodebInfoResult: &getNodebInfoResult{
1042                         nodebInfo: nil,
1043                         rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
1044                 },
1045                 requestBody:          getAddEnbRequest(""),
1046                 expectedStatusCode:   http.StatusInternalServerError,
1047                 expectedJsonResponse: RnibErrorJson,
1048         }
1049
1050         controllerAddEnbTestExecuter(t, &context)
1051 }
1052
1053 func TestControllerAddEnbNodebExistsFailure(t *testing.T) {
1054         context := controllerAddEnbTestContext{
1055                 getNodebInfoResult: &getNodebInfoResult{
1056                         nodebInfo: &entities.NodebInfo{},
1057                         rnibError: nil,
1058                 },
1059                 requestBody:          getAddEnbRequest(""),
1060                 expectedStatusCode:   http.StatusBadRequest,
1061                 expectedJsonResponse: NodebExistsJson,
1062         }
1063
1064         controllerAddEnbTestExecuter(t, &context)
1065 }
1066
1067 func TestControllerAddEnbSaveNodebFailure(t *testing.T) {
1068         context := controllerAddEnbTestContext{
1069                 saveNodebParams: &saveNodebParams{
1070                         err: common.NewInternalError(errors.New("#reader.SaveeNodeb - Internal Error")),
1071                 },
1072                 getNodebInfoResult: &getNodebInfoResult{
1073                         nodebInfo: nil,
1074                         rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1075                 },
1076                 requestBody:          getAddEnbRequest(""),
1077                 expectedStatusCode:   http.StatusInternalServerError,
1078                 expectedJsonResponse: RnibErrorJson,
1079         }
1080
1081         controllerAddEnbTestExecuter(t, &context)
1082 }
1083
1084 func TestControllerAddEnbMissingRequiredRequestProps(t *testing.T) {
1085
1086         for _, v := range AddEnbRequestRequiredFields {
1087                 context := controllerAddEnbTestContext{
1088                         requestBody:          getAddEnbRequest(v),
1089                         expectedStatusCode:   http.StatusBadRequest,
1090                         expectedJsonResponse: ValidationFailureJson,
1091                 }
1092
1093                 controllerAddEnbTestExecuter(t, &context)
1094         }
1095 }
1096
1097 func TestControllerAddEnbInvalidRequest(t *testing.T) {
1098         controller, _, _, _, _ := setupControllerTest(t)
1099         writer := httptest.NewRecorder()
1100
1101         // Invalid json: attribute name without quotes (should be "cause":).
1102         invalidJson := strings.NewReader("{ranName:\"whatever\"")
1103         req, _ := http.NewRequest(http.MethodPost, AddEnbUrl, invalidJson)
1104
1105         controller.AddEnb(writer, req)
1106         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1107         bodyBytes, _ := ioutil.ReadAll(writer.Body)
1108         assert.Equal(t, CorruptedJson, string(bodyBytes))
1109
1110 }
1111
1112 func TestControllerAddEnbMissingRequiredGlobalNbIdProps(t *testing.T) {
1113
1114         r := getAddEnbRequest("")
1115
1116         for _, v := range GlobalIdRequiredFields {
1117                 r["globalNbId"] = buildGlobalNbId(v)
1118
1119                 context := controllerAddEnbTestContext{
1120                         requestBody:          r,
1121                         expectedStatusCode:   http.StatusBadRequest,
1122                         expectedJsonResponse: ValidationFailureJson,
1123                 }
1124
1125                 controllerAddEnbTestExecuter(t, &context)
1126         }
1127 }
1128
1129 func TestControllerAddEnbMissingRequiredEnbProps(t *testing.T) {
1130
1131         r := getAddEnbRequest("")
1132
1133         for _, v := range EnbRequiredFields {
1134                 r["enb"] = buildEnb(v)
1135
1136                 context := controllerAddEnbTestContext{
1137                         requestBody:          r,
1138                         expectedStatusCode:   http.StatusBadRequest,
1139                         expectedJsonResponse: ValidationFailureJson,
1140                 }
1141
1142                 controllerAddEnbTestExecuter(t, &context)
1143         }
1144 }
1145
1146 func TestControllerUpdateEnbMissingRequiredServedCellProps(t *testing.T) {
1147
1148         r := getUpdateEnbRequest("")
1149
1150         for _, v := range ServedCellRequiredFields {
1151                 enb := r["enb"]
1152
1153                 enbMap, _ := enb.(map[string]interface{})
1154
1155                 enbMap["servedCells"] = []interface{}{
1156                         buildServedCell(v),
1157                 }
1158
1159                 context := controllerUpdateEnbTestContext{
1160                         requestBody:          r,
1161                         expectedStatusCode:   http.StatusBadRequest,
1162                         expectedJsonResponse: ValidationFailureJson,
1163                 }
1164
1165                 controllerUpdateEnbTestExecuter(t, &context)
1166         }
1167 }
1168
1169 func TestControllerAddEnbMissingRequiredServedCellProps(t *testing.T) {
1170
1171         r := getAddEnbRequest("")
1172
1173         for _, v := range ServedCellRequiredFields {
1174                 enb := r["enb"]
1175
1176                 enbMap, _ := enb.(map[string]interface{})
1177
1178                 enbMap["servedCells"] = []interface{}{
1179                         buildServedCell(v),
1180                 }
1181
1182                 context := controllerAddEnbTestContext{
1183                         requestBody:          r,
1184                         expectedStatusCode:   http.StatusBadRequest,
1185                         expectedJsonResponse: ValidationFailureJson,
1186                 }
1187
1188                 controllerAddEnbTestExecuter(t, &context)
1189         }
1190 }
1191
1192 func TestControllerAddEnbSuccess(t *testing.T) {
1193         context := controllerAddEnbTestContext{
1194                 saveNodebParams: &saveNodebParams{
1195                         err: nil,
1196                 },
1197                 getNodebInfoResult: &getNodebInfoResult{
1198                         nodebInfo: nil,
1199                         rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1200                 },
1201                 requestBody: map[string]interface{}{
1202                         "ranName": RanName,
1203                         "globalNbId": map[string]interface{}{
1204                                 "plmnId": "whatever",
1205                                 "nbId":   "whatever2",
1206                         },
1207                         "enb": map[string]interface{}{
1208                                 "enbType": 1,
1209                                 "servedCells": []interface{}{
1210                                         buildServedCell(""),
1211                                 },
1212                         },
1213                 },
1214                 expectedStatusCode:   http.StatusCreated,
1215                 expectedJsonResponse: "{\"ranName\":\"test\",\"connectionStatus\":\"DISCONNECTED\",\"globalNbId\":{\"plmnId\":\"whatever\",\"nbId\":\"whatever2\"},\"nodeType\":\"ENB\",\"enb\":{\"enbType\":\"MACRO_ENB\",\"servedCells\":[{\"pci\":1,\"cellId\":\"whatever\",\"tac\":\"whatever3\",\"broadcastPlmns\":[\"whatever\"],\"choiceEutraMode\":{\"fdd\":{}},\"eutraMode\":\"FDD\"}]}}",
1216         }
1217
1218         controllerAddEnbTestExecuter(t, &context)
1219 }
1220
1221 func TestControllerDeleteEnbGetNodebInternalError(t *testing.T) {
1222         context := controllerDeleteEnbTestContext{
1223                 getNodebInfoResult: &getNodebInfoResult{
1224                         nodebInfo: nil,
1225                         rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
1226                 },
1227                 expectedStatusCode:   http.StatusInternalServerError,
1228                 expectedJsonResponse: RnibErrorJson,
1229         }
1230
1231         controllerDeleteEnbTestExecuter(t, &context)
1232 }
1233
1234 func TestControllerDeleteEnbNodebNotExistsFailure(t *testing.T) {
1235         context := controllerDeleteEnbTestContext{
1236                 getNodebInfoResult: &getNodebInfoResult{
1237                         nodebInfo: nil,
1238                         rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found"),
1239                 },
1240                 expectedStatusCode:   http.StatusNotFound,
1241                 expectedJsonResponse: ResourceNotFoundJson,
1242         }
1243
1244         controllerDeleteEnbTestExecuter(t, &context)
1245 }
1246
1247 func TestControllerDeleteEnbNodebNotEnb(t *testing.T) {
1248         context := controllerDeleteEnbTestContext{
1249                 getNodebInfoResult: &getNodebInfoResult{
1250                         nodebInfo: &entities.NodebInfo{RanName: "ran1", NodeType: entities.Node_GNB, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED},
1251                         rnibError: nil,
1252                 },
1253                 expectedStatusCode:   http.StatusBadRequest,
1254                 expectedJsonResponse: ValidationFailureJson,
1255         }
1256
1257         controllerDeleteEnbTestExecuter(t, &context)
1258 }
1259
1260 func TestControllerDeleteEnbSuccess(t *testing.T) {
1261         context := controllerDeleteEnbTestContext{
1262                 getNodebInfoResult: &getNodebInfoResult{
1263                         nodebInfo: &entities.NodebInfo{RanName: "ran1", NodeType: entities.Node_ENB, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED},
1264                         rnibError: nil,
1265                 },
1266                 expectedStatusCode:   http.StatusNoContent,
1267                 expectedJsonResponse: "",
1268         }
1269         controllerDeleteEnbTestExecuter(t, &context)
1270 }
1271
1272 func getJsonRequestAsBuffer(requestJson map[string]interface{}) *bytes.Buffer {
1273         b := new(bytes.Buffer)
1274         _ = json.NewEncoder(b).Encode(requestJson)
1275         return b
1276 }
1277
1278 func TestControllerGetNodebSuccess(t *testing.T) {
1279         ranName := "test"
1280         var rnibError error
1281         context := controllerGetNodebTestContext{
1282                 ranName:              ranName,
1283                 nodebInfo:            &entities.NodebInfo{RanName: ranName, Ip: "10.0.2.15", Port: 1234},
1284                 rnibError:            rnibError,
1285                 expectedStatusCode:   http.StatusOK,
1286                 expectedJsonResponse: fmt.Sprintf("{\"ranName\":\"%s\",\"ip\":\"10.0.2.15\",\"port\":1234}", ranName),
1287         }
1288
1289         controllerGetNodebTestExecuter(t, &context)
1290 }
1291
1292 func TestControllerGetNodebNotFound(t *testing.T) {
1293
1294         ranName := "test"
1295         var nodebInfo *entities.NodebInfo
1296         context := controllerGetNodebTestContext{
1297                 ranName:              ranName,
1298                 nodebInfo:            nodebInfo,
1299                 rnibError:            common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1300                 expectedStatusCode:   http.StatusNotFound,
1301                 expectedJsonResponse: ResourceNotFoundJson,
1302         }
1303
1304         controllerGetNodebTestExecuter(t, &context)
1305 }
1306
1307 func TestControllerGetNodebInternal(t *testing.T) {
1308         ranName := "test"
1309         var nodebInfo *entities.NodebInfo
1310         context := controllerGetNodebTestContext{
1311                 ranName:              ranName,
1312                 nodebInfo:            nodebInfo,
1313                 rnibError:            common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
1314                 expectedStatusCode:   http.StatusInternalServerError,
1315                 expectedJsonResponse: RnibErrorJson,
1316         }
1317
1318         controllerGetNodebTestExecuter(t, &context)
1319 }
1320
1321 func TestControllerGetNodebIdListSuccess(t *testing.T) {
1322         var rnibError error
1323         nodebIdList := []*entities.NbIdentity{
1324                 {InventoryName: "test1", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}},
1325                 {InventoryName: "test2", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId2", NbId: "nbId2"}},
1326         }
1327
1328         context := controllerGetNodebIdListTestContext{
1329                 nodebIdList:          nodebIdList,
1330                 rnibError:            rnibError,
1331                 expectedStatusCode:   http.StatusOK,
1332                 expectedJsonResponse: "[{\"inventoryName\":\"test1\",\"globalNbId\":{\"plmnId\":\"plmnId1\",\"nbId\":\"nbId1\"}},{\"inventoryName\":\"test2\",\"globalNbId\":{\"plmnId\":\"plmnId2\",\"nbId\":\"nbId2\"}}]",
1333         }
1334
1335         controllerGetNodebIdListTestExecuter(t, &context)
1336 }
1337
1338 func TestControllerGetNodebIdListEmptySuccess(t *testing.T) {
1339         var rnibError error
1340         var nodebIdList []*entities.NbIdentity
1341
1342         context := controllerGetNodebIdListTestContext{
1343                 nodebIdList:          nodebIdList,
1344                 rnibError:            rnibError,
1345                 expectedStatusCode:   http.StatusOK,
1346                 expectedJsonResponse: "[]",
1347         }
1348
1349         controllerGetNodebIdListTestExecuter(t, &context)
1350 }
1351
1352 func TestControllerGetNodebIdListInternal(t *testing.T) {
1353         var nodebIdList []*entities.NbIdentity
1354         context := controllerGetNodebIdListTestContext{
1355                 nodebIdList:          nodebIdList,
1356                 rnibError:            common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
1357                 expectedStatusCode:   http.StatusInternalServerError,
1358                 expectedJsonResponse: RnibErrorJson,
1359         }
1360
1361         controllerGetNodebIdListTestExecuter(t, &context)
1362 }
1363
1364 func TestHeaderValidationFailed(t *testing.T) {
1365         controller, _, _, _, _ := setupControllerTest(t)
1366
1367         writer := httptest.NewRecorder()
1368
1369         header := &http.Header{}
1370
1371         controller.handleRequest(writer, header, httpmsghandlerprovider.ShutdownRequest, nil, true, 0)
1372
1373         var errorResponse = parseJsonRequest(t, writer.Body)
1374         err := e2managererrors.NewHeaderValidationError()
1375
1376         assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
1377         assert.Equal(t, errorResponse.Code, err.Code)
1378         assert.Equal(t, errorResponse.Message, err.Message)
1379 }
1380
1381 func TestShutdownStatusNoContent(t *testing.T) {
1382         controller, readerMock, _, _, e2tInstancesManagerMock := setupControllerTest(t)
1383         e2tInstancesManagerMock.On("GetE2TAddresses").Return([]string{}, nil)
1384         readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{}, nil)
1385
1386         writer := httptest.NewRecorder()
1387         controller.Shutdown(writer, tests.GetHttpRequest())
1388
1389         assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
1390 }
1391
1392 func TestHandleInternalError(t *testing.T) {
1393         controller, _, _, _, _ := setupControllerTest(t)
1394
1395         writer := httptest.NewRecorder()
1396         err := e2managererrors.NewInternalError()
1397
1398         controller.handleErrorResponse(err, writer)
1399         var errorResponse = parseJsonRequest(t, writer.Body)
1400
1401         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1402         assert.Equal(t, errorResponse.Code, err.Code)
1403         assert.Equal(t, errorResponse.Message, err.Message)
1404 }
1405
1406 func TestHandleCommandAlreadyInProgressError(t *testing.T) {
1407         controller, _, _, _, _ := setupControllerTest(t)
1408         writer := httptest.NewRecorder()
1409         err := e2managererrors.NewCommandAlreadyInProgressError()
1410
1411         controller.handleErrorResponse(err, writer)
1412         var errorResponse = parseJsonRequest(t, writer.Body)
1413
1414         assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
1415         assert.Equal(t, errorResponse.Code, err.Code)
1416         assert.Equal(t, errorResponse.Message, err.Message)
1417 }
1418
1419 func TestHandleRoutingManagerError(t *testing.T) {
1420         controller, _, _, _, _ := setupControllerTest(t)
1421         writer := httptest.NewRecorder()
1422         err := e2managererrors.NewRoutingManagerError()
1423
1424         controller.handleErrorResponse(err, writer)
1425         var errorResponse = parseJsonRequest(t, writer.Body)
1426
1427         assert.Equal(t, http.StatusServiceUnavailable, writer.Result().StatusCode)
1428         assert.Equal(t, errorResponse.Code, err.Code)
1429         assert.Equal(t, errorResponse.Message, err.Message)
1430 }
1431
1432 func TestHandleE2TInstanceAbsenceError(t *testing.T) {
1433         controller, _, _, _, _ := setupControllerTest(t)
1434
1435         writer := httptest.NewRecorder()
1436         err := e2managererrors.NewE2TInstanceAbsenceError()
1437
1438         controller.handleErrorResponse(err, writer)
1439         var errorResponse = parseJsonRequest(t, writer.Body)
1440
1441         assert.Equal(t, http.StatusServiceUnavailable, writer.Result().StatusCode)
1442         assert.Equal(t, errorResponse.Code, err.Code)
1443         assert.Equal(t, errorResponse.Message, err.Message)
1444 }
1445
1446 func TestValidateHeaders(t *testing.T) {
1447         controller, _, _, _, _ := setupControllerTest(t)
1448
1449         header := http.Header{}
1450         header.Set("Content-Type", "application/json")
1451         result := controller.validateRequestHeader(&header)
1452
1453         assert.Nil(t, result)
1454 }
1455
1456 func parseJsonRequest(t *testing.T, r io.Reader) models.ErrorResponse {
1457
1458         var errorResponse models.ErrorResponse
1459         body, err := ioutil.ReadAll(r)
1460         if err != nil {
1461                 t.Errorf("Error cannot deserialize json request")
1462         }
1463         _ = json.Unmarshal(body, &errorResponse)
1464
1465         return errorResponse
1466 }
1467
1468 func initLog(t *testing.T) *logger.Logger {
1469         log, err := logger.InitLogger(logger.InfoLevel)
1470         if err != nil {
1471                 t.Errorf("#delete_all_request_handler_test.TestHandleSuccessFlow - failed to initialize logger, error: %s", err)
1472         }
1473         return log
1474 }
1475
1476 func TestX2ResetHandleSuccessfulRequestedCause(t *testing.T) {
1477         controller, readerMock, _, rmrMessengerMock, _ := setupControllerTest(t)
1478
1479         ranName := "test1"
1480         payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x40}
1481         var xAction []byte
1482         var msgSrc unsafe.Pointer
1483         msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction, msgSrc)
1484         rmrMessengerMock.On("SendMsg", msg, mock.Anything).Return(msg, nil)
1485
1486         writer := httptest.NewRecorder()
1487
1488         var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
1489         readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
1490
1491         data4Req := map[string]interface{}{"cause": "protocol:transfer-syntax-error"}
1492         b := new(bytes.Buffer)
1493         _ = json.NewEncoder(b).Encode(data4Req)
1494         req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
1495         req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
1496
1497         controller.X2Reset(writer, req)
1498         assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
1499
1500 }
1501
1502 func TestX2ResetHandleSuccessfulRequestedDefault(t *testing.T) {
1503         controller, readerMock, _, rmrMessengerMock, _ := setupControllerTest(t)
1504
1505         ranName := "test1"
1506         // o&m intervention
1507         payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x64}
1508         var xAction []byte
1509         var msgSrc unsafe.Pointer
1510         msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction, msgSrc)
1511         rmrMessengerMock.On("SendMsg", msg, true).Return(msg, nil)
1512
1513         writer := httptest.NewRecorder()
1514
1515         var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
1516         readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
1517
1518         // no body
1519         b := new(bytes.Buffer)
1520         data4Req := map[string]interface{}{}
1521         _ = json.NewEncoder(b).Encode(data4Req)
1522         req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
1523         req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
1524
1525         controller.X2Reset(writer, req)
1526         assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
1527 }
1528
1529 func TestX2ResetHandleFailureInvalidBody(t *testing.T) {
1530         controller, _, _, _, _ := setupControllerTest(t)
1531
1532         ranName := "test1"
1533
1534         writer := httptest.NewRecorder()
1535
1536         // Invalid json: attribute name without quotes (should be "cause":).
1537         b := strings.NewReader("{cause:\"protocol:transfer-syntax-error\"")
1538         req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
1539         req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
1540
1541         controller.X2Reset(writer, req)
1542         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1543
1544 }
1545
1546 func TestHandleErrorResponse(t *testing.T) {
1547         controller, _, _, _, _ := setupControllerTest(t)
1548
1549         writer := httptest.NewRecorder()
1550         controller.handleErrorResponse(e2managererrors.NewRnibDbError(), writer)
1551         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1552
1553         writer = httptest.NewRecorder()
1554         controller.handleErrorResponse(e2managererrors.NewCommandAlreadyInProgressError(), writer)
1555         assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
1556
1557         writer = httptest.NewRecorder()
1558         controller.handleErrorResponse(e2managererrors.NewHeaderValidationError(), writer)
1559         assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
1560
1561         writer = httptest.NewRecorder()
1562         controller.handleErrorResponse(e2managererrors.NewWrongStateError("", ""), writer)
1563         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1564
1565         writer = httptest.NewRecorder()
1566         controller.handleErrorResponse(e2managererrors.NewRequestValidationError(), writer)
1567         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1568
1569         writer = httptest.NewRecorder()
1570         controller.handleErrorResponse(e2managererrors.NewRmrError(), writer)
1571         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1572
1573         writer = httptest.NewRecorder()
1574         controller.handleErrorResponse(e2managererrors.NewResourceNotFoundError(), writer)
1575         assert.Equal(t, http.StatusNotFound, writer.Result().StatusCode)
1576
1577         writer = httptest.NewRecorder()
1578         controller.handleErrorResponse(fmt.Errorf("ErrorError"), writer)
1579         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1580 }
1581
1582 func getRmrSender(rmrMessengerMock *mocks.RmrMessengerMock, log *logger.Logger) *rmrsender.RmrSender {
1583         rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
1584         rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
1585         return rmrsender.NewRmrSender(log, rmrMessenger)
1586 }