2 // Copyright 2019 AT&T Intellectual Property
3 // Copyright 2019 Nokia
5 // Licensed under the Apache License, Version 2.0 (the "License");
6 // you may not use this file except in compliance with the License.
7 // You may obtain a copy of the License at
9 // http://www.apache.org/licenses/LICENSE-2.0
11 // Unless required by applicable law or agreed to in writing, software
12 // distributed under the License is distributed on an "AS IS" BASIS,
13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 // See the License for the specific language governing permissions and
15 // limitations under the License.
17 // This source code is part of the near-RT RIC (RAN Intelligent Controller)
18 // platform project (RICP).
26 "e2mgr/e2managererrors"
31 "e2mgr/providers/httpmsghandlerprovider"
34 "e2mgr/services/rmrsender"
38 "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
39 "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
40 "github.com/golang/protobuf/jsonpb"
41 "github.com/gorilla/mux"
42 "github.com/pkg/errors"
43 "github.com/stretchr/testify/assert"
44 "github.com/stretchr/testify/mock"
56 AssociatedE2TInstanceAddress = "10.0.2.15:38000"
57 CorruptedJson = "{\"errorCode\":401,\"errorMessage\":\"corrupted json\"}"
58 ValidationFailureJson = "{\"errorCode\":402,\"errorMessage\":\"Validation error\"}"
59 ResourceNotFoundJson = "{\"errorCode\":404,\"errorMessage\":\"Resource not found\"}"
60 NodebExistsJson = "{\"errorCode\":406,\"errorMessage\":\"Nodeb already exists\"}"
61 RnibErrorJson = "{\"errorCode\":500,\"errorMessage\":\"RNIB error\"}"
62 InternalErrorJson = "{\"errorCode\":501,\"errorMessage\":\"Internal Server Error. Please try again later\"}"
63 AddEnbUrl = "/nodeb/enb"
67 ServedNrCellInformationRequiredFields = []string{"cellId", "choiceNrMode", "nrMode", "servedPlmns"}
68 NrNeighbourInformationRequiredFields = []string{"nrCgi", "choiceNrMode", "nrMode"}
69 AddEnbRequestRequiredFields = []string{"ranName", "enb", "globalNbId"}
70 UpdateEnbRequestRequiredFields = []string{"enb"}
71 GlobalIdRequiredFields = []string{"plmnId", "nbId"}
72 EnbRequiredFields = []string{"enbType", "servedCells"}
73 ServedCellRequiredFields = []string{"broadcastPlmns", "cellId", "choiceEutraMode", "eutraMode", "tac"}
76 type controllerGetNodebTestContext struct {
78 nodebInfo *entities.NodebInfo
80 expectedStatusCode int
81 expectedJsonResponse string
84 type controllerGetNodebIdListTestContext struct {
85 nodebIdList []*entities.NbIdentity
87 expectedStatusCode int
88 expectedJsonResponse string
91 type getNodebInfoResult struct {
92 nodebInfo *entities.NodebInfo
96 type updateGnbCellsParams struct {
100 type updateEnbCellsParams struct {
104 type saveNodebParams struct {
108 type addNbIdentityParams struct {
112 type removeServedCellsParams struct {
113 servedCellInfo []*entities.ServedCellInfo
117 type removeServedNrCellsParams struct {
118 servedNrCells []*entities.ServedNRCell
122 type controllerUpdateEnbTestContext struct {
123 getNodebInfoResult *getNodebInfoResult
124 removeServedCellsParams *removeServedCellsParams
125 updateEnbCellsParams *updateEnbCellsParams
126 requestBody map[string]interface{}
127 expectedStatusCode int
128 expectedJsonResponse string
131 type controllerUpdateGnbTestContext struct {
132 getNodebInfoResult *getNodebInfoResult
133 removeServedNrCellsParams *removeServedNrCellsParams
134 updateGnbCellsParams *updateGnbCellsParams
135 requestBody map[string]interface{}
136 expectedStatusCode int
137 expectedJsonResponse string
140 type controllerAddEnbTestContext struct {
141 getNodebInfoResult *getNodebInfoResult
142 saveNodebParams *saveNodebParams
143 addNbIdentityParams *addNbIdentityParams
144 requestBody map[string]interface{}
145 expectedStatusCode int
146 expectedJsonResponse string
149 type controllerDeleteEnbTestContext struct {
150 getNodebInfoResult *getNodebInfoResult
151 expectedStatusCode int
152 expectedJsonResponse string
155 func generateServedNrCells(cellIds ...string) []*entities.ServedNRCell {
157 servedNrCells := []*entities.ServedNRCell{}
159 for _, v := range cellIds {
160 servedNrCells = append(servedNrCells, &entities.ServedNRCell{ServedNrCellInformation: &entities.ServedNRCellInformation{
162 ChoiceNrMode: &entities.ServedNRCellInformation_ChoiceNRMode{
163 Fdd: &entities.ServedNRCellInformation_ChoiceNRMode_FddInfo{
167 NrMode: entities.Nr_FDD,
169 ServedPlmns: []string{"whatever"},
176 func generateServedCells(cellIds ...string) []*entities.ServedCellInfo {
178 var servedCells []*entities.ServedCellInfo
180 for i, v := range cellIds {
181 servedCells = append(servedCells, &entities.ServedCellInfo{
183 ChoiceEutraMode: &entities.ChoiceEUTRAMode{
184 Fdd: &entities.FddInfo{},
187 BroadcastPlmns: []string{"whatever"},
194 func buildNrNeighbourInformation(propToOmit string) map[string]interface{} {
195 ret := map[string]interface{}{
197 "choiceNrMode": map[string]interface{}{
198 "tdd": map[string]interface{}{},
204 if len(propToOmit) != 0 {
205 delete(ret, propToOmit)
211 func buildServedNrCellInformation(propToOmit string) map[string]interface{} {
212 ret := map[string]interface{}{
213 "cellId": "whatever",
214 "choiceNrMode": map[string]interface{}{
215 "fdd": map[string]interface{}{},
219 "servedPlmns": []interface{}{
224 if len(propToOmit) != 0 {
225 delete(ret, propToOmit)
231 func buildServedCell(propToOmit string) map[string]interface{} {
232 ret := map[string]interface{}{
233 "cellId": "whatever",
234 "choiceEutraMode": map[string]interface{}{
235 "fdd": map[string]interface{}{},
240 "broadcastPlmns": []interface{}{
245 if len(propToOmit) != 0 {
246 delete(ret, propToOmit)
252 func getUpdateEnbRequest(propToOmit string) map[string]interface{} {
253 ret := map[string]interface{}{
254 "enb": buildEnb(propToOmit),
257 if len(propToOmit) != 0 {
258 delete(ret, propToOmit)
264 func getAddEnbRequest(propToOmit string) map[string]interface{} {
265 ret := map[string]interface{}{
267 "globalNbId": buildGlobalNbId(""),
271 if len(propToOmit) != 0 {
272 delete(ret, propToOmit)
278 func buildEnb(propToOmit string) map[string]interface{} {
279 ret := map[string]interface{}{
281 "servedCells": []interface{}{
285 if len(propToOmit) != 0 {
286 delete(ret, propToOmit)
292 func buildGlobalNbId(propToOmit string) map[string]interface{} {
293 ret := map[string]interface{}{
294 "plmnId": "whatever",
298 if len(propToOmit) != 0 {
299 delete(ret, propToOmit)
305 func setupControllerTest(t *testing.T) (*NodebController, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.RmrMessengerMock, *mocks.E2TInstancesManagerMock, managers.RanListManager) {
307 config := configuration.ParseConfiguration()
309 rmrMessengerMock := &mocks.RmrMessengerMock{}
310 readerMock := &mocks.RnibReaderMock{}
312 writerMock := &mocks.RnibWriterMock{}
314 rnibDataService := services.NewRnibDataService(log, config, readerMock, writerMock)
315 rmrSender := getRmrSender(rmrMessengerMock, log)
316 e2tInstancesManager := &mocks.E2TInstancesManagerMock{}
317 httpClientMock := &mocks.HttpClientMock{}
318 rmClient := clients.NewRoutingManagerClient(log, config, httpClientMock)
319 ranListManager := managers.NewRanListManager(log, rnibDataService)
320 ranAlarmService := &mocks.RanAlarmServiceMock{}
321 ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(log, rnibDataService, ranListManager, ranAlarmService)
322 nodebValidator := managers.NewNodebValidator()
323 updateEnbManager := managers.NewUpdateEnbManager(log, rnibDataService, nodebValidator)
325 handlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(log, rmrSender, config, rnibDataService, e2tInstancesManager, rmClient, ranConnectStatusChangeManager, nodebValidator, updateEnbManager, ranListManager)
326 controller := NewNodebController(log, handlerProvider)
327 return controller, readerMock, writerMock, rmrMessengerMock, e2tInstancesManager, ranListManager
330 func setupDeleteEnbControllerTest(t *testing.T, preAddNbIdentity bool) (*NodebController, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *entities.NbIdentity) {
332 config := configuration.ParseConfiguration()
334 rmrMessengerMock := &mocks.RmrMessengerMock{}
335 readerMock := &mocks.RnibReaderMock{}
337 writerMock := &mocks.RnibWriterMock{}
339 rnibDataService := services.NewRnibDataService(log, config, readerMock, writerMock)
340 rmrSender := getRmrSender(rmrMessengerMock, log)
341 e2tInstancesManager := &mocks.E2TInstancesManagerMock{}
342 httpClientMock := &mocks.HttpClientMock{}
343 rmClient := clients.NewRoutingManagerClient(log, config, httpClientMock)
344 ranListManager := managers.NewRanListManager(log, rnibDataService)
345 var nbIdentity *entities.NbIdentity
346 if preAddNbIdentity {
347 nbIdentity = &entities.NbIdentity{InventoryName: RanName, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
348 writerMock.On("AddNbIdentity", entities.Node_ENB, nbIdentity).Return(nil)
349 ranListManager.AddNbIdentity(entities.Node_ENB, nbIdentity)
351 ranAlarmService := &mocks.RanAlarmServiceMock{}
352 ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(log, rnibDataService, ranListManager, ranAlarmService)
353 nodebValidator := managers.NewNodebValidator()
354 updateEnbManager := managers.NewUpdateEnbManager(log, rnibDataService, nodebValidator)
356 handlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(log, rmrSender, config, rnibDataService, e2tInstancesManager, rmClient, ranConnectStatusChangeManager, nodebValidator, updateEnbManager, ranListManager)
357 controller := NewNodebController(log, handlerProvider)
358 return controller, readerMock, writerMock, nbIdentity
361 func TestShutdownHandlerRnibError(t *testing.T) {
362 controller, _, _, _, e2tInstancesManagerMock, _ := setupControllerTest(t)
363 e2tInstancesManagerMock.On("GetE2TAddresses").Return([]string{}, e2managererrors.NewRnibDbError())
365 writer := httptest.NewRecorder()
367 controller.Shutdown(writer, tests.GetHttpRequest())
369 var errorResponse = parseJsonRequest(t, writer.Body)
371 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
372 assert.Equal(t, errorResponse.Code, e2managererrors.NewRnibDbError().Code)
375 func TestSetGeneralConfigurationHandlerRnibError(t *testing.T) {
376 controller, readerMock, _, _, _ , _:= setupControllerTest(t)
378 configuration := &entities.GeneralConfiguration{}
379 readerMock.On("GetGeneralConfiguration").Return(configuration, e2managererrors.NewRnibDbError())
381 writer := httptest.NewRecorder()
383 httpRequest, _ := http.NewRequest("PUT", "https://localhost:3800/v1/nodeb/parameters", strings.NewReader("{\"enableRic\":false}"))
385 controller.SetGeneralConfiguration(writer, httpRequest)
387 var errorResponse = parseJsonRequest(t, writer.Body)
389 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
390 assert.Equal(t, e2managererrors.NewRnibDbError().Code, errorResponse.Code)
393 func TestSetGeneralConfigurationInvalidJson(t *testing.T) {
394 controller, _, _, _, _, _ := setupControllerTest(t)
396 writer := httptest.NewRecorder()
398 httpRequest, _ := http.NewRequest("PUT", "https://localhost:3800/v1/nodeb/parameters", strings.NewReader("{\"enableRic\":false, \"someValue\":false}"))
400 controller.SetGeneralConfiguration(writer, httpRequest)
402 var errorResponse = parseJsonRequest(t, writer.Body)
404 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
405 assert.Equal(t, e2managererrors.NewInvalidJsonError().Code, errorResponse.Code)
408 func controllerGetNodebTestExecuter(t *testing.T, context *controllerGetNodebTestContext) {
409 controller, readerMock, _, _, _, _ := setupControllerTest(t)
410 writer := httptest.NewRecorder()
411 readerMock.On("GetNodeb", context.ranName).Return(context.nodebInfo, context.rnibError)
412 req, _ := http.NewRequest(http.MethodGet, "/nodeb", nil)
413 req = mux.SetURLVars(req, map[string]string{"ranName": context.ranName})
414 controller.GetNodeb(writer, req)
415 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
416 bodyBytes, _ := ioutil.ReadAll(writer.Body)
417 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
420 func controllerGetNodebIdListTestExecuter(t *testing.T, context *controllerGetNodebIdListTestContext) {
421 controller, readerMock, _, _, _, ranListManager := setupControllerTest(t)
422 writer := httptest.NewRecorder()
423 readerMock.On("GetListNodebIds").Return(context.nodebIdList, context.rnibError)
425 err := ranListManager.InitNbIdentityMap()
427 t.Errorf("Error cannot init identity")
430 req, _ := http.NewRequest(http.MethodGet, "/nodeb/states", nil)
431 controller.GetNodebIdList(writer, req)
432 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
433 bodyBytes, _ := ioutil.ReadAll(writer.Body)
434 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
437 func activateControllerUpdateEnbMocks(context *controllerUpdateEnbTestContext, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock, updateEnbRequest *models.UpdateEnbRequest) {
438 if context.getNodebInfoResult != nil {
439 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
442 if context.removeServedCellsParams != nil {
443 writerMock.On("RemoveServedCells", RanName, context.removeServedCellsParams.servedCellInfo).Return(context.removeServedCellsParams.err)
446 if context.updateEnbCellsParams != nil {
447 updatedNodebInfo := *context.getNodebInfoResult.nodebInfo
448 updatedNodebInfo.Configuration = &entities.NodebInfo_Enb{Enb: updateEnbRequest.Enb}
450 writerMock.On("UpdateEnb", &updatedNodebInfo, updateEnbRequest.Enb.ServedCells).Return(context.updateEnbCellsParams.err)
454 func activateControllerUpdateGnbMocks(context *controllerUpdateGnbTestContext, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
455 if context.getNodebInfoResult != nil {
456 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
459 if context.removeServedNrCellsParams != nil {
460 writerMock.On("RemoveServedNrCells", RanName, context.removeServedNrCellsParams.servedNrCells).Return(context.removeServedNrCellsParams.err)
463 if context.updateGnbCellsParams != nil {
464 updatedNodebInfo := *context.getNodebInfoResult.nodebInfo
465 gnb := entities.Gnb{}
466 _ = jsonpb.Unmarshal(getJsonRequestAsBuffer(context.requestBody), &gnb)
467 updatedGnb := *updatedNodebInfo.GetGnb()
468 updatedGnb.ServedNrCells = gnb.ServedNrCells
469 writerMock.On("UpdateGnbCells", &updatedNodebInfo, gnb.ServedNrCells).Return(context.updateGnbCellsParams.err)
473 func assertControllerUpdateGnb(t *testing.T, context *controllerUpdateGnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
474 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
475 bodyBytes, _ := ioutil.ReadAll(writer.Body)
476 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
477 readerMock.AssertExpectations(t)
478 writerMock.AssertExpectations(t)
481 func assertControllerUpdateEnb(t *testing.T, context *controllerUpdateEnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
482 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
483 bodyBytes, _ := ioutil.ReadAll(writer.Body)
484 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
485 readerMock.AssertExpectations(t)
486 writerMock.AssertExpectations(t)
489 func assertControllerAddEnb(t *testing.T, context *controllerAddEnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
490 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
491 bodyBytes, _ := ioutil.ReadAll(writer.Body)
492 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
493 readerMock.AssertExpectations(t)
494 writerMock.AssertExpectations(t)
497 func assertControllerDeleteEnb(t *testing.T, context *controllerDeleteEnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
498 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
499 bodyBytes, _ := ioutil.ReadAll(writer.Body)
500 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
501 readerMock.AssertExpectations(t)
502 writerMock.AssertExpectations(t)
505 func buildUpdateEnbRequest(context *controllerUpdateEnbTestContext) *http.Request {
506 updateEnbUrl := fmt.Sprintf("/nodeb/enb/%s", RanName)
507 requestBody := getJsonRequestAsBuffer(context.requestBody)
508 req, _ := http.NewRequest(http.MethodPut, updateEnbUrl, requestBody)
509 req.Header.Set("Content-Type", "application/json")
510 req = mux.SetURLVars(req, map[string]string{"ranName": RanName})
514 func buildUpdateGnbRequest(context *controllerUpdateGnbTestContext) *http.Request {
515 updateGnbUrl := fmt.Sprintf("/nodeb/%s/update", RanName)
516 requestBody := getJsonRequestAsBuffer(context.requestBody)
517 req, _ := http.NewRequest(http.MethodPut, updateGnbUrl, requestBody)
518 req.Header.Set("Content-Type", "application/json")
519 req = mux.SetURLVars(req, map[string]string{"ranName": RanName})
523 func buildAddEnbRequest(context *controllerAddEnbTestContext) *http.Request {
524 requestBody := getJsonRequestAsBuffer(context.requestBody)
525 req, _ := http.NewRequest(http.MethodPost, AddEnbUrl, requestBody)
526 req.Header.Set("Content-Type", "application/json")
530 func controllerUpdateEnbTestExecuter(t *testing.T, context *controllerUpdateEnbTestContext) {
531 controller, readerMock, writerMock, _, _, _ := setupControllerTest(t)
532 writer := httptest.NewRecorder()
534 r := buildUpdateEnbRequest(context)
535 body, _ := ioutil.ReadAll(io.LimitReader(r.Body, LimitRequest))
537 updateEnbRequest := models.UpdateEnbRequest{}
538 _ = json.Unmarshal(body, &updateEnbRequest)
540 activateControllerUpdateEnbMocks(context, readerMock, writerMock, &updateEnbRequest)
541 r = buildUpdateEnbRequest(context)
544 controller.UpdateEnb(writer, r)
546 assertControllerUpdateEnb(t, context, writer, readerMock, writerMock)
549 func controllerUpdateGnbTestExecuter(t *testing.T, context *controllerUpdateGnbTestContext) {
550 controller, readerMock, writerMock, _, _, _ := setupControllerTest(t)
551 writer := httptest.NewRecorder()
553 activateControllerUpdateGnbMocks(context, readerMock, writerMock)
554 req := buildUpdateGnbRequest(context)
555 controller.UpdateGnb(writer, req)
556 assertControllerUpdateGnb(t, context, writer, readerMock, writerMock)
559 func activateControllerAddEnbMocks(context *controllerAddEnbTestContext, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock, addEnbRequest *models.AddEnbRequest) {
560 if context.getNodebInfoResult != nil {
561 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
564 if context.saveNodebParams != nil {
565 nodebInfo := entities.NodebInfo{
566 RanName: addEnbRequest.RanName,
567 Ip: addEnbRequest.Ip,
568 Port: addEnbRequest.Port,
569 NodeType: entities.Node_ENB,
570 GlobalNbId: addEnbRequest.GlobalNbId,
571 Configuration: &entities.NodebInfo_Enb{Enb: addEnbRequest.Enb},
572 ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,
575 writerMock.On("SaveNodeb", &nodebInfo).Return(context.saveNodebParams.err)
578 if context.addNbIdentityParams != nil {
579 nbIdentity := entities.NbIdentity{InventoryName: addEnbRequest.RanName, GlobalNbId: addEnbRequest.GlobalNbId, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED}
580 writerMock.On("AddNbIdentity", entities.Node_ENB, &nbIdentity).Return(context.addNbIdentityParams.err)
584 func controllerAddEnbTestExecuter(t *testing.T, context *controllerAddEnbTestContext) {
585 controller, readerMock, writerMock, _, _, _ := setupControllerTest(t)
586 writer := httptest.NewRecorder()
587 r := buildAddEnbRequest(context)
588 body, _ := ioutil.ReadAll(io.LimitReader(r.Body, LimitRequest))
590 addEnbRequest := models.AddEnbRequest{}
592 _ = json.Unmarshal(body, &addEnbRequest)
593 activateControllerAddEnbMocks(context, readerMock, writerMock, &addEnbRequest)
594 r = buildAddEnbRequest(context)
596 controller.AddEnb(writer, r)
597 assertControllerAddEnb(t, context, writer, readerMock, writerMock)
600 func controllerDeleteEnbTestExecuter(t *testing.T, context *controllerDeleteEnbTestContext, preAddNbIdentity bool) {
601 controller, readerMock, writerMock, nbIdentity := setupDeleteEnbControllerTest(t, preAddNbIdentity)
602 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
603 if context.getNodebInfoResult.rnibError == nil && context.getNodebInfoResult.nodebInfo.GetNodeType() == entities.Node_ENB {
604 writerMock.On("RemoveEnb", context.getNodebInfoResult.nodebInfo).Return(nil)
605 if preAddNbIdentity {
606 writerMock.On("RemoveNbIdentity", entities.Node_ENB, nbIdentity).Return(nil)
609 writer := httptest.NewRecorder()
610 r, _ := http.NewRequest(http.MethodDelete, AddEnbUrl+"/"+RanName, nil)
611 r.Header.Set("Content-Type", "application/json")
612 r = mux.SetURLVars(r, map[string]string{"ranName": RanName})
613 controller.DeleteEnb(writer, r)
614 assertControllerDeleteEnb(t, context, writer, readerMock, writerMock)
617 func TestControllerUpdateGnbEmptyServedNrCells(t *testing.T) {
618 context := controllerUpdateGnbTestContext{
619 getNodebInfoResult: nil,
620 requestBody: map[string]interface{}{
621 "servedNrCells": []interface{}{
624 expectedStatusCode: http.StatusBadRequest,
625 expectedJsonResponse: ValidationFailureJson,
628 controllerUpdateGnbTestExecuter(t, &context)
631 func TestControllerUpdateGnbMissingServedNrCellInformation(t *testing.T) {
632 context := controllerUpdateGnbTestContext{
633 getNodebInfoResult: nil,
634 requestBody: map[string]interface{}{
635 "servedNrCells": []interface{}{
636 map[string]interface{}{
637 "servedNrCellInformation": nil,
641 expectedStatusCode: http.StatusBadRequest,
642 expectedJsonResponse: ValidationFailureJson,
645 controllerUpdateGnbTestExecuter(t, &context)
648 func TestControllerUpdateGnbMissingServedNrCellRequiredProp(t *testing.T) {
650 for _, v := range ServedNrCellInformationRequiredFields {
651 context := controllerUpdateGnbTestContext{
652 getNodebInfoResult: nil,
653 requestBody: map[string]interface{}{
654 "servedNrCells": []interface{}{
655 map[string]interface{}{
656 "servedNrCellInformation": buildServedNrCellInformation(v),
660 expectedStatusCode: http.StatusBadRequest,
661 expectedJsonResponse: ValidationFailureJson,
664 controllerUpdateGnbTestExecuter(t, &context)
668 func TestControllerUpdateGnbMissingServedNrCellFddOrTdd(t *testing.T) {
670 servedNrCellInformation := buildServedNrCellInformation("")
671 servedNrCellInformation["choiceNrMode"] = map[string]interface{}{}
673 context := controllerUpdateGnbTestContext{
674 getNodebInfoResult: nil,
675 requestBody: map[string]interface{}{
676 "servedNrCells": []interface{}{
677 map[string]interface{}{
678 "servedNrCellInformation": servedNrCellInformation,
682 expectedStatusCode: http.StatusBadRequest,
683 expectedJsonResponse: ValidationFailureJson,
686 controllerUpdateGnbTestExecuter(t, &context)
689 func TestControllerUpdateGnbMissingNeighbourInfoFddOrTdd(t *testing.T) {
691 nrNeighbourInfo := buildNrNeighbourInformation("")
692 nrNeighbourInfo["choiceNrMode"] = map[string]interface{}{}
694 context := controllerUpdateGnbTestContext{
695 getNodebInfoResult: nil,
696 requestBody: map[string]interface{}{
697 "servedNrCells": []interface{}{
698 map[string]interface{}{
699 "servedNrCellInformation": buildServedNrCellInformation(""),
700 "nrNeighbourInfos": []interface{}{
706 expectedStatusCode: http.StatusBadRequest,
707 expectedJsonResponse: ValidationFailureJson,
710 controllerUpdateGnbTestExecuter(t, &context)
713 func TestControllerUpdateGnbMissingNrNeighbourInformationRequiredProp(t *testing.T) {
715 for _, v := range NrNeighbourInformationRequiredFields {
716 context := controllerUpdateGnbTestContext{
717 getNodebInfoResult: nil,
718 requestBody: map[string]interface{}{
719 "servedNrCells": []interface{}{
720 map[string]interface{}{
721 "servedNrCellInformation": buildServedNrCellInformation(""),
722 "nrNeighbourInfos": []interface{}{
723 buildNrNeighbourInformation(v),
728 expectedStatusCode: http.StatusBadRequest,
729 expectedJsonResponse: ValidationFailureJson,
732 controllerUpdateGnbTestExecuter(t, &context)
736 func TestControllerUpdateGnbValidServedNrCellInformationGetNodebNotFound(t *testing.T) {
737 context := controllerUpdateGnbTestContext{
738 getNodebInfoResult: &getNodebInfoResult{
740 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
742 requestBody: map[string]interface{}{
743 "servedNrCells": []interface{}{
744 map[string]interface{}{
745 "servedNrCellInformation": buildServedNrCellInformation(""),
749 expectedStatusCode: http.StatusNotFound,
750 expectedJsonResponse: ResourceNotFoundJson,
753 controllerUpdateGnbTestExecuter(t, &context)
756 func TestControllerUpdateGnbValidServedNrCellInformationGetNodebInternalError(t *testing.T) {
757 context := controllerUpdateGnbTestContext{
758 getNodebInfoResult: &getNodebInfoResult{
760 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
762 requestBody: map[string]interface{}{
763 "servedNrCells": []interface{}{
764 map[string]interface{}{
765 "servedNrCellInformation": buildServedNrCellInformation(""),
769 expectedStatusCode: http.StatusInternalServerError,
770 expectedJsonResponse: RnibErrorJson,
773 controllerUpdateGnbTestExecuter(t, &context)
776 func TestControllerUpdateGnbGetNodebSuccessInvalidGnbConfiguration(t *testing.T) {
777 context := controllerUpdateGnbTestContext{
778 getNodebInfoResult: &getNodebInfoResult{
779 nodebInfo: &entities.NodebInfo{
781 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
782 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
786 requestBody: map[string]interface{}{
787 "servedNrCells": []interface{}{
788 map[string]interface{}{
789 "servedNrCellInformation": buildServedNrCellInformation(""),
790 "nrNeighbourInfos": []interface{}{
791 buildNrNeighbourInformation(""),
796 expectedStatusCode: http.StatusInternalServerError,
797 expectedJsonResponse: InternalErrorJson,
800 controllerUpdateGnbTestExecuter(t, &context)
803 func TestControllerUpdateGnbGetNodebSuccessRemoveServedNrCellsFailure(t *testing.T) {
804 oldServedNrCells := generateServedNrCells("whatever1", "whatever2")
805 context := controllerUpdateGnbTestContext{
806 removeServedNrCellsParams: &removeServedNrCellsParams{
807 err: common.NewInternalError(errors.New("#writer.UpdateGnbCells - Internal Error")),
808 servedNrCells: oldServedNrCells,
810 getNodebInfoResult: &getNodebInfoResult{
811 nodebInfo: &entities.NodebInfo{
813 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
814 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
815 Configuration: &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{ServedNrCells: oldServedNrCells}},
819 requestBody: map[string]interface{}{
820 "servedNrCells": []interface{}{
821 map[string]interface{}{
822 "servedNrCellInformation": buildServedNrCellInformation(""),
823 "nrNeighbourInfos": []interface{}{
824 buildNrNeighbourInformation(""),
829 expectedStatusCode: http.StatusInternalServerError,
830 expectedJsonResponse: RnibErrorJson,
833 controllerUpdateGnbTestExecuter(t, &context)
836 func TestControllerUpdateGnbGetNodebSuccessUpdateGnbCellsFailure(t *testing.T) {
837 oldServedNrCells := generateServedNrCells("whatever1", "whatever2")
838 context := controllerUpdateGnbTestContext{
839 removeServedNrCellsParams: &removeServedNrCellsParams{
841 servedNrCells: oldServedNrCells,
843 updateGnbCellsParams: &updateGnbCellsParams{
844 err: common.NewInternalError(errors.New("#writer.UpdateGnbCells - Internal Error")),
846 getNodebInfoResult: &getNodebInfoResult{
847 nodebInfo: &entities.NodebInfo{
849 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
850 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
851 Configuration: &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{ServedNrCells: oldServedNrCells}},
855 requestBody: map[string]interface{}{
856 "servedNrCells": []interface{}{
857 map[string]interface{}{
858 "servedNrCellInformation": buildServedNrCellInformation(""),
859 "nrNeighbourInfos": []interface{}{
860 buildNrNeighbourInformation(""),
865 expectedStatusCode: http.StatusInternalServerError,
866 expectedJsonResponse: RnibErrorJson,
869 controllerUpdateGnbTestExecuter(t, &context)
872 func TestControllerUpdateGnbSuccess(t *testing.T) {
873 context := controllerUpdateGnbTestContext{
874 updateGnbCellsParams: &updateGnbCellsParams{
877 getNodebInfoResult: &getNodebInfoResult{
878 nodebInfo: &entities.NodebInfo{
880 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
881 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
882 Configuration: &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{}},
886 requestBody: map[string]interface{}{
887 "servedNrCells": []interface{}{
888 map[string]interface{}{
889 "servedNrCellInformation": buildServedNrCellInformation(""),
890 "nrNeighbourInfos": []interface{}{
891 buildNrNeighbourInformation(""),
896 expectedStatusCode: http.StatusOK,
897 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\"}",
900 controllerUpdateGnbTestExecuter(t, &context)
903 func TestControllerUpdateEnbInvalidRequest(t *testing.T) {
904 controller, _, _, _, _, _ := setupControllerTest(t)
906 writer := httptest.NewRecorder()
907 invalidJson := strings.NewReader("{enb:\"whatever\"")
909 updateEnbUrl := fmt.Sprintf("/nodeb/enb/%s", RanName)
910 req, _ := http.NewRequest(http.MethodPut, updateEnbUrl, invalidJson)
911 req.Header.Set("Content-Type", "application/json")
912 req = mux.SetURLVars(req, map[string]string{"ranName": RanName})
914 controller.UpdateEnb(writer, req)
916 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
917 bodyBytes, _ := ioutil.ReadAll(writer.Body)
918 assert.Equal(t, CorruptedJson, string(bodyBytes))
921 func TestControllerUpdateEnbEmptyEnbType(t *testing.T) {
922 context := controllerUpdateEnbTestContext{
923 getNodebInfoResult: nil,
924 requestBody: getUpdateEnbRequest(EnbRequiredFields[0]),
925 expectedStatusCode: http.StatusBadRequest,
926 expectedJsonResponse: ValidationFailureJson,
929 controllerUpdateEnbTestExecuter(t, &context)
932 func TestControllerUpdateEnbEmptyServedCells(t *testing.T) {
933 context := controllerUpdateEnbTestContext{
934 getNodebInfoResult: nil,
935 requestBody: getUpdateEnbRequest(EnbRequiredFields[1]),
936 expectedStatusCode: http.StatusBadRequest,
937 expectedJsonResponse: ValidationFailureJson,
940 controllerUpdateEnbTestExecuter(t, &context)
943 func TestControllerUpdateEnbMissingEnb(t *testing.T) {
944 context := controllerUpdateEnbTestContext{
945 getNodebInfoResult: nil,
946 requestBody: getUpdateEnbRequest(UpdateEnbRequestRequiredFields[0]),
947 expectedStatusCode: http.StatusBadRequest,
948 expectedJsonResponse: ValidationFailureJson,
951 controllerUpdateEnbTestExecuter(t, &context)
954 func TestControllerUpdateEnbValidServedCellsGetNodebNotFound(t *testing.T) {
955 context := controllerUpdateEnbTestContext{
956 getNodebInfoResult: &getNodebInfoResult{
958 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
960 requestBody: getUpdateEnbRequest(""),
961 expectedStatusCode: http.StatusNotFound,
962 expectedJsonResponse: ResourceNotFoundJson,
965 controllerUpdateEnbTestExecuter(t, &context)
968 func TestControllerUpdateEnbValidServedCellsGetNodebInternalError(t *testing.T) {
969 context := controllerUpdateEnbTestContext{
970 getNodebInfoResult: &getNodebInfoResult{
972 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
974 requestBody: getUpdateEnbRequest(""),
975 expectedStatusCode: http.StatusInternalServerError,
976 expectedJsonResponse: RnibErrorJson,
979 controllerUpdateEnbTestExecuter(t, &context)
982 func TestControllerUpdateEnbGetNodebSuccessGnbTypeFailure(t *testing.T) {
983 oldServedCells := generateServedCells("whatever1", "whatever2")
984 context := controllerUpdateEnbTestContext{
985 getNodebInfoResult: &getNodebInfoResult{
986 nodebInfo: &entities.NodebInfo{
988 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
989 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
990 NodeType: entities.Node_GNB,
991 Configuration: &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells}},
995 requestBody: getUpdateEnbRequest(""),
996 expectedStatusCode: http.StatusBadRequest,
997 expectedJsonResponse: ValidationFailureJson,
1000 controllerUpdateEnbTestExecuter(t, &context)
1003 func TestControllerUpdateEnbGetNodebSuccessRemoveServedCellsFailure(t *testing.T) {
1004 oldServedCells := generateServedCells("whatever1", "whatever2")
1005 context := controllerUpdateEnbTestContext{
1006 removeServedCellsParams: &removeServedCellsParams{
1007 err: common.NewInternalError(errors.New("#writer.RemoveServedCells - Internal Error")),
1008 servedCellInfo: oldServedCells,
1010 getNodebInfoResult: &getNodebInfoResult{
1011 nodebInfo: &entities.NodebInfo{
1013 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
1014 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1015 NodeType: entities.Node_ENB,
1016 Configuration: &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells}},
1020 requestBody: getUpdateEnbRequest(""),
1021 expectedStatusCode: http.StatusInternalServerError,
1022 expectedJsonResponse: RnibErrorJson,
1025 controllerUpdateEnbTestExecuter(t, &context)
1028 func TestControllerUpdateEnbGetNodebSuccessUpdateEnbFailure(t *testing.T) {
1029 oldServedCells := generateServedCells("whatever1", "whatever2")
1030 context := controllerUpdateEnbTestContext{
1031 removeServedCellsParams: &removeServedCellsParams{
1033 servedCellInfo: oldServedCells,
1035 updateEnbCellsParams: &updateEnbCellsParams{
1036 err: common.NewInternalError(errors.New("#writer.UpdateEnb - Internal Error")),
1038 getNodebInfoResult: &getNodebInfoResult{
1039 nodebInfo: &entities.NodebInfo{
1041 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
1042 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1043 NodeType: entities.Node_ENB,
1044 Configuration: &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells, EnbType: entities.EnbType_MACRO_ENB}},
1048 requestBody: getUpdateEnbRequest(""),
1049 expectedStatusCode: http.StatusInternalServerError,
1050 expectedJsonResponse: RnibErrorJson,
1053 controllerUpdateEnbTestExecuter(t, &context)
1056 func TestControllerUpdateEnbSuccess(t *testing.T) {
1057 oldServedCells := generateServedCells("whatever1", "whatever2")
1058 context := controllerUpdateEnbTestContext{
1059 removeServedCellsParams: &removeServedCellsParams{
1061 servedCellInfo: oldServedCells,
1063 updateEnbCellsParams: &updateEnbCellsParams{
1066 getNodebInfoResult: &getNodebInfoResult{
1067 nodebInfo: &entities.NodebInfo{
1069 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
1070 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1071 NodeType: entities.Node_ENB,
1072 Configuration: &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells, EnbType: entities.EnbType_MACRO_ENB}},
1076 requestBody: getUpdateEnbRequest(""),
1077 expectedStatusCode: http.StatusOK,
1078 expectedJsonResponse: "{\"ranName\":\"test\",\"connectionStatus\":\"CONNECTED\",\"nodeType\":\"ENB\",\"enb\":{\"enbType\":\"MACRO_ENB\",\"servedCells\":[{\"pci\":1,\"cellId\":\"whatever\",\"tac\":\"whatever3\",\"broadcastPlmns\":[\"whatever\"],\"choiceEutraMode\":{\"fdd\":{}},\"eutraMode\":\"FDD\"}]},\"associatedE2tInstanceAddress\":\"10.0.2.15:38000\"}",
1081 controllerUpdateEnbTestExecuter(t, &context)
1084 func TestControllerAddEnbGetNodebInternalError(t *testing.T) {
1085 context := controllerAddEnbTestContext{
1086 getNodebInfoResult: &getNodebInfoResult{
1088 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
1090 requestBody: getAddEnbRequest(""),
1091 expectedStatusCode: http.StatusInternalServerError,
1092 expectedJsonResponse: RnibErrorJson,
1095 controllerAddEnbTestExecuter(t, &context)
1098 func TestControllerAddEnbNodebExistsFailure(t *testing.T) {
1099 context := controllerAddEnbTestContext{
1100 getNodebInfoResult: &getNodebInfoResult{
1101 nodebInfo: &entities.NodebInfo{},
1104 requestBody: getAddEnbRequest(""),
1105 expectedStatusCode: http.StatusBadRequest,
1106 expectedJsonResponse: NodebExistsJson,
1109 controllerAddEnbTestExecuter(t, &context)
1112 func TestControllerAddEnbSaveNodebFailure(t *testing.T) {
1113 context := controllerAddEnbTestContext{
1114 saveNodebParams: &saveNodebParams{
1115 err: common.NewInternalError(errors.New("#reader.SaveeNodeb - Internal Error")),
1117 getNodebInfoResult: &getNodebInfoResult{
1119 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1121 requestBody: getAddEnbRequest(""),
1122 expectedStatusCode: http.StatusInternalServerError,
1123 expectedJsonResponse: RnibErrorJson,
1126 controllerAddEnbTestExecuter(t, &context)
1129 func TestControllerAddEnbAddNbIdentityFailure(t *testing.T) {
1130 context := controllerAddEnbTestContext{
1131 saveNodebParams: &saveNodebParams{
1134 addNbIdentityParams: &addNbIdentityParams{
1135 err: common.NewInternalError(errors.New("#writer.addNbIdentity - Internal Error")),
1137 getNodebInfoResult: &getNodebInfoResult{
1139 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1141 requestBody: getAddEnbRequest(""),
1142 expectedStatusCode: http.StatusInternalServerError,
1143 expectedJsonResponse: RnibErrorJson,
1146 controllerAddEnbTestExecuter(t, &context)
1149 func TestControllerAddEnbMissingRequiredRequestProps(t *testing.T) {
1151 for _, v := range AddEnbRequestRequiredFields {
1152 context := controllerAddEnbTestContext{
1153 requestBody: getAddEnbRequest(v),
1154 expectedStatusCode: http.StatusBadRequest,
1155 expectedJsonResponse: ValidationFailureJson,
1158 controllerAddEnbTestExecuter(t, &context)
1162 func TestControllerAddEnbInvalidRequest(t *testing.T) {
1163 controller, _, _, _, _, _ := setupControllerTest(t)
1164 writer := httptest.NewRecorder()
1166 // Invalid json: attribute name without quotes (should be "cause":).
1167 invalidJson := strings.NewReader("{ranName:\"whatever\"")
1168 req, _ := http.NewRequest(http.MethodPost, AddEnbUrl, invalidJson)
1170 controller.AddEnb(writer, req)
1171 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1172 bodyBytes, _ := ioutil.ReadAll(writer.Body)
1173 assert.Equal(t, CorruptedJson, string(bodyBytes))
1177 func TestControllerAddEnbMissingRequiredGlobalNbIdProps(t *testing.T) {
1179 r := getAddEnbRequest("")
1181 for _, v := range GlobalIdRequiredFields {
1182 r["globalNbId"] = buildGlobalNbId(v)
1184 context := controllerAddEnbTestContext{
1186 expectedStatusCode: http.StatusBadRequest,
1187 expectedJsonResponse: ValidationFailureJson,
1190 controllerAddEnbTestExecuter(t, &context)
1194 func TestControllerAddEnbMissingRequiredEnbProps(t *testing.T) {
1196 r := getAddEnbRequest("")
1198 for _, v := range EnbRequiredFields {
1199 r["enb"] = buildEnb(v)
1201 context := controllerAddEnbTestContext{
1203 expectedStatusCode: http.StatusBadRequest,
1204 expectedJsonResponse: ValidationFailureJson,
1207 controllerAddEnbTestExecuter(t, &context)
1211 func TestControllerUpdateEnbMissingRequiredServedCellProps(t *testing.T) {
1213 r := getUpdateEnbRequest("")
1215 for _, v := range ServedCellRequiredFields {
1218 enbMap, _ := enb.(map[string]interface{})
1220 enbMap["servedCells"] = []interface{}{
1224 context := controllerUpdateEnbTestContext{
1226 expectedStatusCode: http.StatusBadRequest,
1227 expectedJsonResponse: ValidationFailureJson,
1230 controllerUpdateEnbTestExecuter(t, &context)
1234 func TestControllerAddEnbMissingRequiredServedCellProps(t *testing.T) {
1236 r := getAddEnbRequest("")
1238 for _, v := range ServedCellRequiredFields {
1241 enbMap, _ := enb.(map[string]interface{})
1243 enbMap["servedCells"] = []interface{}{
1247 context := controllerAddEnbTestContext{
1249 expectedStatusCode: http.StatusBadRequest,
1250 expectedJsonResponse: ValidationFailureJson,
1253 controllerAddEnbTestExecuter(t, &context)
1257 func TestControllerAddEnbSuccess(t *testing.T) {
1258 context := controllerAddEnbTestContext{
1259 saveNodebParams: &saveNodebParams{
1262 addNbIdentityParams: &addNbIdentityParams{
1265 getNodebInfoResult: &getNodebInfoResult{
1267 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1269 requestBody: getAddEnbRequest(""),
1270 expectedStatusCode: http.StatusCreated,
1271 expectedJsonResponse: "{\"ranName\":\"test\",\"connectionStatus\":\"DISCONNECTED\",\"globalNbId\":{\"plmnId\":\"whatever\",\"nbId\":\"whatever2\"},\"nodeType\":\"ENB\",\"enb\":{\"enbType\":\"MACRO_ENB\",\"servedCells\":[{\"pci\":1,\"cellId\":\"whatever\",\"tac\":\"whatever3\",\"broadcastPlmns\":[\"whatever\"],\"choiceEutraMode\":{\"fdd\":{}},\"eutraMode\":\"FDD\"}]}}",
1274 controllerAddEnbTestExecuter(t, &context)
1277 func TestControllerDeleteEnbGetNodebInternalError(t *testing.T) {
1278 context := controllerDeleteEnbTestContext{
1279 getNodebInfoResult: &getNodebInfoResult{
1281 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
1283 expectedStatusCode: http.StatusInternalServerError,
1284 expectedJsonResponse: RnibErrorJson,
1287 controllerDeleteEnbTestExecuter(t, &context, false)
1290 func TestControllerDeleteEnbNodebNotExistsFailure(t *testing.T) {
1291 context := controllerDeleteEnbTestContext{
1292 getNodebInfoResult: &getNodebInfoResult{
1294 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found"),
1296 expectedStatusCode: http.StatusNotFound,
1297 expectedJsonResponse: ResourceNotFoundJson,
1300 controllerDeleteEnbTestExecuter(t, &context, false)
1303 func TestControllerDeleteEnbNodebNotEnb(t *testing.T) {
1304 context := controllerDeleteEnbTestContext{
1305 getNodebInfoResult: &getNodebInfoResult{
1306 nodebInfo: &entities.NodebInfo{RanName: "ran1", NodeType: entities.Node_GNB, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED},
1309 expectedStatusCode: http.StatusBadRequest,
1310 expectedJsonResponse: ValidationFailureJson,
1313 controllerDeleteEnbTestExecuter(t, &context, false)
1316 func TestControllerDeleteEnbSuccess(t *testing.T) {
1317 context := controllerDeleteEnbTestContext{
1318 getNodebInfoResult: &getNodebInfoResult{
1319 nodebInfo: &entities.NodebInfo{RanName: RanName, NodeType: entities.Node_ENB, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED},
1322 expectedStatusCode: http.StatusNoContent,
1323 expectedJsonResponse: "",
1325 controllerDeleteEnbTestExecuter(t, &context, true)
1328 func getJsonRequestAsBuffer(requestJson map[string]interface{}) *bytes.Buffer {
1329 b := new(bytes.Buffer)
1330 _ = json.NewEncoder(b).Encode(requestJson)
1334 func TestControllerGetNodebSuccess(t *testing.T) {
1337 context := controllerGetNodebTestContext{
1339 nodebInfo: &entities.NodebInfo{RanName: ranName, Ip: "10.0.2.15", Port: 1234},
1340 rnibError: rnibError,
1341 expectedStatusCode: http.StatusOK,
1342 expectedJsonResponse: fmt.Sprintf("{\"ranName\":\"%s\",\"ip\":\"10.0.2.15\",\"port\":1234}", ranName),
1345 controllerGetNodebTestExecuter(t, &context)
1348 func TestControllerGetNodebNotFound(t *testing.T) {
1351 var nodebInfo *entities.NodebInfo
1352 context := controllerGetNodebTestContext{
1354 nodebInfo: nodebInfo,
1355 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1356 expectedStatusCode: http.StatusNotFound,
1357 expectedJsonResponse: ResourceNotFoundJson,
1360 controllerGetNodebTestExecuter(t, &context)
1363 func TestControllerGetNodebInternal(t *testing.T) {
1365 var nodebInfo *entities.NodebInfo
1366 context := controllerGetNodebTestContext{
1368 nodebInfo: nodebInfo,
1369 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
1370 expectedStatusCode: http.StatusInternalServerError,
1371 expectedJsonResponse: RnibErrorJson,
1374 controllerGetNodebTestExecuter(t, &context)
1377 func TestControllerGetNodebIdListSuccess(t *testing.T) {
1379 nodebIdList := []*entities.NbIdentity{
1380 {InventoryName: "test1", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}},
1381 {InventoryName: "test2", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId2", NbId: "nbId2"}},
1384 context := controllerGetNodebIdListTestContext{
1385 nodebIdList: nodebIdList,
1386 rnibError: rnibError,
1387 expectedStatusCode: http.StatusOK,
1388 expectedJsonResponse: "[{\"inventoryName\":\"test1\",\"globalNbId\":{\"plmnId\":\"plmnId1\",\"nbId\":\"nbId1\"}},{\"inventoryName\":\"test2\",\"globalNbId\":{\"plmnId\":\"plmnId2\",\"nbId\":\"nbId2\"}}]",
1391 controllerGetNodebIdListTestExecuter(t, &context)
1394 func TestControllerGetNodebIdListEmptySuccess(t *testing.T) {
1396 var nodebIdList []*entities.NbIdentity
1398 context := controllerGetNodebIdListTestContext{
1399 nodebIdList: nodebIdList,
1400 rnibError: rnibError,
1401 expectedStatusCode: http.StatusOK,
1402 expectedJsonResponse: "[]",
1405 controllerGetNodebIdListTestExecuter(t, &context)
1408 func TestHeaderValidationFailed(t *testing.T) {
1409 controller, _, _, _, _, _ := setupControllerTest(t)
1411 writer := httptest.NewRecorder()
1413 header := &http.Header{}
1415 controller.handleRequest(writer, header, httpmsghandlerprovider.ShutdownRequest, nil, true, 0)
1417 var errorResponse = parseJsonRequest(t, writer.Body)
1418 err := e2managererrors.NewHeaderValidationError()
1420 assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
1421 assert.Equal(t, errorResponse.Code, err.Code)
1422 assert.Equal(t, errorResponse.Message, err.Message)
1425 func TestShutdownStatusNoContent(t *testing.T) {
1426 controller, readerMock, _, _, e2tInstancesManagerMock, _ := setupControllerTest(t)
1427 e2tInstancesManagerMock.On("GetE2TAddresses").Return([]string{}, nil)
1428 readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{}, nil)
1430 writer := httptest.NewRecorder()
1431 controller.Shutdown(writer, tests.GetHttpRequest())
1433 assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
1436 func TestHandleInternalError(t *testing.T) {
1437 controller, _, _, _, _, _ := setupControllerTest(t)
1439 writer := httptest.NewRecorder()
1440 err := e2managererrors.NewInternalError()
1442 controller.handleErrorResponse(err, writer)
1443 var errorResponse = parseJsonRequest(t, writer.Body)
1445 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1446 assert.Equal(t, errorResponse.Code, err.Code)
1447 assert.Equal(t, errorResponse.Message, err.Message)
1450 func TestHandleCommandAlreadyInProgressError(t *testing.T) {
1451 controller, _, _, _, _, _ := setupControllerTest(t)
1452 writer := httptest.NewRecorder()
1453 err := e2managererrors.NewCommandAlreadyInProgressError()
1455 controller.handleErrorResponse(err, writer)
1456 var errorResponse = parseJsonRequest(t, writer.Body)
1458 assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
1459 assert.Equal(t, errorResponse.Code, err.Code)
1460 assert.Equal(t, errorResponse.Message, err.Message)
1463 func TestHandleRoutingManagerError(t *testing.T) {
1464 controller, _, _, _, _, _ := setupControllerTest(t)
1465 writer := httptest.NewRecorder()
1466 err := e2managererrors.NewRoutingManagerError()
1468 controller.handleErrorResponse(err, writer)
1469 var errorResponse = parseJsonRequest(t, writer.Body)
1471 assert.Equal(t, http.StatusServiceUnavailable, writer.Result().StatusCode)
1472 assert.Equal(t, errorResponse.Code, err.Code)
1473 assert.Equal(t, errorResponse.Message, err.Message)
1476 func TestHandleE2TInstanceAbsenceError(t *testing.T) {
1477 controller, _, _, _, _, _ := setupControllerTest(t)
1479 writer := httptest.NewRecorder()
1480 err := e2managererrors.NewE2TInstanceAbsenceError()
1482 controller.handleErrorResponse(err, writer)
1483 var errorResponse = parseJsonRequest(t, writer.Body)
1485 assert.Equal(t, http.StatusServiceUnavailable, writer.Result().StatusCode)
1486 assert.Equal(t, errorResponse.Code, err.Code)
1487 assert.Equal(t, errorResponse.Message, err.Message)
1490 func TestValidateHeaders(t *testing.T) {
1491 controller, _, _, _, _, _ := setupControllerTest(t)
1493 header := http.Header{}
1494 header.Set("Content-Type", "application/json")
1495 result := controller.validateRequestHeader(&header)
1497 assert.Nil(t, result)
1500 func parseJsonRequest(t *testing.T, r io.Reader) models.ErrorResponse {
1502 var errorResponse models.ErrorResponse
1503 body, err := ioutil.ReadAll(r)
1505 t.Errorf("Error cannot deserialize json request")
1507 _ = json.Unmarshal(body, &errorResponse)
1509 return errorResponse
1512 func initLog(t *testing.T) *logger.Logger {
1513 log, err := logger.InitLogger(logger.InfoLevel)
1515 t.Errorf("#delete_all_request_handler_test.TestHandleSuccessFlow - failed to initialize logger, error: %s", err)
1520 func TestX2ResetHandleSuccessfulRequestedCause(t *testing.T) {
1521 controller, readerMock, _, rmrMessengerMock, _, _ := setupControllerTest(t)
1524 payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x40}
1526 var msgSrc unsafe.Pointer
1527 msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction, msgSrc)
1528 rmrMessengerMock.On("SendMsg", msg, mock.Anything).Return(msg, nil)
1530 writer := httptest.NewRecorder()
1532 var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
1533 readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
1535 data4Req := map[string]interface{}{"cause": "protocol:transfer-syntax-error"}
1536 b := new(bytes.Buffer)
1537 _ = json.NewEncoder(b).Encode(data4Req)
1538 req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
1539 req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
1541 controller.X2Reset(writer, req)
1542 assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
1546 func TestX2ResetHandleSuccessfulRequestedDefault(t *testing.T) {
1547 controller, readerMock, _, rmrMessengerMock, _, _ := setupControllerTest(t)
1551 payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x64}
1553 var msgSrc unsafe.Pointer
1554 msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction, msgSrc)
1555 rmrMessengerMock.On("SendMsg", msg, true).Return(msg, nil)
1557 writer := httptest.NewRecorder()
1559 var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
1560 readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
1563 b := new(bytes.Buffer)
1564 data4Req := map[string]interface{}{}
1565 _ = json.NewEncoder(b).Encode(data4Req)
1566 req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
1567 req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
1569 controller.X2Reset(writer, req)
1570 assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
1573 func TestX2ResetHandleFailureInvalidBody(t *testing.T) {
1574 controller, _, _, _, _, _ := setupControllerTest(t)
1578 writer := httptest.NewRecorder()
1580 // Invalid json: attribute name without quotes (should be "cause":).
1581 b := strings.NewReader("{cause:\"protocol:transfer-syntax-error\"")
1582 req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
1583 req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
1585 controller.X2Reset(writer, req)
1586 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1590 func TestHandleErrorResponse(t *testing.T) {
1591 controller, _, _, _, _, _ := setupControllerTest(t)
1593 writer := httptest.NewRecorder()
1594 controller.handleErrorResponse(e2managererrors.NewRnibDbError(), writer)
1595 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1597 writer = httptest.NewRecorder()
1598 controller.handleErrorResponse(e2managererrors.NewCommandAlreadyInProgressError(), writer)
1599 assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
1601 writer = httptest.NewRecorder()
1602 controller.handleErrorResponse(e2managererrors.NewHeaderValidationError(), writer)
1603 assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
1605 writer = httptest.NewRecorder()
1606 controller.handleErrorResponse(e2managererrors.NewWrongStateError("", ""), writer)
1607 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1609 writer = httptest.NewRecorder()
1610 controller.handleErrorResponse(e2managererrors.NewRequestValidationError(), writer)
1611 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1613 writer = httptest.NewRecorder()
1614 controller.handleErrorResponse(e2managererrors.NewRmrError(), writer)
1615 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1617 writer = httptest.NewRecorder()
1618 controller.handleErrorResponse(e2managererrors.NewResourceNotFoundError(), writer)
1619 assert.Equal(t, http.StatusNotFound, writer.Result().StatusCode)
1621 writer = httptest.NewRecorder()
1622 controller.handleErrorResponse(fmt.Errorf("ErrorError"), writer)
1623 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1626 func getRmrSender(rmrMessengerMock *mocks.RmrMessengerMock, log *logger.Logger) *rmrsender.RmrSender {
1627 rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
1628 rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
1629 return rmrsender.NewRmrSender(log, rmrMessenger)