X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=pkg%2Fxapp%2Fsubscription_test.go;h=ffdea342af9fa35a3b061e00944c815437fbdbf0;hb=79f0680fd7bbf1c8a8c6e2a842cb18020e387a47;hp=b9713afdb3f36f22f22676f96a4ac1689a9b2804;hpb=844be329568878ce3e2f3aa4a5f9dcfc92b8b0f5;p=ric-plt%2Fxapp-frame.git diff --git a/pkg/xapp/subscription_test.go b/pkg/xapp/subscription_test.go index b9713af..ffdea34 100755 --- a/pkg/xapp/subscription_test.go +++ b/pkg/xapp/subscription_test.go @@ -7,94 +7,40 @@ package xapp import ( - apimodel "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/clientmodel" - "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/models" - "github.com/stretchr/testify/assert" + "bytes" + "fmt" + "net/http" + "net/http/httptest" "testing" "time" -) - -var suite *testing.T - -var meid = "gnb123456" -var funId = int64(1) -var clientEndpoint = "localhost:4561" -var direction = int64(0) -var procedureCode = int64(27) -var typeOfMessage = int64(1) - -var reportParams = apimodel.ReportParams{ - Meid: meid, - RANFunctionID: &funId, - ClientEndpoint: &clientEndpoint, - EventTriggers: apimodel.EventTriggerList{ - &apimodel.EventTrigger{ - InterfaceDirection: direction, - ProcedureCode: procedureCode, - TypeOfMessage: typeOfMessage, - }, - }, -} - -var policyParams = apimodel.PolicyParams{ - Meid: &meid, - RANFunctionID: &funId, - ClientEndpoint: &clientEndpoint, - EventTriggers: apimodel.EventTriggerList{ - &apimodel.EventTrigger{ - InterfaceDirection: direction, - ProcedureCode: procedureCode, - TypeOfMessage: typeOfMessage, - }, - }, - PolicyActionDefinitions: &apimodel.PolicyActionDefinition{}, -} - -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) - } - subId := "xapp-11" - reqId := int64(11) - instanceId := int64(22) - return &models.SubscriptionResponse{ - SubscriptionID: &subId, - SubscriptionInstances: []*models.SubscriptionInstance{ - &models.SubscriptionInstance{RequestorID: &reqId, InstanceID: &instanceId}, - &models.SubscriptionInstance{RequestorID: &reqId, InstanceID: &instanceId}, - }, - }, 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 -} + "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" +) -func deleteHandler(ep string) error { - assert.Equal(suite, clientEndpoint, ep) +var ( + suite *testing.T - 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 @@ -109,31 +55,295 @@ func TestSubscriptionQueryHandling(t *testing.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) { - resp, err := Subscription.SubscribeReport(&reportParams) +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].XappEventInstanceID, int64(11)) + assert.Equal(t, *resp.SubscriptionInstances[0].E2EventInstanceID, int64(22)) + }) + _, err := Subscription.Subscribe(subscriptionParams) assert.Equal(t, err, nil) - assert.Equal(t, len(resp.SubscriptionInstances), 2) - assert.Equal(t, *resp.SubscriptionInstances[0].RequestorID, int64(11)) - assert.Equal(t, *resp.SubscriptionInstances[0].InstanceID, int64(22)) - assert.Equal(t, *resp.SubscriptionInstances[1].RequestorID, int64(11)) - assert.Equal(t, *resp.SubscriptionInstances[1].InstanceID, int64(22)) + <-time.After(1 * time.Second) } -func TestSubscriptionPolicytHandling(t *testing.T) { - resp, err := Subscription.SubscribePolicy(&policyParams) +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].XappEventInstanceID, int64(11)) + assert.Equal(t, *resp.SubscriptionInstances[0].E2EventInstanceID, int64(22)) + }) + + _, err := Subscription.Subscribe(subscriptionParams) assert.Equal(t, err, nil) - assert.Equal(t, len(resp.SubscriptionInstances), 2) - assert.Equal(t, *resp.SubscriptionInstances[0].RequestorID, int64(11)) - assert.Equal(t, *resp.SubscriptionInstances[0].InstanceID, int64(22)) + <-time.After(1 * time.Second) +} + +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 TestSubscriptionDeleteHandling(t *testing.T) { - err := Subscription.UnSubscribe(clientEndpoint) +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) -} \ No newline at end of file + 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 + } +}