[RICPLT-2048] X2 ENDC Setup request refactoring - unit test added

Change-Id: I4f988b32ff4950e5466ab3837cb5af96edbb2114
Signed-off-by: irina <ib565x@intl.att.com>

diff --git a/E2Manager/controllers/controller.go b/E2Manager/controllers/controller.go
index 0cd8293..f9a7bb3 100644 (file)
--- a/E2Manager/controllers/controller.go
+++ b/E2Manager/controllers/controller.go
@@ -38,7 +38,7 @@ import (
 
 const (
        ParamRanName = "ranName"
-       LimitRequest = 1000
+       LimitRequest = 2000
 )
 
 type IController interface {

diff --git a/E2Manager/controllers/controller_test.go b/E2Manager/controllers/controller_test.go
index fe833cf..f14d830 100644 (file)
--- a/E2Manager/controllers/controller_test.go
+++ b/E2Manager/controllers/controller_test.go
@@ -21,6 +21,7 @@ import (
        "bytes"
        "e2mgr/configuration"
        "e2mgr/e2managererrors"
+       "e2mgr/e2pdus"
        "e2mgr/logger"
        "e2mgr/managers"
        "e2mgr/mocks"
@@ -45,32 +46,108 @@ import (
        "testing"
 )
 
-func TestX2SetupSuccess(t *testing.T) {
-/*     log := initLog(t)
+func TestX2SetupInvalidBody(t *testing.T) {
+
+       readerMock, writerMock, rmrMessengerMock, ranSetupManager := initTest(t)
+       log := initLog(t)
 
-       rmrMessengerMock := &mocks.RmrMessengerMock{}
-       readerMock := &mocks.RnibReaderMock{}
        readerProvider := func() reader.RNibReader {
                return readerMock
        }
-       writerMock := &mocks.RnibWriterMock{}
        writerProvider := func() rNibWriter.RNibWriter {
                return writerMock
        }
-       config := configuration.ParseConfiguration()
 
        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()
-       ranSetupManager := managers.NewRanSetupManager(log, getRmrService(rmrMessengerMock, log), rNibWriter.GetRNibWriter)
+       config := configuration.ParseConfiguration()
        controller := NewController(log, getRmrService(rmrMessengerMock, log), readerProvider, writerProvider, config, ranSetupManager)
+       controller.X2SetupHandler(writer, httpRequest)
+
+       var errorResponse = parseJsonRequest(t, writer.Body)
+
+       assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
+       assert.Equal(t, e2managererrors.NewInvalidJsonError().Code, errorResponse.Code)
+}
+
+func TestX2SetupSuccess(t *testing.T) {
+
+       readerMock, writerMock, rmrMessengerMock, ranSetupManager := initTest(t)
+       log := initLog(t)
 
+       readerProvider := func() reader.RNibReader {
+               return readerMock
+       }
+       writerProvider := func() rNibWriter.RNibWriter {
+               return writerMock
+       }
+
+       ranName := "test"
+       nb := &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
+       readerMock.On("GetNodeb", ranName).Return(nb, nil)
+
+       var nbUpdated = &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_CONNECTING, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST, ConnectionAttempts: 1}
+       writerMock.On("UpdateNodebInfo", nbUpdated).Return(nil)
+
+       payload := e2pdus.PackedX2setupRequest
+       xaction := []byte(ranName)
+       msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), ranName, &payload, &xaction)
+
+       rmrMessengerMock.On("SendMsg", mock.Anything, mock.Anything).Return(msg, nil)
+
+       header := http.Header{}
+       header.Set("Content-Type", "application/json")
        httpRequest := tests.GetHttpRequest()
        httpRequest.Header = header
+
+       writer := httptest.NewRecorder()
+       config := configuration.ParseConfiguration()
+       controller := NewController(log, getRmrService(rmrMessengerMock, log), readerProvider, writerProvider, config, ranSetupManager)
        controller.X2SetupHandler(writer, httpRequest)
 
-       assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)*/
+       assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
+}
+
+func TestEndcSetupSuccess(t *testing.T) {
+
+       readerMock, writerMock, rmrMessengerMock, ranSetupManager := initTest(t)
+       log := initLog(t)
+
+       readerProvider := func() reader.RNibReader {
+               return readerMock
+       }
+       writerProvider := func() rNibWriter.RNibWriter {
+               return writerMock
+       }
+
+       ranName := "test"
+       nb := &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST}
+       readerMock.On("GetNodeb", ranName).Return(nb, nil)
+
+       var nbUpdated = &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_CONNECTING, E2ApplicationProtocol: entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST, ConnectionAttempts: 1}
+       writerMock.On("UpdateNodebInfo", nbUpdated).Return(nil)
+
+       payload := e2pdus.PackedEndcX2setupRequest
+       xaction := []byte(ranName)
+       msg := rmrCgo.NewMBuf(rmrCgo.RIC_ENDC_X2_SETUP_REQ, len(payload), ranName, &payload, &xaction)
+
+       rmrMessengerMock.On("SendMsg", mock.Anything, mock.Anything).Return(msg, nil)
+
+       header := http.Header{}
+       header.Set("Content-Type", "application/json")
+       httpRequest := tests.GetHttpRequest()
+       httpRequest.Header = header
+
+       writer := httptest.NewRecorder()
+       config := configuration.ParseConfiguration()
+       controller := NewController(log, getRmrService(rmrMessengerMock, log), readerProvider, writerProvider, config, ranSetupManager)
+       controller.EndcSetupHandler(writer, httpRequest)
+
+       assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
 }
 
 func TestShutdownHandlerRnibError(t *testing.T) {
@@ -363,6 +440,7 @@ func TestX2ResetHandleFailureInvalidBody(t *testing.T) {
 
        controller.X2ResetHandler(writer, req)
        assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
+
 }
 
 func TestHandleErrorResponse(t *testing.T) {
@@ -415,3 +493,20 @@ func TestHandleErrorResponse(t *testing.T) {
        controller.handleErrorResponse(fmt.Errorf("ErrorError"), writer)
        assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
 }
+
+func initTest(t *testing.T)(*mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.RmrMessengerMock, *managers.RanSetupManager) {
+       log := initLog(t)
+
+       readerMock := &mocks.RnibReaderMock{}
+       writerMock := &mocks.RnibWriterMock{}
+       writerProvider := func() rNibWriter.RNibWriter {
+               return writerMock
+       }
+
+       rmrMessengerMock := &mocks.RmrMessengerMock{}
+       rmrService := getRmrService(rmrMessengerMock, log)
+
+       ranSetupManager := managers.NewRanSetupManager(log, rmrService, writerProvider)
+
+       return readerMock, writerMock, rmrMessengerMock, ranSetupManager
+}
\ No newline at end of file

diff --git a/E2Manager/e2pdus/x2_setup_requests_test.go b/E2Manager/e2pdus/x2_setup_requests_test.go
index fd66480..3ad683c 100644 (file)
--- a/E2Manager/e2pdus/x2_setup_requests_test.go
+++ b/E2Manager/e2pdus/x2_setup_requests_test.go
@@ -15,15 +15,86 @@
  *   limitations under the License.
  *
  *******************************************************************************/
- package e2pdus
+package e2pdus
 
 import (
        "bytes"
+       "e2mgr/logger"
        "fmt"
        "strings"
        "testing"
 )
 
+func TestPreparePackedEndcX2SetupRequest(t *testing.T) {
+       _,err := logger.InitLogger(logger.InfoLevel)
+       if err!=nil{
+               t.Errorf("failed to initialize logger, error: %s", err)
+       }
+       packedPdu := "0024003100000100f4002a0000020015000800bbbccc00abcde000fa0017000001f700bbbcccabcde0000000bbbccc000000000001"
+       packedEndcX2setupRequest := PackedEndcX2setupRequest
+
+       tmp := fmt.Sprintf("%x", packedEndcX2setupRequest)
+       if len(tmp) != len(packedPdu) {
+               t.Errorf("want packed len:%d, got: %d\n", len(packedPdu)/2, len(packedEndcX2setupRequest)/2)
+       }
+
+       if strings.Compare(tmp, packedPdu) != 0 {
+               t.Errorf("\nwant :\t[%s]\n got: \t\t[%s]\n", packedPdu, tmp)
+       }
+}
+
+func TestPreparePackedX2SetupRequest(t *testing.T) {
+       _,err := logger.InitLogger(logger.InfoLevel)
+       if err!=nil{
+               t.Errorf("failed to initialize logger, error: %s", err)
+       }
+       packedPdu := "0006002a0000020015000800bbbccc00abcde000140017000001f700bbbcccabcde0000000bbbccc000000000001"
+       packedX2setupRequest := PackedX2setupRequest
+
+       tmp := fmt.Sprintf("%x", packedX2setupRequest)
+       if len(tmp) != len(packedPdu) {
+               t.Errorf("want packed len:%d, got: %d\n", len(packedPdu)/2, len(packedX2setupRequest)/2)
+       }
+
+       if strings.Compare(tmp, packedPdu) != 0 {
+               t.Errorf("\nwant :\t[%s]\n got: \t\t[%s]\n", packedPdu, tmp)
+       }
+}
+
+func TestPreparePackedX2SetupRequestFailure(t *testing.T) {
+       _, err := logger.InitLogger(logger.InfoLevel)
+       if err != nil {
+               t.Errorf("failed to initialize logger, error: %s", err)
+       }
+
+       _, _, err  = preparePackedX2SetupRequest(1, 4096, pLMNId, eNBId, eNBIdBitqty, ricFlag)
+       if err == nil {
+               t.Errorf("want: error, got: success.\n")
+       }
+
+       expected:= "packing error: #src/asn1codec_utils.c.pack_pdu_aux - Encoded output of E2AP-PDU, is too big"
+       if !strings.Contains(err.Error(), expected) {
+               t.Errorf("want :[%s], got: [%s]\n", expected, err)
+       }
+}
+
+func TestPreparePackedEndcSetupRequestFailure(t *testing.T) {
+       _, err := logger.InitLogger(logger.InfoLevel)
+       if err != nil {
+               t.Errorf("failed to initialize logger, error: %s", err)
+       }
+
+       _, _, err  = preparePackedEndcX2SetupRequest(1, 4096, pLMNId, eNBId, eNBIdBitqty, ricFlag)
+       if err == nil {
+               t.Errorf("want: error, got: success.\n")
+       }
+
+       expected:= "packing error: #src/asn1codec_utils.c.pack_pdu_aux - Encoded output of E2AP-PDU, is too big"
+       if !strings.Contains(err.Error(), expected) {
+               t.Errorf("want :[%s], got: [%s]\n", expected, err)
+       }
+}
+
 func TestParseRicId(t *testing.T) {
        var testCases = []struct {
                ricId       string

diff --git a/E2Manager/managers/ran_setup_manager.go b/E2Manager/managers/ran_setup_manager.go
index 89bdcc8..ef4a642 100644 (file)
--- a/E2Manager/managers/ran_setup_manager.go
+++ b/E2Manager/managers/ran_setup_manager.go
@@ -49,9 +49,9 @@ func (m *RanSetupManager) updateConnectionStatus(nodebInfo *entities.NodebInfo,
        nodebInfo.ConnectionAttempts++
        err := m.rnibWriterProvider().UpdateNodebInfo(nodebInfo)
        if err != nil {
-               m.logger.Errorf("#RanSetupManager.updateConnectionStatus - Ran name: %s - Failed updating RAN's connection status to %v : %s", nodebInfo.RanName, status.String(), err)
+               m.logger.Errorf("#RanSetupManager.updateConnectionStatus - Ran name: %s - Failed updating RAN's connection status to %v : %s", nodebInfo.RanName, status, err)
        } else {
-               m.logger.Infof("#RanSetupManager.updateConnectionStatus - Ran name: %s - Successfully updated rNib. RAN's current connection status: %v, RAN's current connection attempts: %d", nodebInfo.RanName, status.String(), nodebInfo.ConnectionAttempts)
+               m.logger.Infof("#RanSetupManager.updateConnectionStatus - Ran name: %s - Successfully updated rNib. RAN's current connection status: %v, RAN's current connection attempts: %d", nodebInfo.RanName, status, nodebInfo.ConnectionAttempts)
        }
        return err
 }