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{00, 0x11, 0x12, 0x13, 0x00, 0x21, 0x22, 0x24, 0x1B, 0x80},
  67                                 ActionToBeSetupList: clientmodel.ActionsToBeSetup{
  68                                         &clientmodel.ActionToBeSetup{
  69                                                 ActionID:         &actionId,
  70                                                 ActionType:       &actionType,
  71                                                 ActionDefinition: clientmodel.ActionDefinition{5, 6, 7, 8},
  72                                                 SubsequentAction: &clientmodel.SubsequentAction{
  73                                                         SubsequentActionType: &subsequestActioType,
  74                                                         TimeToWait:           &timeToWait,
  75                                                 },
  76                                         },
  77                                 },
  78                         },
  79                 },
  80         }
  81
  82         Subscription.SetResponseCB(func(resp *clientmodel.SubscriptionResponse) {
  83                 assert.Equal(t, len(resp.SubscriptionInstances), 1)
  84                 assert.Equal(t, *resp.SubscriptionInstances[0].XappEventInstanceID, int64(11))
  85                 assert.Equal(t, *resp.SubscriptionInstances[0].E2EventInstanceID, int64(22))
  86         })
  87
  88         _, err := Subscription.Subscribe(&subscriptionParams)
  89         assert.Equal(t, err, nil)
  90 }
  91
  92 func TestSubscriptionWithClientProvidedIdHandling(t *testing.T) {
  93         subscriptionParams := clientmodel.SubscriptionParams{
  94                 SubscriptionID: "myxapp",
  95                 Meid:           &meid,
  96                 RANFunctionID:  &funId,
  97                 ClientEndpoint: &clientEndpoint,
  98                 SubscriptionDetails: clientmodel.SubscriptionDetailsList{
  99                         &clientmodel.SubscriptionDetail{
 100                                 XappEventInstanceID: &eventInstanceId,
 101                                 EventTriggers:       clientmodel.EventTriggerDefinition{00, 0x11, 0x12, 0x13, 0x00, 0x21, 0x22, 0x24, 0x1B, 0x80},
 102                                 ActionToBeSetupList: clientmodel.ActionsToBeSetup{
 103                                         &clientmodel.ActionToBeSetup{
 104                                                 ActionID:         &actionId,
 105                                                 ActionType:       &actionType,
 106                                                 ActionDefinition: clientmodel.ActionDefinition{5, 6, 7, 8},
 107                                                 SubsequentAction: &clientmodel.SubsequentAction{
 108                                                         SubsequentActionType: &subsequestActioType,
 109                                                         TimeToWait:           &timeToWait,
 110                                                 },
 111                                         },
 112                                 },
 113                         },
 114                 },
 115         }
 116
 117         Subscription.SetResponseCB(func(resp *clientmodel.SubscriptionResponse) {
 118                 assert.Equal(t, len(resp.SubscriptionInstances), 1)
 119                 assert.Equal(t, *resp.SubscriptionInstances[0].XappEventInstanceID, int64(11))
 120                 assert.Equal(t, *resp.SubscriptionInstances[0].E2EventInstanceID, int64(22))
 121         })
 122
 123         _, err := Subscription.Subscribe(&subscriptionParams)
 124         assert.Equal(t, err, nil)
 125 }
 126
 127 func TestSubscriptionDeleteHandling(t *testing.T) {
 128         err := Subscription.Unsubscribe(subscriptionId)
 129         fmt.Println(err)
 130         assert.Equal(t, err, nil)
 131 }
 132
 133 // Helper functions
 134 func processSubscriptions(subscriptionId string) {
 135         // Generate requestorId, instanceId
 136         xappInstanceId := int64(11)
 137         e2InstanceId := int64(22)
 138
 139         resp := &models.SubscriptionResponse{
 140                 SubscriptionID: &subscriptionId,
 141                 SubscriptionInstances: []*models.SubscriptionInstance{
 142                         {
 143                                 XappEventInstanceID: &xappInstanceId,
 144                                 E2EventInstanceID:   &e2InstanceId,
 145                         },
 146                 },
 147         }
 148
 149         // Notify the client: don't worry about errors ... Notify() will handle retries, etc.
 150         Subscription.Notify(resp, models.SubscriptionParamsClientEndpoint{Host: "localhost", HTTPPort: &hPort, RMRPort: &rPort})
 151 }
 152
 153 func subscriptionHandler(params interface{}) (*models.SubscriptionResponse, error) {
 154         p := params.(*models.SubscriptionParams)
 155
 156         assert.Equal(suite, meid, *p.Meid)
 157         assert.Equal(suite, funId, *p.RANFunctionID)
 158         assert.Equal(suite, clientEndpoint.Host, p.ClientEndpoint.Host)
 159         assert.Equal(suite, clientEndpoint.HTTPPort, p.ClientEndpoint.HTTPPort)
 160         assert.Equal(suite, clientEndpoint.RMRPort, p.ClientEndpoint.RMRPort)
 161
 162         assert.Equal(suite, xappEventInstanceId, *p.SubscriptionDetails[0].XappEventInstanceID)
 163         et := []int64{00, 0x11, 0x12, 0x13, 0x00, 0x21, 0x22, 0x24, 0x1B, 0x80}
 164         assert.ElementsMatch(suite, et, p.SubscriptionDetails[0].EventTriggers)
 165         assert.Equal(suite, actionId, *p.SubscriptionDetails[0].ActionToBeSetupList[0].ActionID)
 166         assert.Equal(suite, actionType, *p.SubscriptionDetails[0].ActionToBeSetupList[0].ActionType)
 167
 168         assert.Equal(suite, subsequestActioType, *p.SubscriptionDetails[0].ActionToBeSetupList[0].SubsequentAction.SubsequentActionType)
 169         assert.Equal(suite, timeToWait, *p.SubscriptionDetails[0].ActionToBeSetupList[0].SubsequentAction.TimeToWait)
 170         assert.ElementsMatch(suite, []int64{5, 6, 7, 8}, p.SubscriptionDetails[0].ActionToBeSetupList[0].ActionDefinition)
 171
 172         // Generate a unique subscriptionId
 173         subscriptionId = fmt.Sprintf("%s-%s", meid, clientEndpoint.Host)
 174
 175         // Process subscriptions on the background
 176         go processSubscriptions(subscriptionId)
 177
 178         // and send response immediately
 179         return &models.SubscriptionResponse{
 180                 SubscriptionID: &subscriptionId,
 181         }, nil
 182 }
 183
 184 func queryHandler() (models.SubscriptionList, error) {
 185         resp := models.SubscriptionList{
 186                 &models.SubscriptionData{
 187                         SubscriptionID: 11,
 188                         Meid:           "Test-Gnb",
 189                         ClientEndpoint: []string{"127.0.0.1:4056"},
 190                 },
 191         }
 192         return resp, nil
 193 }
 194
 195 func deleteHandler(ep string) error {
 196         assert.Equal(suite, subscriptionId, ep)
 197         return nil
 198 }