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         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 TestSubscriptionDeleteHandling(t *testing.T) {
  96         err := Subscription.Unsubscribe(subscriptionId)
  97         fmt.Println(err)
  98         assert.Equal(t, err, nil)
  99 }
 100
 101 // Helper functions
 102 func processSubscriptions(subscriptionId string) {
 103         // Generate requestorId, instanceId
 104         reqId := int64(11)
 105         instanceId := int64(22)
 106
 107         resp := &models.SubscriptionResponse{
 108                 SubscriptionID: &subscriptionId,
 109                 SubscriptionInstances: []*models.SubscriptionInstance{
 110                         {
 111                                 RequestorID: &reqId,
 112                                 InstanceID: &instanceId,
 113                         },
 114                 },
 115         }
 116
 117         // Notify the client: don't worry about errors ... Notify() will handle retries, etc.
 118         Subscription.Notify(resp, models.SubscriptionParamsClientEndpoint{Host: "localhost", HTTPPort: &hPort, RMRPort: &rPort})
 119 }
 120
 121 func subscriptionHandler(params interface{}) (*models.SubscriptionResponse, error) {
 122         p := params.(*models.SubscriptionParams)
 123
 124         assert.Equal(suite, meid, *p.Meid)
 125         assert.Equal(suite, funId, *p.RANFunctionID)
 126         assert.Equal(suite, clientEndpoint.Host, p.ClientEndpoint.Host)
 127         assert.Equal(suite, clientEndpoint.HTTPPort, p.ClientEndpoint.HTTPPort)
 128         assert.Equal(suite, clientEndpoint.RMRPort, p.ClientEndpoint.RMRPort)
 129
 130         assert.Equal(suite, reqId, *p.SubscriptionDetails[0].RequestorID)
 131         assert.Equal(suite, seqId, *p.SubscriptionDetails[0].InstanceID)
 132         assert.Equal(suite, "1234", p.SubscriptionDetails[0].EventTriggers.OctetString)
 133         assert.Equal(suite, actionId, *p.SubscriptionDetails[0].ActionToBeSetupList[0].ActionID)
 134         assert.Equal(suite, actionType, *p.SubscriptionDetails[0].ActionToBeSetupList[0].ActionType)
 135
 136         assert.Equal(suite, subsequestActioType, *p.SubscriptionDetails[0].ActionToBeSetupList[0].SubsequentAction.SubsequentActionType)
 137         assert.Equal(suite, timeToWait, *p.SubscriptionDetails[0].ActionToBeSetupList[0].SubsequentAction.TimeToWait)
 138         assert.Equal(suite, "5678", p.SubscriptionDetails[0].ActionToBeSetupList[0].ActionDefinition.OctetString)
 139
 140         // Generate a unique subscriptionId
 141         subscriptionId = fmt.Sprintf("%s-%s", meid, clientEndpoint.Host)
 142
 143         // Process subscriptions on the background
 144         go processSubscriptions(subscriptionId)
 145
 146         // and send response immediately
 147         return &models.SubscriptionResponse{
 148                 SubscriptionID: &subscriptionId,
 149         }, nil
 150 }
 151
 152 func queryHandler() (models.SubscriptionList, error) {
 153         resp := models.SubscriptionList{
 154                 &models.SubscriptionData{
 155                         SubscriptionID: 11,
 156                         Meid:           "Test-Gnb",
 157                         ClientEndpoint: []string{"127.0.0.1:4056"},
 158                 },
 159         }
 160         return resp, nil
 161 }
 162
 163 func deleteHandler(ep string) error {
 164         assert.Equal(suite, subscriptionId, ep)
 165         return nil
 166 }