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
  18 package controllers
  19
  20 import (
  21         "bytes"
  22         "e2mgr/configuration"
  23         "e2mgr/e2managererrors"
  24         "e2mgr/e2pdus"
  25         "e2mgr/logger"
  26         "e2mgr/managers"
  27         "e2mgr/mocks"
  28         "e2mgr/models"
  29         "e2mgr/providers/httpmsghandlerprovider"
  30         "e2mgr/rmrCgo"
  31         "e2mgr/services"
  32         "e2mgr/services/rmrsender"
  33         "e2mgr/tests"
  34         "encoding/json"
  35         "fmt"
  36         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
  37         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
  38         "github.com/gorilla/mux"
  39         "github.com/pkg/errors"
  40         "github.com/stretchr/testify/assert"
  41         "github.com/stretchr/testify/mock"
  42         "io"
  43         "io/ioutil"
  44         "net/http"
  45         "net/http/httptest"
  46         "strings"
  47         "testing"
  48 )
  49
  50 type controllerGetNodebTestContext struct {
  51         ranName              string
  52         nodebInfo            *entities.NodebInfo
  53         rnibError            error
  54         expectedStatusCode   int
  55         expectedJsonResponse string
  56 }
  57
  58 type controllerGetNodebIdListTestContext struct {
  59         nodebIdList          []*entities.NbIdentity
  60         rnibError            error
  61         expectedStatusCode   int
  62         expectedJsonResponse string
  63 }
  64
  65 func setupControllerTest(t *testing.T) (*NodebController, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.RmrMessengerMock) {
  66         log := initLog(t)
  67         config := configuration.ParseConfiguration()
  68
  69         rmrMessengerMock := &mocks.RmrMessengerMock{}
  70         readerMock := &mocks.RnibReaderMock{}
  71
  72         writerMock := &mocks.RnibWriterMock{}
  73
  74         rnibDataService := services.NewRnibDataService(log, config, readerMock, writerMock)
  75         rmrSender := getRmrSender(rmrMessengerMock, log)
  76         ranSetupManager := managers.NewRanSetupManager(log, rmrSender, rnibDataService)
  77         handlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(log, rmrSender, config, rnibDataService, ranSetupManager)
  78         controller := NewNodebController(log, handlerProvider)
  79         return controller, readerMock, writerMock, rmrMessengerMock
  80 }
  81
  82 func TestX2SetupInvalidBody(t *testing.T) {
  83
  84         controller, _, _, _ := setupControllerTest(t)
  85
  86         header := http.Header{}
  87         header.Set("Content-Type", "application/json")
  88         httpRequest, _ := http.NewRequest("POST", "http://localhost:3800/v1/nodeb/x2-setup", strings.NewReader("{}{}"))
  89         httpRequest.Header = header
  90
  91         writer := httptest.NewRecorder()
  92         controller.X2Setup(writer, httpRequest)
  93
  94         var errorResponse = parseJsonRequest(t, writer.Body)
  95
  96         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
  97         assert.Equal(t, e2managererrors.NewInvalidJsonError().Code, errorResponse.Code)
  98 }
  99
 100 func TestX2SetupSuccess(t *testing.T) {
 101
 102         controller, readerMock, writerMock, rmrMessengerMock := setupControllerTest(t)
 103
 104         ranName := "test"
 105         nb := &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
 106         readerMock.On("GetNodeb", ranName).Return(nb, nil)
 107
 108         var nbUpdated = &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_CONNECTING, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST, ConnectionAttempts: 1}
 109         writerMock.On("UpdateNodebInfo", nbUpdated).Return(nil)
 110
 111         payload := e2pdus.PackedX2setupRequest
 112         var xAction[]byte
 113         msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), ranName, &payload, &xAction)
 114
 115         rmrMessengerMock.On("SendMsg", mock.Anything).Return(msg, nil)
 116
 117         header := http.Header{}
 118         header.Set("Content-Type", "application/json")
 119         httpRequest := tests.GetHttpRequest()
 120         httpRequest.Header = header
 121
 122         writer := httptest.NewRecorder()
 123         controller.X2Setup(writer, httpRequest)
 124
 125         assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
 126 }
 127
 128 func TestEndcSetupSuccess(t *testing.T) {
 129
 130         controller, readerMock, writerMock, rmrMessengerMock := setupControllerTest(t)
 131
 132         ranName := "test"
 133         nb := &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST}
 134         readerMock.On("GetNodeb", ranName).Return(nb, nil)
 135
 136         var nbUpdated = &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_CONNECTING, E2ApplicationProtocol: entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST, ConnectionAttempts: 1}
 137         writerMock.On("UpdateNodebInfo", nbUpdated).Return(nil)
 138
 139         payload := e2pdus.PackedEndcX2setupRequest
 140         var xAction[]byte
 141         msg := rmrCgo.NewMBuf(rmrCgo.RIC_ENDC_X2_SETUP_REQ, len(payload), ranName, &payload, &xAction)
 142
 143         rmrMessengerMock.On("SendMsg", mock.Anything).Return(msg, nil)
 144
 145         header := http.Header{}
 146         header.Set("Content-Type", "application/json")
 147         httpRequest := tests.GetHttpRequest()
 148         httpRequest.Header = header
 149
 150         writer := httptest.NewRecorder()
 151         controller.EndcSetup(writer, httpRequest)
 152
 153         assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
 154 }
 155
 156 func TestShutdownHandlerRnibError(t *testing.T) {
 157         controller, readerMock, _, _ := setupControllerTest(t)
 158
 159         rnibErr := &common.ResourceNotFoundError{}
 160         var nbIdentityList []*entities.NbIdentity
 161         readerMock.On("GetListNodebIds").Return(nbIdentityList, rnibErr)
 162
 163         writer := httptest.NewRecorder()
 164
 165         controller.Shutdown(writer, tests.GetHttpRequest())
 166
 167         var errorResponse = parseJsonRequest(t, writer.Body)
 168
 169         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
 170         assert.Equal(t, errorResponse.Code, e2managererrors.NewRnibDbError().Code)
 171 }
 172
 173 func controllerGetNodebTestExecuter(t *testing.T, context *controllerGetNodebTestContext) {
 174         controller, readerMock, _, _ := setupControllerTest(t)
 175         writer := httptest.NewRecorder()
 176         readerMock.On("GetNodeb", context.ranName).Return(context.nodebInfo, context.rnibError)
 177         req, _ := http.NewRequest("GET", "/nodeb", nil)
 178         req = mux.SetURLVars(req, map[string]string{"ranName": context.ranName})
 179         controller.GetNodeb(writer, req)
 180         assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
 181         bodyBytes, _ := ioutil.ReadAll(writer.Body)
 182         assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
 183 }
 184
 185 func controllerGetNodebIdListTestExecuter(t *testing.T, context *controllerGetNodebIdListTestContext) {
 186         controller, readerMock, _, _ := setupControllerTest(t)
 187         writer := httptest.NewRecorder()
 188         readerMock.On("GetListNodebIds").Return(context.nodebIdList, context.rnibError)
 189         req, _ := http.NewRequest("GET", "/nodeb/ids", nil)
 190         controller.GetNodebIdList(writer, req)
 191         assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
 192         bodyBytes, _ := ioutil.ReadAll(writer.Body)
 193         assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
 194 }
 195
 196 func TestControllerGetNodebSuccess(t *testing.T) {
 197         ranName := "test"
 198         var rnibError error
 199         context := controllerGetNodebTestContext{
 200                 ranName:              ranName,
 201                 nodebInfo:            &entities.NodebInfo{RanName: ranName, Ip: "10.0.2.15", Port: 1234},
 202                 rnibError:            rnibError,
 203                 expectedStatusCode:   http.StatusOK,
 204                 expectedJsonResponse: fmt.Sprintf("{\"ranName\":\"%s\",\"ip\":\"10.0.2.15\",\"port\":1234}", ranName),
 205         }
 206
 207         controllerGetNodebTestExecuter(t, &context)
 208 }
 209
 210 func TestControllerGetNodebNotFound(t *testing.T) {
 211
 212         ranName := "test"
 213         var nodebInfo *entities.NodebInfo
 214         context := controllerGetNodebTestContext{
 215                 ranName:              ranName,
 216                 nodebInfo:            nodebInfo,
 217                 rnibError:            common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
 218                 expectedStatusCode:   http.StatusNotFound,
 219                 expectedJsonResponse: "{\"errorCode\":404,\"errorMessage\":\"Resource not found\"}",
 220         }
 221
 222         controllerGetNodebTestExecuter(t, &context)
 223 }
 224
 225 func TestControllerGetNodebInternal(t *testing.T) {
 226         ranName := "test"
 227         var nodebInfo *entities.NodebInfo
 228         context := controllerGetNodebTestContext{
 229                 ranName:              ranName,
 230                 nodebInfo:            nodebInfo,
 231                 rnibError:            common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
 232                 expectedStatusCode:   http.StatusInternalServerError,
 233                 expectedJsonResponse: "{\"errorCode\":500,\"errorMessage\":\"RNIB error\"}",
 234         }
 235
 236         controllerGetNodebTestExecuter(t, &context)
 237 }
 238
 239 func TestControllerGetNodebIdListSuccess(t *testing.T) {
 240         var rnibError error
 241         nodebIdList := []*entities.NbIdentity{
 242                 {InventoryName: "test1", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}},
 243                 {InventoryName: "test2", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId2", NbId: "nbId2"}},
 244         }
 245
 246         context := controllerGetNodebIdListTestContext{
 247                 nodebIdList:          nodebIdList,
 248                 rnibError:            rnibError,
 249                 expectedStatusCode:   http.StatusOK,
 250                 expectedJsonResponse: "[{\"inventoryName\":\"test1\",\"globalNbId\":{\"plmnId\":\"plmnId1\",\"nbId\":\"nbId1\"}},{\"inventoryName\":\"test2\",\"globalNbId\":{\"plmnId\":\"plmnId2\",\"nbId\":\"nbId2\"}}]",
 251         }
 252
 253         controllerGetNodebIdListTestExecuter(t, &context)
 254 }
 255
 256 func TestControllerGetNodebIdListEmptySuccess(t *testing.T) {
 257         var rnibError error
 258         nodebIdList := []*entities.NbIdentity{}
 259
 260         context := controllerGetNodebIdListTestContext{
 261                 nodebIdList:          nodebIdList,
 262                 rnibError:            rnibError,
 263                 expectedStatusCode:   http.StatusOK,
 264                 expectedJsonResponse: "[]",
 265         }
 266
 267         controllerGetNodebIdListTestExecuter(t, &context)
 268 }
 269
 270 func TestControllerGetNodebIdListInternal(t *testing.T) {
 271         var nodebIdList []*entities.NbIdentity
 272         context := controllerGetNodebIdListTestContext{
 273                 nodebIdList:          nodebIdList,
 274                 rnibError:            common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
 275                 expectedStatusCode:   http.StatusInternalServerError,
 276                 expectedJsonResponse: "{\"errorCode\":500,\"errorMessage\":\"RNIB error\"}",
 277         }
 278
 279         controllerGetNodebIdListTestExecuter(t, &context)
 280 }
 281
 282 func TestHeaderValidationFailed(t *testing.T) {
 283         controller, _, _, _ := setupControllerTest(t)
 284
 285         writer := httptest.NewRecorder()
 286
 287         header := &http.Header{}
 288
 289         controller.handleRequest(writer, header, httpmsghandlerprovider.ShutdownRequest, nil, true)
 290
 291         var errorResponse = parseJsonRequest(t, writer.Body)
 292         err := e2managererrors.NewHeaderValidationError()
 293
 294         assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
 295         assert.Equal(t, errorResponse.Code, err.Code)
 296         assert.Equal(t, errorResponse.Message, err.Message)
 297 }
 298
 299 func TestShutdownStatusNoContent(t *testing.T) {
 300         controller, readerMock, _, _ := setupControllerTest(t)
 301
 302         var rnibError error
 303         nbIdentityList := []*entities.NbIdentity{}
 304         readerMock.On("GetListNodebIds").Return(nbIdentityList, rnibError)
 305
 306         writer := httptest.NewRecorder()
 307         controller.Shutdown(writer, tests.GetHttpRequest())
 308
 309         assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
 310 }
 311
 312 func TestHandleInternalError(t *testing.T) {
 313         controller, _, _, _ := setupControllerTest(t)
 314
 315         writer := httptest.NewRecorder()
 316         err := e2managererrors.NewInternalError()
 317
 318         controller.handleErrorResponse(err, writer)
 319         var errorResponse = parseJsonRequest(t, writer.Body)
 320
 321         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
 322         assert.Equal(t, errorResponse.Code, err.Code)
 323         assert.Equal(t, errorResponse.Message, err.Message)
 324 }
 325
 326 func TestHandleCommandAlreadyInProgressError(t *testing.T) {
 327         controller, _, _, _ := setupControllerTest(t)
 328         writer := httptest.NewRecorder()
 329         err := e2managererrors.NewCommandAlreadyInProgressError()
 330
 331         controller.handleErrorResponse(err, writer)
 332         var errorResponse = parseJsonRequest(t, writer.Body)
 333
 334         assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
 335         assert.Equal(t, errorResponse.Code, err.Code)
 336         assert.Equal(t, errorResponse.Message, err.Message)
 337 }
 338
 339 func TestValidateHeaders(t *testing.T) {
 340         controller, _, _, _ := setupControllerTest(t)
 341
 342         header := http.Header{}
 343         header.Set("Content-Type", "application/json")
 344         result := controller.validateRequestHeader(&header)
 345
 346         assert.Nil(t, result)
 347 }
 348
 349 func parseJsonRequest(t *testing.T, r io.Reader) models.ErrorResponse {
 350
 351         var errorResponse models.ErrorResponse
 352         body, err := ioutil.ReadAll(r)
 353         if err != nil {
 354                 t.Errorf("Error cannot deserialize json request")
 355         }
 356         json.Unmarshal(body, &errorResponse)
 357
 358         return errorResponse
 359 }
 360
 361 func initLog(t *testing.T) *logger.Logger {
 362         log, err := logger.InitLogger(logger.InfoLevel)
 363         if err != nil {
 364                 t.Errorf("#delete_all_request_handler_test.TestHandleSuccessFlow - failed to initialize logger, error: %s", err)
 365         }
 366         return log
 367 }
 368
 369 func TestX2ResetHandleSuccessfulRequestedCause(t *testing.T) {
 370         controller, readerMock, _, rmrMessengerMock := setupControllerTest(t)
 371
 372         ranName := "test1"
 373         payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x40}
 374         var xAction[]byte
 375         msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction)
 376         rmrMessengerMock.On("SendMsg", msg, mock.Anything).Return(msg, nil)
 377
 378         writer := httptest.NewRecorder()
 379
 380         var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
 381         readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
 382
 383         data4Req := map[string]interface{}{"cause": "protocol:transfer-syntax-error"}
 384         b := new(bytes.Buffer)
 385         _ = json.NewEncoder(b).Encode(data4Req)
 386         req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
 387         req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
 388
 389         controller.X2Reset(writer, req)
 390         assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
 391
 392 }
 393
 394 func TestX2ResetHandleSuccessfulRequestedDefault(t *testing.T) {
 395         controller, readerMock, _, rmrMessengerMock := setupControllerTest(t)
 396
 397         ranName := "test1"
 398         // o&m intervention
 399         payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x64}
 400         var xAction[]byte
 401         msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction)
 402         rmrMessengerMock.On("SendMsg", msg).Return(msg, nil)
 403
 404         writer := httptest.NewRecorder()
 405
 406         var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
 407         readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
 408
 409         // no body
 410         b := new(bytes.Buffer)
 411         req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
 412         req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
 413
 414         controller.X2Reset(writer, req)
 415         assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
 416
 417 }
 418
 419 func TestX2ResetHandleFailureInvalidBody(t *testing.T) {
 420         controller, _, _, _ := setupControllerTest(t)
 421
 422         ranName := "test1"
 423
 424         writer := httptest.NewRecorder()
 425
 426         // Invalid json: attribute name without quotes (should be "cause":).
 427         b := strings.NewReader("{cause:\"protocol:transfer-syntax-error\"")
 428         req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
 429         req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
 430
 431         controller.X2Reset(writer, req)
 432         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
 433
 434 }
 435
 436 func TestHandleErrorResponse(t *testing.T) {
 437         controller, _, _, _ := setupControllerTest(t)
 438
 439         writer := httptest.NewRecorder()
 440         controller.handleErrorResponse(e2managererrors.NewRnibDbError(), writer)
 441         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
 442
 443         writer = httptest.NewRecorder()
 444         controller.handleErrorResponse(e2managererrors.NewCommandAlreadyInProgressError(), writer)
 445         assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
 446
 447         writer = httptest.NewRecorder()
 448         controller.handleErrorResponse(e2managererrors.NewHeaderValidationError(), writer)
 449         assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
 450
 451         writer = httptest.NewRecorder()
 452         controller.handleErrorResponse(e2managererrors.NewWrongStateError("", ""), writer)
 453         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
 454
 455         writer = httptest.NewRecorder()
 456         controller.handleErrorResponse(e2managererrors.NewRequestValidationError(), writer)
 457         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
 458
 459         writer = httptest.NewRecorder()
 460         controller.handleErrorResponse(e2managererrors.NewRmrError(), writer)
 461         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
 462
 463         writer = httptest.NewRecorder()
 464         controller.handleErrorResponse(e2managererrors.NewResourceNotFoundError(), writer)
 465         assert.Equal(t, http.StatusNotFound, writer.Result().StatusCode)
 466
 467         writer = httptest.NewRecorder()
 468         controller.handleErrorResponse(fmt.Errorf("ErrorError"), writer)
 469         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
 470 }
 471
 472 func getRmrSender(rmrMessengerMock *mocks.RmrMessengerMock, log *logger.Logger) *rmrsender.RmrSender {
 473         rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
 474         rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
 475         return rmrsender.NewRmrSender(log, rmrMessenger)
 476 }