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/clientmodel"
  12         "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/models"
  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         direction           = int64(0)
  30         procedureCode       = int64(27)
  31         typeOfMessage       = int64(1)
  32         subscriptionId      = ""
  33         hPort               = int64(8080)
  34         rPort               = int64(4560)
  35         clientEndpoint      = clientmodel.SubscriptionParamsClientEndpoint{Host: "localhost", HTTPPort: &hPort, RMRPort: &rPort}
  36 )
  37
  38 // Test cases
  39 func TestSetup(t *testing.T) {
  40         suite = t
  41
  42         // Start the server to simulate SubManager
  43         go Subscription.Listen(subscriptionHandler, queryHandler, deleteHandler)
  44         time.Sleep(time.Duration(2) * time.Second)
  45 }
  46
  47 func TestSubscriptionQueryHandling(t *testing.T) {
  48         resp, err := Subscription.QuerySubscriptions()
  49
  50         assert.Equal(t, err, nil)
  51         assert.Equal(t, resp[0].SubscriptionID, int64(11))
  52         assert.Equal(t, resp[0].Meid, "Test-Gnb")
  53         assert.Equal(t, resp[0].ClientEndpoint, []string{"127.0.0.1:4056"})
  54 }
  55
  56 func TestSubscriptionHandling(t *testing.T) {
  57         subscriptionParams := clientmodel.SubscriptionParams{
  58                 Meid:           &meid,
  59                 RANFunctionID:  &funId,
  60                 ClientEndpoint: &clientEndpoint,
  61                 SubscriptionDetails: clientmodel.SubscriptionDetailsList{
  62                         &clientmodel.SubscriptionDetail{
  63                                 RequestorID: &reqId,
  64                                 InstanceID:  &seqId,
  65                                 EventTriggers: &clientmodel.EventTriggerDefinition{
  66                                         OctetString: "1234",
  67                                 },
  68                                 ActionToBeSetupList: clientmodel.ActionsToBeSetup{
  69                                         &clientmodel.ActionToBeSetup{
  70                                                 ActionID:   &actionId,
  71                                                 ActionType: &actionType,
  72                                                 ActionDefinition: &clientmodel.ActionDefinition{
  73                                                         OctetString: "5678",
  74                                                 },
  75                                                 SubsequentAction: &clientmodel.SubsequentAction{
  76                                                         SubsequentActionType: &subsequestActioType,
  77                                                         TimeToWait:           &timeToWait,
  78                                                 },
  79                                         },
  80                                 },
  81                         },
  82                 },
  83         }
  84
  85         Subscription.SetResponseCB(func(resp *clientmodel.SubscriptionResponse) {
  86                 assert.Equal(t, len(resp.SubscriptionInstances), 1)
  87                 assert.Equal(t, *resp.SubscriptionInstances[0].RequestorID, int64(11))
  88                 assert.Equal(t, *resp.SubscriptionInstances[0].InstanceID, int64(22))
  89         })
  90
  91         _, err := Subscription.Subscribe(&subscriptionParams)
  92         assert.Equal(t, err, nil)
  93 }
  94
  95 func TestSubscriptionWithClientProvidedIdHandling(t *testing.T) {
  96         subscriptionParams := clientmodel.SubscriptionParams{
  97                 Meid:           &meid,
  98                 RANFunctionID:  &funId,
  99                 ClientEndpoint: &clientEndpoint,
 100                 SubscriptionID: "myxapp",
 101                 SubscriptionDetails: clientmodel.SubscriptionDetailsList{
 102                         &clientmodel.SubscriptionDetail{
 103                                 RequestorID: &reqId,
 104                                 InstanceID:  &seqId,
 105                                 EventTriggers: &clientmodel.EventTriggerDefinition{
 106                                         OctetString: "1234",
 107                                 },
 108                                 ActionToBeSetupList: clientmodel.ActionsToBeSetup{
 109                                         &clientmodel.ActionToBeSetup{
 110                                                 ActionID:   &actionId,
 111                                                 ActionType: &actionType,
 112                                                 ActionDefinition: &clientmodel.ActionDefinition{
 113                                                         OctetString: "5678",
 114                                                 },
 115                                                 SubsequentAction: &clientmodel.SubsequentAction{
 116                                                         SubsequentActionType: &subsequestActioType,
 117                                                         TimeToWait:           &timeToWait,
 118                                                 },
 119                                         },
 120                                 },
 121                         },
 122                 },
 123         }
 124
 125         Subscription.SetResponseCB(func(resp *clientmodel.SubscriptionResponse) {
 126                 assert.Equal(t, len(resp.SubscriptionInstances), 1)
 127                 assert.Equal(t, *resp.SubscriptionInstances[0].RequestorID, int64(11))
 128                 assert.Equal(t, *resp.SubscriptionInstances[0].InstanceID, int64(22))
 129         })
 130
 131         _, err := Subscription.Subscribe(&subscriptionParams)
 132         assert.Equal(t, err, nil)
 133 }
 134
 135 func TestSubscriptionDeleteHandling(t *testing.T) {
 136         err := Subscription.Unsubscribe(subscriptionId)
 137         fmt.Println(err)
 138         assert.Equal(t, err, nil)
 139 }
 140
 141 // Helper functions
 142 func processSubscriptions(subscriptionId string) {
 143         // Generate requestorId, instanceId
 144         reqId := int64(11)
 145         instanceId := int64(22)
 146
 147         resp := &models.SubscriptionResponse{
 148                 SubscriptionID: &subscriptionId,
 149                 SubscriptionInstances: []*models.SubscriptionInstance{
 150                         {
 151                                 RequestorID: &reqId,
 152                                 InstanceID:  &instanceId,
 153                         },
 154                 },
 155         }
 156
 157         // Notify the client: don't worry about errors ... Notify() will handle retries, etc.
 158         Subscription.Notify(resp, models.SubscriptionParamsClientEndpoint{Host: "localhost", HTTPPort: &hPort, RMRPort: &rPort})
 159 }
 160
 161 func subscriptionHandler(params interface{}) (*models.SubscriptionResponse, error) {
 162         p := params.(*models.SubscriptionParams)
 163
 164         assert.Equal(suite, meid, *p.Meid)
 165         assert.Equal(suite, funId, *p.RANFunctionID)
 166         assert.Equal(suite, clientEndpoint.Host, p.ClientEndpoint.Host)
 167         assert.Equal(suite, clientEndpoint.HTTPPort, p.ClientEndpoint.HTTPPort)
 168         assert.Equal(suite, clientEndpoint.RMRPort, p.ClientEndpoint.RMRPort)
 169
 170         assert.Equal(suite, reqId, *p.SubscriptionDetails[0].RequestorID)
 171         assert.Equal(suite, seqId, *p.SubscriptionDetails[0].InstanceID)
 172         assert.Equal(suite, "1234", p.SubscriptionDetails[0].EventTriggers.OctetString)
 173         assert.Equal(suite, actionId, *p.SubscriptionDetails[0].ActionToBeSetupList[0].ActionID)
 174         assert.Equal(suite, actionType, *p.SubscriptionDetails[0].ActionToBeSetupList[0].ActionType)
 175
 176         assert.Equal(suite, subsequestActioType, *p.SubscriptionDetails[0].ActionToBeSetupList[0].SubsequentAction.SubsequentActionType)
 177         assert.Equal(suite, timeToWait, *p.SubscriptionDetails[0].ActionToBeSetupList[0].SubsequentAction.TimeToWait)
 178         assert.Equal(suite, "5678", p.SubscriptionDetails[0].ActionToBeSetupList[0].ActionDefinition.OctetString)
 179
 180         // Generate a unique subscriptionId
 181         subscriptionId = fmt.Sprintf("%s-%s", meid, clientEndpoint.Host)
 182
 183         // Process subscriptions on the background
 184         go processSubscriptions(subscriptionId)
 185
 186         // and send response immediately
 187         return &models.SubscriptionResponse{
 188                 SubscriptionID: &subscriptionId,
 189         }, nil
 190 }
 191
 192 func queryHandler() (models.SubscriptionList, error) {
 193         resp := models.SubscriptionList{
 194                 &models.SubscriptionData{
 195                         SubscriptionID: 11,
 196                         Meid:           "Test-Gnb",
 197                         ClientEndpoint: []string{"127.0.0.1:4056"},
 198                 },
 199         }
 200         return resp, nil
 201 }
 202
 203 func deleteHandler(ep string) error {
 204         assert.Equal(suite, subscriptionId, ep)
 205         return nil
 206 }