2 // Copyright 2019 AT&T Intellectual Property
3 // Copyright 2019 Nokia
4 // Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved.
6 // Licensed under the Apache License, Version 2.0 (the "License");
7 // you may not use this file except in compliance with the License.
8 // You may obtain a copy of the License at
10 // http://www.apache.org/licenses/LICENSE-2.0
12 // Unless required by applicable law or agreed to in writing, software
13 // distributed under the License is distributed on an "AS IS" BASIS,
14 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 // See the License for the specific language governing permissions and
16 // limitations under the License.
18 // This source code is part of the near-RT RIC (RAN Intelligent Controller)
19 // platform project (RICP).
27 "e2mgr/e2managererrors"
32 "e2mgr/providers/httpmsghandlerprovider"
35 "e2mgr/services/rmrsender"
39 "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
40 "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
41 "github.com/golang/protobuf/jsonpb"
42 "github.com/gorilla/mux"
43 "github.com/pkg/errors"
44 "github.com/stretchr/testify/assert"
45 "github.com/stretchr/testify/mock"
57 AssociatedE2TInstanceAddress = "10.0.2.15:38000"
58 CorruptedJson = "{\"errorCode\":401,\"errorMessage\":\"corrupted json\"}"
59 ValidationFailureJson = "{\"errorCode\":402,\"errorMessage\":\"Validation error\"}"
60 ResourceNotFoundJson = "{\"errorCode\":404,\"errorMessage\":\"Resource not found\"}"
61 NodebExistsJson = "{\"errorCode\":406,\"errorMessage\":\"Nodeb already exists\"}"
62 RnibErrorJson = "{\"errorCode\":500,\"errorMessage\":\"RNIB error\"}"
63 InternalErrorJson = "{\"errorCode\":501,\"errorMessage\":\"Internal Server Error. Please try again later\"}"
64 AddEnbUrl = "/nodeb/enb"
68 ServedNrCellInformationRequiredFields = []string{"cellId", "choiceNrMode", "nrMode", "servedPlmns"}
69 NrNeighbourInformationRequiredFields = []string{"nrCgi", "choiceNrMode", "nrMode"}
70 AddEnbRequestRequiredFields = []string{"ranName", "enb", "globalNbId"}
71 UpdateEnbRequestRequiredFields = []string{"enb"}
72 GlobalIdRequiredFields = []string{"plmnId", "nbId"}
73 EnbRequiredFields = []string{"enbType", "servedCells"}
74 ServedCellRequiredFields = []string{"broadcastPlmns", "cellId", "choiceEutraMode", "eutraMode", "tac"}
77 type controllerGetNodebTestContext struct {
79 nodebInfo *entities.NodebInfo
81 expectedStatusCode int
82 expectedJsonResponse string
85 type controllerGetNodebIdListTestContext struct {
86 nodebIdList []*entities.NbIdentity
88 expectedStatusCode int
89 expectedJsonResponse string
92 type getNodebInfoResult struct {
93 nodebInfo *entities.NodebInfo
97 type updateGnbCellsParams struct {
101 type updateEnbCellsParams struct {
105 type addEnbParams struct {
109 type addNbIdentityParams struct {
113 type removeServedCellsParams struct {
114 servedCellInfo []*entities.ServedCellInfo
118 type removeServedNrCellsParams struct {
119 servedNrCells []*entities.ServedNRCell
123 type controllerUpdateEnbTestContext struct {
124 getNodebInfoResult *getNodebInfoResult
125 removeServedCellsParams *removeServedCellsParams
126 updateEnbCellsParams *updateEnbCellsParams
127 requestBody map[string]interface{}
128 expectedStatusCode int
129 expectedJsonResponse string
132 type controllerUpdateGnbTestContext struct {
133 getNodebInfoResult *getNodebInfoResult
134 removeServedNrCellsParams *removeServedNrCellsParams
135 updateGnbCellsParams *updateGnbCellsParams
136 requestBody map[string]interface{}
137 expectedStatusCode int
138 expectedJsonResponse string
141 type controllerAddEnbTestContext struct {
142 getNodebInfoResult *getNodebInfoResult
143 addEnbParams *addEnbParams
144 addNbIdentityParams *addNbIdentityParams
145 requestBody map[string]interface{}
146 expectedStatusCode int
147 expectedJsonResponse string
150 type controllerDeleteEnbTestContext struct {
151 getNodebInfoResult *getNodebInfoResult
152 expectedStatusCode int
153 expectedJsonResponse string
156 func generateServedNrCells(cellIds ...string) []*entities.ServedNRCell {
158 servedNrCells := []*entities.ServedNRCell{}
160 for _, v := range cellIds {
161 servedNrCells = append(servedNrCells, &entities.ServedNRCell{ServedNrCellInformation: &entities.ServedNRCellInformation{
163 ChoiceNrMode: &entities.ServedNRCellInformation_ChoiceNRMode{
164 Fdd: &entities.ServedNRCellInformation_ChoiceNRMode_FddInfo{},
166 NrMode: entities.Nr_FDD,
168 ServedPlmns: []string{"whatever"},
175 func generateServedCells(cellIds ...string) []*entities.ServedCellInfo {
177 var servedCells []*entities.ServedCellInfo
179 for i, v := range cellIds {
180 servedCells = append(servedCells, &entities.ServedCellInfo{
182 ChoiceEutraMode: &entities.ChoiceEUTRAMode{
183 Fdd: &entities.FddInfo{},
186 BroadcastPlmns: []string{"whatever"},
193 func buildNrNeighbourInformation(propToOmit string) map[string]interface{} {
194 ret := map[string]interface{}{
196 "choiceNrMode": map[string]interface{}{
197 "tdd": map[string]interface{}{},
203 if len(propToOmit) != 0 {
204 delete(ret, propToOmit)
210 func buildServedNrCellInformation(propToOmit string) map[string]interface{} {
211 ret := map[string]interface{}{
212 "cellId": "whatever",
213 "choiceNrMode": map[string]interface{}{
214 "fdd": map[string]interface{}{},
218 "servedPlmns": []interface{}{
223 if len(propToOmit) != 0 {
224 delete(ret, propToOmit)
230 func buildServedCell(propToOmit string) map[string]interface{} {
231 ret := map[string]interface{}{
232 "cellId": "whatever",
233 "choiceEutraMode": map[string]interface{}{
234 "fdd": map[string]interface{}{},
239 "broadcastPlmns": []interface{}{
244 if len(propToOmit) != 0 {
245 delete(ret, propToOmit)
251 func getUpdateEnbRequest(propToOmit string) map[string]interface{} {
252 ret := map[string]interface{}{
253 "enb": buildEnb(propToOmit),
256 if len(propToOmit) != 0 {
257 delete(ret, propToOmit)
263 func getAddEnbRequest(propToOmit string) map[string]interface{} {
264 ret := map[string]interface{}{
266 "globalNbId": buildGlobalNbId(""),
270 if len(propToOmit) != 0 {
271 delete(ret, propToOmit)
277 func buildEnb(propToOmit string) map[string]interface{} {
278 ret := map[string]interface{}{
280 "servedCells": []interface{}{
284 if len(propToOmit) != 0 {
285 delete(ret, propToOmit)
291 func buildGlobalNbId(propToOmit string) map[string]interface{} {
292 ret := map[string]interface{}{
293 "plmnId": "whatever",
297 if len(propToOmit) != 0 {
298 delete(ret, propToOmit)
304 func setupControllerTest(t *testing.T) (*NodebController, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.RmrMessengerMock, *mocks.E2TInstancesManagerMock, managers.RanListManager) {
306 config := configuration.ParseConfiguration()
308 rmrMessengerMock := &mocks.RmrMessengerMock{}
309 readerMock := &mocks.RnibReaderMock{}
311 writerMock := &mocks.RnibWriterMock{}
313 rnibDataService := services.NewRnibDataService(log, config, readerMock, writerMock)
314 rmrSender := getRmrSender(rmrMessengerMock, log)
315 e2tInstancesManager := &mocks.E2TInstancesManagerMock{}
316 httpClientMock := &mocks.HttpClientMock{}
317 rmClient := clients.NewRoutingManagerClient(log, config, httpClientMock)
318 ranListManager := managers.NewRanListManager(log, rnibDataService)
319 ranAlarmService := &mocks.RanAlarmServiceMock{}
320 ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(log, rnibDataService, ranListManager, ranAlarmService)
321 nodebValidator := managers.NewNodebValidator()
322 updateEnbManager := managers.NewUpdateEnbManager(log, rnibDataService, nodebValidator)
323 updateGnbManager := managers.NewUpdateGnbManager(log, rnibDataService, nodebValidator)
324 handlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(log, rmrSender, config, rnibDataService, e2tInstancesManager, rmClient, ranConnectStatusChangeManager, nodebValidator, updateEnbManager, updateGnbManager, ranListManager)
325 controller := NewNodebController(log, handlerProvider)
326 return controller, readerMock, writerMock, rmrMessengerMock, e2tInstancesManager, ranListManager
329 func setupDeleteEnbControllerTest(t *testing.T, preAddNbIdentity bool) (*NodebController, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *entities.NbIdentity) {
331 config := configuration.ParseConfiguration()
333 rmrMessengerMock := &mocks.RmrMessengerMock{}
334 readerMock := &mocks.RnibReaderMock{}
336 writerMock := &mocks.RnibWriterMock{}
338 rnibDataService := services.NewRnibDataService(log, config, readerMock, writerMock)
339 rmrSender := getRmrSender(rmrMessengerMock, log)
340 e2tInstancesManager := &mocks.E2TInstancesManagerMock{}
341 httpClientMock := &mocks.HttpClientMock{}
342 rmClient := clients.NewRoutingManagerClient(log, config, httpClientMock)
343 ranListManager := managers.NewRanListManager(log, rnibDataService)
344 var nbIdentity *entities.NbIdentity
345 if preAddNbIdentity {
346 nbIdentity = &entities.NbIdentity{InventoryName: RanName, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
347 writerMock.On("AddNbIdentity", entities.Node_ENB, nbIdentity).Return(nil)
348 ranListManager.AddNbIdentity(entities.Node_ENB, nbIdentity)
350 ranAlarmService := &mocks.RanAlarmServiceMock{}
351 ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(log, rnibDataService, ranListManager, ranAlarmService)
352 nodebValidator := managers.NewNodebValidator()
353 updateEnbManager := managers.NewUpdateEnbManager(log, rnibDataService, nodebValidator)
354 updateGnbManager := managers.NewUpdateGnbManager(log, rnibDataService, nodebValidator)
356 handlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(log, rmrSender, config, rnibDataService, e2tInstancesManager, rmClient, ranConnectStatusChangeManager, nodebValidator, updateEnbManager, updateGnbManager, ranListManager)
357 controller := NewNodebController(log, handlerProvider)
358 return controller, readerMock, writerMock, nbIdentity
361 func TestShutdownHandlerRnibError(t *testing.T) {
362 controller, _, _, _, e2tInstancesManagerMock, _ := setupControllerTest(t)
363 e2tInstancesManagerMock.On("GetE2TAddresses").Return([]string{}, e2managererrors.NewRnibDbError())
365 writer := httptest.NewRecorder()
367 controller.Shutdown(writer, tests.GetHttpRequest())
369 var errorResponse = parseJsonRequest(t, writer.Body)
371 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
372 assert.Equal(t, errorResponse.Code, e2managererrors.NewRnibDbError().Code)
375 func TestSetGeneralConfigurationHandlerRnibError(t *testing.T) {
376 controller, readerMock, _, _, _, _ := setupControllerTest(t)
378 configuration := &entities.GeneralConfiguration{}
379 readerMock.On("GetGeneralConfiguration").Return(configuration, e2managererrors.NewRnibDbError())
381 writer := httptest.NewRecorder()
383 httpRequest, _ := http.NewRequest("PUT", "https://localhost:3800/v1/nodeb/parameters", strings.NewReader("{\"enableRic\":false}"))
385 controller.SetGeneralConfiguration(writer, httpRequest)
387 var errorResponse = parseJsonRequest(t, writer.Body)
389 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
390 assert.Equal(t, e2managererrors.NewRnibDbError().Code, errorResponse.Code)
393 func TestSetGeneralConfigurationInvalidJson(t *testing.T) {
394 controller, _, _, _, _, _ := setupControllerTest(t)
396 writer := httptest.NewRecorder()
398 httpRequest, _ := http.NewRequest("PUT", "https://localhost:3800/v1/nodeb/parameters", strings.NewReader("{\"enableRic\":false, \"someValue\":false}"))
400 controller.SetGeneralConfiguration(writer, httpRequest)
402 var errorResponse = parseJsonRequest(t, writer.Body)
404 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
405 assert.Equal(t, e2managererrors.NewInvalidJsonError().Code, errorResponse.Code)
408 func controllerGetNodebTestExecuter(t *testing.T, context *controllerGetNodebTestContext) {
409 controller, readerMock, _, _, _, _ := setupControllerTest(t)
410 writer := httptest.NewRecorder()
411 readerMock.On("GetNodeb", context.ranName).Return(context.nodebInfo, context.rnibError)
412 req, _ := http.NewRequest(http.MethodGet, "/nodeb", nil)
413 req = mux.SetURLVars(req, map[string]string{"ranName": context.ranName})
414 controller.GetNodeb(writer, req)
415 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
416 bodyBytes, _ := ioutil.ReadAll(writer.Body)
417 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
420 func controllerGetNodebIdListTestExecuter(t *testing.T, context *controllerGetNodebIdListTestContext) {
421 controller, readerMock, _, _, _, ranListManager := setupControllerTest(t)
422 writer := httptest.NewRecorder()
423 readerMock.On("GetListNodebIds").Return(context.nodebIdList, context.rnibError)
425 err := ranListManager.InitNbIdentityMap()
427 t.Errorf("Error cannot init identity")
430 req, _ := http.NewRequest(http.MethodGet, "/nodeb/states", nil)
431 controller.GetNodebIdList(writer, req)
432 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
433 bodyBytes, _ := ioutil.ReadAll(writer.Body)
434 assert.Contains(t, context.expectedJsonResponse, string(bodyBytes))
437 func activateControllerUpdateEnbMocks(context *controllerUpdateEnbTestContext, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock, updateEnbRequest *models.UpdateEnbRequest) {
438 if context.getNodebInfoResult != nil {
439 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
442 if context.removeServedCellsParams != nil {
443 writerMock.On("RemoveServedCells", RanName, context.removeServedCellsParams.servedCellInfo).Return(context.removeServedCellsParams.err)
446 if context.updateEnbCellsParams != nil {
447 updatedNodebInfo := *context.getNodebInfoResult.nodebInfo
449 if context.getNodebInfoResult.nodebInfo.SetupFromNetwork {
450 updateEnbRequest.Enb.EnbType = context.getNodebInfoResult.nodebInfo.GetEnb().EnbType
453 updatedNodebInfo.Configuration = &entities.NodebInfo_Enb{Enb: updateEnbRequest.Enb}
455 writerMock.On("UpdateEnb", &updatedNodebInfo, updateEnbRequest.Enb.ServedCells).Return(context.updateEnbCellsParams.err)
459 func activateControllerUpdateGnbMocks(context *controllerUpdateGnbTestContext, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
460 if context.getNodebInfoResult != nil {
461 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
464 if context.removeServedNrCellsParams != nil {
465 writerMock.On("RemoveServedNrCells", RanName, context.removeServedNrCellsParams.servedNrCells).Return(context.removeServedNrCellsParams.err)
468 if context.updateGnbCellsParams != nil {
469 updatedNodebInfo := *context.getNodebInfoResult.nodebInfo
470 gnb := entities.Gnb{}
471 _ = jsonpb.Unmarshal(getJsonRequestAsBuffer(context.requestBody), &gnb)
472 updatedGnb := *updatedNodebInfo.GetGnb()
473 updatedGnb.ServedNrCells = gnb.ServedNrCells
474 writerMock.On("UpdateGnbCells", &updatedNodebInfo, gnb.ServedNrCells).Return(context.updateGnbCellsParams.err)
478 func assertControllerUpdateGnb(t *testing.T, context *controllerUpdateGnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
479 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
480 bodyBytes, _ := ioutil.ReadAll(writer.Body)
481 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
482 readerMock.AssertExpectations(t)
483 writerMock.AssertExpectations(t)
486 func assertControllerUpdateEnb(t *testing.T, context *controllerUpdateEnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
487 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
488 bodyBytes, _ := ioutil.ReadAll(writer.Body)
489 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
490 readerMock.AssertExpectations(t)
491 writerMock.AssertExpectations(t)
494 func assertControllerAddEnb(t *testing.T, context *controllerAddEnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
495 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
496 bodyBytes, _ := ioutil.ReadAll(writer.Body)
497 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
498 readerMock.AssertExpectations(t)
499 writerMock.AssertExpectations(t)
502 func assertControllerDeleteEnb(t *testing.T, context *controllerDeleteEnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
503 assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
504 bodyBytes, _ := ioutil.ReadAll(writer.Body)
505 assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
506 readerMock.AssertExpectations(t)
507 writerMock.AssertExpectations(t)
510 func buildUpdateEnbRequest(context *controllerUpdateEnbTestContext) *http.Request {
511 updateEnbUrl := fmt.Sprintf("/nodeb/enb/%s", RanName)
512 requestBody := getJsonRequestAsBuffer(context.requestBody)
513 req, _ := http.NewRequest(http.MethodPut, updateEnbUrl, requestBody)
514 req.Header.Set("Content-Type", "application/json")
515 req = mux.SetURLVars(req, map[string]string{"ranName": RanName})
519 func buildUpdateGnbRequest(context *controllerUpdateGnbTestContext) *http.Request {
520 updateGnbUrl := fmt.Sprintf("/nodeb/gnb/%s", RanName)
521 requestBody := getJsonRequestAsBuffer(context.requestBody)
522 req, _ := http.NewRequest(http.MethodPut, updateGnbUrl, requestBody)
523 req.Header.Set("Content-Type", "application/json")
524 req = mux.SetURLVars(req, map[string]string{"ranName": RanName})
528 func buildAddEnbRequest(context *controllerAddEnbTestContext) *http.Request {
529 requestBody := getJsonRequestAsBuffer(context.requestBody)
530 req, _ := http.NewRequest(http.MethodPost, AddEnbUrl, requestBody)
531 req.Header.Set("Content-Type", "application/json")
535 func controllerUpdateEnbTestExecuter(t *testing.T, context *controllerUpdateEnbTestContext) {
536 controller, readerMock, writerMock, _, _, _ := setupControllerTest(t)
537 writer := httptest.NewRecorder()
539 r := buildUpdateEnbRequest(context)
540 body, _ := ioutil.ReadAll(io.LimitReader(r.Body, LimitRequest))
542 updateEnbRequest := models.UpdateEnbRequest{}
543 _ = json.Unmarshal(body, &updateEnbRequest)
545 activateControllerUpdateEnbMocks(context, readerMock, writerMock, &updateEnbRequest)
546 r = buildUpdateEnbRequest(context)
549 controller.UpdateEnb(writer, r)
551 assertControllerUpdateEnb(t, context, writer, readerMock, writerMock)
554 func controllerUpdateGnbTestExecuter(t *testing.T, context *controllerUpdateGnbTestContext) {
555 controller, readerMock, writerMock, _, _, _ := setupControllerTest(t)
556 writer := httptest.NewRecorder()
558 activateControllerUpdateGnbMocks(context, readerMock, writerMock)
559 req := buildUpdateGnbRequest(context)
560 controller.UpdateGnb(writer, req)
561 assertControllerUpdateGnb(t, context, writer, readerMock, writerMock)
564 func activateControllerAddEnbMocks(context *controllerAddEnbTestContext, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock, addEnbRequest *models.AddEnbRequest) {
565 if context.getNodebInfoResult != nil {
566 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
569 if context.addEnbParams != nil {
570 nodebInfo := entities.NodebInfo{
571 RanName: addEnbRequest.RanName,
572 Ip: addEnbRequest.Ip,
573 Port: addEnbRequest.Port,
574 NodeType: entities.Node_ENB,
575 GlobalNbId: addEnbRequest.GlobalNbId,
576 Configuration: &entities.NodebInfo_Enb{Enb: addEnbRequest.Enb},
577 ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,
580 writerMock.On("AddEnb", &nodebInfo).Return(context.addEnbParams.err)
583 if context.addNbIdentityParams != nil {
584 nbIdentity := entities.NbIdentity{InventoryName: addEnbRequest.RanName, GlobalNbId: addEnbRequest.GlobalNbId, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED}
585 writerMock.On("AddNbIdentity", entities.Node_ENB, &nbIdentity).Return(context.addNbIdentityParams.err)
589 func controllerAddEnbTestExecuter(t *testing.T, context *controllerAddEnbTestContext) {
590 controller, readerMock, writerMock, _, _, _ := setupControllerTest(t)
591 writer := httptest.NewRecorder()
592 r := buildAddEnbRequest(context)
593 body, _ := ioutil.ReadAll(io.LimitReader(r.Body, LimitRequest))
595 addEnbRequest := models.AddEnbRequest{}
597 _ = json.Unmarshal(body, &addEnbRequest)
598 activateControllerAddEnbMocks(context, readerMock, writerMock, &addEnbRequest)
599 r = buildAddEnbRequest(context)
601 controller.AddEnb(writer, r)
602 assertControllerAddEnb(t, context, writer, readerMock, writerMock)
605 func controllerDeleteEnbTestExecuter(t *testing.T, context *controllerDeleteEnbTestContext, preAddNbIdentity bool) {
606 controller, readerMock, writerMock, nbIdentity := setupDeleteEnbControllerTest(t, preAddNbIdentity)
607 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
608 if context.getNodebInfoResult.rnibError == nil && context.getNodebInfoResult.nodebInfo.GetNodeType() == entities.Node_ENB &&
609 !context.getNodebInfoResult.nodebInfo.SetupFromNetwork {
610 writerMock.On("RemoveEnb", context.getNodebInfoResult.nodebInfo).Return(nil)
611 if preAddNbIdentity {
612 writerMock.On("RemoveNbIdentity", entities.Node_ENB, nbIdentity).Return(nil)
615 writer := httptest.NewRecorder()
616 r, _ := http.NewRequest(http.MethodDelete, AddEnbUrl+"/"+RanName, nil)
617 r.Header.Set("Content-Type", "application/json")
618 r = mux.SetURLVars(r, map[string]string{"ranName": RanName})
619 controller.DeleteEnb(writer, r)
620 assertControllerDeleteEnb(t, context, writer, readerMock, writerMock)
627 // BEGIN - UpdateGnb Validation Failure UTs
629 func TestControllerUpdateGnbEmptyServedNrCells(t *testing.T) {
630 context := controllerUpdateGnbTestContext{
631 getNodebInfoResult: nil,
632 requestBody: map[string]interface{}{
633 "servedNrCells": []interface{}{},
635 expectedStatusCode: http.StatusBadRequest,
636 expectedJsonResponse: ValidationFailureJson,
639 controllerUpdateGnbTestExecuter(t, &context)
642 func TestControllerUpdateGnbMissingServedNrCellInformation(t *testing.T) {
643 context := controllerUpdateGnbTestContext{
644 getNodebInfoResult: nil,
645 requestBody: map[string]interface{}{
646 "servedNrCells": []interface{}{
647 map[string]interface{}{
648 "servedNrCellInformation": nil,
652 expectedStatusCode: http.StatusBadRequest,
653 expectedJsonResponse: ValidationFailureJson,
656 controllerUpdateGnbTestExecuter(t, &context)
659 func TestControllerUpdateGnbMissingServedNrCellRequiredProp(t *testing.T) {
661 for _, v := range ServedNrCellInformationRequiredFields {
662 context := controllerUpdateGnbTestContext{
663 getNodebInfoResult: nil,
664 requestBody: map[string]interface{}{
665 "servedNrCells": []interface{}{
666 map[string]interface{}{
667 "servedNrCellInformation": buildServedNrCellInformation(v),
671 expectedStatusCode: http.StatusBadRequest,
672 expectedJsonResponse: ValidationFailureJson,
675 controllerUpdateGnbTestExecuter(t, &context)
679 func TestControllerUpdateGnbMissingServedNrCellFddOrTdd(t *testing.T) {
681 servedNrCellInformation := buildServedNrCellInformation("")
682 servedNrCellInformation["choiceNrMode"] = map[string]interface{}{}
684 context := controllerUpdateGnbTestContext{
685 getNodebInfoResult: nil,
686 requestBody: map[string]interface{}{
687 "servedNrCells": []interface{}{
688 map[string]interface{}{
689 "servedNrCellInformation": servedNrCellInformation,
693 expectedStatusCode: http.StatusBadRequest,
694 expectedJsonResponse: ValidationFailureJson,
697 controllerUpdateGnbTestExecuter(t, &context)
700 func TestControllerUpdateGnbMissingNeighbourInfoFddOrTdd(t *testing.T) {
702 nrNeighbourInfo := buildNrNeighbourInformation("")
703 nrNeighbourInfo["choiceNrMode"] = map[string]interface{}{}
705 context := controllerUpdateGnbTestContext{
706 getNodebInfoResult: nil,
707 requestBody: map[string]interface{}{
708 "servedNrCells": []interface{}{
709 map[string]interface{}{
710 "servedNrCellInformation": buildServedNrCellInformation(""),
711 "nrNeighbourInfos": []interface{}{
717 expectedStatusCode: http.StatusBadRequest,
718 expectedJsonResponse: ValidationFailureJson,
721 controllerUpdateGnbTestExecuter(t, &context)
724 func TestControllerUpdateGnbMissingNrNeighbourInformationRequiredProp(t *testing.T) {
726 for _, v := range NrNeighbourInformationRequiredFields {
727 context := controllerUpdateGnbTestContext{
728 getNodebInfoResult: nil,
729 requestBody: map[string]interface{}{
730 "servedNrCells": []interface{}{
731 map[string]interface{}{
732 "servedNrCellInformation": buildServedNrCellInformation(""),
733 "nrNeighbourInfos": []interface{}{
734 buildNrNeighbourInformation(v),
739 expectedStatusCode: http.StatusBadRequest,
740 expectedJsonResponse: ValidationFailureJson,
743 controllerUpdateGnbTestExecuter(t, &context)
747 // END - UpdateGnb Validation Failure UTs
749 func TestControllerUpdateGnbValidServedNrCellInformationGetNodebNotFound(t *testing.T) {
750 context := controllerUpdateGnbTestContext{
751 getNodebInfoResult: &getNodebInfoResult{
753 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
755 requestBody: map[string]interface{}{
756 "servedNrCells": []interface{}{
757 map[string]interface{}{
758 "servedNrCellInformation": buildServedNrCellInformation(""),
762 expectedStatusCode: http.StatusNotFound,
763 expectedJsonResponse: ResourceNotFoundJson,
766 controllerUpdateGnbTestExecuter(t, &context)
769 func TestControllerUpdateGnbValidServedNrCellInformationGetNodebInternalError(t *testing.T) {
770 context := controllerUpdateGnbTestContext{
771 getNodebInfoResult: &getNodebInfoResult{
773 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
775 requestBody: map[string]interface{}{
776 "servedNrCells": []interface{}{
777 map[string]interface{}{
778 "servedNrCellInformation": buildServedNrCellInformation(""),
782 expectedStatusCode: http.StatusInternalServerError,
783 expectedJsonResponse: RnibErrorJson,
786 controllerUpdateGnbTestExecuter(t, &context)
789 func TestControllerUpdateGnbGetNodebSuccessInvalidGnbConfiguration(t *testing.T) {
790 context := controllerUpdateGnbTestContext{
791 getNodebInfoResult: &getNodebInfoResult{
792 nodebInfo: &entities.NodebInfo{
794 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
795 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
796 NodeType: entities.Node_ENB,
800 requestBody: map[string]interface{}{
801 "servedNrCells": []interface{}{
802 map[string]interface{}{
803 "servedNrCellInformation": buildServedNrCellInformation(""),
804 "nrNeighbourInfos": []interface{}{
805 buildNrNeighbourInformation(""),
810 expectedStatusCode: http.StatusBadRequest,
811 expectedJsonResponse: ValidationFailureJson,
814 controllerUpdateGnbTestExecuter(t, &context)
817 func TestControllerUpdateGnbGetNodebSuccessRemoveServedNrCellsFailure(t *testing.T) {
818 oldServedNrCells := generateServedNrCells("whatever1", "whatever2")
819 context := controllerUpdateGnbTestContext{
820 removeServedNrCellsParams: &removeServedNrCellsParams{
821 err: common.NewInternalError(errors.New("#writer.UpdateGnbCells - Internal Error")),
822 servedNrCells: oldServedNrCells,
824 getNodebInfoResult: &getNodebInfoResult{
825 nodebInfo: &entities.NodebInfo{
827 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
828 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
829 Configuration: &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{ServedNrCells: oldServedNrCells}},
830 NodeType: entities.Node_GNB,
834 requestBody: map[string]interface{}{
835 "servedNrCells": []interface{}{
836 map[string]interface{}{
837 "servedNrCellInformation": buildServedNrCellInformation(""),
838 "nrNeighbourInfos": []interface{}{
839 buildNrNeighbourInformation(""),
844 expectedStatusCode: http.StatusInternalServerError,
845 expectedJsonResponse: RnibErrorJson,
848 controllerUpdateGnbTestExecuter(t, &context)
851 func TestControllerUpdateGnbGetNodebSuccessUpdateGnbCellsFailure(t *testing.T) {
852 oldServedNrCells := generateServedNrCells("whatever1", "whatever2")
853 context := controllerUpdateGnbTestContext{
854 removeServedNrCellsParams: &removeServedNrCellsParams{
856 servedNrCells: oldServedNrCells,
858 updateGnbCellsParams: &updateGnbCellsParams{
859 err: common.NewInternalError(errors.New("#writer.UpdateGnbCells - Internal Error")),
861 getNodebInfoResult: &getNodebInfoResult{
862 nodebInfo: &entities.NodebInfo{
864 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
865 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
866 Configuration: &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{ServedNrCells: oldServedNrCells}},
867 NodeType: entities.Node_GNB,
871 requestBody: map[string]interface{}{
872 "servedNrCells": []interface{}{
873 map[string]interface{}{
874 "servedNrCellInformation": buildServedNrCellInformation(""),
875 "nrNeighbourInfos": []interface{}{
876 buildNrNeighbourInformation(""),
881 expectedStatusCode: http.StatusInternalServerError,
882 expectedJsonResponse: RnibErrorJson,
885 controllerUpdateGnbTestExecuter(t, &context)
888 func TestControllerUpdateGnbExistingEmptyCellsSuccess(t *testing.T) {
889 oldServedNrCells := []*entities.ServedNRCell{}
891 context := controllerUpdateGnbTestContext{
892 updateGnbCellsParams: &updateGnbCellsParams{
895 getNodebInfoResult: &getNodebInfoResult{
896 nodebInfo: &entities.NodebInfo{
898 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
899 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
900 Configuration: &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{ServedNrCells: oldServedNrCells}},
901 NodeType: entities.Node_GNB,
905 requestBody: map[string]interface{}{
906 "servedNrCells": []interface{}{
907 map[string]interface{}{
908 "servedNrCellInformation": buildServedNrCellInformation(""),
909 "nrNeighbourInfos": []interface{}{
910 buildNrNeighbourInformation(""),
915 expectedStatusCode: http.StatusOK,
916 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\"}",
919 controllerUpdateGnbTestExecuter(t, &context)
922 func TestControllerUpdateGnbSuccess(t *testing.T) {
923 oldServedNrCells := generateServedNrCells("whatever1", "whatever2")
925 context := controllerUpdateGnbTestContext{
926 removeServedNrCellsParams: &removeServedNrCellsParams{
928 servedNrCells: oldServedNrCells,
930 updateGnbCellsParams: &updateGnbCellsParams{
933 getNodebInfoResult: &getNodebInfoResult{
934 nodebInfo: &entities.NodebInfo{
936 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
937 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
938 Configuration: &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{ServedNrCells: oldServedNrCells}},
939 NodeType: entities.Node_GNB,
943 requestBody: map[string]interface{}{
944 "servedNrCells": []interface{}{
945 map[string]interface{}{
946 "servedNrCellInformation": buildServedNrCellInformation(""),
947 "nrNeighbourInfos": []interface{}{
948 buildNrNeighbourInformation(""),
953 expectedStatusCode: http.StatusOK,
954 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\"}",
957 controllerUpdateGnbTestExecuter(t, &context)
964 func TestControllerUpdateEnbInvalidRequest(t *testing.T) {
965 controller, _, _, _, _, _ := setupControllerTest(t)
967 writer := httptest.NewRecorder()
968 invalidJson := strings.NewReader("{enb:\"whatever\"")
970 updateEnbUrl := fmt.Sprintf("/nodeb/enb/%s", RanName)
971 req, _ := http.NewRequest(http.MethodPut, updateEnbUrl, invalidJson)
972 req.Header.Set("Content-Type", "application/json")
973 req = mux.SetURLVars(req, map[string]string{"ranName": RanName})
975 controller.UpdateEnb(writer, req)
977 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
978 bodyBytes, _ := ioutil.ReadAll(writer.Body)
979 assert.Equal(t, CorruptedJson, string(bodyBytes))
982 func TestControllerUpdateEnbEmptyEnbType(t *testing.T) {
983 context := controllerUpdateEnbTestContext{
984 getNodebInfoResult: nil,
985 requestBody: getUpdateEnbRequest(EnbRequiredFields[0]),
986 expectedStatusCode: http.StatusBadRequest,
987 expectedJsonResponse: ValidationFailureJson,
990 controllerUpdateEnbTestExecuter(t, &context)
993 func TestControllerUpdateEnbEmptyServedCells(t *testing.T) {
994 context := controllerUpdateEnbTestContext{
995 getNodebInfoResult: nil,
996 requestBody: getUpdateEnbRequest(EnbRequiredFields[1]),
997 expectedStatusCode: http.StatusBadRequest,
998 expectedJsonResponse: ValidationFailureJson,
1001 controllerUpdateEnbTestExecuter(t, &context)
1004 func TestControllerUpdateEnbMissingEnb(t *testing.T) {
1005 context := controllerUpdateEnbTestContext{
1006 getNodebInfoResult: nil,
1007 requestBody: getUpdateEnbRequest(UpdateEnbRequestRequiredFields[0]),
1008 expectedStatusCode: http.StatusBadRequest,
1009 expectedJsonResponse: ValidationFailureJson,
1012 controllerUpdateEnbTestExecuter(t, &context)
1015 func TestControllerUpdateEnbMissingRequiredServedCellProps(t *testing.T) {
1017 r := getUpdateEnbRequest("")
1019 for _, v := range ServedCellRequiredFields {
1022 enbMap, _ := enb.(map[string]interface{})
1024 enbMap["servedCells"] = []interface{}{
1028 context := controllerUpdateEnbTestContext{
1030 expectedStatusCode: http.StatusBadRequest,
1031 expectedJsonResponse: ValidationFailureJson,
1034 controllerUpdateEnbTestExecuter(t, &context)
1038 func TestControllerUpdateEnbValidServedCellsGetNodebNotFound(t *testing.T) {
1039 context := controllerUpdateEnbTestContext{
1040 getNodebInfoResult: &getNodebInfoResult{
1042 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1044 requestBody: getUpdateEnbRequest(""),
1045 expectedStatusCode: http.StatusNotFound,
1046 expectedJsonResponse: ResourceNotFoundJson,
1049 controllerUpdateEnbTestExecuter(t, &context)
1052 func TestControllerUpdateEnbValidServedCellsGetNodebInternalError(t *testing.T) {
1053 context := controllerUpdateEnbTestContext{
1054 getNodebInfoResult: &getNodebInfoResult{
1056 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
1058 requestBody: getUpdateEnbRequest(""),
1059 expectedStatusCode: http.StatusInternalServerError,
1060 expectedJsonResponse: RnibErrorJson,
1063 controllerUpdateEnbTestExecuter(t, &context)
1066 func TestControllerUpdateEnbGetNodebSuccessGnbTypeFailure(t *testing.T) {
1067 oldServedCells := generateServedCells("whatever1", "whatever2")
1068 context := controllerUpdateEnbTestContext{
1069 getNodebInfoResult: &getNodebInfoResult{
1070 nodebInfo: &entities.NodebInfo{
1072 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
1073 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1074 NodeType: entities.Node_GNB,
1075 Configuration: &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells}},
1079 requestBody: getUpdateEnbRequest(""),
1080 expectedStatusCode: http.StatusBadRequest,
1081 expectedJsonResponse: ValidationFailureJson,
1084 controllerUpdateEnbTestExecuter(t, &context)
1087 func TestControllerUpdateEnbGetNodebSuccessRemoveServedCellsFailure(t *testing.T) {
1088 oldServedCells := generateServedCells("whatever1", "whatever2")
1089 context := controllerUpdateEnbTestContext{
1090 removeServedCellsParams: &removeServedCellsParams{
1091 err: common.NewInternalError(errors.New("#writer.RemoveServedCells - Internal Error")),
1092 servedCellInfo: oldServedCells,
1094 getNodebInfoResult: &getNodebInfoResult{
1095 nodebInfo: &entities.NodebInfo{
1097 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
1098 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1099 NodeType: entities.Node_ENB,
1100 Configuration: &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells}},
1104 requestBody: getUpdateEnbRequest(""),
1105 expectedStatusCode: http.StatusInternalServerError,
1106 expectedJsonResponse: RnibErrorJson,
1109 controllerUpdateEnbTestExecuter(t, &context)
1112 func TestControllerUpdateEnbGetNodebSuccessUpdateEnbFailure(t *testing.T) {
1113 oldServedCells := generateServedCells("whatever1", "whatever2")
1114 context := controllerUpdateEnbTestContext{
1115 removeServedCellsParams: &removeServedCellsParams{
1117 servedCellInfo: oldServedCells,
1119 updateEnbCellsParams: &updateEnbCellsParams{
1120 err: common.NewInternalError(errors.New("#writer.UpdateEnb - Internal Error")),
1122 getNodebInfoResult: &getNodebInfoResult{
1123 nodebInfo: &entities.NodebInfo{
1125 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
1126 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1127 NodeType: entities.Node_ENB,
1128 Configuration: &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells, EnbType: entities.EnbType_MACRO_ENB}},
1132 requestBody: getUpdateEnbRequest(""),
1133 expectedStatusCode: http.StatusInternalServerError,
1134 expectedJsonResponse: RnibErrorJson,
1137 controllerUpdateEnbTestExecuter(t, &context)
1140 func TestControllerUpdateEnbExistingEmptyCellsSuccess(t *testing.T) {
1141 oldServedCells := []*entities.ServedCellInfo{}
1142 context := controllerUpdateEnbTestContext{
1143 updateEnbCellsParams: &updateEnbCellsParams{
1146 getNodebInfoResult: &getNodebInfoResult{
1147 nodebInfo: &entities.NodebInfo{
1149 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
1150 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1151 NodeType: entities.Node_ENB,
1152 Configuration: &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells, EnbType: entities.EnbType_MACRO_ENB}},
1156 requestBody: getUpdateEnbRequest(""),
1157 expectedStatusCode: http.StatusOK,
1158 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\"}",
1161 controllerUpdateEnbTestExecuter(t, &context)
1164 func TestControllerUpdateEnbNgEnbFailure(t *testing.T) {
1166 requestBody := map[string]interface{}{
1167 "enb": map[string]interface{}{
1169 "servedCells": []interface{}{
1170 buildServedCell(""),
1174 oldServedCells := generateServedCells("whatever1", "whatever2")
1176 context := controllerUpdateEnbTestContext{
1177 getNodebInfoResult: &getNodebInfoResult{
1178 nodebInfo: &entities.NodebInfo{
1180 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
1181 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1182 NodeType: entities.Node_ENB,
1183 Configuration: &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells, EnbType: entities.EnbType_MACRO_NG_ENB}},
1187 requestBody: requestBody,
1188 expectedStatusCode: http.StatusBadRequest,
1189 expectedJsonResponse: ValidationFailureJson,
1192 controllerUpdateEnbTestExecuter(t, &context)
1195 func TestControllerUpdateEnbSuccessSetupFromNwFalse(t *testing.T) {
1196 oldServedCells := generateServedCells("whatever1", "whatever2")
1197 context := controllerUpdateEnbTestContext{
1198 removeServedCellsParams: &removeServedCellsParams{
1200 servedCellInfo: oldServedCells,
1202 updateEnbCellsParams: &updateEnbCellsParams{
1205 getNodebInfoResult: &getNodebInfoResult{
1206 nodebInfo: &entities.NodebInfo{
1208 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
1209 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1210 NodeType: entities.Node_ENB,
1211 Configuration: &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells, EnbType: entities.EnbType_LONG_MACRO_ENB}},
1215 requestBody: getUpdateEnbRequest(""),
1216 expectedStatusCode: http.StatusOK,
1217 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\"}",
1220 controllerUpdateEnbTestExecuter(t, &context)
1223 func TestControllerUpdateEnbSuccessSetupFromNwTrue(t *testing.T) {
1224 oldServedCells := generateServedCells("whatever1", "whatever2")
1225 context := controllerUpdateEnbTestContext{
1226 removeServedCellsParams: &removeServedCellsParams{
1228 servedCellInfo: oldServedCells,
1230 updateEnbCellsParams: &updateEnbCellsParams{
1233 getNodebInfoResult: &getNodebInfoResult{
1234 nodebInfo: &entities.NodebInfo{
1236 ConnectionStatus: entities.ConnectionStatus_CONNECTED,
1237 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1238 NodeType: entities.Node_ENB,
1239 Configuration: &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells, EnbType: entities.EnbType_LONG_MACRO_ENB}},
1240 SetupFromNetwork: true,
1244 requestBody: getUpdateEnbRequest(""),
1245 expectedStatusCode: http.StatusOK,
1246 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}",
1249 controllerUpdateEnbTestExecuter(t, &context)
1256 func TestControllerAddEnbGetNodebInternalError(t *testing.T) {
1257 context := controllerAddEnbTestContext{
1258 getNodebInfoResult: &getNodebInfoResult{
1260 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
1262 requestBody: getAddEnbRequest(""),
1263 expectedStatusCode: http.StatusInternalServerError,
1264 expectedJsonResponse: RnibErrorJson,
1267 controllerAddEnbTestExecuter(t, &context)
1270 func TestControllerAddEnbNodebExistsFailure(t *testing.T) {
1271 context := controllerAddEnbTestContext{
1272 getNodebInfoResult: &getNodebInfoResult{
1273 nodebInfo: &entities.NodebInfo{},
1276 requestBody: getAddEnbRequest(""),
1277 expectedStatusCode: http.StatusBadRequest,
1278 expectedJsonResponse: NodebExistsJson,
1281 controllerAddEnbTestExecuter(t, &context)
1284 func TestControllerAddEnbSaveNodebFailure(t *testing.T) {
1285 context := controllerAddEnbTestContext{
1286 addEnbParams: &addEnbParams{
1287 err: common.NewInternalError(errors.New("#reader.AddEnb - Internal Error")),
1289 getNodebInfoResult: &getNodebInfoResult{
1291 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1293 requestBody: getAddEnbRequest(""),
1294 expectedStatusCode: http.StatusInternalServerError,
1295 expectedJsonResponse: RnibErrorJson,
1298 controllerAddEnbTestExecuter(t, &context)
1301 func TestControllerAddEnbAddNbIdentityFailure(t *testing.T) {
1302 context := controllerAddEnbTestContext{
1303 addEnbParams: &addEnbParams{
1306 addNbIdentityParams: &addNbIdentityParams{
1307 err: common.NewInternalError(errors.New("#writer.addNbIdentity - Internal Error")),
1309 getNodebInfoResult: &getNodebInfoResult{
1311 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1313 requestBody: getAddEnbRequest(""),
1314 expectedStatusCode: http.StatusInternalServerError,
1315 expectedJsonResponse: RnibErrorJson,
1318 controllerAddEnbTestExecuter(t, &context)
1321 func TestControllerAddEnbMissingRequiredRequestProps(t *testing.T) {
1323 for _, v := range AddEnbRequestRequiredFields {
1324 context := controllerAddEnbTestContext{
1325 requestBody: getAddEnbRequest(v),
1326 expectedStatusCode: http.StatusBadRequest,
1327 expectedJsonResponse: ValidationFailureJson,
1330 controllerAddEnbTestExecuter(t, &context)
1334 func TestControllerAddEnbInvalidRequest(t *testing.T) {
1335 controller, _, _, _, _, _ := setupControllerTest(t)
1336 writer := httptest.NewRecorder()
1338 // Invalid json: attribute name without quotes (should be "cause":).
1339 invalidJson := strings.NewReader("{ranName:\"whatever\"")
1340 req, _ := http.NewRequest(http.MethodPost, AddEnbUrl, invalidJson)
1342 controller.AddEnb(writer, req)
1343 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1344 bodyBytes, _ := ioutil.ReadAll(writer.Body)
1345 assert.Equal(t, CorruptedJson, string(bodyBytes))
1349 func TestControllerAddEnbMissingRequiredGlobalNbIdProps(t *testing.T) {
1351 r := getAddEnbRequest("")
1353 for _, v := range GlobalIdRequiredFields {
1354 r["globalNbId"] = buildGlobalNbId(v)
1356 context := controllerAddEnbTestContext{
1358 expectedStatusCode: http.StatusBadRequest,
1359 expectedJsonResponse: ValidationFailureJson,
1362 controllerAddEnbTestExecuter(t, &context)
1366 func TestControllerAddEnbMissingRequiredEnbProps(t *testing.T) {
1368 r := getAddEnbRequest("")
1370 for _, v := range EnbRequiredFields {
1371 r["enb"] = buildEnb(v)
1373 context := controllerAddEnbTestContext{
1375 expectedStatusCode: http.StatusBadRequest,
1376 expectedJsonResponse: ValidationFailureJson,
1379 controllerAddEnbTestExecuter(t, &context)
1383 func TestControllerAddEnbMissingRequiredServedCellProps(t *testing.T) {
1385 r := getAddEnbRequest("")
1387 for _, v := range ServedCellRequiredFields {
1390 enbMap, _ := enb.(map[string]interface{})
1392 enbMap["servedCells"] = []interface{}{
1396 context := controllerAddEnbTestContext{
1398 expectedStatusCode: http.StatusBadRequest,
1399 expectedJsonResponse: ValidationFailureJson,
1402 controllerAddEnbTestExecuter(t, &context)
1406 func TestControllerAddEnbNgEnbFailure(t *testing.T) {
1408 requestBody := map[string]interface{}{
1410 "globalNbId": buildGlobalNbId(""),
1411 "enb": map[string]interface{}{
1413 "servedCells": []interface{}{
1414 buildServedCell(""),
1419 context := controllerAddEnbTestContext{
1420 requestBody: requestBody,
1421 expectedStatusCode: http.StatusBadRequest,
1422 expectedJsonResponse: ValidationFailureJson,
1425 controllerAddEnbTestExecuter(t, &context)
1428 func TestControllerAddEnbSuccess(t *testing.T) {
1429 context := controllerAddEnbTestContext{
1430 addEnbParams: &addEnbParams{
1433 addNbIdentityParams: &addNbIdentityParams{
1436 getNodebInfoResult: &getNodebInfoResult{
1438 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1440 requestBody: getAddEnbRequest(""),
1441 expectedStatusCode: http.StatusCreated,
1442 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\"}]}}",
1445 controllerAddEnbTestExecuter(t, &context)
1448 func TestControllerDeleteEnbGetNodebInternalError(t *testing.T) {
1449 context := controllerDeleteEnbTestContext{
1450 getNodebInfoResult: &getNodebInfoResult{
1452 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
1454 expectedStatusCode: http.StatusInternalServerError,
1455 expectedJsonResponse: RnibErrorJson,
1458 controllerDeleteEnbTestExecuter(t, &context, false)
1465 func TestControllerDeleteEnbNodebNotExistsFailure(t *testing.T) {
1466 context := controllerDeleteEnbTestContext{
1467 getNodebInfoResult: &getNodebInfoResult{
1469 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found"),
1471 expectedStatusCode: http.StatusNotFound,
1472 expectedJsonResponse: ResourceNotFoundJson,
1475 controllerDeleteEnbTestExecuter(t, &context, false)
1478 func TestControllerDeleteEnbNodebNotEnb(t *testing.T) {
1479 context := controllerDeleteEnbTestContext{
1480 getNodebInfoResult: &getNodebInfoResult{
1481 nodebInfo: &entities.NodebInfo{RanName: "ran1", NodeType: entities.Node_GNB, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED},
1484 expectedStatusCode: http.StatusBadRequest,
1485 expectedJsonResponse: ValidationFailureJson,
1488 controllerDeleteEnbTestExecuter(t, &context, false)
1491 func TestControllerDeleteEnbSetupFromNetworkTrueFailure(t *testing.T) {
1492 context := controllerDeleteEnbTestContext{
1493 getNodebInfoResult: &getNodebInfoResult{
1494 nodebInfo: &entities.NodebInfo{RanName: RanName, NodeType: entities.Node_ENB, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, SetupFromNetwork: true},
1497 expectedStatusCode: http.StatusBadRequest,
1498 expectedJsonResponse: ValidationFailureJson,
1500 controllerDeleteEnbTestExecuter(t, &context, true)
1503 func TestControllerDeleteEnbSuccess(t *testing.T) {
1504 context := controllerDeleteEnbTestContext{
1505 getNodebInfoResult: &getNodebInfoResult{
1506 nodebInfo: &entities.NodebInfo{RanName: RanName, NodeType: entities.Node_ENB, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED},
1509 expectedStatusCode: http.StatusNoContent,
1510 expectedJsonResponse: "",
1512 controllerDeleteEnbTestExecuter(t, &context, true)
1515 func getJsonRequestAsBuffer(requestJson map[string]interface{}) *bytes.Buffer {
1516 b := new(bytes.Buffer)
1517 _ = json.NewEncoder(b).Encode(requestJson)
1525 func TestControllerGetNodebSuccess(t *testing.T) {
1528 context := controllerGetNodebTestContext{
1530 nodebInfo: &entities.NodebInfo{RanName: ranName, Ip: "10.0.2.15", Port: 1234},
1531 rnibError: rnibError,
1532 expectedStatusCode: http.StatusOK,
1533 expectedJsonResponse: fmt.Sprintf("{\"ranName\":\"%s\",\"ip\":\"10.0.2.15\",\"port\":1234}", ranName),
1536 controllerGetNodebTestExecuter(t, &context)
1539 func TestControllerGetNodebNotFound(t *testing.T) {
1542 var nodebInfo *entities.NodebInfo
1543 context := controllerGetNodebTestContext{
1545 nodebInfo: nodebInfo,
1546 rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1547 expectedStatusCode: http.StatusNotFound,
1548 expectedJsonResponse: ResourceNotFoundJson,
1551 controllerGetNodebTestExecuter(t, &context)
1554 func TestControllerGetNodebInternal(t *testing.T) {
1556 var nodebInfo *entities.NodebInfo
1557 context := controllerGetNodebTestContext{
1559 nodebInfo: nodebInfo,
1560 rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
1561 expectedStatusCode: http.StatusInternalServerError,
1562 expectedJsonResponse: RnibErrorJson,
1565 controllerGetNodebTestExecuter(t, &context)
1568 func TestControllerGetNodebIdListSuccess(t *testing.T) {
1570 nodebIdList := []*entities.NbIdentity{
1571 {InventoryName: "test1", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}},
1572 {InventoryName: "test2", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId2", NbId: "nbId2"}},
1575 context := controllerGetNodebIdListTestContext{
1576 nodebIdList: nodebIdList,
1577 rnibError: rnibError,
1578 expectedStatusCode: http.StatusOK,
1579 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\"}}]",
1582 controllerGetNodebIdListTestExecuter(t, &context)
1585 func TestControllerGetNodebIdListEmptySuccess(t *testing.T) {
1587 var nodebIdList []*entities.NbIdentity
1589 context := controllerGetNodebIdListTestContext{
1590 nodebIdList: nodebIdList,
1591 rnibError: rnibError,
1592 expectedStatusCode: http.StatusOK,
1593 expectedJsonResponse: "[]",
1596 controllerGetNodebIdListTestExecuter(t, &context)
1599 func TestHeaderValidationFailed(t *testing.T) {
1600 controller, _, _, _, _, _ := setupControllerTest(t)
1602 writer := httptest.NewRecorder()
1604 header := &http.Header{}
1606 controller.handleRequest(writer, header, httpmsghandlerprovider.ShutdownRequest, nil, true, 0)
1608 var errorResponse = parseJsonRequest(t, writer.Body)
1609 err := e2managererrors.NewHeaderValidationError()
1611 assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
1612 assert.Equal(t, errorResponse.Code, err.Code)
1613 assert.Equal(t, errorResponse.Message, err.Message)
1616 func TestShutdownStatusNoContent(t *testing.T) {
1617 controller, readerMock, _, _, e2tInstancesManagerMock, _ := setupControllerTest(t)
1618 e2tInstancesManagerMock.On("GetE2TAddresses").Return([]string{}, nil)
1619 readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{}, nil)
1621 writer := httptest.NewRecorder()
1622 controller.Shutdown(writer, tests.GetHttpRequest())
1624 assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
1627 func TestHandleInternalError(t *testing.T) {
1628 controller, _, _, _, _, _ := setupControllerTest(t)
1630 writer := httptest.NewRecorder()
1631 err := e2managererrors.NewInternalError()
1633 controller.handleErrorResponse(err, writer)
1634 var errorResponse = parseJsonRequest(t, writer.Body)
1636 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1637 assert.Equal(t, errorResponse.Code, err.Code)
1638 assert.Equal(t, errorResponse.Message, err.Message)
1641 func TestHandleCommandAlreadyInProgressError(t *testing.T) {
1642 controller, _, _, _, _, _ := setupControllerTest(t)
1643 writer := httptest.NewRecorder()
1644 err := e2managererrors.NewCommandAlreadyInProgressError()
1646 controller.handleErrorResponse(err, writer)
1647 var errorResponse = parseJsonRequest(t, writer.Body)
1649 assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
1650 assert.Equal(t, errorResponse.Code, err.Code)
1651 assert.Equal(t, errorResponse.Message, err.Message)
1654 func TestHandleRoutingManagerError(t *testing.T) {
1655 controller, _, _, _, _, _ := setupControllerTest(t)
1656 writer := httptest.NewRecorder()
1657 err := e2managererrors.NewRoutingManagerError()
1659 controller.handleErrorResponse(err, writer)
1660 var errorResponse = parseJsonRequest(t, writer.Body)
1662 assert.Equal(t, http.StatusServiceUnavailable, writer.Result().StatusCode)
1663 assert.Equal(t, errorResponse.Code, err.Code)
1664 assert.Equal(t, errorResponse.Message, err.Message)
1667 func TestHandleE2TInstanceAbsenceError(t *testing.T) {
1668 controller, _, _, _, _, _ := setupControllerTest(t)
1670 writer := httptest.NewRecorder()
1671 err := e2managererrors.NewE2TInstanceAbsenceError()
1673 controller.handleErrorResponse(err, writer)
1674 var errorResponse = parseJsonRequest(t, writer.Body)
1676 assert.Equal(t, http.StatusServiceUnavailable, writer.Result().StatusCode)
1677 assert.Equal(t, errorResponse.Code, err.Code)
1678 assert.Equal(t, errorResponse.Message, err.Message)
1681 func TestValidateHeaders(t *testing.T) {
1682 controller, _, _, _, _, _ := setupControllerTest(t)
1684 header := http.Header{}
1685 header.Set("Content-Type", "application/json")
1686 result := controller.validateRequestHeader(&header)
1688 assert.Nil(t, result)
1691 func parseJsonRequest(t *testing.T, r io.Reader) models.ErrorResponse {
1693 var errorResponse models.ErrorResponse
1694 body, err := ioutil.ReadAll(r)
1696 t.Errorf("Error cannot deserialize json request")
1698 _ = json.Unmarshal(body, &errorResponse)
1700 return errorResponse
1703 func initLog(t *testing.T) *logger.Logger {
1704 InfoLevel := int8(3)
1705 log, err := logger.InitLogger(InfoLevel)
1707 t.Errorf("#delete_all_request_handler_test.TestHandleSuccessFlow - failed to initialize logger, error: %s", err)
1712 func TestX2ResetHandleSuccessfulRequestedCause(t *testing.T) {
1713 controller, readerMock, _, rmrMessengerMock, _, _ := setupControllerTest(t)
1716 payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x40}
1718 var msgSrc unsafe.Pointer
1719 msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction, msgSrc)
1720 rmrMessengerMock.On("SendMsg", msg, mock.Anything).Return(msg, nil)
1722 writer := httptest.NewRecorder()
1724 var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
1725 readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
1727 data4Req := map[string]interface{}{"cause": "protocol:transfer-syntax-error"}
1728 b := new(bytes.Buffer)
1729 _ = json.NewEncoder(b).Encode(data4Req)
1730 req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
1731 req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
1733 controller.X2Reset(writer, req)
1734 assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
1738 func TestX2ResetHandleSuccessfulRequestedDefault(t *testing.T) {
1739 controller, readerMock, _, rmrMessengerMock, _, _ := setupControllerTest(t)
1743 payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x64}
1745 var msgSrc unsafe.Pointer
1746 msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction, msgSrc)
1747 rmrMessengerMock.On("SendMsg", msg, true).Return(msg, nil)
1749 writer := httptest.NewRecorder()
1751 var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
1752 readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
1755 b := new(bytes.Buffer)
1756 data4Req := map[string]interface{}{}
1757 _ = json.NewEncoder(b).Encode(data4Req)
1758 req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
1759 req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
1761 controller.X2Reset(writer, req)
1762 assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
1765 func TestX2ResetHandleFailureBodyReadError(t *testing.T) {
1766 controller, _, _, _, _, _ := setupControllerTest(t)
1769 writer := httptest.NewRecorder()
1771 // Fake reader to return reading error.
1772 req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", errReader(0))
1773 req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
1775 controller.X2Reset(writer, req)
1776 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1780 func TestX2ResetHandleFailureInvalidBody(t *testing.T) {
1781 controller, _, _, _, _, _ := setupControllerTest(t)
1785 writer := httptest.NewRecorder()
1787 // Invalid json: attribute name without quotes (should be "cause":).
1788 b := strings.NewReader("{cause:\"protocol:transfer-syntax-error\"")
1789 req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
1790 req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
1792 controller.X2Reset(writer, req)
1793 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1798 func TestControllerHealthCheckRequestSuccess(t *testing.T) {
1799 controller, readerMock, _, rmrMessengerMock, _, _ := setupControllerTest(t)
1803 payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x64}
1805 var msgSrc unsafe.Pointer
1806 msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction, msgSrc)
1807 rmrMessengerMock.On("SendMsg", msg, true).Return(msg, nil)
1809 writer := httptest.NewRecorder()
1811 var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
1812 readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
1814 data4Req := map[string]interface{}{"ranList": []string{"abcd"}}
1815 b := new(bytes.Buffer)
1816 _ = json.NewEncoder(b).Encode(data4Req)
1817 req, _ := http.NewRequest("PUT", "https://localhost:3800/v1/nodeb/health", b)
1818 req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
1820 controller.HealthCheckRequest(writer, req)
1821 assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
1825 func TestHandleErrorResponse(t *testing.T) {
1826 controller, _, _, _, _, _ := setupControllerTest(t)
1828 writer := httptest.NewRecorder()
1829 controller.handleErrorResponse(e2managererrors.NewRnibDbError(), writer)
1830 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1832 writer = httptest.NewRecorder()
1833 controller.handleErrorResponse(e2managererrors.NewCommandAlreadyInProgressError(), writer)
1834 assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
1836 writer = httptest.NewRecorder()
1837 controller.handleErrorResponse(e2managererrors.NewHeaderValidationError(), writer)
1838 assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
1840 writer = httptest.NewRecorder()
1841 controller.handleErrorResponse(e2managererrors.NewWrongStateError("", ""), writer)
1842 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1844 writer = httptest.NewRecorder()
1845 controller.handleErrorResponse(e2managererrors.NewRequestValidationError(), writer)
1846 assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1848 writer = httptest.NewRecorder()
1849 controller.handleErrorResponse(e2managererrors.NewRmrError(), writer)
1850 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1852 writer = httptest.NewRecorder()
1853 controller.handleErrorResponse(e2managererrors.NewNoConnectedRanError(), writer)
1854 assert.Equal(t, http.StatusNotFound, writer.Result().StatusCode)
1856 writer = httptest.NewRecorder()
1857 controller.handleErrorResponse(e2managererrors.NewResourceNotFoundError(), writer)
1858 assert.Equal(t, http.StatusNotFound, writer.Result().StatusCode)
1860 writer = httptest.NewRecorder()
1861 controller.handleErrorResponse(fmt.Errorf("ErrorError"), writer)
1862 assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1865 func getRmrSender(rmrMessengerMock *mocks.RmrMessengerMock, log *logger.Logger) *rmrsender.RmrSender {
1866 rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
1867 rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
1868 return rmrsender.NewRmrSender(log, rmrMessenger)
1873 func (errReader) Read(p []byte) (n int, err error) {
1874 return 0, errors.New("test error")