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 UpdateEnbRequestRequiredFields = []string{"enb"}
71 GlobalIdRequiredFields = []string{"plmnId", "nbId"}
72 EnbRequiredFields = []string{"enbType", "servedCells"}
73 ServedCellRequiredFields = []string{"broadcastPlmns", "cellId", "choiceEutraMode", "eutraMode", "tac"}
76 type controllerGetNodebTestContext struct {
78 nodebInfo *entities.NodebInfo
80 expectedStatusCode int
81 expectedJsonResponse string
84 type controllerGetNodebIdListTestContext struct {
85 nodebIdList []*entities.NbIdentity
87 expectedStatusCode int
88 expectedJsonResponse string
91 type getNodebInfoResult struct {
92 nodebInfo *entities.NodebInfo
96 type updateGnbCellsParams struct {
100 type updateEnbCellsParams struct {
104 type saveNodebParams struct {
105 nodebInfo *entities.NodebInfo
106 nbIdentity *entities.NbIdentity
110 type removeServedCellsParams struct {
111 servedCellInfo []*entities.ServedCellInfo
115 type removeServedNrCellsParams struct {
116 servedNrCells []*entities.ServedNRCell
120 type controllerUpdateEnbTestContext struct {
121 getNodebInfoResult *getNodebInfoResult
122 removeServedCellsParams *removeServedCellsParams
123 updateEnbCellsParams *updateEnbCellsParams
124 requestBody map[string]interface{}
125 expectedStatusCode int
126 expectedJsonResponse string
129 type controllerUpdateGnbTestContext struct {
130 getNodebInfoResult *getNodebInfoResult
131 removeServedNrCellsParams *removeServedNrCellsParams
132 updateGnbCellsParams *updateGnbCellsParams
133 requestBody map[string]interface{}
134 expectedStatusCode int
135 expectedJsonResponse string
138 type controllerAddEnbTestContext struct {
139 getNodebInfoResult *getNodebInfoResult
140 saveNodebParams *saveNodebParams
141 requestBody map[string]interface{}
142 expectedStatusCode int
143 expectedJsonResponse string
146 type controllerDeleteEnbTestContext struct {
147 getNodebInfoResult *getNodebInfoResult
148 expectedStatusCode int
149 expectedJsonResponse string
152 func generateServedNrCells(cellIds ...string) []*entities.ServedNRCell {
154 servedNrCells := []*entities.ServedNRCell{}
156 for _, v := range cellIds {
157 servedNrCells = append(servedNrCells, &entities.ServedNRCell{ServedNrCellInformation: &entities.ServedNRCellInformation{
159 ChoiceNrMode: &entities.ServedNRCellInformation_ChoiceNRMode{
160 Fdd: &entities.ServedNRCellInformation_ChoiceNRMode_FddInfo{
164 NrMode: entities.Nr_FDD,
166 ServedPlmns: []string{"whatever"},
173 func generateServedCells(cellIds ...string) []*entities.ServedCellInfo {
175 var servedCells []*entities.ServedCellInfo
177 for i, v := range cellIds {
178 servedCells = append(servedCells, &entities.ServedCellInfo{
180 ChoiceEutraMode: &entities.ChoiceEUTRAMode{
181 Fdd: &entities.FddInfo{},
184 BroadcastPlmns: []string{"whatever"},
191 func buildNrNeighbourInformation(propToOmit string) map[string]interface{} {
192 ret := map[string]interface{}{
194 "choiceNrMode": map[string]interface{}{
195 "tdd": map[string]interface{}{},
201 if len(propToOmit) != 0 {
202 delete(ret, propToOmit)
208 func buildServedNrCellInformation(propToOmit string) map[string]interface{} {
209 ret := map[string]interface{}{
210 "cellId": "whatever",
211 "choiceNrMode": map[string]interface{}{
212 "fdd": map[string]interface{}{},
216 "servedPlmns": []interface{}{
221 if len(propToOmit) != 0 {
222 delete(ret, propToOmit)
228 func buildServedCell(propToOmit string) map[string]interface{} {
229 ret := map[string]interface{}{
230 "cellId": "whatever",
231 "choiceEutraMode": map[string]interface{}{
232 "fdd": map[string]interface{}{},
237 "broadcastPlmns": []interface{}{
242 if len(propToOmit) != 0 {
243 delete(ret, propToOmit)
249 func getUpdateEnbRequest(propToOmit string) map[string]interface{} {
250 ret := map[string]interface{}{
251 "enb": buildEnb(propToOmit),
254 if len(propToOmit) != 0 {
255 delete(ret, propToOmit)
262 func getAddEnbRequest(propToOmit string) map[string]interface{} {
263 ret := map[string]interface{}{
265 "globalNbId": buildGlobalNbId(""),
269 if len(propToOmit) != 0 {
270 delete(ret, propToOmit)
276 func buildEnb(propToOmit string) map[string]interface{} {
277 ret := map[string]interface{}{
279 "servedCells": []interface{}{
283 if len(propToOmit) != 0 {
284 delete(ret, propToOmit)
290 func buildGlobalNbId(propToOmit string) map[string]interface{} {
291 ret := map[string]interface{}{
292 "plmnId": "whatever",
296 if len(propToOmit) != 0 {
297 delete(ret, propToOmit)
303 func setupControllerTest(t *testing.T) (*NodebController, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.RmrMessengerMock, *mocks.E2TInstancesManagerMock) {
305 config := configuration.ParseConfiguration()
307 rmrMessengerMock := &mocks.RmrMessengerMock{}
308 readerMock := &mocks.RnibReaderMock{}
310 writerMock := &mocks.RnibWriterMock{}
312 rnibDataService := services.NewRnibDataService(log, config, readerMock, writerMock)
313 rmrSender := getRmrSender(rmrMessengerMock, log)
314 e2tInstancesManager := &mocks.E2TInstancesManagerMock{}
315 httpClientMock := &mocks.HttpClientMock{}
316 rmClient := clients.NewRoutingManagerClient(log, config, httpClientMock)
317 ranListManager := &mocks.RanListManagerMock{}
318 ranAlarmService := &mocks.RanAlarmServiceMock{}
319 ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(log, rnibDataService, ranListManager, ranAlarmService)
320 nodebValidator := managers.NewNodebValidator()
321 updateEnbManager := managers.NewUpdateEnbManager(log, rnibDataService, nodebValidator)
323 handlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(log, rmrSender, config, rnibDataService, e2tInstancesManager, rmClient, ranConnectStatusChangeManager, nodebValidator, updateEnbManager)
324 controller := NewNodebController(log, handlerProvider)
325 return controller, readerMock, writerMock, rmrMessengerMock, e2tInstancesManager
328 func TestShutdownHandlerRnibError(t *testing.T) {
329 controller, _, _, _, e2tInstancesManagerMock := setupControllerTest(t)
330 e2tInstancesManagerMock.On("GetE2TAddresses").Return([]string{}, e2managererrors.NewRnibDbError())
332 writer := httptest.NewRecorder()
334 controller.Shutdown(writer, tests.GetHttpRequest())
336 var errorResponse = parseJsonRequest(t, writer.Body)
338 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
339 assert.Equal(t, errorResponse.Code, e2managererrors.NewRnibDbError().Code)
342 func TestSetGeneralConfigurationHandlerRnibError(t *testing.T) {
343 controller, readerMock, _, _, _ := setupControllerTest(t)
345 configuration := &entities.GeneralConfiguration{}
346 readerMock.On("GetGeneralConfiguration").Return(configuration, e2managererrors.NewRnibDbError())
348 writer := httptest.NewRecorder()
350 httpRequest, _ := http.NewRequest("PUT", "https://localhost:3800/v1/nodeb/parameters", strings.NewReader("{\"enableRic\":false}"))
352 controller.SetGeneralConfiguration(writer, httpRequest)
354 var errorResponse = parseJsonRequest(t, writer.Body)
356 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
357 assert.Equal(t, e2managererrors.NewRnibDbError().Code, errorResponse.Code)
360 func TestSetGeneralConfigurationInvalidJson(t *testing.T) {
361 controller, _, _, _, _ := setupControllerTest(t)
363 writer := httptest.NewRecorder()
365 httpRequest, _ := http.NewRequest("PUT", "https://localhost:3800/v1/nodeb/parameters", strings.NewReader("{\"enableRic\":false, \"someValue\":false}"))
367 controller.SetGeneralConfiguration(writer, httpRequest)
369 var errorResponse = parseJsonRequest(t, writer.Body)
371 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
372 assert.Equal(t, e2managererrors.NewInvalidJsonError().Code, errorResponse.Code)
375 func controllerGetNodebTestExecuter(t *testing.T, context *controllerGetNodebTestContext) {
376 controller, readerMock, _, _, _ := setupControllerTest(t)
377 writer := httptest.NewRecorder()
378 readerMock.On("GetNodeb", context.ranName).Return(context.nodebInfo, context.rnibError)
379 req, _ := http.NewRequest(http.MethodGet, "/nodeb", nil)
380 req = mux.SetURLVars(req, map[string]string{"ranName": context.ranName})
381 controller.GetNodeb(writer, req)
382 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
383 bodyBytes, _ := ioutil.ReadAll(writer.Body)
384 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
387 func controllerGetNodebIdListTestExecuter(t *testing.T, context *controllerGetNodebIdListTestContext) {
388 controller, readerMock, _, _, _ := setupControllerTest(t)
389 writer := httptest.NewRecorder()
390 readerMock.On("GetListNodebIds").Return(context.nodebIdList, context.rnibError)
391 req, _ := http.NewRequest(http.MethodGet, "/nodeb/ids", nil)
392 controller.GetNodebIdList(writer, req)
393 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
394 bodyBytes, _ := ioutil.ReadAll(writer.Body)
395 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
398 func activateControllerUpdateEnbMocks(context *controllerUpdateEnbTestContext, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock,updateEnbRequest *models.UpdateEnbRequest) {
399 if context.getNodebInfoResult != nil {
400 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
403 if context.removeServedCellsParams != nil {
404 writerMock.On("RemoveServedCells", RanName, context.removeServedCellsParams.servedCellInfo).Return(context.removeServedCellsParams.err)
407 if context.updateEnbCellsParams != nil {
408 updatedNodebInfo := *context.getNodebInfoResult.nodebInfo
409 updatedNodebInfo.Configuration = &entities.NodebInfo_Enb{Enb: updateEnbRequest.Enb}
411 writerMock.On("UpdateEnb", &updatedNodebInfo, updateEnbRequest.Enb.ServedCells).Return(context.updateEnbCellsParams.err)
415 func activateControllerUpdateGnbMocks(context *controllerUpdateGnbTestContext, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
416 if context.getNodebInfoResult != nil {
417 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
420 if context.removeServedNrCellsParams != nil {
421 writerMock.On("RemoveServedNrCells", RanName, context.removeServedNrCellsParams.servedNrCells).Return(context.removeServedNrCellsParams.err)
424 if context.updateGnbCellsParams != nil {
425 updatedNodebInfo := *context.getNodebInfoResult.nodebInfo
426 gnb := entities.Gnb{}
427 _ = jsonpb.Unmarshal(getJsonRequestAsBuffer(context.requestBody), &gnb)
428 updatedGnb := *updatedNodebInfo.GetGnb()
429 updatedGnb.ServedNrCells = gnb.ServedNrCells
430 writerMock.On("UpdateGnbCells", &updatedNodebInfo, gnb.ServedNrCells).Return(context.updateGnbCellsParams.err)
434 func assertControllerUpdateGnb(t *testing.T, context *controllerUpdateGnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
435 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
436 bodyBytes, _ := ioutil.ReadAll(writer.Body)
437 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
438 readerMock.AssertExpectations(t)
439 writerMock.AssertExpectations(t)
442 func assertControllerUpdateEnb(t *testing.T, context *controllerUpdateEnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
443 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
444 bodyBytes, _ := ioutil.ReadAll(writer.Body)
445 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
446 readerMock.AssertExpectations(t)
447 writerMock.AssertExpectations(t)
450 func assertControllerAddEnb(t *testing.T, context *controllerAddEnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
451 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
452 bodyBytes, _ := ioutil.ReadAll(writer.Body)
453 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
454 readerMock.AssertExpectations(t)
455 writerMock.AssertExpectations(t)
458 func assertControllerDeleteEnb(t *testing.T, context *controllerDeleteEnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
459 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
460 bodyBytes, _ := ioutil.ReadAll(writer.Body)
461 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
462 readerMock.AssertExpectations(t)
463 writerMock.AssertExpectations(t)
466 func buildUpdateEnbRequest(context *controllerUpdateEnbTestContext) *http.Request {
467 updateEnbUrl := fmt.Sprintf("/nodeb/enb/%s", RanName)
468 requestBody := getJsonRequestAsBuffer(context.requestBody)
469 req, _ := http.NewRequest(http.MethodPut, updateEnbUrl, requestBody)
470 req.Header.Set("Content-Type", "application/json")
471 req = mux.SetURLVars(req, map[string]string{"ranName": RanName})
475 func buildUpdateGnbRequest(context *controllerUpdateGnbTestContext) *http.Request {
476 updateGnbUrl := fmt.Sprintf("/nodeb/%s/update", RanName)
477 requestBody := getJsonRequestAsBuffer(context.requestBody)
478 req, _ := http.NewRequest(http.MethodPut, updateGnbUrl, requestBody)
479 req.Header.Set("Content-Type", "application/json")
480 req = mux.SetURLVars(req, map[string]string{"ranName": RanName})
484 func buildAddEnbRequest(context *controllerAddEnbTestContext) *http.Request {
485 requestBody := getJsonRequestAsBuffer(context.requestBody)
486 req, _ := http.NewRequest(http.MethodPost, AddEnbUrl, requestBody)
487 req.Header.Set("Content-Type", "application/json")
491 func controllerUpdateEnbTestExecuter(t *testing.T, context *controllerUpdateEnbTestContext) {
492 controller, readerMock, writerMock, _, _ := setupControllerTest(t)
493 writer := httptest.NewRecorder()
495 r := buildUpdateEnbRequest(context)
496 body, _ := ioutil.ReadAll(io.LimitReader(r.Body, LimitRequest))
498 updateEnbRequest := models.UpdateEnbRequest{}
499 _ = json.Unmarshal(body, &updateEnbRequest)
501 activateControllerUpdateEnbMocks(context, readerMock, writerMock, &updateEnbRequest)
502 r = buildUpdateEnbRequest(context)
505 controller.UpdateEnb(writer, r)
507 assertControllerUpdateEnb(t, context, writer, readerMock, writerMock)
510 func controllerUpdateGnbTestExecuter(t *testing.T, context *controllerUpdateGnbTestContext) {
511 controller, readerMock, writerMock, _, _ := setupControllerTest(t)
512 writer := httptest.NewRecorder()
514 activateControllerUpdateGnbMocks(context, readerMock, writerMock)
515 req := buildUpdateGnbRequest(context)
516 controller.UpdateGnb(writer, req)
517 assertControllerUpdateGnb(t, context, writer, readerMock, writerMock)
520 func activateControllerAddEnbMocks(context *controllerAddEnbTestContext, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock, addEnbRequest *models.AddEnbRequest) {
521 if context.getNodebInfoResult != nil {
522 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
525 if context.saveNodebParams != nil {
526 nodebInfo := entities.NodebInfo{
527 RanName: addEnbRequest.RanName,
528 Ip: addEnbRequest.Ip,
529 Port: addEnbRequest.Port,
530 NodeType: entities.Node_ENB,
531 GlobalNbId: addEnbRequest.GlobalNbId,
532 Configuration: &entities.NodebInfo_Enb{Enb: addEnbRequest.Enb},
533 ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,
536 //nbIdentity := entities.NbIdentity{InventoryName: addEnbRequest.RanName, GlobalNbId: addEnbRequest.GlobalNbId}
537 writerMock.On("SaveNodeb", &nodebInfo).Return(context.saveNodebParams.err)
538 // TODO: add writerMock.On("AddNbIdentity")
542 func controllerAddEnbTestExecuter(t *testing.T, context *controllerAddEnbTestContext) {
543 controller, readerMock, writerMock, _, _ := setupControllerTest(t)
544 writer := httptest.NewRecorder()
545 r := buildAddEnbRequest(context)
546 body, _ := ioutil.ReadAll(io.LimitReader(r.Body, LimitRequest))
548 addEnbRequest := models.AddEnbRequest{}
550 _ = json.Unmarshal(body, &addEnbRequest)
551 activateControllerAddEnbMocks(context, readerMock, writerMock, &addEnbRequest)
552 r = buildAddEnbRequest(context)
554 controller.AddEnb(writer, r)
555 assertControllerAddEnb(t, context, writer, readerMock, writerMock)
558 func controllerDeleteEnbTestExecuter(t *testing.T, context *controllerDeleteEnbTestContext) {
559 controller, readerMock, writerMock, _, _ := setupControllerTest(t)
560 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
561 if context.getNodebInfoResult.rnibError == nil && context.getNodebInfoResult.nodebInfo.GetNodeType() == entities.Node_ENB {
562 writerMock.On("RemoveEnb", context.getNodebInfoResult.nodebInfo).Return(nil)
564 writer := httptest.NewRecorder()
565 r, _ := http.NewRequest(http.MethodDelete, AddEnbUrl+"/"+RanName, nil)
566 r.Header.Set("Content-Type", "application/json")
567 r = mux.SetURLVars(r, map[string]string{"ranName": RanName})
568 controller.DeleteEnb(writer, r)
569 assertControllerDeleteEnb(t, context, writer, readerMock, writerMock)
572 func TestControllerUpdateGnbEmptyServedNrCells(t *testing.T) {
573 context := controllerUpdateGnbTestContext{
574 getNodebInfoResult: nil,
575 requestBody: map[string]interface{}{
576 "servedNrCells": []interface{}{
579 expectedStatusCode: http.StatusBadRequest,
580 expectedJsonResponse: ValidationFailureJson,
583 controllerUpdateGnbTestExecuter(t, &context)
586 func TestControllerUpdateGnbMissingServedNrCellInformation(t *testing.T) {
587 context := controllerUpdateGnbTestContext{
588 getNodebInfoResult: nil,
589 requestBody: map[string]interface{}{
590 "servedNrCells": []interface{}{
591 map[string]interface{}{
592 "servedNrCellInformation": nil,
596 expectedStatusCode: http.StatusBadRequest,
597 expectedJsonResponse: ValidationFailureJson,
600 controllerUpdateGnbTestExecuter(t, &context)
603 func TestControllerUpdateGnbMissingServedNrCellRequiredProp(t *testing.T) {
605 for _, v := range ServedNrCellInformationRequiredFields {
606 context := controllerUpdateGnbTestContext{
607 getNodebInfoResult: nil,
608 requestBody: map[string]interface{}{
609 "servedNrCells": []interface{}{
610 map[string]interface{}{
611 "servedNrCellInformation": buildServedNrCellInformation(v),
615 expectedStatusCode: http.StatusBadRequest,
616 expectedJsonResponse: ValidationFailureJson,
619 controllerUpdateGnbTestExecuter(t, &context)
623 func TestControllerUpdateGnbMissingServedNrCellFddOrTdd(t *testing.T) {
625 servedNrCellInformation := buildServedNrCellInformation("")
626 servedNrCellInformation["choiceNrMode"] = map[string]interface{}{}
628 context := controllerUpdateGnbTestContext{
629 getNodebInfoResult: nil,
630 requestBody: map[string]interface{}{
631 "servedNrCells": []interface{}{
632 map[string]interface{}{
633 "servedNrCellInformation": servedNrCellInformation,
637 expectedStatusCode: http.StatusBadRequest,
638 expectedJsonResponse: ValidationFailureJson,
641 controllerUpdateGnbTestExecuter(t, &context)
644 func TestControllerUpdateGnbMissingNeighbourInfoFddOrTdd(t *testing.T) {
646 nrNeighbourInfo := buildNrNeighbourInformation("")
647 nrNeighbourInfo["choiceNrMode"] = map[string]interface{}{}
649 context := controllerUpdateGnbTestContext{
650 getNodebInfoResult: nil,
651 requestBody: map[string]interface{}{
652 "servedNrCells": []interface{}{
653 map[string]interface{}{
654 "servedNrCellInformation": buildServedNrCellInformation(""),
655 "nrNeighbourInfos": []interface{}{
661 expectedStatusCode: http.StatusBadRequest,
662 expectedJsonResponse: ValidationFailureJson,
665 controllerUpdateGnbTestExecuter(t, &context)
668 func TestControllerUpdateGnbMissingNrNeighbourInformationRequiredProp(t *testing.T) {
670 for _, v := range NrNeighbourInformationRequiredFields {
671 context := controllerUpdateGnbTestContext{
672 getNodebInfoResult: nil,
673 requestBody: map[string]interface{}{
674 "servedNrCells": []interface{}{
675 map[string]interface{}{
676 "servedNrCellInformation": buildServedNrCellInformation(""),
677 "nrNeighbourInfos": []interface{}{
678 buildNrNeighbourInformation(v),
683 expectedStatusCode: http.StatusBadRequest,
684 expectedJsonResponse: ValidationFailureJson,
687 controllerUpdateGnbTestExecuter(t, &context)
691 func TestControllerUpdateGnbValidServedNrCellInformationGetNodebNotFound(t *testing.T) {
692 context := controllerUpdateGnbTestContext{
693 getNodebInfoResult: &getNodebInfoResult{
695 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
697 requestBody: map[string]interface{}{
698 "servedNrCells": []interface{}{
699 map[string]interface{}{
700 "servedNrCellInformation": buildServedNrCellInformation(""),
704 expectedStatusCode: http.StatusNotFound,
705 expectedJsonResponse: ResourceNotFoundJson,
708 controllerUpdateGnbTestExecuter(t, &context)
711 func TestControllerUpdateGnbValidServedNrCellInformationGetNodebInternalError(t *testing.T) {
712 context := controllerUpdateGnbTestContext{
713 getNodebInfoResult: &getNodebInfoResult{
715 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
717 requestBody: map[string]interface{}{
718 "servedNrCells": []interface{}{
719 map[string]interface{}{
720 "servedNrCellInformation": buildServedNrCellInformation(""),
724 expectedStatusCode: http.StatusInternalServerError,
725 expectedJsonResponse: RnibErrorJson,
728 controllerUpdateGnbTestExecuter(t, &context)
731 func TestControllerUpdateGnbGetNodebSuccessInvalidGnbConfiguration(t *testing.T) {
732 context := controllerUpdateGnbTestContext{
733 getNodebInfoResult: &getNodebInfoResult{
734 nodebInfo: &entities.NodebInfo{
736 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
737 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
741 requestBody: map[string]interface{}{
742 "servedNrCells": []interface{}{
743 map[string]interface{}{
744 "servedNrCellInformation": buildServedNrCellInformation(""),
745 "nrNeighbourInfos": []interface{}{
746 buildNrNeighbourInformation(""),
751 expectedStatusCode: http.StatusInternalServerError,
752 expectedJsonResponse: InternalErrorJson,
755 controllerUpdateGnbTestExecuter(t, &context)
758 func TestControllerUpdateGnbGetNodebSuccessRemoveServedNrCellsFailure(t *testing.T) {
759 oldServedNrCells := generateServedNrCells("whatever1", "whatever2")
760 context := controllerUpdateGnbTestContext{
761 removeServedNrCellsParams: &removeServedNrCellsParams{
762 err: common.NewInternalError(errors.New("#writer.UpdateGnbCells - Internal Error")),
763 servedNrCells: oldServedNrCells,
765 getNodebInfoResult: &getNodebInfoResult{
766 nodebInfo: &entities.NodebInfo{
768 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
769 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
770 Configuration: &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{ServedNrCells: oldServedNrCells}},
774 requestBody: map[string]interface{}{
775 "servedNrCells": []interface{}{
776 map[string]interface{}{
777 "servedNrCellInformation": buildServedNrCellInformation(""),
778 "nrNeighbourInfos": []interface{}{
779 buildNrNeighbourInformation(""),
784 expectedStatusCode: http.StatusInternalServerError,
785 expectedJsonResponse: RnibErrorJson,
788 controllerUpdateGnbTestExecuter(t, &context)
791 func TestControllerUpdateGnbGetNodebSuccessUpdateGnbCellsFailure(t *testing.T) {
792 oldServedNrCells := generateServedNrCells("whatever1", "whatever2")
793 context := controllerUpdateGnbTestContext{
794 removeServedNrCellsParams: &removeServedNrCellsParams{
796 servedNrCells: oldServedNrCells,
798 updateGnbCellsParams: &updateGnbCellsParams{
799 err: common.NewInternalError(errors.New("#writer.UpdateGnbCells - Internal Error")),
801 getNodebInfoResult: &getNodebInfoResult{
802 nodebInfo: &entities.NodebInfo{
804 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
805 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
806 Configuration: &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{ServedNrCells: oldServedNrCells}},
810 requestBody: map[string]interface{}{
811 "servedNrCells": []interface{}{
812 map[string]interface{}{
813 "servedNrCellInformation": buildServedNrCellInformation(""),
814 "nrNeighbourInfos": []interface{}{
815 buildNrNeighbourInformation(""),
820 expectedStatusCode: http.StatusInternalServerError,
821 expectedJsonResponse: RnibErrorJson,
824 controllerUpdateGnbTestExecuter(t, &context)
827 func TestControllerUpdateGnbSuccess(t *testing.T) {
828 context := controllerUpdateGnbTestContext{
829 updateGnbCellsParams: &updateGnbCellsParams{
832 getNodebInfoResult: &getNodebInfoResult{
833 nodebInfo: &entities.NodebInfo{
835 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
836 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
837 Configuration: &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{}},
841 requestBody: map[string]interface{}{
842 "servedNrCells": []interface{}{
843 map[string]interface{}{
844 "servedNrCellInformation": buildServedNrCellInformation(""),
845 "nrNeighbourInfos": []interface{}{
846 buildNrNeighbourInformation(""),
851 expectedStatusCode: http.StatusOK,
852 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\"}",
855 controllerUpdateGnbTestExecuter(t, &context)
858 func TestControllerUpdateEnbInvalidRequest(t *testing.T) {
859 controller, _, _, _, _ := setupControllerTest(t)
861 writer := httptest.NewRecorder()
862 invalidJson := strings.NewReader("{enb:\"whatever\"")
864 updateEnbUrl := fmt.Sprintf("/nodeb/enb/%s", RanName)
865 req, _ := http.NewRequest(http.MethodPut, updateEnbUrl, invalidJson)
866 req.Header.Set("Content-Type", "application/json")
867 req = mux.SetURLVars(req, map[string]string{"ranName": RanName})
869 controller.UpdateEnb(writer, req)
871 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
872 bodyBytes, _ := ioutil.ReadAll(writer.Body)
873 assert.Equal(t, CorruptedJson, string(bodyBytes))
876 func TestControllerUpdateEnbEmptyEnbType(t *testing.T) {
877 context := controllerUpdateEnbTestContext{
878 getNodebInfoResult: nil,
879 requestBody: getUpdateEnbRequest(EnbRequiredFields[0]),
880 expectedStatusCode: http.StatusBadRequest,
881 expectedJsonResponse: ValidationFailureJson,
884 controllerUpdateEnbTestExecuter(t, &context)
887 func TestControllerUpdateEnbEmptyServedCells(t *testing.T) {
888 context := controllerUpdateEnbTestContext{
889 getNodebInfoResult: nil,
890 requestBody: getUpdateEnbRequest(EnbRequiredFields[1]),
891 expectedStatusCode: http.StatusBadRequest,
892 expectedJsonResponse: ValidationFailureJson,
895 controllerUpdateEnbTestExecuter(t, &context)
898 func TestControllerUpdateEnbMissingEnb(t *testing.T) {
899 context := controllerUpdateEnbTestContext{
900 getNodebInfoResult: nil,
901 requestBody: getUpdateEnbRequest(UpdateEnbRequestRequiredFields[0]),
902 expectedStatusCode: http.StatusBadRequest,
903 expectedJsonResponse: ValidationFailureJson,
906 controllerUpdateEnbTestExecuter(t, &context)
909 func TestControllerUpdateEnbValidServedCellsGetNodebNotFound(t *testing.T) {
910 context := controllerUpdateEnbTestContext{
911 getNodebInfoResult: &getNodebInfoResult{
913 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
915 requestBody: getUpdateEnbRequest(""),
916 expectedStatusCode: http.StatusNotFound,
917 expectedJsonResponse: ResourceNotFoundJson,
920 controllerUpdateEnbTestExecuter(t, &context)
923 func TestControllerUpdateEnbValidServedCellsGetNodebInternalError(t *testing.T) {
924 context := controllerUpdateEnbTestContext{
925 getNodebInfoResult: &getNodebInfoResult{
927 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
929 requestBody: getUpdateEnbRequest(""),
930 expectedStatusCode: http.StatusInternalServerError,
931 expectedJsonResponse: RnibErrorJson,
934 controllerUpdateEnbTestExecuter(t, &context)
937 func TestControllerUpdateEnbGetNodebSuccessGnbTypeFailure(t *testing.T) {
938 oldServedCells := generateServedCells("whatever1", "whatever2")
939 context := controllerUpdateEnbTestContext{
940 getNodebInfoResult: &getNodebInfoResult{
941 nodebInfo: &entities.NodebInfo{
943 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
944 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
945 NodeType: entities.Node_GNB,
946 Configuration: &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells}},
950 requestBody: getUpdateEnbRequest(""),
951 expectedStatusCode: http.StatusBadRequest,
952 expectedJsonResponse: ValidationFailureJson,
955 controllerUpdateEnbTestExecuter(t, &context)
958 func TestControllerUpdateEnbGetNodebSuccessRemoveServedCellsFailure(t *testing.T) {
959 oldServedCells := generateServedCells("whatever1", "whatever2")
960 context := controllerUpdateEnbTestContext{
961 removeServedCellsParams: &removeServedCellsParams{
962 err: common.NewInternalError(errors.New("#writer.RemoveServedCells - Internal Error")),
963 servedCellInfo: oldServedCells,
965 getNodebInfoResult: &getNodebInfoResult{
966 nodebInfo: &entities.NodebInfo{
968 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
969 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
970 NodeType: entities.Node_ENB,
971 Configuration: &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells}},
975 requestBody: getUpdateEnbRequest(""),
976 expectedStatusCode: http.StatusInternalServerError,
977 expectedJsonResponse: RnibErrorJson,
980 controllerUpdateEnbTestExecuter(t, &context)
983 func TestControllerUpdateEnbGetNodebSuccessUpdateEnbFailure(t *testing.T) {
984 oldServedCells := generateServedCells("whatever1", "whatever2")
985 context := controllerUpdateEnbTestContext{
986 removeServedCellsParams: &removeServedCellsParams{
988 servedCellInfo: oldServedCells,
990 updateEnbCellsParams: &updateEnbCellsParams{
991 err: common.NewInternalError(errors.New("#writer.UpdateEnb - Internal Error")),
993 getNodebInfoResult: &getNodebInfoResult{
994 nodebInfo: &entities.NodebInfo{
996 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
997 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
998 NodeType: entities.Node_ENB,
999 Configuration: &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells, EnbType: entities.EnbType_MACRO_ENB}},
1003 requestBody: getUpdateEnbRequest(""),
1004 expectedStatusCode: http.StatusInternalServerError,
1005 expectedJsonResponse: RnibErrorJson,
1008 controllerUpdateEnbTestExecuter(t, &context)
1011 func TestControllerUpdateEnbSuccess(t *testing.T) {
1012 oldServedCells := generateServedCells("whatever1", "whatever2")
1013 context := controllerUpdateEnbTestContext{
1014 removeServedCellsParams: &removeServedCellsParams{
1016 servedCellInfo: oldServedCells,
1018 updateEnbCellsParams: &updateEnbCellsParams{
1021 getNodebInfoResult: &getNodebInfoResult{
1022 nodebInfo: &entities.NodebInfo{
1024 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
1025 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1026 NodeType: entities.Node_ENB,
1027 Configuration: &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells, EnbType: entities.EnbType_MACRO_ENB}},
1031 requestBody: getUpdateEnbRequest(""),
1032 expectedStatusCode: http.StatusOK,
1033 expectedJsonResponse: "{\"ranName\":\"test\",\"connectionStatus\":\"CONNECTED\",\"nodeType\":\"ENB\",\"enb\":{\"enbType\":\"MACRO_ENB\",\"servedCells\":[{\"pci\":1,\"cellId\":\"whatever\",\"tac\":\"whatever3\",\"broadcastPlmns\":[\"whatever\"],\"choiceEutraMode\":{\"fdd\":{}},\"eutraMode\":\"FDD\"}]},\"associatedE2tInstanceAddress\":\"10.0.2.15:38000\"}",
1036 controllerUpdateEnbTestExecuter(t, &context)
1039 func TestControllerAddEnbGetNodebInternalError(t *testing.T) {
1040 context := controllerAddEnbTestContext{
1041 getNodebInfoResult: &getNodebInfoResult{
1043 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
1045 requestBody: getAddEnbRequest(""),
1046 expectedStatusCode: http.StatusInternalServerError,
1047 expectedJsonResponse: RnibErrorJson,
1050 controllerAddEnbTestExecuter(t, &context)
1053 func TestControllerAddEnbNodebExistsFailure(t *testing.T) {
1054 context := controllerAddEnbTestContext{
1055 getNodebInfoResult: &getNodebInfoResult{
1056 nodebInfo: &entities.NodebInfo{},
1059 requestBody: getAddEnbRequest(""),
1060 expectedStatusCode: http.StatusBadRequest,
1061 expectedJsonResponse: NodebExistsJson,
1064 controllerAddEnbTestExecuter(t, &context)
1067 func TestControllerAddEnbSaveNodebFailure(t *testing.T) {
1068 context := controllerAddEnbTestContext{
1069 saveNodebParams: &saveNodebParams{
1070 err: common.NewInternalError(errors.New("#reader.SaveeNodeb - Internal Error")),
1072 getNodebInfoResult: &getNodebInfoResult{
1074 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1076 requestBody: getAddEnbRequest(""),
1077 expectedStatusCode: http.StatusInternalServerError,
1078 expectedJsonResponse: RnibErrorJson,
1081 controllerAddEnbTestExecuter(t, &context)
1084 func TestControllerAddEnbMissingRequiredRequestProps(t *testing.T) {
1086 for _, v := range AddEnbRequestRequiredFields {
1087 context := controllerAddEnbTestContext{
1088 requestBody: getAddEnbRequest(v),
1089 expectedStatusCode: http.StatusBadRequest,
1090 expectedJsonResponse: ValidationFailureJson,
1093 controllerAddEnbTestExecuter(t, &context)
1097 func TestControllerAddEnbInvalidRequest(t *testing.T) {
1098 controller, _, _, _, _ := setupControllerTest(t)
1099 writer := httptest.NewRecorder()
1101 // Invalid json: attribute name without quotes (should be "cause":).
1102 invalidJson := strings.NewReader("{ranName:\"whatever\"")
1103 req, _ := http.NewRequest(http.MethodPost, AddEnbUrl, invalidJson)
1105 controller.AddEnb(writer, req)
1106 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1107 bodyBytes, _ := ioutil.ReadAll(writer.Body)
1108 assert.Equal(t, CorruptedJson, string(bodyBytes))
1112 func TestControllerAddEnbMissingRequiredGlobalNbIdProps(t *testing.T) {
1114 r := getAddEnbRequest("")
1116 for _, v := range GlobalIdRequiredFields {
1117 r["globalNbId"] = buildGlobalNbId(v)
1119 context := controllerAddEnbTestContext{
1121 expectedStatusCode: http.StatusBadRequest,
1122 expectedJsonResponse: ValidationFailureJson,
1125 controllerAddEnbTestExecuter(t, &context)
1129 func TestControllerAddEnbMissingRequiredEnbProps(t *testing.T) {
1131 r := getAddEnbRequest("")
1133 for _, v := range EnbRequiredFields {
1134 r["enb"] = buildEnb(v)
1136 context := controllerAddEnbTestContext{
1138 expectedStatusCode: http.StatusBadRequest,
1139 expectedJsonResponse: ValidationFailureJson,
1142 controllerAddEnbTestExecuter(t, &context)
1146 func TestControllerUpdateEnbMissingRequiredServedCellProps(t *testing.T) {
1148 r := getUpdateEnbRequest("")
1150 for _, v := range ServedCellRequiredFields {
1153 enbMap, _ := enb.(map[string]interface{})
1155 enbMap["servedCells"] = []interface{}{
1159 context := controllerUpdateEnbTestContext{
1161 expectedStatusCode: http.StatusBadRequest,
1162 expectedJsonResponse: ValidationFailureJson,
1165 controllerUpdateEnbTestExecuter(t, &context)
1169 func TestControllerAddEnbMissingRequiredServedCellProps(t *testing.T) {
1171 r := getAddEnbRequest("")
1173 for _, v := range ServedCellRequiredFields {
1176 enbMap, _ := enb.(map[string]interface{})
1178 enbMap["servedCells"] = []interface{}{
1182 context := controllerAddEnbTestContext{
1184 expectedStatusCode: http.StatusBadRequest,
1185 expectedJsonResponse: ValidationFailureJson,
1188 controllerAddEnbTestExecuter(t, &context)
1192 func TestControllerAddEnbSuccess(t *testing.T) {
1193 context := controllerAddEnbTestContext{
1194 saveNodebParams: &saveNodebParams{
1197 getNodebInfoResult: &getNodebInfoResult{
1199 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1201 requestBody: map[string]interface{}{
1203 "globalNbId": map[string]interface{}{
1204 "plmnId": "whatever",
1205 "nbId": "whatever2",
1207 "enb": map[string]interface{}{
1209 "servedCells": []interface{}{
1210 buildServedCell(""),
1214 expectedStatusCode: http.StatusCreated,
1215 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\"}]}}",
1218 controllerAddEnbTestExecuter(t, &context)
1221 func TestControllerDeleteEnbGetNodebInternalError(t *testing.T) {
1222 context := controllerDeleteEnbTestContext{
1223 getNodebInfoResult: &getNodebInfoResult{
1225 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
1227 expectedStatusCode: http.StatusInternalServerError,
1228 expectedJsonResponse: RnibErrorJson,
1231 controllerDeleteEnbTestExecuter(t, &context)
1234 func TestControllerDeleteEnbNodebNotExistsFailure(t *testing.T) {
1235 context := controllerDeleteEnbTestContext{
1236 getNodebInfoResult: &getNodebInfoResult{
1238 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found"),
1240 expectedStatusCode: http.StatusNotFound,
1241 expectedJsonResponse: ResourceNotFoundJson,
1244 controllerDeleteEnbTestExecuter(t, &context)
1247 func TestControllerDeleteEnbNodebNotEnb(t *testing.T) {
1248 context := controllerDeleteEnbTestContext{
1249 getNodebInfoResult: &getNodebInfoResult{
1250 nodebInfo: &entities.NodebInfo{RanName: "ran1", NodeType: entities.Node_GNB, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED},
1253 expectedStatusCode: http.StatusBadRequest,
1254 expectedJsonResponse: ValidationFailureJson,
1257 controllerDeleteEnbTestExecuter(t, &context)
1260 func TestControllerDeleteEnbSuccess(t *testing.T) {
1261 context := controllerDeleteEnbTestContext{
1262 getNodebInfoResult: &getNodebInfoResult{
1263 nodebInfo: &entities.NodebInfo{RanName: "ran1", NodeType: entities.Node_ENB, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED},
1266 expectedStatusCode: http.StatusNoContent,
1267 expectedJsonResponse: "",
1269 controllerDeleteEnbTestExecuter(t, &context)
1272 func getJsonRequestAsBuffer(requestJson map[string]interface{}) *bytes.Buffer {
1273 b := new(bytes.Buffer)
1274 _ = json.NewEncoder(b).Encode(requestJson)
1278 func TestControllerGetNodebSuccess(t *testing.T) {
1281 context := controllerGetNodebTestContext{
1283 nodebInfo: &entities.NodebInfo{RanName: ranName, Ip: "10.0.2.15", Port: 1234},
1284 rnibError: rnibError,
1285 expectedStatusCode: http.StatusOK,
1286 expectedJsonResponse: fmt.Sprintf("{\"ranName\":\"%s\",\"ip\":\"10.0.2.15\",\"port\":1234}", ranName),
1289 controllerGetNodebTestExecuter(t, &context)
1292 func TestControllerGetNodebNotFound(t *testing.T) {
1295 var nodebInfo *entities.NodebInfo
1296 context := controllerGetNodebTestContext{
1298 nodebInfo: nodebInfo,
1299 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1300 expectedStatusCode: http.StatusNotFound,
1301 expectedJsonResponse: ResourceNotFoundJson,
1304 controllerGetNodebTestExecuter(t, &context)
1307 func TestControllerGetNodebInternal(t *testing.T) {
1309 var nodebInfo *entities.NodebInfo
1310 context := controllerGetNodebTestContext{
1312 nodebInfo: nodebInfo,
1313 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
1314 expectedStatusCode: http.StatusInternalServerError,
1315 expectedJsonResponse: RnibErrorJson,
1318 controllerGetNodebTestExecuter(t, &context)
1321 func TestControllerGetNodebIdListSuccess(t *testing.T) {
1323 nodebIdList := []*entities.NbIdentity{
1324 {InventoryName: "test1", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}},
1325 {InventoryName: "test2", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId2", NbId: "nbId2"}},
1328 context := controllerGetNodebIdListTestContext{
1329 nodebIdList: nodebIdList,
1330 rnibError: rnibError,
1331 expectedStatusCode: http.StatusOK,
1332 expectedJsonResponse: "[{\"inventoryName\":\"test1\",\"globalNbId\":{\"plmnId\":\"plmnId1\",\"nbId\":\"nbId1\"}},{\"inventoryName\":\"test2\",\"globalNbId\":{\"plmnId\":\"plmnId2\",\"nbId\":\"nbId2\"}}]",
1335 controllerGetNodebIdListTestExecuter(t, &context)
1338 func TestControllerGetNodebIdListEmptySuccess(t *testing.T) {
1340 var nodebIdList []*entities.NbIdentity
1342 context := controllerGetNodebIdListTestContext{
1343 nodebIdList: nodebIdList,
1344 rnibError: rnibError,
1345 expectedStatusCode: http.StatusOK,
1346 expectedJsonResponse: "[]",
1349 controllerGetNodebIdListTestExecuter(t, &context)
1352 func TestControllerGetNodebIdListInternal(t *testing.T) {
1353 var nodebIdList []*entities.NbIdentity
1354 context := controllerGetNodebIdListTestContext{
1355 nodebIdList: nodebIdList,
1356 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
1357 expectedStatusCode: http.StatusInternalServerError,
1358 expectedJsonResponse: RnibErrorJson,
1361 controllerGetNodebIdListTestExecuter(t, &context)
1364 func TestHeaderValidationFailed(t *testing.T) {
1365 controller, _, _, _, _ := setupControllerTest(t)
1367 writer := httptest.NewRecorder()
1369 header := &http.Header{}
1371 controller.handleRequest(writer, header, httpmsghandlerprovider.ShutdownRequest, nil, true, 0)
1373 var errorResponse = parseJsonRequest(t, writer.Body)
1374 err := e2managererrors.NewHeaderValidationError()
1376 assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
1377 assert.Equal(t, errorResponse.Code, err.Code)
1378 assert.Equal(t, errorResponse.Message, err.Message)
1381 func TestShutdownStatusNoContent(t *testing.T) {
1382 controller, readerMock, _, _, e2tInstancesManagerMock := setupControllerTest(t)
1383 e2tInstancesManagerMock.On("GetE2TAddresses").Return([]string{}, nil)
1384 readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{}, nil)
1386 writer := httptest.NewRecorder()
1387 controller.Shutdown(writer, tests.GetHttpRequest())
1389 assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
1392 func TestHandleInternalError(t *testing.T) {
1393 controller, _, _, _, _ := setupControllerTest(t)
1395 writer := httptest.NewRecorder()
1396 err := e2managererrors.NewInternalError()
1398 controller.handleErrorResponse(err, writer)
1399 var errorResponse = parseJsonRequest(t, writer.Body)
1401 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1402 assert.Equal(t, errorResponse.Code, err.Code)
1403 assert.Equal(t, errorResponse.Message, err.Message)
1406 func TestHandleCommandAlreadyInProgressError(t *testing.T) {
1407 controller, _, _, _, _ := setupControllerTest(t)
1408 writer := httptest.NewRecorder()
1409 err := e2managererrors.NewCommandAlreadyInProgressError()
1411 controller.handleErrorResponse(err, writer)
1412 var errorResponse = parseJsonRequest(t, writer.Body)
1414 assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
1415 assert.Equal(t, errorResponse.Code, err.Code)
1416 assert.Equal(t, errorResponse.Message, err.Message)
1419 func TestHandleRoutingManagerError(t *testing.T) {
1420 controller, _, _, _, _ := setupControllerTest(t)
1421 writer := httptest.NewRecorder()
1422 err := e2managererrors.NewRoutingManagerError()
1424 controller.handleErrorResponse(err, writer)
1425 var errorResponse = parseJsonRequest(t, writer.Body)
1427 assert.Equal(t, http.StatusServiceUnavailable, writer.Result().StatusCode)
1428 assert.Equal(t, errorResponse.Code, err.Code)
1429 assert.Equal(t, errorResponse.Message, err.Message)
1432 func TestHandleE2TInstanceAbsenceError(t *testing.T) {
1433 controller, _, _, _, _ := setupControllerTest(t)
1435 writer := httptest.NewRecorder()
1436 err := e2managererrors.NewE2TInstanceAbsenceError()
1438 controller.handleErrorResponse(err, writer)
1439 var errorResponse = parseJsonRequest(t, writer.Body)
1441 assert.Equal(t, http.StatusServiceUnavailable, writer.Result().StatusCode)
1442 assert.Equal(t, errorResponse.Code, err.Code)
1443 assert.Equal(t, errorResponse.Message, err.Message)
1446 func TestValidateHeaders(t *testing.T) {
1447 controller, _, _, _, _ := setupControllerTest(t)
1449 header := http.Header{}
1450 header.Set("Content-Type", "application/json")
1451 result := controller.validateRequestHeader(&header)
1453 assert.Nil(t, result)
1456 func parseJsonRequest(t *testing.T, r io.Reader) models.ErrorResponse {
1458 var errorResponse models.ErrorResponse
1459 body, err := ioutil.ReadAll(r)
1461 t.Errorf("Error cannot deserialize json request")
1463 _ = json.Unmarshal(body, &errorResponse)
1465 return errorResponse
1468 func initLog(t *testing.T) *logger.Logger {
1469 log, err := logger.InitLogger(logger.InfoLevel)
1471 t.Errorf("#delete_all_request_handler_test.TestHandleSuccessFlow - failed to initialize logger, error: %s", err)
1476 func TestX2ResetHandleSuccessfulRequestedCause(t *testing.T) {
1477 controller, readerMock, _, rmrMessengerMock, _ := setupControllerTest(t)
1480 payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x40}
1482 var msgSrc unsafe.Pointer
1483 msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction, msgSrc)
1484 rmrMessengerMock.On("SendMsg", msg, mock.Anything).Return(msg, nil)
1486 writer := httptest.NewRecorder()
1488 var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
1489 readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
1491 data4Req := map[string]interface{}{"cause": "protocol:transfer-syntax-error"}
1492 b := new(bytes.Buffer)
1493 _ = json.NewEncoder(b).Encode(data4Req)
1494 req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
1495 req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
1497 controller.X2Reset(writer, req)
1498 assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
1502 func TestX2ResetHandleSuccessfulRequestedDefault(t *testing.T) {
1503 controller, readerMock, _, rmrMessengerMock, _ := setupControllerTest(t)
1507 payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x64}
1509 var msgSrc unsafe.Pointer
1510 msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction, msgSrc)
1511 rmrMessengerMock.On("SendMsg", msg, true).Return(msg, nil)
1513 writer := httptest.NewRecorder()
1515 var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
1516 readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
1519 b := new(bytes.Buffer)
1520 data4Req := map[string]interface{}{}
1521 _ = json.NewEncoder(b).Encode(data4Req)
1522 req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
1523 req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
1525 controller.X2Reset(writer, req)
1526 assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
1529 func TestX2ResetHandleFailureInvalidBody(t *testing.T) {
1530 controller, _, _, _, _ := setupControllerTest(t)
1534 writer := httptest.NewRecorder()
1536 // Invalid json: attribute name without quotes (should be "cause":).
1537 b := strings.NewReader("{cause:\"protocol:transfer-syntax-error\"")
1538 req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
1539 req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
1541 controller.X2Reset(writer, req)
1542 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1546 func TestHandleErrorResponse(t *testing.T) {
1547 controller, _, _, _, _ := setupControllerTest(t)
1549 writer := httptest.NewRecorder()
1550 controller.handleErrorResponse(e2managererrors.NewRnibDbError(), writer)
1551 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1553 writer = httptest.NewRecorder()
1554 controller.handleErrorResponse(e2managererrors.NewCommandAlreadyInProgressError(), writer)
1555 assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
1557 writer = httptest.NewRecorder()
1558 controller.handleErrorResponse(e2managererrors.NewHeaderValidationError(), writer)
1559 assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
1561 writer = httptest.NewRecorder()
1562 controller.handleErrorResponse(e2managererrors.NewWrongStateError("", ""), writer)
1563 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1565 writer = httptest.NewRecorder()
1566 controller.handleErrorResponse(e2managererrors.NewRequestValidationError(), writer)
1567 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1569 writer = httptest.NewRecorder()
1570 controller.handleErrorResponse(e2managererrors.NewRmrError(), writer)
1571 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1573 writer = httptest.NewRecorder()
1574 controller.handleErrorResponse(e2managererrors.NewResourceNotFoundError(), writer)
1575 assert.Equal(t, http.StatusNotFound, writer.Result().StatusCode)
1577 writer = httptest.NewRecorder()
1578 controller.handleErrorResponse(fmt.Errorf("ErrorError"), writer)
1579 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1582 func getRmrSender(rmrMessengerMock *mocks.RmrMessengerMock, log *logger.Logger) *rmrsender.RmrSender {
1583 rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
1584 rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
1585 return rmrsender.NewRmrSender(log, rmrMessenger)