X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=pkg%2Fxapp%2Fsubscription_test.go;h=d41649feeac45292a1825ea19d26291f83549973;hb=b1ed7be0b303c9c6ec3744b82caf7d1c720ee19a;hp=dc0a171f6d1c0389d154d34fe059f3edb8250e05;hpb=3602bf801fef17e317cb35a4c710118ec80908b9;p=ric-plt%2Fxapp-frame.git diff --git a/pkg/xapp/subscription_test.go b/pkg/xapp/subscription_test.go index dc0a171..d41649f 100755 --- a/pkg/xapp/subscription_test.go +++ b/pkg/xapp/subscription_test.go @@ -7,31 +7,37 @@ package xapp import ( + "bytes" "fmt" - "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/models" - "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/clientmodel" - "github.com/stretchr/testify/assert" + "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" ) var ( suite *testing.T - meid = "gnb123456" - reqId = int64(1) - seqId = int64(1) - funId = int64(1) - actionId = int64(1) - actionType = "report" + meid = "gnb123456" + xappEventInstanceId = int64(1) + eventInstanceId = int64(1) + funId = int64(1) + actionId = int64(1) + actionType = "report" subsequestActioType = "continue" - timeToWait = "w10ms" - port = int64(4560) - clientEndpoint = clientmodel.SubscriptionParamsClientEndpoint{ServiceName: "localhost", Port: &port} - direction = int64(0) - procedureCode = int64(27) - typeOfMessage = int64(1) - subscriptionId = "" + timeToWait = "w10ms" + direction = int64(0) + procedureCode = int64(27) + typeOfMessage = int64(1) + subscriptionId = "" + hPort = int64(8080) + rPort = int64(4560) + clientEndpoint = clientmodel.SubscriptionParamsClientEndpoint{Host: "localhost", HTTPPort: &hPort, RMRPort: &rPort} ) // Test cases @@ -49,102 +55,198 @@ 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"}) } func TestSubscriptionHandling(t *testing.T) { - subscriptionParams := clientmodel.SubscriptionParams{ + subscriptionParams := GetSubscriptionparams() + + 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(22)) + }) + + _, err := Subscription.Subscribe(subscriptionParams) + assert.Equal(t, err, nil) +} + +func TestSubscriptionWithClientProvidedIdHandling(t *testing.T) { + subscriptionParams := GetSubscriptionparams() + subscriptionParams.SubscriptionID = "myxapp" + + 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(22)) + }) + + _, err := Subscription.Subscribe(subscriptionParams) + assert.Equal(t, err, nil) +} + +func TestBadRequestSubscriptionHandling(t *testing.T) { + subscriptionParams := GetSubscriptionparams() + subscriptionParams.SubscriptionID = "123_send_bad_request_response" + + 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(22)) + }) + + _, err := Subscription.Subscribe(subscriptionParams) + assert.Equal(t, err.Error(), "[POST /subscriptions][400] subscribeBadRequest ") + fmt.Println("Error:",err) +} + +func TestInternalServerErrorSubscriptionHandling(t *testing.T) { + subscriptionParams := GetSubscriptionparams() + subscriptionParams.SubscriptionID = "123_send_internal_server_error_response" + + 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(22)) + }) + + _, err := Subscription.Subscribe(subscriptionParams) + assert.Equal(t, err.Error(), "[POST /subscriptions][500] subscribeInternalServerError ") + fmt.Println("Error:",err) +} + +func GetSubscriptionparams() *clientmodel.SubscriptionParams { + return &clientmodel.SubscriptionParams{ + SubscriptionID: "", Meid: &meid, RANFunctionID: &funId, ClientEndpoint: &clientEndpoint, - RequestorID: &reqId, - InstanceID: &seqId, SubscriptionDetails: clientmodel.SubscriptionDetailsList{ - &clientmodel.SubscriptionDetails{ - EventTriggerList: &clientmodel.EventTriggerDefinition{ - OctetString: "1234", - }, + &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{ - OctetString: "5678", - }, + ActionID: &actionId, + ActionType: &actionType, + ActionDefinition: clientmodel.ActionDefinition{5, 6, 7, 8}, SubsequentAction: &clientmodel.SubsequentAction{ SubsequentActionType: &subsequestActioType, - TimeToWait: &timeToWait, + TimeToWait: &timeToWait, }, }, }, }, }, } +} - Subscription.SetResponseCB(func(resp *clientmodel.SubscriptionResponse) { - 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)) - }) - - _, err := Subscription.Subscribe(&subscriptionParams) +func TestSuccessfulSubscriptionDeleteHandling(t *testing.T) { + subscriptionId = "123_send_successful_response" + err := Subscription.Unsubscribe(subscriptionId) assert.Equal(t, err, nil) + fmt.Println("Error:",err) } -func TestSubscriptionDeleteHandling(t *testing.T) { +func TestBadRequestSubscriptionDeleteHandling(t *testing.T) { + subscriptionId = "123_send_bad_request_response" err := Subscription.Unsubscribe(subscriptionId) - fmt.Println(err) - assert.Equal(t, err, nil) + 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 = "123_send_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 requestorId, instanceId - reqId := int64(11) - instanceId := int64(22) + xappInstanceId := int64(11) + e2InstanceId := int64(22) resp := &models.SubscriptionResponse{ SubscriptionID: &subscriptionId, SubscriptionInstances: []*models.SubscriptionInstance{ { - RequestorID: &reqId, - InstanceID: &instanceId, + XappEventInstanceID: &xappInstanceId, + E2EventInstanceID: &e2InstanceId, }, }, } // Notify the client: don't worry about errors ... Notify() will handle retries, etc. - Subscription.Notify(resp, models.SubscriptionParamsClientEndpoint{ServiceName: "localhost", Port: &port}) + Subscription.Notify(resp, models.SubscriptionParamsClientEndpoint{Host: "localhost", HTTPPort: &hPort, RMRPort: &rPort}) } -func subscriptionHandler(params interface{}) (*models.SubscriptionResponse, error) { +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.ServiceName, p.ClientEndpoint.ServiceName) - assert.Equal(suite, clientEndpoint.Port, p.ClientEndpoint.Port) - assert.Equal(suite, reqId, *p.RequestorID) - assert.Equal(suite, seqId, *p.InstanceID) + 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, "1234", p.SubscriptionDetails[0].EventTriggerList.OctetString) + 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.Equal(suite, "5678", p.SubscriptionDetails[0].ActionToBeSetupList[0].ActionDefinition.OctetString) + assert.ElementsMatch(suite, []int64{5, 6, 7, 8}, p.SubscriptionDetails[0].ActionToBeSetupList[0].ActionDefinition) // Generate a unique subscriptionId - subscriptionId = fmt.Sprintf("%s-%s", meid, clientEndpoint.ServiceName) + subscriptionId = fmt.Sprintf("%s-%s", meid, clientEndpoint.Host) + if p.SubscriptionID == "123_send_bad_request_response" { + // Simulate bad request case + return &models.SubscriptionResponse{ + }, common.UnsubscribeBadRequestCode + + } + + if p.SubscriptionID == "123_send_internal_server_error_response" { + // Simulate bad internal server error case + return &models.SubscriptionResponse{ + }, common.UnsubscribeInternalServerErrorCode + } // Process subscriptions on the background go processSubscriptions(subscriptionId) // and send response immediately return &models.SubscriptionResponse{ SubscriptionID: &subscriptionId, - }, nil + }, common.SubscribeCreatedCode } func queryHandler() (models.SubscriptionList, error) { @@ -152,13 +254,19 @@ func queryHandler() (models.SubscriptionList, error) { &models.SubscriptionData{ SubscriptionID: 11, Meid: "Test-Gnb", - Endpoint: []string{"127.0.0.1:4056"}, + ClientEndpoint: []string{"127.0.0.1:4056"}, }, } return resp, nil } -func deleteHandler(ep string) error { +func deleteHandler(ep string) int { assert.Equal(suite, subscriptionId, ep) - return nil + if subscriptionId == "123_send_successful_response" { + return common.UnsubscribeNoContentCode + } else if subscriptionId == "123_send_bad_request_response" { + return common.UnsubscribeBadRequestCode + } else { + return common.UnsubscribeInternalServerErrorCode + } }