RIC-193 - Setup from RAN fixes: Marshal XML Response, trim whitespaces, convert ricId...

Change-Id: Id911cdfb01fb9394adaa139d0eb6d2eca4445cb2
Signed-off-by: ns019t <ns019t@intl.att.com>

diff --git a/E2Manager/handlers/rmrmsghandlers/e2_setup_request_notification_handler.go b/E2Manager/handlers/rmrmsghandlers/e2_setup_request_notification_handler.go
index 90a417c..8ec18eb 100644 (file)
--- a/E2Manager/handlers/rmrmsghandlers/e2_setup_request_notification_handler.go
+++ b/E2Manager/handlers/rmrmsghandlers/e2_setup_request_notification_handler.go
@@ -34,6 +34,8 @@ import (
        "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"
+       "strconv"
+       "strings"
 )
 
 type E2SetupRequestNotificationHandler struct {
@@ -58,7 +60,7 @@ func NewE2SetupRequestNotificationHandler(logger *logger.Logger, config *configu
 
 func (h E2SetupRequestNotificationHandler) Handle(request *models.NotificationRequest){
        ranName := request.RanName
-       h.logger.Infof("#E2SetupRequestNotificationHandler.Handle - RAN name: %s - received E2 Setup Request. Payload: %x", ranName, request.Payload)
+       h.logger.Infof("#E2SetupRequestNotificationHandler.Handle - RAN name: %s - received E2_SETUP_REQUEST. Payload: %x", ranName, request.Payload)
 
        setupRequest, e2tIpAddress, err := h.parseSetupRequest(request.Payload)
        if err != nil {
@@ -113,21 +115,41 @@ func (h E2SetupRequestNotificationHandler) Handle(request *models.NotificationRe
                h.logger.Errorf("#E2SetupRequestNotificationHandler.Handle - RAN name: %s - failed to associate E2T to nodeB entity. Error: %s", ranName, err)
                return
        }
-       successResponse := models.NewE2SetupSuccessResponseMessage()
-       successResponse.SetPlmnId(h.config.GlobalRicId.PlmnId)
-       successResponse.SetRicId(h.config.GlobalRicId.RicNearRtId)
-       successResponse.SetExtractRanFunctionsIDList(setupRequest)
-       responsePayload, err := xml.Marshal(&successResponse.E2APPDU)
+
+       ricNearRtId, err := convertTo20BitString(h.config.GlobalRicId.RicNearRtId)
+       if err != nil{
+               h.logger.Errorf("#E2SetupRequestNotificationHandler.Handle - RAN name: %s - failed to convert RicNearRtId value %s to 20 bit string . Error: %s", ranName, h.config.GlobalRicId.RicNearRtId, err)
+               return
+       }
+       successResponse := models.NewE2SetupSuccessResponseMessage(h.config.GlobalRicId.PlmnId, ricNearRtId,setupRequest)
        h.logger.Debugf("#E2SetupRequestNotificationHandler.Handle - E2_SETUP_RESPONSE has been built successfully %+v", successResponse)
 
+       responsePayload, err := xml.Marshal(&successResponse.E2APPDU)
        if err != nil{
-               h.logger.Warnf("#E2SetupRequestNotificationHandler.Handle - RAN name: %s - Error marshalling E2 Setup Response. Response: %x", ranName, responsePayload)
+               h.logger.Warnf("#E2SetupRequestNotificationHandler.Handle - RAN name: %s - Error marshalling RIC_E2_SETUP_RESP. Payload: %s", ranName, responsePayload)
        }
+
+       responsePayload = replaceCriticalityTagsWithSelfClosing(responsePayload)
+
        msg := models.NewRmrMessage(rmrCgo.RIC_E2_SETUP_RESP, ranName, responsePayload, request.TransactionId)
-       h.logger.Infof("#E2SetupRequestNotificationHandler.Handle - RAN name: %s - E2 Setup Request has been built. Message: %x", ranName, msg)
+       h.logger.Infof("#E2SetupRequestNotificationHandler.Handle - RAN name: %s - RIC_E2_SETUP_RESP message has been built successfully. Message: %x", ranName, msg)
        _ = h.rmrSender.Send(msg)
 }
 
+func replaceCriticalityTagsWithSelfClosing(responsePayload []byte) []byte {
+       responseString := strings.Replace(string(responsePayload), "<reject></reject>", "<reject/>", -1)
+       responseString = strings.Replace(responseString, "<ignore></ignore>", "<ignore/>", -1)
+       return []byte(responseString)
+}
+
+func convertTo20BitString(ricNearRtId string) (string, error){
+       r, err := strconv.ParseUint(ricNearRtId, 16, 32)
+       if err != nil{
+               return "", err
+       }
+       return fmt.Sprintf("%020b", r)[:20], nil
+}
+
 func (h E2SetupRequestNotificationHandler) parseSetupRequest(payload []byte)(*models.E2SetupRequestMessage, string, error){
 
        pipInd := bytes.IndexByte(payload, '|')

diff --git a/E2Manager/handlers/rmrmsghandlers/e2_setup_request_notification_handler_test.go b/E2Manager/handlers/rmrmsghandlers/e2_setup_request_notification_handler_test.go
index 1d87809..f1d73e1 100644 (file)
--- a/E2Manager/handlers/rmrmsghandlers/e2_setup_request_notification_handler_test.go
+++ b/E2Manager/handlers/rmrmsghandlers/e2_setup_request_notification_handler_test.go
@@ -20,9 +20,7 @@
 package rmrmsghandlers
 
 import (
-       "bytes"
        "e2mgr/configuration"
-       "e2mgr/logger"
        "e2mgr/managers"
        "e2mgr/mocks"
        "e2mgr/models"
@@ -34,16 +32,13 @@ import (
        "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
        "github.com/stretchr/testify/assert"
        "github.com/stretchr/testify/mock"
-       "io"
        "io/ioutil"
-       "os"
        "path/filepath"
        "testing"
 )
 
 const (
        prefix = "10.0.2.15:9999|"
-       logFilePath = "./loggerTest.txt"
        e2tInstanceFullAddress = "10.0.2.15:9999"
        nodebRanName = "gnb:310-410-b5c67788"
 )
@@ -57,11 +52,11 @@ func TestParseSetupRequest_Success(t *testing.T){
        if err != nil {
                t.Fatal(err)
        }
-       handler := stubMockSuccessFlowNewNodeb(t)
+       handler, _, _, _, _, _ := initMocks(t)
        prefBytes := []byte(prefix)
        request, _, err := handler.parseSetupRequest(append(prefBytes, xmlGnb...))
        assert.Equal(t, request.GetPlmnId(), "131014")
-       assert.Equal(t, request.GetNbId(), "10110101110001100111011110001000")
+       assert.Equal(t, request.GetNbId(), "10011001101010101011")
 }
 
 func TestParseSetupRequest_PipFailure(t *testing.T){
@@ -73,7 +68,7 @@ func TestParseSetupRequest_PipFailure(t *testing.T){
        if err != nil {
                t.Fatal(err)
        }
-       handler := stubMockSuccessFlowNewNodeb(t)
+       handler, _, _, _, _, _ := initMocks(t)
        prefBytes := []byte("10.0.2.15:9999")
        request, _, err := handler.parseSetupRequest(append(prefBytes, xmlGnb...))
        assert.Nil(t, request)
@@ -82,7 +77,7 @@ func TestParseSetupRequest_PipFailure(t *testing.T){
 }
 
 func TestParseSetupRequest_UnmarshalFailure(t *testing.T){
-       handler := stubMockSuccessFlowNewNodeb(t)
+       handler, _, _, _, _, _ := initMocks(t)
        prefBytes := []byte(prefix)
        request, _, err := handler.parseSetupRequest(append(prefBytes, 1,2,3))
        assert.Nil(t, request)
@@ -100,20 +95,22 @@ func TestE2SetupRequestNotificationHandler_HandleNewGnbSuccess(t *testing.T) {
                t.Fatal(err)
        }
 
-       logFile, err := os.Create(logFilePath)
-       if err != nil{
-               t.Errorf("e2_setup_request_notification_handler_test.TestE2SetupRequestNotificationHandler_HandleNewGnbSuccess - failed to create file, error: %s", err)
-       }
-       oldStdout := os.Stdout
-       defer changeStdout(oldStdout)
-       defer removeLogFile(t)
-       os.Stdout = logFile
-
-       handler := stubMockSuccessFlowNewNodeb(t)
+       handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock := initMocks(t)
+       var e2tInstance = &entities.E2TInstance{}
+       e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(e2tInstance, nil)
+       var gnb *entities.NodebInfo
+       readerMock.On("GetNodeb", mock.Anything).Return(gnb, common.NewResourceNotFoundError("Not found"))
+       writerMock.On("SaveNodeb", mock.Anything, mock.Anything).Return(nil)
+       routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything).Return(nil)
+       writerMock.On("UpdateNodebInfo", mock.Anything).Return(nil)
+       e2tInstancesManagerMock.On("AddRansToInstance", mock.Anything, mock.Anything).Return(nil)
+       var errEmpty error
+       rmrMessage := &rmrCgo.MBuf{}
+       rmrMessengerMock.On("SendMsg", mock.Anything, mock.Anything).Return(rmrMessage, errEmpty)
        prefBytes := []byte(prefix)
        notificationRequest := &models.NotificationRequest{RanName: nodebRanName, Payload: append(prefBytes, xmlGnb...)}
        handler.Handle(notificationRequest)
-       assertSuccessFlowNewNodebLogs(t)
+       assertNewNodebSuccessCalls(readerMock, t, e2tInstancesManagerMock, writerMock, routingManagerClientMock, rmrMessengerMock)
 }
 
 func TestE2SetupRequestNotificationHandler_HandleNewEnGnbSuccess(t *testing.T) {
@@ -125,20 +122,23 @@ func TestE2SetupRequestNotificationHandler_HandleNewEnGnbSuccess(t *testing.T) {
        if err != nil {
                t.Fatal(err)
        }
-       logFile, err := os.Create(logFilePath)
-       if err != nil{
-               t.Errorf("e2_setup_request_notification_handler_test.TestE2SetupRequestNotificationHandler_HandleNewEnGnbSuccess - failed to create file, error: %s", err)
-       }
-       oldStdout := os.Stdout
-       defer changeStdout(oldStdout)
-       defer removeLogFile(t)
-       os.Stdout = logFile
 
-       handler := stubMockSuccessFlowNewNodeb(t)
+       handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock := initMocks(t)
+       var e2tInstance = &entities.E2TInstance{}
+       e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(e2tInstance, nil)
+       var gnb *entities.NodebInfo
+       readerMock.On("GetNodeb", mock.Anything).Return(gnb, common.NewResourceNotFoundError("Not found"))
+       writerMock.On("SaveNodeb", mock.Anything, mock.Anything).Return(nil)
+       routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything).Return(nil)
+       writerMock.On("UpdateNodebInfo", mock.Anything).Return(nil)
+       e2tInstancesManagerMock.On("AddRansToInstance", mock.Anything, mock.Anything).Return(nil)
+       var errEmpty error
+       rmrMessage := &rmrCgo.MBuf{}
+       rmrMessengerMock.On("SendMsg", mock.Anything, mock.Anything).Return(rmrMessage, errEmpty)
        prefBytes := []byte(prefix)
        notificationRequest := &models.NotificationRequest{RanName: nodebRanName, Payload: append(prefBytes, xmlEnGnb...)}
        handler.Handle(notificationRequest)
-       assertSuccessFlowNewNodebLogs(t)
+       assertNewNodebSuccessCalls(readerMock, t, e2tInstancesManagerMock, writerMock, routingManagerClientMock, rmrMessengerMock)
 }
 
 func TestE2SetupRequestNotificationHandler_HandleNewNgEnbSuccess(t *testing.T) {
@@ -150,20 +150,23 @@ func TestE2SetupRequestNotificationHandler_HandleNewNgEnbSuccess(t *testing.T) {
        if err != nil {
                t.Fatal(err)
        }
-       logFile, err := os.Create(logFilePath)
-       if err != nil{
-               t.Errorf("e2_setup_request_notification_handler_test.TestE2SetupRequestNotificationHandler_HandleNewNgEnbSuccess - failed to create file, error: %s", err)
-       }
-       oldStdout := os.Stdout
-       defer changeStdout(oldStdout)
-       defer removeLogFile(t)
-       os.Stdout = logFile
 
-       handler := stubMockSuccessFlowNewNodeb(t)
+       handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock := initMocks(t)
+       var e2tInstance = &entities.E2TInstance{}
+       e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(e2tInstance, nil)
+       var gnb *entities.NodebInfo
+       readerMock.On("GetNodeb", mock.Anything).Return(gnb, common.NewResourceNotFoundError("Not found"))
+       writerMock.On("SaveNodeb", mock.Anything, mock.Anything).Return(nil)
+       routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything).Return(nil)
+       writerMock.On("UpdateNodebInfo", mock.Anything).Return(nil)
+       e2tInstancesManagerMock.On("AddRansToInstance", mock.Anything, mock.Anything).Return(nil)
+       var errEmpty error
+       rmrMessage := &rmrCgo.MBuf{}
+       rmrMessengerMock.On("SendMsg", mock.Anything, mock.Anything).Return(rmrMessage, errEmpty)
        prefBytes := []byte(prefix)
        notificationRequest := &models.NotificationRequest{RanName: nodebRanName, Payload: append(prefBytes, xmlEnGnb...)}
        handler.Handle(notificationRequest)
-       assertSuccessFlowNewNodebLogs(t)
+       assertNewNodebSuccessCalls(readerMock, t, e2tInstancesManagerMock, writerMock, routingManagerClientMock, rmrMessengerMock)
 }
 
 func TestE2SetupRequestNotificationHandler_HandleExistingGnbSuccess(t *testing.T) {
@@ -176,20 +179,27 @@ func TestE2SetupRequestNotificationHandler_HandleExistingGnbSuccess(t *testing.T
                t.Fatal(err)
        }
 
-       logFile, err := os.Create(logFilePath)
-       if err != nil{
-               t.Errorf("e2_setup_request_notification_handler_test.TestE2SetupRequestNotificationHandler_HandleNewGnbSuccess - failed to create file, error: %s", err)
+       handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock := initMocks(t)
+       var e2tInstance = &entities.E2TInstance{}
+       e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(e2tInstance, nil)
+       var gnb = &entities.NodebInfo{
+               RanName: nodebRanName,
+               AssociatedE2TInstanceAddress: e2tInstanceFullAddress,
+               ConnectionStatus: entities.ConnectionStatus_CONNECTED,
+               NodeType: entities.Node_GNB,
+               Configuration: &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{}},
        }
-       oldStdout := os.Stdout
-       defer changeStdout(oldStdout)
-       defer removeLogFile(t)
-       os.Stdout = logFile
-
-       handler := stubMockSuccessFlowExistingNodeb(t)
+       readerMock.On("GetNodeb", mock.Anything).Return(gnb, nil)
+       routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything).Return(nil)
+       writerMock.On("UpdateNodebInfo", mock.Anything).Return(nil)
+       e2tInstancesManagerMock.On("AddRansToInstance", mock.Anything, mock.Anything).Return(nil)
+       var errEmpty error
+       rmrMessage := &rmrCgo.MBuf{}
+       rmrMessengerMock.On("SendMsg", mock.Anything, mock.Anything).Return(rmrMessage, errEmpty)
        prefBytes := []byte(prefix)
        notificationRequest := &models.NotificationRequest{RanName: nodebRanName, Payload: append(prefBytes, xmlGnb...)}
        handler.Handle(notificationRequest)
-       assertSuccessFlowExistingNodebLogs(t)
+       assertExistingNodebSuccessCalls(readerMock, t, e2tInstancesManagerMock, writerMock, routingManagerClientMock, rmrMessengerMock)
 }
 
 func TestE2SetupRequestNotificationHandler_HandleParseError(t *testing.T) {
@@ -202,37 +212,29 @@ func TestE2SetupRequestNotificationHandler_HandleParseError(t *testing.T) {
                t.Fatal(err)
        }
 
-       logFile, err := os.Create(logFilePath)
-       if err != nil{
-               t.Errorf("e2_setup_request_notification_handler_test.TestE2SetupRequestNotificationHandler_HandleNewGnbSuccess - failed to create file, error: %s", err)
-       }
-       oldStdout := os.Stdout
-       defer changeStdout(oldStdout)
-       defer removeLogFile(t)
-       os.Stdout = logFile
-
-       _, handler, _, _, _, _, _ := initMocks(t)
+       handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock := initMocks(t)
        prefBytes := []byte("invalid_prefix")
        notificationRequest := &models.NotificationRequest{RanName: nodebRanName, Payload: append(prefBytes, xmlGnb...)}
        handler.Handle(notificationRequest)
-       assertParseErrorFlowLogs(t)
+       readerMock.AssertNotCalled(t, "GetNodeb", mock.Anything)
+       writerMock.AssertNotCalled(t, "SaveNodeb", mock.Anything, mock.Anything)
+       routingManagerClientMock.AssertNotCalled(t, "AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything)
+       writerMock.AssertNotCalled(t, "UpdateNodebInfo", mock.Anything)
+       e2tInstancesManagerMock.AssertNotCalled(t, "AddRansToInstance", mock.Anything, mock.Anything)
+       rmrMessengerMock.AssertNotCalled(t, "SendMsg", mock.Anything, mock.Anything)
 }
 
 func TestE2SetupRequestNotificationHandler_HandleUnmarshalError(t *testing.T) {
-       logFile, err := os.Create(logFilePath)
-       if err != nil{
-               t.Errorf("e2_setup_request_notification_handler_test.TestE2SetupRequestNotificationHandler_HandleNewGnbSuccess - failed to create file, error: %s", err)
-       }
-       oldStdout := os.Stdout
-       defer changeStdout(oldStdout)
-       defer removeLogFile(t)
-       os.Stdout = logFile
-
-       _, handler, _, _, _, _, _ := initMocks(t)
+       handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock := initMocks(t)
        prefBytes := []byte(prefix)
        notificationRequest := &models.NotificationRequest{RanName: nodebRanName, Payload: append(prefBytes, "xmlGnb"...)}
        handler.Handle(notificationRequest)
-       assertUnmarshalErrorFlowLogs(t)
+       readerMock.AssertNotCalled(t, "GetNodeb", mock.Anything)
+       writerMock.AssertNotCalled(t, "SaveNodeb", mock.Anything, mock.Anything)
+       routingManagerClientMock.AssertNotCalled(t, "AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything)
+       writerMock.AssertNotCalled(t, "UpdateNodebInfo", mock.Anything)
+       e2tInstancesManagerMock.AssertNotCalled(t, "AddRansToInstance", mock.Anything, mock.Anything)
+       rmrMessengerMock.AssertNotCalled(t, "SendMsg", mock.Anything, mock.Anything)
 }
 
 func TestE2SetupRequestNotificationHandler_HandleGetE2TInstanceError(t *testing.T) {
@@ -245,22 +247,19 @@ func TestE2SetupRequestNotificationHandler_HandleGetE2TInstanceError(t *testing.
                t.Fatal(err)
        }
 
-       logFile, err := os.Create(logFilePath)
-       if err != nil{
-               t.Errorf("e2_setup_request_notification_handler_test.TestE2SetupRequestNotificationHandler_HandleNewGnbSuccess - failed to create file, error: %s", err)
-       }
-       oldStdout := os.Stdout
-       defer changeStdout(oldStdout)
-       defer removeLogFile(t)
-       os.Stdout = logFile
-
-       _, handler, _, _, _, e2tInstancesManagerMock, _ := initMocks(t)
+       handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock := initMocks(t)
        var e2tInstance * entities.E2TInstance
        e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(e2tInstance, common.NewResourceNotFoundError("Not found"))
        prefBytes := []byte(prefix)
        notificationRequest := &models.NotificationRequest{RanName: nodebRanName, Payload: append(prefBytes, xmlGnb...)}
        handler.Handle(notificationRequest)
-       assertGetE2TInstanceErrorLogs(t)
+       e2tInstancesManagerMock.AssertCalled(t, "GetE2TInstance", e2tInstanceFullAddress)
+       readerMock.AssertNotCalled(t, "GetNodeb", mock.Anything)
+       writerMock.AssertNotCalled(t, "SaveNodeb", mock.Anything, mock.Anything)
+       routingManagerClientMock.AssertNotCalled(t, "AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything)
+       writerMock.AssertNotCalled(t, "UpdateNodebInfo", mock.Anything)
+       e2tInstancesManagerMock.AssertNotCalled(t, "AddRansToInstance", mock.Anything, mock.Anything)
+       rmrMessengerMock.AssertNotCalled(t, "SendMsg", mock.Anything, mock.Anything)
 }
 
 func TestE2SetupRequestNotificationHandler_HandleGetNodebError(t *testing.T) {
@@ -272,24 +271,21 @@ func TestE2SetupRequestNotificationHandler_HandleGetNodebError(t *testing.T) {
        if err != nil {
                t.Fatal(err)
        }
-
-       logFile, err := os.Create(logFilePath)
-       if err != nil{
-               t.Errorf("e2_setup_request_notification_handler_test.TestE2SetupRequestNotificationHandler_HandleNewGnbSuccess - failed to create file, error: %s", err)
-       }
-       oldStdout := os.Stdout
-       defer changeStdout(oldStdout)
-       defer removeLogFile(t)
-       os.Stdout = logFile
-       _, handler, readerMock, _, _, e2tInstancesManagerMock, _ := initMocks(t)
+       handler, readerMock, writerMock, routingManagerClientMock, e2tInstancesManagerMock, rmrMessengerMock := initMocks(t)
        var e2tInstance = &entities.E2TInstance{}
        e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(e2tInstance, nil)
        var gnb *entities.NodebInfo
-       readerMock.On("GetNodeb", mock.Anything).Return(gnb, common.NewInternalError(errors.New("Some error")))
+       readerMock.On("GetNodeb", mock.Anything).Return(gnb, common.NewInternalError(errors.New("some error")))
        prefBytes := []byte(prefix)
        notificationRequest := &models.NotificationRequest{RanName: nodebRanName, Payload: append(prefBytes, xmlGnb...)}
        handler.Handle(notificationRequest)
-       assertGetNodebErrorLogs(t)
+       e2tInstancesManagerMock.AssertCalled(t, "GetE2TInstance", e2tInstanceFullAddress)
+       readerMock.AssertCalled(t, "GetNodeb", mock.Anything)
+       writerMock.AssertNotCalled(t, "SaveNodeb", mock.Anything, mock.Anything)
+       routingManagerClientMock.AssertNotCalled(t, "AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything)
+       writerMock.AssertNotCalled(t, "UpdateNodebInfo", mock.Anything)
+       e2tInstancesManagerMock.AssertNotCalled(t, "AddRansToInstance", mock.Anything, mock.Anything)
+       rmrMessengerMock.AssertNotCalled(t, "SendMsg", mock.Anything, mock.Anything)
 }
 
 func TestE2SetupRequestNotificationHandler_HandleAssociationError(t *testing.T) {
@@ -302,16 +298,7 @@ func TestE2SetupRequestNotificationHandler_HandleAssociationError(t *testing.T)
                t.Fatal(err)
        }
 
-       logFile, err := os.Create(logFilePath)
-       if err != nil{
-               t.Errorf("e2_setup_request_notification_handler_test.TestE2SetupRequestNotificationHandler_HandleNewGnbSuccess - failed to create file, error: %s", err)
-       }
-       oldStdout := os.Stdout
-       defer changeStdout(oldStdout)
-       defer removeLogFile(t)
-       os.Stdout = logFile
-
-       _, handler, readerMock, writerMock, _, e2tInstancesManagerMock, routingManagerClientMock := initMocks(t)
+       handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock := initMocks(t)
        var e2tInstance = &entities.E2TInstance{}
        e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(e2tInstance, nil)
        var gnb *entities.NodebInfo
@@ -322,191 +309,41 @@ func TestE2SetupRequestNotificationHandler_HandleAssociationError(t *testing.T)
        prefBytes := []byte(prefix)
        notificationRequest := &models.NotificationRequest{RanName: nodebRanName, Payload: append(prefBytes, xmlGnb...)}
        handler.Handle(notificationRequest)
-       assertAssociationErrorLogs(t)
+       readerMock.AssertCalled(t, "GetNodeb", mock.Anything)
+       e2tInstancesManagerMock.AssertCalled(t, "GetE2TInstance", e2tInstanceFullAddress)
+       writerMock.AssertCalled(t, "SaveNodeb", mock.Anything, mock.Anything)
+       routingManagerClientMock.AssertCalled(t, "AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything)
+       writerMock.AssertNotCalled(t, "UpdateNodebInfo", mock.Anything)
+       e2tInstancesManagerMock.AssertNotCalled(t, "AddRansToInstance", mock.Anything, mock.Anything)
+       rmrMessengerMock.AssertNotCalled(t, "SendMsg", mock.Anything, mock.Anything)
 }
 
-func TestE2SetupRequestNotificationHandler_HandleExistingGnbInvalidStatusError(t *testing.T) {
-       path, err :=filepath.Abs("../../tests/resources/setupRequest_gnb.xml")
+
+func TestE2SetupRequestNotificationHandler_ConvertTo20BitStringError(t *testing.T){
+
+       path, err :=filepath.Abs("../../tests/resources/setupRequest_en-gNB.xml")
        if err != nil {
                t.Fatal(err)
        }
-       xmlGnb, err := ioutil.ReadFile(path)
+       xmlEnGnb, err := ioutil.ReadFile(path)
        if err != nil {
                t.Fatal(err)
        }
+       logger := tests.InitLog(t)
+       config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3, GlobalRicId: struct {
+               PlmnId      string
+               RicNearRtId string
+       }{PlmnId : "131014", RicNearRtId: "10011001101010101011"}}
+       rmrMessengerMock := &mocks.RmrMessengerMock{}
+       rmrSender := tests.InitRmrSender(rmrMessengerMock, logger)
+       readerMock := &mocks.RnibReaderMock{}
+       writerMock := &mocks.RnibWriterMock{}
+       routingManagerClientMock := &mocks.RoutingManagerClientMock{}
+       rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock)
+       e2tInstancesManagerMock := &mocks.E2TInstancesManagerMock{}
+       e2tAssociationManager := managers.NewE2TAssociationManager(logger, rnibDataService, e2tInstancesManagerMock, routingManagerClientMock)
+       handler := NewE2SetupRequestNotificationHandler(logger, config, e2tInstancesManagerMock, rmrSender, rnibDataService, e2tAssociationManager)
 
-       logFile, err := os.Create(logFilePath)
-       if err != nil{
-               t.Errorf("e2_setup_request_notification_handler_test.TestE2SetupRequestNotificationHandler_HandleNewGnbSuccess - failed to create file, error: %s", err)
-       }
-       oldStdout := os.Stdout
-       defer changeStdout(oldStdout)
-       defer removeLogFile(t)
-       os.Stdout = logFile
-
-       handler := stubMockInvalidStatusFlowExistingNodeb(t)
-       prefBytes := []byte(prefix)
-       notificationRequest := &models.NotificationRequest{RanName: nodebRanName, Payload: append(prefBytes, xmlGnb...)}
-       handler.Handle(notificationRequest)
-       assertInvalidNodebStatusLogs(t)
-}
-
-func assertInvalidNodebStatusLogs(t *testing.T){
-       buf := getLogFileBuffer(t)
-       assertReceivedAndParsedLog(buf, t)
-       assertInvalidNodebStatusLog(buf, t)
-       assertNoMoreRecordsLog(buf, t)
-}
-
-func assertInvalidNodebStatusLog(buf *bytes.Buffer, t *testing.T) {
-       record, _ := buf.ReadString('\n')
-       assert.Contains(t, record, "#RnibDataService.GetNodeb")
-       assert.Contains(t, record, "connection status: SHUTTING_DOWN")
-       record, _ = buf.ReadString('\n')
-       assert.Contains(t, record, "#E2SetupRequestNotificationHandler.Handle")
-       assert.Contains(t, record, "connection status: SHUTTING_DOWN - nodeB entity in incorrect state")
-       record, _ = buf.ReadString('\n')
-       assert.Contains(t, record, "#E2SetupRequestNotificationHandler.Handle")
-       assert.Contains(t, record, "Summary: elapsed time for receiving and handling setup request message from E2 terminator")
-}
-
-func assertAssociationErrorLogs(t *testing.T){
-       buf := getLogFileBuffer(t)
-       assertReceivedAndParsedLog(buf, t)
-       assertNewNodebSavedLog(buf, t)
-       assertAssociationErrorLog(buf, t)
-       assertNoMoreRecordsLog(buf, t)
-}
-
-func assertAssociationErrorLog(buf *bytes.Buffer, t *testing.T) {
-       record, _ := buf.ReadString('\n')
-       assert.Contains(t, record, "#E2TAssociationManager.AssociateRan - Associating RAN")
-       record, _ = buf.ReadString('\n')
-       assert.Contains(t, record, "#E2TAssociationManager.AssociateRan - RoutingManager failure: Failed to associate RAN")
-       record, _ = buf.ReadString('\n')
-       assert.Contains(t, record, "#E2SetupRequestNotificationHandler.Handle - RAN name:")
-       assert.Contains(t, record, "failed to associate E2T to nodeB entity")
-}
-
-func assertGetNodebErrorLogs(t *testing.T) {
-       buf := getLogFileBuffer(t)
-       assertReceivedAndParsedLog(buf, t)
-       assertGetNodebErrorLog(buf, t)
-       assertNoMoreRecordsLog(buf, t)
-}
-
-func assertGetNodebErrorLog(buf *bytes.Buffer, t *testing.T) {
-       record, _ := buf.ReadString('\n')
-       assert.Contains(t, record, "failed to retrieve nodebInfo entity")
-}
-
-func assertGetE2TInstanceErrorLogs(t *testing.T) {
-       buf := getLogFileBuffer(t)
-       assertReceivedAndParsedLog(buf, t)
-       assertGetE2TInstanceErrorLog(buf, t)
-       assertNoMoreRecordsLog(buf, t)
-}
-
-func assertGetE2TInstanceErrorLog(buf *bytes.Buffer, t *testing.T) {
-       record, _ := buf.ReadString('\n')
-       assert.Contains(t, record, "Failed retrieving E2TInstance")
-}
-
-func removeLogFile(t *testing.T) {
-       err := os.Remove(logFilePath)
-       if err != nil {
-               t.Errorf("e2_setup_request_notification_handler_test.TestE2SetupRequestNotificationHandler_HandleGnbSuccess - failed to remove file, error: %s", err)
-       }
-}
-
-func assertParseErrorFlowLogs(t *testing.T) {
-       buf := getLogFileBuffer(t)
-       assertReceivedAndFailedParseLog(buf, t)
-       assertNoMoreRecordsLog(buf, t)
-}
-
-func assertUnmarshalErrorFlowLogs(t *testing.T) {
-       buf := getLogFileBuffer(t)
-       assertReceivedAndFailedUnmarshalLog(buf, t)
-       assertNoMoreRecordsLog(buf, t)
-}
-
-func assertSuccessFlowNewNodebLogs(t *testing.T){
-       buf := getLogFileBuffer(t)
-       assertReceivedAndParsedLog(buf, t)
-       assertNewNodebSavedLog(buf, t)
-       assertAssociatedLog(buf, t)
-       assertRequestBuiltLog(buf, t)
-       assertRequestSentLog(buf, t)
-       assertNoMoreRecordsLog(buf, t)
-}
-
-func assertSuccessFlowExistingNodebLogs(t *testing.T){
-       buf := getLogFileBuffer(t)
-       assertReceivedAndParsedLog(buf, t)
-       assertExistingNodebRetrievedLog(buf, t)
-       assertAssociatedLog(buf, t)
-       assertRequestBuiltLog(buf, t)
-       assertRequestSentLog(buf, t)
-       assertNoMoreRecordsLog(buf, t)
-}
-
-func assertReceivedAndParsedLog(buf *bytes.Buffer, t *testing.T) {
-       record, _ := buf.ReadString('\n')
-       assert.Contains(t, record, "received E2 Setup Request")
-       record, _ = buf.ReadString('\n')
-       assert.Contains(t, record, "handling E2_SETUP_REQUEST")
-}
-
-func assertReceivedAndFailedParseLog(buf *bytes.Buffer, t *testing.T) {
-       record, _ := buf.ReadString('\n')
-       assert.Contains(t, record, "received E2 Setup Request")
-       record, _ = buf.ReadString('\n')
-       assert.Contains(t, record, "Error parsing E2 Setup Request")
-}
-
-func assertReceivedAndFailedUnmarshalLog(buf *bytes.Buffer, t *testing.T) {
-       record, _ := buf.ReadString('\n')
-       assert.Contains(t, record, "received E2 Setup Request")
-       record, _ = buf.ReadString('\n')
-       assert.Contains(t, record, "Error unmarshalling E2 Setup Request")
-}
-
-func assertNewNodebSavedLog(buf *bytes.Buffer, t *testing.T) {
-       record, _ := buf.ReadString('\n')
-       assert.Contains(t, record, "#RnibDataService.SaveNodeb - nbIdentity:")
-}
-
-func assertExistingNodebRetrievedLog(buf *bytes.Buffer, t *testing.T) {
-       record, _ := buf.ReadString('\n')
-       assert.Contains(t, record, "#RnibDataService.GetNodeb - RAN name:")
-}
-
-func assertAssociatedLog(buf *bytes.Buffer, t *testing.T){
-       record, _ := buf.ReadString('\n')
-       assert.Contains(t, record, "#E2TAssociationManager.AssociateRan - Associating RAN")
-       record, _ = buf.ReadString('\n')
-       assert.Contains(t, record, "#RnibDataService.UpdateNodebInfo")
-       record, _ = buf.ReadString('\n')
-       assert.Contains(t, record, "#E2TAssociationManager.AssociateRan - successfully associated RAN")
-}
-
-func assertRequestSentLog(buf *bytes.Buffer, t *testing.T) {
-       record, _ := buf.ReadString('\n')
-       assert.Contains(t, record, "uccessfully sent RMR message")
-}
-func assertRequestBuiltLog(buf *bytes.Buffer, t *testing.T) {
-       record, _ := buf.ReadString('\n')
-       assert.Contains(t, record, "E2 Setup Request has been built")
-}
-
-func assertNoMoreRecordsLog(buf *bytes.Buffer, t *testing.T) {
-       record, _ := buf.ReadString('\n')
-       assert.Empty(t, record)
-}
-
-func stubMockSuccessFlowNewNodeb(t *testing.T) E2SetupRequestNotificationHandler{
-       _, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock := initMocks(t)
        var e2tInstance = &entities.E2TInstance{}
        e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(e2tInstance, nil)
        var gnb *entities.NodebInfo
@@ -515,45 +352,54 @@ func stubMockSuccessFlowNewNodeb(t *testing.T) E2SetupRequestNotificationHandler
        routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything).Return(nil)
        writerMock.On("UpdateNodebInfo", mock.Anything).Return(nil)
        e2tInstancesManagerMock.On("AddRansToInstance", mock.Anything, mock.Anything).Return(nil)
-       var err error
+       var errEmpty error
        rmrMessage := &rmrCgo.MBuf{}
-       rmrMessengerMock.On("SendMsg", mock.Anything, mock.Anything).Return(rmrMessage, err)
-       return handler
+       rmrMessengerMock.On("SendMsg", mock.Anything, mock.Anything).Return(rmrMessage, errEmpty)
+       prefBytes := []byte(prefix)
+       notificationRequest := &models.NotificationRequest{RanName: nodebRanName, Payload: append(prefBytes, xmlEnGnb...)}
+       handler.Handle(notificationRequest)
+       readerMock.AssertCalled(t, "GetNodeb", mock.Anything)
+       e2tInstancesManagerMock.AssertCalled(t, "GetE2TInstance", e2tInstanceFullAddress)
+       writerMock.AssertCalled(t, "SaveNodeb", mock.Anything, mock.Anything)
+       routingManagerClientMock.AssertCalled(t, "AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything)
+       writerMock.AssertCalled(t, "UpdateNodebInfo", mock.Anything)
+       e2tInstancesManagerMock.AssertCalled(t, "AddRansToInstance", mock.Anything, mock.Anything)
+       rmrMessengerMock.AssertNotCalled(t, "SendMsg", mock.Anything, mock.Anything)
 }
 
-func stubMockSuccessFlowExistingNodeb(t *testing.T) E2SetupRequestNotificationHandler{
-       _, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock := initMocks(t)
-       var e2tInstance = &entities.E2TInstance{}
-       e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(e2tInstance, nil)
-       var gnb = &entities.NodebInfo{
-               RanName: nodebRanName,
-               AssociatedE2TInstanceAddress: e2tAddress,
-               ConnectionStatus: entities.ConnectionStatus_CONNECTED,
-               NodeType: entities.Node_GNB,
-               Configuration: &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{}},
+func TestE2SetupRequestNotificationHandler_HandleExistingGnbInvalidStatusError(t *testing.T) {
+       path, err :=filepath.Abs("../../tests/resources/setupRequest_gnb.xml")
+       if err != nil {
+               t.Fatal(err)
+       }
+       xmlGnb, err := ioutil.ReadFile(path)
+       if err != nil {
+               t.Fatal(err)
        }
-       readerMock.On("GetNodeb", mock.Anything).Return(gnb, nil)
-       routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything).Return(nil)
-       writerMock.On("UpdateNodebInfo", mock.Anything).Return(nil)
-       e2tInstancesManagerMock.On("AddRansToInstance", mock.Anything, mock.Anything).Return(nil)
-       var err error
-       rmrMessage := &rmrCgo.MBuf{}
-       rmrMessengerMock.On("SendMsg", mock.Anything, mock.Anything).Return(rmrMessage, err)
-       return handler
-}
 
-func stubMockInvalidStatusFlowExistingNodeb(t *testing.T) E2SetupRequestNotificationHandler{
-       _, handler, readerMock, _, _, e2tInstancesManagerMock, _ := initMocks(t)
-       var e2tInstance = &entities.E2TInstance{}
-       e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(e2tInstance, nil)
+       handler, readerMock, writerMock, routingManagerClientMock, e2tInstancesManagerMock, rmrMessengerMock := initMocks(t)
        var gnb = &entities.NodebInfo{RanName: nodebRanName, ConnectionStatus:entities.ConnectionStatus_SHUTTING_DOWN}
        readerMock.On("GetNodeb", mock.Anything).Return(gnb, nil)
-       return handler
+       var e2tInstance = &entities.E2TInstance{}
+       e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(e2tInstance, nil)
+       prefBytes := []byte(prefix)
+       notificationRequest := &models.NotificationRequest{RanName: nodebRanName, Payload: append(prefBytes, xmlGnb...)}
+       handler.Handle(notificationRequest)
+       readerMock.AssertCalled(t, "GetNodeb", mock.Anything)
+       e2tInstancesManagerMock.AssertCalled(t, "GetE2TInstance", e2tInstanceFullAddress)
+       writerMock.AssertNotCalled(t, "SaveNodeb", mock.Anything, mock.Anything)
+       routingManagerClientMock.AssertNotCalled(t, "AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything)
+       writerMock.AssertNotCalled(t, "UpdateNodebInfo", mock.Anything)
+       e2tInstancesManagerMock.AssertNotCalled(t, "AddRansToInstance", mock.Anything, mock.Anything)
+       rmrMessengerMock.AssertNotCalled(t, "SendMsg", mock.Anything, mock.Anything)
 }
 
-func initMocks(t *testing.T) (*logger.Logger, E2SetupRequestNotificationHandler, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.RmrMessengerMock, *mocks.E2TInstancesManagerMock, *mocks.RoutingManagerClientMock) {
+func initMocks(t *testing.T) (E2SetupRequestNotificationHandler, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.RmrMessengerMock, *mocks.E2TInstancesManagerMock, *mocks.RoutingManagerClientMock) {
        logger := tests.InitLog(t)
-       config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3}
+       config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3, GlobalRicId: struct {
+               PlmnId      string
+               RicNearRtId string
+       }{PlmnId : "131014", RicNearRtId: "556670"}}
        rmrMessengerMock := &mocks.RmrMessengerMock{}
        rmrSender := tests.InitRmrSender(rmrMessengerMock, logger)
        readerMock := &mocks.RnibReaderMock{}
@@ -563,23 +409,25 @@ func initMocks(t *testing.T) (*logger.Logger, E2SetupRequestNotificationHandler,
        e2tInstancesManagerMock := &mocks.E2TInstancesManagerMock{}
        e2tAssociationManager := managers.NewE2TAssociationManager(logger, rnibDataService, e2tInstancesManagerMock, routingManagerClientMock)
        handler := NewE2SetupRequestNotificationHandler(logger, config, e2tInstancesManagerMock, rmrSender, rnibDataService, e2tAssociationManager)
-       return logger, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock
-}
-
-func changeStdout(old *os.File) {
-       os.Stdout = old
-}
-
-func getLogFileBuffer(t *testing.T) *bytes.Buffer {
-       logFile, err := os.Open(logFilePath)
-       if err != nil {
-               t.Errorf("e2_setup_request_notification_handler_test.assertSuccessFlowNewNodebLogRecords - failed to open file, error: %s", err)
-       }
-       var buf bytes.Buffer
-       _, err = io.Copy(&buf, logFile)
-       if err != nil {
-               t.Errorf("e2_setup_request_notification_handler_test.assertSuccessFlowNewNodebLogRecords - failed to copy bytes, error: %s", err)
-       }
-       return &buf
-}
-
+       return handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock
+}
+
+func assertNewNodebSuccessCalls(readerMock *mocks.RnibReaderMock, t *testing.T, e2tInstancesManagerMock *mocks.E2TInstancesManagerMock, writerMock *mocks.RnibWriterMock, routingManagerClientMock *mocks.RoutingManagerClientMock, rmrMessengerMock *mocks.RmrMessengerMock) {
+       readerMock.AssertCalled(t, "GetNodeb", mock.Anything)
+       writerMock.AssertCalled(t, "SaveNodeb", mock.Anything, mock.Anything)
+       e2tInstancesManagerMock.AssertCalled(t, "GetE2TInstance", e2tInstanceFullAddress)
+       routingManagerClientMock.AssertCalled(t, "AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything)
+       writerMock.AssertCalled(t, "UpdateNodebInfo", mock.Anything)
+       e2tInstancesManagerMock.AssertCalled(t, "AddRansToInstance", mock.Anything, mock.Anything)
+       rmrMessengerMock.AssertCalled(t, "SendMsg", mock.Anything, mock.Anything)
+}
+
+func assertExistingNodebSuccessCalls(readerMock *mocks.RnibReaderMock, t *testing.T, e2tInstancesManagerMock *mocks.E2TInstancesManagerMock, writerMock *mocks.RnibWriterMock, routingManagerClientMock *mocks.RoutingManagerClientMock, rmrMessengerMock *mocks.RmrMessengerMock) {
+       readerMock.AssertCalled(t, "GetNodeb", mock.Anything)
+       writerMock.AssertNotCalled(t, "SaveNodeb", mock.Anything, mock.Anything)
+       e2tInstancesManagerMock.AssertCalled(t, "GetE2TInstance", e2tInstanceFullAddress)
+       routingManagerClientMock.AssertCalled(t, "AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything)
+       writerMock.AssertCalled(t, "UpdateNodebInfo", mock.Anything)
+       e2tInstancesManagerMock.AssertCalled(t, "AddRansToInstance", mock.Anything, mock.Anything)
+       rmrMessengerMock.AssertCalled(t, "SendMsg", mock.Anything, mock.Anything)
+}
\ No newline at end of file

diff --git a/E2Manager/models/e2_setup_request_message.go b/E2Manager/models/e2_setup_request_message.go
index 41aea81..1803a73 100644 (file)
--- a/E2Manager/models/e2_setup_request_message.go
+++ b/E2Manager/models/e2_setup_request_message.go
@@ -25,6 +25,7 @@ import (
        "fmt"
        "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
        "strconv"
+       "strings"
 )
 
 type E2SetupRequestMessage struct {
@@ -146,7 +147,7 @@ func (m *E2SetupRequestMessage) GetExtractRanFunctionsList()([]*entities.RanFunc
                if err != nil {
                        return nil, errors.New(fmt.Sprintf("#e2_setup_request_message.GetExtractRanFunctionsList - Failed parse uint RanFunctionRevision from %s", list[i].Value.RANfunctionItem.RanFunctionRevision))
                }
-               funcs[i].RanFunctionDefinition = list[i].Value.RANfunctionItem.RanFunctionDefinition
+               funcs[i].RanFunctionDefinition = m.trimSpaces(list[i].Value.RANfunctionItem.RanFunctionDefinition)
                funcs[i].RanFunctionRevision = uint32(rev)
        }
        return funcs, nil
@@ -170,32 +171,36 @@ func (m *E2SetupRequestMessage) GetNodeType() entities.Node_Type{
 
 func (m *E2SetupRequestMessage) GetPlmnId() string{
        if id := m.E2APPDU.InitiatingMessage.Value.E2setupRequest.ProtocolIEs.E2setupRequestIEs[0].Value.GlobalE2nodeID.GNB.GlobalGNBID.PlmnID; id!= ""{
-               return id
+               return m.trimSpaces(id)
        }
        if id := m.E2APPDU.InitiatingMessage.Value.E2setupRequest.ProtocolIEs.E2setupRequestIEs[0].Value.GlobalE2nodeID.EnGNB.GlobalGNBID.PlmnID; id!= ""{
-               return id
+               return m.trimSpaces(id)
        }
        if id := m.E2APPDU.InitiatingMessage.Value.E2setupRequest.ProtocolIEs.E2setupRequestIEs[0].Value.GlobalE2nodeID.ENB.GlobalENBID.PlmnID; id!= ""{
-               return id
+               return m.trimSpaces(id)
        }
        if id := m.E2APPDU.InitiatingMessage.Value.E2setupRequest.ProtocolIEs.E2setupRequestIEs[0].Value.GlobalE2nodeID.NgENB.GlobalNgENBID.PlmnID; id!= ""{
-               return id
+               return m.trimSpaces(id)
        }
        return ""
 }
 
 func (m *E2SetupRequestMessage) GetNbId() string{
        if id := m.E2APPDU.InitiatingMessage.Value.E2setupRequest.ProtocolIEs.E2setupRequestIEs[0].Value.GlobalE2nodeID.GNB.GlobalGNBID.GnbID.GnbID; id!= ""{
-               return id
+               return m.trimSpaces(id)
        }
        if id := m.E2APPDU.InitiatingMessage.Value.E2setupRequest.ProtocolIEs.E2setupRequestIEs[0].Value.GlobalE2nodeID.EnGNB.GlobalGNBID.GnbID.GnbID; id!= ""{
-               return id
+               return m.trimSpaces(id)
        }
        if id := m.E2APPDU.InitiatingMessage.Value.E2setupRequest.ProtocolIEs.E2setupRequestIEs[0].Value.GlobalE2nodeID.ENB.GlobalENBID.GnbID.GnbID; id!= ""{
-               return id
+               return m.trimSpaces(id)
        }
        if id := m.E2APPDU.InitiatingMessage.Value.E2setupRequest.ProtocolIEs.E2setupRequestIEs[0].Value.GlobalE2nodeID.NgENB.GlobalNgENBID.GnbID.GnbID; id!= ""{
-               return id
+               return m.trimSpaces(id)
        }
        return ""
+}
+
+func (m *E2SetupRequestMessage) trimSpaces(str string) string {
+       return strings.NewReplacer(" ", "", "\n", "").Replace(str)
 }
\ No newline at end of file

diff --git a/E2Manager/models/e2_setup_success_response_message.go b/E2Manager/models/e2_setup_success_response_message.go
index 52239be..68c97a3 100644 (file)
--- a/E2Manager/models/e2_setup_success_response_message.go
+++ b/E2Manager/models/e2_setup_success_response_message.go
@@ -25,10 +25,11 @@ import (
 type E2SetupSuccessResponseMessage struct {
        XMLName xml.Name `xml:"E2SetupSuccessResponseMessage"`
        Text    string   `xml:",chardata"`
-       E2APPDU E2APPDU`xml:"E2AP-PDU"`
+       E2APPDU E2APPDU  `xml:"E2AP-PDU"`
 }
 
 type E2APPDU struct {
+       XMLName xml.Name `xml:"E2AP-PDU"`
        Text              string `xml:",chardata"`
        SuccessfulOutcome struct {
                Text          string `xml:",chardata"`
@@ -57,18 +58,24 @@ type E2setupResponseIEs struct {
                Text   string `xml:",chardata"`
                Reject string `xml:"reject"`
        } `xml:"criticality"`
-       Value struct {
-               Text        string `xml:",chardata"`
-               GlobalRICID struct {
-                       Text         string `xml:",chardata"`
-                       PLMNIdentity string `xml:"pLMN-Identity"`
-                       RicID        string `xml:"ric-ID"`
-               } `xml:"GlobalRIC-ID"`
-               RANfunctionsIDList struct {
-                       Text                      string `xml:",chardata"`
-                       ProtocolIESingleContainer []ProtocolIESingleContainer `xml:"ProtocolIE-SingleContainer"`
-               } `xml:"RANfunctionsID-List"`
-       } `xml:"value"`
+       Value interface{}`xml:"value"`
+}
+
+type GlobalRICID struct {
+       Text        string `xml:",chardata"`
+       GlobalRICID struct {
+               Text         string `xml:",chardata"`
+               PLMNIdentity string `xml:"pLMN-Identity"`
+               RicID        string `xml:"ric-ID"`
+       } `xml:"GlobalRIC-ID"`
+}
+
+type RANfunctionsIDList struct {
+       Text        string `xml:",chardata"`
+       RANfunctionsIDList struct {
+               Text                      string `xml:",chardata"`
+               ProtocolIESingleContainer []ProtocolIESingleContainer `xml:"ProtocolIE-SingleContainer"`
+       } `xml:"RANfunctionsID-List"`
 }
 
 type ProtocolIESingleContainer struct {
@@ -88,32 +95,37 @@ type ProtocolIESingleContainer struct {
        } `xml:"value"`
 }
 
-func NewE2SetupSuccessResponseMessage() E2SetupSuccessResponseMessage{
+func NewE2SetupSuccessResponseMessage(plmnId string, ricId string, request *E2SetupRequestMessage) E2SetupSuccessResponseMessage{
        msg := E2SetupSuccessResponseMessage{}
        msg.E2APPDU.SuccessfulOutcome.Value.E2setupResponse.ProtocolIEs.E2setupResponseIEs = make([]E2setupResponseIEs, 2)
+       msg.E2APPDU.SuccessfulOutcome.ProcedureCode = "1"
+       msg.E2APPDU.SuccessfulOutcome.Value.E2setupResponse.ProtocolIEs.E2setupResponseIEs[0].ID = "4"
+       msg.E2APPDU.SuccessfulOutcome.Value.E2setupResponse.ProtocolIEs.E2setupResponseIEs[0].Value = GlobalRICID{GlobalRICID: struct {
+               Text         string `xml:",chardata"`
+               PLMNIdentity string `xml:"pLMN-Identity"`
+               RicID        string `xml:"ric-ID"`
+       }{PLMNIdentity:plmnId, RicID:ricId}}
+       msg.E2APPDU.SuccessfulOutcome.Value.E2setupResponse.ProtocolIEs.E2setupResponseIEs[1].ID = "9"
+       msg.E2APPDU.SuccessfulOutcome.Value.E2setupResponse.ProtocolIEs.E2setupResponseIEs[1].Value = RANfunctionsIDList{RANfunctionsIDList: struct {
+               Text                      string `xml:",chardata"`
+               ProtocolIESingleContainer []ProtocolIESingleContainer `xml:"ProtocolIE-SingleContainer"`
+       }{ProtocolIESingleContainer:extractRanFunctionsIDList(request)}}
        return msg
 }
 
-func (m *E2SetupSuccessResponseMessage) SetExtractRanFunctionsIDList(request *E2SetupRequestMessage) {
+func extractRanFunctionsIDList(request *E2SetupRequestMessage) []ProtocolIESingleContainer{
        list := &request.E2APPDU.InitiatingMessage.Value.E2setupRequest.ProtocolIEs.E2setupRequestIEs[1].Value.RANfunctionsList
        ids := make([]ProtocolIESingleContainer,len(list.ProtocolIESingleContainer))
        for i := 0; i< len(ids); i++{
-               ids[i] = m.convertToRANfunctionID(list, i)
+               ids[i] = convertToRANfunctionID(list, i)
        }
-       m.E2APPDU.SuccessfulOutcome.Value.E2setupResponse.ProtocolIEs.E2setupResponseIEs[1].Value.RANfunctionsIDList.ProtocolIESingleContainer = ids
+       return ids
 }
 
-func (m *E2SetupSuccessResponseMessage) convertToRANfunctionID(list *RANfunctionsList, i int) ProtocolIESingleContainer{
+func convertToRANfunctionID(list *RANfunctionsList, i int) ProtocolIESingleContainer{
        id := ProtocolIESingleContainer{}
+       id.ID = "6"
        id.Value.RANfunctionIDItem.RanFunctionID = list.ProtocolIESingleContainer[i].Value.RANfunctionItem.RanFunctionID
        id.Value.RANfunctionIDItem.RanFunctionRevision = list.ProtocolIESingleContainer[i].Value.RANfunctionItem.RanFunctionRevision
        return id
-}
-
-func (m *E2SetupSuccessResponseMessage) SetPlmnId(plmnId string){
-       m.E2APPDU.SuccessfulOutcome.Value.E2setupResponse.ProtocolIEs.E2setupResponseIEs[0].Value.GlobalRICID.PLMNIdentity = plmnId
-}
-
-func (m *E2SetupSuccessResponseMessage) SetRicId(ricId string){
-       m.E2APPDU.SuccessfulOutcome.Value.E2setupResponse.ProtocolIEs.E2setupResponseIEs[0].Value.GlobalRICID.RicID = ricId
 }
\ No newline at end of file

diff --git a/E2Manager/router.txt b/E2Manager/router.txt
index bce30de..99478c2 100644 (file)
--- a/E2Manager/router.txt
+++ b/E2Manager/router.txt
@@ -23,4 +23,5 @@ rte|10090|10.0.2.15:38000
 rte|1101|10.0.2.15:38000
 rte|12002|10.0.2.15:38000
 rte|12003|10.0.2.15:38000
+mse|12002,10.0.2.15:38000|-1|gnb:208-092-303030
 newrt|end

diff --git a/E2Manager/tests/resources/setupRequest_en-gNB.xml b/E2Manager/tests/resources/setupRequest_en-gNB.xml
index 28e4bfe..b7b216a 100644 (file)
--- a/E2Manager/tests/resources/setupRequest_en-gNB.xml
+++ b/E2Manager/tests/resources/setupRequest_en-gNB.xml
@@ -12,9 +12,9 @@
                             <GlobalE2node-ID>\r
                                 <en-gNB>\r
                                     <global-gNB-ID>\r
-                                        <plmn-id>131014</plmn-id>\r
+                                        <plmn-id>13 10 14</plmn-id>\r
                                         <gnb-id>\r
-                                            <gnb-ID>10110101110001100111011110001000</gnb-ID>\r
+                                            <gnb-ID>10011001101010101011</gnb-ID>\r
                                         </gnb-id>\r
                                     </global-gNB-ID>\r
                                 </en-gNB>\r

diff --git a/E2Manager/tests/resources/setupRequest_gnb.xml b/E2Manager/tests/resources/setupRequest_gnb.xml
index e8587e6..549a672 100644 (file)
--- a/E2Manager/tests/resources/setupRequest_gnb.xml
+++ b/E2Manager/tests/resources/setupRequest_gnb.xml
@@ -12,9 +12,9 @@
                             <GlobalE2node-ID>\r
                                 <gNB>\r
                                     <global-gNB-ID>\r
-                                        <plmn-id>131014</plmn-id>\r
+                                        <plmn-id>13 10 14</plmn-id>\r
                                         <gnb-id>\r
-                                            <gnb-ID>10110101110001100111011110001000</gnb-ID>\r
+                                            <gnb-ID>10011001101010101011</gnb-ID>\r
                                         </gnb-id>\r
                                     </global-gNB-ID>\r
                                 </gNB>\r

diff --git a/E2Manager/tests/resources/setupRequest_ng-eNB.xml b/E2Manager/tests/resources/setupRequest_ng-eNB.xml
index 575dac6..1766493 100644 (file)
--- a/E2Manager/tests/resources/setupRequest_ng-eNB.xml
+++ b/E2Manager/tests/resources/setupRequest_ng-eNB.xml
@@ -12,9 +12,9 @@
                             <GlobalE2node-ID>\r
                                 <ng-eNB>\r
                                     <global-ng-eNB-ID>\r
-                                        <plmn-id>131014</plmn-id>\r
+                                        <plmn-id>13 10 14</plmn-id>\r
                                         <gnb-id>\r
-                                            <gnb-ID>10110101110001100111011110001000</gnb-ID>\r
+                                            <gnb-ID>10011001101010101011</gnb-ID>\r
                                         </gnb-id>\r
                                     </global-ng-eNB-ID>\r
                                 </ng-eNB>\r