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
450 if context.getNodebInfoResult.nodebInfo.SetupFromNetwork {
451 updateEnbRequest.Enb.EnbType = context.getNodebInfoResult.nodebInfo.GetEnb().EnbType
454 updatedNodebInfo.Configuration = &entities.NodebInfo_Enb{Enb: updateEnbRequest.Enb}
456 writerMock.On("UpdateEnb", &updatedNodebInfo, updateEnbRequest.Enb.ServedCells).Return(context.updateEnbCellsParams.err)
460 func activateControllerUpdateGnbMocks(context *controllerUpdateGnbTestContext, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
461 if context.getNodebInfoResult != nil {
462 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
465 if context.removeServedNrCellsParams != nil {
466 writerMock.On("RemoveServedNrCells", RanName, context.removeServedNrCellsParams.servedNrCells).Return(context.removeServedNrCellsParams.err)
469 if context.updateGnbCellsParams != nil {
470 updatedNodebInfo := *context.getNodebInfoResult.nodebInfo
471 gnb := entities.Gnb{}
472 _ = jsonpb.Unmarshal(getJsonRequestAsBuffer(context.requestBody), &gnb)
473 updatedGnb := *updatedNodebInfo.GetGnb()
474 updatedGnb.ServedNrCells = gnb.ServedNrCells
475 writerMock.On("UpdateGnbCells", &updatedNodebInfo, gnb.ServedNrCells).Return(context.updateGnbCellsParams.err)
479 func assertControllerUpdateGnb(t *testing.T, context *controllerUpdateGnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
480 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
481 bodyBytes, _ := ioutil.ReadAll(writer.Body)
482 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
483 readerMock.AssertExpectations(t)
484 writerMock.AssertExpectations(t)
487 func assertControllerUpdateEnb(t *testing.T, context *controllerUpdateEnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
488 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
489 bodyBytes, _ := ioutil.ReadAll(writer.Body)
490 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
491 readerMock.AssertExpectations(t)
492 writerMock.AssertExpectations(t)
495 func assertControllerAddEnb(t *testing.T, context *controllerAddEnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
496 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
497 bodyBytes, _ := ioutil.ReadAll(writer.Body)
498 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
499 readerMock.AssertExpectations(t)
500 writerMock.AssertExpectations(t)
503 func assertControllerDeleteEnb(t *testing.T, context *controllerDeleteEnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
504 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
505 bodyBytes, _ := ioutil.ReadAll(writer.Body)
506 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
507 readerMock.AssertExpectations(t)
508 writerMock.AssertExpectations(t)
511 func buildUpdateEnbRequest(context *controllerUpdateEnbTestContext) *http.Request {
512 updateEnbUrl := fmt.Sprintf("/nodeb/enb/%s", RanName)
513 requestBody := getJsonRequestAsBuffer(context.requestBody)
514 req, _ := http.NewRequest(http.MethodPut, updateEnbUrl, requestBody)
515 req.Header.Set("Content-Type", "application/json")
516 req = mux.SetURLVars(req, map[string]string{"ranName": RanName})
520 func buildUpdateGnbRequest(context *controllerUpdateGnbTestContext) *http.Request {
521 updateGnbUrl := fmt.Sprintf("/nodeb/gnb/%s", RanName)
522 requestBody := getJsonRequestAsBuffer(context.requestBody)
523 req, _ := http.NewRequest(http.MethodPut, updateGnbUrl, requestBody)
524 req.Header.Set("Content-Type", "application/json")
525 req = mux.SetURLVars(req, map[string]string{"ranName": RanName})
529 func buildAddEnbRequest(context *controllerAddEnbTestContext) *http.Request {
530 requestBody := getJsonRequestAsBuffer(context.requestBody)
531 req, _ := http.NewRequest(http.MethodPost, AddEnbUrl, requestBody)
532 req.Header.Set("Content-Type", "application/json")
536 func controllerUpdateEnbTestExecuter(t *testing.T, context *controllerUpdateEnbTestContext) {
537 controller, readerMock, writerMock, _, _, _ := setupControllerTest(t)
538 writer := httptest.NewRecorder()
540 r := buildUpdateEnbRequest(context)
541 body, _ := ioutil.ReadAll(io.LimitReader(r.Body, LimitRequest))
543 updateEnbRequest := models.UpdateEnbRequest{}
544 _ = json.Unmarshal(body, &updateEnbRequest)
546 activateControllerUpdateEnbMocks(context, readerMock, writerMock, &updateEnbRequest)
547 r = buildUpdateEnbRequest(context)
550 controller.UpdateEnb(writer, r)
552 assertControllerUpdateEnb(t, context, writer, readerMock, writerMock)
555 func controllerUpdateGnbTestExecuter(t *testing.T, context *controllerUpdateGnbTestContext) {
556 controller, readerMock, writerMock, _, _, _ := setupControllerTest(t)
557 writer := httptest.NewRecorder()
559 activateControllerUpdateGnbMocks(context, readerMock, writerMock)
560 req := buildUpdateGnbRequest(context)
561 controller.UpdateGnb(writer, req)
562 assertControllerUpdateGnb(t, context, writer, readerMock, writerMock)
565 func activateControllerAddEnbMocks(context *controllerAddEnbTestContext, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock, addEnbRequest *models.AddEnbRequest) {
566 if context.getNodebInfoResult != nil {
567 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
570 if context.addEnbParams != nil {
571 nodebInfo := entities.NodebInfo{
572 RanName: addEnbRequest.RanName,
573 Ip: addEnbRequest.Ip,
574 Port: addEnbRequest.Port,
575 NodeType: entities.Node_ENB,
576 GlobalNbId: addEnbRequest.GlobalNbId,
577 Configuration: &entities.NodebInfo_Enb{Enb: addEnbRequest.Enb},
578 ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,
581 writerMock.On("AddEnb", &nodebInfo).Return(context.addEnbParams.err)
584 if context.addNbIdentityParams != nil {
585 nbIdentity := entities.NbIdentity{InventoryName: addEnbRequest.RanName, GlobalNbId: addEnbRequest.GlobalNbId, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED}
586 writerMock.On("AddNbIdentity", entities.Node_ENB, &nbIdentity).Return(context.addNbIdentityParams.err)
590 func controllerAddEnbTestExecuter(t *testing.T, context *controllerAddEnbTestContext) {
591 controller, readerMock, writerMock, _, _, _ := setupControllerTest(t)
592 writer := httptest.NewRecorder()
593 r := buildAddEnbRequest(context)
594 body, _ := ioutil.ReadAll(io.LimitReader(r.Body, LimitRequest))
596 addEnbRequest := models.AddEnbRequest{}
598 _ = json.Unmarshal(body, &addEnbRequest)
599 activateControllerAddEnbMocks(context, readerMock, writerMock, &addEnbRequest)
600 r = buildAddEnbRequest(context)
602 controller.AddEnb(writer, r)
603 assertControllerAddEnb(t, context, writer, readerMock, writerMock)
606 func controllerDeleteEnbTestExecuter(t *testing.T, context *controllerDeleteEnbTestContext, preAddNbIdentity bool) {
607 controller, readerMock, writerMock, nbIdentity := setupDeleteEnbControllerTest(t, preAddNbIdentity)
608 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
609 if context.getNodebInfoResult.rnibError == nil && context.getNodebInfoResult.nodebInfo.GetNodeType() == entities.Node_ENB &&
610 !context.getNodebInfoResult.nodebInfo.SetupFromNetwork {
611 writerMock.On("RemoveEnb", context.getNodebInfoResult.nodebInfo).Return(nil)
612 if preAddNbIdentity {
613 writerMock.On("RemoveNbIdentity", entities.Node_ENB, nbIdentity).Return(nil)
616 writer := httptest.NewRecorder()
617 r, _ := http.NewRequest(http.MethodDelete, AddEnbUrl+"/"+RanName, nil)
618 r.Header.Set("Content-Type", "application/json")
619 r = mux.SetURLVars(r, map[string]string{"ranName": RanName})
620 controller.DeleteEnb(writer, r)
621 assertControllerDeleteEnb(t, context, writer, readerMock, writerMock)
628 // BEGIN - UpdateGnb Validation Failure UTs
630 func TestControllerUpdateGnbEmptyServedNrCells(t *testing.T) {
631 context := controllerUpdateGnbTestContext{
632 getNodebInfoResult: nil,
633 requestBody: map[string]interface{}{
634 "servedNrCells": []interface{}{
637 expectedStatusCode: http.StatusBadRequest,
638 expectedJsonResponse: ValidationFailureJson,
641 controllerUpdateGnbTestExecuter(t, &context)
644 func TestControllerUpdateGnbMissingServedNrCellInformation(t *testing.T) {
645 context := controllerUpdateGnbTestContext{
646 getNodebInfoResult: nil,
647 requestBody: map[string]interface{}{
648 "servedNrCells": []interface{}{
649 map[string]interface{}{
650 "servedNrCellInformation": nil,
654 expectedStatusCode: http.StatusBadRequest,
655 expectedJsonResponse: ValidationFailureJson,
658 controllerUpdateGnbTestExecuter(t, &context)
661 func TestControllerUpdateGnbMissingServedNrCellRequiredProp(t *testing.T) {
663 for _, v := range ServedNrCellInformationRequiredFields {
664 context := controllerUpdateGnbTestContext{
665 getNodebInfoResult: nil,
666 requestBody: map[string]interface{}{
667 "servedNrCells": []interface{}{
668 map[string]interface{}{
669 "servedNrCellInformation": buildServedNrCellInformation(v),
673 expectedStatusCode: http.StatusBadRequest,
674 expectedJsonResponse: ValidationFailureJson,
677 controllerUpdateGnbTestExecuter(t, &context)
681 func TestControllerUpdateGnbMissingServedNrCellFddOrTdd(t *testing.T) {
683 servedNrCellInformation := buildServedNrCellInformation("")
684 servedNrCellInformation["choiceNrMode"] = map[string]interface{}{}
686 context := controllerUpdateGnbTestContext{
687 getNodebInfoResult: nil,
688 requestBody: map[string]interface{}{
689 "servedNrCells": []interface{}{
690 map[string]interface{}{
691 "servedNrCellInformation": servedNrCellInformation,
695 expectedStatusCode: http.StatusBadRequest,
696 expectedJsonResponse: ValidationFailureJson,
699 controllerUpdateGnbTestExecuter(t, &context)
702 func TestControllerUpdateGnbMissingNeighbourInfoFddOrTdd(t *testing.T) {
704 nrNeighbourInfo := buildNrNeighbourInformation("")
705 nrNeighbourInfo["choiceNrMode"] = map[string]interface{}{}
707 context := controllerUpdateGnbTestContext{
708 getNodebInfoResult: nil,
709 requestBody: map[string]interface{}{
710 "servedNrCells": []interface{}{
711 map[string]interface{}{
712 "servedNrCellInformation": buildServedNrCellInformation(""),
713 "nrNeighbourInfos": []interface{}{
719 expectedStatusCode: http.StatusBadRequest,
720 expectedJsonResponse: ValidationFailureJson,
723 controllerUpdateGnbTestExecuter(t, &context)
726 func TestControllerUpdateGnbMissingNrNeighbourInformationRequiredProp(t *testing.T) {
728 for _, v := range NrNeighbourInformationRequiredFields {
729 context := controllerUpdateGnbTestContext{
730 getNodebInfoResult: nil,
731 requestBody: map[string]interface{}{
732 "servedNrCells": []interface{}{
733 map[string]interface{}{
734 "servedNrCellInformation": buildServedNrCellInformation(""),
735 "nrNeighbourInfos": []interface{}{
736 buildNrNeighbourInformation(v),
741 expectedStatusCode: http.StatusBadRequest,
742 expectedJsonResponse: ValidationFailureJson,
745 controllerUpdateGnbTestExecuter(t, &context)
749 // END - UpdateGnb Validation Failure UTs
751 func TestControllerUpdateGnbValidServedNrCellInformationGetNodebNotFound(t *testing.T) {
752 context := controllerUpdateGnbTestContext{
753 getNodebInfoResult: &getNodebInfoResult{
755 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
757 requestBody: map[string]interface{}{
758 "servedNrCells": []interface{}{
759 map[string]interface{}{
760 "servedNrCellInformation": buildServedNrCellInformation(""),
764 expectedStatusCode: http.StatusNotFound,
765 expectedJsonResponse: ResourceNotFoundJson,
768 controllerUpdateGnbTestExecuter(t, &context)
771 func TestControllerUpdateGnbValidServedNrCellInformationGetNodebInternalError(t *testing.T) {
772 context := controllerUpdateGnbTestContext{
773 getNodebInfoResult: &getNodebInfoResult{
775 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
777 requestBody: map[string]interface{}{
778 "servedNrCells": []interface{}{
779 map[string]interface{}{
780 "servedNrCellInformation": buildServedNrCellInformation(""),
784 expectedStatusCode: http.StatusInternalServerError,
785 expectedJsonResponse: RnibErrorJson,
788 controllerUpdateGnbTestExecuter(t, &context)
791 func TestControllerUpdateGnbGetNodebSuccessInvalidGnbConfiguration(t *testing.T) {
792 context := controllerUpdateGnbTestContext{
793 getNodebInfoResult: &getNodebInfoResult{
794 nodebInfo: &entities.NodebInfo{
796 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
797 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
798 NodeType: entities.Node_ENB,
802 requestBody: map[string]interface{}{
803 "servedNrCells": []interface{}{
804 map[string]interface{}{
805 "servedNrCellInformation": buildServedNrCellInformation(""),
806 "nrNeighbourInfos": []interface{}{
807 buildNrNeighbourInformation(""),
812 expectedStatusCode: http.StatusBadRequest,
813 expectedJsonResponse: ValidationFailureJson,
816 controllerUpdateGnbTestExecuter(t, &context)
819 func TestControllerUpdateGnbGetNodebSuccessRemoveServedNrCellsFailure(t *testing.T) {
820 oldServedNrCells := generateServedNrCells("whatever1", "whatever2")
821 context := controllerUpdateGnbTestContext{
822 removeServedNrCellsParams: &removeServedNrCellsParams{
823 err: common.NewInternalError(errors.New("#writer.UpdateGnbCells - Internal Error")),
824 servedNrCells: oldServedNrCells,
826 getNodebInfoResult: &getNodebInfoResult{
827 nodebInfo: &entities.NodebInfo{
829 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
830 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
831 Configuration: &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{ServedNrCells: oldServedNrCells}},
832 NodeType: entities.Node_GNB,
836 requestBody: map[string]interface{}{
837 "servedNrCells": []interface{}{
838 map[string]interface{}{
839 "servedNrCellInformation": buildServedNrCellInformation(""),
840 "nrNeighbourInfos": []interface{}{
841 buildNrNeighbourInformation(""),
846 expectedStatusCode: http.StatusInternalServerError,
847 expectedJsonResponse: RnibErrorJson,
850 controllerUpdateGnbTestExecuter(t, &context)
853 func TestControllerUpdateGnbGetNodebSuccessUpdateGnbCellsFailure(t *testing.T) {
854 oldServedNrCells := generateServedNrCells("whatever1", "whatever2")
855 context := controllerUpdateGnbTestContext{
856 removeServedNrCellsParams: &removeServedNrCellsParams{
858 servedNrCells: oldServedNrCells,
860 updateGnbCellsParams: &updateGnbCellsParams{
861 err: common.NewInternalError(errors.New("#writer.UpdateGnbCells - Internal Error")),
863 getNodebInfoResult: &getNodebInfoResult{
864 nodebInfo: &entities.NodebInfo{
866 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
867 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
868 Configuration: &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{ServedNrCells: oldServedNrCells}},
869 NodeType: entities.Node_GNB,
873 requestBody: map[string]interface{}{
874 "servedNrCells": []interface{}{
875 map[string]interface{}{
876 "servedNrCellInformation": buildServedNrCellInformation(""),
877 "nrNeighbourInfos": []interface{}{
878 buildNrNeighbourInformation(""),
883 expectedStatusCode: http.StatusInternalServerError,
884 expectedJsonResponse: RnibErrorJson,
887 controllerUpdateGnbTestExecuter(t, &context)
890 func TestControllerUpdateGnbExistingEmptyCellsSuccess(t *testing.T) {
891 oldServedNrCells := []*entities.ServedNRCell{}
893 context := controllerUpdateGnbTestContext{
894 updateGnbCellsParams: &updateGnbCellsParams{
897 getNodebInfoResult: &getNodebInfoResult{
898 nodebInfo: &entities.NodebInfo{
900 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
901 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
902 Configuration: &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{ServedNrCells: oldServedNrCells}},
903 NodeType: entities.Node_GNB,
907 requestBody: map[string]interface{}{
908 "servedNrCells": []interface{}{
909 map[string]interface{}{
910 "servedNrCellInformation": buildServedNrCellInformation(""),
911 "nrNeighbourInfos": []interface{}{
912 buildNrNeighbourInformation(""),
917 expectedStatusCode: http.StatusOK,
918 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\"}",
921 controllerUpdateGnbTestExecuter(t, &context)
924 func TestControllerUpdateGnbSuccess(t *testing.T) {
925 oldServedNrCells := generateServedNrCells("whatever1", "whatever2")
927 context := controllerUpdateGnbTestContext{
928 removeServedNrCellsParams: &removeServedNrCellsParams{
930 servedNrCells: oldServedNrCells,
932 updateGnbCellsParams: &updateGnbCellsParams{
935 getNodebInfoResult: &getNodebInfoResult{
936 nodebInfo: &entities.NodebInfo{
938 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
939 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
940 Configuration: &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{ServedNrCells: oldServedNrCells}},
941 NodeType: entities.Node_GNB,
945 requestBody: map[string]interface{}{
946 "servedNrCells": []interface{}{
947 map[string]interface{}{
948 "servedNrCellInformation": buildServedNrCellInformation(""),
949 "nrNeighbourInfos": []interface{}{
950 buildNrNeighbourInformation(""),
955 expectedStatusCode: http.StatusOK,
956 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\"}",
959 controllerUpdateGnbTestExecuter(t, &context)
966 func TestControllerUpdateEnbInvalidRequest(t *testing.T) {
967 controller, _, _, _, _, _ := setupControllerTest(t)
969 writer := httptest.NewRecorder()
970 invalidJson := strings.NewReader("{enb:\"whatever\"")
972 updateEnbUrl := fmt.Sprintf("/nodeb/enb/%s", RanName)
973 req, _ := http.NewRequest(http.MethodPut, updateEnbUrl, invalidJson)
974 req.Header.Set("Content-Type", "application/json")
975 req = mux.SetURLVars(req, map[string]string{"ranName": RanName})
977 controller.UpdateEnb(writer, req)
979 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
980 bodyBytes, _ := ioutil.ReadAll(writer.Body)
981 assert.Equal(t, CorruptedJson, string(bodyBytes))
984 func TestControllerUpdateEnbEmptyEnbType(t *testing.T) {
985 context := controllerUpdateEnbTestContext{
986 getNodebInfoResult: nil,
987 requestBody: getUpdateEnbRequest(EnbRequiredFields[0]),
988 expectedStatusCode: http.StatusBadRequest,
989 expectedJsonResponse: ValidationFailureJson,
992 controllerUpdateEnbTestExecuter(t, &context)
995 func TestControllerUpdateEnbEmptyServedCells(t *testing.T) {
996 context := controllerUpdateEnbTestContext{
997 getNodebInfoResult: nil,
998 requestBody: getUpdateEnbRequest(EnbRequiredFields[1]),
999 expectedStatusCode: http.StatusBadRequest,
1000 expectedJsonResponse: ValidationFailureJson,
1003 controllerUpdateEnbTestExecuter(t, &context)
1006 func TestControllerUpdateEnbMissingEnb(t *testing.T) {
1007 context := controllerUpdateEnbTestContext{
1008 getNodebInfoResult: nil,
1009 requestBody: getUpdateEnbRequest(UpdateEnbRequestRequiredFields[0]),
1010 expectedStatusCode: http.StatusBadRequest,
1011 expectedJsonResponse: ValidationFailureJson,
1014 controllerUpdateEnbTestExecuter(t, &context)
1017 func TestControllerUpdateEnbMissingRequiredServedCellProps(t *testing.T) {
1019 r := getUpdateEnbRequest("")
1021 for _, v := range ServedCellRequiredFields {
1024 enbMap, _ := enb.(map[string]interface{})
1026 enbMap["servedCells"] = []interface{}{
1030 context := controllerUpdateEnbTestContext{
1032 expectedStatusCode: http.StatusBadRequest,
1033 expectedJsonResponse: ValidationFailureJson,
1036 controllerUpdateEnbTestExecuter(t, &context)
1040 func TestControllerUpdateEnbValidServedCellsGetNodebNotFound(t *testing.T) {
1041 context := controllerUpdateEnbTestContext{
1042 getNodebInfoResult: &getNodebInfoResult{
1044 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1046 requestBody: getUpdateEnbRequest(""),
1047 expectedStatusCode: http.StatusNotFound,
1048 expectedJsonResponse: ResourceNotFoundJson,
1051 controllerUpdateEnbTestExecuter(t, &context)
1054 func TestControllerUpdateEnbValidServedCellsGetNodebInternalError(t *testing.T) {
1055 context := controllerUpdateEnbTestContext{
1056 getNodebInfoResult: &getNodebInfoResult{
1058 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
1060 requestBody: getUpdateEnbRequest(""),
1061 expectedStatusCode: http.StatusInternalServerError,
1062 expectedJsonResponse: RnibErrorJson,
1065 controllerUpdateEnbTestExecuter(t, &context)
1068 func TestControllerUpdateEnbGetNodebSuccessGnbTypeFailure(t *testing.T) {
1069 oldServedCells := generateServedCells("whatever1", "whatever2")
1070 context := controllerUpdateEnbTestContext{
1071 getNodebInfoResult: &getNodebInfoResult{
1072 nodebInfo: &entities.NodebInfo{
1074 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
1075 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1076 NodeType: entities.Node_GNB,
1077 Configuration: &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells}},
1081 requestBody: getUpdateEnbRequest(""),
1082 expectedStatusCode: http.StatusBadRequest,
1083 expectedJsonResponse: ValidationFailureJson,
1086 controllerUpdateEnbTestExecuter(t, &context)
1089 func TestControllerUpdateEnbGetNodebSuccessRemoveServedCellsFailure(t *testing.T) {
1090 oldServedCells := generateServedCells("whatever1", "whatever2")
1091 context := controllerUpdateEnbTestContext{
1092 removeServedCellsParams: &removeServedCellsParams{
1093 err: common.NewInternalError(errors.New("#writer.RemoveServedCells - Internal Error")),
1094 servedCellInfo: oldServedCells,
1096 getNodebInfoResult: &getNodebInfoResult{
1097 nodebInfo: &entities.NodebInfo{
1099 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
1100 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1101 NodeType: entities.Node_ENB,
1102 Configuration: &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells}},
1106 requestBody: getUpdateEnbRequest(""),
1107 expectedStatusCode: http.StatusInternalServerError,
1108 expectedJsonResponse: RnibErrorJson,
1111 controllerUpdateEnbTestExecuter(t, &context)
1114 func TestControllerUpdateEnbGetNodebSuccessUpdateEnbFailure(t *testing.T) {
1115 oldServedCells := generateServedCells("whatever1", "whatever2")
1116 context := controllerUpdateEnbTestContext{
1117 removeServedCellsParams: &removeServedCellsParams{
1119 servedCellInfo: oldServedCells,
1121 updateEnbCellsParams: &updateEnbCellsParams{
1122 err: common.NewInternalError(errors.New("#writer.UpdateEnb - Internal Error")),
1124 getNodebInfoResult: &getNodebInfoResult{
1125 nodebInfo: &entities.NodebInfo{
1127 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
1128 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1129 NodeType: entities.Node_ENB,
1130 Configuration: &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells, EnbType: entities.EnbType_MACRO_ENB}},
1134 requestBody: getUpdateEnbRequest(""),
1135 expectedStatusCode: http.StatusInternalServerError,
1136 expectedJsonResponse: RnibErrorJson,
1139 controllerUpdateEnbTestExecuter(t, &context)
1142 func TestControllerUpdateEnbExistingEmptyCellsSuccess(t *testing.T) {
1143 oldServedCells := []*entities.ServedCellInfo{}
1144 context := controllerUpdateEnbTestContext{
1145 updateEnbCellsParams: &updateEnbCellsParams{
1148 getNodebInfoResult: &getNodebInfoResult{
1149 nodebInfo: &entities.NodebInfo{
1151 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
1152 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1153 NodeType: entities.Node_ENB,
1154 Configuration: &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells, EnbType: entities.EnbType_MACRO_ENB}},
1158 requestBody: getUpdateEnbRequest(""),
1159 expectedStatusCode: http.StatusOK,
1160 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\"}",
1163 controllerUpdateEnbTestExecuter(t, &context)
1166 func TestControllerUpdateEnbNgEnbFailure(t *testing.T) {
1168 requestBody := map[string]interface{}{
1169 "enb": map[string]interface{}{
1171 "servedCells": []interface{}{
1172 buildServedCell(""),
1176 oldServedCells := generateServedCells("whatever1", "whatever2")
1178 context := controllerUpdateEnbTestContext{
1179 getNodebInfoResult: &getNodebInfoResult{
1180 nodebInfo: &entities.NodebInfo{
1182 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
1183 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1184 NodeType: entities.Node_ENB,
1185 Configuration: &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells, EnbType: entities.EnbType_MACRO_NG_ENB}},
1189 requestBody: requestBody,
1190 expectedStatusCode: http.StatusBadRequest,
1191 expectedJsonResponse: ValidationFailureJson,
1194 controllerUpdateEnbTestExecuter(t, &context)
1197 func TestControllerUpdateEnbSuccessSetupFromNwFalse(t *testing.T) {
1198 oldServedCells := generateServedCells("whatever1", "whatever2")
1199 context := controllerUpdateEnbTestContext{
1200 removeServedCellsParams: &removeServedCellsParams{
1202 servedCellInfo: oldServedCells,
1204 updateEnbCellsParams: &updateEnbCellsParams{
1207 getNodebInfoResult: &getNodebInfoResult{
1208 nodebInfo: &entities.NodebInfo{
1210 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
1211 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1212 NodeType: entities.Node_ENB,
1213 Configuration: &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells, EnbType: entities.EnbType_LONG_MACRO_ENB}},
1217 requestBody: getUpdateEnbRequest(""),
1218 expectedStatusCode: http.StatusOK,
1219 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\"}",
1222 controllerUpdateEnbTestExecuter(t, &context)
1225 func TestControllerUpdateEnbSuccessSetupFromNwTrue(t *testing.T) {
1226 oldServedCells := generateServedCells("whatever1", "whatever2")
1227 context := controllerUpdateEnbTestContext{
1228 removeServedCellsParams: &removeServedCellsParams{
1230 servedCellInfo: oldServedCells,
1232 updateEnbCellsParams: &updateEnbCellsParams{
1235 getNodebInfoResult: &getNodebInfoResult{
1236 nodebInfo: &entities.NodebInfo{
1238 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
1239 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1240 NodeType: entities.Node_ENB,
1241 Configuration: &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells, EnbType: entities.EnbType_LONG_MACRO_ENB}},
1242 SetupFromNetwork: true,
1246 requestBody: getUpdateEnbRequest(""),
1247 expectedStatusCode: http.StatusOK,
1248 expectedJsonResponse: "{\"ranName\":\"test\",\"connectionStatus\":\"CONNECTED\",\"nodeType\":\"ENB\",\"enb\":{\"enbType\":\"LONG_MACRO_ENB\",\"servedCells\":[{\"pci\":1,\"cellId\":\"whatever\",\"tac\":\"whatever3\",\"broadcastPlmns\":[\"whatever\"],\"choiceEutraMode\":{\"fdd\":{}},\"eutraMode\":\"FDD\"}]},\"associatedE2tInstanceAddress\":\"10.0.2.15:38000\",\"setupFromNetwork\":true}",
1251 controllerUpdateEnbTestExecuter(t, &context)
1258 func TestControllerAddEnbGetNodebInternalError(t *testing.T) {
1259 context := controllerAddEnbTestContext{
1260 getNodebInfoResult: &getNodebInfoResult{
1262 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
1264 requestBody: getAddEnbRequest(""),
1265 expectedStatusCode: http.StatusInternalServerError,
1266 expectedJsonResponse: RnibErrorJson,
1269 controllerAddEnbTestExecuter(t, &context)
1272 func TestControllerAddEnbNodebExistsFailure(t *testing.T) {
1273 context := controllerAddEnbTestContext{
1274 getNodebInfoResult: &getNodebInfoResult{
1275 nodebInfo: &entities.NodebInfo{},
1278 requestBody: getAddEnbRequest(""),
1279 expectedStatusCode: http.StatusBadRequest,
1280 expectedJsonResponse: NodebExistsJson,
1283 controllerAddEnbTestExecuter(t, &context)
1286 func TestControllerAddEnbSaveNodebFailure(t *testing.T) {
1287 context := controllerAddEnbTestContext{
1288 addEnbParams: &addEnbParams{
1289 err: common.NewInternalError(errors.New("#reader.AddEnb - Internal Error")),
1291 getNodebInfoResult: &getNodebInfoResult{
1293 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1295 requestBody: getAddEnbRequest(""),
1296 expectedStatusCode: http.StatusInternalServerError,
1297 expectedJsonResponse: RnibErrorJson,
1300 controllerAddEnbTestExecuter(t, &context)
1303 func TestControllerAddEnbAddNbIdentityFailure(t *testing.T) {
1304 context := controllerAddEnbTestContext{
1305 addEnbParams: &addEnbParams{
1308 addNbIdentityParams: &addNbIdentityParams{
1309 err: common.NewInternalError(errors.New("#writer.addNbIdentity - Internal Error")),
1311 getNodebInfoResult: &getNodebInfoResult{
1313 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1315 requestBody: getAddEnbRequest(""),
1316 expectedStatusCode: http.StatusInternalServerError,
1317 expectedJsonResponse: RnibErrorJson,
1320 controllerAddEnbTestExecuter(t, &context)
1323 func TestControllerAddEnbMissingRequiredRequestProps(t *testing.T) {
1325 for _, v := range AddEnbRequestRequiredFields {
1326 context := controllerAddEnbTestContext{
1327 requestBody: getAddEnbRequest(v),
1328 expectedStatusCode: http.StatusBadRequest,
1329 expectedJsonResponse: ValidationFailureJson,
1332 controllerAddEnbTestExecuter(t, &context)
1336 func TestControllerAddEnbInvalidRequest(t *testing.T) {
1337 controller, _, _, _, _, _ := setupControllerTest(t)
1338 writer := httptest.NewRecorder()
1340 // Invalid json: attribute name without quotes (should be "cause":).
1341 invalidJson := strings.NewReader("{ranName:\"whatever\"")
1342 req, _ := http.NewRequest(http.MethodPost, AddEnbUrl, invalidJson)
1344 controller.AddEnb(writer, req)
1345 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1346 bodyBytes, _ := ioutil.ReadAll(writer.Body)
1347 assert.Equal(t, CorruptedJson, string(bodyBytes))
1351 func TestControllerAddEnbMissingRequiredGlobalNbIdProps(t *testing.T) {
1353 r := getAddEnbRequest("")
1355 for _, v := range GlobalIdRequiredFields {
1356 r["globalNbId"] = buildGlobalNbId(v)
1358 context := controllerAddEnbTestContext{
1360 expectedStatusCode: http.StatusBadRequest,
1361 expectedJsonResponse: ValidationFailureJson,
1364 controllerAddEnbTestExecuter(t, &context)
1368 func TestControllerAddEnbMissingRequiredEnbProps(t *testing.T) {
1370 r := getAddEnbRequest("")
1372 for _, v := range EnbRequiredFields {
1373 r["enb"] = buildEnb(v)
1375 context := controllerAddEnbTestContext{
1377 expectedStatusCode: http.StatusBadRequest,
1378 expectedJsonResponse: ValidationFailureJson,
1381 controllerAddEnbTestExecuter(t, &context)
1385 func TestControllerAddEnbMissingRequiredServedCellProps(t *testing.T) {
1387 r := getAddEnbRequest("")
1389 for _, v := range ServedCellRequiredFields {
1392 enbMap, _ := enb.(map[string]interface{})
1394 enbMap["servedCells"] = []interface{}{
1398 context := controllerAddEnbTestContext{
1400 expectedStatusCode: http.StatusBadRequest,
1401 expectedJsonResponse: ValidationFailureJson,
1404 controllerAddEnbTestExecuter(t, &context)
1408 func TestControllerAddEnbNgEnbFailure(t *testing.T) {
1410 requestBody := map[string]interface{}{
1412 "globalNbId": buildGlobalNbId(""),
1413 "enb": map[string]interface{}{
1415 "servedCells": []interface{}{
1416 buildServedCell(""),
1421 context := controllerAddEnbTestContext{
1422 requestBody: requestBody,
1423 expectedStatusCode: http.StatusBadRequest,
1424 expectedJsonResponse: ValidationFailureJson,
1427 controllerAddEnbTestExecuter(t, &context)
1430 func TestControllerAddEnbSuccess(t *testing.T) {
1431 context := controllerAddEnbTestContext{
1432 addEnbParams: &addEnbParams{
1435 addNbIdentityParams: &addNbIdentityParams{
1438 getNodebInfoResult: &getNodebInfoResult{
1440 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1442 requestBody: getAddEnbRequest(""),
1443 expectedStatusCode: http.StatusCreated,
1444 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\"}]}}",
1447 controllerAddEnbTestExecuter(t, &context)
1450 func TestControllerDeleteEnbGetNodebInternalError(t *testing.T) {
1451 context := controllerDeleteEnbTestContext{
1452 getNodebInfoResult: &getNodebInfoResult{
1454 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
1456 expectedStatusCode: http.StatusInternalServerError,
1457 expectedJsonResponse: RnibErrorJson,
1460 controllerDeleteEnbTestExecuter(t, &context, false)
1467 func TestControllerDeleteEnbNodebNotExistsFailure(t *testing.T) {
1468 context := controllerDeleteEnbTestContext{
1469 getNodebInfoResult: &getNodebInfoResult{
1471 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found"),
1473 expectedStatusCode: http.StatusNotFound,
1474 expectedJsonResponse: ResourceNotFoundJson,
1477 controllerDeleteEnbTestExecuter(t, &context, false)
1480 func TestControllerDeleteEnbNodebNotEnb(t *testing.T) {
1481 context := controllerDeleteEnbTestContext{
1482 getNodebInfoResult: &getNodebInfoResult{
1483 nodebInfo: &entities.NodebInfo{RanName: "ran1", NodeType: entities.Node_GNB, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED},
1486 expectedStatusCode: http.StatusBadRequest,
1487 expectedJsonResponse: ValidationFailureJson,
1490 controllerDeleteEnbTestExecuter(t, &context, false)
1493 func TestControllerDeleteEnbSetupFromNetworkTrueFailure(t *testing.T) {
1494 context := controllerDeleteEnbTestContext{
1495 getNodebInfoResult: &getNodebInfoResult{
1496 nodebInfo: &entities.NodebInfo{RanName: RanName, NodeType: entities.Node_ENB, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, SetupFromNetwork: true},
1499 expectedStatusCode: http.StatusBadRequest,
1500 expectedJsonResponse: ValidationFailureJson,
1502 controllerDeleteEnbTestExecuter(t, &context, true)
1505 func TestControllerDeleteEnbSuccess(t *testing.T) {
1506 context := controllerDeleteEnbTestContext{
1507 getNodebInfoResult: &getNodebInfoResult{
1508 nodebInfo: &entities.NodebInfo{RanName: RanName, NodeType: entities.Node_ENB, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED},
1511 expectedStatusCode: http.StatusNoContent,
1512 expectedJsonResponse: "",
1514 controllerDeleteEnbTestExecuter(t, &context, true)
1517 func getJsonRequestAsBuffer(requestJson map[string]interface{}) *bytes.Buffer {
1518 b := new(bytes.Buffer)
1519 _ = json.NewEncoder(b).Encode(requestJson)
1527 func TestControllerGetNodebSuccess(t *testing.T) {
1530 context := controllerGetNodebTestContext{
1532 nodebInfo: &entities.NodebInfo{RanName: ranName, Ip: "10.0.2.15", Port: 1234},
1533 rnibError: rnibError,
1534 expectedStatusCode: http.StatusOK,
1535 expectedJsonResponse: fmt.Sprintf("{\"ranName\":\"%s\",\"ip\":\"10.0.2.15\",\"port\":1234}", ranName),
1538 controllerGetNodebTestExecuter(t, &context)
1541 func TestControllerGetNodebNotFound(t *testing.T) {
1544 var nodebInfo *entities.NodebInfo
1545 context := controllerGetNodebTestContext{
1547 nodebInfo: nodebInfo,
1548 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1549 expectedStatusCode: http.StatusNotFound,
1550 expectedJsonResponse: ResourceNotFoundJson,
1553 controllerGetNodebTestExecuter(t, &context)
1556 func TestControllerGetNodebInternal(t *testing.T) {
1558 var nodebInfo *entities.NodebInfo
1559 context := controllerGetNodebTestContext{
1561 nodebInfo: nodebInfo,
1562 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
1563 expectedStatusCode: http.StatusInternalServerError,
1564 expectedJsonResponse: RnibErrorJson,
1567 controllerGetNodebTestExecuter(t, &context)
1570 func TestControllerGetNodebIdListSuccess(t *testing.T) {
1572 nodebIdList := []*entities.NbIdentity{
1573 {InventoryName: "test1", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}},
1574 {InventoryName: "test2", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId2", NbId: "nbId2"}},
1577 context := controllerGetNodebIdListTestContext{
1578 nodebIdList: nodebIdList,
1579 rnibError: rnibError,
1580 expectedStatusCode: http.StatusOK,
1581 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\"}}]",
1584 controllerGetNodebIdListTestExecuter(t, &context)
1587 func TestControllerGetNodebIdListEmptySuccess(t *testing.T) {
1589 var nodebIdList []*entities.NbIdentity
1591 context := controllerGetNodebIdListTestContext{
1592 nodebIdList: nodebIdList,
1593 rnibError: rnibError,
1594 expectedStatusCode: http.StatusOK,
1595 expectedJsonResponse: "[]",
1598 controllerGetNodebIdListTestExecuter(t, &context)
1601 func TestHeaderValidationFailed(t *testing.T) {
1602 controller, _, _, _, _, _ := setupControllerTest(t)
1604 writer := httptest.NewRecorder()
1606 header := &http.Header{}
1608 controller.handleRequest(writer, header, httpmsghandlerprovider.ShutdownRequest, nil, true, 0)
1610 var errorResponse = parseJsonRequest(t, writer.Body)
1611 err := e2managererrors.NewHeaderValidationError()
1613 assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
1614 assert.Equal(t, errorResponse.Code, err.Code)
1615 assert.Equal(t, errorResponse.Message, err.Message)
1618 func TestShutdownStatusNoContent(t *testing.T) {
1619 controller, readerMock, _, _, e2tInstancesManagerMock, _ := setupControllerTest(t)
1620 e2tInstancesManagerMock.On("GetE2TAddresses").Return([]string{}, nil)
1621 readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{}, nil)
1623 writer := httptest.NewRecorder()
1624 controller.Shutdown(writer, tests.GetHttpRequest())
1626 assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
1629 func TestHandleInternalError(t *testing.T) {
1630 controller, _, _, _, _, _ := setupControllerTest(t)
1632 writer := httptest.NewRecorder()
1633 err := e2managererrors.NewInternalError()
1635 controller.handleErrorResponse(err, writer)
1636 var errorResponse = parseJsonRequest(t, writer.Body)
1638 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1639 assert.Equal(t, errorResponse.Code, err.Code)
1640 assert.Equal(t, errorResponse.Message, err.Message)
1643 func TestHandleCommandAlreadyInProgressError(t *testing.T) {
1644 controller, _, _, _, _, _ := setupControllerTest(t)
1645 writer := httptest.NewRecorder()
1646 err := e2managererrors.NewCommandAlreadyInProgressError()
1648 controller.handleErrorResponse(err, writer)
1649 var errorResponse = parseJsonRequest(t, writer.Body)
1651 assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
1652 assert.Equal(t, errorResponse.Code, err.Code)
1653 assert.Equal(t, errorResponse.Message, err.Message)
1656 func TestHandleRoutingManagerError(t *testing.T) {
1657 controller, _, _, _, _, _ := setupControllerTest(t)
1658 writer := httptest.NewRecorder()
1659 err := e2managererrors.NewRoutingManagerError()
1661 controller.handleErrorResponse(err, writer)
1662 var errorResponse = parseJsonRequest(t, writer.Body)
1664 assert.Equal(t, http.StatusServiceUnavailable, writer.Result().StatusCode)
1665 assert.Equal(t, errorResponse.Code, err.Code)
1666 assert.Equal(t, errorResponse.Message, err.Message)
1669 func TestHandleE2TInstanceAbsenceError(t *testing.T) {
1670 controller, _, _, _, _, _ := setupControllerTest(t)
1672 writer := httptest.NewRecorder()
1673 err := e2managererrors.NewE2TInstanceAbsenceError()
1675 controller.handleErrorResponse(err, writer)
1676 var errorResponse = parseJsonRequest(t, writer.Body)
1678 assert.Equal(t, http.StatusServiceUnavailable, writer.Result().StatusCode)
1679 assert.Equal(t, errorResponse.Code, err.Code)
1680 assert.Equal(t, errorResponse.Message, err.Message)
1683 func TestValidateHeaders(t *testing.T) {
1684 controller, _, _, _, _, _ := setupControllerTest(t)
1686 header := http.Header{}
1687 header.Set("Content-Type", "application/json")
1688 result := controller.validateRequestHeader(&header)
1690 assert.Nil(t, result)
1693 func parseJsonRequest(t *testing.T, r io.Reader) models.ErrorResponse {
1695 var errorResponse models.ErrorResponse
1696 body, err := ioutil.ReadAll(r)
1698 t.Errorf("Error cannot deserialize json request")
1700 _ = json.Unmarshal(body, &errorResponse)
1702 return errorResponse
1705 func initLog(t *testing.T) *logger.Logger {
1706 log, err := logger.InitLogger(logger.InfoLevel)
1708 t.Errorf("#delete_all_request_handler_test.TestHandleSuccessFlow - failed to initialize logger, error: %s", err)
1713 func TestX2ResetHandleSuccessfulRequestedCause(t *testing.T) {
1714 controller, readerMock, _, rmrMessengerMock, _, _ := setupControllerTest(t)
1717 payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x40}
1719 var msgSrc unsafe.Pointer
1720 msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction, msgSrc)
1721 rmrMessengerMock.On("SendMsg", msg, mock.Anything).Return(msg, nil)
1723 writer := httptest.NewRecorder()
1725 var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
1726 readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
1728 data4Req := map[string]interface{}{"cause": "protocol:transfer-syntax-error"}
1729 b := new(bytes.Buffer)
1730 _ = json.NewEncoder(b).Encode(data4Req)
1731 req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
1732 req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
1734 controller.X2Reset(writer, req)
1735 assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
1739 func TestX2ResetHandleSuccessfulRequestedDefault(t *testing.T) {
1740 controller, readerMock, _, rmrMessengerMock, _, _ := setupControllerTest(t)
1744 payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x64}
1746 var msgSrc unsafe.Pointer
1747 msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction, msgSrc)
1748 rmrMessengerMock.On("SendMsg", msg, true).Return(msg, nil)
1750 writer := httptest.NewRecorder()
1752 var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
1753 readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
1756 b := new(bytes.Buffer)
1757 data4Req := map[string]interface{}{}
1758 _ = json.NewEncoder(b).Encode(data4Req)
1759 req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
1760 req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
1762 controller.X2Reset(writer, req)
1763 assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
1766 func TestX2ResetHandleFailureInvalidBody(t *testing.T) {
1767 controller, _, _, _, _, _ := setupControllerTest(t)
1771 writer := httptest.NewRecorder()
1773 // Invalid json: attribute name without quotes (should be "cause":).
1774 b := strings.NewReader("{cause:\"protocol:transfer-syntax-error\"")
1775 req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
1776 req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
1778 controller.X2Reset(writer, req)
1779 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1783 func TestHandleErrorResponse(t *testing.T) {
1784 controller, _, _, _, _, _ := setupControllerTest(t)
1786 writer := httptest.NewRecorder()
1787 controller.handleErrorResponse(e2managererrors.NewRnibDbError(), writer)
1788 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1790 writer = httptest.NewRecorder()
1791 controller.handleErrorResponse(e2managererrors.NewCommandAlreadyInProgressError(), writer)
1792 assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
1794 writer = httptest.NewRecorder()
1795 controller.handleErrorResponse(e2managererrors.NewHeaderValidationError(), writer)
1796 assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
1798 writer = httptest.NewRecorder()
1799 controller.handleErrorResponse(e2managererrors.NewWrongStateError("", ""), writer)
1800 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1802 writer = httptest.NewRecorder()
1803 controller.handleErrorResponse(e2managererrors.NewRequestValidationError(), writer)
1804 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1806 writer = httptest.NewRecorder()
1807 controller.handleErrorResponse(e2managererrors.NewRmrError(), writer)
1808 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1810 writer = httptest.NewRecorder()
1811 controller.handleErrorResponse(e2managererrors.NewResourceNotFoundError(), writer)
1812 assert.Equal(t, http.StatusNotFound, writer.Result().StatusCode)
1814 writer = httptest.NewRecorder()
1815 controller.handleErrorResponse(fmt.Errorf("ErrorError"), writer)
1816 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1819 func getRmrSender(rmrMessengerMock *mocks.RmrMessengerMock, log *logger.Logger) *rmrsender.RmrSender {
1820 rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
1821 rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
1822 return rmrsender.NewRmrSender(log, rmrMessenger)