From fe8d481d7f3e8d4b889ee3dcd995984eeb64cc6e Mon Sep 17 00:00:00 2001 From: Rahul Banerji Date: Mon, 24 Aug 2020 14:26:41 +0530 Subject: [PATCH] [RIC-247] RAN Health Check Request API - Validation Change-Id: Ibee3f761cd5cd0051747d71b8f2e91f14279b092 Signed-off-by: Rahul Banerji --- E2Manager/container-tag.yaml | 2 +- E2Manager/controllers/nodeb_controller.go | 18 ++++ E2Manager/controllers/nodeb_controller_test.go | 31 +++--- .../e2managererrors/no_connected_ran_error.go | 36 +++++++ .../httpmsghandlers/health_check_handler.go | 89 ++++++++++++++++ .../httpmsghandlers/health_check_handler_test.go | 113 +++++++++++++++++++++ E2Manager/httpserver/http_server.go | 1 + E2Manager/httpserver/http_server_test.go | 14 +++ E2Manager/mocks/nodeb_controller_mock.go | 7 ++ E2Manager/models/health_check_request.go | 23 +++++ .../incoming_request_handler_provider.go | 4 +- .../incoming_request_handler_provider_test.go | 12 +++ 12 files changed, 333 insertions(+), 17 deletions(-) create mode 100644 E2Manager/e2managererrors/no_connected_ran_error.go create mode 100644 E2Manager/handlers/httpmsghandlers/health_check_handler.go create mode 100644 E2Manager/handlers/httpmsghandlers/health_check_handler_test.go create mode 100644 E2Manager/models/health_check_request.go diff --git a/E2Manager/container-tag.yaml b/E2Manager/container-tag.yaml index d7ddab7..b309729 100644 --- a/E2Manager/container-tag.yaml +++ b/E2Manager/container-tag.yaml @@ -1,4 +1,4 @@ # The Jenkins job requires a tag to build the Docker image. # Global-JJB script assumes this file is in the repo root. --- -tag: 5.4.7 +tag: 5.4.8 diff --git a/E2Manager/controllers/nodeb_controller.go b/E2Manager/controllers/nodeb_controller.go index 385824e..f2efd65 100644 --- a/E2Manager/controllers/nodeb_controller.go +++ b/E2Manager/controllers/nodeb_controller.go @@ -53,6 +53,7 @@ type INodebController interface { SetGeneralConfiguration(writer http.ResponseWriter, r *http.Request) AddEnb(writer http.ResponseWriter, r *http.Request) DeleteEnb(writer http.ResponseWriter, r *http.Request) + HealthCheckRequest(writer http.ResponseWriter, r *http.Request) } type NodebController struct { @@ -190,6 +191,19 @@ func (c *NodebController) X2Reset(writer http.ResponseWriter, r *http.Request) { c.handleRequest(writer, &r.Header, httpmsghandlerprovider.ResetRequest, request, false, http.StatusNoContent) } +func (c *NodebController) HealthCheckRequest(writer http.ResponseWriter, r *http.Request) { + c.logger.Infof("[Client -> E2 Manager] #NodebController.HealthCheckRequest - request: %v", c.prettifyRequest(r)) + + request := models.HealthCheckRequest{} + + if err := c.extractJsonBody(r, &request); err != nil { + c.handleErrorResponse(err, writer) + return + } + + c.handleRequest(writer, &r.Header, httpmsghandlerprovider.HealthCheckRequest, request, true, http.StatusNoContent) +} + func (c *NodebController) extractRequestBodyToProto(r *http.Request, pb proto.Message, writer http.ResponseWriter) bool { defer r.Body.Close() @@ -342,6 +356,10 @@ func (c *NodebController) handleErrorResponse(err error, writer http.ResponseWri e2Error, _ := err.(*e2managererrors.NodebExistsError) errorResponseDetails = models.ErrorResponse{Code: e2Error.Code, Message: e2Error.Message} httpError = http.StatusBadRequest + case *e2managererrors.NoConnectedRanError: + e2Error, _ := err.(*e2managererrors.NoConnectedRanError) + errorResponseDetails = models.ErrorResponse{Code: e2Error.Code, Message: e2Error.Message} + httpError = http.StatusNotFound default: e2Error := e2managererrors.NewInternalError() errorResponseDetails = models.ErrorResponse{Code: e2Error.Code, Message: e2Error.Message} diff --git a/E2Manager/controllers/nodeb_controller_test.go b/E2Manager/controllers/nodeb_controller_test.go index f57522c..c01d7c9 100644 --- a/E2Manager/controllers/nodeb_controller_test.go +++ b/E2Manager/controllers/nodeb_controller_test.go @@ -160,9 +160,7 @@ func generateServedNrCells(cellIds ...string) []*entities.ServedNRCell { servedNrCells = append(servedNrCells, &entities.ServedNRCell{ServedNrCellInformation: &entities.ServedNRCellInformation{ CellId: v, ChoiceNrMode: &entities.ServedNRCellInformation_ChoiceNRMode{ - Fdd: &entities.ServedNRCellInformation_ChoiceNRMode_FddInfo{ - - }, + Fdd: &entities.ServedNRCellInformation_ChoiceNRMode_FddInfo{}, }, NrMode: entities.Nr_FDD, NrPci: 5, @@ -631,8 +629,7 @@ func TestControllerUpdateGnbEmptyServedNrCells(t *testing.T) { context := controllerUpdateGnbTestContext{ getNodebInfoResult: nil, requestBody: map[string]interface{}{ - "servedNrCells": []interface{}{ - }, + "servedNrCells": []interface{}{}, }, expectedStatusCode: http.StatusBadRequest, expectedJsonResponse: ValidationFailureJson, @@ -1176,16 +1173,16 @@ func TestControllerUpdateEnbNgEnbFailure(t *testing.T) { oldServedCells := generateServedCells("whatever1", "whatever2") context := controllerUpdateEnbTestContext{ - getNodebInfoResult: &getNodebInfoResult{ - nodebInfo: &entities.NodebInfo{ - RanName: RanName, - ConnectionStatus: entities.ConnectionStatus_CONNECTED, - AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress, - NodeType: entities.Node_ENB, - Configuration: &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells, EnbType: entities.EnbType_MACRO_NG_ENB}}, - }, - rnibError: nil, - }, + getNodebInfoResult: &getNodebInfoResult{ + nodebInfo: &entities.NodebInfo{ + RanName: RanName, + ConnectionStatus: entities.ConnectionStatus_CONNECTED, + AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress, + NodeType: entities.Node_ENB, + Configuration: &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells, EnbType: entities.EnbType_MACRO_NG_ENB}}, + }, + rnibError: nil, + }, requestBody: requestBody, expectedStatusCode: http.StatusBadRequest, expectedJsonResponse: ValidationFailureJson, @@ -1807,6 +1804,10 @@ func TestHandleErrorResponse(t *testing.T) { controller.handleErrorResponse(e2managererrors.NewRmrError(), writer) assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode) + writer = httptest.NewRecorder() + controller.handleErrorResponse(e2managererrors.NewNoConnectedRanError(), writer) + assert.Equal(t, http.StatusNotFound, writer.Result().StatusCode) + writer = httptest.NewRecorder() controller.handleErrorResponse(e2managererrors.NewResourceNotFoundError(), writer) assert.Equal(t, http.StatusNotFound, writer.Result().StatusCode) diff --git a/E2Manager/e2managererrors/no_connected_ran_error.go b/E2Manager/e2managererrors/no_connected_ran_error.go new file mode 100644 index 0000000..7ed127d --- /dev/null +++ b/E2Manager/e2managererrors/no_connected_ran_error.go @@ -0,0 +1,36 @@ +// +// Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// This source code is part of the near-RT RIC (RAN Intelligent Controller) +// platform project (RICP). + +package e2managererrors + +type NoConnectedRanError struct { + *BaseError +} + +func NewNoConnectedRanError() *NoConnectedRanError { + return &NoConnectedRanError{ + &BaseError{ + Code: 406, + Message: "No RAN in Connected State", + }, + } +} + +func (e *NoConnectedRanError) Error() string { + return e.Message +} diff --git a/E2Manager/handlers/httpmsghandlers/health_check_handler.go b/E2Manager/handlers/httpmsghandlers/health_check_handler.go new file mode 100644 index 0000000..70203d8 --- /dev/null +++ b/E2Manager/handlers/httpmsghandlers/health_check_handler.go @@ -0,0 +1,89 @@ +// +// Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// This source code is part of the near-RT RIC (RAN Intelligent Controller) +// platform project (RICP). + +package httpmsghandlers + +import ( + "e2mgr/e2managererrors" + "e2mgr/logger" + "e2mgr/managers" + "e2mgr/models" + "e2mgr/services" + "e2mgr/services/rmrsender" + "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common" + "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities" + // "github.com/pkg/errors" +) + +type HealthCheckRequestHandler struct { + logger *logger.Logger + rNibDataService services.RNibDataService + ranListManager managers.RanListManager + rmrsender *rmrsender.RmrSender +} + +func NewHealthCheckRequestHandler(logger *logger.Logger, rNibDataService services.RNibDataService, ranListManager managers.RanListManager, rmrsender *rmrsender.RmrSender) *HealthCheckRequestHandler { + return &HealthCheckRequestHandler{ + logger: logger, + rNibDataService: rNibDataService, + ranListManager: ranListManager, + rmrsender: rmrsender, + } +} + +func (h *HealthCheckRequestHandler) Handle(request models.Request) (models.IResponse, error) { + ranNameList := h.getRanNameList(request) + isAtleastOneRanConnected := false + + for _, ranName := range ranNameList { + nodebInfo, err := h.rNibDataService.GetNodeb(ranName) //This method is needed for getting RAN functions with later commits + if err != nil { + _, ok := err.(*common.ResourceNotFoundError) + if !ok { + h.logger.Errorf("#HealthCheckRequest.Handle - failed to get nodeBInfo entity for ran name: %v from RNIB. Error: %s", ranName, err) + return nil, e2managererrors.NewRnibDbError() + } + continue + } + if nodebInfo.ConnectionStatus == entities.ConnectionStatus_CONNECTED { + isAtleastOneRanConnected = true + + } + } + if isAtleastOneRanConnected == false { + return nil, e2managererrors.NewNoConnectedRanError() + } + + return nil, nil +} + +func (h *HealthCheckRequestHandler) getRanNameList(request models.Request) []string { + healthCheckRequest := request.(models.HealthCheckRequest) + if request != nil && len(healthCheckRequest.RanList) != 0 { + return healthCheckRequest.RanList + } + nodeIds := h.ranListManager.GetNbIdentityList() + + var ranNameList []string + for _, nbIdentity := range nodeIds { + if nbIdentity.ConnectionStatus == entities.ConnectionStatus_CONNECTED { + ranNameList = append(ranNameList, nbIdentity.InventoryName) + } + } + return ranNameList +} diff --git a/E2Manager/handlers/httpmsghandlers/health_check_handler_test.go b/E2Manager/handlers/httpmsghandlers/health_check_handler_test.go new file mode 100644 index 0000000..2c519df --- /dev/null +++ b/E2Manager/handlers/httpmsghandlers/health_check_handler_test.go @@ -0,0 +1,113 @@ +// +// Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// This source code is part of the near-RT RIC (RAN Intelligent Controller) +// platform project (RICP). + +package httpmsghandlers + +import ( + "e2mgr/configuration" + "e2mgr/e2managererrors" + "e2mgr/mocks" + "e2mgr/models" + "e2mgr/services" + "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities" + "github.com/pkg/errors" + "github.com/stretchr/testify/assert" + "testing" +) + +func setupHealthCheckHandlerTest(t *testing.T) (*HealthCheckRequestHandler, services.RNibDataService, *mocks.RnibReaderMock, *mocks.RanListManagerMock) { + logger := initLog(t) + config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3} + + readerMock := &mocks.RnibReaderMock{} + writerMock := &mocks.RnibWriterMock{} + + rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock) + rmrMessengerMock := &mocks.RmrMessengerMock{} + ranListManagerMock := &mocks.RanListManagerMock{} + + rmrSender := getRmrSender(rmrMessengerMock, logger) + handler := NewHealthCheckRequestHandler(logger, rnibDataService, ranListManagerMock, rmrSender) + + return handler, rnibDataService, readerMock, ranListManagerMock +} + +func TestHealthCheckRequestHandlerArguementHasRanNameSuccess(t *testing.T) { + handler, _, readerMock, _ := setupHealthCheckHandlerTest(t) + + nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_CONNECTED} + ranNames := []string{"RanName_1"} + + readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil) + + _, err := handler.Handle(models.HealthCheckRequest{ranNames}) + + assert.Nil(t, err) + readerMock.AssertExpectations(t) +} + +func TestHealthCheckRequestHandlerArguementHasNoRanNameSuccess(t *testing.T) { + handler, _, readerMock, ranListManagerMock := setupHealthCheckHandlerTest(t) + + nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_CONNECTED}, + {InventoryName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED}} + + ranListManagerMock.On("GetNbIdentityList").Return(nbIdentityList) + + nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_CONNECTED} + readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil) + + nb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED} + readerMock.On("GetNodeb", "RanName_2").Return(nb2, nil) + + _, err := handler.Handle(models.HealthCheckRequest{[]string{}}) + + assert.Nil(t, err) + +} + +func TestHealthCheckRequestHandlerArguementHasNoRanConnectedFailure(t *testing.T) { + handler, _, readerMock, ranListManagerMock := setupHealthCheckHandlerTest(t) + + nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED}, + {InventoryName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED}} + ranListManagerMock.On("GetNbIdentityList").Return(nbIdentityList) + + nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED} + readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil) + + nb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED} + readerMock.On("GetNodeb", "RanName_2").Return(nb2, nil) + + _, err := handler.Handle(models.HealthCheckRequest{[]string{}}) + + assert.IsType(t, &e2managererrors.NoConnectedRanError{}, err) + +} + +func TestHealthCheckRequestHandlerArguementHasRanNameDBErrorFailure(t *testing.T) { + handler, _, readerMock, _ := setupHealthCheckHandlerTest(t) + + ranNames := []string{"RanName_1"} + readerMock.On("GetNodeb", "RanName_1").Return(&entities.NodebInfo{}, errors.New("error")) + + _, err := handler.Handle(models.HealthCheckRequest{ranNames}) + + assert.IsType(t, &e2managererrors.RnibDbError{}, err) + readerMock.AssertExpectations(t) +} diff --git a/E2Manager/httpserver/http_server.go b/E2Manager/httpserver/http_server.go index b49ee50..d1a210c 100644 --- a/E2Manager/httpserver/http_server.go +++ b/E2Manager/httpserver/http_server.go @@ -53,6 +53,7 @@ func initializeRoutes(router *mux.Router, rootController controllers.IRootContro rr.HandleFunc("/enb/{ranName}", nodebController.UpdateEnb).Methods(http.MethodPut) rr.HandleFunc("/shutdown", nodebController.Shutdown).Methods(http.MethodPut) rr.HandleFunc("/parameters", nodebController.SetGeneralConfiguration).Methods(http.MethodPut) + rr.HandleFunc("/health", nodebController.HealthCheckRequest).Methods(http.MethodPut) rrr := r.PathPrefix("/e2t").Subrouter() rrr.HandleFunc("/list", e2tController.GetE2TInstances).Methods(http.MethodGet) } diff --git a/E2Manager/httpserver/http_server_test.go b/E2Manager/httpserver/http_server_test.go index 0a98999..b798186 100644 --- a/E2Manager/httpserver/http_server_test.go +++ b/E2Manager/httpserver/http_server_test.go @@ -42,6 +42,7 @@ func setupRouterAndMocks() (*mux.Router, *mocks.RootControllerMock, *mocks.Nodeb nodebControllerMock.On("DeleteEnb").Return(nil) nodebControllerMock.On("AddEnb").Return(nil) nodebControllerMock.On("UpdateEnb").Return(nil) + nodebControllerMock.On("HealthCheckRequest").Return(nil) e2tControllerMock := &mocks.E2TControllerMock{} @@ -106,6 +107,19 @@ func TestRoutePutNodebShutdown(t *testing.T) { nodebControllerMock.AssertNumberOfCalls(t, "Shutdown", 1) } +func TestHealthCheckRequest(t *testing.T) { + router, _, nodebControllerMock, _ := setupRouterAndMocks() + + req, err := http.NewRequest("PUT", "/v1/nodeb/health", nil) + if err != nil { + t.Fatal(err) + } + rr := httptest.NewRecorder() + router.ServeHTTP(rr, req) + + nodebControllerMock.AssertNumberOfCalls(t, "HealthCheckRequest", 1) +} + func TestRoutePutNodebSetGeneralConfiguration(t *testing.T) { router, _, nodebControllerMock, _ := setupRouterAndMocks() diff --git a/E2Manager/mocks/nodeb_controller_mock.go b/E2Manager/mocks/nodeb_controller_mock.go index 2467666..8308fc1 100644 --- a/E2Manager/mocks/nodeb_controller_mock.go +++ b/E2Manager/mocks/nodeb_controller_mock.go @@ -93,3 +93,10 @@ func (c *NodebControllerMock) SetGeneralConfiguration(writer http.ResponseWriter c.Called() } + +func (c *NodebControllerMock) HealthCheckRequest(writer http.ResponseWriter, r *http.Request) { + writer.Header().Set("Content-Type", "application/json") + writer.WriteHeader(http.StatusOK) + + c.Called() +} diff --git a/E2Manager/models/health_check_request.go b/E2Manager/models/health_check_request.go new file mode 100644 index 0000000..6f3bd9c --- /dev/null +++ b/E2Manager/models/health_check_request.go @@ -0,0 +1,23 @@ +// +// Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// This source code is part of the near-RT RIC (RAN Intelligent Controller) +// platform project (RICP). + +package models + +type HealthCheckRequest struct { + RanList []string +} diff --git a/E2Manager/providers/httpmsghandlerprovider/incoming_request_handler_provider.go b/E2Manager/providers/httpmsghandlerprovider/incoming_request_handler_provider.go index d747669..f20de09 100644 --- a/E2Manager/providers/httpmsghandlerprovider/incoming_request_handler_provider.go +++ b/E2Manager/providers/httpmsghandlerprovider/incoming_request_handler_provider.go @@ -43,6 +43,7 @@ const ( UpdateEnbRequest IncomingRequest = "UpdateEnbRequest" AddEnbRequest IncomingRequest = "AddEnbRequest" DeleteEnbRequest IncomingRequest = "DeleteEnbRequest" + HealthCheckRequest IncomingRequest = "HealthCheckRequest" ) type IncomingRequestHandlerProvider struct { @@ -60,7 +61,7 @@ func NewIncomingRequestHandlerProvider(logger *logger.Logger, rmrSender *rmrsend } } -func initRequestHandlerMap(logger *logger.Logger, rmrSender *rmrsender.RmrSender, config *configuration.Configuration, rNibDataService services.RNibDataService, e2tInstancesManager managers.IE2TInstancesManager, rmClient clients.IRoutingManagerClient, ranConnectStatusChangeManager managers.IRanConnectStatusChangeManager, nodebValidator *managers.NodebValidator, updateEnbManager managers.IUpdateNodebManager, updateGnbManager managers.IUpdateNodebManager, ranListManager managers.RanListManager) map[IncomingRequest]httpmsghandlers.RequestHandler { +func initRequestHandlerMap(logger *logger.Logger, rmrSender *rmrsender.RmrSender, config *configuration.Configuration, rNibDataService services.RNibDataService, e2tInstancesManager managers.IE2TInstancesManager, rmClient clients.IRoutingManagerClient, ranConnectStatusChangeManager managers.IRanConnectStatusChangeManager, nodebValidator *managers.NodebValidator, updateEnbManager managers.IUpdateNodebManager, updateGnbManager managers.IUpdateNodebManager, ranListManager managers.RanListManager) map[IncomingRequest]httpmsghandlers.RequestHandler { return map[IncomingRequest]httpmsghandlers.RequestHandler{ ShutdownRequest: httpmsghandlers.NewDeleteAllRequestHandler(logger, rmrSender, config, rNibDataService, e2tInstancesManager, rmClient, ranConnectStatusChangeManager, ranListManager), @@ -73,6 +74,7 @@ func initRequestHandlerMap(logger *logger.Logger, rmrSender *rmrsender.RmrSender UpdateEnbRequest: httpmsghandlers.NewUpdateNodebRequestHandler(logger, rNibDataService, updateEnbManager), AddEnbRequest: httpmsghandlers.NewAddEnbRequestHandler(logger, rNibDataService, nodebValidator, ranListManager), DeleteEnbRequest: httpmsghandlers.NewDeleteEnbRequestHandler(logger, rNibDataService, ranListManager), + HealthCheckRequest: httpmsghandlers.NewHealthCheckRequestHandler(logger, rNibDataService, ranListManager, rmrSender), } } diff --git a/E2Manager/providers/httpmsghandlerprovider/incoming_request_handler_provider_test.go b/E2Manager/providers/httpmsghandlerprovider/incoming_request_handler_provider_test.go index 761edaf..a692db0 100644 --- a/E2Manager/providers/httpmsghandlerprovider/incoming_request_handler_provider_test.go +++ b/E2Manager/providers/httpmsghandlerprovider/incoming_request_handler_provider_test.go @@ -93,6 +93,18 @@ func TestSetGeneralConfigurationHandler(t *testing.T) { assert.True(t, ok) } +func TestHealthCheckRequest(t *testing.T) { + provider := setupTest(t) + handler, err := provider.GetHandler(HealthCheckRequest) + + assert.NotNil(t, provider) + assert.Nil(t, err) + + _, ok := handler.(*httpmsghandlers.HealthCheckRequestHandler) + + assert.True(t, ok) +} + func TestGetShutdownHandlerFailure(t *testing.T) { provider := setupTest(t) _, actual := provider.GetHandler("test") -- 2.16.6