E2Manager/controllers/nodeb_controller_test.go

   1 //
   2 // Copyright 2019 AT&T Intellectual Property
   3 // Copyright 2019 Nokia
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the "License");
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //      http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16
  17 //  This source code is part of the near-RT RIC (RAN Intelligent Controller)
  18 //  platform project (RICP).
  19
  20 package controllers
  21
  22 import (
  23         "bytes"
  24         "e2mgr/clients"
  25         "e2mgr/configuration"
  26         "e2mgr/e2managererrors"
  27         "e2mgr/logger"
  28         "e2mgr/managers"
  29         "e2mgr/mocks"
  30         "e2mgr/models"
  31         "e2mgr/providers/httpmsghandlerprovider"
  32         "e2mgr/rmrCgo"
  33         "e2mgr/services"
  34         "e2mgr/services/rmrsender"
  35         "e2mgr/tests"
  36         "encoding/json"
  37         "fmt"
  38         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
  39         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
  40         "github.com/golang/protobuf/jsonpb"
  41         "github.com/gorilla/mux"
  42         "github.com/pkg/errors"
  43         "github.com/stretchr/testify/assert"
  44         "github.com/stretchr/testify/mock"
  45         "io"
  46         "io/ioutil"
  47         "net/http"
  48         "net/http/httptest"
  49         "strings"
  50         "testing"
  51         "unsafe"
  52 )
  53
  54 const (
  55         RanName                      = "test"
  56         AssociatedE2TInstanceAddress = "10.0.2.15:38000"
  57         CorruptedJson                = "{\"errorCode\":401,\"errorMessage\":\"corrupted json\"}"
  58         ValidationFailureJson        = "{\"errorCode\":402,\"errorMessage\":\"Validation error\"}"
  59         ResourceNotFoundJson         = "{\"errorCode\":404,\"errorMessage\":\"Resource not found\"}"
  60         NodebExistsJson              = "{\"errorCode\":406,\"errorMessage\":\"Nodeb already exists\"}"
  61         RnibErrorJson                = "{\"errorCode\":500,\"errorMessage\":\"RNIB error\"}"
  62         InternalErrorJson            = "{\"errorCode\":501,\"errorMessage\":\"Internal Server Error. Please try again later\"}"
  63         AddEnbUrl                    = "/nodeb/enb"
  64 )
  65
  66 var (
  67         ServedNrCellInformationRequiredFields = []string{"cellId", "choiceNrMode", "nrMode", "servedPlmns"}
  68         NrNeighbourInformationRequiredFields  = []string{"nrCgi", "choiceNrMode", "nrMode"}
  69         AddEnbRequestRequiredFields           = []string{"ranName", "enb", "globalNbId"}
  70         UpdateEnbRequestRequiredFields        = []string{"enb"}
  71         GlobalIdRequiredFields                = []string{"plmnId", "nbId"}
  72         EnbRequiredFields                     = []string{"enbType", "servedCells"}
  73         ServedCellRequiredFields              = []string{"broadcastPlmns", "cellId", "choiceEutraMode", "eutraMode", "tac"}
  74 )
  75
  76 type controllerGetNodebTestContext struct {
  77         ranName              string
  78         nodebInfo            *entities.NodebInfo
  79         rnibError            error
  80         expectedStatusCode   int
  81         expectedJsonResponse string
  82 }
  83
  84 type controllerGetNodebIdListTestContext struct {
  85         nodebIdList          []*entities.NbIdentity
  86         rnibError            error
  87         expectedStatusCode   int
  88         expectedJsonResponse string
  89 }
  90
  91 type getNodebInfoResult struct {
  92         nodebInfo *entities.NodebInfo
  93         rnibError error
  94 }
  95
  96 type updateGnbCellsParams struct {
  97         err error
  98 }
  99
 100 type updateEnbCellsParams struct {
 101         err error
 102 }
 103
 104 type saveNodebParams struct {
 105         err error
 106 }
 107
 108 type addNbIdentityParams struct {
 109         err error
 110 }
 111
 112 type removeServedCellsParams struct {
 113         servedCellInfo []*entities.ServedCellInfo
 114         err            error
 115 }
 116
 117 type removeServedNrCellsParams struct {
 118         servedNrCells []*entities.ServedNRCell
 119         err           error
 120 }
 121
 122 type controllerUpdateEnbTestContext struct {
 123         getNodebInfoResult      *getNodebInfoResult
 124         removeServedCellsParams *removeServedCellsParams
 125         updateEnbCellsParams    *updateEnbCellsParams
 126         requestBody             map[string]interface{}
 127         expectedStatusCode      int
 128         expectedJsonResponse    string
 129 }
 130
 131 type controllerUpdateGnbTestContext struct {
 132         getNodebInfoResult        *getNodebInfoResult
 133         removeServedNrCellsParams *removeServedNrCellsParams
 134         updateGnbCellsParams      *updateGnbCellsParams
 135         requestBody               map[string]interface{}
 136         expectedStatusCode        int
 137         expectedJsonResponse      string
 138 }
 139
 140 type controllerAddEnbTestContext struct {
 141         getNodebInfoResult   *getNodebInfoResult
 142         saveNodebParams      *saveNodebParams
 143         addNbIdentityParams  *addNbIdentityParams
 144         requestBody          map[string]interface{}
 145         expectedStatusCode   int
 146         expectedJsonResponse string
 147 }
 148
 149 type controllerDeleteEnbTestContext struct {
 150         getNodebInfoResult   *getNodebInfoResult
 151         expectedStatusCode   int
 152         expectedJsonResponse string
 153 }
 154
 155 func generateServedNrCells(cellIds ...string) []*entities.ServedNRCell {
 156
 157         servedNrCells := []*entities.ServedNRCell{}
 158
 159         for _, v := range cellIds {
 160                 servedNrCells = append(servedNrCells, &entities.ServedNRCell{ServedNrCellInformation: &entities.ServedNRCellInformation{
 161                         CellId: v,
 162                         ChoiceNrMode: &entities.ServedNRCellInformation_ChoiceNRMode{
 163                                 Fdd: &entities.ServedNRCellInformation_ChoiceNRMode_FddInfo{
 164
 165                                 },
 166                         },
 167                         NrMode:      entities.Nr_FDD,
 168                         NrPci:       5,
 169                         ServedPlmns: []string{"whatever"},
 170                 }})
 171         }
 172
 173         return servedNrCells
 174 }
 175
 176 func generateServedCells(cellIds ...string) []*entities.ServedCellInfo {
 177
 178         var servedCells []*entities.ServedCellInfo
 179
 180         for i, v := range cellIds {
 181                 servedCells = append(servedCells, &entities.ServedCellInfo{
 182                         CellId: v,
 183                         ChoiceEutraMode: &entities.ChoiceEUTRAMode{
 184                                 Fdd: &entities.FddInfo{},
 185                         },
 186                         Pci:            uint32(i + 1),
 187                         BroadcastPlmns: []string{"whatever"},
 188                 })
 189         }
 190
 191         return servedCells
 192 }
 193
 194 func buildNrNeighbourInformation(propToOmit string) map[string]interface{} {
 195         ret := map[string]interface{}{
 196                 "nrCgi": "whatever",
 197                 "choiceNrMode": map[string]interface{}{
 198                         "tdd": map[string]interface{}{},
 199                 },
 200                 "nrMode": 1,
 201                 "nrPci":  1,
 202         }
 203
 204         if len(propToOmit) != 0 {
 205                 delete(ret, propToOmit)
 206         }
 207
 208         return ret
 209 }
 210
 211 func buildServedNrCellInformation(propToOmit string) map[string]interface{} {
 212         ret := map[string]interface{}{
 213                 "cellId": "whatever",
 214                 "choiceNrMode": map[string]interface{}{
 215                         "fdd": map[string]interface{}{},
 216                 },
 217                 "nrMode": 1,
 218                 "nrPci":  1,
 219                 "servedPlmns": []interface{}{
 220                         "whatever",
 221                 },
 222         }
 223
 224         if len(propToOmit) != 0 {
 225                 delete(ret, propToOmit)
 226         }
 227
 228         return ret
 229 }
 230
 231 func buildServedCell(propToOmit string) map[string]interface{} {
 232         ret := map[string]interface{}{
 233                 "cellId": "whatever",
 234                 "choiceEutraMode": map[string]interface{}{
 235                         "fdd": map[string]interface{}{},
 236                 },
 237                 "eutraMode": 1,
 238                 "pci":       1,
 239                 "tac":       "whatever3",
 240                 "broadcastPlmns": []interface{}{
 241                         "whatever",
 242                 },
 243         }
 244
 245         if len(propToOmit) != 0 {
 246                 delete(ret, propToOmit)
 247         }
 248
 249         return ret
 250 }
 251
 252 func getUpdateEnbRequest(propToOmit string) map[string]interface{} {
 253         ret := map[string]interface{}{
 254                 "enb": buildEnb(propToOmit),
 255         }
 256
 257         if len(propToOmit) != 0 {
 258                 delete(ret, propToOmit)
 259         }
 260
 261         return ret
 262 }
 263
 264 func getAddEnbRequest(propToOmit string) map[string]interface{} {
 265         ret := map[string]interface{}{
 266                 "ranName":    RanName,
 267                 "globalNbId": buildGlobalNbId(""),
 268                 "enb":        buildEnb(""),
 269         }
 270
 271         if len(propToOmit) != 0 {
 272                 delete(ret, propToOmit)
 273         }
 274
 275         return ret
 276 }
 277
 278 func buildEnb(propToOmit string) map[string]interface{} {
 279         ret := map[string]interface{}{
 280                 "enbType": 1,
 281                 "servedCells": []interface{}{
 282                         buildServedCell(""),
 283                 }}
 284
 285         if len(propToOmit) != 0 {
 286                 delete(ret, propToOmit)
 287         }
 288
 289         return ret
 290 }
 291
 292 func buildGlobalNbId(propToOmit string) map[string]interface{} {
 293         ret := map[string]interface{}{
 294                 "plmnId": "whatever",
 295                 "nbId":   "whatever2",
 296         }
 297
 298         if len(propToOmit) != 0 {
 299                 delete(ret, propToOmit)
 300         }
 301
 302         return ret
 303 }
 304
 305 func setupControllerTest(t *testing.T) (*NodebController, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.RmrMessengerMock, *mocks.E2TInstancesManagerMock, managers.RanListManager) {
 306         log := initLog(t)
 307         config := configuration.ParseConfiguration()
 308
 309         rmrMessengerMock := &mocks.RmrMessengerMock{}
 310         readerMock := &mocks.RnibReaderMock{}
 311
 312         writerMock := &mocks.RnibWriterMock{}
 313
 314         rnibDataService := services.NewRnibDataService(log, config, readerMock, writerMock)
 315         rmrSender := getRmrSender(rmrMessengerMock, log)
 316         e2tInstancesManager := &mocks.E2TInstancesManagerMock{}
 317         httpClientMock := &mocks.HttpClientMock{}
 318         rmClient := clients.NewRoutingManagerClient(log, config, httpClientMock)
 319         ranListManager := managers.NewRanListManager(log, rnibDataService)
 320         ranAlarmService := &mocks.RanAlarmServiceMock{}
 321         ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(log, rnibDataService, ranListManager, ranAlarmService)
 322         nodebValidator := managers.NewNodebValidator()
 323         updateEnbManager := managers.NewUpdateEnbManager(log, rnibDataService, nodebValidator)
 324         updateGnbManager := managers.NewUpdateGnbManager(log, rnibDataService, nodebValidator)
 325         handlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(log, rmrSender, config, rnibDataService, e2tInstancesManager, rmClient, ranConnectStatusChangeManager, nodebValidator, updateEnbManager, updateGnbManager, ranListManager)
 326         controller := NewNodebController(log, handlerProvider)
 327         return controller, readerMock, writerMock, rmrMessengerMock, e2tInstancesManager, ranListManager
 328 }
 329
 330 func setupDeleteEnbControllerTest(t *testing.T, preAddNbIdentity bool) (*NodebController, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *entities.NbIdentity) {
 331         log := initLog(t)
 332         config := configuration.ParseConfiguration()
 333
 334         rmrMessengerMock := &mocks.RmrMessengerMock{}
 335         readerMock := &mocks.RnibReaderMock{}
 336
 337         writerMock := &mocks.RnibWriterMock{}
 338
 339         rnibDataService := services.NewRnibDataService(log, config, readerMock, writerMock)
 340         rmrSender := getRmrSender(rmrMessengerMock, log)
 341         e2tInstancesManager := &mocks.E2TInstancesManagerMock{}
 342         httpClientMock := &mocks.HttpClientMock{}
 343         rmClient := clients.NewRoutingManagerClient(log, config, httpClientMock)
 344         ranListManager := managers.NewRanListManager(log, rnibDataService)
 345         var nbIdentity *entities.NbIdentity
 346         if preAddNbIdentity {
 347                 nbIdentity = &entities.NbIdentity{InventoryName: RanName, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
 348                 writerMock.On("AddNbIdentity", entities.Node_ENB, nbIdentity).Return(nil)
 349                 ranListManager.AddNbIdentity(entities.Node_ENB, nbIdentity)
 350         }
 351         ranAlarmService := &mocks.RanAlarmServiceMock{}
 352         ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(log, rnibDataService, ranListManager, ranAlarmService)
 353         nodebValidator := managers.NewNodebValidator()
 354         updateEnbManager := managers.NewUpdateEnbManager(log, rnibDataService, nodebValidator)
 355         updateGnbManager := managers.NewUpdateGnbManager(log, rnibDataService, nodebValidator)
 356
 357         handlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(log, rmrSender, config, rnibDataService, e2tInstancesManager, rmClient, ranConnectStatusChangeManager, nodebValidator, updateEnbManager, updateGnbManager, ranListManager)
 358         controller := NewNodebController(log, handlerProvider)
 359         return controller, readerMock, writerMock, nbIdentity
 360 }
 361
 362 func TestShutdownHandlerRnibError(t *testing.T) {
 363         controller, _, _, _, e2tInstancesManagerMock, _ := setupControllerTest(t)
 364         e2tInstancesManagerMock.On("GetE2TAddresses").Return([]string{}, e2managererrors.NewRnibDbError())
 365
 366         writer := httptest.NewRecorder()
 367
 368         controller.Shutdown(writer, tests.GetHttpRequest())
 369
 370         var errorResponse = parseJsonRequest(t, writer.Body)
 371
 372         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
 373         assert.Equal(t, errorResponse.Code, e2managererrors.NewRnibDbError().Code)
 374 }
 375
 376 func TestSetGeneralConfigurationHandlerRnibError(t *testing.T) {
 377         controller, readerMock, _, _, _, _ := setupControllerTest(t)
 378
 379         configuration := &entities.GeneralConfiguration{}
 380         readerMock.On("GetGeneralConfiguration").Return(configuration, e2managererrors.NewRnibDbError())
 381
 382         writer := httptest.NewRecorder()
 383
 384         httpRequest, _ := http.NewRequest("PUT", "https://localhost:3800/v1/nodeb/parameters", strings.NewReader("{\"enableRic\":false}"))
 385
 386         controller.SetGeneralConfiguration(writer, httpRequest)
 387
 388         var errorResponse = parseJsonRequest(t, writer.Body)
 389
 390         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
 391         assert.Equal(t, e2managererrors.NewRnibDbError().Code, errorResponse.Code)
 392 }
 393
 394 func TestSetGeneralConfigurationInvalidJson(t *testing.T) {
 395         controller, _, _, _, _, _ := setupControllerTest(t)
 396
 397         writer := httptest.NewRecorder()
 398
 399         httpRequest, _ := http.NewRequest("PUT", "https://localhost:3800/v1/nodeb/parameters", strings.NewReader("{\"enableRic\":false, \"someValue\":false}"))
 400
 401         controller.SetGeneralConfiguration(writer, httpRequest)
 402
 403         var errorResponse = parseJsonRequest(t, writer.Body)
 404
 405         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
 406         assert.Equal(t, e2managererrors.NewInvalidJsonError().Code, errorResponse.Code)
 407 }
 408
 409 func controllerGetNodebTestExecuter(t *testing.T, context *controllerGetNodebTestContext) {
 410         controller, readerMock, _, _, _, _ := setupControllerTest(t)
 411         writer := httptest.NewRecorder()
 412         readerMock.On("GetNodeb", context.ranName).Return(context.nodebInfo, context.rnibError)
 413         req, _ := http.NewRequest(http.MethodGet, "/nodeb", nil)
 414         req = mux.SetURLVars(req, map[string]string{"ranName": context.ranName})
 415         controller.GetNodeb(writer, req)
 416         assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
 417         bodyBytes, _ := ioutil.ReadAll(writer.Body)
 418         assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
 419 }
 420
 421 func controllerGetNodebIdListTestExecuter(t *testing.T, context *controllerGetNodebIdListTestContext) {
 422         controller, readerMock, _, _, _, ranListManager := setupControllerTest(t)
 423         writer := httptest.NewRecorder()
 424         readerMock.On("GetListNodebIds").Return(context.nodebIdList, context.rnibError)
 425
 426         err := ranListManager.InitNbIdentityMap()
 427         if err != nil {
 428                 t.Errorf("Error cannot init identity")
 429         }
 430
 431         req, _ := http.NewRequest(http.MethodGet, "/nodeb/states", nil)
 432         controller.GetNodebIdList(writer, req)
 433         assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
 434         bodyBytes, _ := ioutil.ReadAll(writer.Body)
 435         assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
 436 }
 437
 438 func activateControllerUpdateEnbMocks(context *controllerUpdateEnbTestContext, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock, updateEnbRequest *models.UpdateEnbRequest) {
 439         if context.getNodebInfoResult != nil {
 440                 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
 441         }
 442
 443         if context.removeServedCellsParams != nil {
 444                 writerMock.On("RemoveServedCells", RanName, context.removeServedCellsParams.servedCellInfo).Return(context.removeServedCellsParams.err)
 445         }
 446
 447         if context.updateEnbCellsParams != nil {
 448                 updatedNodebInfo := *context.getNodebInfoResult.nodebInfo
 449                 updatedNodebInfo.Configuration = &entities.NodebInfo_Enb{Enb: updateEnbRequest.Enb}
 450
 451                 writerMock.On("UpdateEnb", &updatedNodebInfo, updateEnbRequest.Enb.ServedCells).Return(context.updateEnbCellsParams.err)
 452         }
 453 }
 454
 455 func activateControllerUpdateGnbMocks(context *controllerUpdateGnbTestContext, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
 456         if context.getNodebInfoResult != nil {
 457                 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
 458         }
 459
 460         if context.removeServedNrCellsParams != nil {
 461                 writerMock.On("RemoveServedNrCells", RanName, context.removeServedNrCellsParams.servedNrCells).Return(context.removeServedNrCellsParams.err)
 462         }
 463
 464         if context.updateGnbCellsParams != nil {
 465                 updatedNodebInfo := *context.getNodebInfoResult.nodebInfo
 466                 gnb := entities.Gnb{}
 467                 _ = jsonpb.Unmarshal(getJsonRequestAsBuffer(context.requestBody), &gnb)
 468                 updatedGnb := *updatedNodebInfo.GetGnb()
 469                 updatedGnb.ServedNrCells = gnb.ServedNrCells
 470                 writerMock.On("UpdateGnbCells", &updatedNodebInfo, gnb.ServedNrCells).Return(context.updateGnbCellsParams.err)
 471         }
 472 }
 473
 474 func assertControllerUpdateGnb(t *testing.T, context *controllerUpdateGnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
 475         assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
 476         bodyBytes, _ := ioutil.ReadAll(writer.Body)
 477         assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
 478         readerMock.AssertExpectations(t)
 479         writerMock.AssertExpectations(t)
 480 }
 481
 482 func assertControllerUpdateEnb(t *testing.T, context *controllerUpdateEnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
 483         assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
 484         bodyBytes, _ := ioutil.ReadAll(writer.Body)
 485         assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
 486         readerMock.AssertExpectations(t)
 487         writerMock.AssertExpectations(t)
 488 }
 489
 490 func assertControllerAddEnb(t *testing.T, context *controllerAddEnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
 491         assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
 492         bodyBytes, _ := ioutil.ReadAll(writer.Body)
 493         assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
 494         readerMock.AssertExpectations(t)
 495         writerMock.AssertExpectations(t)
 496 }
 497
 498 func assertControllerDeleteEnb(t *testing.T, context *controllerDeleteEnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
 499         assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
 500         bodyBytes, _ := ioutil.ReadAll(writer.Body)
 501         assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
 502         readerMock.AssertExpectations(t)
 503         writerMock.AssertExpectations(t)
 504 }
 505
 506 func buildUpdateEnbRequest(context *controllerUpdateEnbTestContext) *http.Request {
 507         updateEnbUrl := fmt.Sprintf("/nodeb/enb/%s", RanName)
 508         requestBody := getJsonRequestAsBuffer(context.requestBody)
 509         req, _ := http.NewRequest(http.MethodPut, updateEnbUrl, requestBody)
 510         req.Header.Set("Content-Type", "application/json")
 511         req = mux.SetURLVars(req, map[string]string{"ranName": RanName})
 512         return req
 513 }
 514
 515 func buildUpdateGnbRequest(context *controllerUpdateGnbTestContext) *http.Request {
 516         updateGnbUrl := fmt.Sprintf("/nodeb/gnb/%s", RanName)
 517         requestBody := getJsonRequestAsBuffer(context.requestBody)
 518         req, _ := http.NewRequest(http.MethodPut, updateGnbUrl, requestBody)
 519         req.Header.Set("Content-Type", "application/json")
 520         req = mux.SetURLVars(req, map[string]string{"ranName": RanName})
 521         return req
 522 }
 523
 524 func buildAddEnbRequest(context *controllerAddEnbTestContext) *http.Request {
 525         requestBody := getJsonRequestAsBuffer(context.requestBody)
 526         req, _ := http.NewRequest(http.MethodPost, AddEnbUrl, requestBody)
 527         req.Header.Set("Content-Type", "application/json")
 528         return req
 529 }
 530
 531 func controllerUpdateEnbTestExecuter(t *testing.T, context *controllerUpdateEnbTestContext) {
 532         controller, readerMock, writerMock, _, _, _ := setupControllerTest(t)
 533         writer := httptest.NewRecorder()
 534
 535         r := buildUpdateEnbRequest(context)
 536         body, _ := ioutil.ReadAll(io.LimitReader(r.Body, LimitRequest))
 537
 538         updateEnbRequest := models.UpdateEnbRequest{}
 539         _ = json.Unmarshal(body, &updateEnbRequest)
 540
 541         activateControllerUpdateEnbMocks(context, readerMock, writerMock, &updateEnbRequest)
 542         r = buildUpdateEnbRequest(context)
 543         defer r.Body.Close()
 544
 545         controller.UpdateEnb(writer, r)
 546
 547         assertControllerUpdateEnb(t, context, writer, readerMock, writerMock)
 548 }
 549
 550 func controllerUpdateGnbTestExecuter(t *testing.T, context *controllerUpdateGnbTestContext) {
 551         controller, readerMock, writerMock, _, _, _ := setupControllerTest(t)
 552         writer := httptest.NewRecorder()
 553
 554         activateControllerUpdateGnbMocks(context, readerMock, writerMock)
 555         req := buildUpdateGnbRequest(context)
 556         controller.UpdateGnb(writer, req)
 557         assertControllerUpdateGnb(t, context, writer, readerMock, writerMock)
 558 }
 559
 560 func activateControllerAddEnbMocks(context *controllerAddEnbTestContext, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock, addEnbRequest *models.AddEnbRequest) {
 561         if context.getNodebInfoResult != nil {
 562                 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
 563         }
 564
 565         if context.saveNodebParams != nil {
 566                 nodebInfo := entities.NodebInfo{
 567                         RanName:          addEnbRequest.RanName,
 568                         Ip:               addEnbRequest.Ip,
 569                         Port:             addEnbRequest.Port,
 570                         NodeType:         entities.Node_ENB,
 571                         GlobalNbId:       addEnbRequest.GlobalNbId,
 572                         Configuration:    &entities.NodebInfo_Enb{Enb: addEnbRequest.Enb},
 573                         ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,
 574                 }
 575
 576                 writerMock.On("SaveNodeb", &nodebInfo).Return(context.saveNodebParams.err)
 577         }
 578
 579         if context.addNbIdentityParams != nil {
 580                 nbIdentity := entities.NbIdentity{InventoryName: addEnbRequest.RanName, GlobalNbId: addEnbRequest.GlobalNbId, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED}
 581                 writerMock.On("AddNbIdentity", entities.Node_ENB, &nbIdentity).Return(context.addNbIdentityParams.err)
 582         }
 583 }
 584
 585 func controllerAddEnbTestExecuter(t *testing.T, context *controllerAddEnbTestContext) {
 586         controller, readerMock, writerMock, _, _, _ := setupControllerTest(t)
 587         writer := httptest.NewRecorder()
 588         r := buildAddEnbRequest(context)
 589         body, _ := ioutil.ReadAll(io.LimitReader(r.Body, LimitRequest))
 590
 591         addEnbRequest := models.AddEnbRequest{}
 592
 593         _ = json.Unmarshal(body, &addEnbRequest)
 594         activateControllerAddEnbMocks(context, readerMock, writerMock, &addEnbRequest)
 595         r = buildAddEnbRequest(context)
 596         defer r.Body.Close()
 597         controller.AddEnb(writer, r)
 598         assertControllerAddEnb(t, context, writer, readerMock, writerMock)
 599 }
 600
 601 func controllerDeleteEnbTestExecuter(t *testing.T, context *controllerDeleteEnbTestContext, preAddNbIdentity bool) {
 602         controller, readerMock, writerMock, nbIdentity := setupDeleteEnbControllerTest(t, preAddNbIdentity)
 603         readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
 604         if context.getNodebInfoResult.rnibError == nil && context.getNodebInfoResult.nodebInfo.GetNodeType() == entities.Node_ENB {
 605                 writerMock.On("RemoveEnb", context.getNodebInfoResult.nodebInfo).Return(nil)
 606                 if preAddNbIdentity {
 607                         writerMock.On("RemoveNbIdentity", entities.Node_ENB, nbIdentity).Return(nil)
 608                 }
 609         }
 610         writer := httptest.NewRecorder()
 611         r, _ := http.NewRequest(http.MethodDelete, AddEnbUrl+"/"+RanName, nil)
 612         r.Header.Set("Content-Type", "application/json")
 613         r = mux.SetURLVars(r, map[string]string{"ranName": RanName})
 614         controller.DeleteEnb(writer, r)
 615         assertControllerDeleteEnb(t, context, writer, readerMock, writerMock)
 616 }
 617
 618 /*
 619 UpdateGnb UTs
 620 */
 621
 622 // BEGIN - UpdateGnb Validation Failure UTs
 623
 624 func TestControllerUpdateGnbEmptyServedNrCells(t *testing.T) {
 625         context := controllerUpdateGnbTestContext{
 626                 getNodebInfoResult: nil,
 627                 requestBody: map[string]interface{}{
 628                         "servedNrCells": []interface{}{
 629                         },
 630                 },
 631                 expectedStatusCode:   http.StatusBadRequest,
 632                 expectedJsonResponse: ValidationFailureJson,
 633         }
 634
 635         controllerUpdateGnbTestExecuter(t, &context)
 636 }
 637
 638 func TestControllerUpdateGnbMissingServedNrCellInformation(t *testing.T) {
 639         context := controllerUpdateGnbTestContext{
 640                 getNodebInfoResult: nil,
 641                 requestBody: map[string]interface{}{
 642                         "servedNrCells": []interface{}{
 643                                 map[string]interface{}{
 644                                         "servedNrCellInformation": nil,
 645                                 },
 646                         },
 647                 },
 648                 expectedStatusCode:   http.StatusBadRequest,
 649                 expectedJsonResponse: ValidationFailureJson,
 650         }
 651
 652         controllerUpdateGnbTestExecuter(t, &context)
 653 }
 654
 655 func TestControllerUpdateGnbMissingServedNrCellRequiredProp(t *testing.T) {
 656
 657         for _, v := range ServedNrCellInformationRequiredFields {
 658                 context := controllerUpdateGnbTestContext{
 659                         getNodebInfoResult: nil,
 660                         requestBody: map[string]interface{}{
 661                                 "servedNrCells": []interface{}{
 662                                         map[string]interface{}{
 663                                                 "servedNrCellInformation": buildServedNrCellInformation(v),
 664                                         },
 665                                 },
 666                         },
 667                         expectedStatusCode:   http.StatusBadRequest,
 668                         expectedJsonResponse: ValidationFailureJson,
 669                 }
 670
 671                 controllerUpdateGnbTestExecuter(t, &context)
 672         }
 673 }
 674
 675 func TestControllerUpdateGnbMissingServedNrCellFddOrTdd(t *testing.T) {
 676
 677         servedNrCellInformation := buildServedNrCellInformation("")
 678         servedNrCellInformation["choiceNrMode"] = map[string]interface{}{}
 679
 680         context := controllerUpdateGnbTestContext{
 681                 getNodebInfoResult: nil,
 682                 requestBody: map[string]interface{}{
 683                         "servedNrCells": []interface{}{
 684                                 map[string]interface{}{
 685                                         "servedNrCellInformation": servedNrCellInformation,
 686                                 },
 687                         },
 688                 },
 689                 expectedStatusCode:   http.StatusBadRequest,
 690                 expectedJsonResponse: ValidationFailureJson,
 691         }
 692
 693         controllerUpdateGnbTestExecuter(t, &context)
 694 }
 695
 696 func TestControllerUpdateGnbMissingNeighbourInfoFddOrTdd(t *testing.T) {
 697
 698         nrNeighbourInfo := buildNrNeighbourInformation("")
 699         nrNeighbourInfo["choiceNrMode"] = map[string]interface{}{}
 700
 701         context := controllerUpdateGnbTestContext{
 702                 getNodebInfoResult: nil,
 703                 requestBody: map[string]interface{}{
 704                         "servedNrCells": []interface{}{
 705                                 map[string]interface{}{
 706                                         "servedNrCellInformation": buildServedNrCellInformation(""),
 707                                         "nrNeighbourInfos": []interface{}{
 708                                                 nrNeighbourInfo,
 709                                         },
 710                                 },
 711                         },
 712                 },
 713                 expectedStatusCode:   http.StatusBadRequest,
 714                 expectedJsonResponse: ValidationFailureJson,
 715         }
 716
 717         controllerUpdateGnbTestExecuter(t, &context)
 718 }
 719
 720 func TestControllerUpdateGnbMissingNrNeighbourInformationRequiredProp(t *testing.T) {
 721
 722         for _, v := range NrNeighbourInformationRequiredFields {
 723                 context := controllerUpdateGnbTestContext{
 724                         getNodebInfoResult: nil,
 725                         requestBody: map[string]interface{}{
 726                                 "servedNrCells": []interface{}{
 727                                         map[string]interface{}{
 728                                                 "servedNrCellInformation": buildServedNrCellInformation(""),
 729                                                 "nrNeighbourInfos": []interface{}{
 730                                                         buildNrNeighbourInformation(v),
 731                                                 },
 732                                         },
 733                                 },
 734                         },
 735                         expectedStatusCode:   http.StatusBadRequest,
 736                         expectedJsonResponse: ValidationFailureJson,
 737                 }
 738
 739                 controllerUpdateGnbTestExecuter(t, &context)
 740         }
 741 }
 742
 743 // END - UpdateGnb Validation Failure UTs
 744
 745 func TestControllerUpdateGnbValidServedNrCellInformationGetNodebNotFound(t *testing.T) {
 746         context := controllerUpdateGnbTestContext{
 747                 getNodebInfoResult: &getNodebInfoResult{
 748                         nodebInfo: nil,
 749                         rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
 750                 },
 751                 requestBody: map[string]interface{}{
 752                         "servedNrCells": []interface{}{
 753                                 map[string]interface{}{
 754                                         "servedNrCellInformation": buildServedNrCellInformation(""),
 755                                 },
 756                         },
 757                 },
 758                 expectedStatusCode:   http.StatusNotFound,
 759                 expectedJsonResponse: ResourceNotFoundJson,
 760         }
 761
 762         controllerUpdateGnbTestExecuter(t, &context)
 763 }
 764
 765 func TestControllerUpdateGnbValidServedNrCellInformationGetNodebInternalError(t *testing.T) {
 766         context := controllerUpdateGnbTestContext{
 767                 getNodebInfoResult: &getNodebInfoResult{
 768                         nodebInfo: nil,
 769                         rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
 770                 },
 771                 requestBody: map[string]interface{}{
 772                         "servedNrCells": []interface{}{
 773                                 map[string]interface{}{
 774                                         "servedNrCellInformation": buildServedNrCellInformation(""),
 775                                 },
 776                         },
 777                 },
 778                 expectedStatusCode:   http.StatusInternalServerError,
 779                 expectedJsonResponse: RnibErrorJson,
 780         }
 781
 782         controllerUpdateGnbTestExecuter(t, &context)
 783 }
 784
 785 func TestControllerUpdateGnbGetNodebSuccessInvalidGnbConfiguration(t *testing.T) {
 786         context := controllerUpdateGnbTestContext{
 787                 getNodebInfoResult: &getNodebInfoResult{
 788                         nodebInfo: &entities.NodebInfo{
 789                                 RanName:                      RanName,
 790                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
 791                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
 792                                 NodeType:                     entities.Node_ENB,
 793                         },
 794                         rnibError: nil,
 795                 },
 796                 requestBody: map[string]interface{}{
 797                         "servedNrCells": []interface{}{
 798                                 map[string]interface{}{
 799                                         "servedNrCellInformation": buildServedNrCellInformation(""),
 800                                         "nrNeighbourInfos": []interface{}{
 801                                                 buildNrNeighbourInformation(""),
 802                                         },
 803                                 },
 804                         },
 805                 },
 806                 expectedStatusCode:   http.StatusBadRequest,
 807                 expectedJsonResponse: ValidationFailureJson,
 808         }
 809
 810         controllerUpdateGnbTestExecuter(t, &context)
 811 }
 812
 813 func TestControllerUpdateGnbGetNodebSuccessRemoveServedNrCellsFailure(t *testing.T) {
 814         oldServedNrCells := generateServedNrCells("whatever1", "whatever2")
 815         context := controllerUpdateGnbTestContext{
 816                 removeServedNrCellsParams: &removeServedNrCellsParams{
 817                         err:           common.NewInternalError(errors.New("#writer.UpdateGnbCells - Internal Error")),
 818                         servedNrCells: oldServedNrCells,
 819                 },
 820                 getNodebInfoResult: &getNodebInfoResult{
 821                         nodebInfo: &entities.NodebInfo{
 822                                 RanName:                      RanName,
 823                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
 824                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
 825                                 Configuration:                &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{ServedNrCells: oldServedNrCells}},
 826                                 NodeType:                     entities.Node_GNB,
 827                         },
 828                         rnibError: nil,
 829                 },
 830                 requestBody: map[string]interface{}{
 831                         "servedNrCells": []interface{}{
 832                                 map[string]interface{}{
 833                                         "servedNrCellInformation": buildServedNrCellInformation(""),
 834                                         "nrNeighbourInfos": []interface{}{
 835                                                 buildNrNeighbourInformation(""),
 836                                         },
 837                                 },
 838                         },
 839                 },
 840                 expectedStatusCode:   http.StatusInternalServerError,
 841                 expectedJsonResponse: RnibErrorJson,
 842         }
 843
 844         controllerUpdateGnbTestExecuter(t, &context)
 845 }
 846
 847 func TestControllerUpdateGnbGetNodebSuccessUpdateGnbCellsFailure(t *testing.T) {
 848         oldServedNrCells := generateServedNrCells("whatever1", "whatever2")
 849         context := controllerUpdateGnbTestContext{
 850                 removeServedNrCellsParams: &removeServedNrCellsParams{
 851                         err:           nil,
 852                         servedNrCells: oldServedNrCells,
 853                 },
 854                 updateGnbCellsParams: &updateGnbCellsParams{
 855                         err: common.NewInternalError(errors.New("#writer.UpdateGnbCells - Internal Error")),
 856                 },
 857                 getNodebInfoResult: &getNodebInfoResult{
 858                         nodebInfo: &entities.NodebInfo{
 859                                 RanName:                      RanName,
 860                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
 861                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
 862                                 Configuration:                &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{ServedNrCells: oldServedNrCells}},
 863                                 NodeType:                     entities.Node_GNB,
 864                         },
 865                         rnibError: nil,
 866                 },
 867                 requestBody: map[string]interface{}{
 868                         "servedNrCells": []interface{}{
 869                                 map[string]interface{}{
 870                                         "servedNrCellInformation": buildServedNrCellInformation(""),
 871                                         "nrNeighbourInfos": []interface{}{
 872                                                 buildNrNeighbourInformation(""),
 873                                         },
 874                                 },
 875                         },
 876                 },
 877                 expectedStatusCode:   http.StatusInternalServerError,
 878                 expectedJsonResponse: RnibErrorJson,
 879         }
 880
 881         controllerUpdateGnbTestExecuter(t, &context)
 882 }
 883
 884 func TestControllerUpdateGnbExistingEmptyCellsSuccess(t *testing.T) {
 885         oldServedNrCells := []*entities.ServedNRCell{}
 886
 887         context := controllerUpdateGnbTestContext{
 888                 updateGnbCellsParams: &updateGnbCellsParams{
 889                         err: nil,
 890                 },
 891                 getNodebInfoResult: &getNodebInfoResult{
 892                         nodebInfo: &entities.NodebInfo{
 893                                 RanName:                      RanName,
 894                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
 895                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
 896                                 Configuration:                &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{ServedNrCells: oldServedNrCells}},
 897                                 NodeType:                     entities.Node_GNB,
 898                         },
 899                         rnibError: nil,
 900                 },
 901                 requestBody: map[string]interface{}{
 902                         "servedNrCells": []interface{}{
 903                                 map[string]interface{}{
 904                                         "servedNrCellInformation": buildServedNrCellInformation(""),
 905                                         "nrNeighbourInfos": []interface{}{
 906                                                 buildNrNeighbourInformation(""),
 907                                         },
 908                                 },
 909                         },
 910                 },
 911                 expectedStatusCode:   http.StatusOK,
 912                 expectedJsonResponse: "{\"ranName\":\"test\",\"connectionStatus\":\"CONNECTED\",\"nodeType\":\"GNB\",\"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\"}",
 913         }
 914
 915         controllerUpdateGnbTestExecuter(t, &context)
 916 }
 917
 918 func TestControllerUpdateGnbSuccess(t *testing.T) {
 919         oldServedNrCells := generateServedNrCells("whatever1", "whatever2")
 920
 921         context := controllerUpdateGnbTestContext{
 922                 removeServedNrCellsParams: &removeServedNrCellsParams{
 923                         err:           nil,
 924                         servedNrCells: oldServedNrCells,
 925                 },
 926                 updateGnbCellsParams: &updateGnbCellsParams{
 927                         err: nil,
 928                 },
 929                 getNodebInfoResult: &getNodebInfoResult{
 930                         nodebInfo: &entities.NodebInfo{
 931                                 RanName:                      RanName,
 932                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
 933                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
 934                                 Configuration:                &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{ServedNrCells: oldServedNrCells}},
 935                                 NodeType:                     entities.Node_GNB,
 936                         },
 937                         rnibError: nil,
 938                 },
 939                 requestBody: map[string]interface{}{
 940                         "servedNrCells": []interface{}{
 941                                 map[string]interface{}{
 942                                         "servedNrCellInformation": buildServedNrCellInformation(""),
 943                                         "nrNeighbourInfos": []interface{}{
 944                                                 buildNrNeighbourInformation(""),
 945                                         },
 946                                 },
 947                         },
 948                 },
 949                 expectedStatusCode:   http.StatusOK,
 950                 expectedJsonResponse: "{\"ranName\":\"test\",\"connectionStatus\":\"CONNECTED\",\"nodeType\":\"GNB\",\"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\"}",
 951         }
 952
 953         controllerUpdateGnbTestExecuter(t, &context)
 954 }
 955
 956 /*
 957 UpdateEnb UTs
 958 */
 959
 960 func TestControllerUpdateEnbInvalidRequest(t *testing.T) {
 961         controller, _, _, _, _, _ := setupControllerTest(t)
 962
 963         writer := httptest.NewRecorder()
 964         invalidJson := strings.NewReader("{enb:\"whatever\"")
 965
 966         updateEnbUrl := fmt.Sprintf("/nodeb/enb/%s", RanName)
 967         req, _ := http.NewRequest(http.MethodPut, updateEnbUrl, invalidJson)
 968         req.Header.Set("Content-Type", "application/json")
 969         req = mux.SetURLVars(req, map[string]string{"ranName": RanName})
 970
 971         controller.UpdateEnb(writer, req)
 972
 973         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
 974         bodyBytes, _ := ioutil.ReadAll(writer.Body)
 975         assert.Equal(t, CorruptedJson, string(bodyBytes))
 976 }
 977
 978 func TestControllerUpdateEnbEmptyEnbType(t *testing.T) {
 979         context := controllerUpdateEnbTestContext{
 980                 getNodebInfoResult:   nil,
 981                 requestBody:          getUpdateEnbRequest(EnbRequiredFields[0]),
 982                 expectedStatusCode:   http.StatusBadRequest,
 983                 expectedJsonResponse: ValidationFailureJson,
 984         }
 985
 986         controllerUpdateEnbTestExecuter(t, &context)
 987 }
 988
 989 func TestControllerUpdateEnbEmptyServedCells(t *testing.T) {
 990         context := controllerUpdateEnbTestContext{
 991                 getNodebInfoResult:   nil,
 992                 requestBody:          getUpdateEnbRequest(EnbRequiredFields[1]),
 993                 expectedStatusCode:   http.StatusBadRequest,
 994                 expectedJsonResponse: ValidationFailureJson,
 995         }
 996
 997         controllerUpdateEnbTestExecuter(t, &context)
 998 }
 999
