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