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=a5601cc11e2927b28950d970d37d1f6d2d8c05e2;hpb=5953f7e372df54c71f526e9519e8eb0ee7ee6f72;p=ric-plt%2Fxapp-frame.git

diff --git a/pkg/xapp/subscription_test.go b/pkg/xapp/subscription_test.go
index a5601cc..d41649f 100755
--- a/pkg/xapp/subscription_test.go
+++ b/pkg/xapp/subscription_test.go
@@ -7,111 +7,40 @@
 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"
-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)
+var (
+	suite *testing.T
 
-	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
-}
-
-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(8080)
+	rPort               = int64(4560)
+	clientEndpoint      = clientmodel.SubscriptionParamsClientEndpoint{Host: "localhost", HTTPPort: &hPort, RMRPort: &rPort}
+)
 
+// Test cases
 func TestSetup(t *testing.T) {
 	suite = t
 
@@ -126,33 +55,218 @@ 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 TestSubscriptionReportHandling(t *testing.T) {
+func TestSubscriptionHandling(t *testing.T) {
+	subscriptionParams := GetSubscriptionparams()
+
 	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))
+		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)
 }
 
-func TestSubscriptionPolicytHandling(t *testing.T) {
+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].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)
 }
 
-func TestSubscriptionDeleteHandling(t *testing.T) {
-	err := Subscription.UnSubscribe(clientEndpoint)
+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,
+		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 = "123_send_successful_response"
+	err := Subscription.Unsubscribe(subscriptionId)
 	assert.Equal(t, err, nil)
+	fmt.Println("Error:",err)
+}
+
+func TestBadRequestSubscriptionDeleteHandling(t *testing.T) {
+	subscriptionId = "123_send_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 = "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)
+	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})
+}
+
+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)
+
+	// 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,
+	}, 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 == "123_send_successful_response" {
+		return common.UnsubscribeNoContentCode
+	} else if subscriptionId == "123_send_bad_request_response" {
+		return common.UnsubscribeBadRequestCode
+	} else {
+		return common.UnsubscribeInternalServerErrorCode
+	}
 }