pkg/xapp/subscription_test.go

   1 /*
   2 ==================================================================================
   3   Copyright (c) 2019 Nokia
   4 ==================================================================================
   5 */
   6
   7 package xapp
   8
   9 import (
  10         "fmt"
  11         "testing"
  12         "time"
  13
  14         "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/clientmodel"
  15         "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/models"
  16         "github.com/stretchr/testify/assert"
  17 )
  18
  19 var (
  20         suite *testing.T
  21
  22         meid                = "gnb123456"
  23         xappEventInstanceId = int64(1)
  24         eventInstanceId     = int64(1)
  25         funId               = int64(1)
  26         actionId            = int64(1)
  27         actionType          = "report"
  28         subsequestActioType = "continue"
  29         timeToWait          = "w10ms"
  30         direction           = int64(0)
  31         procedureCode       = int64(27)
  32         typeOfMessage       = int64(1)
  33         subscriptionId      = ""
  34         hPort               = int64(8080)
  35         rPort               = int64(4560)
  36         clientEndpoint      = clientmodel.SubscriptionParamsClientEndpoint{Host: "localhost", HTTPPort: &hPort, RMRPort: &rPort}
  37 )
  38
  39 // Test cases
  40 func TestSetup(t *testing.T) {
  41         suite = t
  42
  43         // Start the server to simulate SubManager
  44         go Subscription.Listen(subscriptionHandler, queryHandler, deleteHandler)
  45         time.Sleep(time.Duration(2) * time.Second)
  46 }
  47
  48 func TestSubscriptionQueryHandling(t *testing.T) {
  49         resp, err := Subscription.QuerySubscriptions()
  50
  51         assert.Equal(t, err, nil)
  52         assert.Equal(t, resp[0].SubscriptionID, int64(11))
  53         assert.Equal(t, resp[0].Meid, "Test-Gnb")
  54         assert.Equal(t, resp[0].ClientEndpoint, []string{"127.0.0.1:4056"})
  55 }
  56
  57 func TestSubscriptionHandling(t *testing.T) {
  58         subscriptionParams := clientmodel.SubscriptionParams{
  59                 SubscriptionID: "",
  60                 Meid:           &meid,
  61                 RANFunctionID:  &funId,
  62                 ClientEndpoint: &clientEndpoint,
  63                 SubscriptionDetails: clientmodel.SubscriptionDetailsList{
  64                         &clientmodel.SubscriptionDetail{
  65                                 XappEventInstanceID: &eventInstanceId,
  66                                 EventTriggers: &clientmodel.EventTriggerDefinition{
  67                                         OctetString: "1234",
  68                                 },
  69                                 ActionToBeSetupList: clientmodel.ActionsToBeSetup{
  70                                         &clientmodel.ActionToBeSetup{
  71                                                 ActionID:   &actionId,
  72                                                 ActionType: &actionType,
  73                                                 ActionDefinition: &clientmodel.ActionDefinition{
  74                                                         OctetString: "5678",
  75                                                 },
  76                                                 SubsequentAction: &clientmodel.SubsequentAction{
  77                                                         SubsequentActionType: &subsequestActioType,
  78                                                         TimeToWait:           &timeToWait,
  79                                                 },
  80                                         },
  81                                 },
  82                         },
  83                 },
  84         }
  85
  86         Subscription.SetResponseCB(func(resp *clientmodel.SubscriptionResponse) {
  87                 assert.Equal(t, len(resp.SubscriptionInstances), 1)
  88                 assert.Equal(t, *resp.SubscriptionInstances[0].XappEventInstanceID, int64(11))
  89                 assert.Equal(t, *resp.SubscriptionInstances[0].E2EventInstanceID, int64(22))
  90         })
  91
  92         _, err := Subscription.Subscribe(&subscriptionParams)
  93         assert.Equal(t, err, nil)
  94 }
  95
  96 func TestSubscriptionWithClientProvidedIdHandling(t *testing.T) {
  97         subscriptionParams := clientmodel.SubscriptionParams{
  98                 SubscriptionID: "myxapp",
  99                 Meid:           &meid,
 100                 RANFunctionID:  &funId,
 101                 ClientEndpoint: &clientEndpoint,
 102                 SubscriptionDetails: clientmodel.SubscriptionDetailsList{
 103                         &clientmodel.SubscriptionDetail{
 104                                 XappEventInstanceID: &eventInstanceId,
 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].XappEventInstanceID, int64(11))
 128                 assert.Equal(t, *resp.SubscriptionInstances[0].E2EventInstanceID, 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         xappInstanceId := int64(11)
 145         e2InstanceId := int64(22)
 146
 147         resp := &models.SubscriptionResponse{
 148                 SubscriptionID: &subscriptionId,
 149                 SubscriptionInstances: []*models.SubscriptionInstance{
 150                         {
 151                                 XappEventInstanceID: &xappInstanceId,
 152                                 E2EventInstanceID:   &e2InstanceId,
 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, xappEventInstanceId, *p.SubscriptionDetails[0].XappEventInstanceID)
 171         assert.Equal(suite, "1234", p.SubscriptionDetails[0].EventTriggers.OctetString)
 172         assert.Equal(suite, actionId, *p.SubscriptionDetails[0].ActionToBeSetupList[0].ActionID)
 173         assert.Equal(suite, actionType, *p.SubscriptionDetails[0].ActionToBeSetupList[0].ActionType)
 174
 175         assert.Equal(suite, subsequestActioType, *p.SubscriptionDetails[0].ActionToBeSetupList[0].SubsequentAction.SubsequentActionType)
 176         assert.Equal(suite, timeToWait, *p.SubscriptionDetails[0].ActionToBeSetupList[0].SubsequentAction.TimeToWait)
 177         assert.Equal(suite, "5678", p.SubscriptionDetails[0].ActionToBeSetupList[0].ActionDefinition.OctetString)
 178
 179         // Generate a unique subscriptionId
 180         subscriptionId = fmt.Sprintf("%s-%s", meid, clientEndpoint.Host)
 181
 182         // Process subscriptions on the background
 183         go processSubscriptions(subscriptionId)
 184
 185         // and send response immediately
 186         return &models.SubscriptionResponse{
 187                 SubscriptionID: &subscriptionId,
 188         }, nil
 189 }
 190
 191 func queryHandler() (models.SubscriptionList, error) {
 192         resp := models.SubscriptionList{
 193                 &models.SubscriptionData{
 194                         SubscriptionID: 11,
 195                         Meid:           "Test-Gnb",
 196                         ClientEndpoint: []string{"127.0.0.1:4056"},
 197                 },
 198         }
 199         return resp, nil
 200 }
 201
 202 func deleteHandler(ep string) error {
 203         assert.Equal(suite, subscriptionId, ep)
 204         return nil
 205 }