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         GlobalIdRequiredFields                = []string{"plmnId", "nbId"}
  71         EnbRequiredFields                     = []string{"enbType", "servedCells"}
  72         ServedCellRequiredFields              = []string{"broadcastPlmns", "cellId", "choiceEutraMode", "eutraMode", "tac"}
  73 )
  74
  75 type controllerGetNodebTestContext struct {
  76         ranName              string
  77         nodebInfo            *entities.NodebInfo
  78         rnibError            error
  79         expectedStatusCode   int
  80         expectedJsonResponse string
  81 }
  82
  83 type controllerGetNodebIdListTestContext struct {
  84         nodebIdList          []*entities.NbIdentity
  85         rnibError            error
  86         expectedStatusCode   int
  87         expectedJsonResponse string
  88 }
  89
  90 type getNodebInfoResult struct {
  91         nodebInfo *entities.NodebInfo
  92         rnibError error
  93 }
  94
  95 type updateGnbCellsParams struct {
  96         err error
  97 }
  98
  99 type saveNodebParams struct {
 100         nodebInfo  *entities.NodebInfo
 101         nbIdentity *entities.NbIdentity
 102         err        error
 103 }
 104
 105 type removeServedNrCellsParams struct {
 106         servedNrCells []*entities.ServedNRCell
 107         err           error
 108 }
 109
 110 type controllerUpdateGnbTestContext struct {
 111         getNodebInfoResult        *getNodebInfoResult
 112         removeServedNrCellsParams *removeServedNrCellsParams
 113         updateGnbCellsParams      *updateGnbCellsParams
 114         requestBody               map[string]interface{}
 115         expectedStatusCode        int
 116         expectedJsonResponse      string
 117 }
 118
 119 type controllerAddEnbTestContext struct {
 120         getNodebInfoResult   *getNodebInfoResult
 121         saveNodebParams      *saveNodebParams
 122         requestBody          map[string]interface{}
 123         expectedStatusCode   int
 124         expectedJsonResponse string
 125 }
 126
 127 func generateServedNrCells(cellIds ...string) []*entities.ServedNRCell {
 128
 129         servedNrCells := []*entities.ServedNRCell{}
 130
 131         for _, v := range cellIds {
 132                 servedNrCells = append(servedNrCells, &entities.ServedNRCell{ServedNrCellInformation: &entities.ServedNRCellInformation{
 133                         CellId: v,
 134                         ChoiceNrMode: &entities.ServedNRCellInformation_ChoiceNRMode{
 135                                 Fdd: &entities.ServedNRCellInformation_ChoiceNRMode_FddInfo{
 136
 137                                 },
 138                         },
 139                         NrMode:      entities.Nr_FDD,
 140                         NrPci:       5,
 141                         ServedPlmns: []string{"whatever"},
 142                 }})
 143         }
 144
 145         return servedNrCells
 146 }
 147
 148 func buildNrNeighbourInformation(propToOmit string) map[string]interface{} {
 149         ret := map[string]interface{}{
 150                 "nrCgi": "whatever",
 151                 "choiceNrMode": map[string]interface{}{
 152                         "tdd": map[string]interface{}{},
 153                 },
 154                 "nrMode": 1,
 155                 "nrPci":  1,
 156         }
 157
 158         if len(propToOmit) != 0 {
 159                 delete(ret, propToOmit)
 160         }
 161
 162         return ret
 163 }
 164
 165 func buildServedNrCellInformation(propToOmit string) map[string]interface{} {
 166         ret := map[string]interface{}{
 167                 "cellId": "whatever",
 168                 "choiceNrMode": map[string]interface{}{
 169                         "fdd": map[string]interface{}{},
 170                 },
 171                 "nrMode": 1,
 172                 "nrPci":  1,
 173                 "servedPlmns": []interface{}{
 174                         "whatever",
 175                 },
 176         }
 177
 178         if len(propToOmit) != 0 {
 179                 delete(ret, propToOmit)
 180         }
 181
 182         return ret
 183 }
 184
 185 func buildServedCell(propToOmit string) map[string]interface{} {
 186         ret := map[string]interface{}{
 187                 "cellId": "whatever",
 188                 "choiceEutraMode": map[string]interface{}{
 189                         "fdd": map[string]interface{}{},
 190                 },
 191                 "eutraMode": 1,
 192                 "pci":       1,
 193                 "tac":       "whatever3",
 194                 "broadcastPlmns": []interface{}{
 195                         "whatever",
 196                 },
 197         }
 198
 199         if len(propToOmit) != 0 {
 200                 delete(ret, propToOmit)
 201         }
 202
 203         return ret
 204 }
 205
 206 func getAddEnbRequest(propToOmit string) map[string]interface{} {
 207         ret := map[string]interface{}{
 208                 "ranName":    RanName,
 209                 "globalNbId": buildGlobalNbId(""),
 210                 "enb":        buildEnb(""),
 211         }
 212
 213         if len(propToOmit) != 0 {
 214                 delete(ret, propToOmit)
 215         }
 216
 217         return ret
 218 }
 219
 220 func buildEnb(propToOmit string) map[string]interface{} {
 221         ret := map[string]interface{}{
 222                 "enbType": 1,
 223                 "servedCells": []interface{}{
 224                         buildServedCell(""),
 225                 }}
 226
 227         if len(propToOmit) != 0 {
 228                 delete(ret, propToOmit)
 229         }
 230
 231         return ret
 232 }
 233
 234 func buildGlobalNbId(propToOmit string) map[string]interface{} {
 235         ret := map[string]interface{}{
 236                 "plmnId": "whatever",
 237                 "nbId":   "whatever2",
 238         }
 239
 240         if len(propToOmit) != 0 {
 241                 delete(ret, propToOmit)
 242         }
 243
 244         return ret
 245 }
 246
 247 func setupControllerTest(t *testing.T) (*NodebController, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.RmrMessengerMock, *mocks.E2TInstancesManagerMock) {
 248         log := initLog(t)
 249         config := configuration.ParseConfiguration()
 250
 251         rmrMessengerMock := &mocks.RmrMessengerMock{}
 252         readerMock := &mocks.RnibReaderMock{}
 253
 254         writerMock := &mocks.RnibWriterMock{}
 255
 256         rnibDataService := services.NewRnibDataService(log, config, readerMock, writerMock)
 257         rmrSender := getRmrSender(rmrMessengerMock, log)
 258         e2tInstancesManager := &mocks.E2TInstancesManagerMock{}
 259         httpClientMock := &mocks.HttpClientMock{}
 260         rmClient := clients.NewRoutingManagerClient(log, config, httpClientMock)
 261         ranListManager := &mocks.RanListManagerMock{}
 262         ranAlarmService := &mocks.RanAlarmServiceMock{}
 263         ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(log, rnibDataService, ranListManager, ranAlarmService)
 264         nodebValidator := managers.NewNodebValidator()
 265         updateEnbManager := managers.NewUpdateEnbManager(log, rnibDataService, nodebValidator)
 266
 267         handlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(log, rmrSender, config, rnibDataService, e2tInstancesManager, rmClient, ranConnectStatusChangeManager, nodebValidator, updateEnbManager)
 268         controller := NewNodebController(log, handlerProvider)
 269         return controller, readerMock, writerMock, rmrMessengerMock, e2tInstancesManager
 270 }
 271
 272 func TestShutdownHandlerRnibError(t *testing.T) {
 273         controller, _, _, _, e2tInstancesManagerMock := setupControllerTest(t)
 274         e2tInstancesManagerMock.On("GetE2TAddresses").Return([]string{}, e2managererrors.NewRnibDbError())
 275
 276         writer := httptest.NewRecorder()
 277
 278         controller.Shutdown(writer, tests.GetHttpRequest())
 279
 280         var errorResponse = parseJsonRequest(t, writer.Body)
 281
 282         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
 283         assert.Equal(t, errorResponse.Code, e2managererrors.NewRnibDbError().Code)
 284 }
 285
 286 func TestSetGeneralConfigurationHandlerRnibError(t *testing.T) {
 287         controller, readerMock, _, _, _ := setupControllerTest(t)
 288
 289         configuration := &entities.GeneralConfiguration{}
 290         readerMock.On("GetGeneralConfiguration").Return(configuration, e2managererrors.NewRnibDbError())
 291
 292         writer := httptest.NewRecorder()
 293
 294         httpRequest, _ := http.NewRequest("PUT", "https://localhost:3800/v1/nodeb/parameters", strings.NewReader("{\"enableRic\":false}"))
 295
 296         controller.SetGeneralConfiguration(writer, httpRequest)
 297
 298         var errorResponse = parseJsonRequest(t, writer.Body)
 299
 300         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
 301         assert.Equal(t, e2managererrors.NewRnibDbError().Code, errorResponse.Code)
 302 }
 303
 304 func TestSetGeneralConfigurationInvalidJson(t *testing.T) {
 305         controller, _, _, _, _ := setupControllerTest(t)
 306
 307         writer := httptest.NewRecorder()
 308
 309         httpRequest, _ := http.NewRequest("PUT", "https://localhost:3800/v1/nodeb/parameters", strings.NewReader("{\"enableRic\":false, \"someValue\":false}"))
 310
 311         controller.SetGeneralConfiguration(writer, httpRequest)
 312
 313         var errorResponse = parseJsonRequest(t, writer.Body)
 314
 315         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
 316         assert.Equal(t, e2managererrors.NewInvalidJsonError().Code, errorResponse.Code)
 317 }
 318
 319 func controllerGetNodebTestExecuter(t *testing.T, context *controllerGetNodebTestContext) {
 320         controller, readerMock, _, _, _ := setupControllerTest(t)
 321         writer := httptest.NewRecorder()
 322         readerMock.On("GetNodeb", context.ranName).Return(context.nodebInfo, context.rnibError)
 323         req, _ := http.NewRequest(http.MethodGet, "/nodeb", nil)
 324         req = mux.SetURLVars(req, map[string]string{"ranName": context.ranName})
 325         controller.GetNodeb(writer, req)
 326         assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
 327         bodyBytes, _ := ioutil.ReadAll(writer.Body)
 328         assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
 329 }
 330
 331 func controllerGetNodebIdListTestExecuter(t *testing.T, context *controllerGetNodebIdListTestContext) {
 332         controller, readerMock, _, _, _ := setupControllerTest(t)
 333         writer := httptest.NewRecorder()
 334         readerMock.On("GetListNodebIds").Return(context.nodebIdList, context.rnibError)
 335         req, _ := http.NewRequest(http.MethodGet, "/nodeb/ids", nil)
 336         controller.GetNodebIdList(writer, req)
 337         assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
 338         bodyBytes, _ := ioutil.ReadAll(writer.Body)
 339         assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
 340 }
 341
 342 func activateControllerUpdateGnbMocks(context *controllerUpdateGnbTestContext, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
 343         if context.getNodebInfoResult != nil {
 344                 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
 345         }
 346
 347         if context.removeServedNrCellsParams != nil {
 348                 writerMock.On("RemoveServedNrCells", RanName, context.removeServedNrCellsParams.servedNrCells).Return(context.removeServedNrCellsParams.err)
 349         }
 350
 351         if context.updateGnbCellsParams != nil {
 352                 updatedNodebInfo := *context.getNodebInfoResult.nodebInfo
 353                 gnb := entities.Gnb{}
 354                 _ = jsonpb.Unmarshal(getJsonRequestAsBuffer(context.requestBody), &gnb)
 355                 updatedGnb := *updatedNodebInfo.GetGnb()
 356                 updatedGnb.ServedNrCells = gnb.ServedNrCells
 357                 writerMock.On("UpdateGnbCells", &updatedNodebInfo, gnb.ServedNrCells).Return(context.updateGnbCellsParams.err)
 358         }
 359 }
 360
 361 func assertControllerUpdateGnb(t *testing.T, context *controllerUpdateGnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
 362         assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
 363         bodyBytes, _ := ioutil.ReadAll(writer.Body)
 364         assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
 365         readerMock.AssertExpectations(t)
 366         writerMock.AssertExpectations(t)
 367 }
 368
 369 func assertControllerAddEnb(t *testing.T, context *controllerAddEnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
 370         assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
 371         bodyBytes, _ := ioutil.ReadAll(writer.Body)
 372         assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
 373         readerMock.AssertExpectations(t)
 374         writerMock.AssertExpectations(t)
 375 }
 376
 377 func buildUpdateGnbRequest(context *controllerUpdateGnbTestContext) *http.Request {
 378         updateGnbUrl := fmt.Sprintf("/nodeb/%s/update", RanName)
 379         requestBody := getJsonRequestAsBuffer(context.requestBody)
 380         req, _ := http.NewRequest(http.MethodPut, updateGnbUrl, requestBody)
 381         req.Header.Set("Content-Type", "application/json")
 382         req = mux.SetURLVars(req, map[string]string{"ranName": RanName})
 383         return req
 384 }
 385
 386 func buildAddEnbRequest(context *controllerAddEnbTestContext) *http.Request {
 387         requestBody := getJsonRequestAsBuffer(context.requestBody)
 388         req, _ := http.NewRequest(http.MethodPost, AddEnbUrl, requestBody)
 389         req.Header.Set("Content-Type", "application/json")
 390         return req
 391 }
 392
 393 func controllerUpdateGnbTestExecuter(t *testing.T, context *controllerUpdateGnbTestContext) {
 394         controller, readerMock, writerMock, _, _ := setupControllerTest(t)
 395         writer := httptest.NewRecorder()
 396
 397         activateControllerUpdateGnbMocks(context, readerMock, writerMock)
 398         req := buildUpdateGnbRequest(context)
 399         controller.UpdateGnb(writer, req)
 400         assertControllerUpdateGnb(t, context, writer, readerMock, writerMock)
 401 }
 402
 403 func activateControllerAddEnbMocks(context *controllerAddEnbTestContext, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock, addEnbRequest *models.AddEnbRequest) {
 404         if context.getNodebInfoResult != nil {
 405                 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
 406         }
 407
 408         if context.saveNodebParams != nil {
 409                 nodebInfo := entities.NodebInfo{
 410                         RanName:          addEnbRequest.RanName,
 411                         Ip:               addEnbRequest.Ip,
 412                         Port:             addEnbRequest.Port,
 413                         NodeType:         entities.Node_ENB,
 414                         GlobalNbId:       addEnbRequest.GlobalNbId,
 415                         Configuration:    &entities.NodebInfo_Enb{Enb: addEnbRequest.Enb},
 416                         ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,
 417                 }
 418
 419                 nbIdentity := entities.NbIdentity{InventoryName: addEnbRequest.RanName, GlobalNbId: addEnbRequest.GlobalNbId}
 420
 421                 writerMock.On("SaveNodeb", &nbIdentity, &nodebInfo).Return(context.saveNodebParams.err)
 422         }
 423 }
 424
 425 func controllerAddEnbTestExecuter(t *testing.T, context *controllerAddEnbTestContext) {
 426         controller, readerMock, writerMock, _, _ := setupControllerTest(t)
 427         writer := httptest.NewRecorder()
 428         r := buildAddEnbRequest(context)
 429         body, _ := ioutil.ReadAll(io.LimitReader(r.Body, LimitRequest))
 430
 431         addEnbRequest := models.AddEnbRequest{}
 432
 433         _ = json.Unmarshal(body, &addEnbRequest)
 434         activateControllerAddEnbMocks(context, readerMock, writerMock, &addEnbRequest)
 435         r = buildAddEnbRequest(context)
 436         defer r.Body.Close()
 437         controller.AddEnb(writer, r)
 438         assertControllerAddEnb(t, context, writer, readerMock, writerMock)
 439 }
 440
 441 func TestControllerUpdateGnbEmptyServedNrCells(t *testing.T) {
 442         context := controllerUpdateGnbTestContext{
 443                 getNodebInfoResult: nil,
 444                 requestBody: map[string]interface{}{
 445                         "servedNrCells": []interface{}{
 446                         },
 447                 },
 448                 expectedStatusCode:   http.StatusBadRequest,
 449                 expectedJsonResponse: ValidationFailureJson,
 450         }
 451
 452         controllerUpdateGnbTestExecuter(t, &context)
 453 }
 454
 455 func TestControllerUpdateGnbMissingServedNrCellInformation(t *testing.T) {
 456         context := controllerUpdateGnbTestContext{
 457                 getNodebInfoResult: nil,
 458                 requestBody: map[string]interface{}{
 459                         "servedNrCells": []interface{}{
 460                                 map[string]interface{}{
 461                                         "servedNrCellInformation": nil,
 462                                 },
 463                         },
 464                 },
 465                 expectedStatusCode:   http.StatusBadRequest,
 466                 expectedJsonResponse: ValidationFailureJson,
 467         }
 468
 469         controllerUpdateGnbTestExecuter(t, &context)
 470 }
 471
 472 func TestControllerUpdateGnbMissingServedNrCellRequiredProp(t *testing.T) {
 473
 474         for _, v := range ServedNrCellInformationRequiredFields {
 475                 context := controllerUpdateGnbTestContext{
 476                         getNodebInfoResult: nil,
 477                         requestBody: map[string]interface{}{
 478                                 "servedNrCells": []interface{}{
 479                                         map[string]interface{}{
 480                                                 "servedNrCellInformation": buildServedNrCellInformation(v),
 481                                         },
 482                                 },
 483                         },
 484                         expectedStatusCode:   http.StatusBadRequest,
 485                         expectedJsonResponse: ValidationFailureJson,
 486                 }
 487
 488                 controllerUpdateGnbTestExecuter(t, &context)
 489         }
 490 }
 491
 492 func TestControllerUpdateGnbMissingServedNrCellFddOrTdd(t *testing.T) {
 493
 494         servedNrCellInformation := buildServedNrCellInformation("")
 495         servedNrCellInformation["choiceNrMode"] = map[string]interface{}{}
 496
 497         context := controllerUpdateGnbTestContext{
 498                 getNodebInfoResult: nil,
 499                 requestBody: map[string]interface{}{
 500                         "servedNrCells": []interface{}{
 501                                 map[string]interface{}{
 502                                         "servedNrCellInformation": servedNrCellInformation,
 503                                 },
 504                         },
 505                 },
 506                 expectedStatusCode:   http.StatusBadRequest,
 507                 expectedJsonResponse: ValidationFailureJson,
 508         }
 509
 510         controllerUpdateGnbTestExecuter(t, &context)
 511 }
 512
 513 func TestControllerUpdateGnbMissingNeighbourInfoFddOrTdd(t *testing.T) {
 514
 515         nrNeighbourInfo := buildNrNeighbourInformation("")
 516         nrNeighbourInfo["choiceNrMode"] = map[string]interface{}{}
 517
 518         context := controllerUpdateGnbTestContext{
 519                 getNodebInfoResult: nil,
 520                 requestBody: map[string]interface{}{
 521                         "servedNrCells": []interface{}{
 522                                 map[string]interface{}{
 523                                         "servedNrCellInformation": buildServedNrCellInformation(""),
 524                                         "nrNeighbourInfos": []interface{}{
 525                                                 nrNeighbourInfo,
 526                                         },
 527                                 },
 528                         },
 529                 },
 530                 expectedStatusCode:   http.StatusBadRequest,
 531                 expectedJsonResponse: ValidationFailureJson,
 532         }
 533
 534         controllerUpdateGnbTestExecuter(t, &context)
 535 }
 536
 537 func TestControllerUpdateGnbMissingNrNeighbourInformationRequiredProp(t *testing.T) {
 538
 539         for _, v := range NrNeighbourInformationRequiredFields {
 540                 context := controllerUpdateGnbTestContext{
 541                         getNodebInfoResult: nil,
 542                         requestBody: map[string]interface{}{
 543                                 "servedNrCells": []interface{}{
 544                                         map[string]interface{}{
 545                                                 "servedNrCellInformation": buildServedNrCellInformation(""),
 546                                                 "nrNeighbourInfos": []interface{}{
 547                                                         buildNrNeighbourInformation(v),
 548                                                 },
 549                                         },
 550                                 },
 551                         },
 552                         expectedStatusCode:   http.StatusBadRequest,
 553                         expectedJsonResponse: ValidationFailureJson,
 554                 }
 555
 556                 controllerUpdateGnbTestExecuter(t, &context)
 557         }
 558 }
 559
 560 func TestControllerUpdateGnbValidServedNrCellInformationGetNodebNotFound(t *testing.T) {
 561         context := controllerUpdateGnbTestContext{
 562                 getNodebInfoResult: &getNodebInfoResult{
 563                         nodebInfo: nil,
 564                         rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
 565                 },
 566                 requestBody: map[string]interface{}{
 567                         "servedNrCells": []interface{}{
 568                                 map[string]interface{}{
 569                                         "servedNrCellInformation": buildServedNrCellInformation(""),
 570                                 },
 571                         },
 572                 },
 573                 expectedStatusCode:   http.StatusNotFound,
 574                 expectedJsonResponse: ResourceNotFoundJson,
 575         }
 576
 577         controllerUpdateGnbTestExecuter(t, &context)
 578 }
 579
 580 func TestControllerUpdateGnbValidServedNrCellInformationGetNodebInternalError(t *testing.T) {
 581         context := controllerUpdateGnbTestContext{
 582                 getNodebInfoResult: &getNodebInfoResult{
 583                         nodebInfo: nil,
 584                         rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
 585                 },
 586                 requestBody: map[string]interface{}{
 587                         "servedNrCells": []interface{}{
 588                                 map[string]interface{}{
 589                                         "servedNrCellInformation": buildServedNrCellInformation(""),
 590                                 },
 591                         },
 592                 },
 593                 expectedStatusCode:   http.StatusInternalServerError,
 594                 expectedJsonResponse: RnibErrorJson,
 595         }
 596
 597         controllerUpdateGnbTestExecuter(t, &context)
 598 }
 599
 600 func TestControllerUpdateGnbGetNodebSuccessInvalidGnbConfiguration(t *testing.T) {
 601         context := controllerUpdateGnbTestContext{
 602                 getNodebInfoResult: &getNodebInfoResult{
 603                         nodebInfo: &entities.NodebInfo{
 604                                 RanName:                      RanName,
 605                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
 606                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
 607                         },
 608                         rnibError: nil,
 609                 },
 610                 requestBody: map[string]interface{}{
 611                         "servedNrCells": []interface{}{
 612                                 map[string]interface{}{
 613                                         "servedNrCellInformation": buildServedNrCellInformation(""),
 614                                         "nrNeighbourInfos": []interface{}{
 615                                                 buildNrNeighbourInformation(""),
 616                                         },
 617                                 },
 618                         },
 619                 },
 620                 expectedStatusCode:   http.StatusInternalServerError,
 621                 expectedJsonResponse: InternalErrorJson,
 622         }
 623
 624         controllerUpdateGnbTestExecuter(t, &context)
 625 }
 626
 627 func TestControllerUpdateGnbGetNodebSuccessRemoveServedNrCellsFailure(t *testing.T) {
 628         oldServedNrCells := generateServedNrCells("whatever1", "whatever2")
 629         context := controllerUpdateGnbTestContext{
 630                 removeServedNrCellsParams: &removeServedNrCellsParams{
 631                         err:           common.NewInternalError(errors.New("#writer.UpdateGnbCells - Internal Error")),
 632                         servedNrCells: oldServedNrCells,
 633                 },
 634                 getNodebInfoResult: &getNodebInfoResult{
 635                         nodebInfo: &entities.NodebInfo{
 636                                 RanName:                      RanName,
 637                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
 638                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
 639                                 Configuration:                &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{ServedNrCells: oldServedNrCells}},
 640                         },
 641                         rnibError: nil,
 642                 },
 643                 requestBody: map[string]interface{}{
 644                         "servedNrCells": []interface{}{
 645                                 map[string]interface{}{
 646                                         "servedNrCellInformation": buildServedNrCellInformation(""),
 647                                         "nrNeighbourInfos": []interface{}{
 648                                                 buildNrNeighbourInformation(""),
 649                                         },
 650                                 },
 651                         },
 652                 },
 653                 expectedStatusCode:   http.StatusInternalServerError,
 654                 expectedJsonResponse: RnibErrorJson,
 655         }
 656
 657         controllerUpdateGnbTestExecuter(t, &context)
 658 }
 659
 660 func TestControllerUpdateGnbGetNodebSuccessUpdateGnbCellsFailure(t *testing.T) {
 661         oldServedNrCells := generateServedNrCells("whatever1", "whatever2")
 662         context := controllerUpdateGnbTestContext{
 663                 removeServedNrCellsParams: &removeServedNrCellsParams{
 664                         err:           nil,
 665                         servedNrCells: oldServedNrCells,
 666                 },
 667                 updateGnbCellsParams: &updateGnbCellsParams{
 668                         err: common.NewInternalError(errors.New("#writer.UpdateGnbCells - Internal Error")),
 669                 },
 670                 getNodebInfoResult: &getNodebInfoResult{
 671                         nodebInfo: &entities.NodebInfo{
 672                                 RanName:                      RanName,
 673                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
 674                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
 675                                 Configuration:                &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{ServedNrCells: oldServedNrCells}},
 676                         },
 677                         rnibError: nil,
 678                 },
 679                 requestBody: map[string]interface{}{
 680                         "servedNrCells": []interface{}{
 681                                 map[string]interface{}{
 682                                         "servedNrCellInformation": buildServedNrCellInformation(""),
 683                                         "nrNeighbourInfos": []interface{}{
 684                                                 buildNrNeighbourInformation(""),
 685                                         },
 686                                 },
 687                         },
 688                 },
 689                 expectedStatusCode:   http.StatusInternalServerError,
 690                 expectedJsonResponse: RnibErrorJson,
 691         }
 692
 693         controllerUpdateGnbTestExecuter(t, &context)
 694 }
 695
 696 func TestControllerUpdateGnbSuccess(t *testing.T) {
 697         context := controllerUpdateGnbTestContext{
 698                 updateGnbCellsParams: &updateGnbCellsParams{
 699                         err: nil,
 700                 },
 701                 getNodebInfoResult: &getNodebInfoResult{
 702                         nodebInfo: &entities.NodebInfo{
 703                                 RanName:                      RanName,
 704                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
 705                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
 706                                 Configuration:                &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{}},
 707                         },
 708                         rnibError: nil,
 709                 },
 710                 requestBody: map[string]interface{}{
 711                         "servedNrCells": []interface{}{
 712                                 map[string]interface{}{
 713                                         "servedNrCellInformation": buildServedNrCellInformation(""),
 714                                         "nrNeighbourInfos": []interface{}{
 715                                                 buildNrNeighbourInformation(""),
 716                                         },
 717                                 },
 718                         },
 719                 },
 720                 expectedStatusCode:   http.StatusOK,
 721                 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\"}",
 722         }
 723
 724         controllerUpdateGnbTestExecuter(t, &context)
 725 }
 726
 727 func TestControllerAddEnbGetNodebInternalError(t *testing.T) {
 728         context := controllerAddEnbTestContext{
 729                 getNodebInfoResult: &getNodebInfoResult{
 730                         nodebInfo: nil,
 731                         rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
 732                 },
 733                 requestBody:          getAddEnbRequest(""),
 734                 expectedStatusCode:   http.StatusInternalServerError,
 735                 expectedJsonResponse: RnibErrorJson,
 736         }
 737
 738         controllerAddEnbTestExecuter(t, &context)
 739 }
 740
 741 func TestControllerAddEnbNodebExistsFailure(t *testing.T) {
 742         context := controllerAddEnbTestContext{
 743                 getNodebInfoResult: &getNodebInfoResult{
 744                         nodebInfo: &entities.NodebInfo{},
 745                         rnibError: nil,
 746                 },
 747                 requestBody:          getAddEnbRequest(""),
 748                 expectedStatusCode:   http.StatusBadRequest,
 749                 expectedJsonResponse: NodebExistsJson,
 750         }
 751
 752         controllerAddEnbTestExecuter(t, &context)
 753 }
 754
 755 func TestControllerAddEnbSaveNodebFailure(t *testing.T) {
 756         context := controllerAddEnbTestContext{
 757                 saveNodebParams: &saveNodebParams{
 758                         err: common.NewInternalError(errors.New("#reader.SaveeNodeb - Internal Error")),
 759                 },
 760                 getNodebInfoResult: &getNodebInfoResult{
 761                         nodebInfo: nil,
 762                         rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
 763                 },
 764                 requestBody:          getAddEnbRequest(""),
 765                 expectedStatusCode:   http.StatusInternalServerError,
 766                 expectedJsonResponse: RnibErrorJson,
 767         }
 768
 769         controllerAddEnbTestExecuter(t, &context)
 770 }
 771
 772 func TestControllerAddEnbMissingRequiredRequestProps(t *testing.T) {
 773
 774         for _, v := range AddEnbRequestRequiredFields {
 775                 context := controllerAddEnbTestContext{
 776                         requestBody:          getAddEnbRequest(v),
 777                         expectedStatusCode:   http.StatusBadRequest,
 778                         expectedJsonResponse: ValidationFailureJson,
 779                 }
 780
 781                 controllerAddEnbTestExecuter(t, &context)
 782         }
 783 }
 784
 785 func TestControllerAddEnbInvalidRequest(t *testing.T) {
 786         controller, _, _, _, _ := setupControllerTest(t)
 787         writer := httptest.NewRecorder()
 788
 789         // Invalid json: attribute name without quotes (should be "cause":).
 790         invalidJson := strings.NewReader("{ranName:\"whatever\"")
 791         req, _ := http.NewRequest(http.MethodPost, AddEnbUrl, invalidJson)
 792
 793         controller.AddEnb(writer, req)
 794         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
 795         bodyBytes, _ := ioutil.ReadAll(writer.Body)
 796         assert.Equal(t, CorruptedJson, string(bodyBytes))
 797
 798 }
 799
 800 func TestControllerAddEnbMissingRequiredGlobalNbIdProps(t *testing.T) {
 801
 802         r := getAddEnbRequest("")
 803
 804         for _, v := range GlobalIdRequiredFields {
 805                 r["globalNbId"] = buildGlobalNbId(v)
 806
 807                 context := controllerAddEnbTestContext{
 808                         requestBody:          r,
 809                         expectedStatusCode:   http.StatusBadRequest,
 810                         expectedJsonResponse: ValidationFailureJson,
 811                 }
 812
 813                 controllerAddEnbTestExecuter(t, &context)
 814         }
 815 }
 816
 817 func TestControllerAddEnbMissingRequiredEnbProps(t *testing.T) {
 818
 819         r := getAddEnbRequest("")
 820
 821         for _, v := range EnbRequiredFields {
 822                 r["enb"] = buildEnb(v)
 823
 824                 context := controllerAddEnbTestContext{
 825                         requestBody:          r,
 826                         expectedStatusCode:   http.StatusBadRequest,
 827                         expectedJsonResponse: ValidationFailureJson,
 828                 }
 829
 830                 controllerAddEnbTestExecuter(t, &context)
 831         }
 832 }
 833
 834 func TestControllerAddEnbMissingRequiredServedCellProps(t *testing.T) {
 835
 836         r := getAddEnbRequest("")
 837
 838         for _, v := range ServedCellRequiredFields {
 839                 enb := r["enb"]
 840
 841                 enbMap, _ := enb.(map[string]interface{})
 842
 843                 enbMap["servedCells"] = []interface{}{
 844                         buildServedCell(v),
 845                 }
 846
 847                 context := controllerAddEnbTestContext{
 848                         requestBody:          r,
 849                         expectedStatusCode:   http.StatusBadRequest,
 850                         expectedJsonResponse: ValidationFailureJson,
 851                 }
 852
 853                 controllerAddEnbTestExecuter(t, &context)
 854         }
 855 }
 856
 857 func TestControllerAddEnbSuccess(t *testing.T) {
 858         context := controllerAddEnbTestContext{
 859                 saveNodebParams: &saveNodebParams{
 860                         err: nil,
 861                 },
 862                 getNodebInfoResult: &getNodebInfoResult{
 863                         nodebInfo: nil,
 864                         rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
 865                 },
 866                 requestBody: map[string]interface{}{
 867                         "ranName": RanName,
 868                         "globalNbId": map[string]interface{}{
 869                                 "plmnId": "whatever",
 870                                 "nbId":   "whatever2",
 871                         },
 872                         "enb": map[string]interface{}{
 873                                 "enbType": 1,
 874                                 "servedCells": []interface{}{
 875                                         buildServedCell(""),
 876                                 },
 877                         },
 878                 },
 879                 expectedStatusCode:   http.StatusCreated,
 880                 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\"}]}}",
 881         }
 882
 883         controllerAddEnbTestExecuter(t, &context)
 884 }
 885
 886 func getJsonRequestAsBuffer(requestJson map[string]interface{}) *bytes.Buffer {
 887         b := new(bytes.Buffer)
 888         _ = json.NewEncoder(b).Encode(requestJson)
 889         return b
 890 }
 891
 892 func TestControllerGetNodebSuccess(t *testing.T) {
 893         ranName := "test"
 894         var rnibError error
 895         context := controllerGetNodebTestContext{
 896                 ranName:              ranName,
 897                 nodebInfo:            &entities.NodebInfo{RanName: ranName, Ip: "10.0.2.15", Port: 1234},
 898                 rnibError:            rnibError,
 899                 expectedStatusCode:   http.StatusOK,
 900                 expectedJsonResponse: fmt.Sprintf("{\"ranName\":\"%s\",\"ip\":\"10.0.2.15\",\"port\":1234}", ranName),
 901         }
 902
 903         controllerGetNodebTestExecuter(t, &context)
 904 }
 905
 906 func TestControllerGetNodebNotFound(t *testing.T) {
 907
 908         ranName := "test"
 909         var nodebInfo *entities.NodebInfo
 910         context := controllerGetNodebTestContext{
 911                 ranName:              ranName,
 912                 nodebInfo:            nodebInfo,
 913                 rnibError:            common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
 914                 expectedStatusCode:   http.StatusNotFound,
 915                 expectedJsonResponse: ResourceNotFoundJson,
 916         }
 917
 918         controllerGetNodebTestExecuter(t, &context)
 919 }
 920
 921 func TestControllerGetNodebInternal(t *testing.T) {
 922         ranName := "test"
 923         var nodebInfo *entities.NodebInfo
 924         context := controllerGetNodebTestContext{
 925                 ranName:              ranName,
 926                 nodebInfo:            nodebInfo,
 927                 rnibError:            common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
 928                 expectedStatusCode:   http.StatusInternalServerError,
 929                 expectedJsonResponse: RnibErrorJson,
 930         }
 931
 932         controllerGetNodebTestExecuter(t, &context)
 933 }
 934
 935 func TestControllerGetNodebIdListSuccess(t *testing.T) {
 936         var rnibError error
 937         nodebIdList := []*entities.NbIdentity{
 938                 {InventoryName: "test1", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}},
 939                 {InventoryName: "test2", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId2", NbId: "nbId2"}},
 940         }
 941
 942         context := controllerGetNodebIdListTestContext{
 943                 nodebIdList:          nodebIdList,
 944                 rnibError:            rnibError,
 945                 expectedStatusCode:   http.StatusOK,
 946                 expectedJsonResponse: "[{\"inventoryName\":\"test1\",\"globalNbId\":{\"plmnId\":\"plmnId1\",\"nbId\":\"nbId1\"}},{\"inventoryName\":\"test2\",\"globalNbId\":{\"plmnId\":\"plmnId2\",\"nbId\":\"nbId2\"}}]",
 947         }
 948
 949         controllerGetNodebIdListTestExecuter(t, &context)
 950 }
 951
 952 func TestControllerGetNodebIdListEmptySuccess(t *testing.T) {
 953         var rnibError error
 954         var nodebIdList []*entities.NbIdentity
 955
 956         context := controllerGetNodebIdListTestContext{
 957                 nodebIdList:          nodebIdList,
 958                 rnibError:            rnibError,
 959                 expectedStatusCode:   http.StatusOK,
 960                 expectedJsonResponse: "[]",
 961         }
 962
 963         controllerGetNodebIdListTestExecuter(t, &context)
 964 }
 965
 966 func TestControllerGetNodebIdListInternal(t *testing.T) {
 967         var nodebIdList []*entities.NbIdentity
 968         context := controllerGetNodebIdListTestContext{
 969                 nodebIdList:          nodebIdList,
 970                 rnibError:            common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
 971                 expectedStatusCode:   http.StatusInternalServerError,
 972                 expectedJsonResponse: RnibErrorJson,
 973         }
 974
 975         controllerGetNodebIdListTestExecuter(t, &context)
 976 }
 977
 978 func TestHeaderValidationFailed(t *testing.T) {
 979         controller, _, _, _, _ := setupControllerTest(t)
 980
 981         writer := httptest.NewRecorder()
 982
 983         header := &http.Header{}
 984
 985         controller.handleRequest(writer, header, httpmsghandlerprovider.ShutdownRequest, nil, true, 0)
 986
 987         var errorResponse = parseJsonRequest(t, writer.Body)
 988         err := e2managererrors.NewHeaderValidationError()
 989
 990         assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
 991         assert.Equal(t, errorResponse.Code, err.Code)
 992         assert.Equal(t, errorResponse.Message, err.Message)
 993 }
 994
 995 func TestShutdownStatusNoContent(t *testing.T) {
 996         controller, readerMock, _, _, e2tInstancesManagerMock := setupControllerTest(t)
 997         e2tInstancesManagerMock.On("GetE2TAddresses").Return([]string{}, nil)
 998         readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{}, nil)
 999
