2 ==================================================================================
3 Copyright (c) 2019 Nokia
4 ==================================================================================
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 "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/restapi/operations/common"
20 "github.com/stretchr/testify/assert"
27 xappEventInstanceId = int64(1)
28 eventInstanceId = int64(1)
32 subsequestActioType = "continue"
35 procedureCode = int64(27)
36 typeOfMessage = int64(1)
38 hPort = int64(8086) // See log: "Xapp started, listening on: :8086"
40 clientEndpoint = clientmodel.SubscriptionParamsClientEndpoint{Host: "localhost", HTTPPort: &hPort, RMRPort: &rPort}
44 func TestSetup(t *testing.T) {
47 // Start the server to simulate SubManager
48 go Subscription.Listen(subscriptionHandler, queryHandler, deleteHandler)
49 time.Sleep(time.Duration(2) * time.Second)
52 func TestSubscriptionQueryHandling(t *testing.T) {
53 resp, err := Subscription.QuerySubscriptions()
55 assert.Equal(t, err, nil)
56 assert.Equal(t, resp[0].SubscriptionID, int64(11))
57 assert.Equal(t, resp[0].Meid, "Test-Gnb")
58 assert.Equal(t, resp[0].ClientEndpoint, []string{"127.0.0.1:4056"})
59 <-time.After(1 * time.Second)
62 func TestSubscriptionHandling(t *testing.T) {
63 subscriptionParams := GetSubscriptionparams()
65 Subscription.SetResponseCB(func(resp *clientmodel.SubscriptionResponse) {
66 fmt.Println("TestSubscriptionHandling: notification received")
67 assert.Equal(t, len(resp.SubscriptionInstances), 1)
68 assert.Equal(t, *resp.SubscriptionInstances[0].XappEventInstanceID, int64(11))
69 assert.Equal(t, *resp.SubscriptionInstances[0].E2EventInstanceID, int64(22))
72 _, err := Subscription.Subscribe(subscriptionParams)
73 assert.Equal(t, err, nil)
74 <-time.After(1 * time.Second)
77 func TestSubscriptionWithClientProvidedIdHandling(t *testing.T) {
78 subscriptionParams := GetSubscriptionparams()
79 subscriptionParams.SubscriptionID = "myxapp"
81 Subscription.SetResponseCB(func(resp *clientmodel.SubscriptionResponse) {
82 fmt.Println("TestSubscriptionWithClientProvidedIdHandling: notification received")
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))
88 _, err := Subscription.Subscribe(subscriptionParams)
89 assert.Equal(t, err, nil)
90 <-time.After(1 * time.Second)
93 func TestFailureNotificationHandling(t *testing.T) {
94 subscriptionParams := GetSubscriptionparams()
95 subscriptionParams.SubscriptionID = "send_failure_notification"
97 Subscription.SetResponseCB(func(resp *clientmodel.SubscriptionResponse) {
98 assert.Equal(t, len(resp.SubscriptionInstances), 1)
99 assert.Equal(t, *resp.SubscriptionInstances[0].XappEventInstanceID, int64(11))
100 assert.Equal(t, *resp.SubscriptionInstances[0].E2EventInstanceID, int64(0))
101 assert.Equal(t, resp.SubscriptionInstances[0].ErrorCause, "Some error")
102 assert.Equal(t, resp.SubscriptionInstances[0].ErrorSource, "SUBMGR")
103 assert.Equal(t, resp.SubscriptionInstances[0].TimeoutType, "E2-Timeout")
106 _, err := Subscription.Subscribe(subscriptionParams)
107 assert.Equal(t, err, nil)
108 <-time.After(1 * time.Second)
111 func TestBadRequestSubscriptionHandling(t *testing.T) {
112 subscriptionParams := GetSubscriptionparams()
113 subscriptionParams.SubscriptionID = "send_400_bad_request_response"
115 // Notification is not coming
117 _, err := Subscription.Subscribe(subscriptionParams)
118 assert.Equal(t, err.Error(), "[POST /subscriptions][400] subscribeBadRequest ")
119 fmt.Println("Error:", err)
122 func TestNotFoundRequestSubscriptionHandling(t *testing.T) {
123 subscriptionParams := GetSubscriptionparams()
124 subscriptionParams.SubscriptionID = "send_404_not_found_response"
126 // Notification is not coming
128 _, err := Subscription.Subscribe(subscriptionParams)
129 assert.Equal(t, err.Error(), "[POST /subscriptions][404] subscribeNotFound ")
130 fmt.Println("Error:", err)
133 func TestInternalServerErrorSubscriptionHandling(t *testing.T) {
134 subscriptionParams := GetSubscriptionparams()
135 subscriptionParams.SubscriptionID = "send_500_internal_server_error_response"
137 // Notification is not coming
139 _, err := Subscription.Subscribe(subscriptionParams)
140 assert.Equal(t, err.Error(), "[POST /subscriptions][500] subscribeInternalServerError ")
141 fmt.Println("Error:", err)
144 func TestServiceUnavailableSubscriptionHandling(t *testing.T) {
145 subscriptionParams := GetSubscriptionparams()
146 subscriptionParams.SubscriptionID = "send_503_Service_Unavailable_response"
148 // Notification is not coming
150 _, err := Subscription.Subscribe(subscriptionParams)
151 assert.Equal(t, err.Error(), "[POST /subscriptions][503] subscribeServiceUnavailable ")
152 fmt.Println("Error:", err)
155 func GetSubscriptionparams() *clientmodel.SubscriptionParams {
156 return &clientmodel.SubscriptionParams{
159 RANFunctionID: &funId,
160 ClientEndpoint: &clientEndpoint,
161 SubscriptionDetails: clientmodel.SubscriptionDetailsList{
162 &clientmodel.SubscriptionDetail{
163 XappEventInstanceID: &eventInstanceId,
164 EventTriggers: clientmodel.EventTriggerDefinition{00, 0x11, 0x12, 0x13, 0x00, 0x21, 0x22, 0x24, 0x1B, 0x80},
165 ActionToBeSetupList: clientmodel.ActionsToBeSetup{
166 &clientmodel.ActionToBeSetup{
168 ActionType: &actionType,
169 ActionDefinition: clientmodel.ActionDefinition{5, 6, 7, 8},
170 SubsequentAction: &clientmodel.SubsequentAction{
171 SubsequentActionType: &subsequestActioType,
172 TimeToWait: &timeToWait,
181 func TestSuccessfulSubscriptionDeleteHandling(t *testing.T) {
182 subscriptionId = "send_201_successful_response"
183 err := Subscription.Unsubscribe(subscriptionId)
184 assert.Equal(t, err, nil)
185 fmt.Println("Error:", err)
188 func TestBadRequestSubscriptionDeleteHandling(t *testing.T) {
189 subscriptionId = "send_400_bad_request_response"
190 err := Subscription.Unsubscribe(subscriptionId)
191 assert.NotEqual(t, err, nil)
192 fmt.Println("Error:", err.Error())
193 assert.Equal(t, err.Error(), "[DELETE /subscriptions/{subscriptionId}][400] unsubscribeBadRequest ")
196 func TestInternalServerErrorSubscriptionDeleteHandling(t *testing.T) {
197 subscriptionId = "send_500_internal_server_error_response"
198 err := Subscription.Unsubscribe(subscriptionId)
199 assert.NotEqual(t, err, nil)
200 fmt.Println("Error:", err.Error())
201 assert.Equal(t, err.Error(), "[DELETE /subscriptions/{subscriptionId}][500] unsubscribeInternalServerError ")
204 func TestResponseHandler(t *testing.T) {
205 Subscription.SetResponseCB(SubscriptionRespHandler)
207 payload := []byte(`{"SubscriptionInstances":[{"tXappEventInstanceID": 1}]`)
208 req, err := http.NewRequest("POST", "/ric/v1/subscriptions/response", bytes.NewBuffer(payload))
213 rr := httptest.NewRecorder()
214 handler := http.HandlerFunc(Subscription.ResponseHandler)
215 handler.ServeHTTP(rr, req)
217 if status := rr.Code; status != http.StatusOK {
218 t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusOK)
220 time.Sleep(time.Duration(2) * time.Second)
224 func SubscriptionRespHandler(resp *clientmodel.SubscriptionResponse) {
227 func processSubscriptions(subscriptionId string) {
229 // Generate xappInstanceId
230 xappInstanceId := int64(11)
232 if subscriptionId == "send_failure_notification" {
233 fmt.Println("Sending error notification")
235 // Generate e2InstanceId
236 e2InstanceId := int64(0)
237 resp := &models.SubscriptionResponse{
238 SubscriptionID: &subscriptionId,
239 SubscriptionInstances: []*models.SubscriptionInstance{
241 XappEventInstanceID: &xappInstanceId,
242 E2EventInstanceID: &e2InstanceId,
243 ErrorCause: "Some error",
244 ErrorSource: "SUBMGR",
245 TimeoutType: "E2-Timeout",
250 Subscription.Notify(resp, models.SubscriptionParamsClientEndpoint{Host: "localhost", HTTPPort: &hPort, RMRPort: &rPort})
254 fmt.Println("Sending successful notification")
256 // Generate e2InstanceId
257 e2InstanceId := int64(22)
259 resp := &models.SubscriptionResponse{
260 SubscriptionID: &subscriptionId,
261 SubscriptionInstances: []*models.SubscriptionInstance{
263 XappEventInstanceID: &xappInstanceId,
264 E2EventInstanceID: &e2InstanceId,
269 // Notify the client: don't worry about errors ... Notify() will handle retries, etc.
270 Subscription.Notify(resp, models.SubscriptionParamsClientEndpoint{Host: "localhost", HTTPPort: &hPort, RMRPort: &rPort})
275 func subscriptionHandler(params interface{}) (*models.SubscriptionResponse, int) {
276 p := params.(*models.SubscriptionParams)
278 assert.Equal(suite, meid, *p.Meid)
279 assert.Equal(suite, funId, *p.RANFunctionID)
280 assert.Equal(suite, clientEndpoint.Host, p.ClientEndpoint.Host)
281 assert.Equal(suite, clientEndpoint.HTTPPort, p.ClientEndpoint.HTTPPort)
282 assert.Equal(suite, clientEndpoint.RMRPort, p.ClientEndpoint.RMRPort)
284 assert.Equal(suite, xappEventInstanceId, *p.SubscriptionDetails[0].XappEventInstanceID)
285 et := []int64{00, 0x11, 0x12, 0x13, 0x00, 0x21, 0x22, 0x24, 0x1B, 0x80}
286 assert.ElementsMatch(suite, et, p.SubscriptionDetails[0].EventTriggers)
287 assert.Equal(suite, actionId, *p.SubscriptionDetails[0].ActionToBeSetupList[0].ActionID)
288 assert.Equal(suite, actionType, *p.SubscriptionDetails[0].ActionToBeSetupList[0].ActionType)
290 assert.Equal(suite, subsequestActioType, *p.SubscriptionDetails[0].ActionToBeSetupList[0].SubsequentAction.SubsequentActionType)
291 assert.Equal(suite, timeToWait, *p.SubscriptionDetails[0].ActionToBeSetupList[0].SubsequentAction.TimeToWait)
292 assert.ElementsMatch(suite, []int64{5, 6, 7, 8}, p.SubscriptionDetails[0].ActionToBeSetupList[0].ActionDefinition)
294 if p.SubscriptionID != "send_failure_notification" {
295 // Generate a unique subscriptionId
296 subscriptionId = fmt.Sprintf("%s-%s", meid, clientEndpoint.Host)
298 subscriptionId = "send_failure_notification"
300 if p.SubscriptionID == "send_400_bad_request_response" {
301 fmt.Println("send_400_bad_request_response")
302 return &models.SubscriptionResponse{}, common.SubscribeBadRequestCode
304 if p.SubscriptionID == "send_404_not_found_response" {
305 fmt.Println("send_404_not_found_response")
306 return &models.SubscriptionResponse{}, common.SubscribeNotFoundCode
308 if p.SubscriptionID == "send_500_internal_server_error_response" {
309 fmt.Println("send_500_internal_server_error_response")
310 return &models.SubscriptionResponse{}, common.SubscribeInternalServerErrorCode
312 if p.SubscriptionID == "send_503_Service_Unavailable_response" {
313 fmt.Println("send_503_Service_Unavailable_response")
314 return &models.SubscriptionResponse{}, common.SubscribeServiceUnavailableCode
317 // Process subscriptions on the background
318 go processSubscriptions(subscriptionId)
320 // and send response immediately
321 return &models.SubscriptionResponse{
322 SubscriptionID: &subscriptionId,
323 }, common.SubscribeCreatedCode
326 func queryHandler() (models.SubscriptionList, error) {
327 resp := models.SubscriptionList{
328 &models.SubscriptionData{
331 ClientEndpoint: []string{"127.0.0.1:4056"},
337 func deleteHandler(ep string) int {
338 assert.Equal(suite, subscriptionId, ep)
339 if subscriptionId == "send_201_successful_response" {
340 return common.UnsubscribeNoContentCode
341 } else if subscriptionId == "send_400_bad_request_response" {
342 return common.UnsubscribeBadRequestCode
343 } else if subscriptionId == "send_500_internal_server_error_response" {
344 return common.UnsubscribeInternalServerErrorCode
346 fmt.Println("Unknown subscriptionId:", subscriptionId)