1000 func TestControllerUpdateEnbMissingEnb(t *testing.T) {
1001         context := controllerUpdateEnbTestContext{
1002                 getNodebInfoResult:   nil,
1003                 requestBody:          getUpdateEnbRequest(UpdateEnbRequestRequiredFields[0]),
1004                 expectedStatusCode:   http.StatusBadRequest,
1005                 expectedJsonResponse: ValidationFailureJson,
1006         }
1007
1008         controllerUpdateEnbTestExecuter(t, &context)
1009 }
1010
1011 func TestControllerUpdateEnbMissingRequiredServedCellProps(t *testing.T) {
1012
1013         r := getUpdateEnbRequest("")
1014
1015         for _, v := range ServedCellRequiredFields {
1016                 enb := r["enb"]
1017
1018                 enbMap, _ := enb.(map[string]interface{})
1019
1020                 enbMap["servedCells"] = []interface{}{
1021                         buildServedCell(v),
1022                 }
1023
1024                 context := controllerUpdateEnbTestContext{
1025                         requestBody:          r,
1026                         expectedStatusCode:   http.StatusBadRequest,
1027                         expectedJsonResponse: ValidationFailureJson,
1028                 }
1029
1030                 controllerUpdateEnbTestExecuter(t, &context)
1031         }
1032 }
1033
1034 func TestControllerUpdateEnbValidServedCellsGetNodebNotFound(t *testing.T) {
1035         context := controllerUpdateEnbTestContext{
1036                 getNodebInfoResult: &getNodebInfoResult{
1037                         nodebInfo: nil,
1038                         rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1039                 },
1040                 requestBody:          getUpdateEnbRequest(""),
1041                 expectedStatusCode:   http.StatusNotFound,
1042                 expectedJsonResponse: ResourceNotFoundJson,
1043         }
1044
1045         controllerUpdateEnbTestExecuter(t, &context)
1046 }
1047
1048 func TestControllerUpdateEnbValidServedCellsGetNodebInternalError(t *testing.T) {
1049         context := controllerUpdateEnbTestContext{
1050                 getNodebInfoResult: &getNodebInfoResult{
1051                         nodebInfo: nil,
1052                         rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
1053                 },
1054                 requestBody:          getUpdateEnbRequest(""),
1055                 expectedStatusCode:   http.StatusInternalServerError,
1056                 expectedJsonResponse: RnibErrorJson,
1057         }
1058
1059         controllerUpdateEnbTestExecuter(t, &context)
1060 }
1061
1062 func TestControllerUpdateEnbGetNodebSuccessGnbTypeFailure(t *testing.T) {
1063         oldServedCells := generateServedCells("whatever1", "whatever2")
1064         context := controllerUpdateEnbTestContext{
1065                 getNodebInfoResult: &getNodebInfoResult{
1066                         nodebInfo: &entities.NodebInfo{
1067                                 RanName:                      RanName,
1068                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
1069                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1070                                 NodeType:                     entities.Node_GNB,
1071                                 Configuration:                &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells}},
1072                         },
1073                         rnibError: nil,
1074                 },
1075                 requestBody:          getUpdateEnbRequest(""),
1076                 expectedStatusCode:   http.StatusBadRequest,
1077                 expectedJsonResponse: ValidationFailureJson,
1078         }
1079
1080         controllerUpdateEnbTestExecuter(t, &context)
1081 }
1082
1083 func TestControllerUpdateEnbGetNodebSuccessRemoveServedCellsFailure(t *testing.T) {
1084         oldServedCells := generateServedCells("whatever1", "whatever2")
1085         context := controllerUpdateEnbTestContext{
1086                 removeServedCellsParams: &removeServedCellsParams{
1087                         err:            common.NewInternalError(errors.New("#writer.RemoveServedCells - Internal Error")),
1088                         servedCellInfo: oldServedCells,
1089                 },
1090                 getNodebInfoResult: &getNodebInfoResult{
1091                         nodebInfo: &entities.NodebInfo{
1092                                 RanName:                      RanName,
1093                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
1094                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1095                                 NodeType:                     entities.Node_ENB,
1096                                 Configuration:                &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells}},
1097                         },
1098                         rnibError: nil,
1099                 },
1100                 requestBody:          getUpdateEnbRequest(""),
1101                 expectedStatusCode:   http.StatusInternalServerError,
1102                 expectedJsonResponse: RnibErrorJson,
1103         }
1104
1105         controllerUpdateEnbTestExecuter(t, &context)
1106 }
1107
1108 func TestControllerUpdateEnbGetNodebSuccessUpdateEnbFailure(t *testing.T) {
1109         oldServedCells := generateServedCells("whatever1", "whatever2")
1110         context := controllerUpdateEnbTestContext{
1111                 removeServedCellsParams: &removeServedCellsParams{
1112                         err:            nil,
1113                         servedCellInfo: oldServedCells,
1114                 },
1115                 updateEnbCellsParams: &updateEnbCellsParams{
1116                         err: common.NewInternalError(errors.New("#writer.UpdateEnb - Internal Error")),
1117                 },
1118                 getNodebInfoResult: &getNodebInfoResult{
1119                         nodebInfo: &entities.NodebInfo{
1120                                 RanName:                      RanName,
1121                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
1122                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1123                                 NodeType:                     entities.Node_ENB,
1124                                 Configuration:                &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells, EnbType: entities.EnbType_MACRO_ENB}},
1125                         },
1126                         rnibError: nil,
1127                 },
1128                 requestBody:          getUpdateEnbRequest(""),
1129                 expectedStatusCode:   http.StatusInternalServerError,
1130                 expectedJsonResponse: RnibErrorJson,
1131         }
1132
1133         controllerUpdateEnbTestExecuter(t, &context)
1134 }
1135
1136 func TestControllerUpdateEnbExistingEmptyCellsSuccess(t *testing.T) {
1137         oldServedCells := []*entities.ServedCellInfo{}
1138         context := controllerUpdateEnbTestContext{
1139                 updateEnbCellsParams: &updateEnbCellsParams{
1140                         err: nil,
1141                 },
1142                 getNodebInfoResult: &getNodebInfoResult{
1143                         nodebInfo: &entities.NodebInfo{
1144                                 RanName:                      RanName,
1145                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
1146                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1147                                 NodeType:                     entities.Node_ENB,
1148                                 Configuration:                &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells, EnbType: entities.EnbType_MACRO_ENB}},
1149                         },
1150                         rnibError: nil,
1151                 },
1152                 requestBody:          getUpdateEnbRequest(""),
1153                 expectedStatusCode:   http.StatusOK,
1154                 expectedJsonResponse: "{\"ranName\":\"test\",\"connectionStatus\":\"CONNECTED\",\"nodeType\":\"ENB\",\"enb\":{\"enbType\":\"MACRO_ENB\",\"servedCells\":[{\"pci\":1,\"cellId\":\"whatever\",\"tac\":\"whatever3\",\"broadcastPlmns\":[\"whatever\"],\"choiceEutraMode\":{\"fdd\":{}},\"eutraMode\":\"FDD\"}]},\"associatedE2tInstanceAddress\":\"10.0.2.15:38000\"}",
1155         }
1156
1157         controllerUpdateEnbTestExecuter(t, &context)
1158 }
1159
1160
1161 func TestControllerUpdateEnbSuccess(t *testing.T) {
1162         oldServedCells := generateServedCells("whatever1", "whatever2")
1163         context := controllerUpdateEnbTestContext{
1164                 removeServedCellsParams: &removeServedCellsParams{
1165                         err:            nil,
1166                         servedCellInfo: oldServedCells,
1167                 },
1168                 updateEnbCellsParams: &updateEnbCellsParams{
1169                         err: nil,
1170                 },
1171                 getNodebInfoResult: &getNodebInfoResult{
1172                         nodebInfo: &entities.NodebInfo{
1173                                 RanName:                      RanName,
1174                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
1175                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1176                                 NodeType:                     entities.Node_ENB,
1177                                 Configuration:                &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells, EnbType: entities.EnbType_MACRO_ENB}},
1178                         },
1179                         rnibError: nil,
1180                 },
1181                 requestBody:          getUpdateEnbRequest(""),
1182                 expectedStatusCode:   http.StatusOK,
1183                 expectedJsonResponse: "{\"ranName\":\"test\",\"connectionStatus\":\"CONNECTED\",\"nodeType\":\"ENB\",\"enb\":{\"enbType\":\"MACRO_ENB\",\"servedCells\":[{\"pci\":1,\"cellId\":\"whatever\",\"tac\":\"whatever3\",\"broadcastPlmns\":[\"whatever\"],\"choiceEutraMode\":{\"fdd\":{}},\"eutraMode\":\"FDD\"}]},\"associatedE2tInstanceAddress\":\"10.0.2.15:38000\"}",
1184         }
1185
1186         controllerUpdateEnbTestExecuter(t, &context)
1187 }
1188
1189 /*
1190 AddEnb UTs
1191 */
1192
1193 func TestControllerAddEnbGetNodebInternalError(t *testing.T) {
1194         context := controllerAddEnbTestContext{
1195                 getNodebInfoResult: &getNodebInfoResult{
1196                         nodebInfo: nil,
1197                         rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
1198                 },
1199                 requestBody:          getAddEnbRequest(""),
1200                 expectedStatusCode:   http.StatusInternalServerError,
1201                 expectedJsonResponse: RnibErrorJson,
1202         }
1203
1204         controllerAddEnbTestExecuter(t, &context)
1205 }
1206
1207 func TestControllerAddEnbNodebExistsFailure(t *testing.T) {
1208         context := controllerAddEnbTestContext{
1209                 getNodebInfoResult: &getNodebInfoResult{
1210                         nodebInfo: &entities.NodebInfo{},
1211                         rnibError: nil,
1212                 },
1213                 requestBody:          getAddEnbRequest(""),
1214                 expectedStatusCode:   http.StatusBadRequest,
1215                 expectedJsonResponse: NodebExistsJson,
1216         }
1217
1218         controllerAddEnbTestExecuter(t, &context)
1219 }
1220
1221 func TestControllerAddEnbSaveNodebFailure(t *testing.T) {
1222         context := controllerAddEnbTestContext{
1223                 saveNodebParams: &saveNodebParams{
1224                         err: common.NewInternalError(errors.New("#reader.SaveeNodeb - Internal Error")),
1225                 },
1226                 getNodebInfoResult: &getNodebInfoResult{
1227                         nodebInfo: nil,
1228                         rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1229                 },
1230                 requestBody:          getAddEnbRequest(""),
1231                 expectedStatusCode:   http.StatusInternalServerError,
1232                 expectedJsonResponse: RnibErrorJson,
1233         }
1234
1235         controllerAddEnbTestExecuter(t, &context)
1236 }
1237
1238 func TestControllerAddEnbAddNbIdentityFailure(t *testing.T) {
1239         context := controllerAddEnbTestContext{
1240                 saveNodebParams: &saveNodebParams{
1241                         err: nil,
1242                 },
1243                 addNbIdentityParams: &addNbIdentityParams{
1244                         err: common.NewInternalError(errors.New("#writer.addNbIdentity - Internal Error")),
1245                 },
1246                 getNodebInfoResult: &getNodebInfoResult{
1247                         nodebInfo: nil,
1248                         rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1249                 },
1250                 requestBody:          getAddEnbRequest(""),
1251                 expectedStatusCode:   http.StatusInternalServerError,
1252                 expectedJsonResponse: RnibErrorJson,
1253         }
1254
1255         controllerAddEnbTestExecuter(t, &context)
1256 }
1257
1258 func TestControllerAddEnbMissingRequiredRequestProps(t *testing.T) {
1259
1260         for _, v := range AddEnbRequestRequiredFields {
1261                 context := controllerAddEnbTestContext{
1262                         requestBody:          getAddEnbRequest(v),
1263                         expectedStatusCode:   http.StatusBadRequest,
1264                         expectedJsonResponse: ValidationFailureJson,
1265                 }
1266
1267                 controllerAddEnbTestExecuter(t, &context)
1268         }
1269 }
1270
1271 func TestControllerAddEnbInvalidRequest(t *testing.T) {
1272         controller, _, _, _, _, _ := setupControllerTest(t)
1273         writer := httptest.NewRecorder()
1274
1275         // Invalid json: attribute name without quotes (should be "cause":).
1276         invalidJson := strings.NewReader("{ranName:\"whatever\"")
1277         req, _ := http.NewRequest(http.MethodPost, AddEnbUrl, invalidJson)
1278
1279         controller.AddEnb(writer, req)
1280         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1281         bodyBytes, _ := ioutil.ReadAll(writer.Body)
1282         assert.Equal(t, CorruptedJson, string(bodyBytes))
1283
1284 }
1285
1286 func TestControllerAddEnbMissingRequiredGlobalNbIdProps(t *testing.T) {
1287
1288         r := getAddEnbRequest("")
1289
1290         for _, v := range GlobalIdRequiredFields {
1291                 r["globalNbId"] = buildGlobalNbId(v)
1292
1293                 context := controllerAddEnbTestContext{
1294                         requestBody:          r,
1295                         expectedStatusCode:   http.StatusBadRequest,
1296                         expectedJsonResponse: ValidationFailureJson,
1297                 }
1298
1299                 controllerAddEnbTestExecuter(t, &context)
1300         }
1301 }
1302
1303 func TestControllerAddEnbMissingRequiredEnbProps(t *testing.T) {
1304
1305         r := getAddEnbRequest("")
1306
1307         for _, v := range EnbRequiredFields {
1308                 r["enb"] = buildEnb(v)
1309
1310                 context := controllerAddEnbTestContext{
1311                         requestBody:          r,
1312                         expectedStatusCode:   http.StatusBadRequest,
1313                         expectedJsonResponse: ValidationFailureJson,
1314                 }
1315
1316                 controllerAddEnbTestExecuter(t, &context)
1317         }
1318 }
1319
1320 func TestControllerAddEnbMissingRequiredServedCellProps(t *testing.T) {
1321
1322         r := getAddEnbRequest("")
1323
1324         for _, v := range ServedCellRequiredFields {
1325                 enb := r["enb"]
1326
1327                 enbMap, _ := enb.(map[string]interface{})
1328
1329                 enbMap["servedCells"] = []interface{}{
1330                         buildServedCell(v),
1331                 }
1332
1333                 context := controllerAddEnbTestContext{
1334                         requestBody:          r,
1335                         expectedStatusCode:   http.StatusBadRequest,
1336                         expectedJsonResponse: ValidationFailureJson,
1337                 }
1338
1339                 controllerAddEnbTestExecuter(t, &context)
1340         }
1341 }
1342
1343 func TestControllerAddEnbSuccess(t *testing.T) {
1344         context := controllerAddEnbTestContext{
1345                 saveNodebParams: &saveNodebParams{
1346                         err: nil,
1347                 },
1348                 addNbIdentityParams: &addNbIdentityParams{
1349                         err: nil,
1350                 },
1351                 getNodebInfoResult: &getNodebInfoResult{
1352                         nodebInfo: nil,
1353                         rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1354                 },
1355                 requestBody:          getAddEnbRequest(""),
1356                 expectedStatusCode:   http.StatusCreated,
1357                 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\"}]}}",
1358         }
1359
1360         controllerAddEnbTestExecuter(t, &context)
1361 }
1362
1363 func TestControllerDeleteEnbGetNodebInternalError(t *testing.T) {
1364         context := controllerDeleteEnbTestContext{
1365                 getNodebInfoResult: &getNodebInfoResult{
1366                         nodebInfo: nil,
1367                         rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
1368                 },
1369                 expectedStatusCode:   http.StatusInternalServerError,
1370                 expectedJsonResponse: RnibErrorJson,
1371         }
1372
1373         controllerDeleteEnbTestExecuter(t, &context, false)
1374 }
1375
1376 /*
1377 DeleteEnb UTs
1378 */
1379
1380 func TestControllerDeleteEnbNodebNotExistsFailure(t *testing.T) {
1381         context := controllerDeleteEnbTestContext{
1382                 getNodebInfoResult: &getNodebInfoResult{
1383                         nodebInfo: nil,
1384                         rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found"),
1385                 },
1386                 expectedStatusCode:   http.StatusNotFound,
1387                 expectedJsonResponse: ResourceNotFoundJson,
1388         }
1389
1390         controllerDeleteEnbTestExecuter(t, &context, false)
1391 }
1392
1393 func TestControllerDeleteEnbNodebNotEnb(t *testing.T) {
1394         context := controllerDeleteEnbTestContext{
1395                 getNodebInfoResult: &getNodebInfoResult{
1396                         nodebInfo: &entities.NodebInfo{RanName: "ran1", NodeType: entities.Node_GNB, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED},
1397                         rnibError: nil,
1398                 },
1399                 expectedStatusCode:   http.StatusBadRequest,
1400                 expectedJsonResponse: ValidationFailureJson,
1401         }
1402
1403         controllerDeleteEnbTestExecuter(t, &context, false)
1404 }
1405
1406 func TestControllerDeleteEnbSuccess(t *testing.T) {
1407         context := controllerDeleteEnbTestContext{
1408                 getNodebInfoResult: &getNodebInfoResult{
1409                         nodebInfo: &entities.NodebInfo{RanName: RanName, NodeType: entities.Node_ENB, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED},
1410                         rnibError: nil,
1411                 },
1412                 expectedStatusCode:   http.StatusNoContent,
1413                 expectedJsonResponse: "",
1414         }
1415         controllerDeleteEnbTestExecuter(t, &context, true)
1416 }
1417
1418 func getJsonRequestAsBuffer(requestJson map[string]interface{}) *bytes.Buffer {
1419         b := new(bytes.Buffer)
1420         _ = json.NewEncoder(b).Encode(requestJson)
1421         return b
1422 }
1423
1424 /*
1425 GetNodeb UTs
1426 */
1427
1428 func TestControllerGetNodebSuccess(t *testing.T) {
1429         ranName := "test"
1430         var rnibError error
1431         context := controllerGetNodebTestContext{
1432                 ranName:              ranName,
1433                 nodebInfo:            &entities.NodebInfo{RanName: ranName, Ip: "10.0.2.15", Port: 1234},
1434                 rnibError:            rnibError,
1435                 expectedStatusCode:   http.StatusOK,
1436                 expectedJsonResponse: fmt.Sprintf("{\"ranName\":\"%s\",\"ip\":\"10.0.2.15\",\"port\":1234}", ranName),
1437         }
1438
1439         controllerGetNodebTestExecuter(t, &context)
1440 }
1441
1442 func TestControllerGetNodebNotFound(t *testing.T) {
1443
1444         ranName := "test"
1445         var nodebInfo *entities.NodebInfo
1446         context := controllerGetNodebTestContext{
1447                 ranName:              ranName,
1448                 nodebInfo:            nodebInfo,
1449                 rnibError:            common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1450                 expectedStatusCode:   http.StatusNotFound,
1451                 expectedJsonResponse: ResourceNotFoundJson,
1452         }
1453
1454         controllerGetNodebTestExecuter(t, &context)
1455 }
1456
1457 func TestControllerGetNodebInternal(t *testing.T) {
1458         ranName := "test"
1459         var nodebInfo *entities.NodebInfo
1460         context := controllerGetNodebTestContext{
1461                 ranName:              ranName,
1462                 nodebInfo:            nodebInfo,
1463                 rnibError:            common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
1464                 expectedStatusCode:   http.StatusInternalServerError,
1465                 expectedJsonResponse: RnibErrorJson,
1466         }
1467
1468         controllerGetNodebTestExecuter(t, &context)
1469 }
1470
1471 func TestControllerGetNodebIdListSuccess(t *testing.T) {
1472         var rnibError error
1473         nodebIdList := []*entities.NbIdentity{
1474                 {InventoryName: "test1", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}},
1475                 {InventoryName: "test2", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId2", NbId: "nbId2"}},
1476         }
1477
1478         context := controllerGetNodebIdListTestContext{
1479                 nodebIdList:          nodebIdList,
1480                 rnibError:            rnibError,
1481                 expectedStatusCode:   http.StatusOK,
1482                 expectedJsonResponse: "[{\"inventoryName\":\"test1\",\"globalNbId\":{\"plmnId\":\"plmnId1\",\"nbId\":\"nbId1\"}},{\"inventoryName\":\"test2\",\"globalNbId\":{\"plmnId\":\"plmnId2\",\"nbId\":\"nbId2\"}}]",
1483         }
1484
1485         controllerGetNodebIdListTestExecuter(t, &context)
1486 }
1487
1488 func TestControllerGetNodebIdListEmptySuccess(t *testing.T) {
1489         var rnibError error
1490         var nodebIdList []*entities.NbIdentity
1491
1492         context := controllerGetNodebIdListTestContext{
1493                 nodebIdList:          nodebIdList,
1494                 rnibError:            rnibError,
1495                 expectedStatusCode:   http.StatusOK,
1496                 expectedJsonResponse: "[]",
1497         }
1498
1499         controllerGetNodebIdListTestExecuter(t, &context)
1500 }
1501
1502 func TestHeaderValidationFailed(t *testing.T) {
1503         controller, _, _, _, _, _ := setupControllerTest(t)
1504
1505         writer := httptest.NewRecorder()
1506
1507         header := &http.Header{}
1508
1509         controller.handleRequest(writer, header, httpmsghandlerprovider.ShutdownRequest, nil, true, 0)
1510
1511         var errorResponse = parseJsonRequest(t, writer.Body)
1512         err := e2managererrors.NewHeaderValidationError()
1513
1514         assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
1515         assert.Equal(t, errorResponse.Code, err.Code)
1516         assert.Equal(t, errorResponse.Message, err.Message)
1517 }
1518
1519 func TestShutdownStatusNoContent(t *testing.T) {
1520         controller, readerMock, _, _, e2tInstancesManagerMock, _ := setupControllerTest(t)
1521         e2tInstancesManagerMock.On("GetE2TAddresses").Return([]string{}, nil)
1522         readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{}, nil)
1523
1524         writer := httptest.NewRecorder()
1525         controller.Shutdown(writer, tests.GetHttpRequest())
1526
1527         assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
1528 }
1529
1530 func TestHandleInternalError(t *testing.T) {
1531         controller, _, _, _, _, _ := setupControllerTest(t)
1532
1533         writer := httptest.NewRecorder()
1534         err := e2managererrors.NewInternalError()
1535
1536         controller.handleErrorResponse(err, writer)
1537         var errorResponse = parseJsonRequest(t, writer.Body)
1538
1539         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1540         assert.Equal(t, errorResponse.Code, err.Code)
1541         assert.Equal(t, errorResponse.Message, err.Message)
1542 }
1543
1544 func TestHandleCommandAlreadyInProgressError(t *testing.T) {
1545         controller, _, _, _, _, _ := setupControllerTest(t)
1546         writer := httptest.NewRecorder()
1547         err := e2managererrors.NewCommandAlreadyInProgressError()
1548
1549         controller.handleErrorResponse(err, writer)
1550         var errorResponse = parseJsonRequest(t, writer.Body)
1551
1552         assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
1553         assert.Equal(t, errorResponse.Code, err.Code)
1554         assert.Equal(t, errorResponse.Message, err.Message)
1555 }
1556
1557 func TestHandleRoutingManagerError(t *testing.T) {
1558         controller, _, _, _, _, _ := setupControllerTest(t)
1559         writer := httptest.NewRecorder()
1560         err := e2managererrors.NewRoutingManagerError()
1561
1562         controller.handleErrorResponse(err, writer)
1563         var errorResponse = parseJsonRequest(t, writer.Body)
1564
1565         assert.Equal(t, http.StatusServiceUnavailable, writer.Result().StatusCode)
1566         assert.Equal(t, errorResponse.Code, err.Code)
1567         assert.Equal(t, errorResponse.Message, err.Message)
1568 }
1569
1570 func TestHandleE2TInstanceAbsenceError(t *testing.T) {
1571         controller, _, _, _, _, _ := setupControllerTest(t)
1572
1573         writer := httptest.NewRecorder()
1574         err := e2managererrors.NewE2TInstanceAbsenceError()
1575
1576         controller.handleErrorResponse(err, writer)
1577         var errorResponse = parseJsonRequest(t, writer.Body)
1578
1579         assert.Equal(t, http.StatusServiceUnavailable, writer.Result().StatusCode)
1580         assert.Equal(t, errorResponse.Code, err.Code)
1581         assert.Equal(t, errorResponse.Message, err.Message)
1582 }
1583
1584 func TestValidateHeaders(t *testing.T) {
1585         controller, _, _, _, _, _ := setupControllerTest(t)
1586
1587         header := http.Header{}
1588         header.Set("Content-Type", "application/json")
1589         result := controller.validateRequestHeader(&header)
1590
1591         assert.Nil(t, result)
1592 }
1593
1594 func parseJsonRequest(t *testing.T, r io.Reader) models.ErrorResponse {
1595
1596         var errorResponse models.ErrorResponse
1597         body, err := ioutil.ReadAll(r)
1598         if err != nil {
1599                 t.Errorf("Error cannot deserialize json request")
1600         }
1601         _ = json.Unmarshal(body, &errorResponse)
1602
1603         return errorResponse
1604 }
1605
1606 func initLog(t *testing.T) *logger.Logger {
1607         log, err := logger.InitLogger(logger.InfoLevel)
1608         if err != nil {
1609                 t.Errorf("#delete_all_request_handler_test.TestHandleSuccessFlow - failed to initialize logger, error: %s", err)
1610         }
1611         return log
1612 }
1613
1614 func TestX2ResetHandleSuccessfulRequestedCause(t *testing.T) {
1615         controller, readerMock, _, rmrMessengerMock, _, _ := setupControllerTest(t)
1616
1617         ranName := "test1"
1618         payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x40}
1619         var xAction []byte
1620         var msgSrc unsafe.Pointer
1621         msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction, msgSrc)
1622         rmrMessengerMock.On("SendMsg", msg, mock.Anything).Return(msg, nil)
1623
1624         writer := httptest.NewRecorder()
1625
1626         var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
1627         readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
1628
1629         data4Req := map[string]interface{}{"cause": "protocol:transfer-syntax-error"}
1630         b := new(bytes.Buffer)
1631         _ = json.NewEncoder(b).Encode(data4Req)
1632         req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
1633         req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
1634
1635         controller.X2Reset(writer, req)
1636         assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
1637
1638 }
1639
1640 func TestX2ResetHandleSuccessfulRequestedDefault(t *testing.T) {
1641         controller, readerMock, _, rmrMessengerMock, _, _ := setupControllerTest(t)
1642
1643         ranName := "test1"
1644         // o&m intervention
1645         payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x64}
1646         var xAction []byte
1647         var msgSrc unsafe.Pointer
1648         msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction, msgSrc)
1649         rmrMessengerMock.On("SendMsg", msg, true).Return(msg, nil)
1650
1651         writer := httptest.NewRecorder()
1652
1653         var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
1654         readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
1655
1656         // no body
1657         b := new(bytes.Buffer)
1658         data4Req := map[string]interface{}{}
1659         _ = json.NewEncoder(b).Encode(data4Req)
1660         req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
1661         req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
1662
1663         controller.X2Reset(writer, req)
1664         assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
1665 }
1666
1667 func TestX2ResetHandleFailureInvalidBody(t *testing.T) {
1668         controller, _, _, _, _, _ := setupControllerTest(t)
1669
1670         ranName := "test1"
1671
1672         writer := httptest.NewRecorder()
1673
1674         // Invalid json: attribute name without quotes (should be "cause":).
1675         b := strings.NewReader("{cause:\"protocol:transfer-syntax-error\"")
1676         req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
1677         req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
1678
1679         controller.X2Reset(writer, req)
1680         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1681
1682 }
1683
1684 func TestHandleErrorResponse(t *testing.T) {
1685         controller, _, _, _, _, _ := setupControllerTest(t)
1686
1687         writer := httptest.NewRecorder()
1688         controller.handleErrorResponse(e2managererrors.NewRnibDbError(), writer)
1689         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1690
1691         writer = httptest.NewRecorder()
1692         controller.handleErrorResponse(e2managererrors.NewCommandAlreadyInProgressError(), writer)
1693         assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
1694
1695         writer = httptest.NewRecorder()
1696         controller.handleErrorResponse(e2managererrors.NewHeaderValidationError(), writer)
1697         assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
1698
1699         writer = httptest.NewRecorder()
1700         controller.handleErrorResponse(e2managererrors.NewWrongStateError("", ""), writer)
1701         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1702
1703         writer = httptest.NewRecorder()
1704         controller.handleErrorResponse(e2managererrors.NewRequestValidationError(), writer)
1705         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1706
1707         writer = httptest.NewRecorder()
1708         controller.handleErrorResponse(e2managererrors.NewRmrError(), writer)
1709         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1710
1711         writer = httptest.NewRecorder()
1712         controller.handleErrorResponse(e2managererrors.NewResourceNotFoundError(), writer)
1713         assert.Equal(t, http.StatusNotFound, writer.Result().StatusCode)
1714
1715         writer = httptest.NewRecorder()
1716         controller.handleErrorResponse(fmt.Errorf("ErrorError"), writer)
1717         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1718 }
1719
1720 func getRmrSender(rmrMessengerMock *mocks.RmrMessengerMock, log *logger.Logger) *rmrsender.RmrSender {
1721         rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
1722         rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
1723         return rmrsender.NewRmrSender(log, rmrMessenger)
1724 }