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) {
 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
 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, _, _, _ := setupControllerTest(t)
 391         writer := httptest.NewRecorder()
 392         readerMock.On("GetListNodebIds").Return(context.nodebIdList, context.rnibError)
 393         req, _ := http.NewRequest(http.MethodGet, "/nodeb/ids", nil)
 394         controller.GetNodebIdList(writer, req)
 395         assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
 396         bodyBytes, _ := ioutil.ReadAll(writer.Body)
 397         assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
 398 }
 399
 400 func activateControllerUpdateEnbMocks(context *controllerUpdateEnbTestContext, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock, updateEnbRequest *models.UpdateEnbRequest) {
 401         if context.getNodebInfoResult != nil {
 402                 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
 403         }
 404
 405         if context.removeServedCellsParams != nil {
 406                 writerMock.On("RemoveServedCells", RanName, context.removeServedCellsParams.servedCellInfo).Return(context.removeServedCellsParams.err)
 407         }
 408
 409         if context.updateEnbCellsParams != nil {
 410                 updatedNodebInfo := *context.getNodebInfoResult.nodebInfo
 411                 updatedNodebInfo.Configuration = &entities.NodebInfo_Enb{Enb: updateEnbRequest.Enb}
 412
 413                 writerMock.On("UpdateEnb", &updatedNodebInfo, updateEnbRequest.Enb.ServedCells).Return(context.updateEnbCellsParams.err)
 414         }
 415 }
 416
 417 func activateControllerUpdateGnbMocks(context *controllerUpdateGnbTestContext, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
 418         if context.getNodebInfoResult != nil {
 419                 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
 420         }
 421
 422         if context.removeServedNrCellsParams != nil {
 423                 writerMock.On("RemoveServedNrCells", RanName, context.removeServedNrCellsParams.servedNrCells).Return(context.removeServedNrCellsParams.err)
 424         }
 425
 426         if context.updateGnbCellsParams != nil {
 427                 updatedNodebInfo := *context.getNodebInfoResult.nodebInfo
 428                 gnb := entities.Gnb{}
 429                 _ = jsonpb.Unmarshal(getJsonRequestAsBuffer(context.requestBody), &gnb)
 430                 updatedGnb := *updatedNodebInfo.GetGnb()
 431                 updatedGnb.ServedNrCells = gnb.ServedNrCells
 432                 writerMock.On("UpdateGnbCells", &updatedNodebInfo, gnb.ServedNrCells).Return(context.updateGnbCellsParams.err)
 433         }
 434 }
 435
 436 func assertControllerUpdateGnb(t *testing.T, context *controllerUpdateGnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
 437         assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
 438         bodyBytes, _ := ioutil.ReadAll(writer.Body)
 439         assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
 440         readerMock.AssertExpectations(t)
 441         writerMock.AssertExpectations(t)
 442 }
 443
 444 func assertControllerUpdateEnb(t *testing.T, context *controllerUpdateEnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
 445         assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
 446         bodyBytes, _ := ioutil.ReadAll(writer.Body)
 447         assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
 448         readerMock.AssertExpectations(t)
 449         writerMock.AssertExpectations(t)
 450 }
 451
 452 func assertControllerAddEnb(t *testing.T, context *controllerAddEnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
 453         assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
 454         bodyBytes, _ := ioutil.ReadAll(writer.Body)
 455         assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
 456         readerMock.AssertExpectations(t)
 457         writerMock.AssertExpectations(t)
 458 }
 459
 460 func assertControllerDeleteEnb(t *testing.T, context *controllerDeleteEnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
 461         assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
 462         bodyBytes, _ := ioutil.ReadAll(writer.Body)
 463         assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
 464         readerMock.AssertExpectations(t)
 465         writerMock.AssertExpectations(t)
 466 }
 467
 468 func buildUpdateEnbRequest(context *controllerUpdateEnbTestContext) *http.Request {
 469         updateEnbUrl := fmt.Sprintf("/nodeb/enb/%s", RanName)
 470         requestBody := getJsonRequestAsBuffer(context.requestBody)
 471         req, _ := http.NewRequest(http.MethodPut, updateEnbUrl, requestBody)
 472         req.Header.Set("Content-Type", "application/json")
 473         req = mux.SetURLVars(req, map[string]string{"ranName": RanName})
 474         return req
 475 }
 476
 477 func buildUpdateGnbRequest(context *controllerUpdateGnbTestContext) *http.Request {
 478         updateGnbUrl := fmt.Sprintf("/nodeb/%s/update", RanName)
 479         requestBody := getJsonRequestAsBuffer(context.requestBody)
 480         req, _ := http.NewRequest(http.MethodPut, updateGnbUrl, requestBody)
 481         req.Header.Set("Content-Type", "application/json")
 482         req = mux.SetURLVars(req, map[string]string{"ranName": RanName})
 483         return req
 484 }
 485
 486 func buildAddEnbRequest(context *controllerAddEnbTestContext) *http.Request {
 487         requestBody := getJsonRequestAsBuffer(context.requestBody)
 488         req, _ := http.NewRequest(http.MethodPost, AddEnbUrl, requestBody)
 489         req.Header.Set("Content-Type", "application/json")
 490         return req
 491 }
 492
 493 func controllerUpdateEnbTestExecuter(t *testing.T, context *controllerUpdateEnbTestContext) {
 494         controller, readerMock, writerMock, _, _ := setupControllerTest(t)
 495         writer := httptest.NewRecorder()
 496
 497         r := buildUpdateEnbRequest(context)
 498         body, _ := ioutil.ReadAll(io.LimitReader(r.Body, LimitRequest))
 499
 500         updateEnbRequest := models.UpdateEnbRequest{}
 501         _ = json.Unmarshal(body, &updateEnbRequest)
 502
 503         activateControllerUpdateEnbMocks(context, readerMock, writerMock, &updateEnbRequest)
 504         r = buildUpdateEnbRequest(context)
 505         defer r.Body.Close()
 506
 507         controller.UpdateEnb(writer, r)
 508
 509         assertControllerUpdateEnb(t, context, writer, readerMock, writerMock)
 510 }
 511
 512 func controllerUpdateGnbTestExecuter(t *testing.T, context *controllerUpdateGnbTestContext) {
 513         controller, readerMock, writerMock, _, _ := setupControllerTest(t)
 514         writer := httptest.NewRecorder()
 515
 516         activateControllerUpdateGnbMocks(context, readerMock, writerMock)
 517         req := buildUpdateGnbRequest(context)
 518         controller.UpdateGnb(writer, req)
 519         assertControllerUpdateGnb(t, context, writer, readerMock, writerMock)
 520 }
 521
 522 func activateControllerAddEnbMocks(context *controllerAddEnbTestContext, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock, addEnbRequest *models.AddEnbRequest) {
 523         if context.getNodebInfoResult != nil {
 524                 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
 525         }
 526
 527         if context.saveNodebParams != nil {
 528                 nodebInfo := entities.NodebInfo{
 529                         RanName:          addEnbRequest.RanName,
 530                         Ip:               addEnbRequest.Ip,
 531                         Port:             addEnbRequest.Port,
 532                         NodeType:         entities.Node_ENB,
 533                         GlobalNbId:       addEnbRequest.GlobalNbId,
 534                         Configuration:    &entities.NodebInfo_Enb{Enb: addEnbRequest.Enb},
 535                         ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,
 536                 }
 537
 538                 writerMock.On("SaveNodeb", &nodebInfo).Return(context.saveNodebParams.err)
 539         }
 540
 541         if context.addNbIdentityParams != nil {
 542                 nbIdentity := entities.NbIdentity{InventoryName: addEnbRequest.RanName, GlobalNbId: addEnbRequest.GlobalNbId, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED}
 543                 writerMock.On("AddNbIdentity", entities.Node_ENB, &nbIdentity).Return(context.addNbIdentityParams.err)
 544         }
 545 }
 546
 547 func controllerAddEnbTestExecuter(t *testing.T, context *controllerAddEnbTestContext) {
 548         controller, readerMock, writerMock, _, _ := setupControllerTest(t)
 549         writer := httptest.NewRecorder()
 550         r := buildAddEnbRequest(context)
 551         body, _ := ioutil.ReadAll(io.LimitReader(r.Body, LimitRequest))
 552
 553         addEnbRequest := models.AddEnbRequest{}
 554
 555         _ = json.Unmarshal(body, &addEnbRequest)
 556         activateControllerAddEnbMocks(context, readerMock, writerMock, &addEnbRequest)
 557         r = buildAddEnbRequest(context)
 558         defer r.Body.Close()
 559         controller.AddEnb(writer, r)
 560         assertControllerAddEnb(t, context, writer, readerMock, writerMock)
 561 }
 562
 563 func controllerDeleteEnbTestExecuter(t *testing.T, context *controllerDeleteEnbTestContext) {
 564         controller, readerMock, writerMock, _, _ := setupControllerTest(t)
 565         readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
 566         if context.getNodebInfoResult.rnibError == nil && context.getNodebInfoResult.nodebInfo.GetNodeType() == entities.Node_ENB {
 567                 writerMock.On("RemoveEnb", context.getNodebInfoResult.nodebInfo).Return(nil)
 568         }
 569         writer := httptest.NewRecorder()
 570         r, _ := http.NewRequest(http.MethodDelete, AddEnbUrl+"/"+RanName, nil)
 571         r.Header.Set("Content-Type", "application/json")
 572         r = mux.SetURLVars(r, map[string]string{"ranName": RanName})
 573         controller.DeleteEnb(writer, r)
 574         assertControllerDeleteEnb(t, context, writer, readerMock, writerMock)
 575 }
 576
 577 func TestControllerUpdateGnbEmptyServedNrCells(t *testing.T) {
 578         context := controllerUpdateGnbTestContext{
 579                 getNodebInfoResult: nil,
 580                 requestBody: map[string]interface{}{
 581                         "servedNrCells": []interface{}{
 582                         },
 583                 },
 584                 expectedStatusCode:   http.StatusBadRequest,
 585                 expectedJsonResponse: ValidationFailureJson,
 586         }
 587
 588         controllerUpdateGnbTestExecuter(t, &context)
 589 }
 590
 591 func TestControllerUpdateGnbMissingServedNrCellInformation(t *testing.T) {
 592         context := controllerUpdateGnbTestContext{
 593                 getNodebInfoResult: nil,
 594                 requestBody: map[string]interface{}{
 595                         "servedNrCells": []interface{}{
 596                                 map[string]interface{}{
 597                                         "servedNrCellInformation": nil,
 598                                 },
 599                         },
 600                 },
 601                 expectedStatusCode:   http.StatusBadRequest,
 602                 expectedJsonResponse: ValidationFailureJson,
 603         }
 604
 605         controllerUpdateGnbTestExecuter(t, &context)
 606 }
 607
 608 func TestControllerUpdateGnbMissingServedNrCellRequiredProp(t *testing.T) {
 609
 610         for _, v := range ServedNrCellInformationRequiredFields {
 611                 context := controllerUpdateGnbTestContext{
 612                         getNodebInfoResult: nil,
 613                         requestBody: map[string]interface{}{
 614                                 "servedNrCells": []interface{}{
 615                                         map[string]interface{}{
 616                                                 "servedNrCellInformation": buildServedNrCellInformation(v),
 617                                         },
 618                                 },
 619                         },
 620                         expectedStatusCode:   http.StatusBadRequest,
 621                         expectedJsonResponse: ValidationFailureJson,
 622                 }
 623
 624                 controllerUpdateGnbTestExecuter(t, &context)
 625         }
 626 }
 627
 628 func TestControllerUpdateGnbMissingServedNrCellFddOrTdd(t *testing.T) {
 629
 630         servedNrCellInformation := buildServedNrCellInformation("")
 631         servedNrCellInformation["choiceNrMode"] = map[string]interface{}{}
 632
 633         context := controllerUpdateGnbTestContext{
 634                 getNodebInfoResult: nil,
 635                 requestBody: map[string]interface{}{
 636                         "servedNrCells": []interface{}{
 637                                 map[string]interface{}{
 638                                         "servedNrCellInformation": servedNrCellInformation,
 639                                 },
 640                         },
 641                 },
 642                 expectedStatusCode:   http.StatusBadRequest,
 643                 expectedJsonResponse: ValidationFailureJson,
 644         }
 645
 646         controllerUpdateGnbTestExecuter(t, &context)
 647 }
 648
 649 func TestControllerUpdateGnbMissingNeighbourInfoFddOrTdd(t *testing.T) {
 650
 651         nrNeighbourInfo := buildNrNeighbourInformation("")
 652         nrNeighbourInfo["choiceNrMode"] = map[string]interface{}{}
 653
 654         context := controllerUpdateGnbTestContext{
 655                 getNodebInfoResult: nil,
 656                 requestBody: map[string]interface{}{
 657                         "servedNrCells": []interface{}{
 658                                 map[string]interface{}{
 659                                         "servedNrCellInformation": buildServedNrCellInformation(""),
 660                                         "nrNeighbourInfos": []interface{}{
 661                                                 nrNeighbourInfo,
 662                                         },
 663                                 },
 664                         },
 665                 },
 666                 expectedStatusCode:   http.StatusBadRequest,
 667                 expectedJsonResponse: ValidationFailureJson,
 668         }
 669
 670         controllerUpdateGnbTestExecuter(t, &context)
 671 }
 672
 673 func TestControllerUpdateGnbMissingNrNeighbourInformationRequiredProp(t *testing.T) {
 674
 675         for _, v := range NrNeighbourInformationRequiredFields {
 676                 context := controllerUpdateGnbTestContext{
 677                         getNodebInfoResult: nil,
 678                         requestBody: map[string]interface{}{
 679                                 "servedNrCells": []interface{}{
 680                                         map[string]interface{}{
 681                                                 "servedNrCellInformation": buildServedNrCellInformation(""),
 682                                                 "nrNeighbourInfos": []interface{}{
 683                                                         buildNrNeighbourInformation(v),
 684                                                 },
 685                                         },
 686                                 },
 687                         },
 688                         expectedStatusCode:   http.StatusBadRequest,
 689                         expectedJsonResponse: ValidationFailureJson,
 690                 }
 691
 692                 controllerUpdateGnbTestExecuter(t, &context)
 693         }
 694 }
 695
 696 func TestControllerUpdateGnbValidServedNrCellInformationGetNodebNotFound(t *testing.T) {
 697         context := controllerUpdateGnbTestContext{
 698                 getNodebInfoResult: &getNodebInfoResult{
 699                         nodebInfo: nil,
 700                         rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
 701                 },
 702                 requestBody: map[string]interface{}{
 703                         "servedNrCells": []interface{}{
 704                                 map[string]interface{}{
 705                                         "servedNrCellInformation": buildServedNrCellInformation(""),
 706                                 },
 707                         },
 708                 },
 709                 expectedStatusCode:   http.StatusNotFound,
 710                 expectedJsonResponse: ResourceNotFoundJson,
 711         }
 712
 713         controllerUpdateGnbTestExecuter(t, &context)
 714 }
 715
 716 func TestControllerUpdateGnbValidServedNrCellInformationGetNodebInternalError(t *testing.T) {
 717         context := controllerUpdateGnbTestContext{
 718                 getNodebInfoResult: &getNodebInfoResult{
 719                         nodebInfo: nil,
 720                         rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
 721                 },
 722                 requestBody: map[string]interface{}{
 723                         "servedNrCells": []interface{}{
 724                                 map[string]interface{}{
 725                                         "servedNrCellInformation": buildServedNrCellInformation(""),
 726                                 },
 727                         },
 728                 },
 729                 expectedStatusCode:   http.StatusInternalServerError,
 730                 expectedJsonResponse: RnibErrorJson,
 731         }
 732
 733         controllerUpdateGnbTestExecuter(t, &context)
 734 }
 735
 736 func TestControllerUpdateGnbGetNodebSuccessInvalidGnbConfiguration(t *testing.T) {
 737         context := controllerUpdateGnbTestContext{
 738                 getNodebInfoResult: &getNodebInfoResult{
 739                         nodebInfo: &entities.NodebInfo{
 740                                 RanName:                      RanName,
 741                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
 742                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
 743                         },
 744                         rnibError: nil,
 745                 },
 746                 requestBody: map[string]interface{}{
 747                         "servedNrCells": []interface{}{
 748                                 map[string]interface{}{
 749                                         "servedNrCellInformation": buildServedNrCellInformation(""),
 750                                         "nrNeighbourInfos": []interface{}{
 751                                                 buildNrNeighbourInformation(""),
 752                                         },
 753                                 },
 754                         },
 755                 },
 756                 expectedStatusCode:   http.StatusInternalServerError,
 757                 expectedJsonResponse: InternalErrorJson,
 758         }
 759
 760         controllerUpdateGnbTestExecuter(t, &context)
 761 }
 762
 763 func TestControllerUpdateGnbGetNodebSuccessRemoveServedNrCellsFailure(t *testing.T) {
 764         oldServedNrCells := generateServedNrCells("whatever1", "whatever2")
 765         context := controllerUpdateGnbTestContext{
 766                 removeServedNrCellsParams: &removeServedNrCellsParams{
 767                         err:           common.NewInternalError(errors.New("#writer.UpdateGnbCells - Internal Error")),
 768                         servedNrCells: oldServedNrCells,
 769                 },
 770                 getNodebInfoResult: &getNodebInfoResult{
 771                         nodebInfo: &entities.NodebInfo{
 772                                 RanName:                      RanName,
 773                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
 774                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
 775                                 Configuration:                &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{ServedNrCells: oldServedNrCells}},
 776                         },
 777                         rnibError: nil,
 778                 },
 779                 requestBody: map[string]interface{}{
 780                         "servedNrCells": []interface{}{
 781                                 map[string]interface{}{
 782                                         "servedNrCellInformation": buildServedNrCellInformation(""),
 783                                         "nrNeighbourInfos": []interface{}{
 784                                                 buildNrNeighbourInformation(""),
 785                                         },
 786                                 },
 787                         },
 788                 },
 789                 expectedStatusCode:   http.StatusInternalServerError,
 790                 expectedJsonResponse: RnibErrorJson,
 791         }
 792
 793         controllerUpdateGnbTestExecuter(t, &context)
 794 }
 795
 796 func TestControllerUpdateGnbGetNodebSuccessUpdateGnbCellsFailure(t *testing.T) {
 797         oldServedNrCells := generateServedNrCells("whatever1", "whatever2")
 798         context := controllerUpdateGnbTestContext{
 799                 removeServedNrCellsParams: &removeServedNrCellsParams{
 800                         err:           nil,
 801                         servedNrCells: oldServedNrCells,
 802                 },
 803                 updateGnbCellsParams: &updateGnbCellsParams{
 804                         err: common.NewInternalError(errors.New("#writer.UpdateGnbCells - Internal Error")),
 805                 },
 806                 getNodebInfoResult: &getNodebInfoResult{
 807                         nodebInfo: &entities.NodebInfo{
 808                                 RanName:                      RanName,
 809                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
 810                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
 811                                 Configuration:                &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{ServedNrCells: oldServedNrCells}},
 812                         },
 813                         rnibError: nil,
 814                 },
 815                 requestBody: map[string]interface{}{
 816                         "servedNrCells": []interface{}{
 817                                 map[string]interface{}{
 818                                         "servedNrCellInformation": buildServedNrCellInformation(""),
 819                                         "nrNeighbourInfos": []interface{}{
 820                                                 buildNrNeighbourInformation(""),
 821                                         },
 822                                 },
 823                         },
 824                 },
 825                 expectedStatusCode:   http.StatusInternalServerError,
 826                 expectedJsonResponse: RnibErrorJson,
 827         }
 828
 829         controllerUpdateGnbTestExecuter(t, &context)
 830 }
 831
 832 func TestControllerUpdateGnbSuccess(t *testing.T) {
 833         context := controllerUpdateGnbTestContext{
 834                 updateGnbCellsParams: &updateGnbCellsParams{
 835                         err: nil,
 836                 },
 837                 getNodebInfoResult: &getNodebInfoResult{
 838                         nodebInfo: &entities.NodebInfo{
 839                                 RanName:                      RanName,
 840                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
 841                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
 842                                 Configuration:                &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{}},
 843                         },
 844                         rnibError: nil,
 845                 },
 846                 requestBody: map[string]interface{}{
 847                         "servedNrCells": []interface{}{
 848                                 map[string]interface{}{
 849                                         "servedNrCellInformation": buildServedNrCellInformation(""),
 850                                         "nrNeighbourInfos": []interface{}{
 851                                                 buildNrNeighbourInformation(""),
 852                                         },
 853                                 },
 854                         },
 855                 },
 856                 expectedStatusCode:   http.StatusOK,
 857                 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\"}",
 858         }
 859
 860         controllerUpdateGnbTestExecuter(t, &context)
 861 }
 862
 863 func TestControllerUpdateEnbInvalidRequest(t *testing.T) {
 864         controller, _, _, _, _ := setupControllerTest(t)
 865
 866         writer := httptest.NewRecorder()
 867         invalidJson := strings.NewReader("{enb:\"whatever\"")
 868
 869         updateEnbUrl := fmt.Sprintf("/nodeb/enb/%s", RanName)
 870         req, _ := http.NewRequest(http.MethodPut, updateEnbUrl, invalidJson)
 871         req.Header.Set("Content-Type", "application/json")
 872         req = mux.SetURLVars(req, map[string]string{"ranName": RanName})
 873
 874         controller.UpdateEnb(writer, req)
 875
 876         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
 877         bodyBytes, _ := ioutil.ReadAll(writer.Body)
 878         assert.Equal(t, CorruptedJson, string(bodyBytes))
 879 }
 880
 881 func TestControllerUpdateEnbEmptyEnbType(t *testing.T) {
 882         context := controllerUpdateEnbTestContext{
 883                 getNodebInfoResult:   nil,
 884                 requestBody:          getUpdateEnbRequest(EnbRequiredFields[0]),
 885                 expectedStatusCode:   http.StatusBadRequest,
 886                 expectedJsonResponse: ValidationFailureJson,
 887         }
 888
 889         controllerUpdateEnbTestExecuter(t, &context)
 890 }
 891
 892 func TestControllerUpdateEnbEmptyServedCells(t *testing.T) {
 893         context := controllerUpdateEnbTestContext{
 894                 getNodebInfoResult:   nil,
 895                 requestBody:          getUpdateEnbRequest(EnbRequiredFields[1]),
 896                 expectedStatusCode:   http.StatusBadRequest,
 897                 expectedJsonResponse: ValidationFailureJson,
 898         }
 899
 900         controllerUpdateEnbTestExecuter(t, &context)
 901 }
 902
 903 func TestControllerUpdateEnbMissingEnb(t *testing.T) {
 904         context := controllerUpdateEnbTestContext{
 905                 getNodebInfoResult:   nil,
 906                 requestBody:          getUpdateEnbRequest(UpdateEnbRequestRequiredFields[0]),
 907                 expectedStatusCode:   http.StatusBadRequest,
 908                 expectedJsonResponse: ValidationFailureJson,
 909         }
 910
 911         controllerUpdateEnbTestExecuter(t, &context)
 912 }
 913
 914 func TestControllerUpdateEnbValidServedCellsGetNodebNotFound(t *testing.T) {
 915         context := controllerUpdateEnbTestContext{
 916                 getNodebInfoResult: &getNodebInfoResult{
 917                         nodebInfo: nil,
 918                         rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
 919                 },
 920                 requestBody:          getUpdateEnbRequest(""),
 921                 expectedStatusCode:   http.StatusNotFound,
 922                 expectedJsonResponse: ResourceNotFoundJson,
 923         }
 924
 925         controllerUpdateEnbTestExecuter(t, &context)
 926 }
 927
 928 func TestControllerUpdateEnbValidServedCellsGetNodebInternalError(t *testing.T) {
 929         context := controllerUpdateEnbTestContext{
 930                 getNodebInfoResult: &getNodebInfoResult{
 931                         nodebInfo: nil,
 932                         rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
 933                 },
 934                 requestBody:          getUpdateEnbRequest(""),
 935                 expectedStatusCode:   http.StatusInternalServerError,
 936                 expectedJsonResponse: RnibErrorJson,
 937         }
 938
 939         controllerUpdateEnbTestExecuter(t, &context)
 940 }
 941
 942 func TestControllerUpdateEnbGetNodebSuccessGnbTypeFailure(t *testing.T) {
 943         oldServedCells := generateServedCells("whatever1", "whatever2")
 944         context := controllerUpdateEnbTestContext{
 945                 getNodebInfoResult: &getNodebInfoResult{
 946                         nodebInfo: &entities.NodebInfo{
 947                                 RanName:                      RanName,
 948                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
 949                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
 950                                 NodeType:                     entities.Node_GNB,
 951                                 Configuration:                &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells}},
 952                         },
 953                         rnibError: nil,
 954                 },
 955                 requestBody:          getUpdateEnbRequest(""),
 956                 expectedStatusCode:   http.StatusBadRequest,
 957                 expectedJsonResponse: ValidationFailureJson,
 958         }
 959
 960         controllerUpdateEnbTestExecuter(t, &context)
 961 }
 962
 963 func TestControllerUpdateEnbGetNodebSuccessRemoveServedCellsFailure(t *testing.T) {
 964         oldServedCells := generateServedCells("whatever1", "whatever2")
 965         context := controllerUpdateEnbTestContext{
 966                 removeServedCellsParams: &removeServedCellsParams{
 967                         err:            common.NewInternalError(errors.New("#writer.RemoveServedCells - Internal Error")),
 968                         servedCellInfo: oldServedCells,
 969                 },
 970                 getNodebInfoResult: &getNodebInfoResult{
 971                         nodebInfo: &entities.NodebInfo{
 972                                 RanName:                      RanName,
 973                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
 974                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
 975                                 NodeType:                     entities.Node_ENB,
 976                                 Configuration:                &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells}},
 977                         },
 978                         rnibError: nil,
 979                 },
 980                 requestBody:          getUpdateEnbRequest(""),
 981                 expectedStatusCode:   http.StatusInternalServerError,
 982                 expectedJsonResponse: RnibErrorJson,
 983         }
 984
 985         controllerUpdateEnbTestExecuter(t, &context)
 986 }
 987
 988 func TestControllerUpdateEnbGetNodebSuccessUpdateEnbFailure(t *testing.T) {
 989         oldServedCells := generateServedCells("whatever1", "whatever2")
 990         context := controllerUpdateEnbTestContext{
 991                 removeServedCellsParams: &removeServedCellsParams{
 992                         err:            nil,
 993                         servedCellInfo: oldServedCells,
 994                 },
 995                 updateEnbCellsParams: &updateEnbCellsParams{
 996                         err: common.NewInternalError(errors.New("#writer.UpdateEnb - Internal Error")),
 997                 },
 998                 getNodebInfoResult: &getNodebInfoResult{
 999                         nodebInfo: &entities.NodebInfo{
1000                                 RanName:                      RanName,
1001                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
1002                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1003                                 NodeType:                     entities.Node_ENB,
1004                                 Configuration:                &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells, EnbType: entities.EnbType_MACRO_ENB}},
1005                         },
1006                         rnibError: nil,
1007                 },
1008                 requestBody:          getUpdateEnbRequest(""),
1009                 expectedStatusCode:   http.StatusInternalServerError,
1010                 expectedJsonResponse: RnibErrorJson,
1011         }
1012
1013         controllerUpdateEnbTestExecuter(t, &context)
1014 }
1015
1016 func TestControllerUpdateEnbSuccess(t *testing.T) {
1017         oldServedCells := generateServedCells("whatever1", "whatever2")
1018         context := controllerUpdateEnbTestContext{
1019                 removeServedCellsParams: &removeServedCellsParams{
1020                         err:            nil,
1021                         servedCellInfo: oldServedCells,
1022                 },
1023                 updateEnbCellsParams: &updateEnbCellsParams{
1024                         err: nil,
1025                 },
1026                 getNodebInfoResult: &getNodebInfoResult{
1027                         nodebInfo: &entities.NodebInfo{
1028                                 RanName:                      RanName,
1029                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
1030                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1031                                 NodeType:                     entities.Node_ENB,
1032                                 Configuration:                &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells, EnbType: entities.EnbType_MACRO_ENB}},
1033                         },
1034                         rnibError: nil,
1035                 },
1036                 requestBody:          getUpdateEnbRequest(""),
1037                 expectedStatusCode:   http.StatusOK,
1038                 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\"}",
1039         }
1040
1041         controllerUpdateEnbTestExecuter(t, &context)
1042 }
1043
1044 func TestControllerAddEnbGetNodebInternalError(t *testing.T) {
1045         context := controllerAddEnbTestContext{
1046                 getNodebInfoResult: &getNodebInfoResult{
1047                         nodebInfo: nil,
1048                         rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
1049                 },
1050                 requestBody:          getAddEnbRequest(""),
1051                 expectedStatusCode:   http.StatusInternalServerError,
1052                 expectedJsonResponse: RnibErrorJson,
1053         }
1054
1055         controllerAddEnbTestExecuter(t, &context)
1056 }
1057
1058 func TestControllerAddEnbNodebExistsFailure(t *testing.T) {
1059         context := controllerAddEnbTestContext{
1060                 getNodebInfoResult: &getNodebInfoResult{
1061                         nodebInfo: &entities.NodebInfo{},
1062                         rnibError: nil,
1063                 },
1064                 requestBody:          getAddEnbRequest(""),
1065                 expectedStatusCode:   http.StatusBadRequest,
1066                 expectedJsonResponse: NodebExistsJson,
1067         }
1068
1069         controllerAddEnbTestExecuter(t, &context)
1070 }
1071
1072 func TestControllerAddEnbSaveNodebFailure(t *testing.T) {
1073         context := controllerAddEnbTestContext{
1074                 saveNodebParams: &saveNodebParams{
1075                         err: common.NewInternalError(errors.New("#reader.SaveeNodeb - Internal Error")),
1076                 },
1077                 getNodebInfoResult: &getNodebInfoResult{
1078                         nodebInfo: nil,
1079                         rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1080                 },
1081                 requestBody:          getAddEnbRequest(""),
1082                 expectedStatusCode:   http.StatusInternalServerError,
1083                 expectedJsonResponse: RnibErrorJson,
1084         }
1085
1086         controllerAddEnbTestExecuter(t, &context)
1087 }
1088
1089 func TestControllerAddEnbAddNbIdentityFailure(t *testing.T) {
1090         context := controllerAddEnbTestContext{
1091                 saveNodebParams: &saveNodebParams{
1092                         err: nil,
1093                 },
1094                 addNbIdentityParams: &addNbIdentityParams{
1095                         err: common.NewInternalError(errors.New("#writer.addNbIdentity - Internal Error")),
1096                 },
1097                 getNodebInfoResult: &getNodebInfoResult{
1098                         nodebInfo: nil,
1099                         rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1100                 },
1101                 requestBody:          getAddEnbRequest(""),
1102                 expectedStatusCode:   http.StatusInternalServerError,
1103                 expectedJsonResponse: RnibErrorJson,
1104         }
1105
1106         controllerAddEnbTestExecuter(t, &context)
1107 }
1108
1109 func TestControllerAddEnbMissingRequiredRequestProps(t *testing.T) {
1110
1111         for _, v := range AddEnbRequestRequiredFields {
1112                 context := controllerAddEnbTestContext{
1113                         requestBody:          getAddEnbRequest(v),
1114                         expectedStatusCode:   http.StatusBadRequest,
1115                         expectedJsonResponse: ValidationFailureJson,
1116                 }
1117
1118                 controllerAddEnbTestExecuter(t, &context)
1119         }
1120 }
1121
1122 func TestControllerAddEnbInvalidRequest(t *testing.T) {
1123         controller, _, _, _, _ := setupControllerTest(t)
1124         writer := httptest.NewRecorder()
1125
1126         // Invalid json: attribute name without quotes (should be "cause":).
1127         invalidJson := strings.NewReader("{ranName:\"whatever\"")
1128         req, _ := http.NewRequest(http.MethodPost, AddEnbUrl, invalidJson)
1129
1130         controller.AddEnb(writer, req)
1131         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1132         bodyBytes, _ := ioutil.ReadAll(writer.Body)
1133         assert.Equal(t, CorruptedJson, string(bodyBytes))
1134
1135 }
1136
1137 func TestControllerAddEnbMissingRequiredGlobalNbIdProps(t *testing.T) {
1138
1139         r := getAddEnbRequest("")
1140
1141         for _, v := range GlobalIdRequiredFields {
1142                 r["globalNbId"] = buildGlobalNbId(v)
1143
1144                 context := controllerAddEnbTestContext{
1145                         requestBody:          r,
1146                         expectedStatusCode:   http.StatusBadRequest,
1147                         expectedJsonResponse: ValidationFailureJson,
1148                 }
1149
1150                 controllerAddEnbTestExecuter(t, &context)
1151         }
1152 }
1153
1154 func TestControllerAddEnbMissingRequiredEnbProps(t *testing.T) {
1155
1156         r := getAddEnbRequest("")
1157
1158         for _, v := range EnbRequiredFields {
1159                 r["enb"] = buildEnb(v)
1160
1161                 context := controllerAddEnbTestContext{
1162                         requestBody:          r,
1163                         expectedStatusCode:   http.StatusBadRequest,
1164                         expectedJsonResponse: ValidationFailureJson,
1165                 }
1166
1167                 controllerAddEnbTestExecuter(t, &context)
1168         }
1169 }
1170
1171 func TestControllerUpdateEnbMissingRequiredServedCellProps(t *testing.T) {
1172
1173         r := getUpdateEnbRequest("")
1174
1175         for _, v := range ServedCellRequiredFields {
1176                 enb := r["enb"]
1177
1178                 enbMap, _ := enb.(map[string]interface{})
1179
1180                 enbMap["servedCells"] = []interface{}{
1181                         buildServedCell(v),
1182                 }
1183
1184                 context := controllerUpdateEnbTestContext{
1185                         requestBody:          r,
1186                         expectedStatusCode:   http.StatusBadRequest,
1187                         expectedJsonResponse: ValidationFailureJson,
1188                 }
1189
1190                 controllerUpdateEnbTestExecuter(t, &context)
1191         }
1192 }
1193
1194 func TestControllerAddEnbMissingRequiredServedCellProps(t *testing.T) {
1195
1196         r := getAddEnbRequest("")
1197
1198         for _, v := range ServedCellRequiredFields {
1199                 enb := r["enb"]
1200
1201                 enbMap, _ := enb.(map[string]interface{})
1202
1203                 enbMap["servedCells"] = []interface{}{
1204                         buildServedCell(v),
1205                 }
1206
1207                 context := controllerAddEnbTestContext{
1208                         requestBody:          r,
1209                         expectedStatusCode:   http.StatusBadRequest,
1210                         expectedJsonResponse: ValidationFailureJson,
1211                 }
1212
1213                 controllerAddEnbTestExecuter(t, &context)
1214         }
1215 }
1216
1217 func TestControllerAddEnbSuccess(t *testing.T) {
1218         context := controllerAddEnbTestContext{
1219                 saveNodebParams: &saveNodebParams{
1220                         err: nil,
1221                 },
1222                 addNbIdentityParams: &addNbIdentityParams{
1223                         err: nil,
1224                 },
1225                 getNodebInfoResult: &getNodebInfoResult{
1226                         nodebInfo: nil,
1227                         rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1228                 },
1229                 requestBody:          getAddEnbRequest(""),
1230                 expectedStatusCode:   http.StatusCreated,
1231                 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\"}]}}",
1232         }
1233
1234         controllerAddEnbTestExecuter(t, &context)
1235 }
1236
1237 func TestControllerDeleteEnbGetNodebInternalError(t *testing.T) {
1238         context := controllerDeleteEnbTestContext{
1239                 getNodebInfoResult: &getNodebInfoResult{
1240                         nodebInfo: nil,
1241                         rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
1242                 },
1243                 expectedStatusCode:   http.StatusInternalServerError,
1244                 expectedJsonResponse: RnibErrorJson,
1245         }
1246
1247         controllerDeleteEnbTestExecuter(t, &context)
1248 }
1249
1250 func TestControllerDeleteEnbNodebNotExistsFailure(t *testing.T) {
1251         context := controllerDeleteEnbTestContext{
1252                 getNodebInfoResult: &getNodebInfoResult{
1253                         nodebInfo: nil,
1254                         rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found"),
1255                 },
1256                 expectedStatusCode:   http.StatusNotFound,
1257                 expectedJsonResponse: ResourceNotFoundJson,
1258         }
1259
1260         controllerDeleteEnbTestExecuter(t, &context)
1261 }
1262
1263 func TestControllerDeleteEnbNodebNotEnb(t *testing.T) {
1264         context := controllerDeleteEnbTestContext{
1265                 getNodebInfoResult: &getNodebInfoResult{
1266                         nodebInfo: &entities.NodebInfo{RanName: "ran1", NodeType: entities.Node_GNB, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED},
1267                         rnibError: nil,
1268                 },
1269                 expectedStatusCode:   http.StatusBadRequest,
1270                 expectedJsonResponse: ValidationFailureJson,
1271         }
1272
1273         controllerDeleteEnbTestExecuter(t, &context)
1274 }
1275
1276 func TestControllerDeleteEnbSuccess(t *testing.T) {
1277         context := controllerDeleteEnbTestContext{
1278                 getNodebInfoResult: &getNodebInfoResult{
1279                         nodebInfo: &entities.NodebInfo{RanName: "ran1", NodeType: entities.Node_ENB, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED},
1280                         rnibError: nil,
1281                 },
1282                 expectedStatusCode:   http.StatusNoContent,
1283                 expectedJsonResponse: "",
1284         }
1285         controllerDeleteEnbTestExecuter(t, &context)
1286 }
1287
1288 func getJsonRequestAsBuffer(requestJson map[string]interface{}) *bytes.Buffer {
1289         b := new(bytes.Buffer)
1290         _ = json.NewEncoder(b).Encode(requestJson)
1291         return b
1292 }
1293
1294 func TestControllerGetNodebSuccess(t *testing.T) {
1295         ranName := "test"
1296         var rnibError error
1297         context := controllerGetNodebTestContext{
1298                 ranName:              ranName,
1299                 nodebInfo:            &entities.NodebInfo{RanName: ranName, Ip: "10.0.2.15", Port: 1234},
1300                 rnibError:            rnibError,
1301                 expectedStatusCode:   http.StatusOK,
1302                 expectedJsonResponse: fmt.Sprintf("{\"ranName\":\"%s\",\"ip\":\"10.0.2.15\",\"port\":1234}", ranName),
1303         }
1304
1305         controllerGetNodebTestExecuter(t, &context)
1306 }
1307
1308 func TestControllerGetNodebNotFound(t *testing.T) {
1309
1310         ranName := "test"
1311         var nodebInfo *entities.NodebInfo
1312         context := controllerGetNodebTestContext{
1313                 ranName:              ranName,
1314                 nodebInfo:            nodebInfo,
1315                 rnibError:            common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1316                 expectedStatusCode:   http.StatusNotFound,
1317                 expectedJsonResponse: ResourceNotFoundJson,
1318         }
1319
1320         controllerGetNodebTestExecuter(t, &context)
1321 }
1322
1323 func TestControllerGetNodebInternal(t *testing.T) {
1324         ranName := "test"
1325         var nodebInfo *entities.NodebInfo
1326         context := controllerGetNodebTestContext{
1327                 ranName:              ranName,
1328                 nodebInfo:            nodebInfo,
1329                 rnibError:            common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
1330                 expectedStatusCode:   http.StatusInternalServerError,
1331                 expectedJsonResponse: RnibErrorJson,
1332         }
1333
1334         controllerGetNodebTestExecuter(t, &context)
1335 }
1336
1337 func TestControllerGetNodebIdListSuccess(t *testing.T) {
1338         var rnibError error
1339         nodebIdList := []*entities.NbIdentity{
1340                 {InventoryName: "test1", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}},
1341                 {InventoryName: "test2", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId2", NbId: "nbId2"}},
1342         }
1343
1344         context := controllerGetNodebIdListTestContext{
1345                 nodebIdList:          nodebIdList,
1346                 rnibError:            rnibError,
1347                 expectedStatusCode:   http.StatusOK,
1348                 expectedJsonResponse: "[{\"inventoryName\":\"test1\",\"globalNbId\":{\"plmnId\":\"plmnId1\",\"nbId\":\"nbId1\"}},{\"inventoryName\":\"test2\",\"globalNbId\":{\"plmnId\":\"plmnId2\",\"nbId\":\"nbId2\"}}]",
1349         }
1350
1351         controllerGetNodebIdListTestExecuter(t, &context)
1352 }
1353
1354 func TestControllerGetNodebIdListEmptySuccess(t *testing.T) {
1355         var rnibError error
1356         var nodebIdList []*entities.NbIdentity
1357
1358         context := controllerGetNodebIdListTestContext{
1359                 nodebIdList:          nodebIdList,
1360                 rnibError:            rnibError,
1361                 expectedStatusCode:   http.StatusOK,
1362                 expectedJsonResponse: "[]",
1363         }
1364
1365         controllerGetNodebIdListTestExecuter(t, &context)
1366 }
1367
1368 func TestControllerGetNodebIdListInternal(t *testing.T) {
1369         var nodebIdList []*entities.NbIdentity
1370         context := controllerGetNodebIdListTestContext{
1371                 nodebIdList:          nodebIdList,
1372                 rnibError:            common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
1373                 expectedStatusCode:   http.StatusInternalServerError,
1374                 expectedJsonResponse: RnibErrorJson,
1375         }
1376
1377         controllerGetNodebIdListTestExecuter(t, &context)
1378 }
1379
1380 func TestHeaderValidationFailed(t *testing.T) {
1381         controller, _, _, _, _ := setupControllerTest(t)
1382
1383         writer := httptest.NewRecorder()
1384
1385         header := &http.Header{}
1386
1387         controller.handleRequest(writer, header, httpmsghandlerprovider.ShutdownRequest, nil, true, 0)
1388
1389         var errorResponse = parseJsonRequest(t, writer.Body)
1390         err := e2managererrors.NewHeaderValidationError()
1391
1392         assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
1393         assert.Equal(t, errorResponse.Code, err.Code)
1394         assert.Equal(t, errorResponse.Message, err.Message)
1395 }
1396
1397 func TestShutdownStatusNoContent(t *testing.T) {
1398         controller, readerMock, _, _, e2tInstancesManagerMock := setupControllerTest(t)
1399         e2tInstancesManagerMock.On("GetE2TAddresses").Return([]string{}, nil)
1400         readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{}, nil)
1401
1402         writer := httptest.NewRecorder()
1403         controller.Shutdown(writer, tests.GetHttpRequest())
1404
1405         assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
1406 }
1407
1408 func TestHandleInternalError(t *testing.T) {
1409         controller, _, _, _, _ := setupControllerTest(t)
1410
1411         writer := httptest.NewRecorder()
1412         err := e2managererrors.NewInternalError()
1413
1414         controller.handleErrorResponse(err, writer)
1415         var errorResponse = parseJsonRequest(t, writer.Body)
1416
1417         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1418         assert.Equal(t, errorResponse.Code, err.Code)
1419         assert.Equal(t, errorResponse.Message, err.Message)
1420 }
1421
1422 func TestHandleCommandAlreadyInProgressError(t *testing.T) {
1423         controller, _, _, _, _ := setupControllerTest(t)
1424         writer := httptest.NewRecorder()
1425         err := e2managererrors.NewCommandAlreadyInProgressError()
1426
1427         controller.handleErrorResponse(err, writer)
1428         var errorResponse = parseJsonRequest(t, writer.Body)
1429
1430         assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
1431         assert.Equal(t, errorResponse.Code, err.Code)
1432         assert.Equal(t, errorResponse.Message, err.Message)
1433 }
1434
1435 func TestHandleRoutingManagerError(t *testing.T) {
1436         controller, _, _, _, _ := setupControllerTest(t)
1437         writer := httptest.NewRecorder()
1438         err := e2managererrors.NewRoutingManagerError()
1439
1440         controller.handleErrorResponse(err, writer)
1441         var errorResponse = parseJsonRequest(t, writer.Body)
1442
1443         assert.Equal(t, http.StatusServiceUnavailable, writer.Result().StatusCode)
1444         assert.Equal(t, errorResponse.Code, err.Code)
1445         assert.Equal(t, errorResponse.Message, err.Message)
1446 }
1447
1448 func TestHandleE2TInstanceAbsenceError(t *testing.T) {
1449         controller, _, _, _, _ := setupControllerTest(t)
1450
1451         writer := httptest.NewRecorder()
1452         err := e2managererrors.NewE2TInstanceAbsenceError()
1453
1454         controller.handleErrorResponse(err, writer)
1455         var errorResponse = parseJsonRequest(t, writer.Body)
1456
1457         assert.Equal(t, http.StatusServiceUnavailable, writer.Result().StatusCode)
1458         assert.Equal(t, errorResponse.Code, err.Code)
1459         assert.Equal(t, errorResponse.Message, err.Message)
1460 }
1461
1462 func TestValidateHeaders(t *testing.T) {
1463         controller, _, _, _, _ := setupControllerTest(t)
1464
1465         header := http.Header{}
1466         header.Set("Content-Type", "application/json")
1467         result := controller.validateRequestHeader(&header)
1468
1469         assert.Nil(t, result)
1470 }
1471
1472 func parseJsonRequest(t *testing.T, r io.Reader) models.ErrorResponse {
1473
1474         var errorResponse models.ErrorResponse
1475         body, err := ioutil.ReadAll(r)
1476         if err != nil {
1477                 t.Errorf("Error cannot deserialize json request")
1478         }
1479         _ = json.Unmarshal(body, &errorResponse)
1480
1481         return errorResponse
1482 }
1483
1484 func initLog(t *testing.T) *logger.Logger {
1485         log, err := logger.InitLogger(logger.InfoLevel)
1486         if err != nil {
1487                 t.Errorf("#delete_all_request_handler_test.TestHandleSuccessFlow - failed to initialize logger, error: %s", err)
1488         }
1489         return log
1490 }
1491
1492 func TestX2ResetHandleSuccessfulRequestedCause(t *testing.T) {
1493         controller, readerMock, _, rmrMessengerMock, _ := setupControllerTest(t)
1494
1495         ranName := "test1"
1496         payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x40}
1497         var xAction []byte
1498         var msgSrc unsafe.Pointer
1499         msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction, msgSrc)
1500         rmrMessengerMock.On("SendMsg", msg, mock.Anything).Return(msg, nil)
1501
1502         writer := httptest.NewRecorder()
1503
1504         var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
1505         readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
1506
1507         data4Req := map[string]interface{}{"cause": "protocol:transfer-syntax-error"}
1508         b := new(bytes.Buffer)
1509         _ = json.NewEncoder(b).Encode(data4Req)
1510         req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
1511         req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
1512
1513         controller.X2Reset(writer, req)
1514         assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
1515
1516 }
1517
1518 func TestX2ResetHandleSuccessfulRequestedDefault(t *testing.T) {
1519         controller, readerMock, _, rmrMessengerMock, _ := setupControllerTest(t)
1520
1521         ranName := "test1"
1522         // o&m intervention
1523         payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x64}
1524         var xAction []byte
1525         var msgSrc unsafe.Pointer
1526         msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction, msgSrc)
1527         rmrMessengerMock.On("SendMsg", msg, true).Return(msg, nil)
1528
1529         writer := httptest.NewRecorder()
1530
1531         var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
1532         readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
1533
1534         // no body
1535         b := new(bytes.Buffer)
1536         data4Req := map[string]interface{}{}
1537         _ = json.NewEncoder(b).Encode(data4Req)
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.StatusNoContent, writer.Result().StatusCode)
1543 }
1544
1545 func TestX2ResetHandleFailureInvalidBody(t *testing.T) {
1546         controller, _, _, _, _ := setupControllerTest(t)
1547
1548         ranName := "test1"
1549
1550         writer := httptest.NewRecorder()
1551
1552         // Invalid json: attribute name without quotes (should be "cause":).
1553         b := strings.NewReader("{cause:\"protocol:transfer-syntax-error\"")
1554         req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
1555         req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
1556
1557         controller.X2Reset(writer, req)
1558         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1559
1560 }
1561
1562 func TestHandleErrorResponse(t *testing.T) {
1563         controller, _, _, _, _ := setupControllerTest(t)
1564
1565         writer := httptest.NewRecorder()
1566         controller.handleErrorResponse(e2managererrors.NewRnibDbError(), writer)
1567         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1568
1569         writer = httptest.NewRecorder()
1570         controller.handleErrorResponse(e2managererrors.NewCommandAlreadyInProgressError(), writer)
1571         assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
1572
1573         writer = httptest.NewRecorder()
1574         controller.handleErrorResponse(e2managererrors.NewHeaderValidationError(), writer)
1575         assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
1576
1577         writer = httptest.NewRecorder()
1578         controller.handleErrorResponse(e2managererrors.NewWrongStateError("", ""), writer)
1579         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1580
1581         writer = httptest.NewRecorder()
1582         controller.handleErrorResponse(e2managererrors.NewRequestValidationError(), writer)
1583         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1584
1585         writer = httptest.NewRecorder()
1586         controller.handleErrorResponse(e2managererrors.NewRmrError(), writer)
1587         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1588
1589         writer = httptest.NewRecorder()
1590         controller.handleErrorResponse(e2managererrors.NewResourceNotFoundError(), writer)
1591         assert.Equal(t, http.StatusNotFound, writer.Result().StatusCode)
1592
1593         writer = httptest.NewRecorder()
1594         controller.handleErrorResponse(fmt.Errorf("ErrorError"), writer)
1595         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1596 }
1597
1598 func getRmrSender(rmrMessengerMock *mocks.RmrMessengerMock, log *logger.Logger) *rmrsender.RmrSender {
1599         rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
1600         rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
1601         return rmrsender.NewRmrSender(log, rmrMessenger)
1602 }