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