pkg/xapp/subscription_test.go

   1 /*
   2 ==================================================================================
   3   Copyright (c) 2019 Nokia
   4 ==================================================================================
   5 */
   6
   7 package xapp
   8
   9 import (
  10         "bytes"
  11         "fmt"
  12         "net/http"
  13         "net/http/httptest"
  14         "testing"
  15         "time"
  16
  17         "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/clientmodel"
  18         "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/models"
  19         "github.com/stretchr/testify/assert"
  20 )
  21
  22 var (
  23         suite *testing.T
  24
  25         meid                = "gnb123456"
  26         xappEventInstanceId = int64(1)
  27         eventInstanceId     = int64(1)
  28         funId               = int64(1)
  29         actionId            = int64(1)
  30         actionType          = "report"
  31         subsequestActioType = "continue"
  32         timeToWait          = "w10ms"
  33         direction           = int64(0)
  34         procedureCode       = int64(27)
  35         typeOfMessage       = int64(1)
  36         subscriptionId      = ""
  37         hPort               = int64(8080)
  38         rPort               = int64(4560)
  39         clientEndpoint      = clientmodel.SubscriptionParamsClientEndpoint{Host: "localhost", HTTPPort: &hPort, RMRPort: &rPort}
  40 )
  41
  42 // Test cases
  43 func TestSetup(t *testing.T) {
  44         suite = t
  45
  46         // Start the server to simulate SubManager
  47         go Subscription.Listen(subscriptionHandler, queryHandler, deleteHandler)
  48         time.Sleep(time.Duration(2) * time.Second)
  49 }
  50
  51 func TestSubscriptionQueryHandling(t *testing.T) {
  52         resp, err := Subscription.QuerySubscriptions()
  53
  54         assert.Equal(t, err, nil)
  55         assert.Equal(t, resp[0].SubscriptionID, int64(11))
  56         assert.Equal(t, resp[0].Meid, "Test-Gnb")
  57         assert.Equal(t, resp[0].ClientEndpoint, []string{"127.0.0.1:4056"})
  58 }
  59
  60 func TestSubscriptionHandling(t *testing.T) {
  61         subscriptionParams := clientmodel.SubscriptionParams{
  62                 SubscriptionID: "",
  63                 Meid:           &meid,
  64                 RANFunctionID:  &funId,
  65                 ClientEndpoint: &clientEndpoint,
  66                 SubscriptionDetails: clientmodel.SubscriptionDetailsList{
  67                         &clientmodel.SubscriptionDetail{
  68                                 XappEventInstanceID: &eventInstanceId,
  69                                 EventTriggers:       clientmodel.EventTriggerDefinition{00, 0x11, 0x12, 0x13, 0x00, 0x21, 0x22, 0x24, 0x1B, 0x80},
  70                                 ActionToBeSetupList: clientmodel.ActionsToBeSetup{
  71                                         &clientmodel.ActionToBeSetup{
  72                                                 ActionID:         &actionId,
  73                                                 ActionType:       &actionType,
  74                                                 ActionDefinition: clientmodel.ActionDefinition{5, 6, 7, 8},
  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].XappEventInstanceID, int64(11))
  88                 assert.Equal(t, *resp.SubscriptionInstances[0].E2EventInstanceID, 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                 SubscriptionID: "myxapp",
  98                 Meid:           &meid,
  99                 RANFunctionID:  &funId,
 100                 ClientEndpoint: &clientEndpoint,
 101                 SubscriptionDetails: clientmodel.SubscriptionDetailsList{
 102                         &clientmodel.SubscriptionDetail{
 103                                 XappEventInstanceID: &eventInstanceId,
 104                                 EventTriggers:       clientmodel.EventTriggerDefinition{00, 0x11, 0x12, 0x13, 0x00, 0x21, 0x22, 0x24, 0x1B, 0x80},
 105                                 ActionToBeSetupList: clientmodel.ActionsToBeSetup{
 106                                         &clientmodel.ActionToBeSetup{
 107                                                 ActionID:         &actionId,
 108                                                 ActionType:       &actionType,
 109                                                 ActionDefinition: clientmodel.ActionDefinition{5, 6, 7, 8},
 110                                                 SubsequentAction: &clientmodel.SubsequentAction{
 111                                                         SubsequentActionType: &subsequestActioType,
 112                                                         TimeToWait:           &timeToWait,
 113                                                 },
 114                                         },
 115                                 },
 116                         },
 117                 },
 118         }
 119
 120         Subscription.SetResponseCB(func(resp *clientmodel.SubscriptionResponse) {
 121                 assert.Equal(t, len(resp.SubscriptionInstances), 1)
 122                 assert.Equal(t, *resp.SubscriptionInstances[0].XappEventInstanceID, int64(11))
 123                 assert.Equal(t, *resp.SubscriptionInstances[0].E2EventInstanceID, int64(22))
 124         })
 125
 126         _, err := Subscription.Subscribe(&subscriptionParams)
 127         assert.Equal(t, err, nil)
 128 }
 129
 130 func TestSubscriptionDeleteHandling(t *testing.T) {
 131         err := Subscription.Unsubscribe(subscriptionId)
 132         fmt.Println(err)
 133         assert.Equal(t, err, nil)
 134 }
 135
 136 func TestResponseHandler(t *testing.T) {
 137         Subscription.SetResponseCB(SubscriptionRespHandler)
 138
 139         payload := []byte(`{"SubscriptionInstances":[{"tXappEventInstanceID": 1}]`)
 140         req, err := http.NewRequest("POST", "/ric/v1/subscriptions/response", bytes.NewBuffer(payload))
 141         if err != nil {
 142                 t.Fatal(err)
 143         }
 144
 145         rr := httptest.NewRecorder()
 146         handler := http.HandlerFunc(Subscription.ResponseHandler)
 147         handler.ServeHTTP(rr, req)
 148
 149         if status := rr.Code; status != http.StatusOK {
 150                 t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusOK)
 151         }
 152         time.Sleep(time.Duration(2) * time.Second)
 153 }
 154
 155 // Helper functions
 156 func SubscriptionRespHandler(resp *clientmodel.SubscriptionResponse) {
 157 }
 158
 159 func processSubscriptions(subscriptionId string) {
 160         // Generate requestorId, instanceId
 161         xappInstanceId := int64(11)
 162         e2InstanceId := int64(22)
 163
 164         resp := &models.SubscriptionResponse{
 165                 SubscriptionID: &subscriptionId,
 166                 SubscriptionInstances: []*models.SubscriptionInstance{
 167                         {
 168                                 XappEventInstanceID: &xappInstanceId,
 169                                 E2EventInstanceID:   &e2InstanceId,
 170                         },
 171                 },
 172         }
 173
 174         // Notify the client: don't worry about errors ... Notify() will handle retries, etc.
 175         Subscription.Notify(resp, models.SubscriptionParamsClientEndpoint{Host: "localhost", HTTPPort: &hPort, RMRPort: &rPort})
 176 }
 177
 178 func subscriptionHandler(params interface{}) (*models.SubscriptionResponse, error) {
 179         p := params.(*models.SubscriptionParams)
 180
 181         assert.Equal(suite, meid, *p.Meid)
 182         assert.Equal(suite, funId, *p.RANFunctionID)
 183         assert.Equal(suite, clientEndpoint.Host, p.ClientEndpoint.Host)
 184         assert.Equal(suite, clientEndpoint.HTTPPort, p.ClientEndpoint.HTTPPort)
 185         assert.Equal(suite, clientEndpoint.RMRPort, p.ClientEndpoint.RMRPort)
 186
 187         assert.Equal(suite, xappEventInstanceId, *p.SubscriptionDetails[0].XappEventInstanceID)
 188         et := []int64{00, 0x11, 0x12, 0x13, 0x00, 0x21, 0x22, 0x24, 0x1B, 0x80}
 189         assert.ElementsMatch(suite, et, p.SubscriptionDetails[0].EventTriggers)
 190         assert.Equal(suite, actionId, *p.SubscriptionDetails[0].ActionToBeSetupList[0].ActionID)
 191         assert.Equal(suite, actionType, *p.SubscriptionDetails[0].ActionToBeSetupList[0].ActionType)
 192
 193         assert.Equal(suite, subsequestActioType, *p.SubscriptionDetails[0].ActionToBeSetupList[0].SubsequentAction.SubsequentActionType)
 194         assert.Equal(suite, timeToWait, *p.SubscriptionDetails[0].ActionToBeSetupList[0].SubsequentAction.TimeToWait)
 195         assert.ElementsMatch(suite, []int64{5, 6, 7, 8}, p.SubscriptionDetails[0].ActionToBeSetupList[0].ActionDefinition)
 196
 197         // Generate a unique subscriptionId
 198         subscriptionId = fmt.Sprintf("%s-%s", meid, clientEndpoint.Host)
 199
 200         // Process subscriptions on the background
 201         go processSubscriptions(subscriptionId)
 202
 203         // and send response immediately
 204         return &models.SubscriptionResponse{
 205                 SubscriptionID: &subscriptionId,
 206         }, nil
 207 }
 208
 209 func queryHandler() (models.SubscriptionList, error) {
 210         resp := models.SubscriptionList{
 211                 &models.SubscriptionData{
 212                         SubscriptionID: 11,
 213                         Meid:           "Test-Gnb",
 214                         ClientEndpoint: []string{"127.0.0.1:4056"},
 215                 },
 216         }
 217         return resp, nil
 218 }
 219
 220 func deleteHandler(ep string) error {
 221         assert.Equal(suite, subscriptionId, ep)
 222         return nil
 223 }