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