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 addEnbParams 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 addEnbParams *addEnbParams
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)
324 updateGnbManager := managers.NewUpdateGnbManager(log, rnibDataService, nodebValidator)
325 handlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(log, rmrSender, config, rnibDataService, e2tInstancesManager, rmClient, ranConnectStatusChangeManager, nodebValidator, updateEnbManager, updateGnbManager, 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)
355 updateGnbManager := managers.NewUpdateGnbManager(log, rnibDataService, nodebValidator)
357 handlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(log, rmrSender, config, rnibDataService, e2tInstancesManager, rmClient, ranConnectStatusChangeManager, nodebValidator, updateEnbManager, updateGnbManager, ranListManager)
358 controller := NewNodebController(log, handlerProvider)
359 return controller, readerMock, writerMock, nbIdentity
362 func TestShutdownHandlerRnibError(t *testing.T) {
363 controller, _, _, _, e2tInstancesManagerMock, _ := setupControllerTest(t)
364 e2tInstancesManagerMock.On("GetE2TAddresses").Return([]string{}, e2managererrors.NewRnibDbError())
366 writer := httptest.NewRecorder()
368 controller.Shutdown(writer, tests.GetHttpRequest())
370 var errorResponse = parseJsonRequest(t, writer.Body)
372 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
373 assert.Equal(t, errorResponse.Code, e2managererrors.NewRnibDbError().Code)
376 func TestSetGeneralConfigurationHandlerRnibError(t *testing.T) {
377 controller, readerMock, _, _, _, _ := setupControllerTest(t)
379 configuration := &entities.GeneralConfiguration{}
380 readerMock.On("GetGeneralConfiguration").Return(configuration, e2managererrors.NewRnibDbError())
382 writer := httptest.NewRecorder()
384 httpRequest, _ := http.NewRequest("PUT", "https://localhost:3800/v1/nodeb/parameters", strings.NewReader("{\"enableRic\":false}"))
386 controller.SetGeneralConfiguration(writer, httpRequest)
388 var errorResponse = parseJsonRequest(t, writer.Body)
390 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
391 assert.Equal(t, e2managererrors.NewRnibDbError().Code, errorResponse.Code)
394 func TestSetGeneralConfigurationInvalidJson(t *testing.T) {
395 controller, _, _, _, _, _ := setupControllerTest(t)
397 writer := httptest.NewRecorder()
399 httpRequest, _ := http.NewRequest("PUT", "https://localhost:3800/v1/nodeb/parameters", strings.NewReader("{\"enableRic\":false, \"someValue\":false}"))
401 controller.SetGeneralConfiguration(writer, httpRequest)
403 var errorResponse = parseJsonRequest(t, writer.Body)
405 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
406 assert.Equal(t, e2managererrors.NewInvalidJsonError().Code, errorResponse.Code)
409 func controllerGetNodebTestExecuter(t *testing.T, context *controllerGetNodebTestContext) {
410 controller, readerMock, _, _, _, _ := setupControllerTest(t)
411 writer := httptest.NewRecorder()
412 readerMock.On("GetNodeb", context.ranName).Return(context.nodebInfo, context.rnibError)
413 req, _ := http.NewRequest(http.MethodGet, "/nodeb", nil)
414 req = mux.SetURLVars(req, map[string]string{"ranName": context.ranName})
415 controller.GetNodeb(writer, req)
416 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
417 bodyBytes, _ := ioutil.ReadAll(writer.Body)
418 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
421 func controllerGetNodebIdListTestExecuter(t *testing.T, context *controllerGetNodebIdListTestContext) {
422 controller, readerMock, _, _, _, ranListManager := setupControllerTest(t)
423 writer := httptest.NewRecorder()
424 readerMock.On("GetListNodebIds").Return(context.nodebIdList, context.rnibError)
426 err := ranListManager.InitNbIdentityMap()
428 t.Errorf("Error cannot init identity")
431 req, _ := http.NewRequest(http.MethodGet, "/nodeb/states", nil)
432 controller.GetNodebIdList(writer, req)
433 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
434 bodyBytes, _ := ioutil.ReadAll(writer.Body)
435 assert.Contains(t, context.expectedJsonResponse, string(bodyBytes))
438 func activateControllerUpdateEnbMocks(context *controllerUpdateEnbTestContext, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock, updateEnbRequest *models.UpdateEnbRequest) {
439 if context.getNodebInfoResult != nil {
440 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
443 if context.removeServedCellsParams != nil {
444 writerMock.On("RemoveServedCells", RanName, context.removeServedCellsParams.servedCellInfo).Return(context.removeServedCellsParams.err)
447 if context.updateEnbCellsParams != nil {
448 updatedNodebInfo := *context.getNodebInfoResult.nodebInfo
449 updatedNodebInfo.Configuration = &entities.NodebInfo_Enb{Enb: updateEnbRequest.Enb}
451 writerMock.On("UpdateEnb", &updatedNodebInfo, updateEnbRequest.Enb.ServedCells).Return(context.updateEnbCellsParams.err)
455 func activateControllerUpdateGnbMocks(context *controllerUpdateGnbTestContext, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
456 if context.getNodebInfoResult != nil {
457 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
460 if context.removeServedNrCellsParams != nil {
461 writerMock.On("RemoveServedNrCells", RanName, context.removeServedNrCellsParams.servedNrCells).Return(context.removeServedNrCellsParams.err)
464 if context.updateGnbCellsParams != nil {
465 updatedNodebInfo := *context.getNodebInfoResult.nodebInfo
466 gnb := entities.Gnb{}
467 _ = jsonpb.Unmarshal(getJsonRequestAsBuffer(context.requestBody), &gnb)
468 updatedGnb := *updatedNodebInfo.GetGnb()
469 updatedGnb.ServedNrCells = gnb.ServedNrCells
470 writerMock.On("UpdateGnbCells", &updatedNodebInfo, gnb.ServedNrCells).Return(context.updateGnbCellsParams.err)
474 func assertControllerUpdateGnb(t *testing.T, context *controllerUpdateGnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
475 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
476 bodyBytes, _ := ioutil.ReadAll(writer.Body)
477 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
478 readerMock.AssertExpectations(t)
479 writerMock.AssertExpectations(t)
482 func assertControllerUpdateEnb(t *testing.T, context *controllerUpdateEnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
483 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
484 bodyBytes, _ := ioutil.ReadAll(writer.Body)
485 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
486 readerMock.AssertExpectations(t)
487 writerMock.AssertExpectations(t)
490 func assertControllerAddEnb(t *testing.T, context *controllerAddEnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
491 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
492 bodyBytes, _ := ioutil.ReadAll(writer.Body)
493 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
494 readerMock.AssertExpectations(t)
495 writerMock.AssertExpectations(t)
498 func assertControllerDeleteEnb(t *testing.T, context *controllerDeleteEnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
499 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
500 bodyBytes, _ := ioutil.ReadAll(writer.Body)
501 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
502 readerMock.AssertExpectations(t)
503 writerMock.AssertExpectations(t)
506 func buildUpdateEnbRequest(context *controllerUpdateEnbTestContext) *http.Request {
507 updateEnbUrl := fmt.Sprintf("/nodeb/enb/%s", RanName)
508 requestBody := getJsonRequestAsBuffer(context.requestBody)
509 req, _ := http.NewRequest(http.MethodPut, updateEnbUrl, requestBody)
510 req.Header.Set("Content-Type", "application/json")
511 req = mux.SetURLVars(req, map[string]string{"ranName": RanName})
515 func buildUpdateGnbRequest(context *controllerUpdateGnbTestContext) *http.Request {
516 updateGnbUrl := fmt.Sprintf("/nodeb/gnb/%s", RanName)
517 requestBody := getJsonRequestAsBuffer(context.requestBody)
518 req, _ := http.NewRequest(http.MethodPut, updateGnbUrl, requestBody)
519 req.Header.Set("Content-Type", "application/json")
520 req = mux.SetURLVars(req, map[string]string{"ranName": RanName})
524 func buildAddEnbRequest(context *controllerAddEnbTestContext) *http.Request {
525 requestBody := getJsonRequestAsBuffer(context.requestBody)
526 req, _ := http.NewRequest(http.MethodPost, AddEnbUrl, requestBody)
527 req.Header.Set("Content-Type", "application/json")
531 func controllerUpdateEnbTestExecuter(t *testing.T, context *controllerUpdateEnbTestContext) {
532 controller, readerMock, writerMock, _, _, _ := setupControllerTest(t)
533 writer := httptest.NewRecorder()
535 r := buildUpdateEnbRequest(context)
536 body, _ := ioutil.ReadAll(io.LimitReader(r.Body, LimitRequest))
538 updateEnbRequest := models.UpdateEnbRequest{}
539 _ = json.Unmarshal(body, &updateEnbRequest)
541 activateControllerUpdateEnbMocks(context, readerMock, writerMock, &updateEnbRequest)
542 r = buildUpdateEnbRequest(context)
545 controller.UpdateEnb(writer, r)
547 assertControllerUpdateEnb(t, context, writer, readerMock, writerMock)
550 func controllerUpdateGnbTestExecuter(t *testing.T, context *controllerUpdateGnbTestContext) {
551 controller, readerMock, writerMock, _, _, _ := setupControllerTest(t)
552 writer := httptest.NewRecorder()
554 activateControllerUpdateGnbMocks(context, readerMock, writerMock)
555 req := buildUpdateGnbRequest(context)
556 controller.UpdateGnb(writer, req)
557 assertControllerUpdateGnb(t, context, writer, readerMock, writerMock)
560 func activateControllerAddEnbMocks(context *controllerAddEnbTestContext, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock, addEnbRequest *models.AddEnbRequest) {
561 if context.getNodebInfoResult != nil {
562 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
565 if context.addEnbParams != nil {
566 nodebInfo := entities.NodebInfo{
567 RanName: addEnbRequest.RanName,
568 Ip: addEnbRequest.Ip,
569 Port: addEnbRequest.Port,
570 NodeType: entities.Node_ENB,
571 GlobalNbId: addEnbRequest.GlobalNbId,
572 Configuration: &entities.NodebInfo_Enb{Enb: addEnbRequest.Enb},
573 ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,
576 writerMock.On("AddEnb", &nodebInfo).Return(context.addEnbParams.err)
579 if context.addNbIdentityParams != nil {
580 nbIdentity := entities.NbIdentity{InventoryName: addEnbRequest.RanName, GlobalNbId: addEnbRequest.GlobalNbId, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED}
581 writerMock.On("AddNbIdentity", entities.Node_ENB, &nbIdentity).Return(context.addNbIdentityParams.err)
585 func controllerAddEnbTestExecuter(t *testing.T, context *controllerAddEnbTestContext) {
586 controller, readerMock, writerMock, _, _, _ := setupControllerTest(t)
587 writer := httptest.NewRecorder()
588 r := buildAddEnbRequest(context)
589 body, _ := ioutil.ReadAll(io.LimitReader(r.Body, LimitRequest))
591 addEnbRequest := models.AddEnbRequest{}
593 _ = json.Unmarshal(body, &addEnbRequest)
594 activateControllerAddEnbMocks(context, readerMock, writerMock, &addEnbRequest)
595 r = buildAddEnbRequest(context)
597 controller.AddEnb(writer, r)
598 assertControllerAddEnb(t, context, writer, readerMock, writerMock)
601 func controllerDeleteEnbTestExecuter(t *testing.T, context *controllerDeleteEnbTestContext, preAddNbIdentity bool) {
602 controller, readerMock, writerMock, nbIdentity := setupDeleteEnbControllerTest(t, preAddNbIdentity)
603 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
604 if context.getNodebInfoResult.rnibError == nil && context.getNodebInfoResult.nodebInfo.GetNodeType() == entities.Node_ENB {
605 writerMock.On("RemoveEnb", context.getNodebInfoResult.nodebInfo).Return(nil)
606 if preAddNbIdentity {
607 writerMock.On("RemoveNbIdentity", entities.Node_ENB, nbIdentity).Return(nil)
610 writer := httptest.NewRecorder()
611 r, _ := http.NewRequest(http.MethodDelete, AddEnbUrl+"/"+RanName, nil)
612 r.Header.Set("Content-Type", "application/json")
613 r = mux.SetURLVars(r, map[string]string{"ranName": RanName})
614 controller.DeleteEnb(writer, r)
615 assertControllerDeleteEnb(t, context, writer, readerMock, writerMock)
622 // BEGIN - UpdateGnb Validation Failure UTs
624 func TestControllerUpdateGnbEmptyServedNrCells(t *testing.T) {
625 context := controllerUpdateGnbTestContext{
626 getNodebInfoResult: nil,
627 requestBody: map[string]interface{}{
628 "servedNrCells": []interface{}{
631 expectedStatusCode: http.StatusBadRequest,
632 expectedJsonResponse: ValidationFailureJson,
635 controllerUpdateGnbTestExecuter(t, &context)
638 func TestControllerUpdateGnbMissingServedNrCellInformation(t *testing.T) {
639 context := controllerUpdateGnbTestContext{
640 getNodebInfoResult: nil,
641 requestBody: map[string]interface{}{
642 "servedNrCells": []interface{}{
643 map[string]interface{}{
644 "servedNrCellInformation": nil,
648 expectedStatusCode: http.StatusBadRequest,
649 expectedJsonResponse: ValidationFailureJson,
652 controllerUpdateGnbTestExecuter(t, &context)
655 func TestControllerUpdateGnbMissingServedNrCellRequiredProp(t *testing.T) {
657 for _, v := range ServedNrCellInformationRequiredFields {
658 context := controllerUpdateGnbTestContext{
659 getNodebInfoResult: nil,
660 requestBody: map[string]interface{}{
661 "servedNrCells": []interface{}{
662 map[string]interface{}{
663 "servedNrCellInformation": buildServedNrCellInformation(v),
667 expectedStatusCode: http.StatusBadRequest,
668 expectedJsonResponse: ValidationFailureJson,
671 controllerUpdateGnbTestExecuter(t, &context)
675 func TestControllerUpdateGnbMissingServedNrCellFddOrTdd(t *testing.T) {
677 servedNrCellInformation := buildServedNrCellInformation("")
678 servedNrCellInformation["choiceNrMode"] = map[string]interface{}{}
680 context := controllerUpdateGnbTestContext{
681 getNodebInfoResult: nil,
682 requestBody: map[string]interface{}{
683 "servedNrCells": []interface{}{
684 map[string]interface{}{
685 "servedNrCellInformation": servedNrCellInformation,
689 expectedStatusCode: http.StatusBadRequest,
690 expectedJsonResponse: ValidationFailureJson,
693 controllerUpdateGnbTestExecuter(t, &context)
696 func TestControllerUpdateGnbMissingNeighbourInfoFddOrTdd(t *testing.T) {
698 nrNeighbourInfo := buildNrNeighbourInformation("")
699 nrNeighbourInfo["choiceNrMode"] = map[string]interface{}{}
701 context := controllerUpdateGnbTestContext{
702 getNodebInfoResult: nil,
703 requestBody: map[string]interface{}{
704 "servedNrCells": []interface{}{
705 map[string]interface{}{
706 "servedNrCellInformation": buildServedNrCellInformation(""),
707 "nrNeighbourInfos": []interface{}{
713 expectedStatusCode: http.StatusBadRequest,
714 expectedJsonResponse: ValidationFailureJson,
717 controllerUpdateGnbTestExecuter(t, &context)
720 func TestControllerUpdateGnbMissingNrNeighbourInformationRequiredProp(t *testing.T) {
722 for _, v := range NrNeighbourInformationRequiredFields {
723 context := controllerUpdateGnbTestContext{
724 getNodebInfoResult: nil,
725 requestBody: map[string]interface{}{
726 "servedNrCells": []interface{}{
727 map[string]interface{}{
728 "servedNrCellInformation": buildServedNrCellInformation(""),
729 "nrNeighbourInfos": []interface{}{
730 buildNrNeighbourInformation(v),
735 expectedStatusCode: http.StatusBadRequest,
736 expectedJsonResponse: ValidationFailureJson,
739 controllerUpdateGnbTestExecuter(t, &context)
743 // END - UpdateGnb Validation Failure UTs
745 func TestControllerUpdateGnbValidServedNrCellInformationGetNodebNotFound(t *testing.T) {
746 context := controllerUpdateGnbTestContext{
747 getNodebInfoResult: &getNodebInfoResult{
749 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
751 requestBody: map[string]interface{}{
752 "servedNrCells": []interface{}{
753 map[string]interface{}{
754 "servedNrCellInformation": buildServedNrCellInformation(""),
758 expectedStatusCode: http.StatusNotFound,
759 expectedJsonResponse: ResourceNotFoundJson,
762 controllerUpdateGnbTestExecuter(t, &context)
765 func TestControllerUpdateGnbValidServedNrCellInformationGetNodebInternalError(t *testing.T) {
766 context := controllerUpdateGnbTestContext{
767 getNodebInfoResult: &getNodebInfoResult{
769 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
771 requestBody: map[string]interface{}{
772 "servedNrCells": []interface{}{
773 map[string]interface{}{
774 "servedNrCellInformation": buildServedNrCellInformation(""),
778 expectedStatusCode: http.StatusInternalServerError,
779 expectedJsonResponse: RnibErrorJson,
782 controllerUpdateGnbTestExecuter(t, &context)
785 func TestControllerUpdateGnbGetNodebSuccessInvalidGnbConfiguration(t *testing.T) {
786 context := controllerUpdateGnbTestContext{
787 getNodebInfoResult: &getNodebInfoResult{
788 nodebInfo: &entities.NodebInfo{
790 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
791 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
792 NodeType: entities.Node_ENB,
796 requestBody: map[string]interface{}{
797 "servedNrCells": []interface{}{
798 map[string]interface{}{
799 "servedNrCellInformation": buildServedNrCellInformation(""),
800 "nrNeighbourInfos": []interface{}{
801 buildNrNeighbourInformation(""),
806 expectedStatusCode: http.StatusBadRequest,
807 expectedJsonResponse: ValidationFailureJson,
810 controllerUpdateGnbTestExecuter(t, &context)
813 func TestControllerUpdateGnbGetNodebSuccessRemoveServedNrCellsFailure(t *testing.T) {
814 oldServedNrCells := generateServedNrCells("whatever1", "whatever2")
815 context := controllerUpdateGnbTestContext{
816 removeServedNrCellsParams: &removeServedNrCellsParams{
817 err: common.NewInternalError(errors.New("#writer.UpdateGnbCells - Internal Error")),
818 servedNrCells: oldServedNrCells,
820 getNodebInfoResult: &getNodebInfoResult{
821 nodebInfo: &entities.NodebInfo{
823 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
824 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
825 Configuration: &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{ServedNrCells: oldServedNrCells}},
826 NodeType: entities.Node_GNB,
830 requestBody: map[string]interface{}{
831 "servedNrCells": []interface{}{
832 map[string]interface{}{
833 "servedNrCellInformation": buildServedNrCellInformation(""),
834 "nrNeighbourInfos": []interface{}{
835 buildNrNeighbourInformation(""),
840 expectedStatusCode: http.StatusInternalServerError,
841 expectedJsonResponse: RnibErrorJson,
844 controllerUpdateGnbTestExecuter(t, &context)
847 func TestControllerUpdateGnbGetNodebSuccessUpdateGnbCellsFailure(t *testing.T) {
848 oldServedNrCells := generateServedNrCells("whatever1", "whatever2")
849 context := controllerUpdateGnbTestContext{
850 removeServedNrCellsParams: &removeServedNrCellsParams{
852 servedNrCells: oldServedNrCells,
854 updateGnbCellsParams: &updateGnbCellsParams{
855 err: common.NewInternalError(errors.New("#writer.UpdateGnbCells - Internal Error")),
857 getNodebInfoResult: &getNodebInfoResult{
858 nodebInfo: &entities.NodebInfo{
860 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
861 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
862 Configuration: &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{ServedNrCells: oldServedNrCells}},
863 NodeType: entities.Node_GNB,
867 requestBody: map[string]interface{}{
868 "servedNrCells": []interface{}{
869 map[string]interface{}{
870 "servedNrCellInformation": buildServedNrCellInformation(""),
871 "nrNeighbourInfos": []interface{}{
872 buildNrNeighbourInformation(""),
877 expectedStatusCode: http.StatusInternalServerError,
878 expectedJsonResponse: RnibErrorJson,
881 controllerUpdateGnbTestExecuter(t, &context)
884 func TestControllerUpdateGnbExistingEmptyCellsSuccess(t *testing.T) {
885 oldServedNrCells := []*entities.ServedNRCell{}
887 context := controllerUpdateGnbTestContext{
888 updateGnbCellsParams: &updateGnbCellsParams{
891 getNodebInfoResult: &getNodebInfoResult{
892 nodebInfo: &entities.NodebInfo{
894 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
895 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
896 Configuration: &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{ServedNrCells: oldServedNrCells}},
897 NodeType: entities.Node_GNB,
901 requestBody: map[string]interface{}{
902 "servedNrCells": []interface{}{
903 map[string]interface{}{
904 "servedNrCellInformation": buildServedNrCellInformation(""),
905 "nrNeighbourInfos": []interface{}{
906 buildNrNeighbourInformation(""),
911 expectedStatusCode: http.StatusOK,
912 expectedJsonResponse: "{\"ranName\":\"test\",\"connectionStatus\":\"CONNECTED\",\"nodeType\":\"GNB\",\"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\"}",
915 controllerUpdateGnbTestExecuter(t, &context)
918 func TestControllerUpdateGnbSuccess(t *testing.T) {
919 oldServedNrCells := generateServedNrCells("whatever1", "whatever2")
921 context := controllerUpdateGnbTestContext{
922 removeServedNrCellsParams: &removeServedNrCellsParams{
924 servedNrCells: oldServedNrCells,
926 updateGnbCellsParams: &updateGnbCellsParams{
929 getNodebInfoResult: &getNodebInfoResult{
930 nodebInfo: &entities.NodebInfo{
932 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
933 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
934 Configuration: &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{ServedNrCells: oldServedNrCells}},
935 NodeType: entities.Node_GNB,
939 requestBody: map[string]interface{}{
940 "servedNrCells": []interface{}{
941 map[string]interface{}{
942 "servedNrCellInformation": buildServedNrCellInformation(""),
943 "nrNeighbourInfos": []interface{}{
944 buildNrNeighbourInformation(""),
949 expectedStatusCode: http.StatusOK,
950 expectedJsonResponse: "{\"ranName\":\"test\",\"connectionStatus\":\"CONNECTED\",\"nodeType\":\"GNB\",\"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\"}",
953 controllerUpdateGnbTestExecuter(t, &context)
960 func TestControllerUpdateEnbInvalidRequest(t *testing.T) {
961 controller, _, _, _, _, _ := setupControllerTest(t)
963 writer := httptest.NewRecorder()
964 invalidJson := strings.NewReader("{enb:\"whatever\"")
966 updateEnbUrl := fmt.Sprintf("/nodeb/enb/%s", RanName)
967 req, _ := http.NewRequest(http.MethodPut, updateEnbUrl, invalidJson)
968 req.Header.Set("Content-Type", "application/json")
969 req = mux.SetURLVars(req, map[string]string{"ranName": RanName})
971 controller.UpdateEnb(writer, req)
973 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
974 bodyBytes, _ := ioutil.ReadAll(writer.Body)
975 assert.Equal(t, CorruptedJson, string(bodyBytes))
978 func TestControllerUpdateEnbEmptyEnbType(t *testing.T) {
979 context := controllerUpdateEnbTestContext{
980 getNodebInfoResult: nil,
981 requestBody: getUpdateEnbRequest(EnbRequiredFields[0]),
982 expectedStatusCode: http.StatusBadRequest,
983 expectedJsonResponse: ValidationFailureJson,
986 controllerUpdateEnbTestExecuter(t, &context)
989 func TestControllerUpdateEnbEmptyServedCells(t *testing.T) {
990 context := controllerUpdateEnbTestContext{
991 getNodebInfoResult: nil,
992 requestBody: getUpdateEnbRequest(EnbRequiredFields[1]),
993 expectedStatusCode: http.StatusBadRequest,
994 expectedJsonResponse: ValidationFailureJson,
997 controllerUpdateEnbTestExecuter(t, &context)
1000 func TestControllerUpdateEnbMissingEnb(t *testing.T) {
1001 context := controllerUpdateEnbTestContext{
1002 getNodebInfoResult: nil,
1003 requestBody: getUpdateEnbRequest(UpdateEnbRequestRequiredFields[0]),
1004 expectedStatusCode: http.StatusBadRequest,
1005 expectedJsonResponse: ValidationFailureJson,
1008 controllerUpdateEnbTestExecuter(t, &context)
1011 func TestControllerUpdateEnbMissingRequiredServedCellProps(t *testing.T) {
1013 r := getUpdateEnbRequest("")
1015 for _, v := range ServedCellRequiredFields {
1018 enbMap, _ := enb.(map[string]interface{})
1020 enbMap["servedCells"] = []interface{}{
1024 context := controllerUpdateEnbTestContext{
1026 expectedStatusCode: http.StatusBadRequest,
1027 expectedJsonResponse: ValidationFailureJson,
1030 controllerUpdateEnbTestExecuter(t, &context)
1034 func TestControllerUpdateEnbValidServedCellsGetNodebNotFound(t *testing.T) {
1035 context := controllerUpdateEnbTestContext{
1036 getNodebInfoResult: &getNodebInfoResult{
1038 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1040 requestBody: getUpdateEnbRequest(""),
1041 expectedStatusCode: http.StatusNotFound,
1042 expectedJsonResponse: ResourceNotFoundJson,
1045 controllerUpdateEnbTestExecuter(t, &context)
1048 func TestControllerUpdateEnbValidServedCellsGetNodebInternalError(t *testing.T) {
1049 context := controllerUpdateEnbTestContext{
1050 getNodebInfoResult: &getNodebInfoResult{
1052 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
1054 requestBody: getUpdateEnbRequest(""),
1055 expectedStatusCode: http.StatusInternalServerError,
1056 expectedJsonResponse: RnibErrorJson,
1059 controllerUpdateEnbTestExecuter(t, &context)
1062 func TestControllerUpdateEnbGetNodebSuccessGnbTypeFailure(t *testing.T) {
1063 oldServedCells := generateServedCells("whatever1", "whatever2")
1064 context := controllerUpdateEnbTestContext{
1065 getNodebInfoResult: &getNodebInfoResult{
1066 nodebInfo: &entities.NodebInfo{
1068 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
1069 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1070 NodeType: entities.Node_GNB,
1071 Configuration: &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells}},
1075 requestBody: getUpdateEnbRequest(""),
1076 expectedStatusCode: http.StatusBadRequest,
1077 expectedJsonResponse: ValidationFailureJson,
1080 controllerUpdateEnbTestExecuter(t, &context)
1083 func TestControllerUpdateEnbGetNodebSuccessRemoveServedCellsFailure(t *testing.T) {
1084 oldServedCells := generateServedCells("whatever1", "whatever2")
1085 context := controllerUpdateEnbTestContext{
1086 removeServedCellsParams: &removeServedCellsParams{
1087 err: common.NewInternalError(errors.New("#writer.RemoveServedCells - Internal Error")),
1088 servedCellInfo: oldServedCells,
1090 getNodebInfoResult: &getNodebInfoResult{
1091 nodebInfo: &entities.NodebInfo{
1093 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
1094 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1095 NodeType: entities.Node_ENB,
1096 Configuration: &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells}},
1100 requestBody: getUpdateEnbRequest(""),
1101 expectedStatusCode: http.StatusInternalServerError,
1102 expectedJsonResponse: RnibErrorJson,
1105 controllerUpdateEnbTestExecuter(t, &context)
1108 func TestControllerUpdateEnbGetNodebSuccessUpdateEnbFailure(t *testing.T) {
1109 oldServedCells := generateServedCells("whatever1", "whatever2")
1110 context := controllerUpdateEnbTestContext{
1111 removeServedCellsParams: &removeServedCellsParams{
1113 servedCellInfo: oldServedCells,
1115 updateEnbCellsParams: &updateEnbCellsParams{
1116 err: common.NewInternalError(errors.New("#writer.UpdateEnb - Internal Error")),
1118 getNodebInfoResult: &getNodebInfoResult{
1119 nodebInfo: &entities.NodebInfo{
1121 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
1122 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1123 NodeType: entities.Node_ENB,
1124 Configuration: &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells, EnbType: entities.EnbType_MACRO_ENB}},
1128 requestBody: getUpdateEnbRequest(""),
1129 expectedStatusCode: http.StatusInternalServerError,
1130 expectedJsonResponse: RnibErrorJson,
1133 controllerUpdateEnbTestExecuter(t, &context)
1136 func TestControllerUpdateEnbExistingEmptyCellsSuccess(t *testing.T) {
1137 oldServedCells := []*entities.ServedCellInfo{}
1138 context := controllerUpdateEnbTestContext{
1139 updateEnbCellsParams: &updateEnbCellsParams{
1142 getNodebInfoResult: &getNodebInfoResult{
1143 nodebInfo: &entities.NodebInfo{
1145 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
1146 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1147 NodeType: entities.Node_ENB,
1148 Configuration: &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells, EnbType: entities.EnbType_MACRO_ENB}},
1152 requestBody: getUpdateEnbRequest(""),
1153 expectedStatusCode: http.StatusOK,
1154 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\"}",
1157 controllerUpdateEnbTestExecuter(t, &context)
1161 func TestControllerUpdateEnbSuccess(t *testing.T) {
1162 oldServedCells := generateServedCells("whatever1", "whatever2")
1163 context := controllerUpdateEnbTestContext{
1164 removeServedCellsParams: &removeServedCellsParams{
1166 servedCellInfo: oldServedCells,
1168 updateEnbCellsParams: &updateEnbCellsParams{
1171 getNodebInfoResult: &getNodebInfoResult{
1172 nodebInfo: &entities.NodebInfo{
1174 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
1175 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1176 NodeType: entities.Node_ENB,
1177 Configuration: &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells, EnbType: entities.EnbType_MACRO_ENB}},
1181 requestBody: getUpdateEnbRequest(""),
1182 expectedStatusCode: http.StatusOK,
1183 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\"}",
1186 controllerUpdateEnbTestExecuter(t, &context)
1193 func TestControllerAddEnbGetNodebInternalError(t *testing.T) {
1194 context := controllerAddEnbTestContext{
1195 getNodebInfoResult: &getNodebInfoResult{
1197 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
1199 requestBody: getAddEnbRequest(""),
1200 expectedStatusCode: http.StatusInternalServerError,
1201 expectedJsonResponse: RnibErrorJson,
1204 controllerAddEnbTestExecuter(t, &context)
1207 func TestControllerAddEnbNodebExistsFailure(t *testing.T) {
1208 context := controllerAddEnbTestContext{
1209 getNodebInfoResult: &getNodebInfoResult{
1210 nodebInfo: &entities.NodebInfo{},
1213 requestBody: getAddEnbRequest(""),
1214 expectedStatusCode: http.StatusBadRequest,
1215 expectedJsonResponse: NodebExistsJson,
1218 controllerAddEnbTestExecuter(t, &context)
1221 func TestControllerAddEnbSaveNodebFailure(t *testing.T) {
1222 context := controllerAddEnbTestContext{
1223 addEnbParams: &addEnbParams{
1224 err: common.NewInternalError(errors.New("#reader.AddEnb - Internal Error")),
1226 getNodebInfoResult: &getNodebInfoResult{
1228 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1230 requestBody: getAddEnbRequest(""),
1231 expectedStatusCode: http.StatusInternalServerError,
1232 expectedJsonResponse: RnibErrorJson,
1235 controllerAddEnbTestExecuter(t, &context)
1238 func TestControllerAddEnbAddNbIdentityFailure(t *testing.T) {
1239 context := controllerAddEnbTestContext{
1240 addEnbParams: &addEnbParams{
1243 addNbIdentityParams: &addNbIdentityParams{
1244 err: common.NewInternalError(errors.New("#writer.addNbIdentity - Internal Error")),
1246 getNodebInfoResult: &getNodebInfoResult{
1248 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1250 requestBody: getAddEnbRequest(""),
1251 expectedStatusCode: http.StatusInternalServerError,
1252 expectedJsonResponse: RnibErrorJson,
1255 controllerAddEnbTestExecuter(t, &context)
1258 func TestControllerAddEnbMissingRequiredRequestProps(t *testing.T) {
1260 for _, v := range AddEnbRequestRequiredFields {
1261 context := controllerAddEnbTestContext{
1262 requestBody: getAddEnbRequest(v),
1263 expectedStatusCode: http.StatusBadRequest,
1264 expectedJsonResponse: ValidationFailureJson,
1267 controllerAddEnbTestExecuter(t, &context)
1271 func TestControllerAddEnbInvalidRequest(t *testing.T) {
1272 controller, _, _, _, _, _ := setupControllerTest(t)
1273 writer := httptest.NewRecorder()
1275 // Invalid json: attribute name without quotes (should be "cause":).
1276 invalidJson := strings.NewReader("{ranName:\"whatever\"")
1277 req, _ := http.NewRequest(http.MethodPost, AddEnbUrl, invalidJson)
1279 controller.AddEnb(writer, req)
1280 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1281 bodyBytes, _ := ioutil.ReadAll(writer.Body)
1282 assert.Equal(t, CorruptedJson, string(bodyBytes))
1286 func TestControllerAddEnbMissingRequiredGlobalNbIdProps(t *testing.T) {
1288 r := getAddEnbRequest("")
1290 for _, v := range GlobalIdRequiredFields {
1291 r["globalNbId"] = buildGlobalNbId(v)
1293 context := controllerAddEnbTestContext{
1295 expectedStatusCode: http.StatusBadRequest,
1296 expectedJsonResponse: ValidationFailureJson,
1299 controllerAddEnbTestExecuter(t, &context)
1303 func TestControllerAddEnbMissingRequiredEnbProps(t *testing.T) {
1305 r := getAddEnbRequest("")
1307 for _, v := range EnbRequiredFields {
1308 r["enb"] = buildEnb(v)
1310 context := controllerAddEnbTestContext{
1312 expectedStatusCode: http.StatusBadRequest,
1313 expectedJsonResponse: ValidationFailureJson,
1316 controllerAddEnbTestExecuter(t, &context)
1320 func TestControllerAddEnbMissingRequiredServedCellProps(t *testing.T) {
1322 r := getAddEnbRequest("")
1324 for _, v := range ServedCellRequiredFields {
1327 enbMap, _ := enb.(map[string]interface{})
1329 enbMap["servedCells"] = []interface{}{
1333 context := controllerAddEnbTestContext{
1335 expectedStatusCode: http.StatusBadRequest,
1336 expectedJsonResponse: ValidationFailureJson,
1339 controllerAddEnbTestExecuter(t, &context)
1343 func TestControllerAddEnbSuccess(t *testing.T) {
1344 context := controllerAddEnbTestContext{
1345 addEnbParams: &addEnbParams{
1348 addNbIdentityParams: &addNbIdentityParams{
1351 getNodebInfoResult: &getNodebInfoResult{
1353 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1355 requestBody: getAddEnbRequest(""),
1356 expectedStatusCode: http.StatusCreated,
1357 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\"}]}}",
1360 controllerAddEnbTestExecuter(t, &context)
1363 func TestControllerDeleteEnbGetNodebInternalError(t *testing.T) {
1364 context := controllerDeleteEnbTestContext{
1365 getNodebInfoResult: &getNodebInfoResult{
1367 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
1369 expectedStatusCode: http.StatusInternalServerError,
1370 expectedJsonResponse: RnibErrorJson,
1373 controllerDeleteEnbTestExecuter(t, &context, false)
1380 func TestControllerDeleteEnbNodebNotExistsFailure(t *testing.T) {
1381 context := controllerDeleteEnbTestContext{
1382 getNodebInfoResult: &getNodebInfoResult{
1384 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found"),
1386 expectedStatusCode: http.StatusNotFound,
1387 expectedJsonResponse: ResourceNotFoundJson,
1390 controllerDeleteEnbTestExecuter(t, &context, false)
1393 func TestControllerDeleteEnbNodebNotEnb(t *testing.T) {
1394 context := controllerDeleteEnbTestContext{
1395 getNodebInfoResult: &getNodebInfoResult{
1396 nodebInfo: &entities.NodebInfo{RanName: "ran1", NodeType: entities.Node_GNB, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED},
1399 expectedStatusCode: http.StatusBadRequest,
1400 expectedJsonResponse: ValidationFailureJson,
1403 controllerDeleteEnbTestExecuter(t, &context, false)
1406 func TestControllerDeleteEnbSuccess(t *testing.T) {
1407 context := controllerDeleteEnbTestContext{
1408 getNodebInfoResult: &getNodebInfoResult{
1409 nodebInfo: &entities.NodebInfo{RanName: RanName, NodeType: entities.Node_ENB, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED},
1412 expectedStatusCode: http.StatusNoContent,
1413 expectedJsonResponse: "",
1415 controllerDeleteEnbTestExecuter(t, &context, true)
1418 func getJsonRequestAsBuffer(requestJson map[string]interface{}) *bytes.Buffer {
1419 b := new(bytes.Buffer)
1420 _ = json.NewEncoder(b).Encode(requestJson)
1428 func TestControllerGetNodebSuccess(t *testing.T) {
1431 context := controllerGetNodebTestContext{
1433 nodebInfo: &entities.NodebInfo{RanName: ranName, Ip: "10.0.2.15", Port: 1234},
1434 rnibError: rnibError,
1435 expectedStatusCode: http.StatusOK,
1436 expectedJsonResponse: fmt.Sprintf("{\"ranName\":\"%s\",\"ip\":\"10.0.2.15\",\"port\":1234}", ranName),
1439 controllerGetNodebTestExecuter(t, &context)
1442 func TestControllerGetNodebNotFound(t *testing.T) {
1445 var nodebInfo *entities.NodebInfo
1446 context := controllerGetNodebTestContext{
1448 nodebInfo: nodebInfo,
1449 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1450 expectedStatusCode: http.StatusNotFound,
1451 expectedJsonResponse: ResourceNotFoundJson,
1454 controllerGetNodebTestExecuter(t, &context)
1457 func TestControllerGetNodebInternal(t *testing.T) {
1459 var nodebInfo *entities.NodebInfo
1460 context := controllerGetNodebTestContext{
1462 nodebInfo: nodebInfo,
1463 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
1464 expectedStatusCode: http.StatusInternalServerError,
1465 expectedJsonResponse: RnibErrorJson,
1468 controllerGetNodebTestExecuter(t, &context)
1471 func TestControllerGetNodebIdListSuccess(t *testing.T) {
1473 nodebIdList := []*entities.NbIdentity{
1474 {InventoryName: "test1", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}},
1475 {InventoryName: "test2", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId2", NbId: "nbId2"}},
1478 context := controllerGetNodebIdListTestContext{
1479 nodebIdList: nodebIdList,
1480 rnibError: rnibError,
1481 expectedStatusCode: http.StatusOK,
1482 expectedJsonResponse: "[{\"inventoryName\":\"test1\",\"globalNbId\":{\"plmnId\":\"plmnId1\",\"nbId\":\"nbId1\"}},{\"inventoryName\":\"test2\",\"globalNbId\":{\"plmnId\":\"plmnId2\",\"nbId\":\"nbId2\"}}][{\"inventoryName\":\"test2\",\"globalNbId\":{\"plmnId\":\"plmnId2\",\"nbId\":\"nbId2\"}},{\"inventoryName\":\"test1\",\"globalNbId\":{\"plmnId\":\"plmnId1\",\"nbId\":\"nbId1\"}}]",
1485 controllerGetNodebIdListTestExecuter(t, &context)
1488 func TestControllerGetNodebIdListEmptySuccess(t *testing.T) {
1490 var nodebIdList []*entities.NbIdentity
1492 context := controllerGetNodebIdListTestContext{
1493 nodebIdList: nodebIdList,
1494 rnibError: rnibError,
1495 expectedStatusCode: http.StatusOK,
1496 expectedJsonResponse: "[]",
1499 controllerGetNodebIdListTestExecuter(t, &context)
1502 func TestHeaderValidationFailed(t *testing.T) {
1503 controller, _, _, _, _, _ := setupControllerTest(t)
1505 writer := httptest.NewRecorder()
1507 header := &http.Header{}
1509 controller.handleRequest(writer, header, httpmsghandlerprovider.ShutdownRequest, nil, true, 0)
1511 var errorResponse = parseJsonRequest(t, writer.Body)
1512 err := e2managererrors.NewHeaderValidationError()
1514 assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
1515 assert.Equal(t, errorResponse.Code, err.Code)
1516 assert.Equal(t, errorResponse.Message, err.Message)
1519 func TestShutdownStatusNoContent(t *testing.T) {
1520 controller, readerMock, _, _, e2tInstancesManagerMock, _ := setupControllerTest(t)
1521 e2tInstancesManagerMock.On("GetE2TAddresses").Return([]string{}, nil)
1522 readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{}, nil)
1524 writer := httptest.NewRecorder()
1525 controller.Shutdown(writer, tests.GetHttpRequest())
1527 assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
1530 func TestHandleInternalError(t *testing.T) {
1531 controller, _, _, _, _, _ := setupControllerTest(t)
1533 writer := httptest.NewRecorder()
1534 err := e2managererrors.NewInternalError()
1536 controller.handleErrorResponse(err, writer)
1537 var errorResponse = parseJsonRequest(t, writer.Body)
1539 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1540 assert.Equal(t, errorResponse.Code, err.Code)
1541 assert.Equal(t, errorResponse.Message, err.Message)
1544 func TestHandleCommandAlreadyInProgressError(t *testing.T) {
1545 controller, _, _, _, _, _ := setupControllerTest(t)
1546 writer := httptest.NewRecorder()
1547 err := e2managererrors.NewCommandAlreadyInProgressError()
1549 controller.handleErrorResponse(err, writer)
1550 var errorResponse = parseJsonRequest(t, writer.Body)
1552 assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
1553 assert.Equal(t, errorResponse.Code, err.Code)
1554 assert.Equal(t, errorResponse.Message, err.Message)
1557 func TestHandleRoutingManagerError(t *testing.T) {
1558 controller, _, _, _, _, _ := setupControllerTest(t)
1559 writer := httptest.NewRecorder()
1560 err := e2managererrors.NewRoutingManagerError()
1562 controller.handleErrorResponse(err, writer)
1563 var errorResponse = parseJsonRequest(t, writer.Body)
1565 assert.Equal(t, http.StatusServiceUnavailable, writer.Result().StatusCode)
1566 assert.Equal(t, errorResponse.Code, err.Code)
1567 assert.Equal(t, errorResponse.Message, err.Message)
1570 func TestHandleE2TInstanceAbsenceError(t *testing.T) {
1571 controller, _, _, _, _, _ := setupControllerTest(t)
1573 writer := httptest.NewRecorder()
1574 err := e2managererrors.NewE2TInstanceAbsenceError()
1576 controller.handleErrorResponse(err, writer)
1577 var errorResponse = parseJsonRequest(t, writer.Body)
1579 assert.Equal(t, http.StatusServiceUnavailable, writer.Result().StatusCode)
1580 assert.Equal(t, errorResponse.Code, err.Code)
1581 assert.Equal(t, errorResponse.Message, err.Message)
1584 func TestValidateHeaders(t *testing.T) {
1585 controller, _, _, _, _, _ := setupControllerTest(t)
1587 header := http.Header{}
1588 header.Set("Content-Type", "application/json")
1589 result := controller.validateRequestHeader(&header)
1591 assert.Nil(t, result)
1594 func parseJsonRequest(t *testing.T, r io.Reader) models.ErrorResponse {
1596 var errorResponse models.ErrorResponse
1597 body, err := ioutil.ReadAll(r)
1599 t.Errorf("Error cannot deserialize json request")
1601 _ = json.Unmarshal(body, &errorResponse)
1603 return errorResponse
1606 func initLog(t *testing.T) *logger.Logger {
1607 log, err := logger.InitLogger(logger.InfoLevel)
1609 t.Errorf("#delete_all_request_handler_test.TestHandleSuccessFlow - failed to initialize logger, error: %s", err)
1614 func TestX2ResetHandleSuccessfulRequestedCause(t *testing.T) {
1615 controller, readerMock, _, rmrMessengerMock, _, _ := setupControllerTest(t)
1618 payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x40}
1620 var msgSrc unsafe.Pointer
1621 msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction, msgSrc)
1622 rmrMessengerMock.On("SendMsg", msg, mock.Anything).Return(msg, nil)
1624 writer := httptest.NewRecorder()
1626 var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
1627 readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
1629 data4Req := map[string]interface{}{"cause": "protocol:transfer-syntax-error"}
1630 b := new(bytes.Buffer)
1631 _ = json.NewEncoder(b).Encode(data4Req)
1632 req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
1633 req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
1635 controller.X2Reset(writer, req)
1636 assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
1640 func TestX2ResetHandleSuccessfulRequestedDefault(t *testing.T) {
1641 controller, readerMock, _, rmrMessengerMock, _, _ := setupControllerTest(t)
1645 payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x64}
1647 var msgSrc unsafe.Pointer
1648 msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction, msgSrc)
1649 rmrMessengerMock.On("SendMsg", msg, true).Return(msg, nil)
1651 writer := httptest.NewRecorder()
1653 var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
1654 readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
1657 b := new(bytes.Buffer)
1658 data4Req := map[string]interface{}{}
1659 _ = json.NewEncoder(b).Encode(data4Req)
1660 req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
1661 req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
1663 controller.X2Reset(writer, req)
1664 assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
1667 func TestX2ResetHandleFailureInvalidBody(t *testing.T) {
1668 controller, _, _, _, _, _ := setupControllerTest(t)
1672 writer := httptest.NewRecorder()
1674 // Invalid json: attribute name without quotes (should be "cause":).
1675 b := strings.NewReader("{cause:\"protocol:transfer-syntax-error\"")
1676 req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
1677 req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
1679 controller.X2Reset(writer, req)
1680 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1684 func TestHandleErrorResponse(t *testing.T) {
1685 controller, _, _, _, _, _ := setupControllerTest(t)
1687 writer := httptest.NewRecorder()
1688 controller.handleErrorResponse(e2managererrors.NewRnibDbError(), writer)
1689 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1691 writer = httptest.NewRecorder()
1692 controller.handleErrorResponse(e2managererrors.NewCommandAlreadyInProgressError(), writer)
1693 assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
1695 writer = httptest.NewRecorder()
1696 controller.handleErrorResponse(e2managererrors.NewHeaderValidationError(), writer)
1697 assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
1699 writer = httptest.NewRecorder()
1700 controller.handleErrorResponse(e2managererrors.NewWrongStateError("", ""), writer)
1701 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1703 writer = httptest.NewRecorder()
1704 controller.handleErrorResponse(e2managererrors.NewRequestValidationError(), writer)
1705 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1707 writer = httptest.NewRecorder()
1708 controller.handleErrorResponse(e2managererrors.NewRmrError(), writer)
1709 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1711 writer = httptest.NewRecorder()
1712 controller.handleErrorResponse(e2managererrors.NewResourceNotFoundError(), writer)
1713 assert.Equal(t, http.StatusNotFound, writer.Result().StatusCode)
1715 writer = httptest.NewRecorder()
1716 controller.handleErrorResponse(fmt.Errorf("ErrorError"), writer)
1717 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1720 func getRmrSender(rmrMessengerMock *mocks.RmrMessengerMock, log *logger.Logger) *rmrsender.RmrSender {
1721 rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
1722 rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
1723 return rmrsender.NewRmrSender(log, rmrMessenger)