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