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