X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=E2Manager%2Fcontrollers%2Fnodeb_controller_test.go;h=a9bccdc7b13909e55a79cc5bb96e816b9c2f1439;hb=087f53f09d66902bc245655e4d7220679e002312;hp=f6a9e54bade1c08a0e9ede43f69edae3e746ad5a;hpb=966f2102168cad95b8aa1bc83241b4b6730ab1e2;p=ric-plt%2Fe2mgr.git

diff --git a/E2Manager/controllers/nodeb_controller_test.go b/E2Manager/controllers/nodeb_controller_test.go
index f6a9e54..a9bccdc 100644
--- a/E2Manager/controllers/nodeb_controller_test.go
+++ b/E2Manager/controllers/nodeb_controller_test.go
@@ -13,359 +13,948 @@
 // 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 controllers
 
 import (
+	"bytes"
+	"e2mgr/clients"
+	"e2mgr/configuration"
+	"e2mgr/e2managererrors"
+	"e2mgr/e2pdus"
 	"e2mgr/logger"
+	"e2mgr/managers"
 	"e2mgr/mocks"
 	"e2mgr/models"
-	"e2mgr/rNibWriter"
+	"e2mgr/providers/httpmsghandlerprovider"
 	"e2mgr/rmrCgo"
 	"e2mgr/services"
-	"e2mgr/sessions"
+	"e2mgr/services/rmrsender"
 	"e2mgr/tests"
+	"encoding/json"
 	"fmt"
 	"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
 	"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
-	"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader"
-	"github.com/julienschmidt/httprouter"
+	"github.com/golang/protobuf/jsonpb"
+	"github.com/gorilla/mux"
 	"github.com/pkg/errors"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
+	"io"
 	"io/ioutil"
 	"net/http"
 	"net/http/httptest"
+	"strings"
 	"testing"
+	"unsafe"
 )
 
-const x2SetupMessageType = "x2-setup"
+const (
+	RanName                      = "test"
+	AssociatedE2TInstanceAddress = "10.0.2.15:38000"
+	ValidationFailureJson        = "{\"errorCode\":402,\"errorMessage\":\"Validation error\"}"
+	ResourceNotFoundJson         = "{\"errorCode\":404,\"errorMessage\":\"Resource not found\"}"
+	RnibErrorJson                = "{\"errorCode\":500,\"errorMessage\":\"RNIB error\"}"
+	InternalErrorJson            = "{\"errorCode\":501,\"errorMessage\":\"Internal Server Error. Please try again later\"}"
+)
 
