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 writerMock.On("UpdateNodebInfo", &nbUpdated).Return(nil)
187 var nbUpdated2 = &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_CONNECTING, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST, AssociatedE2TInstanceAddress: "10.0.2.15:8989"}
188 writerMock.On("UpdateNodebInfo", nbUpdated2).Return(nil)
190 payload := e2pdus.PackedX2setupRequest
192 var msgSrc unsafe.Pointer
193 msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), ranName, &payload, &xAction, msgSrc)
195 rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg, nil)
197 header := http.Header{}
198 header.Set("Content-Type", "application/json")
199 httpRequest := tests.GetHttpRequest()
200 httpRequest.Header = header
202 writer := httptest.NewRecorder()
203 controller.X2Setup(writer, httpRequest)
205 assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
208 func TestEndcSetupSuccess(t *testing.T) {
210 controller, readerMock, writerMock, rmrMessengerMock, _ := setupControllerTest(t)
213 nb := &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST, AssociatedE2TInstanceAddress: "10.0.2.15:8989"}
214 readerMock.On("GetNodeb", ranName).Return(nb, nil)
216 writerMock.On("UpdateNodebInfo", &nbUpdated).Return(nil)
218 var nbUpdated2 = &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_CONNECTING, E2ApplicationProtocol: entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST, AssociatedE2TInstanceAddress: "10.0.2.15:8989"}
219 writerMock.On("UpdateNodebInfo", nbUpdated2).Return(nil)
221 payload := e2pdus.PackedEndcX2setupRequest
223 var msgSrc unsafe.Pointer
224 msg := rmrCgo.NewMBuf(rmrCgo.RIC_ENDC_X2_SETUP_REQ, len(payload), ranName, &payload, &xAction, msgSrc)
226 rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg, nil)
228 header := http.Header{}
229 header.Set("Content-Type", "application/json")
230 httpRequest := tests.GetHttpRequest()
231 httpRequest.Header = header
233 writer := httptest.NewRecorder()
234 controller.EndcSetup(writer, httpRequest)
236 assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
239 func TestShutdownHandlerRnibError(t *testing.T) {
240 controller, _, _, _, e2tInstancesManagerMock := setupControllerTest(t)
241 e2tInstancesManagerMock.On("GetE2TAddresses").Return([]string{}, e2managererrors.NewRnibDbError())
243 writer := httptest.NewRecorder()
245 controller.Shutdown(writer, tests.GetHttpRequest())
247 var errorResponse = parseJsonRequest(t, writer.Body)
249 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
250 assert.Equal(t, errorResponse.Code, e2managererrors.NewRnibDbError().Code)
253 func controllerGetNodebTestExecuter(t *testing.T, context *controllerGetNodebTestContext) {
254 controller, readerMock, _, _, _ := setupControllerTest(t)
255 writer := httptest.NewRecorder()
256 readerMock.On("GetNodeb", context.ranName).Return(context.nodebInfo, context.rnibError)
257 req, _ := http.NewRequest(http.MethodGet, "/nodeb", nil)
258 req = mux.SetURLVars(req, map[string]string{"ranName": context.ranName})
259 controller.GetNodeb(writer, req)
260 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
261 bodyBytes, _ := ioutil.ReadAll(writer.Body)
262 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
265 func controllerGetNodebIdListTestExecuter(t *testing.T, context *controllerGetNodebIdListTestContext) {
266 controller, readerMock, _, _, _ := setupControllerTest(t)
267 writer := httptest.NewRecorder()
268 readerMock.On("GetListNodebIds").Return(context.nodebIdList, context.rnibError)
269 req, _ := http.NewRequest(http.MethodGet, "/nodeb/ids", nil)
270 controller.GetNodebIdList(writer, req)
271 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
272 bodyBytes, _ := ioutil.ReadAll(writer.Body)
273 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
276 func activateControllerUpdateGnbMocks(context *controllerUpdateGnbTestContext, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
277 if context.getNodebInfoResult != nil {
278 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
281 if context.updateGnbCellsParams != nil {
282 updatedNodebInfo := *context.getNodebInfoResult.nodebInfo
283 gnb := entities.Gnb{}
284 _ = jsonpb.Unmarshal(getJsonRequestAsBuffer(context.requestBody), &gnb)
285 updatedNodebInfo.GetGnb().ServedNrCells = gnb.ServedNrCells
286 writerMock.On("UpdateGnbCells", &updatedNodebInfo, gnb.ServedNrCells).Return(context.updateGnbCellsParams.err)
290 func assertControllerUpdateGnb(t *testing.T, context *controllerUpdateGnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
291 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
292 bodyBytes, _ := ioutil.ReadAll(writer.Body)
293 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
294 readerMock.AssertExpectations(t)
295 writerMock.AssertExpectations(t)
297 if context.getNodebInfoResult != nil {
298 readerMock.AssertNotCalled(t, "GetNodeb")
301 if context.updateGnbCellsParams != nil {
302 writerMock.AssertNotCalled(t, "UpdateGnb")
306 func buildUpdateGnbRequest(context *controllerUpdateGnbTestContext) *http.Request {
307 updateGnbUrl := fmt.Sprintf("/nodeb/%s/update", RanName)
308 requestBody := getJsonRequestAsBuffer(context.requestBody)
309 req, _ := http.NewRequest(http.MethodGet, updateGnbUrl, requestBody)
310 req.Header.Set("Content-Type", "application/json")
311 req = mux.SetURLVars(req, map[string]string{"ranName": RanName})
315 func controllerUpdateGnbTestExecuter(t *testing.T, context *controllerUpdateGnbTestContext) {
316 controller, readerMock, writerMock, _, _ := setupControllerTest(t)
317 writer := httptest.NewRecorder()
319 activateControllerUpdateGnbMocks(context, readerMock, writerMock)
320 req := buildUpdateGnbRequest(context)
321 controller.UpdateGnb(writer, req)
322 assertControllerUpdateGnb(t, context, writer, readerMock, writerMock)
325 func TestControllerUpdateGnbEmptyServedNrCells(t *testing.T) {
326 context := controllerUpdateGnbTestContext{
327 getNodebInfoResult: nil,
328 requestBody: map[string]interface{}{
329 "servedNrCells": []interface{}{
332 expectedStatusCode: http.StatusBadRequest,
333 expectedJsonResponse: ValidationFailureJson,
336 controllerUpdateGnbTestExecuter(t, &context)
339 func TestControllerUpdateGnbMissingServedNrCellInformation(t *testing.T) {
340 context := controllerUpdateGnbTestContext{
341 getNodebInfoResult: nil,
342 requestBody: map[string]interface{}{
343 "servedNrCells": []interface{}{
344 map[string]interface{}{
345 "servedNrCellInformation": nil,
349 expectedStatusCode: http.StatusBadRequest,
350 expectedJsonResponse: ValidationFailureJson,
353 controllerUpdateGnbTestExecuter(t, &context)
356 func TestControllerUpdateGnbMissingServedNrCellRequiredProp(t *testing.T) {
358 for _, v := range ServedNrCellInformationRequiredFields {
359 context := controllerUpdateGnbTestContext{
360 getNodebInfoResult: nil,
361 requestBody: map[string]interface{}{
362 "servedNrCells": []interface{}{
363 map[string]interface{}{
364 "servedNrCellInformation": buildServedNrCellInformation(v),
368 expectedStatusCode: http.StatusBadRequest,
369 expectedJsonResponse: ValidationFailureJson,
372 controllerUpdateGnbTestExecuter(t, &context)
376 func TestControllerUpdateGnbMissingServedNrCellFddOrTdd(t *testing.T) {
378 servedNrCellInformation := buildServedNrCellInformation("")
379 servedNrCellInformation["choiceNrMode"] = map[string]interface{}{}
381 context := controllerUpdateGnbTestContext{
382 getNodebInfoResult: nil,
383 requestBody: map[string]interface{}{
384 "servedNrCells": []interface{}{
385 map[string]interface{}{
386 "servedNrCellInformation": servedNrCellInformation,
390 expectedStatusCode: http.StatusBadRequest,
391 expectedJsonResponse: ValidationFailureJson,
394 controllerUpdateGnbTestExecuter(t, &context)
397 func TestControllerUpdateGnbMissingNeighbourInfoFddOrTdd(t *testing.T) {
399 nrNeighbourInfo := buildNrNeighbourInformation("")
400 nrNeighbourInfo["choiceNrMode"] = map[string]interface{}{}
402 context := controllerUpdateGnbTestContext{
403 getNodebInfoResult: nil,
404 requestBody: map[string]interface{}{
405 "servedNrCells": []interface{}{
406 map[string]interface{}{
407 "servedNrCellInformation": buildServedNrCellInformation(""),
408 "nrNeighbourInfos": []interface{}{
414 expectedStatusCode: http.StatusBadRequest,
415 expectedJsonResponse: ValidationFailureJson,
418 controllerUpdateGnbTestExecuter(t, &context)
421 func TestControllerUpdateGnbMissingNrNeighbourInformationRequiredProp(t *testing.T) {
423 for _, v := range NrNeighbourInformationRequiredFields {
424 context := controllerUpdateGnbTestContext{
425 getNodebInfoResult: nil,
426 requestBody: map[string]interface{}{
427 "servedNrCells": []interface{}{
428 map[string]interface{}{
429 "servedNrCellInformation": buildServedNrCellInformation(""),
430 "nrNeighbourInfos": []interface{}{
431 buildNrNeighbourInformation(v),
436 expectedStatusCode: http.StatusBadRequest,
437 expectedJsonResponse: ValidationFailureJson,
440 controllerUpdateGnbTestExecuter(t, &context)
444 func TestControllerUpdateGnbValidServedNrCellInformationGetNodebNotFound(t *testing.T) {
445 context := controllerUpdateGnbTestContext{
446 getNodebInfoResult: &getNodebInfoResult{
448 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
450 requestBody: map[string]interface{}{
451 "servedNrCells": []interface{}{
452 map[string]interface{}{
453 "servedNrCellInformation": buildServedNrCellInformation(""),
457 expectedStatusCode: http.StatusNotFound,
458 expectedJsonResponse: ResourceNotFoundJson,
461 controllerUpdateGnbTestExecuter(t, &context)
464 func TestControllerUpdateGnbValidServedNrCellInformationGetNodebInternalError(t *testing.T) {
465 context := controllerUpdateGnbTestContext{
466 getNodebInfoResult: &getNodebInfoResult{
468 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
470 requestBody: map[string]interface{}{
471 "servedNrCells": []interface{}{
472 map[string]interface{}{
473 "servedNrCellInformation": buildServedNrCellInformation(""),
477 expectedStatusCode: http.StatusInternalServerError,
478 expectedJsonResponse: RnibErrorJson,
481 controllerUpdateGnbTestExecuter(t, &context)
484 func TestControllerUpdateGnbGetNodebSuccessInvalidGnbConfiguration(t *testing.T) {
485 context := controllerUpdateGnbTestContext{
486 getNodebInfoResult: &getNodebInfoResult{
487 nodebInfo: &entities.NodebInfo{
489 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
490 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
494 requestBody: map[string]interface{}{
495 "servedNrCells": []interface{}{
496 map[string]interface{}{
497 "servedNrCellInformation": buildServedNrCellInformation(""),
498 "nrNeighbourInfos": []interface{}{
499 buildNrNeighbourInformation(""),
504 expectedStatusCode: http.StatusInternalServerError,
505 expectedJsonResponse: InternalErrorJson,
508 controllerUpdateGnbTestExecuter(t, &context)
511 func TestControllerUpdateGnbGetNodebSuccessUpdateGnbCellsFailure(t *testing.T) {
512 context := controllerUpdateGnbTestContext{
513 updateGnbCellsParams: &updateGnbCellsParams{
514 err: common.NewInternalError(errors.New("#writer.UpdateGnbCells - Internal Error")),
516 getNodebInfoResult: &getNodebInfoResult{
517 nodebInfo: &entities.NodebInfo{
519 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
520 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
521 Configuration: &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{}},
525 requestBody: map[string]interface{}{
526 "servedNrCells": []interface{}{
527 map[string]interface{}{
528 "servedNrCellInformation": buildServedNrCellInformation(""),
529 "nrNeighbourInfos": []interface{}{
530 buildNrNeighbourInformation(""),
535 expectedStatusCode: http.StatusInternalServerError,
536 expectedJsonResponse: RnibErrorJson,
539 controllerUpdateGnbTestExecuter(t, &context)
542 func TestControllerUpdateGnbSuccess(t *testing.T) {
543 context := controllerUpdateGnbTestContext{
544 updateGnbCellsParams: &updateGnbCellsParams{
547 getNodebInfoResult: &getNodebInfoResult{
548 nodebInfo: &entities.NodebInfo{
550 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
551 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
552 Configuration: &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{}},
556 requestBody: map[string]interface{}{
557 "servedNrCells": []interface{}{
558 map[string]interface{}{
559 "servedNrCellInformation": buildServedNrCellInformation(""),
560 "nrNeighbourInfos": []interface{}{
561 buildNrNeighbourInformation(""),
566 expectedStatusCode: http.StatusOK,
567 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\"}",
570 controllerUpdateGnbTestExecuter(t, &context)
573 func getJsonRequestAsBuffer(requestJson map[string]interface{}) *bytes.Buffer {
574 b := new(bytes.Buffer)
575 _ = json.NewEncoder(b).Encode(requestJson)
579 func TestControllerGetNodebSuccess(t *testing.T) {
582 context := controllerGetNodebTestContext{
584 nodebInfo: &entities.NodebInfo{RanName: ranName, Ip: "10.0.2.15", Port: 1234},
585 rnibError: rnibError,
586 expectedStatusCode: http.StatusOK,
587 expectedJsonResponse: fmt.Sprintf("{\"ranName\":\"%s\",\"ip\":\"10.0.2.15\",\"port\":1234}", ranName),
590 controllerGetNodebTestExecuter(t, &context)
593 func TestControllerGetNodebNotFound(t *testing.T) {
596 var nodebInfo *entities.NodebInfo
597 context := controllerGetNodebTestContext{
599 nodebInfo: nodebInfo,
600 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
601 expectedStatusCode: http.StatusNotFound,
602 expectedJsonResponse: ResourceNotFoundJson,
605 controllerGetNodebTestExecuter(t, &context)
608 func TestControllerGetNodebInternal(t *testing.T) {
610 var nodebInfo *entities.NodebInfo
611 context := controllerGetNodebTestContext{
613 nodebInfo: nodebInfo,
614 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
615 expectedStatusCode: http.StatusInternalServerError,
616 expectedJsonResponse: RnibErrorJson,
619 controllerGetNodebTestExecuter(t, &context)
622 func TestControllerGetNodebIdListSuccess(t *testing.T) {
624 nodebIdList := []*entities.NbIdentity{
625 {InventoryName: "test1", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}},
626 {InventoryName: "test2", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId2", NbId: "nbId2"}},
629 context := controllerGetNodebIdListTestContext{
630 nodebIdList: nodebIdList,
631 rnibError: rnibError,
632 expectedStatusCode: http.StatusOK,
633 expectedJsonResponse: "[{\"inventoryName\":\"test1\",\"globalNbId\":{\"plmnId\":\"plmnId1\",\"nbId\":\"nbId1\"}},{\"inventoryName\":\"test2\",\"globalNbId\":{\"plmnId\":\"plmnId2\",\"nbId\":\"nbId2\"}}]",
636 controllerGetNodebIdListTestExecuter(t, &context)
639 func TestControllerGetNodebIdListEmptySuccess(t *testing.T) {
641 nodebIdList := []*entities.NbIdentity{}
643 context := controllerGetNodebIdListTestContext{
644 nodebIdList: nodebIdList,
645 rnibError: rnibError,
646 expectedStatusCode: http.StatusOK,
647 expectedJsonResponse: "[]",
650 controllerGetNodebIdListTestExecuter(t, &context)
653 func TestControllerGetNodebIdListInternal(t *testing.T) {
654 var nodebIdList []*entities.NbIdentity
655 context := controllerGetNodebIdListTestContext{
656 nodebIdList: nodebIdList,
657 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
658 expectedStatusCode: http.StatusInternalServerError,
659 expectedJsonResponse: RnibErrorJson,
662 controllerGetNodebIdListTestExecuter(t, &context)
665 func TestHeaderValidationFailed(t *testing.T) {
666 controller, _, _, _, _ := setupControllerTest(t)
668 writer := httptest.NewRecorder()
670 header := &http.Header{}
672 controller.handleRequest(writer, header, httpmsghandlerprovider.ShutdownRequest, nil, true)
674 var errorResponse = parseJsonRequest(t, writer.Body)
675 err := e2managererrors.NewHeaderValidationError()
677 assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
678 assert.Equal(t, errorResponse.Code, err.Code)
679 assert.Equal(t, errorResponse.Message, err.Message)
682 func TestShutdownStatusNoContent(t *testing.T) {
683 controller, readerMock, _, _, e2tInstancesManagerMock := setupControllerTest(t)
684 e2tInstancesManagerMock.On("GetE2TAddresses").Return([]string{}, nil)
685 readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{}, nil)
687 writer := httptest.NewRecorder()
688 controller.Shutdown(writer, tests.GetHttpRequest())
690 assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
693 func TestHandleInternalError(t *testing.T) {
694 controller, _, _, _, _ := setupControllerTest(t)
696 writer := httptest.NewRecorder()
697 err := e2managererrors.NewInternalError()
699 controller.handleErrorResponse(err, writer)
700 var errorResponse = parseJsonRequest(t, writer.Body)
702 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
703 assert.Equal(t, errorResponse.Code, err.Code)
704 assert.Equal(t, errorResponse.Message, err.Message)
707 func TestHandleCommandAlreadyInProgressError(t *testing.T) {
708 controller, _, _, _, _ := setupControllerTest(t)
709 writer := httptest.NewRecorder()
710 err := e2managererrors.NewCommandAlreadyInProgressError()
712 controller.handleErrorResponse(err, writer)
713 var errorResponse = parseJsonRequest(t, writer.Body)
715 assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
716 assert.Equal(t, errorResponse.Code, err.Code)
717 assert.Equal(t, errorResponse.Message, err.Message)
720 func TestHandleRoutingManagerError(t *testing.T) {
721 controller, _, _, _, _ := setupControllerTest(t)
722 writer := httptest.NewRecorder()
723 err := e2managererrors.NewRoutingManagerError()
725 controller.handleErrorResponse(err, writer)
726 var errorResponse = parseJsonRequest(t, writer.Body)
728 assert.Equal(t, http.StatusServiceUnavailable, writer.Result().StatusCode)
729 assert.Equal(t, errorResponse.Code, err.Code)
730 assert.Equal(t, errorResponse.Message, err.Message)
733 func TestHandleE2TInstanceAbsenceError(t *testing.T) {
734 controller, _, _, _, _ := setupControllerTest(t)
736 writer := httptest.NewRecorder()
737 err := e2managererrors.NewE2TInstanceAbsenceError()
739 controller.handleErrorResponse(err, writer)
740 var errorResponse = parseJsonRequest(t, writer.Body)
742 assert.Equal(t, http.StatusServiceUnavailable, writer.Result().StatusCode)
743 assert.Equal(t, errorResponse.Code, err.Code)
744 assert.Equal(t, errorResponse.Message, err.Message)
747 func TestValidateHeaders(t *testing.T) {
748 controller, _, _, _, _ := setupControllerTest(t)
750 header := http.Header{}
751 header.Set("Content-Type", "application/json")
752 result := controller.validateRequestHeader(&header)
754 assert.Nil(t, result)
757 func parseJsonRequest(t *testing.T, r io.Reader) models.ErrorResponse {
759 var errorResponse models.ErrorResponse
760 body, err := ioutil.ReadAll(r)
762 t.Errorf("Error cannot deserialize json request")
764 _ =json.Unmarshal(body, &errorResponse)
769 func initLog(t *testing.T) *logger.Logger {
770 log, err := logger.InitLogger(logger.InfoLevel)
772 t.Errorf("#delete_all_request_handler_test.TestHandleSuccessFlow - failed to initialize logger, error: %s", err)
777 func TestX2ResetHandleSuccessfulRequestedCause(t *testing.T) {
778 controller, readerMock, _, rmrMessengerMock, _ := setupControllerTest(t)
781 payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x40}
783 var msgSrc unsafe.Pointer
784 msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction, msgSrc)
785 rmrMessengerMock.On("SendMsg", msg, mock.Anything).Return(msg, nil)
787 writer := httptest.NewRecorder()
789 var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
790 readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
792 data4Req := map[string]interface{}{"cause": "protocol:transfer-syntax-error"}
793 b := new(bytes.Buffer)
794 _ = json.NewEncoder(b).Encode(data4Req)
795 req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
796 req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
798 controller.X2Reset(writer, req)
799 assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
803 func TestX2ResetHandleSuccessfulRequestedDefault(t *testing.T) {
804 controller, readerMock, _, rmrMessengerMock, _ := setupControllerTest(t)
808 payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x64}
810 var msgSrc unsafe.Pointer
811 msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction, msgSrc)
812 rmrMessengerMock.On("SendMsg", msg, true).Return(msg, nil)
814 writer := httptest.NewRecorder()
816 var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
817 readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
820 b := new(bytes.Buffer)
821 req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
822 req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
824 controller.X2Reset(writer, req)
825 assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
829 func TestX2ResetHandleFailureInvalidBody(t *testing.T) {
830 controller, _, _, _, _ := setupControllerTest(t)
834 writer := httptest.NewRecorder()
836 // Invalid json: attribute name without quotes (should be "cause":).
837 b := strings.NewReader("{cause:\"protocol:transfer-syntax-error\"")
838 req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
839 req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
841 controller.X2Reset(writer, req)
842 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
846 func TestHandleErrorResponse(t *testing.T) {
847 controller, _, _, _, _ := setupControllerTest(t)
849 writer := httptest.NewRecorder()
850 controller.handleErrorResponse(e2managererrors.NewRnibDbError(), writer)
851 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
853 writer = httptest.NewRecorder()
854 controller.handleErrorResponse(e2managererrors.NewCommandAlreadyInProgressError(), writer)
855 assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
857 writer = httptest.NewRecorder()
858 controller.handleErrorResponse(e2managererrors.NewHeaderValidationError(), writer)
859 assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
861 writer = httptest.NewRecorder()
862 controller.handleErrorResponse(e2managererrors.NewWrongStateError("", ""), writer)
863 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
865 writer = httptest.NewRecorder()
866 controller.handleErrorResponse(e2managererrors.NewRequestValidationError(), writer)
867 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
869 writer = httptest.NewRecorder()
870 controller.handleErrorResponse(e2managererrors.NewRmrError(), writer)
871 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
873 writer = httptest.NewRecorder()
874 controller.handleErrorResponse(e2managererrors.NewResourceNotFoundError(), writer)
875 assert.Equal(t, http.StatusNotFound, writer.Result().StatusCode)
877 writer = httptest.NewRecorder()
878 controller.handleErrorResponse(fmt.Errorf("ErrorError"), writer)
879 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
882 func getRmrSender(rmrMessengerMock *mocks.RmrMessengerMock, log *logger.Logger) *rmrsender.RmrSender {
883 rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
884 rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
885 return rmrsender.NewRmrSender(log, rmrMessenger)