package xapp
import (
+ "bytes"
+ "fmt"
+ "net/http"
+ "net/http/httptest"
+ "testing"
+ "time"
+
"gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/clientmodel"
"gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/models"
+ "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/restapi/operations/common"
"github.com/stretchr/testify/assert"
- "testing"
- "time"
- "fmt"
)
-var suite *testing.T
-
-var meid = "gnb123456"
-var funId = int64(1)
-var clientEndpoint = "localhost:4560"
-var direction = int64(0)
-var procedureCode = int64(27)
-var typeOfMessage = int64(1)
-
-var reportParams = clientmodel.ReportParams{
- Meid: meid,
- RANFunctionID: &funId,
- ClientEndpoint: &clientEndpoint,
- EventTriggers: clientmodel.EventTriggerList{
- &clientmodel.EventTrigger{
- InterfaceDirection: direction,
- ProcedureCode: procedureCode,
- TypeOfMessage: typeOfMessage,
- },
- },
-}
-
-var policyParams = clientmodel.PolicyParams{
- Meid: &meid,
- RANFunctionID: &funId,
- ClientEndpoint: &clientEndpoint,
- EventTriggers: clientmodel.EventTriggerList{
- &clientmodel.EventTrigger{
- InterfaceDirection: direction,
- ProcedureCode: procedureCode,
- TypeOfMessage: typeOfMessage,
- },
- },
- PolicyActionDefinitions: &clientmodel.PolicyActionDefinition{},
-}
-
-func processSubscriptions(subscriptionId string) {
- // Generate requestorId, instanceId
- reqId := int64(11)
- instanceId := int64(22)
-
- resp := &models.SubscriptionResponse{
- SubscriptionID: &subscriptionId,
- SubscriptionInstances: []*models.SubscriptionInstance{
- &models.SubscriptionInstance{RequestorID: &reqId, InstanceID: &instanceId},
- },
- }
-
- // Notify the client: don't worry about errors ... Notify() will handle retries, etc.
- Subscription.Notify(resp, clientEndpoint)
-}
-
-func subscriptionHandler(stype models.SubscriptionType, params interface{}) (*models.SubscriptionResponse, error) {
- switch stype {
- case models.SubscriptionTypeReport:
- p := params.(*models.ReportParams)
- assert.Equal(suite, meid, p.Meid)
- assert.Equal(suite, funId, *p.RANFunctionID)
- assert.Equal(suite, clientEndpoint, *p.ClientEndpoint)
- assert.Equal(suite, direction, p.EventTriggers[0].InterfaceDirection)
- assert.Equal(suite, procedureCode, p.EventTriggers[0].ProcedureCode)
- assert.Equal(suite, typeOfMessage, p.EventTriggers[0].TypeOfMessage)
- case models.SubscriptionTypePolicy:
- p := params.(*models.PolicyParams)
- assert.Equal(suite, clientEndpoint, *p.ClientEndpoint)
- }
-
- // Generate a unique subscriptionId
- subscriptionId := fmt.Sprintf("%s-%s", meid, clientEndpoint)
-
- // Process subscriptions on the background
- go processSubscriptions(subscriptionId)
-
- // and send response immediately
- return &models.SubscriptionResponse{
- SubscriptionID: &subscriptionId,
- }, nil
-}
-
-func queryHandler() (models.SubscriptionList, error) {
- resp := models.SubscriptionList{
- &models.SubscriptionData{
- SubscriptionID: 11,
- Meid: "Test-Gnb",
- Endpoint: []string{"127.0.0.1:4056"},
- },
- }
-
- return resp, nil
-}
+var (
+ suite *testing.T
-func deleteHandler(ep string) error {
- assert.Equal(suite, clientEndpoint, ep)
-
- return nil
-}
+ meid = "gnb123456"
+ xappEventInstanceId = int64(1)
+ eventInstanceId = int64(1)
+ funId = int64(1)
+ actionId = int64(1)
+ actionType = "report"
+ subsequestActioType = "continue"
+ timeToWait = "w10ms"
+ direction = int64(0)
+ procedureCode = int64(27)
+ typeOfMessage = int64(1)
+ subscriptionId = ""
+ hPort = int64(8086) // See log: "Xapp started, listening on: :8086"
+ rPort = int64(4560)
+ clientEndpoint = clientmodel.SubscriptionParamsClientEndpoint{Host: "localhost", HTTPPort: &hPort, RMRPort: &rPort}
+)
+// Test cases
func TestSetup(t *testing.T) {
suite = t
assert.Equal(t, err, nil)
assert.Equal(t, resp[0].SubscriptionID, int64(11))
assert.Equal(t, resp[0].Meid, "Test-Gnb")
- assert.Equal(t, resp[0].Endpoint, []string{"127.0.0.1:4056"})
+ assert.Equal(t, resp[0].ClientEndpoint, []string{"127.0.0.1:4056"})
+ <-time.After(1 * time.Second)
}
-func TestSubscriptionReportHandling(t *testing.T) {
+func TestSubscriptionHandling(t *testing.T) {
+ subscriptionParams := GetSubscriptionparams()
+
Subscription.SetResponseCB(func(resp *clientmodel.SubscriptionResponse) {
+ fmt.Println("TestSubscriptionHandling: notification received")
assert.Equal(t, len(resp.SubscriptionInstances), 1)
- assert.Equal(t, *resp.SubscriptionInstances[0].RequestorID, int64(11))
- assert.Equal(t, *resp.SubscriptionInstances[0].InstanceID, int64(22))
+ assert.Equal(t, *resp.SubscriptionInstances[0].XappEventInstanceID, int64(11))
+ assert.Equal(t, *resp.SubscriptionInstances[0].E2EventInstanceID, int64(22))
})
- _, err := Subscription.SubscribeReport(&reportParams)
+ _, err := Subscription.Subscribe(subscriptionParams)
assert.Equal(t, err, nil)
+ <-time.After(1 * time.Second)
}
-func TestSubscriptionPolicytHandling(t *testing.T) {
+func TestSubscriptionWithClientProvidedIdHandling(t *testing.T) {
+ subscriptionParams := GetSubscriptionparams()
+ subscriptionParams.SubscriptionID = "myxapp"
+
Subscription.SetResponseCB(func(resp *clientmodel.SubscriptionResponse) {
+ fmt.Println("TestSubscriptionWithClientProvidedIdHandling: notification received")
assert.Equal(t, len(resp.SubscriptionInstances), 1)
- assert.Equal(t, *resp.SubscriptionInstances[0].RequestorID, int64(11))
- assert.Equal(t, *resp.SubscriptionInstances[0].InstanceID, int64(22))
+ assert.Equal(t, *resp.SubscriptionInstances[0].XappEventInstanceID, int64(11))
+ assert.Equal(t, *resp.SubscriptionInstances[0].E2EventInstanceID, int64(22))
})
- _, err := Subscription.SubscribePolicy(&policyParams)
+ _, err := Subscription.Subscribe(subscriptionParams)
assert.Equal(t, err, nil)
+ <-time.After(1 * time.Second)
}
-func TestSubscriptionDeleteHandling(t *testing.T) {
- err := Subscription.UnSubscribe(clientEndpoint)
+func TestFailureNotificationHandling(t *testing.T) {
+ subscriptionParams := GetSubscriptionparams()
+ subscriptionParams.SubscriptionID = "send_failure_notification"
+
+ Subscription.SetResponseCB(func(resp *clientmodel.SubscriptionResponse) {
+ assert.Equal(t, len(resp.SubscriptionInstances), 1)
+ assert.Equal(t, *resp.SubscriptionInstances[0].XappEventInstanceID, int64(11))
+ assert.Equal(t, *resp.SubscriptionInstances[0].E2EventInstanceID, int64(0))
+ assert.Equal(t, resp.SubscriptionInstances[0].ErrorCause, "Some error")
+ assert.Equal(t, resp.SubscriptionInstances[0].ErrorSource, "SUBMGR")
+ assert.Equal(t, resp.SubscriptionInstances[0].TimeoutType, "E2-Timeout")
+ })
+ _, err := Subscription.Subscribe(subscriptionParams)
assert.Equal(t, err, nil)
+ <-time.After(1 * time.Second)
+}
+
+func TestBadRequestSubscriptionHandling(t *testing.T) {
+ subscriptionParams := GetSubscriptionparams()
+ subscriptionParams.SubscriptionID = "send_400_bad_request_response"
+
+ // Notification is not coming
+
+ _, err := Subscription.Subscribe(subscriptionParams)
+ assert.Equal(t, err.Error(), "[POST /subscriptions][400] subscribeBadRequest ")
+ fmt.Println("Error:", err)
+}
+
+func TestNotFoundRequestSubscriptionHandling(t *testing.T) {
+ subscriptionParams := GetSubscriptionparams()
+ subscriptionParams.SubscriptionID = "send_404_not_found_response"
+
+ // Notification is not coming
+
+ _, err := Subscription.Subscribe(subscriptionParams)
+ assert.Equal(t, err.Error(), "[POST /subscriptions][404] subscribeNotFound ")
+ fmt.Println("Error:", err)
+}
+
+func TestInternalServerErrorSubscriptionHandling(t *testing.T) {
+ subscriptionParams := GetSubscriptionparams()
+ subscriptionParams.SubscriptionID = "send_500_internal_server_error_response"
+
+ // Notification is not coming
+
+ _, err := Subscription.Subscribe(subscriptionParams)
+ assert.Equal(t, err.Error(), "[POST /subscriptions][500] subscribeInternalServerError ")
+ fmt.Println("Error:", err)
+}
+
+func TestServiceUnavailableSubscriptionHandling(t *testing.T) {
+ subscriptionParams := GetSubscriptionparams()
+ subscriptionParams.SubscriptionID = "send_503_Service_Unavailable_response"
+
+ // Notification is not coming
+
+ _, err := Subscription.Subscribe(subscriptionParams)
+ assert.Equal(t, err.Error(), "[POST /subscriptions][503] subscribeServiceUnavailable ")
+ fmt.Println("Error:", err)
+}
+
+func GetSubscriptionparams() *clientmodel.SubscriptionParams {
+ return &clientmodel.SubscriptionParams{
+ SubscriptionID: "",
+ Meid: &meid,
+ RANFunctionID: &funId,
+ ClientEndpoint: &clientEndpoint,
+ SubscriptionDetails: clientmodel.SubscriptionDetailsList{
+ &clientmodel.SubscriptionDetail{
+ XappEventInstanceID: &eventInstanceId,
+ EventTriggers: clientmodel.EventTriggerDefinition{00, 0x11, 0x12, 0x13, 0x00, 0x21, 0x22, 0x24, 0x1B, 0x80},
+ ActionToBeSetupList: clientmodel.ActionsToBeSetup{
+ &clientmodel.ActionToBeSetup{
+ ActionID: &actionId,
+ ActionType: &actionType,
+ ActionDefinition: clientmodel.ActionDefinition{5, 6, 7, 8},
+ SubsequentAction: &clientmodel.SubsequentAction{
+ SubsequentActionType: &subsequestActioType,
+ TimeToWait: &timeToWait,
+ },
+ },
+ },
+ },
+ },
+ }
+}
+
+func TestSuccessfulSubscriptionDeleteHandling(t *testing.T) {
+ subscriptionId = "send_201_successful_response"
+ err := Subscription.Unsubscribe(subscriptionId)
+ assert.Equal(t, err, nil)
+ fmt.Println("Error:", err)
+}
+
+func TestBadRequestSubscriptionDeleteHandling(t *testing.T) {
+ subscriptionId = "send_400_bad_request_response"
+ err := Subscription.Unsubscribe(subscriptionId)
+ assert.NotEqual(t, err, nil)
+ fmt.Println("Error:", err.Error())
+ assert.Equal(t, err.Error(), "[DELETE /subscriptions/{subscriptionId}][400] unsubscribeBadRequest ")
+}
+
+func TestInternalServerErrorSubscriptionDeleteHandling(t *testing.T) {
+ subscriptionId = "send_500_internal_server_error_response"
+ err := Subscription.Unsubscribe(subscriptionId)
+ assert.NotEqual(t, err, nil)
+ fmt.Println("Error:", err.Error())
+ assert.Equal(t, err.Error(), "[DELETE /subscriptions/{subscriptionId}][500] unsubscribeInternalServerError ")
+}
+
+func TestResponseHandler(t *testing.T) {
+ Subscription.SetResponseCB(SubscriptionRespHandler)
+
+ payload := []byte(`{"SubscriptionInstances":[{"tXappEventInstanceID": 1}]`)
+ req, err := http.NewRequest("POST", "/ric/v1/subscriptions/response", bytes.NewBuffer(payload))
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ rr := httptest.NewRecorder()
+ handler := http.HandlerFunc(Subscription.ResponseHandler)
+ handler.ServeHTTP(rr, req)
+
+ if status := rr.Code; status != http.StatusOK {
+ t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusOK)
+ }
+ time.Sleep(time.Duration(2) * time.Second)
+}
+
+// Helper functions
+func SubscriptionRespHandler(resp *clientmodel.SubscriptionResponse) {
+}
+
+func processSubscriptions(subscriptionId string) {
+
+ // Generate xappInstanceId
+ xappInstanceId := int64(11)
+
+ if subscriptionId == "send_failure_notification" {
+ fmt.Println("Sending error notification")
+
+ // Generate e2InstanceId
+ e2InstanceId := int64(0)
+ resp := &models.SubscriptionResponse{
+ SubscriptionID: &subscriptionId,
+ SubscriptionInstances: []*models.SubscriptionInstance{
+ {
+ XappEventInstanceID: &xappInstanceId,
+ E2EventInstanceID: &e2InstanceId,
+ ErrorCause: "Some error",
+ ErrorSource: "SUBMGR",
+ TimeoutType: "E2-Timeout",
+ },
+ },
+ }
+
+ Subscription.Notify(resp, models.SubscriptionParamsClientEndpoint{Host: "localhost", HTTPPort: &hPort, RMRPort: &rPort})
+ return
+ } else {
+
+ fmt.Println("Sending successful notification")
+
+ // Generate e2InstanceId
+ e2InstanceId := int64(22)
+
+ resp := &models.SubscriptionResponse{
+ SubscriptionID: &subscriptionId,
+ SubscriptionInstances: []*models.SubscriptionInstance{
+ {
+ XappEventInstanceID: &xappInstanceId,
+ E2EventInstanceID: &e2InstanceId,
+ },
+ },
+ }
+
+ // Notify the client: don't worry about errors ... Notify() will handle retries, etc.
+ Subscription.Notify(resp, models.SubscriptionParamsClientEndpoint{Host: "localhost", HTTPPort: &hPort, RMRPort: &rPort})
+ return
+ }
+}
+
+func subscriptionHandler(params interface{}) (*models.SubscriptionResponse, int) {
+ p := params.(*models.SubscriptionParams)
+
+ assert.Equal(suite, meid, *p.Meid)
+ assert.Equal(suite, funId, *p.RANFunctionID)
+ assert.Equal(suite, clientEndpoint.Host, p.ClientEndpoint.Host)
+ assert.Equal(suite, clientEndpoint.HTTPPort, p.ClientEndpoint.HTTPPort)
+ assert.Equal(suite, clientEndpoint.RMRPort, p.ClientEndpoint.RMRPort)
+
+ assert.Equal(suite, xappEventInstanceId, *p.SubscriptionDetails[0].XappEventInstanceID)
+ et := []int64{00, 0x11, 0x12, 0x13, 0x00, 0x21, 0x22, 0x24, 0x1B, 0x80}
+ assert.ElementsMatch(suite, et, p.SubscriptionDetails[0].EventTriggers)
+ assert.Equal(suite, actionId, *p.SubscriptionDetails[0].ActionToBeSetupList[0].ActionID)
+ assert.Equal(suite, actionType, *p.SubscriptionDetails[0].ActionToBeSetupList[0].ActionType)
+
+ assert.Equal(suite, subsequestActioType, *p.SubscriptionDetails[0].ActionToBeSetupList[0].SubsequentAction.SubsequentActionType)
+ assert.Equal(suite, timeToWait, *p.SubscriptionDetails[0].ActionToBeSetupList[0].SubsequentAction.TimeToWait)
+ assert.ElementsMatch(suite, []int64{5, 6, 7, 8}, p.SubscriptionDetails[0].ActionToBeSetupList[0].ActionDefinition)
+
+ if p.SubscriptionID != "send_failure_notification" {
+ // Generate a unique subscriptionId
+ subscriptionId = fmt.Sprintf("%s-%s", meid, clientEndpoint.Host)
+ } else {
+ subscriptionId = "send_failure_notification"
+ }
+ if p.SubscriptionID == "send_400_bad_request_response" {
+ fmt.Println("send_400_bad_request_response")
+ return &models.SubscriptionResponse{}, common.SubscribeBadRequestCode
+ }
+ if p.SubscriptionID == "send_404_not_found_response" {
+ fmt.Println("send_404_not_found_response")
+ return &models.SubscriptionResponse{}, common.SubscribeNotFoundCode
+ }
+ if p.SubscriptionID == "send_500_internal_server_error_response" {
+ fmt.Println("send_500_internal_server_error_response")
+ return &models.SubscriptionResponse{}, common.SubscribeInternalServerErrorCode
+ }
+ if p.SubscriptionID == "send_503_Service_Unavailable_response" {
+ fmt.Println("send_503_Service_Unavailable_response")
+ return &models.SubscriptionResponse{}, common.SubscribeServiceUnavailableCode
+ }
+
+ // Process subscriptions on the background
+ go processSubscriptions(subscriptionId)
+
+ // and send response immediately
+ return &models.SubscriptionResponse{
+ SubscriptionID: &subscriptionId,
+ }, common.SubscribeCreatedCode
+}
+
+func queryHandler() (models.SubscriptionList, error) {
+ resp := models.SubscriptionList{
+ &models.SubscriptionData{
+ SubscriptionID: 11,
+ Meid: "Test-Gnb",
+ ClientEndpoint: []string{"127.0.0.1:4056"},
+ },
+ }
+ return resp, nil
+}
+
+func deleteHandler(ep string) int {
+ assert.Equal(suite, subscriptionId, ep)
+ if subscriptionId == "send_201_successful_response" {
+ return common.UnsubscribeNoContentCode
+ } else if subscriptionId == "send_400_bad_request_response" {
+ return common.UnsubscribeBadRequestCode
+ } else if subscriptionId == "send_500_internal_server_error_response" {
+ return common.UnsubscribeInternalServerErrorCode
+ } else {
+ fmt.Println("Unknown subscriptionId:", subscriptionId)
+ return 0
+ }
}