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 {
108 type addNbIdentityParams struct {
112 type removeServedCellsParams struct {
113 servedCellInfo []*entities.ServedCellInfo
117 type removeServedNrCellsParams struct {
118 servedNrCells []*entities.ServedNRCell
122 type controllerUpdateEnbTestContext struct {
123 getNodebInfoResult *getNodebInfoResult
124 removeServedCellsParams *removeServedCellsParams
125 updateEnbCellsParams *updateEnbCellsParams
126 requestBody map[string]interface{}
127 expectedStatusCode int
128 expectedJsonResponse string
131 type controllerUpdateGnbTestContext struct {
132 getNodebInfoResult *getNodebInfoResult
133 removeServedNrCellsParams *removeServedNrCellsParams
134 updateGnbCellsParams *updateGnbCellsParams
135 requestBody map[string]interface{}
136 expectedStatusCode int
137 expectedJsonResponse string
140 type controllerAddEnbTestContext struct {
141 getNodebInfoResult *getNodebInfoResult
142 saveNodebParams *saveNodebParams
143 addNbIdentityParams *addNbIdentityParams
144 requestBody map[string]interface{}
145 expectedStatusCode int
146 expectedJsonResponse string
149 type controllerDeleteEnbTestContext struct {
150 getNodebInfoResult *getNodebInfoResult
151 expectedStatusCode int
152 expectedJsonResponse string
155 func generateServedNrCells(cellIds ...string) []*entities.ServedNRCell {
157 servedNrCells := []*entities.ServedNRCell{}
159 for _, v := range cellIds {
160 servedNrCells = append(servedNrCells, &entities.ServedNRCell{ServedNrCellInformation: &entities.ServedNRCellInformation{
162 ChoiceNrMode: &entities.ServedNRCellInformation_ChoiceNRMode{
163 Fdd: &entities.ServedNRCellInformation_ChoiceNRMode_FddInfo{
167 NrMode: entities.Nr_FDD,
169 ServedPlmns: []string{"whatever"},
176 func generateServedCells(cellIds ...string) []*entities.ServedCellInfo {
178 var servedCells []*entities.ServedCellInfo
180 for i, v := range cellIds {
181 servedCells = append(servedCells, &entities.ServedCellInfo{
183 ChoiceEutraMode: &entities.ChoiceEUTRAMode{
184 Fdd: &entities.FddInfo{},
187 BroadcastPlmns: []string{"whatever"},
194 func buildNrNeighbourInformation(propToOmit string) map[string]interface{} {
195 ret := map[string]interface{}{
197 "choiceNrMode": map[string]interface{}{
198 "tdd": map[string]interface{}{},
204 if len(propToOmit) != 0 {
205 delete(ret, propToOmit)
211 func buildServedNrCellInformation(propToOmit string) map[string]interface{} {
212 ret := map[string]interface{}{
213 "cellId": "whatever",
214 "choiceNrMode": map[string]interface{}{
215 "fdd": map[string]interface{}{},
219 "servedPlmns": []interface{}{
224 if len(propToOmit) != 0 {
225 delete(ret, propToOmit)
231 func buildServedCell(propToOmit string) map[string]interface{} {
232 ret := map[string]interface{}{
233 "cellId": "whatever",
234 "choiceEutraMode": map[string]interface{}{
235 "fdd": map[string]interface{}{},
240 "broadcastPlmns": []interface{}{
245 if len(propToOmit) != 0 {
246 delete(ret, propToOmit)
252 func getUpdateEnbRequest(propToOmit string) map[string]interface{} {
253 ret := map[string]interface{}{
254 "enb": buildEnb(propToOmit),
257 if len(propToOmit) != 0 {
258 delete(ret, propToOmit)
264 func getAddEnbRequest(propToOmit string) map[string]interface{} {
265 ret := map[string]interface{}{
267 "globalNbId": buildGlobalNbId(""),
271 if len(propToOmit) != 0 {
272 delete(ret, propToOmit)
278 func buildEnb(propToOmit string) map[string]interface{} {
279 ret := map[string]interface{}{
281 "servedCells": []interface{}{
285 if len(propToOmit) != 0 {
286 delete(ret, propToOmit)
292 func buildGlobalNbId(propToOmit string) map[string]interface{} {
293 ret := map[string]interface{}{
294 "plmnId": "whatever",
298 if len(propToOmit) != 0 {
299 delete(ret, propToOmit)
305 func setupControllerTest(t *testing.T) (*NodebController, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.RmrMessengerMock, *mocks.E2TInstancesManagerMock, managers.RanListManager) {
307 config := configuration.ParseConfiguration()
309 rmrMessengerMock := &mocks.RmrMessengerMock{}
310 readerMock := &mocks.RnibReaderMock{}
312 writerMock := &mocks.RnibWriterMock{}
314 rnibDataService := services.NewRnibDataService(log, config, readerMock, writerMock)
315 rmrSender := getRmrSender(rmrMessengerMock, log)
316 e2tInstancesManager := &mocks.E2TInstancesManagerMock{}
317 httpClientMock := &mocks.HttpClientMock{}
318 rmClient := clients.NewRoutingManagerClient(log, config, httpClientMock)
319 ranListManager := managers.NewRanListManager(log, rnibDataService)
320 ranAlarmService := &mocks.RanAlarmServiceMock{}
321 ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(log, rnibDataService, ranListManager, ranAlarmService)
322 nodebValidator := managers.NewNodebValidator()
323 updateEnbManager := managers.NewUpdateEnbManager(log, rnibDataService, nodebValidator)
325 handlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(log, rmrSender, config, rnibDataService, e2tInstancesManager, rmClient, ranConnectStatusChangeManager, nodebValidator, updateEnbManager, ranListManager)
326 controller := NewNodebController(log, handlerProvider)
327 return controller, readerMock, writerMock, rmrMessengerMock, e2tInstancesManager, ranListManager
330 func TestShutdownHandlerRnibError(t *testing.T) {
331 controller, _, _, _, e2tInstancesManagerMock, _ := setupControllerTest(t)
332 e2tInstancesManagerMock.On("GetE2TAddresses").Return([]string{}, e2managererrors.NewRnibDbError())
334 writer := httptest.NewRecorder()
336 controller.Shutdown(writer, tests.GetHttpRequest())
338 var errorResponse = parseJsonRequest(t, writer.Body)
340 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
341 assert.Equal(t, errorResponse.Code, e2managererrors.NewRnibDbError().Code)
344 func TestSetGeneralConfigurationHandlerRnibError(t *testing.T) {
345 controller, readerMock, _, _, _ , _:= setupControllerTest(t)
347 configuration := &entities.GeneralConfiguration{}
348 readerMock.On("GetGeneralConfiguration").Return(configuration, e2managererrors.NewRnibDbError())
350 writer := httptest.NewRecorder()
352 httpRequest, _ := http.NewRequest("PUT", "https://localhost:3800/v1/nodeb/parameters", strings.NewReader("{\"enableRic\":false}"))
354 controller.SetGeneralConfiguration(writer, httpRequest)
356 var errorResponse = parseJsonRequest(t, writer.Body)
358 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
359 assert.Equal(t, e2managererrors.NewRnibDbError().Code, errorResponse.Code)
362 func TestSetGeneralConfigurationInvalidJson(t *testing.T) {
363 controller, _, _, _, _, _ := setupControllerTest(t)
365 writer := httptest.NewRecorder()
367 httpRequest, _ := http.NewRequest("PUT", "https://localhost:3800/v1/nodeb/parameters", strings.NewReader("{\"enableRic\":false, \"someValue\":false}"))
369 controller.SetGeneralConfiguration(writer, httpRequest)
371 var errorResponse = parseJsonRequest(t, writer.Body)
373 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
374 assert.Equal(t, e2managererrors.NewInvalidJsonError().Code, errorResponse.Code)
377 func controllerGetNodebTestExecuter(t *testing.T, context *controllerGetNodebTestContext) {
378 controller, readerMock, _, _, _, _ := setupControllerTest(t)
379 writer := httptest.NewRecorder()
380 readerMock.On("GetNodeb", context.ranName).Return(context.nodebInfo, context.rnibError)
381 req, _ := http.NewRequest(http.MethodGet, "/nodeb", nil)
382 req = mux.SetURLVars(req, map[string]string{"ranName": context.ranName})
383 controller.GetNodeb(writer, req)
384 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
385 bodyBytes, _ := ioutil.ReadAll(writer.Body)
386 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
389 func controllerGetNodebIdListTestExecuter(t *testing.T, context *controllerGetNodebIdListTestContext) {
390 controller, readerMock, _, _, _, ranListManager := setupControllerTest(t)
391 writer := httptest.NewRecorder()
392 readerMock.On("GetListNodebIds").Return(context.nodebIdList, context.rnibError)
394 err := ranListManager.InitNbIdentityMap()
396 t.Errorf("Error cannot init identity")
399 req, _ := http.NewRequest(http.MethodGet, "/nodeb/states", nil)
400 controller.GetNodebIdList(writer, req)
401 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
402 bodyBytes, _ := ioutil.ReadAll(writer.Body)
403 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
406 func activateControllerUpdateEnbMocks(context *controllerUpdateEnbTestContext, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock, updateEnbRequest *models.UpdateEnbRequest) {
407 if context.getNodebInfoResult != nil {
408 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
411 if context.removeServedCellsParams != nil {
412 writerMock.On("RemoveServedCells", RanName, context.removeServedCellsParams.servedCellInfo).Return(context.removeServedCellsParams.err)
415 if context.updateEnbCellsParams != nil {
416 updatedNodebInfo := *context.getNodebInfoResult.nodebInfo
417 updatedNodebInfo.Configuration = &entities.NodebInfo_Enb{Enb: updateEnbRequest.Enb}
419 writerMock.On("UpdateEnb", &updatedNodebInfo, updateEnbRequest.Enb.ServedCells).Return(context.updateEnbCellsParams.err)
423 func activateControllerUpdateGnbMocks(context *controllerUpdateGnbTestContext, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
424 if context.getNodebInfoResult != nil {
425 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
428 if context.removeServedNrCellsParams != nil {
429 writerMock.On("RemoveServedNrCells", RanName, context.removeServedNrCellsParams.servedNrCells).Return(context.removeServedNrCellsParams.err)
432 if context.updateGnbCellsParams != nil {
433 updatedNodebInfo := *context.getNodebInfoResult.nodebInfo
434 gnb := entities.Gnb{}
435 _ = jsonpb.Unmarshal(getJsonRequestAsBuffer(context.requestBody), &gnb)
436 updatedGnb := *updatedNodebInfo.GetGnb()
437 updatedGnb.ServedNrCells = gnb.ServedNrCells
438 writerMock.On("UpdateGnbCells", &updatedNodebInfo, gnb.ServedNrCells).Return(context.updateGnbCellsParams.err)
442 func assertControllerUpdateGnb(t *testing.T, context *controllerUpdateGnbTestContext, 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 assertControllerUpdateEnb(t *testing.T, context *controllerUpdateEnbTestContext, 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 assertControllerAddEnb(t *testing.T, context *controllerAddEnbTestContext, 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 assertControllerDeleteEnb(t *testing.T, context *controllerDeleteEnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
467 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
468 bodyBytes, _ := ioutil.ReadAll(writer.Body)
469 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
470 readerMock.AssertExpectations(t)
471 writerMock.AssertExpectations(t)
474 func buildUpdateEnbRequest(context *controllerUpdateEnbTestContext) *http.Request {
475 updateEnbUrl := fmt.Sprintf("/nodeb/enb/%s", RanName)
476 requestBody := getJsonRequestAsBuffer(context.requestBody)
477 req, _ := http.NewRequest(http.MethodPut, updateEnbUrl, requestBody)
478 req.Header.Set("Content-Type", "application/json")
479 req = mux.SetURLVars(req, map[string]string{"ranName": RanName})
483 func buildUpdateGnbRequest(context *controllerUpdateGnbTestContext) *http.Request {
484 updateGnbUrl := fmt.Sprintf("/nodeb/%s/update", RanName)
485 requestBody := getJsonRequestAsBuffer(context.requestBody)
486 req, _ := http.NewRequest(http.MethodPut, updateGnbUrl, requestBody)
487 req.Header.Set("Content-Type", "application/json")
488 req = mux.SetURLVars(req, map[string]string{"ranName": RanName})
492 func buildAddEnbRequest(context *controllerAddEnbTestContext) *http.Request {
493 requestBody := getJsonRequestAsBuffer(context.requestBody)
494 req, _ := http.NewRequest(http.MethodPost, AddEnbUrl, requestBody)
495 req.Header.Set("Content-Type", "application/json")
499 func controllerUpdateEnbTestExecuter(t *testing.T, context *controllerUpdateEnbTestContext) {
500 controller, readerMock, writerMock, _, _, _ := setupControllerTest(t)
501 writer := httptest.NewRecorder()
503 r := buildUpdateEnbRequest(context)
504 body, _ := ioutil.ReadAll(io.LimitReader(r.Body, LimitRequest))
506 updateEnbRequest := models.UpdateEnbRequest{}
507 _ = json.Unmarshal(body, &updateEnbRequest)
509 activateControllerUpdateEnbMocks(context, readerMock, writerMock, &updateEnbRequest)
510 r = buildUpdateEnbRequest(context)
513 controller.UpdateEnb(writer, r)
515 assertControllerUpdateEnb(t, context, writer, readerMock, writerMock)
518 func controllerUpdateGnbTestExecuter(t *testing.T, context *controllerUpdateGnbTestContext) {
519 controller, readerMock, writerMock, _, _, _ := setupControllerTest(t)
520 writer := httptest.NewRecorder()
522 activateControllerUpdateGnbMocks(context, readerMock, writerMock)
523 req := buildUpdateGnbRequest(context)
524 controller.UpdateGnb(writer, req)
525 assertControllerUpdateGnb(t, context, writer, readerMock, writerMock)
528 func activateControllerAddEnbMocks(context *controllerAddEnbTestContext, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock, addEnbRequest *models.AddEnbRequest) {
529 if context.getNodebInfoResult != nil {
530 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
533 if context.saveNodebParams != nil {
534 nodebInfo := entities.NodebInfo{
535 RanName: addEnbRequest.RanName,
536 Ip: addEnbRequest.Ip,
537 Port: addEnbRequest.Port,
538 NodeType: entities.Node_ENB,
539 GlobalNbId: addEnbRequest.GlobalNbId,
540 Configuration: &entities.NodebInfo_Enb{Enb: addEnbRequest.Enb},
541 ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,
544 writerMock.On("SaveNodeb", &nodebInfo).Return(context.saveNodebParams.err)
547 if context.addNbIdentityParams != nil {
548 nbIdentity := entities.NbIdentity{InventoryName: addEnbRequest.RanName, GlobalNbId: addEnbRequest.GlobalNbId, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED}
549 writerMock.On("AddNbIdentity", entities.Node_ENB, &nbIdentity).Return(context.addNbIdentityParams.err)
553 func controllerAddEnbTestExecuter(t *testing.T, context *controllerAddEnbTestContext) {
554 controller, readerMock, writerMock, _, _, _ := setupControllerTest(t)
555 writer := httptest.NewRecorder()
556 r := buildAddEnbRequest(context)
557 body, _ := ioutil.ReadAll(io.LimitReader(r.Body, LimitRequest))
559 addEnbRequest := models.AddEnbRequest{}
561 _ = json.Unmarshal(body, &addEnbRequest)
562 activateControllerAddEnbMocks(context, readerMock, writerMock, &addEnbRequest)
563 r = buildAddEnbRequest(context)
565 controller.AddEnb(writer, r)
566 assertControllerAddEnb(t, context, writer, readerMock, writerMock)
569 func controllerDeleteEnbTestExecuter(t *testing.T, context *controllerDeleteEnbTestContext) {
570 controller, readerMock, writerMock, _, _, _ := setupControllerTest(t)
571 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
572 if context.getNodebInfoResult.rnibError == nil && context.getNodebInfoResult.nodebInfo.GetNodeType() == entities.Node_ENB {
573 writerMock.On("RemoveEnb", context.getNodebInfoResult.nodebInfo).Return(nil)
575 writer := httptest.NewRecorder()
576 r, _ := http.NewRequest(http.MethodDelete, AddEnbUrl+"/"+RanName, nil)
577 r.Header.Set("Content-Type", "application/json")
578 r = mux.SetURLVars(r, map[string]string{"ranName": RanName})
579 controller.DeleteEnb(writer, r)
580 assertControllerDeleteEnb(t, context, writer, readerMock, writerMock)
583 func TestControllerUpdateGnbEmptyServedNrCells(t *testing.T) {
584 context := controllerUpdateGnbTestContext{
585 getNodebInfoResult: nil,
586 requestBody: map[string]interface{}{
587 "servedNrCells": []interface{}{
590 expectedStatusCode: http.StatusBadRequest,
591 expectedJsonResponse: ValidationFailureJson,
594 controllerUpdateGnbTestExecuter(t, &context)
597 func TestControllerUpdateGnbMissingServedNrCellInformation(t *testing.T) {
598 context := controllerUpdateGnbTestContext{
599 getNodebInfoResult: nil,
600 requestBody: map[string]interface{}{
601 "servedNrCells": []interface{}{
602 map[string]interface{}{
603 "servedNrCellInformation": nil,
607 expectedStatusCode: http.StatusBadRequest,
608 expectedJsonResponse: ValidationFailureJson,
611 controllerUpdateGnbTestExecuter(t, &context)
614 func TestControllerUpdateGnbMissingServedNrCellRequiredProp(t *testing.T) {
616 for _, v := range ServedNrCellInformationRequiredFields {
617 context := controllerUpdateGnbTestContext{
618 getNodebInfoResult: nil,
619 requestBody: map[string]interface{}{
620 "servedNrCells": []interface{}{
621 map[string]interface{}{
622 "servedNrCellInformation": buildServedNrCellInformation(v),
626 expectedStatusCode: http.StatusBadRequest,
627 expectedJsonResponse: ValidationFailureJson,
630 controllerUpdateGnbTestExecuter(t, &context)
634 func TestControllerUpdateGnbMissingServedNrCellFddOrTdd(t *testing.T) {
636 servedNrCellInformation := buildServedNrCellInformation("")
637 servedNrCellInformation["choiceNrMode"] = map[string]interface{}{}
639 context := controllerUpdateGnbTestContext{
640 getNodebInfoResult: nil,
641 requestBody: map[string]interface{}{
642 "servedNrCells": []interface{}{
643 map[string]interface{}{
644 "servedNrCellInformation": servedNrCellInformation,
648 expectedStatusCode: http.StatusBadRequest,
649 expectedJsonResponse: ValidationFailureJson,
652 controllerUpdateGnbTestExecuter(t, &context)
655 func TestControllerUpdateGnbMissingNeighbourInfoFddOrTdd(t *testing.T) {
657 nrNeighbourInfo := buildNrNeighbourInformation("")
658 nrNeighbourInfo["choiceNrMode"] = map[string]interface{}{}
660 context := controllerUpdateGnbTestContext{
661 getNodebInfoResult: nil,
662 requestBody: map[string]interface{}{
663 "servedNrCells": []interface{}{
664 map[string]interface{}{
665 "servedNrCellInformation": buildServedNrCellInformation(""),
666 "nrNeighbourInfos": []interface{}{
672 expectedStatusCode: http.StatusBadRequest,
673 expectedJsonResponse: ValidationFailureJson,
676 controllerUpdateGnbTestExecuter(t, &context)
679 func TestControllerUpdateGnbMissingNrNeighbourInformationRequiredProp(t *testing.T) {
681 for _, v := range NrNeighbourInformationRequiredFields {
682 context := controllerUpdateGnbTestContext{
683 getNodebInfoResult: nil,
684 requestBody: map[string]interface{}{
685 "servedNrCells": []interface{}{
686 map[string]interface{}{
687 "servedNrCellInformation": buildServedNrCellInformation(""),
688 "nrNeighbourInfos": []interface{}{
689 buildNrNeighbourInformation(v),
694 expectedStatusCode: http.StatusBadRequest,
695 expectedJsonResponse: ValidationFailureJson,
698 controllerUpdateGnbTestExecuter(t, &context)
702 func TestControllerUpdateGnbValidServedNrCellInformationGetNodebNotFound(t *testing.T) {
703 context := controllerUpdateGnbTestContext{
704 getNodebInfoResult: &getNodebInfoResult{
706 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
708 requestBody: map[string]interface{}{
709 "servedNrCells": []interface{}{
710 map[string]interface{}{
711 "servedNrCellInformation": buildServedNrCellInformation(""),
715 expectedStatusCode: http.StatusNotFound,
716 expectedJsonResponse: ResourceNotFoundJson,
719 controllerUpdateGnbTestExecuter(t, &context)
722 func TestControllerUpdateGnbValidServedNrCellInformationGetNodebInternalError(t *testing.T) {
723 context := controllerUpdateGnbTestContext{
724 getNodebInfoResult: &getNodebInfoResult{
726 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
728 requestBody: map[string]interface{}{
729 "servedNrCells": []interface{}{
730 map[string]interface{}{
731 "servedNrCellInformation": buildServedNrCellInformation(""),
735 expectedStatusCode: http.StatusInternalServerError,
736 expectedJsonResponse: RnibErrorJson,
739 controllerUpdateGnbTestExecuter(t, &context)
742 func TestControllerUpdateGnbGetNodebSuccessInvalidGnbConfiguration(t *testing.T) {
743 context := controllerUpdateGnbTestContext{
744 getNodebInfoResult: &getNodebInfoResult{
745 nodebInfo: &entities.NodebInfo{
747 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
748 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
752 requestBody: map[string]interface{}{
753 "servedNrCells": []interface{}{
754 map[string]interface{}{
755 "servedNrCellInformation": buildServedNrCellInformation(""),
756 "nrNeighbourInfos": []interface{}{
757 buildNrNeighbourInformation(""),
762 expectedStatusCode: http.StatusInternalServerError,
763 expectedJsonResponse: InternalErrorJson,
766 controllerUpdateGnbTestExecuter(t, &context)
769 func TestControllerUpdateGnbGetNodebSuccessRemoveServedNrCellsFailure(t *testing.T) {
770 oldServedNrCells := generateServedNrCells("whatever1", "whatever2")
771 context := controllerUpdateGnbTestContext{
772 removeServedNrCellsParams: &removeServedNrCellsParams{
773 err: common.NewInternalError(errors.New("#writer.UpdateGnbCells - Internal Error")),
774 servedNrCells: oldServedNrCells,
776 getNodebInfoResult: &getNodebInfoResult{
777 nodebInfo: &entities.NodebInfo{
779 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
780 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
781 Configuration: &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{ServedNrCells: oldServedNrCells}},
785 requestBody: map[string]interface{}{
786 "servedNrCells": []interface{}{
787 map[string]interface{}{
788 "servedNrCellInformation": buildServedNrCellInformation(""),
789 "nrNeighbourInfos": []interface{}{
790 buildNrNeighbourInformation(""),
795 expectedStatusCode: http.StatusInternalServerError,
796 expectedJsonResponse: RnibErrorJson,
799 controllerUpdateGnbTestExecuter(t, &context)
802 func TestControllerUpdateGnbGetNodebSuccessUpdateGnbCellsFailure(t *testing.T) {
803 oldServedNrCells := generateServedNrCells("whatever1", "whatever2")
804 context := controllerUpdateGnbTestContext{
805 removeServedNrCellsParams: &removeServedNrCellsParams{
807 servedNrCells: oldServedNrCells,
809 updateGnbCellsParams: &updateGnbCellsParams{
810 err: common.NewInternalError(errors.New("#writer.UpdateGnbCells - Internal Error")),
812 getNodebInfoResult: &getNodebInfoResult{
813 nodebInfo: &entities.NodebInfo{
815 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
816 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
817 Configuration: &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{ServedNrCells: oldServedNrCells}},
821 requestBody: map[string]interface{}{
822 "servedNrCells": []interface{}{
823 map[string]interface{}{
824 "servedNrCellInformation": buildServedNrCellInformation(""),
825 "nrNeighbourInfos": []interface{}{
826 buildNrNeighbourInformation(""),
831 expectedStatusCode: http.StatusInternalServerError,
832 expectedJsonResponse: RnibErrorJson,
835 controllerUpdateGnbTestExecuter(t, &context)
838 func TestControllerUpdateGnbSuccess(t *testing.T) {
839 context := controllerUpdateGnbTestContext{
840 updateGnbCellsParams: &updateGnbCellsParams{
843 getNodebInfoResult: &getNodebInfoResult{
844 nodebInfo: &entities.NodebInfo{
846 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
847 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
848 Configuration: &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{}},
852 requestBody: map[string]interface{}{
853 "servedNrCells": []interface{}{
854 map[string]interface{}{
855 "servedNrCellInformation": buildServedNrCellInformation(""),
856 "nrNeighbourInfos": []interface{}{
857 buildNrNeighbourInformation(""),
862 expectedStatusCode: http.StatusOK,
863 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\"}",
866 controllerUpdateGnbTestExecuter(t, &context)
869 func TestControllerUpdateEnbInvalidRequest(t *testing.T) {
870 controller, _, _, _, _, _ := setupControllerTest(t)
872 writer := httptest.NewRecorder()
873 invalidJson := strings.NewReader("{enb:\"whatever\"")
875 updateEnbUrl := fmt.Sprintf("/nodeb/enb/%s", RanName)
876 req, _ := http.NewRequest(http.MethodPut, updateEnbUrl, invalidJson)
877 req.Header.Set("Content-Type", "application/json")
878 req = mux.SetURLVars(req, map[string]string{"ranName": RanName})
880 controller.UpdateEnb(writer, req)
882 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
883 bodyBytes, _ := ioutil.ReadAll(writer.Body)
884 assert.Equal(t, CorruptedJson, string(bodyBytes))
887 func TestControllerUpdateEnbEmptyEnbType(t *testing.T) {
888 context := controllerUpdateEnbTestContext{
889 getNodebInfoResult: nil,
890 requestBody: getUpdateEnbRequest(EnbRequiredFields[0]),
891 expectedStatusCode: http.StatusBadRequest,
892 expectedJsonResponse: ValidationFailureJson,
895 controllerUpdateEnbTestExecuter(t, &context)
898 func TestControllerUpdateEnbEmptyServedCells(t *testing.T) {
899 context := controllerUpdateEnbTestContext{
900 getNodebInfoResult: nil,
901 requestBody: getUpdateEnbRequest(EnbRequiredFields[1]),
902 expectedStatusCode: http.StatusBadRequest,
903 expectedJsonResponse: ValidationFailureJson,
906 controllerUpdateEnbTestExecuter(t, &context)
909 func TestControllerUpdateEnbMissingEnb(t *testing.T) {
910 context := controllerUpdateEnbTestContext{
911 getNodebInfoResult: nil,
912 requestBody: getUpdateEnbRequest(UpdateEnbRequestRequiredFields[0]),
913 expectedStatusCode: http.StatusBadRequest,
914 expectedJsonResponse: ValidationFailureJson,
917 controllerUpdateEnbTestExecuter(t, &context)
920 func TestControllerUpdateEnbValidServedCellsGetNodebNotFound(t *testing.T) {
921 context := controllerUpdateEnbTestContext{
922 getNodebInfoResult: &getNodebInfoResult{
924 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
926 requestBody: getUpdateEnbRequest(""),
927 expectedStatusCode: http.StatusNotFound,
928 expectedJsonResponse: ResourceNotFoundJson,
931 controllerUpdateEnbTestExecuter(t, &context)
934 func TestControllerUpdateEnbValidServedCellsGetNodebInternalError(t *testing.T) {
935 context := controllerUpdateEnbTestContext{
936 getNodebInfoResult: &getNodebInfoResult{
938 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
940 requestBody: getUpdateEnbRequest(""),
941 expectedStatusCode: http.StatusInternalServerError,
942 expectedJsonResponse: RnibErrorJson,
945 controllerUpdateEnbTestExecuter(t, &context)
948 func TestControllerUpdateEnbGetNodebSuccessGnbTypeFailure(t *testing.T) {
949 oldServedCells := generateServedCells("whatever1", "whatever2")
950 context := controllerUpdateEnbTestContext{
951 getNodebInfoResult: &getNodebInfoResult{
952 nodebInfo: &entities.NodebInfo{
954 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
955 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
956 NodeType: entities.Node_GNB,
957 Configuration: &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells}},
961 requestBody: getUpdateEnbRequest(""),
962 expectedStatusCode: http.StatusBadRequest,
963 expectedJsonResponse: ValidationFailureJson,
966 controllerUpdateEnbTestExecuter(t, &context)
969 func TestControllerUpdateEnbGetNodebSuccessRemoveServedCellsFailure(t *testing.T) {
970 oldServedCells := generateServedCells("whatever1", "whatever2")
971 context := controllerUpdateEnbTestContext{
972 removeServedCellsParams: &removeServedCellsParams{
973 err: common.NewInternalError(errors.New("#writer.RemoveServedCells - Internal Error")),
974 servedCellInfo: oldServedCells,
976 getNodebInfoResult: &getNodebInfoResult{
977 nodebInfo: &entities.NodebInfo{
979 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
980 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
981 NodeType: entities.Node_ENB,
982 Configuration: &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells}},
986 requestBody: getUpdateEnbRequest(""),
987 expectedStatusCode: http.StatusInternalServerError,
988 expectedJsonResponse: RnibErrorJson,
991 controllerUpdateEnbTestExecuter(t, &context)
994 func TestControllerUpdateEnbGetNodebSuccessUpdateEnbFailure(t *testing.T) {
995 oldServedCells := generateServedCells("whatever1", "whatever2")
996 context := controllerUpdateEnbTestContext{
997 removeServedCellsParams: &removeServedCellsParams{
999 servedCellInfo: oldServedCells,
1001 updateEnbCellsParams: &updateEnbCellsParams{
1002 err: common.NewInternalError(errors.New("#writer.UpdateEnb - Internal Error")),
1004 getNodebInfoResult: &getNodebInfoResult{
1005 nodebInfo: &entities.NodebInfo{
1007 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
1008 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1009 NodeType: entities.Node_ENB,
1010 Configuration: &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells, EnbType: entities.EnbType_MACRO_ENB}},
1014 requestBody: getUpdateEnbRequest(""),
1015 expectedStatusCode: http.StatusInternalServerError,
1016 expectedJsonResponse: RnibErrorJson,
1019 controllerUpdateEnbTestExecuter(t, &context)
1022 func TestControllerUpdateEnbSuccess(t *testing.T) {
1023 oldServedCells := generateServedCells("whatever1", "whatever2")
1024 context := controllerUpdateEnbTestContext{
1025 removeServedCellsParams: &removeServedCellsParams{
1027 servedCellInfo: oldServedCells,
1029 updateEnbCellsParams: &updateEnbCellsParams{
1032 getNodebInfoResult: &getNodebInfoResult{
1033 nodebInfo: &entities.NodebInfo{
1035 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
1036 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1037 NodeType: entities.Node_ENB,
1038 Configuration: &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells, EnbType: entities.EnbType_MACRO_ENB}},
1042 requestBody: getUpdateEnbRequest(""),
1043 expectedStatusCode: http.StatusOK,
1044 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\"}",
1047 controllerUpdateEnbTestExecuter(t, &context)
1050 func TestControllerAddEnbGetNodebInternalError(t *testing.T) {
1051 context := controllerAddEnbTestContext{
1052 getNodebInfoResult: &getNodebInfoResult{
1054 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
1056 requestBody: getAddEnbRequest(""),
1057 expectedStatusCode: http.StatusInternalServerError,
1058 expectedJsonResponse: RnibErrorJson,
1061 controllerAddEnbTestExecuter(t, &context)
1064 func TestControllerAddEnbNodebExistsFailure(t *testing.T) {
1065 context := controllerAddEnbTestContext{
1066 getNodebInfoResult: &getNodebInfoResult{
1067 nodebInfo: &entities.NodebInfo{},
1070 requestBody: getAddEnbRequest(""),
1071 expectedStatusCode: http.StatusBadRequest,
1072 expectedJsonResponse: NodebExistsJson,
1075 controllerAddEnbTestExecuter(t, &context)
1078 func TestControllerAddEnbSaveNodebFailure(t *testing.T) {
1079 context := controllerAddEnbTestContext{
1080 saveNodebParams: &saveNodebParams{
1081 err: common.NewInternalError(errors.New("#reader.SaveeNodeb - Internal Error")),
1083 getNodebInfoResult: &getNodebInfoResult{
1085 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1087 requestBody: getAddEnbRequest(""),
1088 expectedStatusCode: http.StatusInternalServerError,
1089 expectedJsonResponse: RnibErrorJson,
1092 controllerAddEnbTestExecuter(t, &context)
1095 func TestControllerAddEnbAddNbIdentityFailure(t *testing.T) {
1096 context := controllerAddEnbTestContext{
1097 saveNodebParams: &saveNodebParams{
1100 addNbIdentityParams: &addNbIdentityParams{
1101 err: common.NewInternalError(errors.New("#writer.addNbIdentity - Internal Error")),
1103 getNodebInfoResult: &getNodebInfoResult{
1105 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1107 requestBody: getAddEnbRequest(""),
1108 expectedStatusCode: http.StatusInternalServerError,
1109 expectedJsonResponse: RnibErrorJson,
1112 controllerAddEnbTestExecuter(t, &context)
1115 func TestControllerAddEnbMissingRequiredRequestProps(t *testing.T) {
1117 for _, v := range AddEnbRequestRequiredFields {
1118 context := controllerAddEnbTestContext{
1119 requestBody: getAddEnbRequest(v),
1120 expectedStatusCode: http.StatusBadRequest,
1121 expectedJsonResponse: ValidationFailureJson,
1124 controllerAddEnbTestExecuter(t, &context)
1128 func TestControllerAddEnbInvalidRequest(t *testing.T) {
1129 controller, _, _, _, _, _ := setupControllerTest(t)
1130 writer := httptest.NewRecorder()
1132 // Invalid json: attribute name without quotes (should be "cause":).
1133 invalidJson := strings.NewReader("{ranName:\"whatever\"")
1134 req, _ := http.NewRequest(http.MethodPost, AddEnbUrl, invalidJson)
1136 controller.AddEnb(writer, req)
1137 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1138 bodyBytes, _ := ioutil.ReadAll(writer.Body)
1139 assert.Equal(t, CorruptedJson, string(bodyBytes))
1143 func TestControllerAddEnbMissingRequiredGlobalNbIdProps(t *testing.T) {
1145 r := getAddEnbRequest("")
1147 for _, v := range GlobalIdRequiredFields {
1148 r["globalNbId"] = buildGlobalNbId(v)
1150 context := controllerAddEnbTestContext{
1152 expectedStatusCode: http.StatusBadRequest,
1153 expectedJsonResponse: ValidationFailureJson,
1156 controllerAddEnbTestExecuter(t, &context)
1160 func TestControllerAddEnbMissingRequiredEnbProps(t *testing.T) {
1162 r := getAddEnbRequest("")
1164 for _, v := range EnbRequiredFields {
1165 r["enb"] = buildEnb(v)
1167 context := controllerAddEnbTestContext{
1169 expectedStatusCode: http.StatusBadRequest,
1170 expectedJsonResponse: ValidationFailureJson,
1173 controllerAddEnbTestExecuter(t, &context)
1177 func TestControllerUpdateEnbMissingRequiredServedCellProps(t *testing.T) {
1179 r := getUpdateEnbRequest("")
1181 for _, v := range ServedCellRequiredFields {
1184 enbMap, _ := enb.(map[string]interface{})
1186 enbMap["servedCells"] = []interface{}{
1190 context := controllerUpdateEnbTestContext{
1192 expectedStatusCode: http.StatusBadRequest,
1193 expectedJsonResponse: ValidationFailureJson,
1196 controllerUpdateEnbTestExecuter(t, &context)
1200 func TestControllerAddEnbMissingRequiredServedCellProps(t *testing.T) {
1202 r := getAddEnbRequest("")
1204 for _, v := range ServedCellRequiredFields {
1207 enbMap, _ := enb.(map[string]interface{})
1209 enbMap["servedCells"] = []interface{}{
1213 context := controllerAddEnbTestContext{
1215 expectedStatusCode: http.StatusBadRequest,
1216 expectedJsonResponse: ValidationFailureJson,
1219 controllerAddEnbTestExecuter(t, &context)
1223 func TestControllerAddEnbSuccess(t *testing.T) {
1224 context := controllerAddEnbTestContext{
1225 saveNodebParams: &saveNodebParams{
1228 addNbIdentityParams: &addNbIdentityParams{
1231 getNodebInfoResult: &getNodebInfoResult{
1233 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1235 requestBody: getAddEnbRequest(""),
1236 expectedStatusCode: http.StatusCreated,
1237 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\"}]}}",
1240 controllerAddEnbTestExecuter(t, &context)
1243 func TestControllerDeleteEnbGetNodebInternalError(t *testing.T) {
1244 context := controllerDeleteEnbTestContext{
1245 getNodebInfoResult: &getNodebInfoResult{
1247 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
1249 expectedStatusCode: http.StatusInternalServerError,
1250 expectedJsonResponse: RnibErrorJson,
1253 controllerDeleteEnbTestExecuter(t, &context)
1256 func TestControllerDeleteEnbNodebNotExistsFailure(t *testing.T) {
1257 context := controllerDeleteEnbTestContext{
1258 getNodebInfoResult: &getNodebInfoResult{
1260 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found"),
1262 expectedStatusCode: http.StatusNotFound,
1263 expectedJsonResponse: ResourceNotFoundJson,
1266 controllerDeleteEnbTestExecuter(t, &context)
1269 func TestControllerDeleteEnbNodebNotEnb(t *testing.T) {
1270 context := controllerDeleteEnbTestContext{
1271 getNodebInfoResult: &getNodebInfoResult{
1272 nodebInfo: &entities.NodebInfo{RanName: "ran1", NodeType: entities.Node_GNB, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED},
1275 expectedStatusCode: http.StatusBadRequest,
1276 expectedJsonResponse: ValidationFailureJson,
1279 controllerDeleteEnbTestExecuter(t, &context)
1282 func TestControllerDeleteEnbSuccess(t *testing.T) {
1283 context := controllerDeleteEnbTestContext{
1284 getNodebInfoResult: &getNodebInfoResult{
1285 nodebInfo: &entities.NodebInfo{RanName: "ran1", NodeType: entities.Node_ENB, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED},
1288 expectedStatusCode: http.StatusNoContent,
1289 expectedJsonResponse: "",
1291 controllerDeleteEnbTestExecuter(t, &context)
1294 func getJsonRequestAsBuffer(requestJson map[string]interface{}) *bytes.Buffer {
1295 b := new(bytes.Buffer)
1296 _ = json.NewEncoder(b).Encode(requestJson)
1300 func TestControllerGetNodebSuccess(t *testing.T) {
1303 context := controllerGetNodebTestContext{
1305 nodebInfo: &entities.NodebInfo{RanName: ranName, Ip: "10.0.2.15", Port: 1234},
1306 rnibError: rnibError,
1307 expectedStatusCode: http.StatusOK,
1308 expectedJsonResponse: fmt.Sprintf("{\"ranName\":\"%s\",\"ip\":\"10.0.2.15\",\"port\":1234}", ranName),
1311 controllerGetNodebTestExecuter(t, &context)
1314 func TestControllerGetNodebNotFound(t *testing.T) {
1317 var nodebInfo *entities.NodebInfo
1318 context := controllerGetNodebTestContext{
1320 nodebInfo: nodebInfo,
1321 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1322 expectedStatusCode: http.StatusNotFound,
1323 expectedJsonResponse: ResourceNotFoundJson,
1326 controllerGetNodebTestExecuter(t, &context)
1329 func TestControllerGetNodebInternal(t *testing.T) {
1331 var nodebInfo *entities.NodebInfo
1332 context := controllerGetNodebTestContext{
1334 nodebInfo: nodebInfo,
1335 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
1336 expectedStatusCode: http.StatusInternalServerError,
1337 expectedJsonResponse: RnibErrorJson,
1340 controllerGetNodebTestExecuter(t, &context)
1343 func TestControllerGetNodebIdListSuccess(t *testing.T) {
1345 nodebIdList := []*entities.NbIdentity{
1346 {InventoryName: "test1", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}},
1347 {InventoryName: "test2", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId2", NbId: "nbId2"}},
1350 context := controllerGetNodebIdListTestContext{
1351 nodebIdList: nodebIdList,
1352 rnibError: rnibError,
1353 expectedStatusCode: http.StatusOK,
1354 expectedJsonResponse: "[{\"inventoryName\":\"test1\",\"globalNbId\":{\"plmnId\":\"plmnId1\",\"nbId\":\"nbId1\"}},{\"inventoryName\":\"test2\",\"globalNbId\":{\"plmnId\":\"plmnId2\",\"nbId\":\"nbId2\"}}]",
1357 controllerGetNodebIdListTestExecuter(t, &context)
1360 func TestControllerGetNodebIdListEmptySuccess(t *testing.T) {
1362 var nodebIdList []*entities.NbIdentity
1364 context := controllerGetNodebIdListTestContext{
1365 nodebIdList: nodebIdList,
1366 rnibError: rnibError,
1367 expectedStatusCode: http.StatusOK,
1368 expectedJsonResponse: "[]",
1371 controllerGetNodebIdListTestExecuter(t, &context)
1374 func TestHeaderValidationFailed(t *testing.T) {
1375 controller, _, _, _, _, _ := setupControllerTest(t)
1377 writer := httptest.NewRecorder()
1379 header := &http.Header{}
1381 controller.handleRequest(writer, header, httpmsghandlerprovider.ShutdownRequest, nil, true, 0)
1383 var errorResponse = parseJsonRequest(t, writer.Body)
1384 err := e2managererrors.NewHeaderValidationError()
1386 assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
1387 assert.Equal(t, errorResponse.Code, err.Code)
1388 assert.Equal(t, errorResponse.Message, err.Message)
1391 func TestShutdownStatusNoContent(t *testing.T) {
1392 controller, readerMock, _, _, e2tInstancesManagerMock, _ := setupControllerTest(t)
1393 e2tInstancesManagerMock.On("GetE2TAddresses").Return([]string{}, nil)
1394 readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{}, nil)
1396 writer := httptest.NewRecorder()
1397 controller.Shutdown(writer, tests.GetHttpRequest())
1399 assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
1402 func TestHandleInternalError(t *testing.T) {
1403 controller, _, _, _, _, _ := setupControllerTest(t)
1405 writer := httptest.NewRecorder()
1406 err := e2managererrors.NewInternalError()
1408 controller.handleErrorResponse(err, writer)
1409 var errorResponse = parseJsonRequest(t, writer.Body)
1411 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1412 assert.Equal(t, errorResponse.Code, err.Code)
1413 assert.Equal(t, errorResponse.Message, err.Message)
1416 func TestHandleCommandAlreadyInProgressError(t *testing.T) {
1417 controller, _, _, _, _, _ := setupControllerTest(t)
1418 writer := httptest.NewRecorder()
1419 err := e2managererrors.NewCommandAlreadyInProgressError()
1421 controller.handleErrorResponse(err, writer)
1422 var errorResponse = parseJsonRequest(t, writer.Body)
1424 assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
1425 assert.Equal(t, errorResponse.Code, err.Code)
1426 assert.Equal(t, errorResponse.Message, err.Message)
1429 func TestHandleRoutingManagerError(t *testing.T) {
1430 controller, _, _, _, _, _ := setupControllerTest(t)
1431 writer := httptest.NewRecorder()
1432 err := e2managererrors.NewRoutingManagerError()
1434 controller.handleErrorResponse(err, writer)
1435 var errorResponse = parseJsonRequest(t, writer.Body)
1437 assert.Equal(t, http.StatusServiceUnavailable, writer.Result().StatusCode)
1438 assert.Equal(t, errorResponse.Code, err.Code)
1439 assert.Equal(t, errorResponse.Message, err.Message)
1442 func TestHandleE2TInstanceAbsenceError(t *testing.T) {
1443 controller, _, _, _, _, _ := setupControllerTest(t)
1445 writer := httptest.NewRecorder()
1446 err := e2managererrors.NewE2TInstanceAbsenceError()
1448 controller.handleErrorResponse(err, writer)
1449 var errorResponse = parseJsonRequest(t, writer.Body)
1451 assert.Equal(t, http.StatusServiceUnavailable, writer.Result().StatusCode)
1452 assert.Equal(t, errorResponse.Code, err.Code)
1453 assert.Equal(t, errorResponse.Message, err.Message)
1456 func TestValidateHeaders(t *testing.T) {
1457 controller, _, _, _, _, _ := setupControllerTest(t)
1459 header := http.Header{}
1460 header.Set("Content-Type", "application/json")
1461 result := controller.validateRequestHeader(&header)
1463 assert.Nil(t, result)
1466 func parseJsonRequest(t *testing.T, r io.Reader) models.ErrorResponse {
1468 var errorResponse models.ErrorResponse
1469 body, err := ioutil.ReadAll(r)
1471 t.Errorf("Error cannot deserialize json request")
1473 _ = json.Unmarshal(body, &errorResponse)
1475 return errorResponse
1478 func initLog(t *testing.T) *logger.Logger {
1479 log, err := logger.InitLogger(logger.InfoLevel)
1481 t.Errorf("#delete_all_request_handler_test.TestHandleSuccessFlow - failed to initialize logger, error: %s", err)
1486 func TestX2ResetHandleSuccessfulRequestedCause(t *testing.T) {
1487 controller, readerMock, _, rmrMessengerMock, _, _ := setupControllerTest(t)
1490 payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x40}
1492 var msgSrc unsafe.Pointer
1493 msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction, msgSrc)
1494 rmrMessengerMock.On("SendMsg", msg, mock.Anything).Return(msg, nil)
1496 writer := httptest.NewRecorder()
1498 var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
1499 readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
1501 data4Req := map[string]interface{}{"cause": "protocol:transfer-syntax-error"}
1502 b := new(bytes.Buffer)
1503 _ = json.NewEncoder(b).Encode(data4Req)
1504 req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
1505 req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
1507 controller.X2Reset(writer, req)
1508 assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
1512 func TestX2ResetHandleSuccessfulRequestedDefault(t *testing.T) {
1513 controller, readerMock, _, rmrMessengerMock, _, _ := setupControllerTest(t)
1517 payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x64}
1519 var msgSrc unsafe.Pointer
1520 msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction, msgSrc)
1521 rmrMessengerMock.On("SendMsg", msg, true).Return(msg, nil)
1523 writer := httptest.NewRecorder()
1525 var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
1526 readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
1529 b := new(bytes.Buffer)
1530 data4Req := map[string]interface{}{}
1531 _ = json.NewEncoder(b).Encode(data4Req)
1532 req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
1533 req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
1535 controller.X2Reset(writer, req)
1536 assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
1539 func TestX2ResetHandleFailureInvalidBody(t *testing.T) {
1540 controller, _, _, _, _, _ := setupControllerTest(t)
1544 writer := httptest.NewRecorder()
1546 // Invalid json: attribute name without quotes (should be "cause":).
1547 b := strings.NewReader("{cause:\"protocol:transfer-syntax-error\"")
1548 req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
1549 req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
1551 controller.X2Reset(writer, req)
1552 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1556 func TestHandleErrorResponse(t *testing.T) {
1557 controller, _, _, _, _, _ := setupControllerTest(t)
1559 writer := httptest.NewRecorder()
1560 controller.handleErrorResponse(e2managererrors.NewRnibDbError(), writer)
1561 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1563 writer = httptest.NewRecorder()
1564 controller.handleErrorResponse(e2managererrors.NewCommandAlreadyInProgressError(), writer)
1565 assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
1567 writer = httptest.NewRecorder()
1568 controller.handleErrorResponse(e2managererrors.NewHeaderValidationError(), writer)
1569 assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
1571 writer = httptest.NewRecorder()
1572 controller.handleErrorResponse(e2managererrors.NewWrongStateError("", ""), writer)
1573 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1575 writer = httptest.NewRecorder()
1576 controller.handleErrorResponse(e2managererrors.NewRequestValidationError(), writer)
1577 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1579 writer = httptest.NewRecorder()
1580 controller.handleErrorResponse(e2managererrors.NewRmrError(), writer)
1581 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1583 writer = httptest.NewRecorder()
1584 controller.handleErrorResponse(e2managererrors.NewResourceNotFoundError(), writer)
1585 assert.Equal(t, http.StatusNotFound, writer.Result().StatusCode)
1587 writer = httptest.NewRecorder()
1588 controller.handleErrorResponse(fmt.Errorf("ErrorError"), writer)
1589 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1592 func getRmrSender(rmrMessengerMock *mocks.RmrMessengerMock, log *logger.Logger) *rmrsender.RmrSender {
1593 rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
1594 rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
1595 return rmrsender.NewRmrSender(log, rmrMessenger)