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/e2pdus"
  28         "e2mgr/logger"
  29         "e2mgr/managers"
  30         "e2mgr/mocks"
  31         "e2mgr/models"
  32         "e2mgr/providers/httpmsghandlerprovider"
  33         "e2mgr/rmrCgo"
  34         "e2mgr/services"
  35         "e2mgr/services/rmrsender"
  36         "e2mgr/tests"
  37         "encoding/json"
  38         "fmt"
  39         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
  40         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
  41         "github.com/golang/protobuf/jsonpb"
  42         "github.com/gorilla/mux"
  43         "github.com/pkg/errors"
  44         "github.com/stretchr/testify/assert"
  45         "github.com/stretchr/testify/mock"
  46         "io"
  47         "io/ioutil"
  48         "net/http"
  49         "net/http/httptest"
  50         "strings"
  51         "testing"
  52         "unsafe"
  53 )
  54
  55 const (
  56         RanName                      = "test"
  57         AssociatedE2TInstanceAddress = "10.0.2.15:38000"
  58         ValidationFailureJson        = "{\"errorCode\":402,\"errorMessage\":\"Validation error\"}"
  59         ResourceNotFoundJson         = "{\"errorCode\":404,\"errorMessage\":\"Resource not found\"}"
  60         RnibErrorJson                = "{\"errorCode\":500,\"errorMessage\":\"RNIB error\"}"
  61         InternalErrorJson            = "{\"errorCode\":501,\"errorMessage\":\"Internal Server Error. Please try again later\"}"
  62 )
  63
  64 var (
  65         ServedNrCellInformationRequiredFields = []string{"cellId", "choiceNrMode", "nrMode", "nrPci", "servedPlmns"}
  66         NrNeighbourInformationRequiredFields  = []string{"nrCgi", "choiceNrMode", "nrMode", "nrPci"}
  67 )
  68
  69 type controllerGetNodebTestContext struct {
  70         ranName              string
  71         nodebInfo            *entities.NodebInfo
  72         rnibError            error
  73         expectedStatusCode   int
  74         expectedJsonResponse string
  75 }
  76
  77 type controllerGetNodebIdListTestContext struct {
  78         nodebIdList          []*entities.NbIdentity
  79         rnibError            error
  80         expectedStatusCode   int
  81         expectedJsonResponse string
  82 }
  83
  84 type getNodebInfoResult struct {
  85         nodebInfo *entities.NodebInfo
  86         rnibError error
  87 }
  88
  89 type updateGnbCellsParams struct {
  90         err error
  91 }
  92
  93 type controllerUpdateGnbTestContext struct {
  94         getNodebInfoResult   *getNodebInfoResult
  95         updateGnbCellsParams *updateGnbCellsParams
  96         requestBody          map[string]interface{}
  97         expectedStatusCode   int
  98         expectedJsonResponse string
  99 }
 100
 101 func buildNrNeighbourInformation(propToOmit string) map[string]interface{} {
 102         ret := map[string]interface{}{
 103                 "nrCgi": "whatever",
 104                 "choiceNrMode": map[string]interface{}{
 105                         "tdd": map[string]interface{}{},
 106                 },
 107                 "nrMode": 1,
 108                 "nrPci":  1,
 109         }
 110
 111         if len(propToOmit) != 0 {
 112                 delete(ret, propToOmit)
 113         }
 114
 115         return ret
 116 }
 117
 118 func buildServedNrCellInformation(propToOmit string) map[string]interface{} {
 119         ret := map[string]interface{}{
 120                 "cellId": "whatever",
 121                 "choiceNrMode": map[string]interface{}{
 122                         "fdd": map[string]interface{}{},
 123                 },
 124                 "nrMode": 1,
 125                 "nrPci":  1,
 126                 "servedPlmns": []interface{}{
 127                         "whatever",
 128                 },
 129         }
 130
 131         if len(propToOmit) != 0 {
 132                 delete(ret, propToOmit)
 133         }
 134
 135         return ret
 136 }
 137
 138 func setupControllerTest(t *testing.T) (*NodebController, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.RmrMessengerMock, *mocks.E2TInstancesManagerMock) {
 139         log := initLog(t)
 140         config := configuration.ParseConfiguration()
 141
 142         rmrMessengerMock := &mocks.RmrMessengerMock{}
 143         readerMock := &mocks.RnibReaderMock{}
 144
 145         writerMock := &mocks.RnibWriterMock{}
 146
 147         rnibDataService := services.NewRnibDataService(log, config, readerMock, writerMock)
 148         rmrSender := getRmrSender(rmrMessengerMock, log)
 149         ranSetupManager := managers.NewRanSetupManager(log, rmrSender, rnibDataService)
 150         e2tInstancesManager := &mocks.E2TInstancesManagerMock{}
 151         httpClientMock := &mocks.HttpClientMock{}
 152         rmClient := clients.NewRoutingManagerClient(log, config, httpClientMock)
 153         e2tAssociationManager := managers.NewE2TAssociationManager(log, rnibDataService, e2tInstancesManager, rmClient)
 154         handlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(log, rmrSender, config, rnibDataService, ranSetupManager, e2tInstancesManager, e2tAssociationManager, rmClient)
 155         controller := NewNodebController(log, handlerProvider)
 156         return controller, readerMock, writerMock, rmrMessengerMock, e2tInstancesManager
 157 }
 158
 159 func TestX2SetupInvalidBody(t *testing.T) {
 160
 161         controller, _, _, _, _ := setupControllerTest(t)
 162
 163         header := http.Header{}
 164         header.Set("Content-Type", "application/json")
 165         httpRequest, _ := http.NewRequest("POST", "http://localhost:3800/v1/nodeb/x2-setup", strings.NewReader("{}{}"))
 166         httpRequest.Header = header
 167
 168         writer := httptest.NewRecorder()
 169         controller.X2Setup(writer, httpRequest)
 170
 171         var errorResponse = parseJsonRequest(t, writer.Body)
 172
 173         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
 174         assert.Equal(t, e2managererrors.NewInvalidJsonError().Code, errorResponse.Code)
 175 }
 176
 177 func TestX2SetupSuccess(t *testing.T) {
 178
 179         controller, readerMock, writerMock, rmrMessengerMock, _ := setupControllerTest(t)
 180
 181         ranName := "test"
 182         nb := &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST, AssociatedE2TInstanceAddress: "10.0.2.15:8989"}
 183         readerMock.On("GetNodeb", ranName).Return(nb, nil)
 184         var nbUpdated = *nb
 185         nbUpdated.ConnectionAttempts = 0
 186         writerMock.On("UpdateNodebInfo", &nbUpdated).Return(nil)
 187
 188         var nbUpdated2 = &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_CONNECTING, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST, ConnectionAttempts: 1, AssociatedE2TInstanceAddress: "10.0.2.15:8989"}
 189         writerMock.On("UpdateNodebInfo", nbUpdated2).Return(nil)
 190
 191         payload := e2pdus.PackedX2setupRequest
 192         var xAction []byte
 193         var msgSrc unsafe.Pointer
 194         msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), ranName, &payload, &xAction, msgSrc)
 195
 196         rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg, nil)
 197
 198         header := http.Header{}
 199         header.Set("Content-Type", "application/json")
 200         httpRequest := tests.GetHttpRequest()
 201         httpRequest.Header = header
 202
 203         writer := httptest.NewRecorder()
 204         controller.X2Setup(writer, httpRequest)
 205
 206         assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
 207 }
 208
 209 func TestEndcSetupSuccess(t *testing.T) {
 210
 211         controller, readerMock, writerMock, rmrMessengerMock, _ := setupControllerTest(t)
 212
 213         ranName := "test"
 214         nb := &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST, AssociatedE2TInstanceAddress: "10.0.2.15:8989"}
 215         readerMock.On("GetNodeb", ranName).Return(nb, nil)
 216         var nbUpdated = *nb
 217         nbUpdated.ConnectionAttempts = 0
 218         writerMock.On("UpdateNodebInfo", &nbUpdated).Return(nil)
 219
 220         var nbUpdated2 = &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_CONNECTING, E2ApplicationProtocol: entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST, ConnectionAttempts: 1, AssociatedE2TInstanceAddress: "10.0.2.15:8989"}
 221         writerMock.On("UpdateNodebInfo", nbUpdated2).Return(nil)
 222
 223         payload := e2pdus.PackedEndcX2setupRequest
 224         var xAction []byte
 225         var msgSrc unsafe.Pointer
 226         msg := rmrCgo.NewMBuf(rmrCgo.RIC_ENDC_X2_SETUP_REQ, len(payload), ranName, &payload, &xAction, msgSrc)
 227
 228         rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg, nil)
 229
 230         header := http.Header{}
 231         header.Set("Content-Type", "application/json")
 232         httpRequest := tests.GetHttpRequest()
 233         httpRequest.Header = header
 234
 235         writer := httptest.NewRecorder()
 236         controller.EndcSetup(writer, httpRequest)
 237
 238         assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
 239 }
 240
 241 func TestShutdownHandlerRnibError(t *testing.T) {
 242         controller, _, _, _, e2tInstancesManagerMock := setupControllerTest(t)
 243         e2tInstancesManagerMock.On("GetE2TAddresses").Return([]string{}, e2managererrors.NewRnibDbError())
 244
 245         writer := httptest.NewRecorder()
 246
 247         controller.Shutdown(writer, tests.GetHttpRequest())
 248
 249         var errorResponse = parseJsonRequest(t, writer.Body)
 250
 251         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
 252         assert.Equal(t, errorResponse.Code, e2managererrors.NewRnibDbError().Code)
 253 }
 254
 255 func controllerGetNodebTestExecuter(t *testing.T, context *controllerGetNodebTestContext) {
 256         controller, readerMock, _, _, _ := setupControllerTest(t)
 257         writer := httptest.NewRecorder()
 258         readerMock.On("GetNodeb", context.ranName).Return(context.nodebInfo, context.rnibError)
 259         req, _ := http.NewRequest(http.MethodGet, "/nodeb", nil)
 260         req = mux.SetURLVars(req, map[string]string{"ranName": context.ranName})
 261         controller.GetNodeb(writer, req)
 262         assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
 263         bodyBytes, _ := ioutil.ReadAll(writer.Body)
 264         assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
 265 }
 266
 267 func controllerGetNodebIdListTestExecuter(t *testing.T, context *controllerGetNodebIdListTestContext) {
 268         controller, readerMock, _, _, _ := setupControllerTest(t)
 269         writer := httptest.NewRecorder()
 270         readerMock.On("GetListNodebIds").Return(context.nodebIdList, context.rnibError)
 271         req, _ := http.NewRequest(http.MethodGet, "/nodeb/ids", nil)
 272         controller.GetNodebIdList(writer, req)
 273         assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
 274         bodyBytes, _ := ioutil.ReadAll(writer.Body)
 275         assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
 276 }
 277
 278 func activateControllerUpdateGnbMocks(context *controllerUpdateGnbTestContext, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
 279         if context.getNodebInfoResult != nil {
 280                 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
 281         }
 282
 283         if context.updateGnbCellsParams != nil {
 284                 updatedNodebInfo := *context.getNodebInfoResult.nodebInfo
 285                 gnb := entities.Gnb{}
 286                 _ = jsonpb.Unmarshal(getJsonRequestAsBuffer(context.requestBody), &gnb)
 287                 updatedNodebInfo.GetGnb().ServedNrCells = gnb.ServedNrCells
 288                 writerMock.On("UpdateGnbCells", &updatedNodebInfo, gnb.ServedNrCells).Return(context.updateGnbCellsParams.err)
 289         }
 290 }
 291
 292 func assertControllerUpdateGnb(t *testing.T, context *controllerUpdateGnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
 293         assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
 294         bodyBytes, _ := ioutil.ReadAll(writer.Body)
 295         assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
 296         readerMock.AssertExpectations(t)
 297         writerMock.AssertExpectations(t)
 298
 299         if context.getNodebInfoResult != nil {
 300                 readerMock.AssertNotCalled(t, "GetNodeb")
 301         }
 302
 303         if context.updateGnbCellsParams != nil {
 304                 writerMock.AssertNotCalled(t, "UpdateGnb")
 305         }
 306 }
 307
 308 func buildUpdateGnbRequest(context *controllerUpdateGnbTestContext) *http.Request {
 309         updateGnbUrl := fmt.Sprintf("/nodeb/%s/update", RanName)
 310         requestBody := getJsonRequestAsBuffer(context.requestBody)
 311         req, _ := http.NewRequest(http.MethodGet, updateGnbUrl, requestBody)
 312         req.Header.Set("Content-Type", "application/json")
 313         req = mux.SetURLVars(req, map[string]string{"ranName": RanName})
 314         return req
 315 }
 316
 317 func controllerUpdateGnbTestExecuter(t *testing.T, context *controllerUpdateGnbTestContext) {
 318         controller, readerMock, writerMock, _, _ := setupControllerTest(t)
 319         writer := httptest.NewRecorder()
 320
 321         activateControllerUpdateGnbMocks(context, readerMock, writerMock)
 322         req := buildUpdateGnbRequest(context)
 323         controller.UpdateGnb(writer, req)
 324         assertControllerUpdateGnb(t, context, writer, readerMock, writerMock)
 325 }
 326
 327 func TestControllerUpdateGnbEmptyServedNrCells(t *testing.T) {
 328         context := controllerUpdateGnbTestContext{
 329                 getNodebInfoResult: nil,
 330                 requestBody: map[string]interface{}{
 331                         "servedNrCells": []interface{}{
 332                         },
 333                 },
 334                 expectedStatusCode:   http.StatusBadRequest,
 335                 expectedJsonResponse: ValidationFailureJson,
 336         }
 337
 338         controllerUpdateGnbTestExecuter(t, &context)
 339 }
 340
 341 func TestControllerUpdateGnbMissingServedNrCellInformation(t *testing.T) {
 342         context := controllerUpdateGnbTestContext{
 343                 getNodebInfoResult: nil,
 344                 requestBody: map[string]interface{}{
 345                         "servedNrCells": []interface{}{
 346                                 map[string]interface{}{
 347                                         "servedNrCellInformation": nil,
 348                                 },
 349                         },
 350                 },
 351                 expectedStatusCode:   http.StatusBadRequest,
 352                 expectedJsonResponse: ValidationFailureJson,
 353         }
 354
 355         controllerUpdateGnbTestExecuter(t, &context)
 356 }
 357
 358 func TestControllerUpdateGnbMissingServedNrCellRequiredProp(t *testing.T) {
 359
 360         for _, v := range ServedNrCellInformationRequiredFields {
 361                 context := controllerUpdateGnbTestContext{
 362                         getNodebInfoResult: nil,
 363                         requestBody: map[string]interface{}{
 364                                 "servedNrCells": []interface{}{
 365                                         map[string]interface{}{
 366                                                 "servedNrCellInformation": buildServedNrCellInformation(v),
 367                                         },
 368                                 },
 369                         },
 370                         expectedStatusCode:   http.StatusBadRequest,
 371                         expectedJsonResponse: ValidationFailureJson,
 372                 }
 373
 374                 controllerUpdateGnbTestExecuter(t, &context)
 375         }
 376 }
 377
 378 func TestControllerUpdateGnbMissingServedNrCellFddOrTdd(t *testing.T) {
 379
 380         servedNrCellInformation := buildServedNrCellInformation("")
 381         servedNrCellInformation["choiceNrMode"] = map[string]interface{}{}
 382
 383         context := controllerUpdateGnbTestContext{
 384                 getNodebInfoResult: nil,
 385                 requestBody: map[string]interface{}{
 386                         "servedNrCells": []interface{}{
 387                                 map[string]interface{}{
 388                                         "servedNrCellInformation": servedNrCellInformation,
 389                                 },
 390                         },
 391                 },
 392                 expectedStatusCode:   http.StatusBadRequest,
 393                 expectedJsonResponse: ValidationFailureJson,
 394         }
 395
 396         controllerUpdateGnbTestExecuter(t, &context)
 397 }
 398
 399 func TestControllerUpdateGnbMissingNeighbourInfoFddOrTdd(t *testing.T) {
 400
 401         nrNeighbourInfo := buildNrNeighbourInformation("")
 402         nrNeighbourInfo["choiceNrMode"] = map[string]interface{}{}
 403
 404         context := controllerUpdateGnbTestContext{
 405                 getNodebInfoResult: nil,
 406                 requestBody: map[string]interface{}{
 407                         "servedNrCells": []interface{}{
 408                                 map[string]interface{}{
 409                                         "servedNrCellInformation": buildServedNrCellInformation(""),
 410                                         "nrNeighbourInfos": []interface{}{
 411                                                 nrNeighbourInfo,
 412                                         },
 413                                 },
 414                         },
 415                 },
 416                 expectedStatusCode:   http.StatusBadRequest,
 417                 expectedJsonResponse: ValidationFailureJson,
 418         }
 419
 420         controllerUpdateGnbTestExecuter(t, &context)
 421 }
 422
 423 func TestControllerUpdateGnbMissingNrNeighbourInformationRequiredProp(t *testing.T) {
 424
 425         for _, v := range NrNeighbourInformationRequiredFields {
 426                 context := controllerUpdateGnbTestContext{
 427                         getNodebInfoResult: nil,
 428                         requestBody: map[string]interface{}{
 429                                 "servedNrCells": []interface{}{
 430                                         map[string]interface{}{
 431                                                 "servedNrCellInformation": buildServedNrCellInformation(""),
 432                                                 "nrNeighbourInfos": []interface{}{
 433                                                         buildNrNeighbourInformation(v),
 434                                                 },
 435                                         },
 436                                 },
 437                         },
 438                         expectedStatusCode:   http.StatusBadRequest,
 439                         expectedJsonResponse: ValidationFailureJson,
 440                 }
 441
 442                 controllerUpdateGnbTestExecuter(t, &context)
 443         }
 444 }
 445
 446 func TestControllerUpdateGnbValidServedNrCellInformationGetNodebNotFound(t *testing.T) {
 447         context := controllerUpdateGnbTestContext{
 448                 getNodebInfoResult: &getNodebInfoResult{
 449                         nodebInfo: nil,
 450                         rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
 451                 },
 452                 requestBody: map[string]interface{}{
 453                         "servedNrCells": []interface{}{
 454                                 map[string]interface{}{
 455                                         "servedNrCellInformation": buildServedNrCellInformation(""),
 456                                 },
 457                         },
 458                 },
 459                 expectedStatusCode:   http.StatusNotFound,
 460                 expectedJsonResponse: ResourceNotFoundJson,
 461         }
 462
 463         controllerUpdateGnbTestExecuter(t, &context)
 464 }
 465
 466 func TestControllerUpdateGnbValidServedNrCellInformationGetNodebInternalError(t *testing.T) {
 467         context := controllerUpdateGnbTestContext{
 468                 getNodebInfoResult: &getNodebInfoResult{
 469                         nodebInfo: nil,
 470                         rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
 471                 },
 472                 requestBody: map[string]interface{}{
 473                         "servedNrCells": []interface{}{
 474                                 map[string]interface{}{
 475                                         "servedNrCellInformation": buildServedNrCellInformation(""),
 476                                 },
 477                         },
 478                 },
 479                 expectedStatusCode:   http.StatusInternalServerError,
 480                 expectedJsonResponse: RnibErrorJson,
 481         }
 482
 483         controllerUpdateGnbTestExecuter(t, &context)
 484 }
 485
 486 func TestControllerUpdateGnbGetNodebSuccessInvalidGnbConfiguration(t *testing.T) {
 487         context := controllerUpdateGnbTestContext{
 488                 getNodebInfoResult: &getNodebInfoResult{
 489                         nodebInfo: &entities.NodebInfo{
 490                                 RanName:                      RanName,
 491                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
 492                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
 493                         },
 494                         rnibError: nil,
 495                 },
 496                 requestBody: map[string]interface{}{
 497                         "servedNrCells": []interface{}{
 498                                 map[string]interface{}{
 499                                         "servedNrCellInformation": buildServedNrCellInformation(""),
 500                                         "nrNeighbourInfos": []interface{}{
 501                                                 buildNrNeighbourInformation(""),
 502                                         },
 503                                 },
 504                         },
 505                 },
 506                 expectedStatusCode:   http.StatusInternalServerError,
 507                 expectedJsonResponse: InternalErrorJson,
 508         }
 509
 510         controllerUpdateGnbTestExecuter(t, &context)
 511 }
 512
 513 func TestControllerUpdateGnbGetNodebSuccessUpdateGnbCellsFailure(t *testing.T) {
 514         context := controllerUpdateGnbTestContext{
 515                 updateGnbCellsParams: &updateGnbCellsParams{
 516                         err: common.NewInternalError(errors.New("#writer.UpdateGnbCells - Internal Error")),
 517                 },
 518                 getNodebInfoResult: &getNodebInfoResult{
 519                         nodebInfo: &entities.NodebInfo{
 520                                 RanName:                      RanName,
 521                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
 522                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
 523                                 Configuration:                &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{}},
 524                         },
 525                         rnibError: nil,
 526                 },
 527                 requestBody: map[string]interface{}{
 528                         "servedNrCells": []interface{}{
 529                                 map[string]interface{}{
 530                                         "servedNrCellInformation": buildServedNrCellInformation(""),
 531                                         "nrNeighbourInfos": []interface{}{
 532                                                 buildNrNeighbourInformation(""),
 533                                         },
 534                                 },
 535                         },
 536                 },
 537                 expectedStatusCode:   http.StatusInternalServerError,
 538                 expectedJsonResponse: RnibErrorJson,
 539         }
 540
 541         controllerUpdateGnbTestExecuter(t, &context)
 542 }
 543
 544 func TestControllerUpdateGnbSuccess(t *testing.T) {
 545         context := controllerUpdateGnbTestContext{
 546                 updateGnbCellsParams: &updateGnbCellsParams{
 547                         err: nil,
 548                 },
 549                 getNodebInfoResult: &getNodebInfoResult{
 550                         nodebInfo: &entities.NodebInfo{
 551                                 RanName:                      RanName,
 552                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
 553                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
 554                                 Configuration:                &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{}},
 555                         },
 556                         rnibError: nil,
 557                 },
 558                 requestBody: map[string]interface{}{
 559                         "servedNrCells": []interface{}{
 560                                 map[string]interface{}{
 561                                         "servedNrCellInformation": buildServedNrCellInformation(""),
 562                                         "nrNeighbourInfos": []interface{}{
 563                                                 buildNrNeighbourInformation(""),
 564                                         },
 565                                 },
 566                         },
 567                 },
 568                 expectedStatusCode:   http.StatusOK,
 569                 expectedJsonResponse: "{\"ranName\":\"test\",\"connectionStatus\":\"CONNECTED\",\"gnb\":{\"servedNrCells\":[{\"servedNrCellInformation\":{\"nrPci\":1,\"cellId\":\"whatever\",\"servedPlmns\":[\"whatever\"],\"nrMode\":\"FDD\",\"choiceNrMode\":{\"fdd\":{}}},\"nrNeighbourInfos\":[{\"nrPci\":1,\"nrCgi\":\"whatever\",\"nrMode\":\"FDD\",\"choiceNrMode\":{\"tdd\":{}}}]}]},\"associatedE2tInstanceAddress\":\"10.0.2.15:38000\"}",
 570         }
 571
 572         controllerUpdateGnbTestExecuter(t, &context)
 573 }
 574
 575 func getJsonRequestAsBuffer(requestJson map[string]interface{}) *bytes.Buffer {
 576         b := new(bytes.Buffer)
 577         _ = json.NewEncoder(b).Encode(requestJson)
 578         return b;
 579 }
 580
 581 func TestControllerGetNodebSuccess(t *testing.T) {
 582         ranName := "test"
 583         var rnibError error
 584         context := controllerGetNodebTestContext{
 585                 ranName:              ranName,
 586                 nodebInfo:            &entities.NodebInfo{RanName: ranName, Ip: "10.0.2.15", Port: 1234},
 587                 rnibError:            rnibError,
 588                 expectedStatusCode:   http.StatusOK,
 589                 expectedJsonResponse: fmt.Sprintf("{\"ranName\":\"%s\",\"ip\":\"10.0.2.15\",\"port\":1234}", ranName),
 590         }
 591
 592         controllerGetNodebTestExecuter(t, &context)
 593 }
 594
 595 func TestControllerGetNodebNotFound(t *testing.T) {
 596
 597         ranName := "test"
 598         var nodebInfo *entities.NodebInfo
 599         context := controllerGetNodebTestContext{
 600                 ranName:              ranName,
 601                 nodebInfo:            nodebInfo,
 602                 rnibError:            common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
 603                 expectedStatusCode:   http.StatusNotFound,
 604                 expectedJsonResponse: ResourceNotFoundJson,
 605         }
 606
 607         controllerGetNodebTestExecuter(t, &context)
 608 }
 609
 610 func TestControllerGetNodebInternal(t *testing.T) {
 611         ranName := "test"
 612         var nodebInfo *entities.NodebInfo
 613         context := controllerGetNodebTestContext{
 614                 ranName:              ranName,
 615                 nodebInfo:            nodebInfo,
 616                 rnibError:            common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
 617                 expectedStatusCode:   http.StatusInternalServerError,
 618                 expectedJsonResponse: RnibErrorJson,
 619         }
 620
 621         controllerGetNodebTestExecuter(t, &context)
 622 }
 623
 624 func TestControllerGetNodebIdListSuccess(t *testing.T) {
 625         var rnibError error
 626         nodebIdList := []*entities.NbIdentity{
 627                 {InventoryName: "test1", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}},
 628                 {InventoryName: "test2", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId2", NbId: "nbId2"}},
 629         }
 630
 631         context := controllerGetNodebIdListTestContext{
 632                 nodebIdList:          nodebIdList,
 633                 rnibError:            rnibError,
 634                 expectedStatusCode:   http.StatusOK,
 635                 expectedJsonResponse: "[{\"inventoryName\":\"test1\",\"globalNbId\":{\"plmnId\":\"plmnId1\",\"nbId\":\"nbId1\"}},{\"inventoryName\":\"test2\",\"globalNbId\":{\"plmnId\":\"plmnId2\",\"nbId\":\"nbId2\"}}]",
 636         }
 637
 638         controllerGetNodebIdListTestExecuter(t, &context)
 639 }
 640
 641 func TestControllerGetNodebIdListEmptySuccess(t *testing.T) {
 642         var rnibError error
 643         nodebIdList := []*entities.NbIdentity{}
 644
 645         context := controllerGetNodebIdListTestContext{
 646                 nodebIdList:          nodebIdList,
 647                 rnibError:            rnibError,
 648                 expectedStatusCode:   http.StatusOK,
 649                 expectedJsonResponse: "[]",
 650         }
 651
 652         controllerGetNodebIdListTestExecuter(t, &context)
 653 }
 654
 655 func TestControllerGetNodebIdListInternal(t *testing.T) {
 656         var nodebIdList []*entities.NbIdentity
 657         context := controllerGetNodebIdListTestContext{
 658                 nodebIdList:          nodebIdList,
 659                 rnibError:            common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
 660                 expectedStatusCode:   http.StatusInternalServerError,
 661                 expectedJsonResponse: RnibErrorJson,
 662         }
 663
 664         controllerGetNodebIdListTestExecuter(t, &context)
 665 }
 666
 667 func TestHeaderValidationFailed(t *testing.T) {
 668         controller, _, _, _, _ := setupControllerTest(t)
 669
 670         writer := httptest.NewRecorder()
 671
 672         header := &http.Header{}
 673
 674         controller.handleRequest(writer, header, httpmsghandlerprovider.ShutdownRequest, nil, true)
 675
 676         var errorResponse = parseJsonRequest(t, writer.Body)
 677         err := e2managererrors.NewHeaderValidationError()
 678
 679         assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
 680         assert.Equal(t, errorResponse.Code, err.Code)
 681         assert.Equal(t, errorResponse.Message, err.Message)
 682 }
 683
 684 func TestShutdownStatusNoContent(t *testing.T) {
 685         controller, readerMock, _, _, e2tInstancesManagerMock := setupControllerTest(t)
 686         e2tInstancesManagerMock.On("GetE2TAddresses").Return([]string{}, nil)
 687         readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{}, nil)
 688
 689         writer := httptest.NewRecorder()
 690         controller.Shutdown(writer, tests.GetHttpRequest())
 691
 692         assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
 693 }
 694
 695 func TestHandleInternalError(t *testing.T) {
 696         controller, _, _, _, _ := setupControllerTest(t)
 697
 698         writer := httptest.NewRecorder()
 699         err := e2managererrors.NewInternalError()
 700
 701         controller.handleErrorResponse(err, writer)
 702         var errorResponse = parseJsonRequest(t, writer.Body)
 703
 704         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
 705         assert.Equal(t, errorResponse.Code, err.Code)
 706         assert.Equal(t, errorResponse.Message, err.Message)
 707 }
 708
 709 func TestHandleCommandAlreadyInProgressError(t *testing.T) {
 710         controller, _, _, _, _ := setupControllerTest(t)
 711         writer := httptest.NewRecorder()
 712         err := e2managererrors.NewCommandAlreadyInProgressError()
 713
 714         controller.handleErrorResponse(err, writer)
 715         var errorResponse = parseJsonRequest(t, writer.Body)
 716
 717         assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
 718         assert.Equal(t, errorResponse.Code, err.Code)
 719         assert.Equal(t, errorResponse.Message, err.Message)
 720 }
 721
 722 func TestHandleRoutingManagerError(t *testing.T) {
 723         controller, _, _, _, _ := setupControllerTest(t)
 724         writer := httptest.NewRecorder()
 725         err := e2managererrors.NewRoutingManagerError()
 726
 727         controller.handleErrorResponse(err, writer)
 728         var errorResponse = parseJsonRequest(t, writer.Body)
 729
 730         assert.Equal(t, http.StatusServiceUnavailable, writer.Result().StatusCode)
 731         assert.Equal(t, errorResponse.Code, err.Code)
 732         assert.Equal(t, errorResponse.Message, err.Message)
 733 }
 734
 735 func TestHandleE2TInstanceAbsenceError(t *testing.T) {
 736         controller, _, _, _, _ := setupControllerTest(t)
 737
 738         writer := httptest.NewRecorder()
 739         err := e2managererrors.NewE2TInstanceAbsenceError()
 740
 741         controller.handleErrorResponse(err, writer)
 742         var errorResponse = parseJsonRequest(t, writer.Body)
 743
 744         assert.Equal(t, http.StatusServiceUnavailable, writer.Result().StatusCode)
 745         assert.Equal(t, errorResponse.Code, err.Code)
 746         assert.Equal(t, errorResponse.Message, err.Message)
 747 }
 748
 749 func TestValidateHeaders(t *testing.T) {
 750         controller, _, _, _, _ := setupControllerTest(t)
 751
 752         header := http.Header{}
 753         header.Set("Content-Type", "application/json")
 754         result := controller.validateRequestHeader(&header)
 755
 756         assert.Nil(t, result)
 757 }
 758
 759 func parseJsonRequest(t *testing.T, r io.Reader) models.ErrorResponse {
 760
 761         var errorResponse models.ErrorResponse
 762         body, err := ioutil.ReadAll(r)
 763         if err != nil {
 764                 t.Errorf("Error cannot deserialize json request")
 765         }
 766         _ =json.Unmarshal(body, &errorResponse)
 767
 768         return errorResponse
 769 }
 770
 771 func initLog(t *testing.T) *logger.Logger {
 772         log, err := logger.InitLogger(logger.InfoLevel)
 773         if err != nil {
 774                 t.Errorf("#delete_all_request_handler_test.TestHandleSuccessFlow - failed to initialize logger, error: %s", err)
 775         }
 776         return log
 777 }
 778
 779 func TestX2ResetHandleSuccessfulRequestedCause(t *testing.T) {
 780         controller, readerMock, _, rmrMessengerMock, _ := setupControllerTest(t)
 781
 782         ranName := "test1"
 783         payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x40}
 784         var xAction []byte
 785         var msgSrc unsafe.Pointer
 786         msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction, msgSrc)
 787         rmrMessengerMock.On("SendMsg", msg, mock.Anything).Return(msg, nil)
 788
 789         writer := httptest.NewRecorder()
 790
 791         var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
 792         readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
 793
 794         data4Req := map[string]interface{}{"cause": "protocol:transfer-syntax-error"}
 795         b := new(bytes.Buffer)
 796         _ = json.NewEncoder(b).Encode(data4Req)
 797         req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
 798         req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
 799
 800         controller.X2Reset(writer, req)
 801         assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
 802
 803 }
 804
 805 func TestX2ResetHandleSuccessfulRequestedDefault(t *testing.T) {
 806         controller, readerMock, _, rmrMessengerMock, _ := setupControllerTest(t)
 807
 808         ranName := "test1"
 809         // o&m intervention
 810         payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x64}
 811         var xAction []byte
 812         var msgSrc unsafe.Pointer
 813         msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction, msgSrc)
 814         rmrMessengerMock.On("SendMsg", msg, true).Return(msg, nil)
 815
 816         writer := httptest.NewRecorder()
 817
 818         var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
 819         readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
 820
 821         // no body
 822         b := new(bytes.Buffer)
 823         req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
 824         req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
 825
 826         controller.X2Reset(writer, req)
 827         assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
 828
 829 }
 830
 831 func TestX2ResetHandleFailureInvalidBody(t *testing.T) {
 832         controller, _, _, _, _ := setupControllerTest(t)
 833
 834         ranName := "test1"
 835
 836         writer := httptest.NewRecorder()
 837
 838         // Invalid json: attribute name without quotes (should be "cause":).
 839         b := strings.NewReader("{cause:\"protocol:transfer-syntax-error\"")
 840         req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
 841         req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
 842
 843         controller.X2Reset(writer, req)
 844         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
 845
 846 }
 847
 848 func TestHandleErrorResponse(t *testing.T) {
 849         controller, _, _, _, _ := setupControllerTest(t)
 850
 851         writer := httptest.NewRecorder()
 852         controller.handleErrorResponse(e2managererrors.NewRnibDbError(), writer)
 853         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
 854
 855         writer = httptest.NewRecorder()
 856         controller.handleErrorResponse(e2managererrors.NewCommandAlreadyInProgressError(), writer)
 857         assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
 858
 859         writer = httptest.NewRecorder()
 860         controller.handleErrorResponse(e2managererrors.NewHeaderValidationError(), writer)
 861         assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
 862
 863         writer = httptest.NewRecorder()
 864         controller.handleErrorResponse(e2managererrors.NewWrongStateError("", ""), writer)
 865         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
 866
 867         writer = httptest.NewRecorder()
 868         controller.handleErrorResponse(e2managererrors.NewRequestValidationError(), writer)
 869         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
 870
 871         writer = httptest.NewRecorder()
 872         controller.handleErrorResponse(e2managererrors.NewRmrError(), writer)
 873         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
 874
 875         writer = httptest.NewRecorder()
 876         controller.handleErrorResponse(e2managererrors.NewResourceNotFoundError(), writer)
 877         assert.Equal(t, http.StatusNotFound, writer.Result().StatusCode)
 878
 879         writer = httptest.NewRecorder()
 880         controller.handleErrorResponse(fmt.Errorf("ErrorError"), writer)
 881         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
 882 }
 883
 884 func getRmrSender(rmrMessengerMock *mocks.RmrMessengerMock, log *logger.Logger) *rmrsender.RmrSender {
 885         rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
 886         rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
 887         return rmrsender.NewRmrSender(log, rmrMessenger)
 888 }