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).
27 "e2mgr/e2managererrors"
33 "e2mgr/providers/httpmsghandlerprovider"
36 "e2mgr/services/rmrsender"
40 "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
41 "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
42 "github.com/gorilla/mux"
43 "github.com/pkg/errors"
44 "github.com/stretchr/testify/assert"
45 "github.com/stretchr/testify/mock"
54 type controllerGetNodebTestContext struct {
56 nodebInfo *entities.NodebInfo
58 expectedStatusCode int
59 expectedJsonResponse string
62 type controllerGetNodebIdListTestContext struct {
63 nodebIdList []*entities.NbIdentity
65 expectedStatusCode int
66 expectedJsonResponse string
69 func setupControllerTest(t *testing.T) (*NodebController, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.RmrMessengerMock, *mocks.E2TInstancesManagerMock) {
71 config := configuration.ParseConfiguration()
73 rmrMessengerMock := &mocks.RmrMessengerMock{}
74 readerMock := &mocks.RnibReaderMock{}
76 writerMock := &mocks.RnibWriterMock{}
78 rnibDataService := services.NewRnibDataService(log, config, readerMock, writerMock)
79 rmrSender := getRmrSender(rmrMessengerMock, log)
80 ranSetupManager := managers.NewRanSetupManager(log, rmrSender, rnibDataService)
81 e2tInstancesManager := &mocks.E2TInstancesManagerMock{}
82 httpClientMock := &mocks.HttpClientMock{}
83 rmClient := clients.NewRoutingManagerClient(log, config, httpClientMock)
84 e2tAssociationManager := managers.NewE2TAssociationManager(log, rnibDataService, e2tInstancesManager, rmClient)
85 handlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(log, rmrSender, config, rnibDataService, ranSetupManager, e2tInstancesManager, e2tAssociationManager, rmClient)
86 controller := NewNodebController(log, handlerProvider)
87 return controller, readerMock, writerMock, rmrMessengerMock, e2tInstancesManager
90 func TestX2SetupInvalidBody(t *testing.T) {
92 controller, _, _, _, _ := setupControllerTest(t)
94 header := http.Header{}
95 header.Set("Content-Type", "application/json")
96 httpRequest, _ := http.NewRequest("POST", "http://localhost:3800/v1/nodeb/x2-setup", strings.NewReader("{}{}"))
97 httpRequest.Header = header
99 writer := httptest.NewRecorder()
100 controller.X2Setup(writer, httpRequest)
102 var errorResponse = parseJsonRequest(t, writer.Body)
104 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
105 assert.Equal(t, e2managererrors.NewInvalidJsonError().Code, errorResponse.Code)
108 func TestX2SetupSuccess(t *testing.T) {
110 controller, readerMock, writerMock, rmrMessengerMock, _ := setupControllerTest(t)
113 nb := &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST, AssociatedE2TInstanceAddress:"10.0.2.15:8989"}
114 readerMock.On("GetNodeb", ranName).Return(nb, nil)
116 nbUpdated.ConnectionAttempts = 0
117 writerMock.On("UpdateNodebInfo", &nbUpdated).Return(nil)
119 var nbUpdated2 = &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_CONNECTING, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST, ConnectionAttempts: 1, AssociatedE2TInstanceAddress:"10.0.2.15:8989"}
120 writerMock.On("UpdateNodebInfo", nbUpdated2).Return(nil)
122 payload := e2pdus.PackedX2setupRequest
124 msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), ranName, &payload, &xAction)
126 rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg, nil)
128 header := http.Header{}
129 header.Set("Content-Type", "application/json")
130 httpRequest := tests.GetHttpRequest()
131 httpRequest.Header = header
133 writer := httptest.NewRecorder()
134 controller.X2Setup(writer, httpRequest)
136 assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
139 func TestEndcSetupSuccess(t *testing.T) {
141 controller, readerMock, writerMock, rmrMessengerMock, _ := setupControllerTest(t)
144 nb := &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST, AssociatedE2TInstanceAddress:"10.0.2.15:8989"}
145 readerMock.On("GetNodeb", ranName).Return(nb, nil)
147 nbUpdated.ConnectionAttempts = 0
148 writerMock.On("UpdateNodebInfo", &nbUpdated).Return(nil)
150 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"}
151 writerMock.On("UpdateNodebInfo", nbUpdated2).Return(nil)
153 payload := e2pdus.PackedEndcX2setupRequest
155 msg := rmrCgo.NewMBuf(rmrCgo.RIC_ENDC_X2_SETUP_REQ, len(payload), ranName, &payload, &xAction)
157 rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg, nil)
159 header := http.Header{}
160 header.Set("Content-Type", "application/json")
161 httpRequest := tests.GetHttpRequest()
162 httpRequest.Header = header
164 writer := httptest.NewRecorder()
165 controller.EndcSetup(writer, httpRequest)
167 assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
170 func TestShutdownHandlerRnibError(t *testing.T) {
171 controller, _, _, _, e2tInstancesManagerMock:= setupControllerTest(t)
172 e2tInstancesManagerMock.On("GetE2TAddresses").Return([]string{}, e2managererrors.NewRnibDbError())
174 writer := httptest.NewRecorder()
176 controller.Shutdown(writer, tests.GetHttpRequest())
178 var errorResponse = parseJsonRequest(t, writer.Body)
180 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
181 assert.Equal(t, errorResponse.Code, e2managererrors.NewRnibDbError().Code)
184 func controllerGetNodebTestExecuter(t *testing.T, context *controllerGetNodebTestContext) {
185 controller, readerMock, _, _, _ := setupControllerTest(t)
186 writer := httptest.NewRecorder()
187 readerMock.On("GetNodeb", context.ranName).Return(context.nodebInfo, context.rnibError)
188 req, _ := http.NewRequest("GET", "/nodeb", nil)
189 req = mux.SetURLVars(req, map[string]string{"ranName": context.ranName})
190 controller.GetNodeb(writer, req)
191 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
192 bodyBytes, _ := ioutil.ReadAll(writer.Body)
193 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
196 func controllerGetNodebIdListTestExecuter(t *testing.T, context *controllerGetNodebIdListTestContext) {
197 controller, readerMock, _, _, _ := setupControllerTest(t)
198 writer := httptest.NewRecorder()
199 readerMock.On("GetListNodebIds").Return(context.nodebIdList, context.rnibError)
200 req, _ := http.NewRequest("GET", "/nodeb/ids", nil)
201 controller.GetNodebIdList(writer, req)
202 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
203 bodyBytes, _ := ioutil.ReadAll(writer.Body)
204 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
207 func TestControllerGetNodebSuccess(t *testing.T) {
210 context := controllerGetNodebTestContext{
212 nodebInfo: &entities.NodebInfo{RanName: ranName, Ip: "10.0.2.15", Port: 1234},
213 rnibError: rnibError,
214 expectedStatusCode: http.StatusOK,
215 expectedJsonResponse: fmt.Sprintf("{\"ranName\":\"%s\",\"ip\":\"10.0.2.15\",\"port\":1234}", ranName),
218 controllerGetNodebTestExecuter(t, &context)
221 func TestControllerGetNodebNotFound(t *testing.T) {
224 var nodebInfo *entities.NodebInfo
225 context := controllerGetNodebTestContext{
227 nodebInfo: nodebInfo,
228 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
229 expectedStatusCode: http.StatusNotFound,
230 expectedJsonResponse: "{\"errorCode\":404,\"errorMessage\":\"Resource not found\"}",
233 controllerGetNodebTestExecuter(t, &context)
236 func TestControllerGetNodebInternal(t *testing.T) {
238 var nodebInfo *entities.NodebInfo
239 context := controllerGetNodebTestContext{
241 nodebInfo: nodebInfo,
242 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
243 expectedStatusCode: http.StatusInternalServerError,
244 expectedJsonResponse: "{\"errorCode\":500,\"errorMessage\":\"RNIB error\"}",
247 controllerGetNodebTestExecuter(t, &context)
250 func TestControllerGetNodebIdListSuccess(t *testing.T) {
252 nodebIdList := []*entities.NbIdentity{
253 {InventoryName: "test1", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}},
254 {InventoryName: "test2", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId2", NbId: "nbId2"}},
257 context := controllerGetNodebIdListTestContext{
258 nodebIdList: nodebIdList,
259 rnibError: rnibError,
260 expectedStatusCode: http.StatusOK,
261 expectedJsonResponse: "[{\"inventoryName\":\"test1\",\"globalNbId\":{\"plmnId\":\"plmnId1\",\"nbId\":\"nbId1\"}},{\"inventoryName\":\"test2\",\"globalNbId\":{\"plmnId\":\"plmnId2\",\"nbId\":\"nbId2\"}}]",
264 controllerGetNodebIdListTestExecuter(t, &context)
267 func TestControllerGetNodebIdListEmptySuccess(t *testing.T) {
269 nodebIdList := []*entities.NbIdentity{}
271 context := controllerGetNodebIdListTestContext{
272 nodebIdList: nodebIdList,
273 rnibError: rnibError,
274 expectedStatusCode: http.StatusOK,
275 expectedJsonResponse: "[]",
278 controllerGetNodebIdListTestExecuter(t, &context)
281 func TestControllerGetNodebIdListInternal(t *testing.T) {
282 var nodebIdList []*entities.NbIdentity
283 context := controllerGetNodebIdListTestContext{
284 nodebIdList: nodebIdList,
285 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
286 expectedStatusCode: http.StatusInternalServerError,
287 expectedJsonResponse: "{\"errorCode\":500,\"errorMessage\":\"RNIB error\"}",
290 controllerGetNodebIdListTestExecuter(t, &context)
293 func TestHeaderValidationFailed(t *testing.T) {
294 controller, _, _, _, _ := setupControllerTest(t)
296 writer := httptest.NewRecorder()
298 header := &http.Header{}
300 controller.handleRequest(writer, header, httpmsghandlerprovider.ShutdownRequest, nil, true)
302 var errorResponse = parseJsonRequest(t, writer.Body)
303 err := e2managererrors.NewHeaderValidationError()
305 assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
306 assert.Equal(t, errorResponse.Code, err.Code)
307 assert.Equal(t, errorResponse.Message, err.Message)
310 func TestShutdownStatusNoContent(t *testing.T) {
311 controller, readerMock, _, _, e2tInstancesManagerMock := setupControllerTest(t)
312 e2tInstancesManagerMock.On("GetE2TAddresses").Return([]string{}, nil)
313 readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{}, nil)
315 writer := httptest.NewRecorder()
316 controller.Shutdown(writer, tests.GetHttpRequest())
318 assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
321 func TestHandleInternalError(t *testing.T) {
322 controller, _, _, _, _ := setupControllerTest(t)
324 writer := httptest.NewRecorder()
325 err := e2managererrors.NewInternalError()
327 controller.handleErrorResponse(err, writer)
328 var errorResponse = parseJsonRequest(t, writer.Body)
330 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
331 assert.Equal(t, errorResponse.Code, err.Code)
332 assert.Equal(t, errorResponse.Message, err.Message)
335 func TestHandleCommandAlreadyInProgressError(t *testing.T) {
336 controller, _, _, _, _ := setupControllerTest(t)
337 writer := httptest.NewRecorder()
338 err := e2managererrors.NewCommandAlreadyInProgressError()
340 controller.handleErrorResponse(err, writer)
341 var errorResponse = parseJsonRequest(t, writer.Body)
343 assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
344 assert.Equal(t, errorResponse.Code, err.Code)
345 assert.Equal(t, errorResponse.Message, err.Message)
348 func TestHandleE2TInstanceAbsenceError(t *testing.T) {
349 controller, _, _, _, _ := setupControllerTest(t)
351 writer := httptest.NewRecorder()
352 err := e2managererrors.NewE2TInstanceAbsenceError()
354 controller.handleErrorResponse(err, writer)
355 var errorResponse = parseJsonRequest(t, writer.Body)
357 assert.Equal(t, http.StatusServiceUnavailable, writer.Result().StatusCode)
358 assert.Equal(t, errorResponse.Code, err.Code)
359 assert.Equal(t, errorResponse.Message, err.Message)
362 func TestValidateHeaders(t *testing.T) {
363 controller, _, _, _, _ := setupControllerTest(t)
365 header := http.Header{}
366 header.Set("Content-Type", "application/json")
367 result := controller.validateRequestHeader(&header)
369 assert.Nil(t, result)
372 func parseJsonRequest(t *testing.T, r io.Reader) models.ErrorResponse {
374 var errorResponse models.ErrorResponse
375 body, err := ioutil.ReadAll(r)
377 t.Errorf("Error cannot deserialize json request")
379 json.Unmarshal(body, &errorResponse)
384 func initLog(t *testing.T) *logger.Logger {
385 log, err := logger.InitLogger(logger.InfoLevel)
387 t.Errorf("#delete_all_request_handler_test.TestHandleSuccessFlow - failed to initialize logger, error: %s", err)
392 func TestX2ResetHandleSuccessfulRequestedCause(t *testing.T) {
393 controller, readerMock, _, rmrMessengerMock, _ := setupControllerTest(t)
396 payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x40}
398 msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction)
399 rmrMessengerMock.On("SendMsg", msg, mock.Anything).Return(msg, nil)
401 writer := httptest.NewRecorder()
403 var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
404 readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
406 data4Req := map[string]interface{}{"cause": "protocol:transfer-syntax-error"}
407 b := new(bytes.Buffer)
408 _ = json.NewEncoder(b).Encode(data4Req)
409 req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
410 req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
412 controller.X2Reset(writer, req)
413 assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
417 func TestX2ResetHandleSuccessfulRequestedDefault(t *testing.T) {
418 controller, readerMock, _, rmrMessengerMock, _ := setupControllerTest(t)
422 payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x64}
424 msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction)
425 rmrMessengerMock.On("SendMsg", msg, true).Return(msg, nil)
427 writer := httptest.NewRecorder()
429 var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
430 readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
433 b := new(bytes.Buffer)
434 req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
435 req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
437 controller.X2Reset(writer, req)
438 assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
442 func TestX2ResetHandleFailureInvalidBody(t *testing.T) {
443 controller, _, _, _ , _:= setupControllerTest(t)
447 writer := httptest.NewRecorder()
449 // Invalid json: attribute name without quotes (should be "cause":).
450 b := strings.NewReader("{cause:\"protocol:transfer-syntax-error\"")
451 req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
452 req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
454 controller.X2Reset(writer, req)
455 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
459 func TestHandleErrorResponse(t *testing.T) {
460 controller, _, _, _ , _:= setupControllerTest(t)
462 writer := httptest.NewRecorder()
463 controller.handleErrorResponse(e2managererrors.NewRnibDbError(), writer)
464 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
466 writer = httptest.NewRecorder()
467 controller.handleErrorResponse(e2managererrors.NewCommandAlreadyInProgressError(), writer)
468 assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
470 writer = httptest.NewRecorder()
471 controller.handleErrorResponse(e2managererrors.NewHeaderValidationError(), writer)
472 assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
474 writer = httptest.NewRecorder()
475 controller.handleErrorResponse(e2managererrors.NewWrongStateError("", ""), writer)
476 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
478 writer = httptest.NewRecorder()
479 controller.handleErrorResponse(e2managererrors.NewRequestValidationError(), writer)
480 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
482 writer = httptest.NewRecorder()
483 controller.handleErrorResponse(e2managererrors.NewRmrError(), writer)
484 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
486 writer = httptest.NewRecorder()
487 controller.handleErrorResponse(e2managererrors.NewResourceNotFoundError(), writer)
488 assert.Equal(t, http.StatusNotFound, writer.Result().StatusCode)
490 writer = httptest.NewRecorder()
491 controller.handleErrorResponse(fmt.Errorf("ErrorError"), writer)
492 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
495 func getRmrSender(rmrMessengerMock *mocks.RmrMessengerMock, log *logger.Logger) *rmrsender.RmrSender {
496 rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
497 rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
498 return rmrsender.NewRmrSender(log, rmrMessenger)