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