-func TestNewRequestController(t *testing.T) {
-	rnibReaderProvider := func() reader.RNibReader {
-		return &mocks.RnibReaderMock{}
-	}
-	rnibWriterProvider := func() rNibWriter.RNibWriter {
-		return &mocks.RnibWriterMock{}
-	}
+var (
+	ServedNrCellInformationRequiredFields = []string{"cellId", "choiceNrMode", "nrMode", "nrPci", "servedPlmns"}
+	NrNeighbourInformationRequiredFields  = []string{"nrCgi", "choiceNrMode", "nrMode", "nrPci"}
+)
 
-	assert.NotNil(t, NewNodebController(&logger.Logger{}, &services.RmrService{}, rnibReaderProvider, rnibWriterProvider))
+type controllerGetNodebTestContext struct {
+	ranName              string
+	nodebInfo            *entities.NodebInfo
+	rnibError            error
+	expectedStatusCode   int
+	expectedJsonResponse string
 }
 
-func TestHandleRequestSuccess(t *testing.T) {
-	log, err := logger.InitLogger(logger.InfoLevel)
-	if err != nil {
-		t.Errorf("#nodeb_controller_test.TestHandleRequestSuccess - failed to initialize logger, error: %s", err)
+type controllerGetNodebIdListTestContext struct {
+	nodebIdList          []*entities.NbIdentity
+	rnibError            error
+	expectedStatusCode   int
+	expectedJsonResponse string
+}
+
+type getNodebInfoResult struct {
+	nodebInfo *entities.NodebInfo
+	rnibError error
+}
+
+type updateGnbCellsParams struct {
+	err error
+}
+
+type removeServedNrCellsParams struct {
+	servedNrCells []*entities.ServedNRCell
+	err           error
+}
+
+type controllerUpdateGnbTestContext struct {
+	getNodebInfoResult        *getNodebInfoResult
+	removeServedNrCellsParams *removeServedNrCellsParams
+	updateGnbCellsParams      *updateGnbCellsParams
+	requestBody               map[string]interface{}
+	expectedStatusCode        int
+	expectedJsonResponse      string
+}
+
+func generateServedNrCells(cellIds ...string) []*entities.ServedNRCell {
+
+	servedNrCells := []*entities.ServedNRCell{}
+
+	for _, v := range cellIds {
+		servedNrCells = append(servedNrCells, &entities.ServedNRCell{ServedNrCellInformation: &entities.ServedNRCellInformation{
+			CellId: v,
+			ChoiceNrMode: &entities.ServedNRCellInformation_ChoiceNRMode{
+				Fdd: &entities.ServedNRCellInformation_ChoiceNRMode_FddInfo{
+
+				},
+			},
+			NrMode:      entities.Nr_FDD,
+			NrPci:       5,
+			ServedPlmns: []string{"whatever"},
+		}})
 	}
 
-	rmrMessengerMock :=&mocks.RmrMessengerMock{}
-	mbuf := rmrCgo.NewMBuf(tests.MessageType, tests.MaxMsgSize,"RanName", &tests.DummyPayload, &tests.DummyXAction)
+	return servedNrCells
+}
 
-	rmrMessengerMock.On("SendMsg",
-		mock.AnythingOfType(fmt.Sprintf("%T", mbuf)),
-		tests.MaxMsgSize).Return(mbuf, nil)
+func buildNrNeighbourInformation(propToOmit string) map[string]interface{} {
+	ret := map[string]interface{}{
+		"nrCgi": "whatever",
+		"choiceNrMode": map[string]interface{}{
+			"tdd": map[string]interface{}{},
+		},
+		"nrMode": 1,
+		"nrPci":  1,
+	}
 
-	writer := httptest.NewRecorder()
+	if len(propToOmit) != 0 {
+		delete(ret, propToOmit)
+	}
 
-	handleRequest(writer, log, rmrMessengerMock, tests.GetHttpRequest(), x2SetupMessageType)
-	assert.Equal(t, writer.Result().StatusCode, http.StatusOK)
+	return ret
 }
 
-func TestHandleRequestFailure_InvalidRequestDetails(t *testing.T) {
-	log, err := logger.InitLogger(logger.InfoLevel)
-	if err != nil {
-		t.Errorf("#nodeb_controller_test.TestHandleRequestFailure - failed to initialize logger, error: %s", err)
+func buildServedNrCellInformation(propToOmit string) map[string]interface{} {
+	ret := map[string]interface{}{
+		"cellId": "whatever",
+		"choiceNrMode": map[string]interface{}{
+			"fdd": map[string]interface{}{},
+		},
+		"nrMode": 1,
+		"nrPci":  1,
+		"servedPlmns": []interface{}{
+			"whatever",
+		},
+	}
+
+	if len(propToOmit) != 0 {
+		delete(ret, propToOmit)
 	}
 
+	return ret
+}
+
+func setupControllerTest(t *testing.T) (*NodebController, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.RmrMessengerMock, *mocks.E2TInstancesManagerMock) {
+	log := initLog(t)
+	config := configuration.ParseConfiguration()
+
 	rmrMessengerMock := &mocks.RmrMessengerMock{}
-	var mbuf *rmrCgo.MBuf
+	readerMock := &mocks.RnibReaderMock{}
+
+	writerMock := &mocks.RnibWriterMock{}
+
+	rnibDataService := services.NewRnibDataService(log, config, readerMock, writerMock)
+	rmrSender := getRmrSender(rmrMessengerMock, log)
+	ranSetupManager := managers.NewRanSetupManager(log, rmrSender, rnibDataService)
+	e2tInstancesManager := &mocks.E2TInstancesManagerMock{}
+	httpClientMock := &mocks.HttpClientMock{}
+	rmClient := clients.NewRoutingManagerClient(log, config, httpClientMock)
+	e2tAssociationManager := managers.NewE2TAssociationManager(log, rnibDataService, e2tInstancesManager, rmClient)
+	handlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(log, rmrSender, config, rnibDataService, ranSetupManager, e2tInstancesManager, e2tAssociationManager, rmClient)
+	controller := NewNodebController(log, handlerProvider)
+	return controller, readerMock, writerMock, rmrMessengerMock, e2tInstancesManager
+}
+
+func TestX2SetupInvalidBody(t *testing.T) {
 
-	rmrMessengerMock.On("SendMsg",
-		mock.AnythingOfType(fmt.Sprintf("%T", mbuf)),
-		tests.MaxMsgSize).Return(mbuf, errors.New("test failure"))
+	controller, _, _, _, _ := setupControllerTest(t)
+
+	header := http.Header{}
+	header.Set("Content-Type", "application/json")
+	httpRequest, _ := http.NewRequest("POST", "http://localhost:3800/v1/nodeb/x2-setup", strings.NewReader("{}{}"))
+	httpRequest.Header = header
 
 	writer := httptest.NewRecorder()
+	controller.X2Setup(writer, httpRequest)
+
+	var errorResponse = parseJsonRequest(t, writer.Body)
 
-	handleRequest(writer, log, rmrMessengerMock, tests.GetInvalidRequestDetails(), x2SetupMessageType)
 	assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
+	assert.Equal(t, e2managererrors.NewInvalidJsonError().Code, errorResponse.Code)
 }
 
-func TestHandleRequestFailure_InvalidMessageType(t *testing.T) {
-	log, err := logger.InitLogger(logger.InfoLevel)
-	if err != nil {
-		t.Errorf("#nodeb_controller_test.TestHandleRequestFailure - failed to initialize logger, error: %s", err)
-	}
+func TestX2SetupSuccess(t *testing.T) {
 
-	rmrMessengerMock := &mocks.RmrMessengerMock{}
-	var mbuf *rmrCgo.MBuf
+	controller, readerMock, writerMock, rmrMessengerMock, _ := setupControllerTest(t)
 
-	rmrMessengerMock.On("SendMsg",
-		mock.AnythingOfType(fmt.Sprintf("%T", mbuf)),
-		tests.MaxMsgSize).Return(mbuf, errors.New("test failure"))
+	ranName := "test"
+	nb := &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST, AssociatedE2TInstanceAddress: "10.0.2.15:8989"}
+	readerMock.On("GetNodeb", ranName).Return(nb, nil)
+	var nbUpdated = *nb
+	writerMock.On("UpdateNodebInfo", &nbUpdated).Return(nil)
+
+	var nbUpdated2 = &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_CONNECTING, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST, AssociatedE2TInstanceAddress: "10.0.2.15:8989"}
+	writerMock.On("UpdateNodebInfo", nbUpdated2).Return(nil)
+
+	payload := e2pdus.PackedX2setupRequest
+	var xAction []byte
+	var msgSrc unsafe.Pointer
+	msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), ranName, &payload, &xAction, msgSrc)
+
+	rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg, nil)
+
+	header := http.Header{}
+	header.Set("Content-Type", "application/json")
+	httpRequest := tests.GetHttpRequest()
+	httpRequest.Header = header
 
 	writer := httptest.NewRecorder()
+	controller.X2Setup(writer, httpRequest)
 
-	handleRequest(writer, log, rmrMessengerMock, tests.GetInvalidMessageType(), "dummy")
-	assert.Equal(t, http.StatusNotFound, writer.Result().StatusCode)
+	assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
 }
 
-func TestHandleHealthCheckRequest(t *testing.T) {
-	rc := NewNodebController(nil, nil, nil, nil)
+func TestEndcSetupSuccess(t *testing.T) {
+
+	controller, readerMock, writerMock, rmrMessengerMock, _ := setupControllerTest(t)
+
+	ranName := "test"
+	nb := &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST, AssociatedE2TInstanceAddress: "10.0.2.15:8989"}
+	readerMock.On("GetNodeb", ranName).Return(nb, nil)
+	var nbUpdated = *nb
+	writerMock.On("UpdateNodebInfo", &nbUpdated).Return(nil)
+
+	var nbUpdated2 = &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_CONNECTING, E2ApplicationProtocol: entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST, AssociatedE2TInstanceAddress: "10.0.2.15:8989"}
+	writerMock.On("UpdateNodebInfo", nbUpdated2).Return(nil)
+
+	payload := e2pdus.PackedEndcX2setupRequest
+	var xAction []byte
+	var msgSrc unsafe.Pointer
+	msg := rmrCgo.NewMBuf(rmrCgo.RIC_ENDC_X2_SETUP_REQ, len(payload), ranName, &payload, &xAction, msgSrc)
+
+	rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg, nil)
+
+	header := http.Header{}
+	header.Set("Content-Type", "application/json")
+	httpRequest := tests.GetHttpRequest()
+	httpRequest.Header = header
+
 	writer := httptest.NewRecorder()
