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