package xapp
import (
- apimodel "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/clientmodel"
+ "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"
"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{
- &models.SubscriptionResponseItem{SubscriptionID: &subId, RequestorID: &reqId, InstanceID: &instanceId},
- &models.SubscriptionResponseItem{SubscriptionID: &subId, 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
-}
-
-func deleteHandler(ep string) error {
- assert.Equal(suite, clientEndpoint, ep)
-
- return nil
-}
+var (
+ suite *testing.T
+
+ meid = "gnb123456"
+ reqId = int64(1)
+ seqId = 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
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) {
- result, err := Subscription.SubscribeReport(&reportParams)
+func TestSubscriptionHandling(t *testing.T) {
+ subscriptionParams := clientmodel.SubscriptionParams{
+ Meid: &meid,
+ RANFunctionID: &funId,
+ ClientEndpoint: &clientEndpoint,
+ SubscriptionDetails: clientmodel.SubscriptionDetailsList{
+ &clientmodel.SubscriptionDetail{
+ RequestorID: &reqId,
+ InstanceID: &seqId,
+ EventTriggers: &clientmodel.EventTriggerDefinition{
+ OctetString: "1234",
+ },
+ ActionToBeSetupList: clientmodel.ActionsToBeSetup{
+ &clientmodel.ActionToBeSetup{
+ ActionID: &actionId,
+ ActionType: &actionType,
+ ActionDefinition: &clientmodel.ActionDefinition{
+ OctetString: "5678",
+ },
+ SubsequentAction: &clientmodel.SubsequentAction{
+ SubsequentActionType: &subsequestActioType,
+ 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)
assert.Equal(t, err, nil)
- assert.Equal(t, len(result), 2)
- assert.Equal(t, *result[0].RequestorID, int64(11))
- assert.Equal(t, *result[0].InstanceID, int64(22))
- assert.Equal(t, *result[1].RequestorID, int64(11))
- assert.Equal(t, *result[1].InstanceID, int64(22))
}
-func TestSubscriptionPolicytHandling(t *testing.T) {
- result, err := Subscription.SubscribePolicy(&policyParams)
-
+func TestSubscriptionDeleteHandling(t *testing.T) {
+ err := Subscription.Unsubscribe(subscriptionId)
+ fmt.Println(err)
assert.Equal(t, err, nil)
- assert.Equal(t, len(result), 2)
- assert.Equal(t, *result[0].RequestorID, int64(11))
- assert.Equal(t, *result[0].InstanceID, int64(22))
}
-func TestSubscriptionDeleteHandling(t *testing.T) {
- err := Subscription.UnSubscribe(clientEndpoint)
+// Helper functions
+func processSubscriptions(subscriptionId string) {
+ // Generate requestorId, instanceId
+ reqId := int64(11)
+ instanceId := int64(22)
- assert.Equal(t, err, nil)
-}
\ No newline at end of file
+ resp := &models.SubscriptionResponse{
+ SubscriptionID: &subscriptionId,
+ SubscriptionInstances: []*models.SubscriptionInstance{
+ {
+ RequestorID: &reqId,
+ InstanceID: &instanceId,
+ },
+ },
+ }
+
+ // 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, error) {
+ 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, reqId, *p.SubscriptionDetails[0].RequestorID)
+ assert.Equal(suite, seqId, *p.SubscriptionDetails[0].InstanceID)
+ assert.Equal(suite, "1234", p.SubscriptionDetails[0].EventTriggers.OctetString)
+ 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)
+
+ // Generate a unique subscriptionId
+ subscriptionId = fmt.Sprintf("%s-%s", meid, clientEndpoint.Host)
+
+ // 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",
+ ClientEndpoint: []string{"127.0.0.1:4056"},
+ },
+ }
+ return resp, nil
+}
+
+func deleteHandler(ep string) error {
+ assert.Equal(suite, subscriptionId, ep)
+ return nil
+}
Code Review / ric-plt / xapp-frame.git / blobdiff