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