-	rc.HandleHealthCheckRequest(writer, nil, nil)
-	assert.Equal(t, writer.Result().StatusCode, http.StatusOK)
+	controller.EndcSetup(writer, httpRequest)
+
+	assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
 }
 
-func handleRequest(writer *httptest.ResponseRecorder, log *logger.Logger, rmrMessengerMock *mocks.RmrMessengerMock,
-	request *http.Request, messageType string) {
-	rmrService := getRmrService(rmrMessengerMock, log)
-	params := []httprouter.Param{{Key: "messageType", Value: messageType}}
+func TestShutdownHandlerRnibError(t *testing.T) {
+	controller, _, _, _, e2tInstancesManagerMock := setupControllerTest(t)
+	e2tInstancesManagerMock.On("GetE2TAddresses").Return([]string{}, e2managererrors.NewRnibDbError())
 
-	var nodebInfo *entities.NodebInfo
-	var nbIdentity *entities.NbIdentity
+	writer := httptest.NewRecorder()
+
+	controller.Shutdown(writer, tests.GetHttpRequest())
 
-	rnibWriterMock := mocks.RnibWriterMock{}
-	rnibWriterMock.On("SaveNodeb",
-		mock.AnythingOfType(fmt.Sprintf("%T", nbIdentity)),
-		mock.AnythingOfType(fmt.Sprintf("%T", nodebInfo))).Return(nil)
+	var errorResponse = parseJsonRequest(t, writer.Body)
 
-	rnibReaderProvider := func() reader.RNibReader {
-		return &mocks.RnibReaderMock{}
+	assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
+	assert.Equal(t, errorResponse.Code, e2managererrors.NewRnibDbError().Code)
+}
+
+func controllerGetNodebTestExecuter(t *testing.T, context *controllerGetNodebTestContext) {
+	controller, readerMock, _, _, _ := setupControllerTest(t)
+	writer := httptest.NewRecorder()
+	readerMock.On("GetNodeb", context.ranName).Return(context.nodebInfo, context.rnibError)
+	req, _ := http.NewRequest(http.MethodGet, "/nodeb", nil)
+	req = mux.SetURLVars(req, map[string]string{"ranName": context.ranName})
+	controller.GetNodeb(writer, req)
+	assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
+	bodyBytes, _ := ioutil.ReadAll(writer.Body)
+	assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
+}
+
+func controllerGetNodebIdListTestExecuter(t *testing.T, context *controllerGetNodebIdListTestContext) {
+	controller, readerMock, _, _, _ := setupControllerTest(t)
+	writer := httptest.NewRecorder()
+	readerMock.On("GetListNodebIds").Return(context.nodebIdList, context.rnibError)
+	req, _ := http.NewRequest(http.MethodGet, "/nodeb/ids", nil)
+	controller.GetNodebIdList(writer, req)
+	assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
+	bodyBytes, _ := ioutil.ReadAll(writer.Body)
+	assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
+}
+
+func activateControllerUpdateGnbMocks(context *controllerUpdateGnbTestContext, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
+	if context.getNodebInfoResult != nil {
+		readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
 	}
 
-	rnibWriterProvider := func() rNibWriter.RNibWriter {
-		return &rnibWriterMock
+	if context.removeServedNrCellsParams != nil {
+		writerMock.On("RemoveServedNrCells", RanName, context.removeServedNrCellsParams.servedNrCells).Return(context.removeServedNrCellsParams.err)
 	}
 
-	NewNodebController(log, rmrService, rnibReaderProvider, rnibWriterProvider).HandleRequest(writer, request, params)
+	if context.updateGnbCellsParams != nil {
+		updatedNodebInfo := *context.getNodebInfoResult.nodebInfo
+		gnb := entities.Gnb{}
+		_ = jsonpb.Unmarshal(getJsonRequestAsBuffer(context.requestBody), &gnb)
+		updatedGnb := *updatedNodebInfo.GetGnb()
+		updatedGnb.ServedNrCells = gnb.ServedNrCells
+		writerMock.On("UpdateGnbCells", &updatedNodebInfo, gnb.ServedNrCells).Return(context.updateGnbCellsParams.err)
+	}
 }
 
-func getRmrService(rmrMessengerMock *mocks.RmrMessengerMock, log *logger.Logger) *services.RmrService {
-	rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
-	messageChannel := make(chan *models.NotificationResponse)
-	rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
-	return services.NewRmrService(services.NewRmrConfig(tests.Port, tests.MaxMsgSize, tests.Flags, log), rmrMessenger,  make(sessions.E2Sessions), messageChannel)
+func assertControllerUpdateGnb(t *testing.T, context *controllerUpdateGnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
+	assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
+	bodyBytes, _ := ioutil.ReadAll(writer.Body)
+	assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
+	readerMock.AssertExpectations(t)
+	writerMock.AssertExpectations(t)
+
+	if context.getNodebInfoResult != nil {
+		readerMock.AssertNotCalled(t, "GetNodeb")
+	}
+
+	if context.updateGnbCellsParams != nil {
+		writerMock.AssertNotCalled(t, "UpdateGnb")
+	}
+
+	if context.removeServedNrCellsParams != nil {
+		writerMock.AssertNotCalled(t, "RemoveServedNrCells")
+	}
 }
 
+func buildUpdateGnbRequest(context *controllerUpdateGnbTestContext) *http.Request {
+	updateGnbUrl := fmt.Sprintf("/nodeb/%s/update", RanName)
+	requestBody := getJsonRequestAsBuffer(context.requestBody)
+	req, _ := http.NewRequest(http.MethodGet, updateGnbUrl, requestBody)
+	req.Header.Set("Content-Type", "application/json")
+	req = mux.SetURLVars(req, map[string]string{"ranName": RanName})
+	return req
+}
 
-func executeGetNodeb(logger *logger.Logger, writer *httptest.ResponseRecorder, rnibReaderProvider func() reader.RNibReader) {
-	req, _ := http.NewRequest("GET", "/nodeb", nil)
+func controllerUpdateGnbTestExecuter(t *testing.T, context *controllerUpdateGnbTestContext) {
+	controller, readerMock, writerMock, _, _ := setupControllerTest(t)
+	writer := httptest.NewRecorder()
 
-	params := []httprouter.Param{{Key: "ranName", Value: "testNode"}}
+	activateControllerUpdateGnbMocks(context, readerMock, writerMock)
+	req := buildUpdateGnbRequest(context)
+	controller.UpdateGnb(writer, req)
+	assertControllerUpdateGnb(t, context, writer, readerMock, writerMock)
+}
 
-	NewNodebController(logger, nil, rnibReaderProvider, nil).GetNodeb(writer, req, params)
+func TestControllerUpdateGnbEmptyServedNrCells(t *testing.T) {
+	context := controllerUpdateGnbTestContext{
+		getNodebInfoResult: nil,
+		requestBody: map[string]interface{}{
+			"servedNrCells": []interface{}{
+			},
+		},
+		expectedStatusCode:   http.StatusBadRequest,
+		expectedJsonResponse: ValidationFailureJson,
+	}
+
+	controllerUpdateGnbTestExecuter(t, &context)
 }
 
-func TestNodebController_GetNodeb_Success(t *testing.T) {
-	log, err := logger.InitLogger(logger.InfoLevel)
+func TestControllerUpdateGnbMissingServedNrCellInformation(t *testing.T) {
+	context := controllerUpdateGnbTestContext{
+		getNodebInfoResult: nil,
+		requestBody: map[string]interface{}{
+			"servedNrCells": []interface{}{
+				map[string]interface{}{
+					"servedNrCellInformation": nil,
+				},
+			},
+		},
+		expectedStatusCode:   http.StatusBadRequest,
+		expectedJsonResponse: ValidationFailureJson,
+	}
 
-	if err != nil {
-		t.Errorf("#nodeb_controller_test.TestNodebController_GetNodeb_Success - failed to initialize logger, error: %s", err)
+	controllerUpdateGnbTestExecuter(t, &context)
+}
+
+func TestControllerUpdateGnbMissingServedNrCellRequiredProp(t *testing.T) {
+
+	for _, v := range ServedNrCellInformationRequiredFields {
+		context := controllerUpdateGnbTestContext{
+			getNodebInfoResult: nil,
+			requestBody: map[string]interface{}{
+				"servedNrCells": []interface{}{
+					map[string]interface{}{
+						"servedNrCellInformation": buildServedNrCellInformation(v),
+					},
+				},
+			},
+			expectedStatusCode:   http.StatusBadRequest,
+			expectedJsonResponse: ValidationFailureJson,
+		}
+
+		controllerUpdateGnbTestExecuter(t, &context)
 	}
+}
 
-	writer := httptest.NewRecorder()
+func TestControllerUpdateGnbMissingServedNrCellFddOrTdd(t *testing.T) {
+
+	servedNrCellInformation := buildServedNrCellInformation("")
+	servedNrCellInformation["choiceNrMode"] = map[string]interface{}{}
+
+	context := controllerUpdateGnbTestContext{
+		getNodebInfoResult: nil,
+		requestBody: map[string]interface{}{
+			"servedNrCells": []interface{}{
+				map[string]interface{}{
+					"servedNrCellInformation": servedNrCellInformation,
+				},
+			},
+		},
+		expectedStatusCode:   http.StatusBadRequest,
+		expectedJsonResponse: ValidationFailureJson,
+	}
 
-	rnibReaderMock := mocks.RnibReaderMock{}
+	controllerUpdateGnbTestExecuter(t, &context)
+}
 
-	var rnibError common.IRNibError
-	rnibReaderMock.On("GetNodeb", "testNode").Return(&entities.NodebInfo{}, rnibError)
+func TestControllerUpdateGnbMissingNeighbourInfoFddOrTdd(t *testing.T) {
+
+	nrNeighbourInfo := buildNrNeighbourInformation("")
+	nrNeighbourInfo["choiceNrMode"] = map[string]interface{}{}
+
+	context := controllerUpdateGnbTestContext{
+		getNodebInfoResult: nil,
+		requestBody: map[string]interface{}{
+			"servedNrCells": []interface{}{
+				map[string]interface{}{
+					"servedNrCellInformation": buildServedNrCellInformation(""),
+					"nrNeighbourInfos": []interface{}{
+						nrNeighbourInfo,
+					},
+				},
+			},
+		},
+		expectedStatusCode:   http.StatusBadRequest,
+		expectedJsonResponse: ValidationFailureJson,
+	}
+
+	controllerUpdateGnbTestExecuter(t, &context)
+}
 
-	rnibReaderProvider := func() reader.RNibReader {
-		return &rnibReaderMock
+func TestControllerUpdateGnbMissingNrNeighbourInformationRequiredProp(t *testing.T) {
+
+	for _, v := range NrNeighbourInformationRequiredFields {
+		context := controllerUpdateGnbTestContext{
+			getNodebInfoResult: nil,
+			requestBody: map[string]interface{}{
+				"servedNrCells": []interface{}{
+					map[string]interface{}{
+						"servedNrCellInformation": buildServedNrCellInformation(""),
+						"nrNeighbourInfos": []interface{}{
+							buildNrNeighbourInformation(v),
+						},
+					},
+				},
+			},
+			expectedStatusCode:   http.StatusBadRequest,
+			expectedJsonResponse: ValidationFailureJson,
+		}
+
+		controllerUpdateGnbTestExecuter(t, &context)
 	}
+}
 
-	executeGetNodeb(log, writer, rnibReaderProvider)
+func TestControllerUpdateGnbValidServedNrCellInformationGetNodebNotFound(t *testing.T) {
+	context := controllerUpdateGnbTestContext{
+		getNodebInfoResult: &getNodebInfoResult{
+			nodebInfo: nil,
+			rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
+		},
+		requestBody: map[string]interface{}{
+			"servedNrCells": []interface{}{
+				map[string]interface{}{
+					"servedNrCellInformation": buildServedNrCellInformation(""),
+				},
+			},
+		},
+		expectedStatusCode:   http.StatusNotFound,
+		expectedJsonResponse: ResourceNotFoundJson,
+	}
 
-	assert.Equal(t, writer.Result().StatusCode, http.StatusOK)
+	controllerUpdateGnbTestExecuter(t, &context)
 }
 
-func TestNodebController_GetNodeb_NotFound(t *testing.T) {
-	log, err := logger.InitLogger(logger.InfoLevel)
+func TestControllerUpdateGnbValidServedNrCellInformationGetNodebInternalError(t *testing.T) {
+	context := controllerUpdateGnbTestContext{
+		getNodebInfoResult: &getNodebInfoResult{
+			nodebInfo: nil,
+			rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
+		},
+		requestBody: map[string]interface{}{
+			"servedNrCells": []interface{}{
+				map[string]interface{}{
+					"servedNrCellInformation": buildServedNrCellInformation(""),
+				},
+			},
+		},
+		expectedStatusCode:   http.StatusInternalServerError,
+		expectedJsonResponse: RnibErrorJson,
+	}
 
-	if err != nil {
-		t.Errorf("#nodeb_controller_test.TestNodebController_GetNodeb_NotFound - failed to initialize logger, error: %s", err)
+	controllerUpdateGnbTestExecuter(t, &context)
+}
+
+func TestControllerUpdateGnbGetNodebSuccessInvalidGnbConfiguration(t *testing.T) {
+	context := controllerUpdateGnbTestContext{
+		getNodebInfoResult: &getNodebInfoResult{
+			nodebInfo: &entities.NodebInfo{
+				RanName:                      RanName,
+				ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
+				AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
+			},
+			rnibError: nil,
+		},
+		requestBody: map[string]interface{}{
+			"servedNrCells": []interface{}{
+				map[string]interface{}{
+					"servedNrCellInformation": buildServedNrCellInformation(""),
+					"nrNeighbourInfos": []interface{}{
+						buildNrNeighbourInformation(""),
+					},
+				},
+			},
+		},
+		expectedStatusCode:   http.StatusInternalServerError,
+		expectedJsonResponse: InternalErrorJson,
 	}
 
-	writer := httptest.NewRecorder()
+	controllerUpdateGnbTestExecuter(t, &context)
+}
 
-	rnibReaderMock := mocks.RnibReaderMock{}
-	rnibError := common.NewResourceNotFoundError(errors.Errorf("#reader.GetNodeb - responding node %s not found", "testNode"))
-	var nodebInfo *entities.NodebInfo
-	rnibReaderMock.On("GetNodeb", "testNode").Return(nodebInfo, rnibError)
+func TestControllerUpdateGnbGetNodebSuccessRemoveServedNrCellsFailure(t *testing.T) {
+	oldServedNrCells := generateServedNrCells("whatever1", "whatever2")
+	context := controllerUpdateGnbTestContext{
+		removeServedNrCellsParams: &removeServedNrCellsParams{
+			err:           common.NewInternalError(errors.New("#writer.UpdateGnbCells - Internal Error")),
+			servedNrCells: oldServedNrCells,
+		},
+		getNodebInfoResult: &getNodebInfoResult{
+			nodebInfo: &entities.NodebInfo{
+				RanName:                      RanName,
+				ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
+				AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
+				Configuration:                &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{ServedNrCells: oldServedNrCells}},
+			},
+			rnibError: nil,
+		},
+		requestBody: map[string]interface{}{
+			"servedNrCells": []interface{}{
+				map[string]interface{}{
+					"servedNrCellInformation": buildServedNrCellInformation(""),
+					"nrNeighbourInfos": []interface{}{
+						buildNrNeighbourInformation(""),
+					},
+				},
+			},
+		},
+		expectedStatusCode:   http.StatusInternalServerError,
+		expectedJsonResponse: RnibErrorJson,
+	}
 
-	rnibReaderProvider := func() reader.RNibReader {
-		return &rnibReaderMock
+	controllerUpdateGnbTestExecuter(t, &context)
+}
+
+func TestControllerUpdateGnbGetNodebSuccessUpdateGnbCellsFailure(t *testing.T) {
+	oldServedNrCells := generateServedNrCells("whatever1", "whatever2")
+	context := controllerUpdateGnbTestContext{
+		removeServedNrCellsParams: &removeServedNrCellsParams{
+			err:           nil,
+			servedNrCells: oldServedNrCells,
+		},
+		updateGnbCellsParams: &updateGnbCellsParams{
+			err: common.NewInternalError(errors.New("#writer.UpdateGnbCells - Internal Error")),
+		},
+		getNodebInfoResult: &getNodebInfoResult{
+			nodebInfo: &entities.NodebInfo{
+				RanName:                      RanName,
+				ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
+				AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
+				Configuration:                &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{ServedNrCells: oldServedNrCells}},
+			},
+			rnibError: nil,
+		},
+		requestBody: map[string]interface{}{
+			"servedNrCells": []interface{}{
+				map[string]interface{}{
+					"servedNrCellInformation": buildServedNrCellInformation(""),
+					"nrNeighbourInfos": []interface{}{
+						buildNrNeighbourInformation(""),
+					},
+				},
+			},
+		},
+		expectedStatusCode:   http.StatusInternalServerError,
+		expectedJsonResponse: RnibErrorJson,
 	}
 
-	executeGetNodeb(log, writer, rnibReaderProvider)
-	assert.Equal(t, writer.Result().StatusCode, http.StatusNotFound)
+	controllerUpdateGnbTestExecuter(t, &context)
 }
 
-func TestNodebController_GetNodeb_InternalError(t *testing.T) {
-	log, err := logger.InitLogger(logger.InfoLevel)
+func TestControllerUpdateGnbSuccess(t *testing.T) {
+	context := controllerUpdateGnbTestContext{
+		updateGnbCellsParams: &updateGnbCellsParams{
+			err: nil,
+		},
+		getNodebInfoResult: &getNodebInfoResult{
+			nodebInfo: &entities.NodebInfo{
+				RanName:                      RanName,
+				ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
+				AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
+				Configuration:                &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{}},
+			},
+			rnibError: nil,
+		},
+		requestBody: map[string]interface{}{
+			"servedNrCells": []interface{}{
+				map[string]interface{}{
+					"servedNrCellInformation": buildServedNrCellInformation(""),
+					"nrNeighbourInfos": []interface{}{
+						buildNrNeighbourInformation(""),
+					},
+				},
+			},
+		},
+		expectedStatusCode:   http.StatusOK,
+		expectedJsonResponse: "{\"ranName\":\"test\",\"connectionStatus\":\"CONNECTED\",\"gnb\":{\"servedNrCells\":[{\"servedNrCellInformation\":{\"nrPci\":1,\"cellId\":\"whatever\",\"servedPlmns\":[\"whatever\"],\"nrMode\":\"FDD\",\"choiceNrMode\":{\"fdd\":{}}},\"nrNeighbourInfos\":[{\"nrPci\":1,\"nrCgi\":\"whatever\",\"nrMode\":\"FDD\",\"choiceNrMode\":{\"tdd\":{}}}]}]},\"associatedE2tInstanceAddress\":\"10.0.2.15:38000\"}",
+	}
 
-	if err != nil {
-		t.Errorf("#nodeb_controller_test.TestNodebController_GetNodeb_InternalError - failed to initialize logger, error: %s", err)
+	controllerUpdateGnbTestExecuter(t, &context)
+}
+
+func getJsonRequestAsBuffer(requestJson map[string]interface{}) *bytes.Buffer {
+	b := new(bytes.Buffer)
+	_ = json.NewEncoder(b).Encode(requestJson)
+	return b
+}
+
+func TestControllerGetNodebSuccess(t *testing.T) {
+	ranName := "test"
+	var rnibError error
+	context := controllerGetNodebTestContext{
+		ranName:              ranName,
+		nodebInfo:            &entities.NodebInfo{RanName: ranName, Ip: "10.0.2.15", Port: 1234},
+		rnibError:            rnibError,
+		expectedStatusCode:   http.StatusOK,
+		expectedJsonResponse: fmt.Sprintf("{\"ranName\":\"%s\",\"ip\":\"10.0.2.15\",\"port\":1234}", ranName),
 	}
 
-	writer := httptest.NewRecorder()
+	controllerGetNodebTestExecuter(t, &context)
+}
 
-	rnibReaderMock := mocks.RnibReaderMock{}
+func TestControllerGetNodebNotFound(t *testing.T) {
 
-	rnibError := common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error"))
+	ranName := "test"
 	var nodebInfo *entities.NodebInfo
-	rnibReaderMock.On("GetNodeb", "testNode").Return(nodebInfo, rnibError)
+	context := controllerGetNodebTestContext{
+		ranName:              ranName,
+		nodebInfo:            nodebInfo,
+		rnibError:            common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
+		expectedStatusCode:   http.StatusNotFound,
+		expectedJsonResponse: ResourceNotFoundJson,
+	}
 
-	rnibReaderProvider := func() reader.RNibReader {
-		return &rnibReaderMock
+	controllerGetNodebTestExecuter(t, &context)
+}
+
+func TestControllerGetNodebInternal(t *testing.T) {
+	ranName := "test"
+	var nodebInfo *entities.NodebInfo
+	context := controllerGetNodebTestContext{
+		ranName:              ranName,
+		nodebInfo:            nodebInfo,
+		rnibError:            common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
+		expectedStatusCode:   http.StatusInternalServerError,
+		expectedJsonResponse: RnibErrorJson,
 	}
 
-	executeGetNodeb(log, writer, rnibReaderProvider)
-	assert.Equal(t, writer.Result().StatusCode, http.StatusInternalServerError)
+	controllerGetNodebTestExecuter(t, &context)
 }
 
-func executeGetNodebIdList(logger *logger.Logger, writer *httptest.ResponseRecorder, rnibReaderProvider func() reader.RNibReader) {
-	req, _ := http.NewRequest("GET", "/nodeb-ids", nil)
-	NewNodebController(logger, nil, rnibReaderProvider, nil ).GetNodebIdList(writer,req,nil)
+func TestControllerGetNodebIdListSuccess(t *testing.T) {
+	var rnibError error
+	nodebIdList := []*entities.NbIdentity{
+		{InventoryName: "test1", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}},
+		{InventoryName: "test2", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId2", NbId: "nbId2"}},
+	}
+
+	context := controllerGetNodebIdListTestContext{
+		nodebIdList:          nodebIdList,
+		rnibError:            rnibError,
+		expectedStatusCode:   http.StatusOK,
+		expectedJsonResponse: "[{\"inventoryName\":\"test1\",\"globalNbId\":{\"plmnId\":\"plmnId1\",\"nbId\":\"nbId1\"}},{\"inventoryName\":\"test2\",\"globalNbId\":{\"plmnId\":\"plmnId2\",\"nbId\":\"nbId2\"}}]",
+	}
+
+	controllerGetNodebIdListTestExecuter(t, &context)
 }
 
-func TestNodebController_GetNodebIdList_Success(t *testing.T) {
-	logger, err := logger.InitLogger(logger.InfoLevel)
+func TestControllerGetNodebIdListEmptySuccess(t *testing.T) {
+	var rnibError error
+	nodebIdList := []*entities.NbIdentity{}
+
+	context := controllerGetNodebIdListTestContext{
+		nodebIdList:          nodebIdList,
+		rnibError:            rnibError,
+		expectedStatusCode:   http.StatusOK,
+		expectedJsonResponse: "[]",
+	}
+
+	controllerGetNodebIdListTestExecuter(t, &context)
+}
 
-	if err!=nil{
-		t.Errorf("#nodeb_controller_test.TestNodebController_GetNodebIdList_Success - failed to initialize logger, error: %s", err)
+func TestControllerGetNodebIdListInternal(t *testing.T) {
+	var nodebIdList []*entities.NbIdentity
+	context := controllerGetNodebIdListTestContext{
+		nodebIdList:          nodebIdList,
+		rnibError:            common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
+		expectedStatusCode:   http.StatusInternalServerError,
+		expectedJsonResponse: RnibErrorJson,
 	}
 
+	controllerGetNodebIdListTestExecuter(t, &context)
+}
+
+func TestHeaderValidationFailed(t *testing.T) {
+	controller, _, _, _, _ := setupControllerTest(t)
+
 	writer := httptest.NewRecorder()
 
-	rnibReaderMock := mocks.RnibReaderMock{}
-	var rnibError common.IRNibError
+	header := &http.Header{}
 
-	enbList := []*entities.NbIdentity{&entities.NbIdentity{InventoryName:"test1", GlobalNbId: &entities.GlobalNbId{PlmnId:"plmnId1",NbId: "nbId1"}}}
-	gnbList := []*entities.NbIdentity{&entities.NbIdentity{InventoryName:"test2", GlobalNbId: &entities.GlobalNbId{PlmnId:"plmnId2",NbId: "nbId2"}}}
+	controller.handleRequest(writer, header, httpmsghandlerprovider.ShutdownRequest, nil, true)
 
-	rnibReaderMock.On("GetListEnbIds").Return(&enbList, rnibError)
-	rnibReaderMock.On("GetListGnbIds").Return(&gnbList, rnibError)
+	var errorResponse = parseJsonRequest(t, writer.Body)
+	err := e2managererrors.NewHeaderValidationError()
 
+	assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
+	assert.Equal(t, errorResponse.Code, err.Code)
+	assert.Equal(t, errorResponse.Message, err.Message)
+}
 
-	rnibReaderProvider:= func() reader.RNibReader {
-		return &rnibReaderMock
-	}
+func TestShutdownStatusNoContent(t *testing.T) {
+	controller, readerMock, _, _, e2tInstancesManagerMock := setupControllerTest(t)
+	e2tInstancesManagerMock.On("GetE2TAddresses").Return([]string{}, nil)
+	readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{}, nil)
 
-	executeGetNodebIdList(logger, writer, rnibReaderProvider)
-	assert.Equal(t, writer.Result().StatusCode, http.StatusOK)
-	bodyBytes, err := ioutil.ReadAll(writer.Body)
-	assert.Equal(t, "[{\"inventoryName\":\"test1\",\"globalNbId\":{\"plmnId\":\"plmnId1\",\"nbId\":\"nbId1\"}},{\"inventoryName\":\"test2\",\"globalNbId\":{\"plmnId\":\"plmnId2\",\"nbId\":\"nbId2\"}}]",string(bodyBytes) )
+	writer := httptest.NewRecorder()
+	controller.Shutdown(writer, tests.GetHttpRequest())
+
+	assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
 }
 
-func TestNodebController_GetNodebIdList_EmptyList(t *testing.T) {
-	log, err := logger.InitLogger(logger.InfoLevel)
+func TestHandleInternalError(t *testing.T) {
+	controller, _, _, _, _ := setupControllerTest(t)
 
-	if err!=nil{
-		t.Errorf("#nodeb_controller_test.TestNodebController_GetNodebIdList_EmptyList - failed to initialize logger, error: %s", err)
-	}
+	writer := httptest.NewRecorder()
+	err := e2managererrors.NewInternalError()
+
+	controller.handleErrorResponse(err, writer)
+	var errorResponse = parseJsonRequest(t, writer.Body)
 
+	assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
+	assert.Equal(t, errorResponse.Code, err.Code)
+	assert.Equal(t, errorResponse.Message, err.Message)
+}
+
+func TestHandleCommandAlreadyInProgressError(t *testing.T) {
+	controller, _, _, _, _ := setupControllerTest(t)
 	writer := httptest.NewRecorder()
+	err := e2managererrors.NewCommandAlreadyInProgressError()
 
-	rnibReaderMock := mocks.RnibReaderMock{}
+	controller.handleErrorResponse(err, writer)
+	var errorResponse = parseJsonRequest(t, writer.Body)
 
-	var rnibError common.IRNibError
-	enbList := []*entities.NbIdentity{}
-	gnbList := []*entities.NbIdentity{}
+	assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
+	assert.Equal(t, errorResponse.Code, err.Code)
+	assert.Equal(t, errorResponse.Message, err.Message)
+}
 
-	rnibReaderMock.On("GetListEnbIds").Return(&enbList, rnibError)
-	rnibReaderMock.On("GetListGnbIds").Return(&gnbList, rnibError)
+func TestHandleRoutingManagerError(t *testing.T) {
+	controller, _, _, _, _ := setupControllerTest(t)
+	writer := httptest.NewRecorder()
+	err := e2managererrors.NewRoutingManagerError()
 
+	controller.handleErrorResponse(err, writer)
+	var errorResponse = parseJsonRequest(t, writer.Body)
 
-	rnibReaderProvider:= func() reader.RNibReader {
-		return &rnibReaderMock
-	}
+	assert.Equal(t, http.StatusServiceUnavailable, writer.Result().StatusCode)
+	assert.Equal(t, errorResponse.Code, err.Code)
+	assert.Equal(t, errorResponse.Message, err.Message)
+}
+
+func TestHandleE2TInstanceAbsenceError(t *testing.T) {
+	controller, _, _, _, _ := setupControllerTest(t)
+
+	writer := httptest.NewRecorder()
+	err := e2managererrors.NewE2TInstanceAbsenceError()
+
+	controller.handleErrorResponse(err, writer)
+	var errorResponse = parseJsonRequest(t, writer.Body)
+
+	assert.Equal(t, http.StatusServiceUnavailable, writer.Result().StatusCode)
+	assert.Equal(t, errorResponse.Code, err.Code)
+	assert.Equal(t, errorResponse.Message, err.Message)
+}
+
+func TestValidateHeaders(t *testing.T) {
+	controller, _, _, _, _ := setupControllerTest(t)
 
-	executeGetNodebIdList(log, writer, rnibReaderProvider)
+	header := http.Header{}
+	header.Set("Content-Type", "application/json")
+	result := controller.validateRequestHeader(&header)
 
-	assert.Equal(t, writer.Result().StatusCode, http.StatusOK)
-	bodyBytes, err := ioutil.ReadAll(writer.Body)
-	assert.Equal(t, "[]", string(bodyBytes))
+	assert.Nil(t, result)
 }
 
-func TestNodebController_GetNodebIdList_InternalError(t *testing.T) {
-	logger, err := logger.InitLogger(logger.InfoLevel)
+func parseJsonRequest(t *testing.T, r io.Reader) models.ErrorResponse {
 
+	var errorResponse models.ErrorResponse
+	body, err := ioutil.ReadAll(r)
 	if err != nil {
-		t.Errorf("#nodeb_controller_test.TestNodebController_GetNodebIdList_InternalError - failed to initialize logger, error: %s", err)
+		t.Errorf("Error cannot deserialize json request")
 	}
+	_ = json.Unmarshal(body, &errorResponse)
+
+	return errorResponse
+}
+
+func initLog(t *testing.T) *logger.Logger {
+	log, err := logger.InitLogger(logger.InfoLevel)
+	if err != nil {
+		t.Errorf("#delete_all_request_handler_test.TestHandleSuccessFlow - failed to initialize logger, error: %s", err)
+	}
+	return log
+}
+
+func TestX2ResetHandleSuccessfulRequestedCause(t *testing.T) {
+	controller, readerMock, _, rmrMessengerMock, _ := setupControllerTest(t)
+
+	ranName := "test1"
+	payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x40}
+	var xAction []byte
+	var msgSrc unsafe.Pointer
+	msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction, msgSrc)
+	rmrMessengerMock.On("SendMsg", msg, mock.Anything).Return(msg, nil)
 
 	writer := httptest.NewRecorder()
 
-	rnibReaderMock := mocks.RnibReaderMock{}
+	var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
+	readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
 
-	rnibError := common.NewInternalError(errors.New("#reader.GetEnbIdList - Internal Error"))
-	var enbList *[]*entities.NbIdentity
-	rnibReaderMock.On("GetListEnbIds").Return(enbList, rnibError)
+	data4Req := map[string]interface{}{"cause": "protocol:transfer-syntax-error"}
+	b := new(bytes.Buffer)
+	_ = json.NewEncoder(b).Encode(data4Req)
+	req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
+	req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
 
-	rnibReaderProvider := func() reader.RNibReader {
-		return &rnibReaderMock
-	}
+	controller.X2Reset(writer, req)
+	assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
 
-	executeGetNodebIdList(logger, writer, rnibReaderProvider)
-	assert.Equal(t, writer.Result().StatusCode, http.StatusInternalServerError)
 }
 
-func TestNodebController_GetNodebIdList_Success_One(t *testing.T) {
-	logger, err := logger.InitLogger(logger.InfoLevel)
+func TestX2ResetHandleSuccessfulRequestedDefault(t *testing.T) {
+	controller, readerMock, _, rmrMessengerMock, _ := setupControllerTest(t)
 
-	if err!=nil{
-		t.Errorf("#nodeb_controller_test.TestNodebController_GetNodebIdList_Success - failed to initialize logger, error: %s", err)
-	}
+	ranName := "test1"
+	// o&m intervention
+	payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x64}
+	var xAction []byte
+	var msgSrc unsafe.Pointer
+	msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction, msgSrc)
+	rmrMessengerMock.On("SendMsg", msg, true).Return(msg, nil)
 
 	writer := httptest.NewRecorder()
 
-	rnibReaderMock := mocks.RnibReaderMock{}
-	var rnibError common.IRNibError
+	var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
+	readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
 
-	enbList := []*entities.NbIdentity{}
-	gnbList := []*entities.NbIdentity{&entities.NbIdentity{InventoryName:"test2", GlobalNbId: &entities.GlobalNbId{PlmnId:"plmnId2",NbId: "nbId2"}}}
+	// no body
+	b := new(bytes.Buffer)
+	req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
+	req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
 
-	rnibReaderMock.On("GetListEnbIds").Return(&enbList, rnibError)
-	rnibReaderMock.On("GetListGnbIds").Return(&gnbList, rnibError)
+	controller.X2Reset(writer, req)
+	assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
 
+}
 
-	rnibReaderProvider:= func() reader.RNibReader {
-		return &rnibReaderMock
-	}
+func TestX2ResetHandleFailureInvalidBody(t *testing.T) {
+	controller, _, _, _, _ := setupControllerTest(t)
 
-	executeGetNodebIdList(logger, writer, rnibReaderProvider)
-	assert.Equal(t, writer.Result().StatusCode, http.StatusOK)
-	bodyBytes, err := ioutil.ReadAll(writer.Body)
-	assert.Equal(t, "[{\"inventoryName\":\"test2\",\"globalNbId\":{\"plmnId\":\"plmnId2\",\"nbId\":\"nbId2\"}}]",string(bodyBytes) )
-}
+	ranName := "test1"
 
-func TestNodebController_GetNodebIdList_Success_Many(t *testing.T) {
-	logger, err := logger.InitLogger(logger.InfoLevel)
+	writer := httptest.NewRecorder()
 
-	if err!=nil{
-		t.Errorf("#nodeb_controller_test.TestNodebController_GetNodebIdList_Success - failed to initialize logger, error: %s", err)
-	}
+	// Invalid json: attribute name without quotes (should be "cause":).
+	b := strings.NewReader("{cause:\"protocol:transfer-syntax-error\"")
+	req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
+	req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
+
+	controller.X2Reset(writer, req)
+	assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
+
+}
+
+func TestHandleErrorResponse(t *testing.T) {
+	controller, _, _, _, _ := setupControllerTest(t)
 
 	writer := httptest.NewRecorder()
+	controller.handleErrorResponse(e2managererrors.NewRnibDbError(), writer)
+	assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
+
+	writer = httptest.NewRecorder()
+	controller.handleErrorResponse(e2managererrors.NewCommandAlreadyInProgressError(), writer)
+	assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
 
-	rnibReaderMock := mocks.RnibReaderMock{}
-	var rnibError common.IRNibError
+	writer = httptest.NewRecorder()
+	controller.handleErrorResponse(e2managererrors.NewHeaderValidationError(), writer)
+	assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
 
-	enbList := []*entities.NbIdentity{&entities.NbIdentity{InventoryName:"test1", GlobalNbId: &entities.GlobalNbId{PlmnId:"plmnId1",NbId: "nbId1"}}}
-	gnbList := []*entities.NbIdentity{&entities.NbIdentity{InventoryName:"test2", GlobalNbId: &entities.GlobalNbId{PlmnId:"plmnId2",NbId: "nbId2"}}, {InventoryName:"test3", GlobalNbId: &entities.GlobalNbId{PlmnId:"plmnId3",NbId: "nbId3"}}}
+	writer = httptest.NewRecorder()
+	controller.handleErrorResponse(e2managererrors.NewWrongStateError("", ""), writer)
+	assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
 
-	rnibReaderMock.On("GetListEnbIds").Return(&enbList, rnibError)
-	rnibReaderMock.On("GetListGnbIds").Return(&gnbList, rnibError)
+	writer = httptest.NewRecorder()
+	controller.handleErrorResponse(e2managererrors.NewRequestValidationError(), writer)
+	assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
 
+	writer = httptest.NewRecorder()
+	controller.handleErrorResponse(e2managererrors.NewRmrError(), writer)
+	assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
 
-	rnibReaderProvider:= func() reader.RNibReader {
-		return &rnibReaderMock
-	}
+	writer = httptest.NewRecorder()
+	controller.handleErrorResponse(e2managererrors.NewResourceNotFoundError(), writer)
+	assert.Equal(t, http.StatusNotFound, writer.Result().StatusCode)
 
-	executeGetNodebIdList(logger, writer, rnibReaderProvider)
-	assert.Equal(t, writer.Result().StatusCode, http.StatusOK)
-	bodyBytes, err := ioutil.ReadAll(writer.Body)
-	assert.Equal(t, "[{\"inventoryName\":\"test1\",\"globalNbId\":{\"plmnId\":\"plmnId1\",\"nbId\":\"nbId1\"}},{\"inventoryName\":\"test2\",\"globalNbId\":{\"plmnId\":\"plmnId2\",\"nbId\":\"nbId2\"}},{\"inventoryName\":\"test3\",\"globalNbId\":{\"plmnId\":\"plmnId3\",\"nbId\":\"nbId3\"}}]",string(bodyBytes) )
-}
\ No newline at end of file
+	writer = httptest.NewRecorder()
+	controller.handleErrorResponse(fmt.Errorf("ErrorError"), writer)
+	assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
+}
+
+func getRmrSender(rmrMessengerMock *mocks.RmrMessengerMock, log *logger.Logger) *rmrsender.RmrSender {
+	rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
+	rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
+	return rmrsender.NewRmrSender(log, rmrMessenger)
+}