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/clientmodel"
"gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/models"
"github.com/stretchr/testify/assert"
"testing"
"time"
+ "fmt"
)
var suite *testing.T
-var requestorId = int64(0x4EEC)
+var meid = "gnb123456"
+var funId = int64(1)
+var clientEndpoint = "localhost:4560"
var direction = int64(0)
var procedureCode = int64(27)
var typeOfMessage = int64(1)
-var reportParams = apimodel.ReportParams{
- RequestorID: &requestorId,
- EventTriggers: apimodel.EventTriggerList{
- &apimodel.EventTrigger{
- InterfaceDirection: &direction,
- ProcedureCode: &procedureCode,
- TypeOfMessage: &typeOfMessage,
+var reportParams = clientmodel.ReportParams{
+ Meid: meid,
+ RANFunctionID: &funId,
+ ClientEndpoint: &clientEndpoint,
+ EventTriggers: clientmodel.EventTriggerList{
+ &clientmodel.EventTrigger{
+ InterfaceDirection: direction,
+ ProcedureCode: procedureCode,
+ TypeOfMessage: typeOfMessage,
},
},
}
-var controlParams = apimodel.ControlParams{
- RequestorID: requestorId,
+var policyParams = clientmodel.PolicyParams{
+ Meid: &meid,
+ RANFunctionID: &funId,
+ ClientEndpoint: &clientEndpoint,
+ EventTriggers: clientmodel.EventTriggerList{
+ &clientmodel.EventTrigger{
+ InterfaceDirection: direction,
+ ProcedureCode: procedureCode,
+ TypeOfMessage: typeOfMessage,
+ },
+ },
+ PolicyActionDefinitions: &clientmodel.PolicyActionDefinition{},
}
-var policyParams = apimodel.PolicyParams{
- RequestorID: requestorId,
+func processSubscriptions(subscriptionId string) {
+ // Generate requestorId, instanceId
+ reqId := int64(11)
+ instanceId := int64(22)
+
+ 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.SubscriptionResult, error) {
+func subscriptionHandler(stype models.SubscriptionType, params interface{}) (*models.SubscriptionResponse, error) {
switch stype {
case models.SubscriptionTypeReport:
p := params.(*models.ReportParams)
- assert.Equal(suite, requestorId, *p.RequestorID)
- 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.SubscriptionTypeControl:
- p := params.(*models.ControlParams)
- assert.Equal(suite, requestorId, p.RequestorID)
+ 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, requestorId, p.RequestorID)
+ assert.Equal(suite, clientEndpoint, *p.ClientEndpoint)
}
- return models.SubscriptionResult{11, 22, 33}, nil
+ // 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) {
return resp, nil
}
+func deleteHandler(ep string) error {
+ assert.Equal(suite, clientEndpoint, ep)
+
+ return nil
+}
+
func TestSetup(t *testing.T) {
suite = t
// Start the server to simulate SubManager
- go Subscription.Listen(subscriptionHandler, queryHandler)
+ go Subscription.Listen(subscriptionHandler, queryHandler, deleteHandler)
time.Sleep(time.Duration(2) * time.Second)
}
}
func TestSubscriptionReportHandling(t *testing.T) {
- result, err := Subscription.SubscribeReport(&reportParams)
+ 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.SubscribeReport(&reportParams)
assert.Equal(t, err, nil)
- assert.Equal(t, len(result), 3)
- assert.Equal(t, result[0], int64(11))
- assert.Equal(t, result[1], int64(22))
- assert.Equal(t, result[2], int64(33))
}
-func TestSubscriptionControltHandling(t *testing.T) {
- result, err := Subscription.SubscribeControl(&controlParams)
+func TestSubscriptionPolicytHandling(t *testing.T) {
+ 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.SubscribePolicy(&policyParams)
assert.Equal(t, err, nil)
- assert.Equal(t, len(result), 3)
- assert.Equal(t, result[0], int64(11))
}
-func TestSubscriptionPolicytHandling(t *testing.T) {
- result, err := Subscription.SubscribePolicy(&policyParams)
+func TestSubscriptionDeleteHandling(t *testing.T) {
+ err := Subscription.UnSubscribe(clientEndpoint)
assert.Equal(t, err, nil)
- assert.Equal(t, len(result), 3)
- assert.Equal(t, result[0], int64(11))
}