2 // Copyright 2019 AT&T Intellectual Property
3 // Copyright 2019 Nokia
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
9 // http://www.apache.org/licenses/LICENSE-2.0
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.
17 // This source code is part of the near-RT RIC (RAN Intelligent Controller)
18 // platform project (RICP).
26 "e2mgr/e2managererrors"
31 "e2mgr/providers/httpmsghandlerprovider"
34 "e2mgr/services/rmrsender"
38 "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
39 "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
40 "github.com/golang/protobuf/jsonpb"
41 "github.com/gorilla/mux"
42 "github.com/pkg/errors"
43 "github.com/stretchr/testify/assert"
44 "github.com/stretchr/testify/mock"
56 AssociatedE2TInstanceAddress = "10.0.2.15:38000"
57 CorruptedJson = "{\"errorCode\":401,\"errorMessage\":\"corrupted json\"}"
58 ValidationFailureJson = "{\"errorCode\":402,\"errorMessage\":\"Validation error\"}"
59 ResourceNotFoundJson = "{\"errorCode\":404,\"errorMessage\":\"Resource not found\"}"
60 NodebExistsJson = "{\"errorCode\":406,\"errorMessage\":\"Nodeb already exists\"}"
61 RnibErrorJson = "{\"errorCode\":500,\"errorMessage\":\"RNIB error\"}"
62 InternalErrorJson = "{\"errorCode\":501,\"errorMessage\":\"Internal Server Error. Please try again later\"}"
63 AddEnbUrl = "/nodeb/enb"
67 ServedNrCellInformationRequiredFields = []string{"cellId", "choiceNrMode", "nrMode", "servedPlmns"}
68 NrNeighbourInformationRequiredFields = []string{"nrCgi", "choiceNrMode", "nrMode"}
69 AddEnbRequestRequiredFields = []string{"ranName", "enb", "globalNbId"}
70 GlobalIdRequiredFields = []string{"plmnId", "nbId"}
71 EnbRequiredFields = []string{"enbType", "servedCells"}
72 ServedCellRequiredFields = []string{"broadcastPlmns", "cellId", "choiceEutraMode", "eutraMode", "tac"}
75 type controllerGetNodebTestContext struct {
77 nodebInfo *entities.NodebInfo
79 expectedStatusCode int
80 expectedJsonResponse string
83 type controllerGetNodebIdListTestContext struct {
84 nodebIdList []*entities.NbIdentity
86 expectedStatusCode int
87 expectedJsonResponse string
90 type getNodebInfoResult struct {
91 nodebInfo *entities.NodebInfo
95 type updateGnbCellsParams struct {
99 type saveNodebParams struct {
100 nodebInfo *entities.NodebInfo
101 nbIdentity *entities.NbIdentity
105 type removeServedNrCellsParams struct {
106 servedNrCells []*entities.ServedNRCell
110 type controllerUpdateGnbTestContext struct {
111 getNodebInfoResult *getNodebInfoResult
112 removeServedNrCellsParams *removeServedNrCellsParams
113 updateGnbCellsParams *updateGnbCellsParams
114 requestBody map[string]interface{}
115 expectedStatusCode int
116 expectedJsonResponse string
119 type controllerAddEnbTestContext struct {
120 getNodebInfoResult *getNodebInfoResult
121 saveNodebParams *saveNodebParams
122 requestBody map[string]interface{}
123 expectedStatusCode int
124 expectedJsonResponse string
127 func generateServedNrCells(cellIds ...string) []*entities.ServedNRCell {
129 servedNrCells := []*entities.ServedNRCell{}
131 for _, v := range cellIds {
132 servedNrCells = append(servedNrCells, &entities.ServedNRCell{ServedNrCellInformation: &entities.ServedNRCellInformation{
134 ChoiceNrMode: &entities.ServedNRCellInformation_ChoiceNRMode{
135 Fdd: &entities.ServedNRCellInformation_ChoiceNRMode_FddInfo{
139 NrMode: entities.Nr_FDD,
141 ServedPlmns: []string{"whatever"},
148 func buildNrNeighbourInformation(propToOmit string) map[string]interface{} {
149 ret := map[string]interface{}{
151 "choiceNrMode": map[string]interface{}{
152 "tdd": map[string]interface{}{},
158 if len(propToOmit) != 0 {
159 delete(ret, propToOmit)
165 func buildServedNrCellInformation(propToOmit string) map[string]interface{} {
166 ret := map[string]interface{}{
167 "cellId": "whatever",
168 "choiceNrMode": map[string]interface{}{
169 "fdd": map[string]interface{}{},
173 "servedPlmns": []interface{}{
178 if len(propToOmit) != 0 {
179 delete(ret, propToOmit)
185 func buildServedCell(propToOmit string) map[string]interface{} {
186 ret := map[string]interface{}{
187 "cellId": "whatever",
188 "choiceEutraMode": map[string]interface{}{
189 "fdd": map[string]interface{}{},
194 "broadcastPlmns": []interface{}{
199 if len(propToOmit) != 0 {
200 delete(ret, propToOmit)
206 func getAddEnbRequest(propToOmit string) map[string]interface{} {
207 ret := map[string]interface{}{
209 "globalNbId": buildGlobalNbId(""),
213 if len(propToOmit) != 0 {
214 delete(ret, propToOmit)
220 func buildEnb(propToOmit string) map[string]interface{} {
221 ret := map[string]interface{}{
223 "servedCells": []interface{}{
227 if len(propToOmit) != 0 {
228 delete(ret, propToOmit)
234 func buildGlobalNbId(propToOmit string) map[string]interface{} {
235 ret := map[string]interface{}{
236 "plmnId": "whatever",
240 if len(propToOmit) != 0 {
241 delete(ret, propToOmit)
247 func setupControllerTest(t *testing.T) (*NodebController, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.RmrMessengerMock, *mocks.E2TInstancesManagerMock) {
249 config := configuration.ParseConfiguration()
251 rmrMessengerMock := &mocks.RmrMessengerMock{}
252 readerMock := &mocks.RnibReaderMock{}
254 writerMock := &mocks.RnibWriterMock{}
256 rnibDataService := services.NewRnibDataService(log, config, readerMock, writerMock)
257 rmrSender := getRmrSender(rmrMessengerMock, log)
258 e2tInstancesManager := &mocks.E2TInstancesManagerMock{}
259 httpClientMock := &mocks.HttpClientMock{}
260 rmClient := clients.NewRoutingManagerClient(log, config, httpClientMock)
261 ranListManager := &mocks.RanListManagerMock{}
262 ranAlarmService := &mocks.RanAlarmServiceMock{}
263 ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(log, rnibDataService, ranListManager, ranAlarmService)
264 nodebValidator := managers.NewNodebValidator()
265 updateEnbManager := managers.NewUpdateEnbManager(log, rnibDataService, nodebValidator)
267 handlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(log, rmrSender, config, rnibDataService, e2tInstancesManager, rmClient, ranConnectStatusChangeManager, nodebValidator, updateEnbManager)
268 controller := NewNodebController(log, handlerProvider)
269 return controller, readerMock, writerMock, rmrMessengerMock, e2tInstancesManager
272 func TestShutdownHandlerRnibError(t *testing.T) {
273 controller, _, _, _, e2tInstancesManagerMock := setupControllerTest(t)
274 e2tInstancesManagerMock.On("GetE2TAddresses").Return([]string{}, e2managererrors.NewRnibDbError())
276 writer := httptest.NewRecorder()
278 controller.Shutdown(writer, tests.GetHttpRequest())
280 var errorResponse = parseJsonRequest(t, writer.Body)
282 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
283 assert.Equal(t, errorResponse.Code, e2managererrors.NewRnibDbError().Code)
286 func TestSetGeneralConfigurationHandlerRnibError(t *testing.T) {
287 controller, readerMock, _, _, _ := setupControllerTest(t)
289 configuration := &entities.GeneralConfiguration{}
290 readerMock.On("GetGeneralConfiguration").Return(configuration, e2managererrors.NewRnibDbError())
292 writer := httptest.NewRecorder()
294 httpRequest, _ := http.NewRequest("PUT", "https://localhost:3800/v1/nodeb/parameters", strings.NewReader("{\"enableRic\":false}"))
296 controller.SetGeneralConfiguration(writer, httpRequest)
298 var errorResponse = parseJsonRequest(t, writer.Body)
300 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
301 assert.Equal(t, e2managererrors.NewRnibDbError().Code, errorResponse.Code)
304 func TestSetGeneralConfigurationInvalidJson(t *testing.T) {
305 controller, _, _, _, _ := setupControllerTest(t)
307 writer := httptest.NewRecorder()
309 httpRequest, _ := http.NewRequest("PUT", "https://localhost:3800/v1/nodeb/parameters", strings.NewReader("{\"enableRic\":false, \"someValue\":false}"))
311 controller.SetGeneralConfiguration(writer, httpRequest)
313 var errorResponse = parseJsonRequest(t, writer.Body)
315 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
316 assert.Equal(t, e2managererrors.NewInvalidJsonError().Code, errorResponse.Code)
319 func controllerGetNodebTestExecuter(t *testing.T, context *controllerGetNodebTestContext) {
320 controller, readerMock, _, _, _ := setupControllerTest(t)
321 writer := httptest.NewRecorder()
322 readerMock.On("GetNodeb", context.ranName).Return(context.nodebInfo, context.rnibError)
323 req, _ := http.NewRequest(http.MethodGet, "/nodeb", nil)
324 req = mux.SetURLVars(req, map[string]string{"ranName": context.ranName})
325 controller.GetNodeb(writer, req)
326 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
327 bodyBytes, _ := ioutil.ReadAll(writer.Body)
328 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
331 func controllerGetNodebIdListTestExecuter(t *testing.T, context *controllerGetNodebIdListTestContext) {
332 controller, readerMock, _, _, _ := setupControllerTest(t)
333 writer := httptest.NewRecorder()
334 readerMock.On("GetListNodebIds").Return(context.nodebIdList, context.rnibError)
335 req, _ := http.NewRequest(http.MethodGet, "/nodeb/ids", nil)
336 controller.GetNodebIdList(writer, req)
337 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
338 bodyBytes, _ := ioutil.ReadAll(writer.Body)
339 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
342 func activateControllerUpdateGnbMocks(context *controllerUpdateGnbTestContext, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
343 if context.getNodebInfoResult != nil {
344 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
347 if context.removeServedNrCellsParams != nil {
348 writerMock.On("RemoveServedNrCells", RanName, context.removeServedNrCellsParams.servedNrCells).Return(context.removeServedNrCellsParams.err)
351 if context.updateGnbCellsParams != nil {
352 updatedNodebInfo := *context.getNodebInfoResult.nodebInfo
353 gnb := entities.Gnb{}
354 _ = jsonpb.Unmarshal(getJsonRequestAsBuffer(context.requestBody), &gnb)
355 updatedGnb := *updatedNodebInfo.GetGnb()
356 updatedGnb.ServedNrCells = gnb.ServedNrCells
357 writerMock.On("UpdateGnbCells", &updatedNodebInfo, gnb.ServedNrCells).Return(context.updateGnbCellsParams.err)
361 func assertControllerUpdateGnb(t *testing.T, context *controllerUpdateGnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
362 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
363 bodyBytes, _ := ioutil.ReadAll(writer.Body)
364 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
365 readerMock.AssertExpectations(t)
366 writerMock.AssertExpectations(t)
369 func assertControllerAddEnb(t *testing.T, context *controllerAddEnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
370 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
371 bodyBytes, _ := ioutil.ReadAll(writer.Body)
372 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
373 readerMock.AssertExpectations(t)
374 writerMock.AssertExpectations(t)
377 func buildUpdateGnbRequest(context *controllerUpdateGnbTestContext) *http.Request {
378 updateGnbUrl := fmt.Sprintf("/nodeb/%s/update", RanName)
379 requestBody := getJsonRequestAsBuffer(context.requestBody)
380 req, _ := http.NewRequest(http.MethodPut, updateGnbUrl, requestBody)
381 req.Header.Set("Content-Type", "application/json")
382 req = mux.SetURLVars(req, map[string]string{"ranName": RanName})
386 func buildAddEnbRequest(context *controllerAddEnbTestContext) *http.Request {
387 requestBody := getJsonRequestAsBuffer(context.requestBody)
388 req, _ := http.NewRequest(http.MethodPost, AddEnbUrl, requestBody)
389 req.Header.Set("Content-Type", "application/json")
393 func controllerUpdateGnbTestExecuter(t *testing.T, context *controllerUpdateGnbTestContext) {
394 controller, readerMock, writerMock, _, _ := setupControllerTest(t)
395 writer := httptest.NewRecorder()
397 activateControllerUpdateGnbMocks(context, readerMock, writerMock)
398 req := buildUpdateGnbRequest(context)
399 controller.UpdateGnb(writer, req)
400 assertControllerUpdateGnb(t, context, writer, readerMock, writerMock)
403 func activateControllerAddEnbMocks(context *controllerAddEnbTestContext, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock, addEnbRequest *models.AddEnbRequest) {
404 if context.getNodebInfoResult != nil {
405 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
408 if context.saveNodebParams != nil {
409 nodebInfo := entities.NodebInfo{
410 RanName: addEnbRequest.RanName,
411 Ip: addEnbRequest.Ip,
412 Port: addEnbRequest.Port,
413 NodeType: entities.Node_ENB,
414 GlobalNbId: addEnbRequest.GlobalNbId,
415 Configuration: &entities.NodebInfo_Enb{Enb: addEnbRequest.Enb},
416 ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,
419 nbIdentity := entities.NbIdentity{InventoryName: addEnbRequest.RanName, GlobalNbId: addEnbRequest.GlobalNbId}
421 writerMock.On("SaveNodeb", &nbIdentity, &nodebInfo).Return(context.saveNodebParams.err)
425 func controllerAddEnbTestExecuter(t *testing.T, context *controllerAddEnbTestContext) {
426 controller, readerMock, writerMock, _, _ := setupControllerTest(t)
427 writer := httptest.NewRecorder()
428 r := buildAddEnbRequest(context)
429 body, _ := ioutil.ReadAll(io.LimitReader(r.Body, LimitRequest))
431 addEnbRequest := models.AddEnbRequest{}
433 _ = json.Unmarshal(body, &addEnbRequest)
434 activateControllerAddEnbMocks(context, readerMock, writerMock, &addEnbRequest)
435 r = buildAddEnbRequest(context)
437 controller.AddEnb(writer, r)
438 assertControllerAddEnb(t, context, writer, readerMock, writerMock)
441 func TestControllerUpdateGnbEmptyServedNrCells(t *testing.T) {
442 context := controllerUpdateGnbTestContext{
443 getNodebInfoResult: nil,
444 requestBody: map[string]interface{}{
445 "servedNrCells": []interface{}{
448 expectedStatusCode: http.StatusBadRequest,
449 expectedJsonResponse: ValidationFailureJson,
452 controllerUpdateGnbTestExecuter(t, &context)
455 func TestControllerUpdateGnbMissingServedNrCellInformation(t *testing.T) {
456 context := controllerUpdateGnbTestContext{
457 getNodebInfoResult: nil,
458 requestBody: map[string]interface{}{
459 "servedNrCells": []interface{}{
460 map[string]interface{}{
461 "servedNrCellInformation": nil,
465 expectedStatusCode: http.StatusBadRequest,
466 expectedJsonResponse: ValidationFailureJson,
469 controllerUpdateGnbTestExecuter(t, &context)
472 func TestControllerUpdateGnbMissingServedNrCellRequiredProp(t *testing.T) {
474 for _, v := range ServedNrCellInformationRequiredFields {
475 context := controllerUpdateGnbTestContext{
476 getNodebInfoResult: nil,
477 requestBody: map[string]interface{}{
478 "servedNrCells": []interface{}{
479 map[string]interface{}{
480 "servedNrCellInformation": buildServedNrCellInformation(v),
484 expectedStatusCode: http.StatusBadRequest,
485 expectedJsonResponse: ValidationFailureJson,
488 controllerUpdateGnbTestExecuter(t, &context)
492 func TestControllerUpdateGnbMissingServedNrCellFddOrTdd(t *testing.T) {
494 servedNrCellInformation := buildServedNrCellInformation("")
495 servedNrCellInformation["choiceNrMode"] = map[string]interface{}{}
497 context := controllerUpdateGnbTestContext{
498 getNodebInfoResult: nil,
499 requestBody: map[string]interface{}{
500 "servedNrCells": []interface{}{
501 map[string]interface{}{
502 "servedNrCellInformation": servedNrCellInformation,
506 expectedStatusCode: http.StatusBadRequest,
507 expectedJsonResponse: ValidationFailureJson,
510 controllerUpdateGnbTestExecuter(t, &context)
513 func TestControllerUpdateGnbMissingNeighbourInfoFddOrTdd(t *testing.T) {
515 nrNeighbourInfo := buildNrNeighbourInformation("")
516 nrNeighbourInfo["choiceNrMode"] = map[string]interface{}{}
518 context := controllerUpdateGnbTestContext{
519 getNodebInfoResult: nil,
520 requestBody: map[string]interface{}{
521 "servedNrCells": []interface{}{
522 map[string]interface{}{
523 "servedNrCellInformation": buildServedNrCellInformation(""),
524 "nrNeighbourInfos": []interface{}{
530 expectedStatusCode: http.StatusBadRequest,
531 expectedJsonResponse: ValidationFailureJson,
534 controllerUpdateGnbTestExecuter(t, &context)
537 func TestControllerUpdateGnbMissingNrNeighbourInformationRequiredProp(t *testing.T) {
539 for _, v := range NrNeighbourInformationRequiredFields {
540 context := controllerUpdateGnbTestContext{
541 getNodebInfoResult: nil,
542 requestBody: map[string]interface{}{
543 "servedNrCells": []interface{}{
544 map[string]interface{}{
545 "servedNrCellInformation": buildServedNrCellInformation(""),
546 "nrNeighbourInfos": []interface{}{
547 buildNrNeighbourInformation(v),
552 expectedStatusCode: http.StatusBadRequest,
553 expectedJsonResponse: ValidationFailureJson,
556 controllerUpdateGnbTestExecuter(t, &context)
560 func TestControllerUpdateGnbValidServedNrCellInformationGetNodebNotFound(t *testing.T) {
561 context := controllerUpdateGnbTestContext{
562 getNodebInfoResult: &getNodebInfoResult{
564 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
566 requestBody: map[string]interface{}{
567 "servedNrCells": []interface{}{
568 map[string]interface{}{
569 "servedNrCellInformation": buildServedNrCellInformation(""),
573 expectedStatusCode: http.StatusNotFound,
574 expectedJsonResponse: ResourceNotFoundJson,
577 controllerUpdateGnbTestExecuter(t, &context)
580 func TestControllerUpdateGnbValidServedNrCellInformationGetNodebInternalError(t *testing.T) {
581 context := controllerUpdateGnbTestContext{
582 getNodebInfoResult: &getNodebInfoResult{
584 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
586 requestBody: map[string]interface{}{
587 "servedNrCells": []interface{}{
588 map[string]interface{}{
589 "servedNrCellInformation": buildServedNrCellInformation(""),
593 expectedStatusCode: http.StatusInternalServerError,
594 expectedJsonResponse: RnibErrorJson,
597 controllerUpdateGnbTestExecuter(t, &context)
600 func TestControllerUpdateGnbGetNodebSuccessInvalidGnbConfiguration(t *testing.T) {
601 context := controllerUpdateGnbTestContext{
602 getNodebInfoResult: &getNodebInfoResult{
603 nodebInfo: &entities.NodebInfo{
605 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
606 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
610 requestBody: map[string]interface{}{
611 "servedNrCells": []interface{}{
612 map[string]interface{}{
613 "servedNrCellInformation": buildServedNrCellInformation(""),
614 "nrNeighbourInfos": []interface{}{
615 buildNrNeighbourInformation(""),
620 expectedStatusCode: http.StatusInternalServerError,
621 expectedJsonResponse: InternalErrorJson,
624 controllerUpdateGnbTestExecuter(t, &context)
627 func TestControllerUpdateGnbGetNodebSuccessRemoveServedNrCellsFailure(t *testing.T) {
628 oldServedNrCells := generateServedNrCells("whatever1", "whatever2")
629 context := controllerUpdateGnbTestContext{
630 removeServedNrCellsParams: &removeServedNrCellsParams{
631 err: common.NewInternalError(errors.New("#writer.UpdateGnbCells - Internal Error")),
632 servedNrCells: oldServedNrCells,
634 getNodebInfoResult: &getNodebInfoResult{
635 nodebInfo: &entities.NodebInfo{
637 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
638 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
639 Configuration: &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{ServedNrCells: oldServedNrCells}},
643 requestBody: map[string]interface{}{
644 "servedNrCells": []interface{}{
645 map[string]interface{}{
646 "servedNrCellInformation": buildServedNrCellInformation(""),
647 "nrNeighbourInfos": []interface{}{
648 buildNrNeighbourInformation(""),
653 expectedStatusCode: http.StatusInternalServerError,
654 expectedJsonResponse: RnibErrorJson,
657 controllerUpdateGnbTestExecuter(t, &context)
660 func TestControllerUpdateGnbGetNodebSuccessUpdateGnbCellsFailure(t *testing.T) {
661 oldServedNrCells := generateServedNrCells("whatever1", "whatever2")
662 context := controllerUpdateGnbTestContext{
663 removeServedNrCellsParams: &removeServedNrCellsParams{
665 servedNrCells: oldServedNrCells,
667 updateGnbCellsParams: &updateGnbCellsParams{
668 err: common.NewInternalError(errors.New("#writer.UpdateGnbCells - Internal Error")),
670 getNodebInfoResult: &getNodebInfoResult{
671 nodebInfo: &entities.NodebInfo{
673 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
674 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
675 Configuration: &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{ServedNrCells: oldServedNrCells}},
679 requestBody: map[string]interface{}{
680 "servedNrCells": []interface{}{
681 map[string]interface{}{
682 "servedNrCellInformation": buildServedNrCellInformation(""),
683 "nrNeighbourInfos": []interface{}{
684 buildNrNeighbourInformation(""),
689 expectedStatusCode: http.StatusInternalServerError,
690 expectedJsonResponse: RnibErrorJson,
693 controllerUpdateGnbTestExecuter(t, &context)
696 func TestControllerUpdateGnbSuccess(t *testing.T) {
697 context := controllerUpdateGnbTestContext{
698 updateGnbCellsParams: &updateGnbCellsParams{
701 getNodebInfoResult: &getNodebInfoResult{
702 nodebInfo: &entities.NodebInfo{
704 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
705 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
706 Configuration: &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{}},
710 requestBody: map[string]interface{}{
711 "servedNrCells": []interface{}{
712 map[string]interface{}{
713 "servedNrCellInformation": buildServedNrCellInformation(""),
714 "nrNeighbourInfos": []interface{}{
715 buildNrNeighbourInformation(""),
720 expectedStatusCode: http.StatusOK,
721 expectedJsonResponse: "{\"ranName\":\"test\",\"connectionStatus\":\"CONNECTED\",\"gnb\":{\"servedNrCells\":[{\"servedNrCellInformation\":{\"nrPci\":1,\"cellId\":\"whatever\",\"servedPlmns\":[\"whatever\"],\"nrMode\":\"FDD\",\"choiceNrMode\":{\"fdd\":{}}},\"nrNeighbourInfos\":[{\"nrPci\":1,\"nrCgi\":\"whatever\",\"nrMode\":\"FDD\",\"choiceNrMode\":{\"tdd\":{}}}]}]},\"associatedE2tInstanceAddress\":\"10.0.2.15:38000\"}",
724 controllerUpdateGnbTestExecuter(t, &context)
727 func TestControllerAddEnbGetNodebInternalError(t *testing.T) {
728 context := controllerAddEnbTestContext{
729 getNodebInfoResult: &getNodebInfoResult{
731 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
733 requestBody: getAddEnbRequest(""),
734 expectedStatusCode: http.StatusInternalServerError,
735 expectedJsonResponse: RnibErrorJson,
738 controllerAddEnbTestExecuter(t, &context)
741 func TestControllerAddEnbNodebExistsFailure(t *testing.T) {
742 context := controllerAddEnbTestContext{
743 getNodebInfoResult: &getNodebInfoResult{
744 nodebInfo: &entities.NodebInfo{},
747 requestBody: getAddEnbRequest(""),
748 expectedStatusCode: http.StatusBadRequest,
749 expectedJsonResponse: NodebExistsJson,
752 controllerAddEnbTestExecuter(t, &context)
755 func TestControllerAddEnbSaveNodebFailure(t *testing.T) {
756 context := controllerAddEnbTestContext{
757 saveNodebParams: &saveNodebParams{
758 err: common.NewInternalError(errors.New("#reader.SaveeNodeb - Internal Error")),
760 getNodebInfoResult: &getNodebInfoResult{
762 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
764 requestBody: getAddEnbRequest(""),
765 expectedStatusCode: http.StatusInternalServerError,
766 expectedJsonResponse: RnibErrorJson,
769 controllerAddEnbTestExecuter(t, &context)
772 func TestControllerAddEnbMissingRequiredRequestProps(t *testing.T) {
774 for _, v := range AddEnbRequestRequiredFields {
775 context := controllerAddEnbTestContext{
776 requestBody: getAddEnbRequest(v),
777 expectedStatusCode: http.StatusBadRequest,
778 expectedJsonResponse: ValidationFailureJson,
781 controllerAddEnbTestExecuter(t, &context)
785 func TestControllerAddEnbInvalidRequest(t *testing.T) {
786 controller, _, _, _, _ := setupControllerTest(t)
787 writer := httptest.NewRecorder()
789 // Invalid json: attribute name without quotes (should be "cause":).
790 invalidJson := strings.NewReader("{ranName:\"whatever\"")
791 req, _ := http.NewRequest(http.MethodPost, AddEnbUrl, invalidJson)
793 controller.AddEnb(writer, req)
794 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
795 bodyBytes, _ := ioutil.ReadAll(writer.Body)
796 assert.Equal(t, CorruptedJson, string(bodyBytes))
800 func TestControllerAddEnbMissingRequiredGlobalNbIdProps(t *testing.T) {
802 r := getAddEnbRequest("")
804 for _, v := range GlobalIdRequiredFields {
805 r["globalNbId"] = buildGlobalNbId(v)
807 context := controllerAddEnbTestContext{
809 expectedStatusCode: http.StatusBadRequest,
810 expectedJsonResponse: ValidationFailureJson,
813 controllerAddEnbTestExecuter(t, &context)
817 func TestControllerAddEnbMissingRequiredEnbProps(t *testing.T) {
819 r := getAddEnbRequest("")
821 for _, v := range EnbRequiredFields {
822 r["enb"] = buildEnb(v)
824 context := controllerAddEnbTestContext{
826 expectedStatusCode: http.StatusBadRequest,
827 expectedJsonResponse: ValidationFailureJson,
830 controllerAddEnbTestExecuter(t, &context)
834 func TestControllerAddEnbMissingRequiredServedCellProps(t *testing.T) {
836 r := getAddEnbRequest("")
838 for _, v := range ServedCellRequiredFields {
841 enbMap, _ := enb.(map[string]interface{})
843 enbMap["servedCells"] = []interface{}{
847 context := controllerAddEnbTestContext{
849 expectedStatusCode: http.StatusBadRequest,
850 expectedJsonResponse: ValidationFailureJson,
853 controllerAddEnbTestExecuter(t, &context)
857 func TestControllerAddEnbSuccess(t *testing.T) {
858 context := controllerAddEnbTestContext{
859 saveNodebParams: &saveNodebParams{
862 getNodebInfoResult: &getNodebInfoResult{
864 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
866 requestBody: map[string]interface{}{
868 "globalNbId": map[string]interface{}{
869 "plmnId": "whatever",
872 "enb": map[string]interface{}{
874 "servedCells": []interface{}{
879 expectedStatusCode: http.StatusCreated,
880 expectedJsonResponse: "{\"ranName\":\"test\",\"connectionStatus\":\"DISCONNECTED\",\"globalNbId\":{\"plmnId\":\"whatever\",\"nbId\":\"whatever2\"},\"nodeType\":\"ENB\",\"enb\":{\"enbType\":\"MACRO_ENB\",\"servedCells\":[{\"pci\":1,\"cellId\":\"whatever\",\"tac\":\"whatever3\",\"broadcastPlmns\":[\"whatever\"],\"choiceEutraMode\":{\"fdd\":{}},\"eutraMode\":\"FDD\"}]}}",
883 controllerAddEnbTestExecuter(t, &context)
886 func getJsonRequestAsBuffer(requestJson map[string]interface{}) *bytes.Buffer {
887 b := new(bytes.Buffer)
888 _ = json.NewEncoder(b).Encode(requestJson)
892 func TestControllerGetNodebSuccess(t *testing.T) {
895 context := controllerGetNodebTestContext{
897 nodebInfo: &entities.NodebInfo{RanName: ranName, Ip: "10.0.2.15", Port: 1234},
898 rnibError: rnibError,
899 expectedStatusCode: http.StatusOK,
900 expectedJsonResponse: fmt.Sprintf("{\"ranName\":\"%s\",\"ip\":\"10.0.2.15\",\"port\":1234}", ranName),
903 controllerGetNodebTestExecuter(t, &context)
906 func TestControllerGetNodebNotFound(t *testing.T) {
909 var nodebInfo *entities.NodebInfo
910 context := controllerGetNodebTestContext{
912 nodebInfo: nodebInfo,
913 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
914 expectedStatusCode: http.StatusNotFound,
915 expectedJsonResponse: ResourceNotFoundJson,
918 controllerGetNodebTestExecuter(t, &context)
921 func TestControllerGetNodebInternal(t *testing.T) {
923 var nodebInfo *entities.NodebInfo
924 context := controllerGetNodebTestContext{
926 nodebInfo: nodebInfo,
927 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
928 expectedStatusCode: http.StatusInternalServerError,
929 expectedJsonResponse: RnibErrorJson,
932 controllerGetNodebTestExecuter(t, &context)
935 func TestControllerGetNodebIdListSuccess(t *testing.T) {
937 nodebIdList := []*entities.NbIdentity{
938 {InventoryName: "test1", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}},
939 {InventoryName: "test2", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId2", NbId: "nbId2"}},
942 context := controllerGetNodebIdListTestContext{
943 nodebIdList: nodebIdList,
944 rnibError: rnibError,
945 expectedStatusCode: http.StatusOK,
946 expectedJsonResponse: "[{\"inventoryName\":\"test1\",\"globalNbId\":{\"plmnId\":\"plmnId1\",\"nbId\":\"nbId1\"}},{\"inventoryName\":\"test2\",\"globalNbId\":{\"plmnId\":\"plmnId2\",\"nbId\":\"nbId2\"}}]",
949 controllerGetNodebIdListTestExecuter(t, &context)
952 func TestControllerGetNodebIdListEmptySuccess(t *testing.T) {
954 var nodebIdList []*entities.NbIdentity
956 context := controllerGetNodebIdListTestContext{
957 nodebIdList: nodebIdList,
958 rnibError: rnibError,
959 expectedStatusCode: http.StatusOK,
960 expectedJsonResponse: "[]",
963 controllerGetNodebIdListTestExecuter(t, &context)
966 func TestControllerGetNodebIdListInternal(t *testing.T) {
967 var nodebIdList []*entities.NbIdentity
968 context := controllerGetNodebIdListTestContext{
969 nodebIdList: nodebIdList,
970 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
971 expectedStatusCode: http.StatusInternalServerError,
972 expectedJsonResponse: RnibErrorJson,
975 controllerGetNodebIdListTestExecuter(t, &context)
978 func TestHeaderValidationFailed(t *testing.T) {
979 controller, _, _, _, _ := setupControllerTest(t)
981 writer := httptest.NewRecorder()
983 header := &http.Header{}
985 controller.handleRequest(writer, header, httpmsghandlerprovider.ShutdownRequest, nil, true, 0)
987 var errorResponse = parseJsonRequest(t, writer.Body)
988 err := e2managererrors.NewHeaderValidationError()
990 assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
991 assert.Equal(t, errorResponse.Code, err.Code)
992 assert.Equal(t, errorResponse.Message, err.Message)
995 func TestShutdownStatusNoContent(t *testing.T) {
996 controller, readerMock, _, _, e2tInstancesManagerMock := setupControllerTest(t)
997 e2tInstancesManagerMock.On("GetE2TAddresses").Return([]string{}, nil)
998 readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{}, nil)
1000 writer := httptest.NewRecorder()
1001 controller.Shutdown(writer, tests.GetHttpRequest())
1003 assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
1006 func TestHandleInternalError(t *testing.T) {
1007 controller, _, _, _, _ := setupControllerTest(t)
1009 writer := httptest.NewRecorder()
1010 err := e2managererrors.NewInternalError()
1012 controller.handleErrorResponse(err, writer)
1013 var errorResponse = parseJsonRequest(t, writer.Body)
1015 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1016 assert.Equal(t, errorResponse.Code, err.Code)
1017 assert.Equal(t, errorResponse.Message, err.Message)
1020 func TestHandleCommandAlreadyInProgressError(t *testing.T) {
1021 controller, _, _, _, _ := setupControllerTest(t)
1022 writer := httptest.NewRecorder()
1023 err := e2managererrors.NewCommandAlreadyInProgressError()
1025 controller.handleErrorResponse(err, writer)
1026 var errorResponse = parseJsonRequest(t, writer.Body)
1028 assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
1029 assert.Equal(t, errorResponse.Code, err.Code)
1030 assert.Equal(t, errorResponse.Message, err.Message)
1033 func TestHandleRoutingManagerError(t *testing.T) {
1034 controller, _, _, _, _ := setupControllerTest(t)
1035 writer := httptest.NewRecorder()
1036 err := e2managererrors.NewRoutingManagerError()
1038 controller.handleErrorResponse(err, writer)
1039 var errorResponse = parseJsonRequest(t, writer.Body)
1041 assert.Equal(t, http.StatusServiceUnavailable, writer.Result().StatusCode)
1042 assert.Equal(t, errorResponse.Code, err.Code)
1043 assert.Equal(t, errorResponse.Message, err.Message)
1046 func TestHandleE2TInstanceAbsenceError(t *testing.T) {
1047 controller, _, _, _, _ := setupControllerTest(t)
1049 writer := httptest.NewRecorder()
1050 err := e2managererrors.NewE2TInstanceAbsenceError()
1052 controller.handleErrorResponse(err, writer)
1053 var errorResponse = parseJsonRequest(t, writer.Body)
1055 assert.Equal(t, http.StatusServiceUnavailable, writer.Result().StatusCode)
1056 assert.Equal(t, errorResponse.Code, err.Code)
1057 assert.Equal(t, errorResponse.Message, err.Message)
1060 func TestValidateHeaders(t *testing.T) {
1061 controller, _, _, _, _ := setupControllerTest(t)
1063 header := http.Header{}
1064 header.Set("Content-Type", "application/json")
1065 result := controller.validateRequestHeader(&header)
1067 assert.Nil(t, result)
1070 func parseJsonRequest(t *testing.T, r io.Reader) models.ErrorResponse {
1072 var errorResponse models.ErrorResponse
1073 body, err := ioutil.ReadAll(r)
1075 t.Errorf("Error cannot deserialize json request")
1077 _ = json.Unmarshal(body, &errorResponse)
1079 return errorResponse
1082 func initLog(t *testing.T) *logger.Logger {
1083 log, err := logger.InitLogger(logger.InfoLevel)
1085 t.Errorf("#delete_all_request_handler_test.TestHandleSuccessFlow - failed to initialize logger, error: %s", err)
1090 func TestX2ResetHandleSuccessfulRequestedCause(t *testing.T) {
1091 controller, readerMock, _, rmrMessengerMock, _ := setupControllerTest(t)
1094 payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x40}
1096 var msgSrc unsafe.Pointer
1097 msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction, msgSrc)
1098 rmrMessengerMock.On("SendMsg", msg, mock.Anything).Return(msg, nil)
1100 writer := httptest.NewRecorder()
1102 var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
1103 readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
1105 data4Req := map[string]interface{}{"cause": "protocol:transfer-syntax-error"}
1106 b := new(bytes.Buffer)
1107 _ = json.NewEncoder(b).Encode(data4Req)
1108 req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
1109 req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
1111 controller.X2Reset(writer, req)
1112 assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
1116 func TestX2ResetHandleSuccessfulRequestedDefault(t *testing.T) {
1117 controller, readerMock, _, rmrMessengerMock, _ := setupControllerTest(t)
1121 payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x64}
1123 var msgSrc unsafe.Pointer
1124 msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction, msgSrc)
1125 rmrMessengerMock.On("SendMsg", msg, true).Return(msg, nil)
1127 writer := httptest.NewRecorder()
1129 var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
1130 readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
1133 b := new(bytes.Buffer)
1134 data4Req := map[string]interface{}{}
1135 _ = json.NewEncoder(b).Encode(data4Req)
1136 req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
1137 req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
1139 controller.X2Reset(writer, req)
1140 assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
1143 func TestX2ResetHandleFailureInvalidBody(t *testing.T) {
1144 controller, _, _, _, _ := setupControllerTest(t)
1148 writer := httptest.NewRecorder()
1150 // Invalid json: attribute name without quotes (should be "cause":).
1151 b := strings.NewReader("{cause:\"protocol:transfer-syntax-error\"")
1152 req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
1153 req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
1155 controller.X2Reset(writer, req)
1156 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1160 func TestHandleErrorResponse(t *testing.T) {
1161 controller, _, _, _, _ := setupControllerTest(t)
1163 writer := httptest.NewRecorder()
1164 controller.handleErrorResponse(e2managererrors.NewRnibDbError(), writer)
1165 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1167 writer = httptest.NewRecorder()
1168 controller.handleErrorResponse(e2managererrors.NewCommandAlreadyInProgressError(), writer)
1169 assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
1171 writer = httptest.NewRecorder()
1172 controller.handleErrorResponse(e2managererrors.NewHeaderValidationError(), writer)
1173 assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
1175 writer = httptest.NewRecorder()
1176 controller.handleErrorResponse(e2managererrors.NewWrongStateError("", ""), writer)
1177 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1179 writer = httptest.NewRecorder()
1180 controller.handleErrorResponse(e2managererrors.NewRequestValidationError(), writer)
1181 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1183 writer = httptest.NewRecorder()
1184 controller.handleErrorResponse(e2managererrors.NewRmrError(), writer)
1185 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1187 writer = httptest.NewRecorder()
1188 controller.handleErrorResponse(e2managererrors.NewResourceNotFoundError(), writer)
1189 assert.Equal(t, http.StatusNotFound, writer.Result().StatusCode)
1191 writer = httptest.NewRecorder()
1192 controller.handleErrorResponse(fmt.Errorf("ErrorError"), writer)
1193 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1196 func getRmrSender(rmrMessengerMock *mocks.RmrMessengerMock, log *logger.Logger) *rmrsender.RmrSender {
1197 rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
1198 rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
1199 return rmrsender.NewRmrSender(log, rmrMessenger)