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"
32 "e2mgr/providers/httpmsghandlerprovider"
35 "e2mgr/services/rmrsender"
39 "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
40 "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
41 "github.com/golang/protobuf/jsonpb"
42 "github.com/gorilla/mux"
43 "github.com/pkg/errors"
44 "github.com/stretchr/testify/assert"
45 "github.com/stretchr/testify/mock"
57 AssociatedE2TInstanceAddress = "10.0.2.15:38000"
58 ValidationFailureJson = "{\"errorCode\":402,\"errorMessage\":\"Validation error\"}"
59 ResourceNotFoundJson = "{\"errorCode\":404,\"errorMessage\":\"Resource not found\"}"
60 RnibErrorJson = "{\"errorCode\":500,\"errorMessage\":\"RNIB error\"}"
61 InternalErrorJson = "{\"errorCode\":501,\"errorMessage\":\"Internal Server Error. Please try again later\"}"
65 ServedNrCellInformationRequiredFields = []string{"cellId", "choiceNrMode", "nrMode", "nrPci", "servedPlmns"}
66 NrNeighbourInformationRequiredFields = []string{"nrCgi", "choiceNrMode", "nrMode", "nrPci"}
69 type controllerGetNodebTestContext struct {
71 nodebInfo *entities.NodebInfo
73 expectedStatusCode int
74 expectedJsonResponse string
77 type controllerGetNodebIdListTestContext struct {
78 nodebIdList []*entities.NbIdentity
80 expectedStatusCode int
81 expectedJsonResponse string
84 type getNodebInfoResult struct {
85 nodebInfo *entities.NodebInfo
89 type updateGnbCellsParams struct {
93 type controllerUpdateGnbTestContext struct {
94 getNodebInfoResult *getNodebInfoResult
95 updateGnbCellsParams *updateGnbCellsParams
96 requestBody map[string]interface{}
97 expectedStatusCode int
98 expectedJsonResponse string
101 func buildNrNeighbourInformation(propToOmit string) map[string]interface{} {
102 ret := map[string]interface{}{
104 "choiceNrMode": map[string]interface{}{
105 "tdd": map[string]interface{}{},
111 if len(propToOmit) != 0 {
112 delete(ret, propToOmit)
118 func buildServedNrCellInformation(propToOmit string) map[string]interface{} {
119 ret := map[string]interface{}{
120 "cellId": "whatever",
121 "choiceNrMode": map[string]interface{}{
122 "fdd": map[string]interface{}{},
126 "servedPlmns": []interface{}{
131 if len(propToOmit) != 0 {
132 delete(ret, propToOmit)
138 func setupControllerTest(t *testing.T) (*NodebController, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.RmrMessengerMock, *mocks.E2TInstancesManagerMock) {
140 config := configuration.ParseConfiguration()
142 rmrMessengerMock := &mocks.RmrMessengerMock{}
143 readerMock := &mocks.RnibReaderMock{}
145 writerMock := &mocks.RnibWriterMock{}
147 rnibDataService := services.NewRnibDataService(log, config, readerMock, writerMock)
148 rmrSender := getRmrSender(rmrMessengerMock, log)
149 ranSetupManager := managers.NewRanSetupManager(log, rmrSender, rnibDataService)
150 e2tInstancesManager := &mocks.E2TInstancesManagerMock{}
151 httpClientMock := &mocks.HttpClientMock{}
152 rmClient := clients.NewRoutingManagerClient(log, config, httpClientMock)
153 e2tAssociationManager := managers.NewE2TAssociationManager(log, rnibDataService, e2tInstancesManager, rmClient)
154 handlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(log, rmrSender, config, rnibDataService, ranSetupManager, e2tInstancesManager, e2tAssociationManager, rmClient)
155 controller := NewNodebController(log, handlerProvider)
156 return controller, readerMock, writerMock, rmrMessengerMock, e2tInstancesManager
159 func TestX2SetupInvalidBody(t *testing.T) {
161 controller, _, _, _, _ := setupControllerTest(t)
163 header := http.Header{}
164 header.Set("Content-Type", "application/json")
165 httpRequest, _ := http.NewRequest("POST", "http://localhost:3800/v1/nodeb/x2-setup", strings.NewReader("{}{}"))
166 httpRequest.Header = header
168 writer := httptest.NewRecorder()
169 controller.X2Setup(writer, httpRequest)
171 var errorResponse = parseJsonRequest(t, writer.Body)
173 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
174 assert.Equal(t, e2managererrors.NewInvalidJsonError().Code, errorResponse.Code)
177 func TestX2SetupSuccess(t *testing.T) {
179 controller, readerMock, writerMock, rmrMessengerMock, _ := setupControllerTest(t)
182 nb := &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST, AssociatedE2TInstanceAddress: "10.0.2.15:8989"}
183 readerMock.On("GetNodeb", ranName).Return(nb, nil)
185 nbUpdated.ConnectionAttempts = 0
186 writerMock.On("UpdateNodebInfo", &nbUpdated).Return(nil)
188 var nbUpdated2 = &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_CONNECTING, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST, ConnectionAttempts: 1, AssociatedE2TInstanceAddress: "10.0.2.15:8989"}
189 writerMock.On("UpdateNodebInfo", nbUpdated2).Return(nil)
191 payload := e2pdus.PackedX2setupRequest
193 var msgSrc unsafe.Pointer
194 msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), ranName, &payload, &xAction, msgSrc)
196 rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg, nil)
198 header := http.Header{}
199 header.Set("Content-Type", "application/json")
200 httpRequest := tests.GetHttpRequest()
201 httpRequest.Header = header
203 writer := httptest.NewRecorder()
204 controller.X2Setup(writer, httpRequest)
206 assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
209 func TestEndcSetupSuccess(t *testing.T) {
211 controller, readerMock, writerMock, rmrMessengerMock, _ := setupControllerTest(t)
214 nb := &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST, AssociatedE2TInstanceAddress: "10.0.2.15:8989"}
215 readerMock.On("GetNodeb", ranName).Return(nb, nil)
217 nbUpdated.ConnectionAttempts = 0
218 writerMock.On("UpdateNodebInfo", &nbUpdated).Return(nil)
220 var nbUpdated2 = &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_CONNECTING, E2ApplicationProtocol: entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST, ConnectionAttempts: 1, AssociatedE2TInstanceAddress: "10.0.2.15:8989"}
221 writerMock.On("UpdateNodebInfo", nbUpdated2).Return(nil)
223 payload := e2pdus.PackedEndcX2setupRequest
225 var msgSrc unsafe.Pointer
226 msg := rmrCgo.NewMBuf(rmrCgo.RIC_ENDC_X2_SETUP_REQ, len(payload), ranName, &payload, &xAction, msgSrc)
228 rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg, nil)
230 header := http.Header{}
231 header.Set("Content-Type", "application/json")
232 httpRequest := tests.GetHttpRequest()
233 httpRequest.Header = header
235 writer := httptest.NewRecorder()
236 controller.EndcSetup(writer, httpRequest)
238 assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
241 func TestShutdownHandlerRnibError(t *testing.T) {
242 controller, _, _, _, e2tInstancesManagerMock := setupControllerTest(t)
243 e2tInstancesManagerMock.On("GetE2TAddresses").Return([]string{}, e2managererrors.NewRnibDbError())
245 writer := httptest.NewRecorder()
247 controller.Shutdown(writer, tests.GetHttpRequest())
249 var errorResponse = parseJsonRequest(t, writer.Body)
251 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
252 assert.Equal(t, errorResponse.Code, e2managererrors.NewRnibDbError().Code)
255 func controllerGetNodebTestExecuter(t *testing.T, context *controllerGetNodebTestContext) {
256 controller, readerMock, _, _, _ := setupControllerTest(t)
257 writer := httptest.NewRecorder()
258 readerMock.On("GetNodeb", context.ranName).Return(context.nodebInfo, context.rnibError)
259 req, _ := http.NewRequest(http.MethodGet, "/nodeb", nil)
260 req = mux.SetURLVars(req, map[string]string{"ranName": context.ranName})
261 controller.GetNodeb(writer, req)
262 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
263 bodyBytes, _ := ioutil.ReadAll(writer.Body)
264 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
267 func controllerGetNodebIdListTestExecuter(t *testing.T, context *controllerGetNodebIdListTestContext) {
268 controller, readerMock, _, _, _ := setupControllerTest(t)
269 writer := httptest.NewRecorder()
270 readerMock.On("GetListNodebIds").Return(context.nodebIdList, context.rnibError)
271 req, _ := http.NewRequest(http.MethodGet, "/nodeb/ids", nil)
272 controller.GetNodebIdList(writer, req)
273 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
274 bodyBytes, _ := ioutil.ReadAll(writer.Body)
275 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
278 func activateControllerUpdateGnbMocks(context *controllerUpdateGnbTestContext, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
279 if context.getNodebInfoResult != nil {
280 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
283 if context.updateGnbCellsParams != nil {
284 updatedNodebInfo := *context.getNodebInfoResult.nodebInfo
285 gnb := entities.Gnb{}
286 _ = jsonpb.Unmarshal(getJsonRequestAsBuffer(context.requestBody), &gnb)
287 updatedNodebInfo.GetGnb().ServedNrCells = gnb.ServedNrCells
288 writerMock.On("UpdateGnbCells", &updatedNodebInfo, gnb.ServedNrCells).Return(context.updateGnbCellsParams.err)
292 func assertControllerUpdateGnb(t *testing.T, context *controllerUpdateGnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
293 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
294 bodyBytes, _ := ioutil.ReadAll(writer.Body)
295 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
296 readerMock.AssertExpectations(t)
297 writerMock.AssertExpectations(t)
299 if context.getNodebInfoResult != nil {
300 readerMock.AssertNotCalled(t, "GetNodeb")
303 if context.updateGnbCellsParams != nil {
304 writerMock.AssertNotCalled(t, "UpdateGnb")
308 func buildUpdateGnbRequest(context *controllerUpdateGnbTestContext) *http.Request {
309 updateGnbUrl := fmt.Sprintf("/nodeb/%s/update", RanName)
310 requestBody := getJsonRequestAsBuffer(context.requestBody)
311 req, _ := http.NewRequest(http.MethodGet, updateGnbUrl, requestBody)
312 req.Header.Set("Content-Type", "application/json")
313 req = mux.SetURLVars(req, map[string]string{"ranName": RanName})
317 func controllerUpdateGnbTestExecuter(t *testing.T, context *controllerUpdateGnbTestContext) {
318 controller, readerMock, writerMock, _, _ := setupControllerTest(t)
319 writer := httptest.NewRecorder()
321 activateControllerUpdateGnbMocks(context, readerMock, writerMock)
322 req := buildUpdateGnbRequest(context)
323 controller.UpdateGnb(writer, req)
324 assertControllerUpdateGnb(t, context, writer, readerMock, writerMock)
327 func TestControllerUpdateGnbEmptyServedNrCells(t *testing.T) {
328 context := controllerUpdateGnbTestContext{
329 getNodebInfoResult: nil,
330 requestBody: map[string]interface{}{
331 "servedNrCells": []interface{}{
334 expectedStatusCode: http.StatusBadRequest,
335 expectedJsonResponse: ValidationFailureJson,
338 controllerUpdateGnbTestExecuter(t, &context)
341 func TestControllerUpdateGnbMissingServedNrCellInformation(t *testing.T) {
342 context := controllerUpdateGnbTestContext{
343 getNodebInfoResult: nil,
344 requestBody: map[string]interface{}{
345 "servedNrCells": []interface{}{
346 map[string]interface{}{
347 "servedNrCellInformation": nil,
351 expectedStatusCode: http.StatusBadRequest,
352 expectedJsonResponse: ValidationFailureJson,
355 controllerUpdateGnbTestExecuter(t, &context)
358 func TestControllerUpdateGnbMissingServedNrCellRequiredProp(t *testing.T) {
360 for _, v := range ServedNrCellInformationRequiredFields {
361 context := controllerUpdateGnbTestContext{
362 getNodebInfoResult: nil,
363 requestBody: map[string]interface{}{
364 "servedNrCells": []interface{}{
365 map[string]interface{}{
366 "servedNrCellInformation": buildServedNrCellInformation(v),
370 expectedStatusCode: http.StatusBadRequest,
371 expectedJsonResponse: ValidationFailureJson,
374 controllerUpdateGnbTestExecuter(t, &context)
378 func TestControllerUpdateGnbMissingServedNrCellFddOrTdd(t *testing.T) {
380 servedNrCellInformation := buildServedNrCellInformation("")
381 servedNrCellInformation["choiceNrMode"] = map[string]interface{}{}
383 context := controllerUpdateGnbTestContext{
384 getNodebInfoResult: nil,
385 requestBody: map[string]interface{}{
386 "servedNrCells": []interface{}{
387 map[string]interface{}{
388 "servedNrCellInformation": servedNrCellInformation,
392 expectedStatusCode: http.StatusBadRequest,
393 expectedJsonResponse: ValidationFailureJson,
396 controllerUpdateGnbTestExecuter(t, &context)
399 func TestControllerUpdateGnbMissingNeighbourInfoFddOrTdd(t *testing.T) {
401 nrNeighbourInfo := buildNrNeighbourInformation("")
402 nrNeighbourInfo["choiceNrMode"] = map[string]interface{}{}
404 context := controllerUpdateGnbTestContext{
405 getNodebInfoResult: nil,
406 requestBody: map[string]interface{}{
407 "servedNrCells": []interface{}{
408 map[string]interface{}{
409 "servedNrCellInformation": buildServedNrCellInformation(""),
410 "nrNeighbourInfos": []interface{}{
416 expectedStatusCode: http.StatusBadRequest,
417 expectedJsonResponse: ValidationFailureJson,
420 controllerUpdateGnbTestExecuter(t, &context)
423 func TestControllerUpdateGnbMissingNrNeighbourInformationRequiredProp(t *testing.T) {
425 for _, v := range NrNeighbourInformationRequiredFields {
426 context := controllerUpdateGnbTestContext{
427 getNodebInfoResult: nil,
428 requestBody: map[string]interface{}{
429 "servedNrCells": []interface{}{
430 map[string]interface{}{
431 "servedNrCellInformation": buildServedNrCellInformation(""),
432 "nrNeighbourInfos": []interface{}{
433 buildNrNeighbourInformation(v),
438 expectedStatusCode: http.StatusBadRequest,
439 expectedJsonResponse: ValidationFailureJson,
442 controllerUpdateGnbTestExecuter(t, &context)
446 func TestControllerUpdateGnbValidServedNrCellInformationGetNodebNotFound(t *testing.T) {
447 context := controllerUpdateGnbTestContext{
448 getNodebInfoResult: &getNodebInfoResult{
450 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
452 requestBody: map[string]interface{}{
453 "servedNrCells": []interface{}{
454 map[string]interface{}{
455 "servedNrCellInformation": buildServedNrCellInformation(""),
459 expectedStatusCode: http.StatusNotFound,
460 expectedJsonResponse: ResourceNotFoundJson,
463 controllerUpdateGnbTestExecuter(t, &context)
466 func TestControllerUpdateGnbValidServedNrCellInformationGetNodebInternalError(t *testing.T) {
467 context := controllerUpdateGnbTestContext{
468 getNodebInfoResult: &getNodebInfoResult{
470 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
472 requestBody: map[string]interface{}{
473 "servedNrCells": []interface{}{
474 map[string]interface{}{
475 "servedNrCellInformation": buildServedNrCellInformation(""),
479 expectedStatusCode: http.StatusInternalServerError,
480 expectedJsonResponse: RnibErrorJson,
483 controllerUpdateGnbTestExecuter(t, &context)
486 func TestControllerUpdateGnbGetNodebSuccessInvalidGnbConfiguration(t *testing.T) {
487 context := controllerUpdateGnbTestContext{
488 getNodebInfoResult: &getNodebInfoResult{
489 nodebInfo: &entities.NodebInfo{
491 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
492 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
496 requestBody: map[string]interface{}{
497 "servedNrCells": []interface{}{
498 map[string]interface{}{
499 "servedNrCellInformation": buildServedNrCellInformation(""),
500 "nrNeighbourInfos": []interface{}{
501 buildNrNeighbourInformation(""),
506 expectedStatusCode: http.StatusInternalServerError,
507 expectedJsonResponse: InternalErrorJson,
510 controllerUpdateGnbTestExecuter(t, &context)
513 func TestControllerUpdateGnbGetNodebSuccessUpdateGnbCellsFailure(t *testing.T) {
514 context := controllerUpdateGnbTestContext{
515 updateGnbCellsParams: &updateGnbCellsParams{
516 err: common.NewInternalError(errors.New("#writer.UpdateGnbCells - Internal Error")),
518 getNodebInfoResult: &getNodebInfoResult{
519 nodebInfo: &entities.NodebInfo{
521 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
522 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
523 Configuration: &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{}},
527 requestBody: map[string]interface{}{
528 "servedNrCells": []interface{}{
529 map[string]interface{}{
530 "servedNrCellInformation": buildServedNrCellInformation(""),
531 "nrNeighbourInfos": []interface{}{
532 buildNrNeighbourInformation(""),
537 expectedStatusCode: http.StatusInternalServerError,
538 expectedJsonResponse: RnibErrorJson,
541 controllerUpdateGnbTestExecuter(t, &context)
544 func TestControllerUpdateGnbSuccess(t *testing.T) {
545 context := controllerUpdateGnbTestContext{
546 updateGnbCellsParams: &updateGnbCellsParams{
549 getNodebInfoResult: &getNodebInfoResult{
550 nodebInfo: &entities.NodebInfo{
552 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
553 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
554 Configuration: &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{}},
558 requestBody: map[string]interface{}{
559 "servedNrCells": []interface{}{
560 map[string]interface{}{
561 "servedNrCellInformation": buildServedNrCellInformation(""),
562 "nrNeighbourInfos": []interface{}{
563 buildNrNeighbourInformation(""),
568 expectedStatusCode: http.StatusOK,
569 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\"}",
572 controllerUpdateGnbTestExecuter(t, &context)
575 func getJsonRequestAsBuffer(requestJson map[string]interface{}) *bytes.Buffer {
576 b := new(bytes.Buffer)
577 _ = json.NewEncoder(b).Encode(requestJson)
581 func TestControllerGetNodebSuccess(t *testing.T) {
584 context := controllerGetNodebTestContext{
586 nodebInfo: &entities.NodebInfo{RanName: ranName, Ip: "10.0.2.15", Port: 1234},
587 rnibError: rnibError,
588 expectedStatusCode: http.StatusOK,
589 expectedJsonResponse: fmt.Sprintf("{\"ranName\":\"%s\",\"ip\":\"10.0.2.15\",\"port\":1234}", ranName),
592 controllerGetNodebTestExecuter(t, &context)
595 func TestControllerGetNodebNotFound(t *testing.T) {
598 var nodebInfo *entities.NodebInfo
599 context := controllerGetNodebTestContext{
601 nodebInfo: nodebInfo,
602 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
603 expectedStatusCode: http.StatusNotFound,
604 expectedJsonResponse: ResourceNotFoundJson,
607 controllerGetNodebTestExecuter(t, &context)
610 func TestControllerGetNodebInternal(t *testing.T) {
612 var nodebInfo *entities.NodebInfo
613 context := controllerGetNodebTestContext{
615 nodebInfo: nodebInfo,
616 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
617 expectedStatusCode: http.StatusInternalServerError,
618 expectedJsonResponse: RnibErrorJson,
621 controllerGetNodebTestExecuter(t, &context)
624 func TestControllerGetNodebIdListSuccess(t *testing.T) {
626 nodebIdList := []*entities.NbIdentity{
627 {InventoryName: "test1", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}},
628 {InventoryName: "test2", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId2", NbId: "nbId2"}},
631 context := controllerGetNodebIdListTestContext{
632 nodebIdList: nodebIdList,
633 rnibError: rnibError,
634 expectedStatusCode: http.StatusOK,
635 expectedJsonResponse: "[{\"inventoryName\":\"test1\",\"globalNbId\":{\"plmnId\":\"plmnId1\",\"nbId\":\"nbId1\"}},{\"inventoryName\":\"test2\",\"globalNbId\":{\"plmnId\":\"plmnId2\",\"nbId\":\"nbId2\"}}]",
638 controllerGetNodebIdListTestExecuter(t, &context)
641 func TestControllerGetNodebIdListEmptySuccess(t *testing.T) {
643 nodebIdList := []*entities.NbIdentity{}
645 context := controllerGetNodebIdListTestContext{
646 nodebIdList: nodebIdList,
647 rnibError: rnibError,
648 expectedStatusCode: http.StatusOK,
649 expectedJsonResponse: "[]",
652 controllerGetNodebIdListTestExecuter(t, &context)
655 func TestControllerGetNodebIdListInternal(t *testing.T) {
656 var nodebIdList []*entities.NbIdentity
657 context := controllerGetNodebIdListTestContext{
658 nodebIdList: nodebIdList,
659 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
660 expectedStatusCode: http.StatusInternalServerError,
661 expectedJsonResponse: RnibErrorJson,
664 controllerGetNodebIdListTestExecuter(t, &context)
667 func TestHeaderValidationFailed(t *testing.T) {
668 controller, _, _, _, _ := setupControllerTest(t)
670 writer := httptest.NewRecorder()
672 header := &http.Header{}
674 controller.handleRequest(writer, header, httpmsghandlerprovider.ShutdownRequest, nil, true)
676 var errorResponse = parseJsonRequest(t, writer.Body)
677 err := e2managererrors.NewHeaderValidationError()
679 assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
680 assert.Equal(t, errorResponse.Code, err.Code)
681 assert.Equal(t, errorResponse.Message, err.Message)
684 func TestShutdownStatusNoContent(t *testing.T) {
685 controller, readerMock, _, _, e2tInstancesManagerMock := setupControllerTest(t)
686 e2tInstancesManagerMock.On("GetE2TAddresses").Return([]string{}, nil)
687 readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{}, nil)
689 writer := httptest.NewRecorder()
690 controller.Shutdown(writer, tests.GetHttpRequest())
692 assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
695 func TestHandleInternalError(t *testing.T) {
696 controller, _, _, _, _ := setupControllerTest(t)
698 writer := httptest.NewRecorder()
699 err := e2managererrors.NewInternalError()
701 controller.handleErrorResponse(err, writer)
702 var errorResponse = parseJsonRequest(t, writer.Body)
704 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
705 assert.Equal(t, errorResponse.Code, err.Code)
706 assert.Equal(t, errorResponse.Message, err.Message)
709 func TestHandleCommandAlreadyInProgressError(t *testing.T) {
710 controller, _, _, _, _ := setupControllerTest(t)
711 writer := httptest.NewRecorder()
712 err := e2managererrors.NewCommandAlreadyInProgressError()
714 controller.handleErrorResponse(err, writer)
715 var errorResponse = parseJsonRequest(t, writer.Body)
717 assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
718 assert.Equal(t, errorResponse.Code, err.Code)
719 assert.Equal(t, errorResponse.Message, err.Message)
722 func TestHandleRoutingManagerError(t *testing.T) {
723 controller, _, _, _, _ := setupControllerTest(t)
724 writer := httptest.NewRecorder()
725 err := e2managererrors.NewRoutingManagerError()
727 controller.handleErrorResponse(err, writer)
728 var errorResponse = parseJsonRequest(t, writer.Body)
730 assert.Equal(t, http.StatusServiceUnavailable, writer.Result().StatusCode)
731 assert.Equal(t, errorResponse.Code, err.Code)
732 assert.Equal(t, errorResponse.Message, err.Message)
735 func TestHandleE2TInstanceAbsenceError(t *testing.T) {
736 controller, _, _, _, _ := setupControllerTest(t)
738 writer := httptest.NewRecorder()
739 err := e2managererrors.NewE2TInstanceAbsenceError()
741 controller.handleErrorResponse(err, writer)
742 var errorResponse = parseJsonRequest(t, writer.Body)
744 assert.Equal(t, http.StatusServiceUnavailable, writer.Result().StatusCode)
745 assert.Equal(t, errorResponse.Code, err.Code)
746 assert.Equal(t, errorResponse.Message, err.Message)
749 func TestValidateHeaders(t *testing.T) {
750 controller, _, _, _, _ := setupControllerTest(t)
752 header := http.Header{}
753 header.Set("Content-Type", "application/json")
754 result := controller.validateRequestHeader(&header)
756 assert.Nil(t, result)
759 func parseJsonRequest(t *testing.T, r io.Reader) models.ErrorResponse {
761 var errorResponse models.ErrorResponse
762 body, err := ioutil.ReadAll(r)
764 t.Errorf("Error cannot deserialize json request")
766 _ =json.Unmarshal(body, &errorResponse)
771 func initLog(t *testing.T) *logger.Logger {
772 log, err := logger.InitLogger(logger.InfoLevel)
774 t.Errorf("#delete_all_request_handler_test.TestHandleSuccessFlow - failed to initialize logger, error: %s", err)
779 func TestX2ResetHandleSuccessfulRequestedCause(t *testing.T) {
780 controller, readerMock, _, rmrMessengerMock, _ := setupControllerTest(t)
783 payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x40}
785 var msgSrc unsafe.Pointer
786 msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction, msgSrc)
787 rmrMessengerMock.On("SendMsg", msg, mock.Anything).Return(msg, nil)
789 writer := httptest.NewRecorder()
791 var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
792 readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
794 data4Req := map[string]interface{}{"cause": "protocol:transfer-syntax-error"}
795 b := new(bytes.Buffer)
796 _ = json.NewEncoder(b).Encode(data4Req)
797 req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
798 req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
800 controller.X2Reset(writer, req)
801 assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
805 func TestX2ResetHandleSuccessfulRequestedDefault(t *testing.T) {
806 controller, readerMock, _, rmrMessengerMock, _ := setupControllerTest(t)
810 payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x64}
812 var msgSrc unsafe.Pointer
813 msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction, msgSrc)
814 rmrMessengerMock.On("SendMsg", msg, true).Return(msg, nil)
816 writer := httptest.NewRecorder()
818 var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
819 readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
822 b := new(bytes.Buffer)
823 req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
824 req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
826 controller.X2Reset(writer, req)
827 assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
831 func TestX2ResetHandleFailureInvalidBody(t *testing.T) {
832 controller, _, _, _, _ := setupControllerTest(t)
836 writer := httptest.NewRecorder()
838 // Invalid json: attribute name without quotes (should be "cause":).
839 b := strings.NewReader("{cause:\"protocol:transfer-syntax-error\"")
840 req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
841 req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
843 controller.X2Reset(writer, req)
844 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
848 func TestHandleErrorResponse(t *testing.T) {
849 controller, _, _, _, _ := setupControllerTest(t)
851 writer := httptest.NewRecorder()
852 controller.handleErrorResponse(e2managererrors.NewRnibDbError(), writer)
853 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
855 writer = httptest.NewRecorder()
856 controller.handleErrorResponse(e2managererrors.NewCommandAlreadyInProgressError(), writer)
857 assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
859 writer = httptest.NewRecorder()
860 controller.handleErrorResponse(e2managererrors.NewHeaderValidationError(), writer)
861 assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
863 writer = httptest.NewRecorder()
864 controller.handleErrorResponse(e2managererrors.NewWrongStateError("", ""), writer)
865 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
867 writer = httptest.NewRecorder()
868 controller.handleErrorResponse(e2managererrors.NewRequestValidationError(), writer)
869 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
871 writer = httptest.NewRecorder()
872 controller.handleErrorResponse(e2managererrors.NewRmrError(), writer)
873 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
875 writer = httptest.NewRecorder()
876 controller.handleErrorResponse(e2managererrors.NewResourceNotFoundError(), writer)
877 assert.Equal(t, http.StatusNotFound, writer.Result().StatusCode)
879 writer = httptest.NewRecorder()
880 controller.handleErrorResponse(fmt.Errorf("ErrorError"), writer)
881 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
884 func getRmrSender(rmrMessengerMock *mocks.RmrMessengerMock, log *logger.Logger) *rmrsender.RmrSender {
885 rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
886 rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
887 return rmrsender.NewRmrSender(log, rmrMessenger)