pkg/xapp/subscription_test.go

   1 /*
   2 ==================================================================================
   3   Copyright (c) 2019 Nokia
   4 ==================================================================================
   5 */
   6
   7 package xapp
   8
   9 import (
  10         "fmt"
  11         "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/models"
  12         "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/clientmodel"
  13         "github.com/stretchr/testify/assert"
  14         "testing"
  15         "time"
  16 )
  17
  18 var (
  19         suite *testing.T
  20
  21         meid = "gnb123456"
  22         reqId = int64(1)
  23         seqId = int64(1)
  24         funId = int64(1)
  25         actionId = int64(1)
  26         actionType = "report"
  27         subsequestActioType = "continue"
  28         timeToWait = "w10ms"
  29         port = int64(4560)
  30         clientEndpoint = clientmodel.SubscriptionParamsClientEndpoint{ServiceName: "localhost", Port: &port}
  31         direction = int64(0)
  32         procedureCode = int64(27)
  33         typeOfMessage = int64(1)
  34         subscriptionId = ""
  35 )
  36
  37 // Test cases
  38 func TestSetup(t *testing.T) {
  39         suite = t
  40
  41         // Start the server to simulate SubManager
  42         go Subscription.Listen(subscriptionHandler, queryHandler, deleteHandler)
  43         time.Sleep(time.Duration(2) * time.Second)
  44 }
  45
  46 func TestSubscriptionQueryHandling(t *testing.T) {
  47         resp, err := Subscription.QuerySubscriptions()
  48
  49         assert.Equal(t, err, nil)
  50         assert.Equal(t, resp[0].SubscriptionID, int64(11))
  51         assert.Equal(t, resp[0].Meid, "Test-Gnb")
  52         assert.Equal(t, resp[0].Endpoint, []string{"127.0.0.1:4056"})
  53 }
  54
  55 func TestSubscriptionHandling(t *testing.T) {
  56         subscriptionParams := clientmodel.SubscriptionParams{
  57                 Meid:           &meid,
  58                 RANFunctionID:  &funId,
  59                 ClientEndpoint: &clientEndpoint,
  60                 RequestorID: &reqId,
  61                 InstanceID: &seqId,
  62                 SubscriptionDetails: clientmodel.SubscriptionDetailsList{
  63                         &clientmodel.SubscriptionDetails{
  64                                 EventTriggerList: &clientmodel.EventTriggerDefinition{
  65                                         OctetString: "1234",
  66                                 },
  67                                 ActionToBeSetupList: clientmodel.ActionsToBeSetup{
  68                                         &clientmodel.ActionToBeSetup{
  69                                                 ActionID: &actionId,
  70                                                 ActionType: &actionType,
  71                                                 ActionDefinition: &clientmodel.ActionDefinition{
  72                                                         OctetString: "5678",
  73                                                 },
  74                                                 SubsequentAction: &clientmodel.SubsequentAction{
  75                                                         SubsequentActionType: &subsequestActioType,
  76                                                         TimeToWait: &timeToWait,
  77                                                 },
  78                                         },
  79                                 },
  80                         },
  81                 },
  82         }
  83
  84         Subscription.SetResponseCB(func(resp *clientmodel.SubscriptionResponse) {
  85                 assert.Equal(t, len(resp.SubscriptionInstances), 1)
  86                 assert.Equal(t, *resp.SubscriptionInstances[0].RequestorID, int64(11))
  87                 assert.Equal(t, *resp.SubscriptionInstances[0].InstanceID, int64(22))
  88         })
  89
  90         _, err := Subscription.Subscribe(&subscriptionParams)
  91         assert.Equal(t, err, nil)
  92 }
  93
  94 func TestSubscriptionDeleteHandling(t *testing.T) {
  95         err := Subscription.Unsubscribe(subscriptionId)
  96         fmt.Println(err)
  97         assert.Equal(t, err, nil)
  98 }
  99
 100 // Helper functions
 101 func processSubscriptions(subscriptionId string) {
 102         // Generate requestorId, instanceId
 103         reqId := int64(11)
 104         instanceId := int64(22)
 105
 106         resp := &models.SubscriptionResponse{
 107                 SubscriptionID: &subscriptionId,
 108                 SubscriptionInstances: []*models.SubscriptionInstance{
 109                         {
 110                                 RequestorID: &reqId,
 111                                 InstanceID: &instanceId,
 112                         },
 113                 },
 114         }
 115
 116         // Notify the client: don't worry about errors ... Notify() will handle retries, etc.
 117         Subscription.Notify(resp, models.SubscriptionParamsClientEndpoint{ServiceName: "localhost", Port: &port})
 118 }
 119
 120 func subscriptionHandler(params interface{}) (*models.SubscriptionResponse, error) {
 121         p := params.(*models.SubscriptionParams)
 122
 123         assert.Equal(suite, meid, *p.Meid)
 124         assert.Equal(suite, funId, *p.RANFunctionID)
 125         assert.Equal(suite, clientEndpoint.ServiceName, p.ClientEndpoint.ServiceName)
 126         assert.Equal(suite, clientEndpoint.Port, p.ClientEndpoint.Port)
 127         assert.Equal(suite, reqId, *p.RequestorID)
 128         assert.Equal(suite, seqId, *p.InstanceID)
 129
 130         assert.Equal(suite, "1234", p.SubscriptionDetails[0].EventTriggerList.OctetString)
 131         assert.Equal(suite, actionId, *p.SubscriptionDetails[0].ActionToBeSetupList[0].ActionID)
 132         assert.Equal(suite, actionType, *p.SubscriptionDetails[0].ActionToBeSetupList[0].ActionType)
 133
 134         assert.Equal(suite, subsequestActioType, *p.SubscriptionDetails[0].ActionToBeSetupList[0].SubsequentAction.SubsequentActionType)
 135         assert.Equal(suite, timeToWait, *p.SubscriptionDetails[0].ActionToBeSetupList[0].SubsequentAction.TimeToWait)
 136         assert.Equal(suite, "5678", p.SubscriptionDetails[0].ActionToBeSetupList[0].ActionDefinition.OctetString)
 137
 138         // Generate a unique subscriptionId
 139         subscriptionId = fmt.Sprintf("%s-%s", meid, clientEndpoint.ServiceName)
 140
 141         // Process subscriptions on the background
 142         go processSubscriptions(subscriptionId)
 143
 144         // and send response immediately
 145         return &models.SubscriptionResponse{
 146                 SubscriptionID: &subscriptionId,
 147         }, nil
 148 }
 149
 150 func queryHandler() (models.SubscriptionList, error) {
 151         resp := models.SubscriptionList{
 152                 &models.SubscriptionData{
 153                         SubscriptionID: 11,
 154                         Meid:           "Test-Gnb",
 155                         Endpoint:       []string{"127.0.0.1:4056"},
 156                 },
 157         }
 158         return resp, nil
 159 }
 160
 161 func deleteHandler(ep string) error {
 162         assert.Equal(suite, subscriptionId, ep)
 163         return nil
 164 }