X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=pkg%2Fxapp%2Fsubscription_test.go;h=d41649feeac45292a1825ea19d26291f83549973;hb=refs%2Fchanges%2F04%2F6704%2F1;hp=c7b00cd728025972a9e3b7eaf56265fb12c5d9a2;hpb=1f555883dfe854ff50b26a2e677278360283d88a;p=ric-plt%2Fxapp-frame.git

diff --git a/pkg/xapp/subscription_test.go b/pkg/xapp/subscription_test.go
index c7b00cd..d41649f 100755
--- a/pkg/xapp/subscription_test.go
+++ b/pkg/xapp/subscription_test.go
@@ -7,12 +7,16 @@
 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"
 )
 
@@ -55,29 +59,7 @@ func TestSubscriptionQueryHandling(t *testing.T) {
 }
 
 func TestSubscriptionHandling(t *testing.T) {
-	subscriptionParams := 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,
-						},
-					},
-				},
-			},
-		},
-	}
+	subscriptionParams := GetSubscriptionparams()
 
 	Subscription.SetResponseCB(func(resp *clientmodel.SubscriptionResponse) {
 		assert.Equal(t, len(resp.SubscriptionInstances), 1)
@@ -85,13 +67,57 @@ func TestSubscriptionHandling(t *testing.T) {
 		assert.Equal(t, *resp.SubscriptionInstances[0].E2EventInstanceID, int64(22))
 	})
 
-	_, err := Subscription.Subscribe(&subscriptionParams)
+	_, err := Subscription.Subscribe(subscriptionParams)
 	assert.Equal(t, err, nil)
 }
 
 func TestSubscriptionWithClientProvidedIdHandling(t *testing.T) {
-	subscriptionParams := clientmodel.SubscriptionParams{
-		SubscriptionID: "myxapp",
+	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,
@@ -113,24 +139,54 @@ func TestSubscriptionWithClientProvidedIdHandling(t *testing.T) {
 			},
 		},
 	}
+}
 
-	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)
+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
 	xappInstanceId := int64(11)
@@ -150,7 +206,7 @@ func processSubscriptions(subscriptionId string) {
 	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)
@@ -172,13 +228,25 @@ func subscriptionHandler(params interface{}) (*models.SubscriptionResponse, erro
 	// Generate a unique subscriptionId
 	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) {
@@ -192,7 +260,13 @@ func queryHandler() (models.SubscriptionList, error) {
 	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
+	}
 }