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 TestHandleRoutingManagerError(t *testing.T) {
349 controller, _, _, _, _ := setupControllerTest(t)
350 writer := httptest.NewRecorder()
351 err := e2managererrors.NewRoutingManagerError()
353 controller.handleErrorResponse(err, writer)
354 var errorResponse = parseJsonRequest(t, writer.Body)
356 assert.Equal(t, http.StatusServiceUnavailable, writer.Result().StatusCode)
357 assert.Equal(t, errorResponse.Code, err.Code)
358 assert.Equal(t, errorResponse.Message, err.Message)
361 func TestHandleE2TInstanceAbsenceError(t *testing.T) {
362 controller, _, _, _, _ := setupControllerTest(t)
364 writer := httptest.NewRecorder()
365 err := e2managererrors.NewE2TInstanceAbsenceError()
367 controller.handleErrorResponse(err, writer)
368 var errorResponse = parseJsonRequest(t, writer.Body)
370 assert.Equal(t, http.StatusServiceUnavailable, writer.Result().StatusCode)
371 assert.Equal(t, errorResponse.Code, err.Code)
372 assert.Equal(t, errorResponse.Message, err.Message)
375 func TestValidateHeaders(t *testing.T) {
376 controller, _, _, _, _ := setupControllerTest(t)
378 header := http.Header{}
379 header.Set("Content-Type", "application/json")
380 result := controller.validateRequestHeader(&header)
382 assert.Nil(t, result)
385 func parseJsonRequest(t *testing.T, r io.Reader) models.ErrorResponse {
387 var errorResponse models.ErrorResponse
388 body, err := ioutil.ReadAll(r)
390 t.Errorf("Error cannot deserialize json request")
392 json.Unmarshal(body, &errorResponse)
397 func initLog(t *testing.T) *logger.Logger {
398 log, err := logger.InitLogger(logger.InfoLevel)
400 t.Errorf("#delete_all_request_handler_test.TestHandleSuccessFlow - failed to initialize logger, error: %s", err)
405 func TestX2ResetHandleSuccessfulRequestedCause(t *testing.T) {
406 controller, readerMock, _, rmrMessengerMock, _ := setupControllerTest(t)
409 payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x40}
411 msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction)
412 rmrMessengerMock.On("SendMsg", msg, mock.Anything).Return(msg, nil)
414 writer := httptest.NewRecorder()
416 var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
417 readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
419 data4Req := map[string]interface{}{"cause": "protocol:transfer-syntax-error"}
420 b := new(bytes.Buffer)
421 _ = json.NewEncoder(b).Encode(data4Req)
422 req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
423 req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
425 controller.X2Reset(writer, req)
426 assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
430 func TestX2ResetHandleSuccessfulRequestedDefault(t *testing.T) {
431 controller, readerMock, _, rmrMessengerMock, _ := setupControllerTest(t)
435 payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x64}
437 msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction)
438 rmrMessengerMock.On("SendMsg", msg, true).Return(msg, nil)
440 writer := httptest.NewRecorder()
442 var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
443 readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
446 b := new(bytes.Buffer)
447 req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
448 req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
450 controller.X2Reset(writer, req)
451 assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
455 func TestX2ResetHandleFailureInvalidBody(t *testing.T) {
456 controller, _, _, _ , _:= setupControllerTest(t)
460 writer := httptest.NewRecorder()
462 // Invalid json: attribute name without quotes (should be "cause":).
463 b := strings.NewReader("{cause:\"protocol:transfer-syntax-error\"")
464 req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
465 req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
467 controller.X2Reset(writer, req)
468 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
472 func TestHandleErrorResponse(t *testing.T) {
473 controller, _, _, _ , _:= setupControllerTest(t)
475 writer := httptest.NewRecorder()
476 controller.handleErrorResponse(e2managererrors.NewRnibDbError(), writer)
477 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
479 writer = httptest.NewRecorder()
480 controller.handleErrorResponse(e2managererrors.NewCommandAlreadyInProgressError(), writer)
481 assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
483 writer = httptest.NewRecorder()
484 controller.handleErrorResponse(e2managererrors.NewHeaderValidationError(), writer)
485 assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
487 writer = httptest.NewRecorder()
488 controller.handleErrorResponse(e2managererrors.NewWrongStateError("", ""), writer)
489 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
491 writer = httptest.NewRecorder()
492 controller.handleErrorResponse(e2managererrors.NewRequestValidationError(), writer)
493 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
495 writer = httptest.NewRecorder()
496 controller.handleErrorResponse(e2managererrors.NewRmrError(), writer)
497 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
499 writer = httptest.NewRecorder()
500 controller.handleErrorResponse(e2managererrors.NewResourceNotFoundError(), writer)
501 assert.Equal(t, http.StatusNotFound, writer.Result().StatusCode)
503 writer = httptest.NewRecorder()
504 controller.handleErrorResponse(fmt.Errorf("ErrorError"), writer)
505 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
508 func getRmrSender(rmrMessengerMock *mocks.RmrMessengerMock, log *logger.Logger) *rmrsender.RmrSender {
509 rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
510 rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
511 return rmrsender.NewRmrSender(log, rmrMessenger)