1000         writer := httptest.NewRecorder()
1001         controller.Shutdown(writer, tests.GetHttpRequest())
1002
1003         assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
1004 }
1005
1006 func TestHandleInternalError(t *testing.T) {
1007         controller, _, _, _, _ := setupControllerTest(t)
1008
1009         writer := httptest.NewRecorder()
1010         err := e2managererrors.NewInternalError()
1011
1012         controller.handleErrorResponse(err, writer)
1013         var errorResponse = parseJsonRequest(t, writer.Body)
1014
1015         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1016         assert.Equal(t, errorResponse.Code, err.Code)
1017         assert.Equal(t, errorResponse.Message, err.Message)
1018 }
1019
1020 func TestHandleCommandAlreadyInProgressError(t *testing.T) {
1021         controller, _, _, _, _ := setupControllerTest(t)
1022         writer := httptest.NewRecorder()
1023         err := e2managererrors.NewCommandAlreadyInProgressError()
1024
1025         controller.handleErrorResponse(err, writer)
1026         var errorResponse = parseJsonRequest(t, writer.Body)
1027
1028         assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
1029         assert.Equal(t, errorResponse.Code, err.Code)
1030         assert.Equal(t, errorResponse.Message, err.Message)
1031 }
1032
1033 func TestHandleRoutingManagerError(t *testing.T) {
1034         controller, _, _, _, _ := setupControllerTest(t)
1035         writer := httptest.NewRecorder()
1036         err := e2managererrors.NewRoutingManagerError()
1037
1038         controller.handleErrorResponse(err, writer)
1039         var errorResponse = parseJsonRequest(t, writer.Body)
1040
1041         assert.Equal(t, http.StatusServiceUnavailable, writer.Result().StatusCode)
1042         assert.Equal(t, errorResponse.Code, err.Code)
1043         assert.Equal(t, errorResponse.Message, err.Message)
1044 }
1045
1046 func TestHandleE2TInstanceAbsenceError(t *testing.T) {
1047         controller, _, _, _, _ := setupControllerTest(t)
1048
1049         writer := httptest.NewRecorder()
1050         err := e2managererrors.NewE2TInstanceAbsenceError()
1051
1052         controller.handleErrorResponse(err, writer)
1053         var errorResponse = parseJsonRequest(t, writer.Body)
1054
1055         assert.Equal(t, http.StatusServiceUnavailable, writer.Result().StatusCode)
1056         assert.Equal(t, errorResponse.Code, err.Code)
1057         assert.Equal(t, errorResponse.Message, err.Message)
1058 }
1059
1060 func TestValidateHeaders(t *testing.T) {
1061         controller, _, _, _, _ := setupControllerTest(t)
1062
1063         header := http.Header{}
1064         header.Set("Content-Type", "application/json")
1065         result := controller.validateRequestHeader(&header)
1066
1067         assert.Nil(t, result)
1068 }
1069
1070 func parseJsonRequest(t *testing.T, r io.Reader) models.ErrorResponse {
1071
1072         var errorResponse models.ErrorResponse
1073         body, err := ioutil.ReadAll(r)
1074         if err != nil {
1075                 t.Errorf("Error cannot deserialize json request")
1076         }
1077         _ = json.Unmarshal(body, &errorResponse)
1078
1079         return errorResponse
1080 }
1081
1082 func initLog(t *testing.T) *logger.Logger {
1083         log, err := logger.InitLogger(logger.InfoLevel)
1084         if err != nil {
1085                 t.Errorf("#delete_all_request_handler_test.TestHandleSuccessFlow - failed to initialize logger, error: %s", err)
1086         }
1087         return log
1088 }
1089
1090 func TestX2ResetHandleSuccessfulRequestedCause(t *testing.T) {
1091         controller, readerMock, _, rmrMessengerMock, _ := setupControllerTest(t)
1092
1093         ranName := "test1"
1094         payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x40}
1095         var xAction []byte
1096         var msgSrc unsafe.Pointer
1097         msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction, msgSrc)
1098         rmrMessengerMock.On("SendMsg", msg, mock.Anything).Return(msg, nil)
1099
1100         writer := httptest.NewRecorder()
1101
1102         var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
1103         readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
1104
1105         data4Req := map[string]interface{}{"cause": "protocol:transfer-syntax-error"}
1106         b := new(bytes.Buffer)
1107         _ = json.NewEncoder(b).Encode(data4Req)
1108         req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
1109         req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
1110
1111         controller.X2Reset(writer, req)
1112         assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
1113
1114 }
1115
1116 func TestX2ResetHandleSuccessfulRequestedDefault(t *testing.T) {
1117         controller, readerMock, _, rmrMessengerMock, _ := setupControllerTest(t)
1118
1119         ranName := "test1"
1120         // o&m intervention
1121         payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x64}
1122         var xAction []byte
1123         var msgSrc unsafe.Pointer
1124         msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction, msgSrc)
1125         rmrMessengerMock.On("SendMsg", msg, true).Return(msg, nil)
1126
1127         writer := httptest.NewRecorder()
1128
1129         var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
1130         readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
1131
1132         // no body
1133         b := new(bytes.Buffer)
1134         data4Req := map[string]interface{}{}
1135         _ = json.NewEncoder(b).Encode(data4Req)
1136         req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
1137         req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
1138
1139         controller.X2Reset(writer, req)
1140         assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
1141 }
1142
1143 func TestX2ResetHandleFailureInvalidBody(t *testing.T) {
1144         controller, _, _, _, _ := setupControllerTest(t)
1145
1146         ranName := "test1"
1147
1148         writer := httptest.NewRecorder()
1149
1150         // Invalid json: attribute name without quotes (should be "cause":).
1151         b := strings.NewReader("{cause:\"protocol:transfer-syntax-error\"")
1152         req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
1153         req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
1154
1155         controller.X2Reset(writer, req)
1156         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1157
1158 }
1159
1160 func TestHandleErrorResponse(t *testing.T) {
1161         controller, _, _, _, _ := setupControllerTest(t)
1162
1163         writer := httptest.NewRecorder()
1164         controller.handleErrorResponse(e2managererrors.NewRnibDbError(), writer)
1165         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1166
1167         writer = httptest.NewRecorder()
1168         controller.handleErrorResponse(e2managererrors.NewCommandAlreadyInProgressError(), writer)
1169         assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
1170
1171         writer = httptest.NewRecorder()
1172         controller.handleErrorResponse(e2managererrors.NewHeaderValidationError(), writer)
1173         assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
1174
1175         writer = httptest.NewRecorder()
1176         controller.handleErrorResponse(e2managererrors.NewWrongStateError("", ""), writer)
1177         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1178
1179         writer = httptest.NewRecorder()
1180         controller.handleErrorResponse(e2managererrors.NewRequestValidationError(), writer)
1181         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1182
1183         writer = httptest.NewRecorder()
1184         controller.handleErrorResponse(e2managererrors.NewRmrError(), writer)
1185         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1186
1187         writer = httptest.NewRecorder()
1188         controller.handleErrorResponse(e2managererrors.NewResourceNotFoundError(), writer)
1189         assert.Equal(t, http.StatusNotFound, writer.Result().StatusCode)
1190
1191         writer = httptest.NewRecorder()
1192         controller.handleErrorResponse(fmt.Errorf("ErrorError"), writer)
1193         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1194 }
1195
1196 func getRmrSender(rmrMessengerMock *mocks.RmrMessengerMock, log *logger.Logger) *rmrsender.RmrSender {
1197         rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
1198         rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
1199         return rmrsender.NewRmrSender(log, rmrMessenger)
1200 }