2 ==================================================================================
3 Copyright (c) 2019 AT&T Intellectual Property.
4 Copyright (c) 2019 Nokia
6 Licensed under the Apache License, Version 2.0 (the "License");
7 you may not use this file except in compliance with the License.
8 You may obtain a copy of the License at
10 http://www.apache.org/licenses/LICENSE-2.0
12 Unless required by applicable law or agreed to in writing, software
13 distributed under the License is distributed on an "AS IS" BASIS,
14 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 See the License for the specific language governing permissions and
16 limitations under the License.
17 ==================================================================================
28 "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap"
29 "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap_wrapper"
30 "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
31 "gerrit.o-ran-sc.org/r/ric-plt/submgr/pkg/teststube2ap"
32 "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
33 "github.com/stretchr/testify/assert"
36 func TestSuiteSetup(t *testing.T) {
37 // The effect of this call shall endure though the UT suite!
38 // If this causes any issues, the previous interface can be restored
40 // SetPackerIf(e2ap_wrapper.NewAsn1E2APPacker())
42 mainCtrl.InitAllCounterMap()
43 SetPackerIf(e2ap_wrapper.NewUtAsn1E2APPacker())
44 mainCtrl.c.restDuplicateCtrl.Init()
47 func TestRanStatusChangeViaSDLNotification(t *testing.T) {
49 // Current UT test cases use these ran names
50 xappRnibMock.CreateGnb("RAN_NAME_1", entities.ConnectionStatus_DISCONNECTED)
51 xappRnibMock.CreateGnb("RAN_NAME_11", entities.ConnectionStatus_DISCONNECTED)
52 xappRnibMock.CreateGnb("RAN_NAME_2", entities.ConnectionStatus_DISCONNECTED)
54 mainCtrl.c.e2IfState.ReadE2ConfigurationFromRnib()
55 mainCtrl.c.e2IfState.SubscribeChannels()
57 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
58 mainCtrl.SetE2State(t, "RAN_NAME_2_CONNECTED")
59 mainCtrl.SetE2State(t, "RAN_NAME_11_CONNECTED")
62 //-----------------------------------------------------------------------------
63 // TestRESTSubReqAfterE2ConnBreak
66 // +-------+ +---------+ +---------+
67 // | xapp | | submgr | | e2term |
68 // +-------+ +---------+ +---------+
70 // | [E2 Conn. DOWN] |
73 // |---------------->| |
75 // |<----------------| |
78 //-----------------------------------------------------------------------------
80 func TestRESTSubReqAfterE2ConnBreak(t *testing.T) {
81 CaseBegin("TestRESTSubReqAfterE2ConnBreak")
83 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
84 Counter{cRestSubReqFromXapp, 1},
85 Counter{cRestReqRejDueE2Down, 1},
88 // E2 disconnect after E2term has received response
89 mainCtrl.SetE2State(t, "RAN_NAME_1_DISCONNECTED")
91 const subReqCount int = 1
92 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
93 xappConn1.SendRESTSubsReq(t, params)
95 // Restore E2 connection for following test cases
96 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
98 mainCtrl.VerifyCounterValues(t)
102 //-----------------------------------------------------------------------------
103 // TestRESTSubReqE2ConnBreak
106 // +-------+ +---------+ +---------+
107 // | xapp | | submgr | | e2term |
108 // +-------+ +---------+ +---------+
111 // |---------------->| |
113 // |<----------------| |
115 // | |------------->|
117 // | |<-------------|
119 // | [E2 Conn. DOWN] |
120 // | [Int. SUBS DELETE] |
122 // | RESTNotif(unsuccessful) |
123 // |<----------------| |
127 //-----------------------------------------------------------------------------
128 func TestRESTSubReqE2ConnBreak(t *testing.T) {
129 CaseBegin("TestRESTSubReqE2ConnBreak")
131 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
132 Counter{cRestSubReqFromXapp, 1},
133 Counter{cRestSubRespToXapp, 1},
134 Counter{cSubReqToE2, 1},
135 Counter{cSubRespFromE2, 1},
136 Counter{cRestSubFailNotifToXapp, 1},
140 const subReqCount int = 1
141 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
142 restSubId := xappConn1.SendRESTSubsReq(t, params)
144 crereq, cremsg := e2termConn1.RecvSubsReq(t)
145 xappConn1.ExpectRESTNotification(t, restSubId)
147 // E2 disconnect after E2term has received response
148 mainCtrl.SetE2State(t, "RAN_NAME_1_DISCONNECTED")
150 e2termConn1.SendSubsResp(t, crereq, cremsg)
151 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
153 <-time.After(time.Second * 1)
154 assert.Equal(t, 0, len(mainCtrl.c.registry.register))
155 assert.Equal(t, 0, len(mainCtrl.c.registry.restSubscriptions))
157 subIds, register, err := mainCtrl.c.ReadAllSubscriptionsFromSdl()
159 xapp.Logger.Error("%v", err)
161 assert.Equal(t, 65534, len(subIds)) // range 1-65535 , FFFF = 65535
162 assert.Equal(t, 0, len(register))
165 restSubscriptions, err := mainCtrl.c.ReadAllRESTSubscriptionsFromSdl()
167 xapp.Logger.Error("%v", err)
169 assert.Equal(t, 0, len(restSubscriptions))
172 // Restore E2 connection for following test cases
173 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
175 // Wait that subs is cleaned
176 waitSubsCleanup(t, e2SubsId, 10)
177 mainCtrl.VerifyCounterValues(t)
180 //-----------------------------------------------------------------------------
181 // TestRESTSubscriptionDeleteAfterE2ConnectionBreak
184 // +-------+ +---------+ +---------+
185 // | xapp | | submgr | | e2term |
186 // +-------+ +---------+ +---------+
190 // | [E2 Conn. DOWN] |
192 // | RESTSubDelReq | |
193 // |---------------->| |
195 // | RESTSubDelResp | |
196 // |<----------------| |
198 // | [No valid subscription found] |
201 //-----------------------------------------------------------------------------
202 func TestRESTSubscriptionDeleteAfterE2ConnectionBreak(t *testing.T) {
203 xapp.Logger.Debug("TEST: TestRESTSubscriptionDeleteAfterE2ConnectionBreak")
205 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
206 Counter{cRestSubReqFromXapp, 1},
207 Counter{cRestSubRespToXapp, 1},
208 Counter{cSubReqToE2, 1},
209 Counter{cSubRespFromE2, 1},
210 Counter{cRestSubNotifToXapp, 1},
211 Counter{cRestSubDelReqFromXapp, 1},
212 Counter{cRestSubDelRespToXapp, 1},
216 var params *teststube2ap.RESTSubsReqParams = nil
217 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
219 // E2 disconnect after E2term has received response
220 mainCtrl.SetE2State(t, "RAN_NAME_1_DISCONNECTED")
223 xappConn1.SendRESTSubsDelReq(t, &restSubId)
225 <-time.After(time.Second * 1)
226 assert.Equal(t, 0, len(mainCtrl.c.registry.register))
227 assert.Equal(t, 0, len(mainCtrl.c.registry.restSubscriptions))
229 subIds, register, err := mainCtrl.c.ReadAllSubscriptionsFromSdl()
231 xapp.Logger.Error("%v", err)
233 assert.Equal(t, 65534, len(subIds)) // range 1-65535 , FFFF = 65535
234 assert.Equal(t, 0, len(register))
237 restSubscriptions, err := mainCtrl.c.ReadAllRESTSubscriptionsFromSdl()
239 xapp.Logger.Error("%v", err)
241 assert.Equal(t, 0, len(restSubscriptions))
244 // Restore E2 connection for following test cases
245 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
247 // Wait that subs is cleaned
248 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
250 xappConn1.TestMsgChanEmpty(t)
251 e2termConn1.TestMsgChanEmpty(t)
252 mainCtrl.wait_registry_empty(t, 10)
253 mainCtrl.VerifyCounterValues(t)
256 //-----------------------------------------------------------------------------
257 // TestRESTOtherE2ConnectionChanges
261 // +-------+ +---------+ +---------+
262 // | xapp | | submgr | | e2term |
263 // +-------+ +---------+ +---------+
267 // | [E2 CONNECTED_SETUP_FAILED] |
268 // | [E2 CONNECTING] |
269 // | [E2 SHUTTING_DOWN] |
270 // | [E2 SHUT_DOWN] |
275 //-----------------------------------------------------------------------------
276 func TestRESTOtherE2ConnectionChanges(t *testing.T) {
277 xapp.Logger.Debug("TEST: TestRESTOtherE2ConnectionChanges")
279 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
280 Counter{cRestSubReqFromXapp, 1},
281 Counter{cRestSubRespToXapp, 1},
282 Counter{cSubReqToE2, 1},
283 Counter{cSubRespFromE2, 1},
284 Counter{cRestSubNotifToXapp, 1},
285 Counter{cRestSubDelReqFromXapp, 1},
286 Counter{cSubDelReqToE2, 1},
287 Counter{cSubDelRespFromE2, 1},
288 Counter{cRestSubDelRespToXapp, 1},
292 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
293 restSubId := xappConn1.SendRESTSubsReq(t, params)
295 crereq, cremsg := e2termConn1.RecvSubsReq(t)
296 xappConn1.ExpectRESTNotification(t, restSubId)
297 e2termConn1.SendSubsResp(t, crereq, cremsg)
298 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
300 // Submgr should not react any other connection state changes than CONNECTED and DISCONNECTED
301 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED_SETUP_FAILED")
302 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTING")
303 mainCtrl.SetE2State(t, "RAN_NAME_1_SHUTTING_DOWN")
304 mainCtrl.SetE2State(t, "RAN_NAME_1_SHUT_DOWN")
307 xappConn1.SendRESTSubsDelReq(t, &restSubId)
308 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
309 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
311 // Restore E2 connection for following test cases
312 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
314 // Wait that subs is cleaned
315 waitSubsCleanup(t, e2SubsId, 10)
316 mainCtrl.VerifyCounterValues(t)
319 //-----------------------------------------------------------------------------
320 // TestRESTSubReqAndDeleteOkWithE2apUtWrapper
323 // +-------+ +---------+ +---------+ +---------+
324 // | xapp | | submgr | | e2term | | rtmgr |
325 // +-------+ +---------+ +---------+ +---------+
327 // | RESTSubReq | | |
328 // |---------------->| | |
329 // | | RouteCreate | |
330 // | |--------------------------->| // The order of these events may vary
332 // | RESTSubResp | | | // The order of these events may vary
333 // |<----------------| | |
334 // | | RouteResponse| |
335 // | |<---------------------------| // The order of these events may vary
338 // | |------------->| | // The order of these events may vary
341 // | |<-------------| |
342 // | RESTNotif1 | | |
343 // |<----------------| | |
345 // | RESTSubDelReq | | |
346 // |---------------->| | |
348 // | |------------->| |
350 // | RESTSubDelResp| | |
351 // |<----------------| | |
353 // | | SubDelResp | |
354 // | |<-------------| |
358 //-----------------------------------------------------------------------------
359 func TestRESTSubReqAndDeleteOkWithE2apUtWrapper(t *testing.T) {
361 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil)
363 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
365 waitSubsCleanup(t, e2SubsId, 10)
368 //-----------------------------------------------------------------------------
369 // TestRESTSubReqAndE1apDeleteReqPackingError
372 // +-------+ +---------+ +---------+ +---------+
373 // | xapp | | submgr | | e2term | | rtmgr |
374 // +-------+ +---------+ +---------+ +---------+
376 // | RESTSubReq | | |
377 // |---------------->| | |
378 // | | RouteCreate | |
379 // | |--------------------------->| // The order of these events may vary
381 // | RESTSubResp | | | // The order of these events may vary
382 // |<----------------| | |
383 // | | RouteResponse| |
384 // | |<---------------------------| // The order of these events may vary
387 // | |------------->| | // The order of these events may vary
390 // | |<-------------| |
391 // | RESTNotif1 | | |
392 // |<----------------| | |
394 // | RESTSubDelReq | | |
395 // |---------------->| | |
397 // | RESTSubDelResp| | |
398 // |<----------------| | |
402 //-----------------------------------------------------------------------------
403 func TestRESTSubReqAndE1apDeleteReqPackingError(t *testing.T) {
405 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil)
407 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_REQ, false)
408 xappConn1.SendRESTSubsDelReq(t, &restSubId)
409 defer e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_REQ, true)
411 waitSubsCleanup(t, e2SubsId, 10)
414 //-----------------------------------------------------------------------------
415 // TestRESTSubReqAndE1apDeleteRespUnpackingError
418 // +-------+ +---------+ +---------+ +---------+
419 // | xapp | | submgr | | e2term | | rtmgr |
420 // +-------+ +---------+ +---------+ +---------+
422 // | RESTSubReq | | |
423 // |---------------->| | |
424 // | | RouteCreate | |
425 // | |--------------------------->| // The order of these events may vary
427 // | RESTSubResp | | | // The order of these events may vary
428 // |<----------------| | |
429 // | | RouteResponse| |
430 // | |<---------------------------| // The order of these events may vary
433 // | |------------->| | // The order of these events may vary
436 // | |<-------------| |
437 // | RESTNotif1 | | |
438 // |<----------------| | |
440 // | RESTSubDelReq | | |
441 // |---------------->| | |
443 // | |------------->| |
445 // | RESTSubDelResp| | |
446 // |<----------------| | | // The order of these events may vary
448 // | | SubDelResp | |
449 // | |<-------------| | // 1.st NOK
452 // | |------------->| |
454 // | | SubDelResp | |
455 // | |<-------------| | // 2.nd NOK
457 //-----------------------------------------------------------------------------
459 func TestRESTSubReqAndE1apDeleteRespUnpackingError(t *testing.T) {
461 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil)
463 xappConn1.SendRESTSubsDelReq(t, &restSubId)
464 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_RESP, false)
465 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
466 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
468 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
469 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
471 defer e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_RESP, true)
473 waitSubsCleanup(t, e2SubsId, 10)
476 //-----------------------------------------------------------------------------
477 // TestSubReqAndRouteNok
480 // +-------+ +---------+ +---------+
481 // | xapp | | submgr | | rtmgr |
482 // +-------+ +---------+ +---------+
485 // |------------->| |
488 // | |------------->|
492 // | |<-------------|
494 // | [SUBS INT DELETE] |
497 //-----------------------------------------------------------------------------
499 func TestSubReqAndRouteNok(t *testing.T) {
500 CaseBegin("TestSubReqAndRouteNok")
502 // Init counter check
503 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
504 Counter{cSubReqFromXapp, 1},
505 Counter{cRouteCreateFail, 1},
508 waiter := rtmgrHttp.AllocNextEvent(false)
509 newSubsId := mainCtrl.get_registry_next_subid(t)
510 xappConn1.SendSubsReq(t, nil, nil)
513 //Wait that subs is cleaned
514 mainCtrl.wait_subs_clean(t, newSubsId, 10)
516 xappConn1.TestMsgChanEmpty(t)
517 xappConn2.TestMsgChanEmpty(t)
518 e2termConn1.TestMsgChanEmpty(t)
519 mainCtrl.wait_registry_empty(t, 10)
521 <-time.After(1 * time.Second)
522 mainCtrl.VerifyCounterValues(t)
525 //-----------------------------------------------------------------------------
526 // TestSubReqAndRouteUpdateNok
529 // +-------+ +-------+ +---------+ +---------+
530 // | xapp2 | | xapp1 | | submgr | | rtmgr |
531 // +-------+ +-------+ +---------+ +---------+
533 // | [SUBS CREATE] | |
537 // | SubReq (mergeable) | |
538 // |--------------------------->| | |
540 // | | | RouteUpdate |
541 // | | |------------->|
543 // | | | RouteUpdate |
544 // | | | status:400 |
545 // | | |<-------------|
547 // | [SUBS INT DELETE] | |
550 // | [SUBS DELETE] | |
553 func TestSubReqAndRouteUpdateNok(t *testing.T) {
554 CaseBegin("TestSubReqAndRouteUpdateNok")
556 // Init counter check
557 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
558 Counter{cSubReqFromXapp, 2},
559 Counter{cSubReqToE2, 1},
560 Counter{cSubRespFromE2, 1},
561 Counter{cSubRespToXapp, 1},
562 Counter{cRouteCreateUpdateFail, 1},
563 Counter{cSubDelReqFromXapp, 1},
564 Counter{cSubDelReqToE2, 1},
565 Counter{cSubDelRespFromE2, 1},
566 Counter{cSubDelRespToXapp, 1},
569 cretrans := xappConn1.SendSubsReq(t, nil, nil)
570 crereq, cremsg := e2termConn1.RecvSubsReq(t)
571 e2termConn1.SendSubsResp(t, crereq, cremsg)
572 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
574 resp, _ := xapp.Subscription.QuerySubscriptions()
575 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
576 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
577 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
579 waiter := rtmgrHttp.AllocNextEvent(false)
580 newSubsId := mainCtrl.get_registry_next_subid(t)
581 xappConn2.SendSubsReq(t, nil, nil)
584 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
585 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
587 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
588 xappConn1.RecvSubsDelResp(t, deltrans)
590 //Wait that subs is cleaned
591 mainCtrl.wait_subs_clean(t, newSubsId, 10)
592 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
594 xappConn1.TestMsgChanEmpty(t)
595 xappConn2.TestMsgChanEmpty(t)
596 e2termConn1.TestMsgChanEmpty(t)
597 mainCtrl.wait_registry_empty(t, 10)
599 mainCtrl.VerifyCounterValues(t)
602 //-----------------------------------------------------------------------------
603 // TestSubDelReqAndRouteDeleteNok
606 // +-------+ +---------+ +---------+ +---------+
607 // | xapp | | submgr | | e2term | | rtmgr |
608 // +-------+ +---------+ +---------+ +---------+
610 // | [SUBS CREATE] | |
615 // |------------->| | |
617 // | |------------->| |
619 // | |<-------------| |
621 // |<-------------| | |
622 // | | RouteDelete | |
623 // | |---------------------------->|
625 // | | RouteDelete | |
626 // | | status:400 | |
627 // | |<----------------------------|
629 func TestSubDelReqAndRouteDeleteNok(t *testing.T) {
630 CaseBegin("TestSubDelReqAndRouteDeleteNok")
632 // Init counter check
633 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
634 Counter{cSubReqFromXapp, 1},
635 Counter{cSubReqToE2, 1},
636 Counter{cSubRespFromE2, 1},
637 Counter{cSubRespToXapp, 1},
638 Counter{cSubDelReqFromXapp, 1},
639 Counter{cRouteDeleteFail, 1},
640 Counter{cSubDelReqToE2, 1},
641 Counter{cSubDelRespFromE2, 1},
642 Counter{cSubDelRespToXapp, 1},
645 cretrans := xappConn1.SendSubsReq(t, nil, nil)
646 crereq, cremsg := e2termConn1.RecvSubsReq(t)
647 e2termConn1.SendSubsResp(t, crereq, cremsg)
648 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
650 resp, _ := xapp.Subscription.QuerySubscriptions()
651 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
652 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
653 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
655 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
656 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
658 waiter := rtmgrHttp.AllocNextEvent(false)
659 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
662 xappConn1.RecvSubsDelResp(t, deltrans)
664 //Wait that subs is cleaned
665 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
667 xappConn1.TestMsgChanEmpty(t)
668 xappConn2.TestMsgChanEmpty(t)
669 e2termConn1.TestMsgChanEmpty(t)
670 mainCtrl.wait_registry_empty(t, 10)
672 mainCtrl.VerifyCounterValues(t)
675 //-----------------------------------------------------------------------------
676 // TestSubMergeDelAndRouteUpdateNok
678 // +-------+ +-------+ +---------+ +---------+
679 // | xapp2 | | xapp1 | | submgr | | e2term |
680 // +-------+ +-------+ +---------+ +---------+
685 // | |------------->| |
688 // | | |------------->|
690 // | | |<-------------|
692 // | |<-------------| |
695 // |--------------------------->| |
698 // |<---------------------------| |
700 // | | SubDelReq 1 | |
701 // | |------------->| |
702 // | | | RouteUpdate |
703 // | | |-----> rtmgr |
705 // | | | RouteUpdate |
706 // | | | status:400 |
707 // | | |<----- rtmgr |
709 // | | SubDelResp 1 | |
710 // | |<-------------| |
713 // |--------------------------->| |
715 // | | | SubDelReq 2 |
716 // | | |------------->|
718 // | | | SubDelReq 2 |
719 // | | |------------->|
721 // | SubDelResp 2 | |
722 // |<---------------------------| |
724 //-----------------------------------------------------------------------------
725 func TestSubMergeDelAndRouteUpdateNok(t *testing.T) {
726 CaseBegin("TestSubMergeDelAndRouteUpdateNok")
728 // Init counter check
729 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
730 Counter{cSubReqFromXapp, 2},
731 Counter{cMergedSubscriptions, 1},
732 Counter{cSubReqToE2, 1},
733 Counter{cSubRespFromE2, 1},
734 Counter{cSubRespToXapp, 2},
735 Counter{cSubDelReqFromXapp, 2},
736 Counter{cRouteDeleteUpdateFail, 1},
737 Counter{cSubDelReqToE2, 1},
738 Counter{cSubDelRespFromE2, 1},
739 Counter{cSubDelRespToXapp, 2},
740 Counter{cUnmergedSubscriptions, 1},
744 rparams1 := &teststube2ap.E2StubSubsReqParams{}
746 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
747 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
748 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
749 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
752 rparams2 := &teststube2ap.E2StubSubsReqParams{}
754 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
755 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
757 resp, _ := xapp.Subscription.QuerySubscriptions()
758 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
759 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
760 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
763 waiter := rtmgrHttp.AllocNextEvent(false)
764 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
767 xappConn1.RecvSubsDelResp(t, deltrans1)
770 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
771 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
772 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
773 xappConn2.RecvSubsDelResp(t, deltrans2)
774 //Wait that subs is cleaned
775 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
777 xappConn1.TestMsgChanEmpty(t)
778 xappConn2.TestMsgChanEmpty(t)
779 e2termConn1.TestMsgChanEmpty(t)
780 mainCtrl.wait_registry_empty(t, 10)
782 mainCtrl.VerifyCounterValues(t)
785 //-----------------------------------------------------------------------------
787 //-----------------------------------------------------------------------------
788 // TestSubReqAndSubDelOk
791 // +-------+ +---------+ +---------+
792 // | xapp | | submgr | | e2term |
793 // +-------+ +---------+ +---------+
796 // |------------->| |
799 // | |------------->|
802 // | |<-------------|
805 // |<-------------| |
809 // |------------->| |
812 // | |------------->|
815 // | |<-------------|
818 // |<-------------| |
820 //-----------------------------------------------------------------------------
821 func TestSubReqAndSubDelOk(t *testing.T) {
822 CaseBegin("TestSubReqAndSubDelOk")
824 // Init counter check
825 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
826 Counter{cSubReqFromXapp, 1},
827 Counter{cSubReqToE2, 1},
828 Counter{cSubRespFromE2, 1},
829 Counter{cSubRespToXapp, 1},
830 Counter{cSubDelReqFromXapp, 1},
831 Counter{cSubDelReqToE2, 1},
832 Counter{cSubDelRespFromE2, 1},
833 Counter{cSubDelRespToXapp, 1},
836 cretrans := xappConn1.SendSubsReq(t, nil, nil)
837 crereq, cremsg := e2termConn1.RecvSubsReq(t)
838 e2termConn1.SendSubsResp(t, crereq, cremsg)
839 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
841 resp, _ := xapp.Subscription.QuerySubscriptions()
842 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
843 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
844 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
846 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
847 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
849 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
850 xappConn1.RecvSubsDelResp(t, deltrans)
852 //Wait that subs is cleaned
853 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
855 xappConn1.TestMsgChanEmpty(t)
856 xappConn2.TestMsgChanEmpty(t)
857 e2termConn1.TestMsgChanEmpty(t)
858 mainCtrl.wait_registry_empty(t, 10)
860 mainCtrl.VerifyCounterValues(t)
863 //-----------------------------------------------------------------------------
864 // TestSubReqRetransmission
867 // +-------+ +---------+ +---------+
868 // | xapp | | submgr | | e2term |
869 // +-------+ +---------+ +---------+
872 // |------------->| |
875 // | |------------->|
879 // |------------->| |
882 // | |<-------------|
885 // |<-------------| |
890 //-----------------------------------------------------------------------------
891 func TestSubReqRetransmission(t *testing.T) {
892 CaseBegin("TestSubReqRetransmission")
895 cretrans := xappConn1.SendSubsReq(t, nil, nil)
896 crereq, cremsg := e2termConn1.RecvSubsReq(t)
898 seqBef := mainCtrl.get_msgcounter(t)
899 xappConn1.SendSubsReq(t, nil, cretrans) //Retransmitted SubReq
900 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
902 // hack as there is no real way to see has message be handled.
903 // Previuos counter check just tells that is has been received by submgr
904 // --> artificial delay
905 <-time.After(1 * time.Second)
906 e2termConn1.SendSubsResp(t, crereq, cremsg)
907 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
910 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
911 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
912 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
913 xappConn1.RecvSubsDelResp(t, deltrans)
915 //Wait that subs is cleaned
916 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
918 xappConn1.TestMsgChanEmpty(t)
919 xappConn2.TestMsgChanEmpty(t)
920 e2termConn1.TestMsgChanEmpty(t)
921 mainCtrl.wait_registry_empty(t, 10)
924 //-----------------------------------------------------------------------------
925 // TestSubDelReqRetransmission
928 // +-------+ +---------+ +---------+
929 // | xapp | | submgr | | e2term |
930 // +-------+ +---------+ +---------+
936 // |------------->| |
939 // | |------------->|
944 // |------------->| |
947 // | |<-------------|
950 // |<-------------| |
952 //-----------------------------------------------------------------------------
953 func TestSubDelReqRetransmission(t *testing.T) {
954 CaseBegin("TestSubDelReqRetransmission")
957 cretrans := xappConn1.SendSubsReq(t, nil, nil)
958 crereq, cremsg := e2termConn1.RecvSubsReq(t)
959 e2termConn1.SendSubsResp(t, crereq, cremsg)
960 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
963 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
964 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
966 seqBef := mainCtrl.get_msgcounter(t)
967 xappConn1.SendSubsDelReq(t, deltrans, e2SubsId) //Retransmitted SubDelReq
968 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
970 // hack as there is no real way to see has message be handled.
971 // Previuos counter check just tells that is has been received by submgr
972 // --> artificial delay
973 <-time.After(1 * time.Second)
975 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
976 xappConn1.RecvSubsDelResp(t, deltrans)
978 //Wait that subs is cleaned
979 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
981 xappConn1.TestMsgChanEmpty(t)
982 xappConn2.TestMsgChanEmpty(t)
983 e2termConn1.TestMsgChanEmpty(t)
984 mainCtrl.wait_registry_empty(t, 10)
987 //-----------------------------------------------------------------------------
988 // TestSubDelReqCollision
991 // +-------+ +---------+ +---------+
992 // | xapp | | submgr | | e2term |
993 // +-------+ +---------+ +---------+
999 // |------------->| |
1001 // | | SubDelReq 1 |
1002 // | |------------->|
1004 // | SubDelReq 2 | |
1007 // |------------->| |
1009 // | | SubDelResp 1 |
1010 // | |<-------------|
1012 // | SubDelResp 1 | |
1013 // |<-------------| |
1015 // | SubDelResp 2 | |
1016 // |<-------------| |
1018 //-----------------------------------------------------------------------------
1020 func TestSubDelReqCollision(t *testing.T) {
1021 CaseBegin("TestSubDelReqCollision")
1024 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1025 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1026 e2termConn1.SendSubsResp(t, crereq, cremsg)
1027 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1030 xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1031 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1033 // Subs Delete colliding
1034 seqBef := mainCtrl.get_msgcounter(t)
1035 deltranscol2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1036 xappConn1.SendSubsDelReq(t, deltranscol2, e2SubsId) //Colliding SubDelReq
1037 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
1039 // hack as there is no real way to see has message be handled.
1040 // Previuos counter check just tells that is has been received by submgr
1041 // --> artificial delay
1042 <-time.After(1 * time.Second)
1044 // Del resp for first and second
1045 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1047 // don't care in which order responses are received
1048 xappConn1.RecvSubsDelResp(t, nil)
1049 xappConn1.RecvSubsDelResp(t, nil)
1051 //Wait that subs is cleaned
1052 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1054 xappConn1.TestMsgChanEmpty(t)
1055 xappConn2.TestMsgChanEmpty(t)
1056 e2termConn1.TestMsgChanEmpty(t)
1057 mainCtrl.wait_registry_empty(t, 10)
1060 //-----------------------------------------------------------------------------
1061 // TestSubReqAndSubDelOkTwoParallel
1064 // +-------+ +-------+ +---------+ +---------+
1065 // | xapp | | xapp | | submgr | | e2term |
1066 // +-------+ +-------+ +---------+ +---------+
1071 // | |------------->| |
1074 // | | |------------->|
1077 // |------------------------>| |
1080 // | | |------------->|
1083 // | | |<-------------|
1085 // | |<-------------| |
1088 // | | |<-------------|
1090 // |<------------------------| |
1092 // | | [SUBS 1 DELETE] |
1094 // | | [SUBS 2 DELETE] |
1097 //-----------------------------------------------------------------------------
1099 func TestSubReqAndSubDelOkTwoParallel(t *testing.T) {
1100 CaseBegin("TestSubReqAndSubDelOkTwoParallel")
1103 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1105 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1106 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1109 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1112 rparams2.Req.EventTriggerDefinition.Data.Length = 1
1113 rparams2.Req.EventTriggerDefinition.Data.Data = make([]uint8, rparams2.Req.EventTriggerDefinition.Data.Length)
1114 rparams2.Req.EventTriggerDefinition.Data.Data[0] = 2
1116 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1117 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
1120 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1121 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1124 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
1125 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1128 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1129 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1130 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1131 xappConn1.RecvSubsDelResp(t, deltrans1)
1132 //Wait that subs is cleaned
1133 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1136 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1137 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1138 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1139 xappConn2.RecvSubsDelResp(t, deltrans2)
1140 //Wait that subs is cleaned
1141 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1143 xappConn1.TestMsgChanEmpty(t)
1144 xappConn2.TestMsgChanEmpty(t)
1145 e2termConn1.TestMsgChanEmpty(t)
1146 mainCtrl.wait_registry_empty(t, 10)
1149 //-----------------------------------------------------------------------------
1150 // TestSameSubsDiffRan
1151 // Same subscription to different RANs
1154 // +-------+ +---------+ +---------+
1155 // | xapp | | submgr | | e2term |
1156 // +-------+ +---------+ +---------+
1161 // |------------->| |
1164 // | |------------->|
1166 // | | SubResp(r1) |
1167 // | |<-------------|
1169 // | SubResp(r1) | |
1170 // |<-------------| |
1173 // |------------->| |
1176 // | |------------->|
1178 // | | SubResp(r2) |
1179 // | |<-------------|
1181 // | SubResp(r2) | |
1182 // |<-------------| |
1184 // | [SUBS r1 DELETE] |
1186 // | [SUBS r2 DELETE] |
1189 //-----------------------------------------------------------------------------
1190 func TestSameSubsDiffRan(t *testing.T) {
1191 CaseBegin("TestSameSubsDiffRan")
1194 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1195 xappConn1.SendSubsReq(t, nil, cretrans1)
1196 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1197 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1198 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1201 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
1202 xappConn1.SendSubsReq(t, nil, cretrans2)
1203 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
1204 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
1205 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
1208 deltrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1209 xappConn1.SendSubsDelReq(t, deltrans1, e2SubsId1)
1210 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1211 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1212 xappConn1.RecvSubsDelResp(t, deltrans1)
1213 //Wait that subs is cleaned
1214 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1217 deltrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
1218 xappConn1.SendSubsDelReq(t, deltrans2, e2SubsId2)
1219 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1220 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1221 xappConn1.RecvSubsDelResp(t, deltrans2)
1222 //Wait that subs is cleaned
1223 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1225 xappConn1.TestMsgChanEmpty(t)
1226 xappConn2.TestMsgChanEmpty(t)
1227 e2termConn1.TestMsgChanEmpty(t)
1228 mainCtrl.wait_registry_empty(t, 10)
1231 //-----------------------------------------------------------------------------
1232 // TestSubReqRetryInSubmgr
1235 // +-------+ +---------+ +---------+
1236 // | xapp | | submgr | | e2term |
1237 // +-------+ +---------+ +---------+
1240 // |------------->| |
1243 // | |------------->|
1247 // | |------------->|
1250 // | |<-------------|
1253 // |<-------------| |
1255 // | [SUBS DELETE] |
1258 //-----------------------------------------------------------------------------
1260 func TestSubReqRetryInSubmgr(t *testing.T) {
1261 CaseBegin("TestSubReqRetryInSubmgr start")
1263 // Init counter check
1264 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1265 Counter{cSubReqFromXapp, 1},
1266 Counter{cSubReqToE2, 1},
1267 Counter{cSubReqTimerExpiry, 1},
1268 Counter{cSubReReqToE2, 1},
1269 Counter{cSubRespFromE2, 1},
1270 Counter{cSubRespToXapp, 1},
1271 Counter{cSubDelReqFromXapp, 1},
1272 Counter{cSubDelReqToE2, 1},
1273 Counter{cSubDelRespFromE2, 1},
1274 Counter{cSubDelRespToXapp, 1},
1277 // Xapp: Send SubsReq
1278 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1280 // E2t: Receive 1st SubsReq
1281 e2termConn1.RecvSubsReq(t)
1283 // E2t: Receive 2nd SubsReq and send SubsResp
1284 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1285 e2termConn1.SendSubsResp(t, crereq, cremsg)
1287 // Xapp: Receive SubsResp
1288 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1290 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1291 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1292 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1293 xappConn1.RecvSubsDelResp(t, deltrans)
1295 // Wait that subs is cleaned
1296 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1298 xappConn1.TestMsgChanEmpty(t)
1299 xappConn2.TestMsgChanEmpty(t)
1300 e2termConn1.TestMsgChanEmpty(t)
1301 mainCtrl.wait_registry_empty(t, 10)
1303 mainCtrl.VerifyCounterValues(t)
1306 //-----------------------------------------------------------------------------
1307 // TestSubReqTwoRetriesNoRespSubDelRespInSubmgr
1310 // +-------+ +---------+ +---------+
1311 // | xapp | | submgr | | e2term |
1312 // +-------+ +---------+ +---------+
1315 // |------------->| |
1318 // | |------------->|
1322 // | |------------->|
1325 // | |------------->|
1328 // | |<-------------|
1331 //-----------------------------------------------------------------------------
1332 func TestSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
1333 CaseBegin("TestSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
1335 // Init counter check
1336 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1337 Counter{cSubReqFromXapp, 1},
1338 Counter{cSubReqToE2, 1},
1339 Counter{cSubReReqToE2, 1},
1340 Counter{cSubReqTimerExpiry, 2},
1341 Counter{cSubDelReqToE2, 1},
1342 Counter{cSubDelRespFromE2, 1},
1345 // Xapp: Send SubsReq
1346 xappConn1.SendSubsReq(t, nil, nil)
1348 // E2t: Receive 1st SubsReq
1349 e2termConn1.RecvSubsReq(t)
1351 // E2t: Receive 2nd SubsReq
1352 e2termConn1.RecvSubsReq(t)
1354 // E2t: Send receive SubsDelReq and send SubsResp
1355 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1356 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1358 // Wait that subs is cleaned
1359 mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 10)
1361 xappConn1.TestMsgChanEmpty(t)
1362 xappConn2.TestMsgChanEmpty(t)
1363 e2termConn1.TestMsgChanEmpty(t)
1364 mainCtrl.wait_registry_empty(t, 10)
1366 mainCtrl.VerifyCounterValues(t)
1369 //-----------------------------------------------------------------------------
1370 // TestSubReqTwoRetriesNoRespAtAllInSubmgr
1373 // +-------+ +---------+ +---------+
1374 // | xapp | | submgr | | e2term |
1375 // +-------+ +---------+ +---------+
1378 // |------------->| |
1381 // | |------------->|
1385 // | |------------->|
1388 // | |------------->|
1392 // | |------------->|
1396 //-----------------------------------------------------------------------------
1398 func TestSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
1399 CaseBegin("TestSubReqTwoRetriesNoRespAtAllInSubmgr start")
1401 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1402 Counter{cSubReqFromXapp, 1},
1403 Counter{cSubReqToE2, 1},
1404 Counter{cSubReReqToE2, 1},
1405 Counter{cSubReqTimerExpiry, 2},
1406 Counter{cSubDelReqToE2, 1},
1407 Counter{cSubDelReReqToE2, 1},
1408 Counter{cSubDelReqTimerExpiry, 2},
1411 // Xapp: Send SubsReq
1412 xappConn1.SendSubsReq(t, nil, nil)
1414 // E2t: Receive 1st SubsReq
1415 e2termConn1.RecvSubsReq(t)
1417 // E2t: Receive 2nd SubsReq
1418 e2termConn1.RecvSubsReq(t)
1420 // E2t: Receive 1st SubsDelReq
1421 e2termConn1.RecvSubsDelReq(t)
1423 // E2t: Receive 2nd SubsDelReq
1424 delreq, _ := e2termConn1.RecvSubsDelReq(t)
1426 // Wait that subs is cleaned
1427 mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 15)
1429 xappConn1.TestMsgChanEmpty(t)
1430 xappConn2.TestMsgChanEmpty(t)
1431 e2termConn1.TestMsgChanEmpty(t)
1432 mainCtrl.wait_registry_empty(t, 10)
1434 mainCtrl.VerifyCounterValues(t)
1437 //-----------------------------------------------------------------------------
1438 // TestSubReqSubFailRespInSubmgr
1441 // +-------+ +---------+ +---------+
1442 // | xapp | | submgr | | e2term |
1443 // +-------+ +---------+ +---------+
1446 // |------------->| |
1449 // | |------------->|
1452 // | |<-------------|
1455 // |<-------------| |
1458 //-----------------------------------------------------------------------------
1460 func TestSubReqSubFailRespInSubmgr(t *testing.T) {
1461 CaseBegin("TestSubReqSubFailRespInSubmgr start")
1463 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1464 Counter{cSubReqFromXapp, 1},
1465 Counter{cSubReqToE2, 1},
1466 Counter{cSubFailFromE2, 1},
1467 Counter{cSubFailToXapp, 1},
1470 // Xapp: Send SubsReq
1471 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1473 // E2t: Receive SubsReq and send SubsFail (first)
1474 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1475 fparams1 := &teststube2ap.E2StubSubsFailParams{}
1476 fparams1.Set(crereq1)
1477 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
1479 // Xapp: Receive SubsFail
1480 e2SubsId := xappConn1.RecvSubsFail(t, cretrans)
1482 // Wait that subs is cleaned
1483 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1485 xappConn1.TestMsgChanEmpty(t)
1486 xappConn2.TestMsgChanEmpty(t)
1487 e2termConn1.TestMsgChanEmpty(t)
1488 mainCtrl.wait_registry_empty(t, 10)
1490 mainCtrl.VerifyCounterValues(t)
1493 //-----------------------------------------------------------------------------
1494 // TestSubDelReqRetryInSubmgr
1497 // +-------+ +---------+ +---------+
1498 // | xapp | | submgr | | e2term |
1499 // +-------+ +---------+ +---------+
1501 // | [SUBS CREATE] |
1505 // |------------->| |
1508 // | |------------->|
1511 // | |------------->|
1514 // | |<-------------|
1517 // |<-------------| |
1519 //-----------------------------------------------------------------------------
1521 func TestSubDelReqRetryInSubmgr(t *testing.T) {
1523 CaseBegin("TestSubDelReqRetryInSubmgr start")
1526 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1527 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1528 e2termConn1.SendSubsResp(t, crereq, cremsg)
1529 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1532 // Xapp: Send SubsDelReq
1533 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1535 // E2t: Receive 1st SubsDelReq
1536 e2termConn1.RecvSubsDelReq(t)
1538 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
1539 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1540 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1542 // Xapp: Receive SubsDelResp
1543 xappConn1.RecvSubsDelResp(t, deltrans)
1545 // Wait that subs is cleaned
1546 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1548 xappConn1.TestMsgChanEmpty(t)
1549 xappConn2.TestMsgChanEmpty(t)
1550 e2termConn1.TestMsgChanEmpty(t)
1551 mainCtrl.wait_registry_empty(t, 10)
1554 //-----------------------------------------------------------------------------
1555 // TestSubDelReqTwoRetriesNoRespInSubmgr
1558 // +-------+ +---------+ +---------+
1559 // | xapp | | submgr | | e2term |
1560 // +-------+ +---------+ +---------+
1562 // | [SUBS CREATE] |
1566 // |------------->| |
1569 // | |------------->|
1572 // | |------------->|
1576 // |<-------------| |
1578 //-----------------------------------------------------------------------------
1580 func TestSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
1582 CaseBegin("TestSubDelReTwoRetriesNoRespInSubmgr start")
1585 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1586 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1587 e2termConn1.SendSubsResp(t, crereq, cremsg)
1588 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1591 // Xapp: Send SubsDelReq
1592 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1594 // E2t: Receive 1st SubsDelReq
1595 e2termConn1.RecvSubsDelReq(t)
1597 // E2t: Receive 2nd SubsDelReq
1598 e2termConn1.RecvSubsDelReq(t)
1600 // Xapp: Receive SubsDelResp
1601 xappConn1.RecvSubsDelResp(t, deltrans)
1603 // Wait that subs is cleaned
1604 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1606 xappConn1.TestMsgChanEmpty(t)
1607 xappConn2.TestMsgChanEmpty(t)
1608 e2termConn1.TestMsgChanEmpty(t)
1609 mainCtrl.wait_registry_empty(t, 10)
1612 //-----------------------------------------------------------------------------
1613 // TestSubDelReqSubDelFailRespInSubmgr
1616 // +-------+ +---------+ +---------+
1617 // | xapp | | submgr | | e2term |
1618 // +-------+ +---------+ +---------+
1620 // | [SUBS CREATE] |
1624 // |------------->| |
1627 // | |------------->|
1630 // | |<-------------|
1633 // |<-------------| |
1636 //-----------------------------------------------------------------------------
1638 func TestSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
1639 CaseBegin("TestSubReqSubDelFailRespInSubmgr start")
1641 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1642 Counter{cSubReqFromXapp, 1},
1643 Counter{cSubReqToE2, 1},
1644 Counter{cSubRespFromE2, 1},
1645 Counter{cSubRespToXapp, 1},
1646 Counter{cSubDelReqFromXapp, 1},
1647 Counter{cSubDelReqToE2, 1},
1648 Counter{cSubDelFailFromE2, 1},
1649 Counter{cSubDelRespToXapp, 1},
1653 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1654 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1655 e2termConn1.SendSubsResp(t, crereq, cremsg)
1656 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1658 // Xapp: Send SubsDelReq
1659 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1661 // E2t: Send receive SubsDelReq and send SubsDelFail
1662 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1663 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
1665 // Xapp: Receive SubsDelResp
1666 xappConn1.RecvSubsDelResp(t, deltrans)
1668 // Wait that subs is cleaned
1669 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1671 xappConn1.TestMsgChanEmpty(t)
1672 xappConn2.TestMsgChanEmpty(t)
1673 e2termConn1.TestMsgChanEmpty(t)
1674 mainCtrl.wait_registry_empty(t, 10)
1676 mainCtrl.VerifyCounterValues(t)
1679 //-----------------------------------------------------------------------------
1680 // TestSubReqAndSubDelOkSameAction
1683 // +-------+ +-------+ +---------+ +---------+
1684 // | xapp2 | | xapp1 | | submgr | | e2term |
1685 // +-------+ +-------+ +---------+ +---------+
1690 // | |------------->| |
1693 // | | |------------->|
1695 // | | |<-------------|
1697 // | |<-------------| |
1700 // |--------------------------->| |
1703 // |<---------------------------| |
1705 // | | SubDelReq 1 | |
1706 // | |------------->| |
1708 // | | SubDelResp 1 | |
1709 // | |<-------------| |
1711 // | SubDelReq 2 | |
1712 // |--------------------------->| |
1714 // | | | SubDelReq 2 |
1715 // | | |------------->|
1717 // | | | SubDelReq 2 |
1718 // | | |------------->|
1720 // | SubDelResp 2 | |
1721 // |<---------------------------| |
1723 //-----------------------------------------------------------------------------
1724 func TestSubReqAndSubDelOkSameAction(t *testing.T) {
1725 CaseBegin("TestSubReqAndSubDelOkSameAction")
1727 // Init counter check
1728 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1729 Counter{cSubReqFromXapp, 2},
1730 Counter{cSubReqToE2, 1},
1731 Counter{cSubRespFromE2, 1},
1732 Counter{cSubRespToXapp, 2},
1733 Counter{cMergedSubscriptions, 1},
1734 Counter{cUnmergedSubscriptions, 1},
1735 Counter{cSubDelReqFromXapp, 2},
1736 Counter{cSubDelReqToE2, 1},
1737 Counter{cSubDelRespFromE2, 1},
1738 Counter{cSubDelRespToXapp, 2},
1742 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1744 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1745 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1746 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1747 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1750 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1752 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1753 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1755 resp, _ := xapp.Subscription.QuerySubscriptions()
1756 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
1757 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
1758 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
1761 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1762 xappConn1.RecvSubsDelResp(t, deltrans1)
1765 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1766 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1767 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1768 xappConn2.RecvSubsDelResp(t, deltrans2)
1769 //Wait that subs is cleaned
1770 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1772 xappConn1.TestMsgChanEmpty(t)
1773 xappConn2.TestMsgChanEmpty(t)
1774 e2termConn1.TestMsgChanEmpty(t)
1775 mainCtrl.wait_registry_empty(t, 10)
1777 mainCtrl.VerifyCounterValues(t)
1780 //-----------------------------------------------------------------------------
1781 // TestSubReqAndSubDelOkSameActionParallel
1784 // +-------+ +-------+ +---------+ +---------+
1785 // | xapp2 | | xapp1 | | submgr | | e2term |
1786 // +-------+ +-------+ +---------+ +---------+
1791 // | |------------->| |
1794 // | | |------------->|
1796 // |--------------------------->| |
1798 // | | |<-------------|
1800 // | |<-------------| |
1803 // |<---------------------------| |
1805 // | | SubDelReq 1 | |
1806 // | |------------->| |
1808 // | | SubDelResp 1 | |
1809 // | |<-------------| |
1811 // | SubDelReq 2 | |
1812 // |--------------------------->| |
1814 // | | | SubDelReq 2 |
1815 // | | |------------->|
1817 // | | | SubDelReq 2 |
1818 // | | |------------->|
1820 // | SubDelResp 2 | |
1821 // |<---------------------------| |
1823 //-----------------------------------------------------------------------------
1824 func TestSubReqAndSubDelOkSameActionParallel(t *testing.T) {
1825 CaseBegin("TestSubReqAndSubDelOkSameActionParallel")
1828 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1830 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1831 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1834 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1836 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1839 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1840 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1843 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1846 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1847 xappConn1.RecvSubsDelResp(t, deltrans1)
1850 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1851 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1852 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1853 xappConn2.RecvSubsDelResp(t, deltrans2)
1855 //Wait that subs is cleaned
1856 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1858 xappConn1.TestMsgChanEmpty(t)
1859 xappConn2.TestMsgChanEmpty(t)
1860 e2termConn1.TestMsgChanEmpty(t)
1861 mainCtrl.wait_registry_empty(t, 10)
1864 //-----------------------------------------------------------------------------
1865 // TestSubReqAndSubDelNokSameActionParallel
1868 // +-------+ +-------+ +---------+ +---------+
1869 // | xapp2 | | xapp1 | | submgr | | e2term |
1870 // +-------+ +-------+ +---------+ +---------+
1875 // | |------------->| |
1878 // | | |------------->|
1880 // |--------------------------->| |
1882 // | | |<-------------|
1885 // | |<-------------| |
1888 // |<---------------------------| |
1890 //-----------------------------------------------------------------------------
1891 func TestSubReqAndSubDelNokSameActionParallel(t *testing.T) {
1892 CaseBegin("TestSubReqAndSubDelNokSameActionParallel")
1895 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1897 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1899 // E2t: Receive SubsReq (first)
1900 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1903 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1905 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
1906 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1907 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
1909 // E2t: send SubsFail (first)
1910 fparams1 := &teststube2ap.E2StubSubsFailParams{}
1911 fparams1.Set(crereq1)
1912 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
1915 e2SubsId1 := xappConn1.RecvSubsFail(t, cretrans1)
1917 xappConn2.RecvSubsFail(t, cretrans2)
1919 //Wait that subs is cleaned
1920 mainCtrl.wait_subs_clean(t, e2SubsId1, 15)
1922 xappConn1.TestMsgChanEmpty(t)
1923 xappConn2.TestMsgChanEmpty(t)
1924 e2termConn1.TestMsgChanEmpty(t)
1925 mainCtrl.wait_registry_empty(t, 10)
1928 //-----------------------------------------------------------------------------
1929 // TestSubReqAndSubDelNoAnswerSameActionParallel
1932 // +-------+ +-------+ +---------+ +---------+
1933 // | xapp2 | | xapp1 | | submgr | | e2term |
1934 // +-------+ +-------+ +---------+ +---------+
1939 // | |------------->| |
1942 // | | |------------->|
1944 // |--------------------------->| |
1947 // | | |------------->|
1950 // | | | SubDelReq |
1951 // | | |------------->|
1953 // | | | SubDelResp |
1954 // | | |<-------------|
1956 //-----------------------------------------------------------------------------
1957 func TestSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
1958 CaseBegin("TestSubReqAndSubDelNoAnswerSameActionParallel")
1961 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1963 xappConn1.SendSubsReq(t, rparams1, nil)
1965 crereq1, _ := e2termConn1.RecvSubsReq(t)
1968 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1970 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
1971 xappConn2.SendSubsReq(t, rparams2, nil)
1972 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
1974 //Req1 (retransmitted)
1975 e2termConn1.RecvSubsReq(t)
1977 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1978 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1980 //Wait that subs is cleaned
1981 mainCtrl.wait_subs_clean(t, delreq1.RequestId.InstanceId, 10)
1983 xappConn1.TestMsgChanEmpty(t)
1984 xappConn2.TestMsgChanEmpty(t)
1985 e2termConn1.TestMsgChanEmpty(t)
1986 mainCtrl.wait_registry_empty(t, 15)
1989 //----------------------------- Policy cases ---------------------------------
1990 //-----------------------------------------------------------------------------
1991 // TestSubReqPolicyAndSubDelOk
1994 // +-------+ +---------+ +---------+
1995 // | xapp | | submgr | | e2term |
1996 // +-------+ +---------+ +---------+
1999 // |------------->| |
2002 // | |------------->|
2005 // | |<-------------|
2008 // |<-------------| |
2012 // |------------->| |
2015 // | |------------->|
2018 // | |<-------------|
2021 // |<-------------| |
2023 //-----------------------------------------------------------------------------
2024 func TestSubReqPolicyAndSubDelOk(t *testing.T) {
2025 CaseBegin("TestSubReqAndSubDelOk")
2027 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2029 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
2030 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
2032 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2033 e2termConn1.SendSubsResp(t, crereq, cremsg)
2034 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2035 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2036 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2038 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2039 xappConn1.RecvSubsDelResp(t, deltrans)
2041 //Wait that subs is cleaned
2042 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2044 xappConn1.TestMsgChanEmpty(t)
2045 xappConn2.TestMsgChanEmpty(t)
2046 e2termConn1.TestMsgChanEmpty(t)
2047 mainCtrl.wait_registry_empty(t, 10)
2050 //-----------------------------------------------------------------------------
2051 // TestSubReqPolicyChangeAndSubDelOk
2054 // +-------+ +---------+ +---------+
2055 // | xapp | | submgr | | e2term |
2056 // +-------+ +---------+ +---------+
2059 // |------------->| |
2062 // | |------------->|
2065 // | |<-------------|
2068 // |<-------------| |
2071 // |------------->| |
2074 // | |------------->|
2077 // | |<-------------|
2080 // |<-------------| |
2083 // |------------->| |
2086 // | |------------->|
2089 // | |<-------------|
2092 // |<-------------| |
2094 //-----------------------------------------------------------------------------
2096 func TestSubReqPolicyChangeAndSubDelOk(t *testing.T) {
2097 CaseBegin("TestSubReqAndSubDelOk")
2099 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2101 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
2102 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
2104 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2105 e2termConn1.SendSubsResp(t, crereq, cremsg)
2106 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2109 rparams1.Req.RequestId.InstanceId = e2SubsId
2110 rparams1.Req.ActionSetups[0].SubsequentAction.TimetoWait = e2ap.E2AP_TimeToWaitW200ms
2111 xappConn1.SendSubsReq(t, rparams1, cretrans)
2113 crereq, cremsg = e2termConn1.RecvSubsReq(t)
2114 e2termConn1.SendSubsResp(t, crereq, cremsg)
2115 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
2116 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2117 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2119 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2120 xappConn1.RecvSubsDelResp(t, deltrans)
2122 //Wait that subs is cleaned
2123 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2125 xappConn1.TestMsgChanEmpty(t)
2126 xappConn2.TestMsgChanEmpty(t)
2127 e2termConn1.TestMsgChanEmpty(t)
2128 mainCtrl.wait_registry_empty(t, 10)
2131 //-----------------------------------------------------------------------------
2132 // TestSubReqAndSubDelOkTwoE2termParallel
2135 // +-------+ +---------+ +---------+ +---------+
2136 // | xapp | | submgr | | e2term1 | | e2term2 |
2137 // +-------+ +---------+ +---------+ +---------+
2142 // |------------->| | |
2145 // | |------------->| |
2148 // |------------->| | |
2151 // | |---------------------------->|
2154 // | |<-------------| |
2156 // |<-------------| | |
2158 // | |<----------------------------|
2160 // |<-------------| | |
2162 // | [SUBS 1 DELETE] | |
2164 // | [SUBS 2 DELETE] | |
2167 //-----------------------------------------------------------------------------
2168 func TestSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
2169 CaseBegin("TestSubReqAndSubDelOkTwoE2termParallel")
2172 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
2173 xappConn1.SendSubsReq(t, nil, cretrans1)
2174 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2176 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_11")
2177 xappConn1.SendSubsReq(t, nil, cretrans2)
2178 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
2181 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2182 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
2185 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
2186 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
2189 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
2190 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
2191 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
2192 xappConn1.RecvSubsDelResp(t, deltrans1)
2193 //Wait that subs is cleaned
2194 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
2197 deltrans2 := xappConn1.SendSubsDelReq(t, nil, e2SubsId2)
2198 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
2199 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
2200 xappConn1.RecvSubsDelResp(t, deltrans2)
2201 //Wait that subs is cleaned
2202 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
2204 xappConn1.TestMsgChanEmpty(t)
2205 xappConn2.TestMsgChanEmpty(t)
2206 e2termConn1.TestMsgChanEmpty(t)
2207 e2termConn2.TestMsgChanEmpty(t)
2208 mainCtrl.wait_registry_empty(t, 10)
2211 //-----------------------------------------------------------------------------
2212 // TestSubReqInsertAndSubDelOk
2215 // +-------+ +---------+ +---------+
2216 // | xapp | | submgr | | e2term |
2217 // +-------+ +---------+ +---------+
2220 // |------------->| |
2223 // | |------------->|
2226 // | |<-------------|
2229 // |<-------------| |
2233 // |------------->| |
2236 // | |------------->|
2239 // | |<-------------|
2242 // |<-------------| |
2244 //-----------------------------------------------------------------------------
2245 func TestSubReqInsertAndSubDelOk(t *testing.T) {
2246 CaseBegin("TestInsertSubReqAndSubDelOk")
2248 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2250 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypeInsert
2251 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
2253 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2254 e2termConn1.SendSubsResp(t, crereq, cremsg)
2255 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2256 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2257 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2259 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2260 xappConn1.RecvSubsDelResp(t, deltrans)
2262 //Wait that subs is cleaned
2263 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2265 xappConn1.TestMsgChanEmpty(t)
2266 xappConn2.TestMsgChanEmpty(t)
2267 e2termConn1.TestMsgChanEmpty(t)
2268 mainCtrl.wait_registry_empty(t, 10)
2271 //-----------------------------------------------------------------------------
2272 // TestSubReqRetransmissionWithSameSubIdDiffXid
2274 // This case simulates case where xApp restarts and starts sending same
2275 // subscription requests which have already subscribed successfully
2278 // +-------+ +---------+ +---------+
2279 // | xapp | | submgr | | e2term |
2280 // +-------+ +---------+ +---------+
2283 // |------------->| |
2286 // | |------------->|
2289 // | |<-------------|
2292 // |<-------------| |
2294 // | xApp restart | |
2297 // | (retrans with same xApp generated subid but diff xid)
2298 // |------------->| |
2301 // |<-------------| |
2303 // | [SUBS DELETE] |
2306 //-----------------------------------------------------------------------------
2307 func TestSubReqRetransmissionWithSameSubIdDiffXid(t *testing.T) {
2308 CaseBegin("TestSubReqRetransmissionWithSameSubIdDiffXid")
2311 cretrans := xappConn1.SendSubsReq(t, nil, nil)
2312 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2313 e2termConn1.SendSubsResp(t, crereq, cremsg)
2314 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2316 // xApp restart here
2317 // --> artificial delay
2318 <-time.After(1 * time.Second)
2321 cretrans = xappConn1.SendSubsReq(t, nil, nil) //Retransmitted SubReq
2322 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
2325 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2326 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2327 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2328 xappConn1.RecvSubsDelResp(t, deltrans)
2330 //Wait that subs is cleaned
2331 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2333 xappConn1.TestMsgChanEmpty(t)
2334 xappConn2.TestMsgChanEmpty(t)
2335 e2termConn1.TestMsgChanEmpty(t)
2336 mainCtrl.wait_registry_empty(t, 10)
2339 //-----------------------------------------------------------------------------
2340 // TestSubReqNokAndSubDelOkWithRestartInMiddle
2343 // +-------+ +---------+ +---------+
2344 // | xapp | | submgr | | e2term |
2345 // +-------+ +---------+ +---------+
2348 // |------------->| |
2351 // | |------------->|
2356 // | Submgr restart |
2360 // | |------------->|
2363 // | |<-------------|
2366 //-----------------------------------------------------------------------------
2368 func TestSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
2369 CaseBegin("TestSubReqNokAndSubDelOkWithRestartInMiddle")
2371 // Remove possible existing subscrition
2372 mainCtrl.removeExistingSubscriptions(t)
2374 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
2375 xappConn1.SendSubsReq(t, nil, nil)
2376 e2termConn1.RecvSubsReq(t)
2377 mainCtrl.SetResetTestFlag(t, false)
2379 resp, _ := xapp.Subscription.QuerySubscriptions()
2380 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2381 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2382 e2SubsId := uint32(resp[0].SubscriptionID)
2383 t.Logf("e2SubsId = %v", e2SubsId)
2385 mainCtrl.SimulateRestart(t)
2386 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2388 // Submgr send delete for uncompleted subscription
2389 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2390 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2392 // Wait that subs is cleaned
2393 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2395 xappConn1.TestMsgChanEmpty(t)
2396 xappConn2.TestMsgChanEmpty(t)
2397 e2termConn1.TestMsgChanEmpty(t)
2398 mainCtrl.wait_registry_empty(t, 10)
2401 //-----------------------------------------------------------------------------
2402 // TestSubReqAndSubDelOkWithRestartInMiddle
2405 // +-------+ +---------+ +---------+
2406 // | xapp | | submgr | | e2term |
2407 // +-------+ +---------+ +---------+
2410 // |------------->| |
2413 // | |------------->|
2416 // | |<-------------|
2419 // |<-------------| |
2422 // | Submgr restart |
2425 // |------------->| |
2428 // | |------------->|
2431 // | |<-------------|
2434 // |<-------------| |
2436 //-----------------------------------------------------------------------------
2438 func TestSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
2439 CaseBegin("TestSubReqAndSubDelOkWithRestartInMiddle")
2441 cretrans := xappConn1.SendSubsReq(t, nil, nil)
2442 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2443 e2termConn1.SendSubsResp(t, crereq, cremsg)
2444 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2446 // Check subscription
2447 resp, _ := xapp.Subscription.QuerySubscriptions()
2448 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
2449 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2450 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2452 mainCtrl.SimulateRestart(t)
2453 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2455 // Check that subscription is restored correctly after restart
2456 resp, _ = xapp.Subscription.QuerySubscriptions()
2457 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
2458 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2459 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2461 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2462 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2463 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2464 xappConn1.RecvSubsDelResp(t, deltrans)
2466 //Wait that subs is cleaned
2467 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2469 xappConn1.TestMsgChanEmpty(t)
2470 xappConn2.TestMsgChanEmpty(t)
2471 e2termConn1.TestMsgChanEmpty(t)
2472 mainCtrl.wait_registry_empty(t, 10)
2475 //-----------------------------------------------------------------------------
2476 // TestSubReqAndSubDelOkSameActionWithRestartsInMiddle
2479 // +-------+ +-------+ +---------+ +---------+
2480 // | xapp2 | | xapp1 | | submgr | | e2term |
2481 // +-------+ +-------+ +---------+ +---------+
2486 // | |------------->| |
2489 // | | |------------->|
2491 // | | |<-------------|
2493 // | |<-------------| |
2496 // | submgr restart |
2501 // |--------------------------->| |
2504 // |<---------------------------| |
2506 // | | SubDelReq 1 | |
2507 // | |------------->| |
2509 // | | SubDelResp 1 | |
2510 // | |<-------------| |
2514 // | submgr restart |
2517 // | SubDelReq 2 | |
2518 // |--------------------------->| |
2520 // | | | SubDelReq 2 |
2521 // | | |------------->|
2523 // | | | SubDelReq 2 |
2524 // | | |------------->|
2526 // | SubDelResp 2 | |
2527 // |<---------------------------| |
2529 //-----------------------------------------------------------------------------
2531 func TestSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
2532 CaseBegin("TestSubReqAndSubDelOkSameActionWithRestartsInMiddle")
2535 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2537 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
2538 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2539 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2540 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
2543 rparams2 := &teststube2ap.E2StubSubsReqParams{}
2545 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
2546 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
2548 // Check subscription
2549 resp, _ := xapp.Subscription.QuerySubscriptions() ////////////////////////////////
2550 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
2551 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2552 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
2554 mainCtrl.SimulateRestart(t)
2555 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2557 // Check that subscription is restored correctly after restart
2558 resp, _ = xapp.Subscription.QuerySubscriptions()
2559 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
2560 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2561 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
2564 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
2565 xapp.Logger.Debug("xappConn1.RecvSubsDelResp")
2566 xappConn1.RecvSubsDelResp(t, deltrans1)
2567 xapp.Logger.Debug("xappConn1.RecvSubsDelResp received")
2569 mainCtrl.SimulateRestart(t)
2570 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2573 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
2574 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
2576 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
2577 xappConn2.RecvSubsDelResp(t, deltrans2)
2579 //Wait that subs is cleaned
2580 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
2582 xappConn1.TestMsgChanEmpty(t)
2583 xappConn2.TestMsgChanEmpty(t)
2584 e2termConn1.TestMsgChanEmpty(t)
2585 mainCtrl.wait_registry_empty(t, 10)
2588 //*****************************************************************************
2589 // REST interface test cases
2590 //*****************************************************************************
2592 //-----------------------------------------------------------------------------
2593 // Test debug GET and POST requests
2596 // +-------+ +---------+
2597 // | user | | submgr |
2598 // +-------+ +---------+
2605 func TestGetSubscriptions(t *testing.T) {
2607 mainCtrl.sendGetRequest(t, "localhost:8088", "/ric/v1/subscriptions")
2610 func TestGetSymptomData(t *testing.T) {
2612 mainCtrl.sendGetRequest(t, "localhost:8080", "/ric/v1/symptomdata")
2615 func TestPostdeleteSubId(t *testing.T) {
2617 mainCtrl.sendPostRequest(t, "localhost:8080", "/ric/v1/test/deletesubid=1")
2620 func TestPostEmptyDb(t *testing.T) {
2622 mainCtrl.sendPostRequest(t, "localhost:8080", "/ric/v1/test/emptydb")
2625 func TestGetRestSubscriptions(t *testing.T) {
2627 mainCtrl.sendGetRequest(t, "localhost:8080", "/ric/v1/restsubscriptions")
2630 //-----------------------------------------------------------------------------
2631 // TestRESTSubReqAndRouteNok
2634 // +-------+ +---------+ +---------+
2635 // | xapp | | submgr | | rtmgr |
2636 // +-------+ +---------+ +---------+
2639 // |---------------->| |
2641 // | RESTSubResp | |
2642 // |<----------------| |
2643 // | | RouteCreate |
2644 // | |------------->|
2646 // | | RouteCreate |
2648 // | |(Bad request) |
2649 // | |<-------------|
2651 // |<----------------| |
2653 // | [SUBS INT DELETE] |
2655 // | RESTSubDelReq | |
2656 // |---------------->| |
2657 // | RESTSubDelResp | |
2658 // |<----------------| |
2660 //-----------------------------------------------------------------------------
2661 func TestRESTSubReqAndRouteNok(t *testing.T) {
2662 CaseBegin("TestRESTSubReqAndRouteNok")
2664 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2665 Counter{cRestSubReqFromXapp, 1},
2666 Counter{cRestSubRespToXapp, 1},
2667 Counter{cRouteCreateFail, 1},
2668 Counter{cRestSubFailNotifToXapp, 1},
2669 Counter{cRestSubDelReqFromXapp, 1},
2670 Counter{cRestSubDelRespToXapp, 1},
2673 const subReqCount int = 1
2675 // Add delay for rtmgt HTTP handling so that HTTP response is received before notify on XAPP side
2676 waiter := rtmgrHttp.AllocNextSleep(50, false)
2677 newSubsId := mainCtrl.get_registry_next_subid(t)
2680 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2681 restSubId := xappConn1.SendRESTSubsReq(t, params)
2682 xappConn1.ExpectRESTNotificationNok(t, restSubId, "failAll")
2683 waiter.WaitResult(t)
2685 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2686 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
2689 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2691 // Wait that subs is cleaned
2692 mainCtrl.wait_subs_clean(t, newSubsId, 10)
2693 waitSubsCleanup(t, e2SubsId, 10)
2694 mainCtrl.VerifyCounterValues(t)
2697 func TestRESTSubReqAndRouteUpdateNok(t *testing.T) {
2698 CaseBegin("TestSubReqAndRouteUpdateNok")
2700 //Init counter check
2701 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2702 Counter{cRestSubReqFromXapp, 2},
2703 Counter{cRestSubRespToXapp, 2},
2704 Counter{cSubReqToE2, 1},
2705 Counter{cSubRespFromE2, 1},
2706 Counter{cRestSubNotifToXapp, 1},
2707 Counter{cRestSubFailNotifToXapp, 1},
2708 Counter{cRouteCreateUpdateFail, 1},
2709 Counter{cRestSubDelReqFromXapp, 1},
2710 Counter{cSubDelReqToE2, 1},
2711 Counter{cSubDelRespFromE2, 1},
2712 Counter{cRestSubDelRespToXapp, 1},
2715 var params *teststube2ap.RESTSubsReqParams = nil
2718 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2720 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2722 // xapp2 ROUTE creation shall fail with 400 from rtmgr -> submgr
2723 waiter := rtmgrHttp.AllocNextEvent(false)
2724 newSubsId := mainCtrl.get_registry_next_subid(t)
2725 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
2726 params.SetMeid("RAN_NAME_1")
2727 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
2728 xapp.Logger.Debug("Send REST subscriber request for second subscriber : %v", restSubId2)
2729 xappConn2.ExpectRESTNotificationNok(t, restSubId2, "allFail")
2730 waiter.WaitResult(t)
2731 // e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) - TOD: missing delete
2732 xappConn2.WaitRESTNotification(t, restSubId2)
2734 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2736 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
2738 mainCtrl.wait_subs_clean(t, newSubsId, 10)
2739 //Wait that subs is cleaned
2740 waitSubsCleanup(t, e2SubsId, 10)
2742 mainCtrl.VerifyCounterValues(t)
2745 func TestRESTSubDelReqAndRouteDeleteNok(t *testing.T) {
2746 CaseBegin("TestRESTSubDelReqAndRouteDeleteNok")
2748 // Init counter check
2749 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2750 Counter{cRestSubReqFromXapp, 1},
2751 Counter{cRestSubRespToXapp, 1},
2752 Counter{cSubReqToE2, 1},
2753 Counter{cSubRespFromE2, 1},
2754 Counter{cRestSubNotifToXapp, 1},
2755 Counter{cRestSubDelReqFromXapp, 1},
2756 Counter{cRouteDeleteFail, 1},
2757 Counter{cSubDelReqToE2, 1},
2758 Counter{cSubDelRespFromE2, 1},
2759 Counter{cRestSubDelRespToXapp, 1},
2762 var params *teststube2ap.RESTSubsReqParams = nil
2765 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2767 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2769 waiter := rtmgrHttp.AllocNextEvent(false)
2770 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2771 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2772 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2773 waiter.WaitResult(t)
2775 waitSubsCleanup(t, e2SubsId, 10)
2777 mainCtrl.VerifyCounterValues(t)
2780 func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) {
2781 CaseBegin("TestRESTSubMergeDelAndRouteUpdateNok")
2783 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2784 Counter{cRestSubReqFromXapp, 2},
2785 Counter{cMergedSubscriptions, 1},
2786 Counter{cRestSubRespToXapp, 2},
2787 Counter{cSubReqToE2, 1},
2788 Counter{cSubRespFromE2, 1},
2789 Counter{cRestSubNotifToXapp, 2},
2790 Counter{cRestSubDelReqFromXapp, 2},
2791 Counter{cRouteDeleteUpdateFail, 1},
2792 Counter{cSubDelReqToE2, 1},
2793 Counter{cSubDelRespFromE2, 1},
2794 Counter{cRestSubDelRespToXapp, 2},
2795 Counter{cUnmergedSubscriptions, 1},
2798 var params *teststube2ap.RESTSubsReqParams = nil
2801 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2803 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2804 restSubId2, e2SubsId2 := createXapp2MergedSubscription(t, "RAN_NAME_1")
2806 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
2808 //Del1, this shall fail on rtmgr side
2809 waiter := rtmgrHttp.AllocNextEvent(false)
2810 xappConn1.SendRESTSubsDelReq(t, &restSubId)
2811 waiter.WaitResult(t)
2813 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13660"})
2816 deleteXapp2Subscription(t, &restSubId2)
2818 waitSubsCleanup(t, e2SubsId2, 10)
2819 mainCtrl.VerifyCounterValues(t)
2822 //-----------------------------------------------------------------------------
2823 // TestRESTSubReqRetransmission
2826 // +-------+ +---------+ +---------+
2827 // | xapp | | submgr | | e2term |
2828 // +-------+ +---------+ +---------+
2830 // | RESTSubReq1 | |
2831 // |---------------->| |
2833 // | RESTSubResp | |
2834 // |<----------------| |
2836 // | |------------->|
2838 // | RESTSubReq2 | |
2840 // |---------------->| |
2841 // | RESTSubResp(201)| |
2842 // |<----------------| |
2845 // | |<-------------|
2847 // |<----------------| |
2849 // | [SUBS DELETE] |
2852 //-----------------------------------------------------------------------------
2854 func TestRESTSubReqRetransmission(t *testing.T) {
2855 CaseBegin("TestRESTSubReqRetransmission")
2857 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2858 Counter{cRestSubReqFromXapp, 2},
2859 Counter{cRestSubRespToXapp, 2},
2860 Counter{cSubReqToE2, 1},
2861 Counter{cSubRespFromE2, 1},
2862 Counter{cRestSubNotifToXapp, 1},
2863 Counter{cRestSubDelReqFromXapp, 1},
2864 Counter{cSubDelReqToE2, 1},
2865 Counter{cSubDelRespFromE2, 1},
2866 Counter{cRestSubDelRespToXapp, 1},
2868 // Retry/duplicate will get the same way as the first request.
2869 // Contianed duplicate messages from same xapp will not be merged. Here we use xappConn2 to simulate sending
2870 // second request from same xapp as doing it from xappConn1 would not work as notification would not be received
2873 const subReqCount int = 1
2875 // In order to force both XAPP's to create their own subscriptions, force rtmgr to block a while so that 2nd create
2876 // gets into execution before the rtmgrg responds for the first one.
2877 waiter := rtmgrHttp.AllocNextSleep(10, true)
2878 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2879 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
2880 xappConn2.SendRESTSubsReq(t, params)
2882 waiter.WaitResult(t)
2884 xappConn1.WaitListedRestNotifications(t, []string{restSubId1})
2886 // Depending one goroutine scheduling order, we cannot say for sure which xapp reaches e2term first. Thus
2887 // the order is not significant he6re.
2888 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2889 e2termConn1.SendSubsResp(t, crereq, cremsg)
2891 e2SubsIdA := <-xappConn1.ListedRESTNotifications
2892 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
2895 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
2896 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
2897 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
2899 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId}, 10)
2901 mainCtrl.VerifyCounterValues(t)
2904 //-----------------------------------------------------------------------------
2906 // +-------+ +---------+ +---------+ +---------+
2907 // | xapp | | submgr | | e2term | | rtmgr |
2908 // +-------+ +---------+ +---------+ +---------+
2910 // | RESTSubReq | | |
2911 // |---------------->| | |
2912 // | RESTSubResp | | |
2913 // |<----------------| | |
2914 // | | RouteCreate | |
2915 // | |--------------------------->|
2916 // | | RouteResponse| |
2917 // | |<---------------------------| // The order of these events may vary
2919 // | |------------->| | // The order of these events may vary
2921 // | |<-------------| |
2922 // | RESTNotif1 | | |
2923 // |<----------------| | |
2924 // | RESTSubReq | | |
2925 // | [RETRANS1] | | |
2926 // |---------------->| | |
2927 // | RESTNotif1 | | |
2928 // |<----------------| | |
2929 // | RESTSubReq | | |
2930 // | [RETRANS2] | | |
2931 // |---------------->| | |
2932 // | RESTNotif1 | | |
2933 // |<----------------| | |
2934 // | RESTSubDelReq | | |
2935 // |---------------->| | |
2936 // | | SubDelReq | |
2937 // | |------------->| |
2938 // | RESTSubDelResp| | |
2939 // |<----------------| | |
2940 // | | SubDelResp | |
2941 // | |<-------------| |
2944 //-----------------------------------------------------------------------------
2946 func TestRESTSubReqRetransmissionV2(t *testing.T) {
2947 CaseBegin("TestRESTSubReqRetransmissionV2")
2949 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2950 Counter{cRestSubReqFromXapp, 3},
2951 Counter{cDuplicateE2SubReq, 2},
2952 Counter{cRestSubRespToXapp, 3},
2953 Counter{cSubReqToE2, 1},
2954 Counter{cSubRespFromE2, 1},
2955 Counter{cRestSubNotifToXapp, 3},
2956 Counter{cRestSubDelReqFromXapp, 1},
2957 Counter{cSubDelReqToE2, 1},
2958 Counter{cSubDelRespFromE2, 1},
2959 Counter{cRestSubDelRespToXapp, 1},
2962 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2964 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
2966 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
2969 restSubId_resend := xappConn1.SendRESTSubsReq(t, params)
2971 assert.Equal(t, restSubId_resend, restSubId)
2973 <-time.After(100 * time.Millisecond)
2976 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
2978 assert.Equal(t, restSubId_resend2, restSubId)
2980 <-time.After(100 * time.Millisecond)
2982 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
2984 waitSubsCleanup(t, e2SubsId, 10)
2986 //Wait that subs is cleaned
2987 mainCtrl.VerifyCounterValues(t)
2990 //-----------------------------------------------------------------------------
2992 // +-------+ +---------+ +---------+ +---------+
2993 // | xapp | | submgr | | e2term | | rtmgr |
2994 // +-------+ +---------+ +---------+ +---------+
2996 // | RESTSubReq | | |
2997 // |---------------->| | |
2998 // | RESTSubResp | | |
2999 // |<----------------| | |
3000 // | | RouteCreate | |
3001 // | |--------------------------->|
3002 // | | RouteResponse| |
3003 // | |<---------------------------| // The order of these events may vary
3005 // | |------------->| | // The order of these events may vary
3007 // | |<-------------| |
3008 // | RESTNotif1 | | |
3009 // |<----------------| | |
3010 // | RESTSubReq | | |
3011 // | [RETRANS, with RESTsubsId] | |
3012 // |---------------->| | |
3013 // | RESTNotif1 | | |
3014 // |<----------------| | |
3015 // | RESTSubReq | | |
3016 // | [RETRANS, without RESTsubsId] | |
3017 // |---------------->| | |
3018 // | RESTNotif1 | | |
3019 // |<----------------| | |
3020 // | RESTSubDelReq | | |
3021 // |---------------->| | |
3022 // | | SubDelReq | |
3023 // | |------------->| |
3024 // | RESTSubDelResp| | |
3025 // |<----------------| | |
3026 // | | SubDelResp | |
3027 // | |<-------------| |
3030 //-----------------------------------------------------------------------------
3031 func TestRESTSubReqRetransmissionV3(t *testing.T) {
3032 CaseBegin("TestRESTSubReqRetransmissionV3")
3034 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3035 Counter{cRestSubReqFromXapp, 3},
3036 Counter{cDuplicateE2SubReq, 2},
3037 Counter{cRestSubRespToXapp, 3},
3038 Counter{cSubReqToE2, 1},
3039 Counter{cSubRespFromE2, 1},
3040 Counter{cRestSubNotifToXapp, 3},
3041 Counter{cRestSubDelReqFromXapp, 1},
3042 Counter{cSubDelReqToE2, 1},
3043 Counter{cSubDelRespFromE2, 1},
3044 Counter{cRestSubDelRespToXapp, 1},
3047 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3049 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3051 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3053 <-time.After(100 * time.Millisecond)
3055 //1.st resend with subscription ID
3056 params.SetSubscriptionID(&restSubId)
3057 restSubId_resend := xappConn1.SendRESTSubsReq(t, params)
3059 assert.Equal(t, restSubId_resend, restSubId)
3061 <-time.After(100 * time.Millisecond)
3063 //2.nd resend without subscription ID (faking app restart)
3064 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3065 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3067 assert.Equal(t, restSubId_resend2, restSubId)
3069 <-time.After(100 * time.Millisecond)
3071 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3073 waitSubsCleanup(t, e2SubsId, 10)
3075 //Wait that subs is cleaned
3076 mainCtrl.VerifyCounterValues(t)
3079 //-----------------------------------------------------------------------------
3081 // +-------+ +---------+ +---------+ +---------+
3082 // | xapp | | submgr | | e2term | | rtmgr |
3083 // +-------+ +---------+ +---------+ +---------+
3085 // | RESTSubReq | | |
3086 // |---------------->| | |
3087 // | RESTSubResp | | |
3088 // |<----------------| | |
3089 // | | RouteCreate | |
3090 // | |--------------------------->|
3091 // | | RouteResponse| |
3092 // | |<---------------------------|
3094 // | |------------->| |
3096 // | |<-------------| |
3097 // | RESTNotif1 | | |
3098 // |<----------------| | |
3099 // | RESTSubReq | | |
3100 // | [with RestSUbsId + one additional e2 subDetail]
3101 // |---------------->| | |
3102 // | RESTNotif1 | | |
3103 // | [for initial e2 subDetail] | |
3104 // |<----------------| | |
3105 // | | RouteCreate | |
3106 // | |--------------------------->|
3107 // | | RouteResponse| |
3108 // | |<---------------------------|
3110 // | |------------->| |
3112 // | |<-------------| |
3113 // | RESTNotif1 | | |
3114 // |<----------------| | |
3115 // | RESTSubReq | | |
3116 // | [with RESTsubsId initial request] |
3117 // |---------------->| | |
3118 // | RESTNotif1 | | |
3119 // |<----------------| | |
3120 // | RESTSubDelReq | | |
3121 // |---------------->| | |
3122 // | RESTSubDelResp| | |
3123 // |<----------------| | |
3124 // | | SubDelReq | |
3125 // | |------------->| |
3126 // | | SubDelResp | |
3127 // | |<-------------| |
3128 // | | SubDelReq | |
3129 // | |------------->| |
3130 // | | SubDelResp | |
3131 // | |<-------------| |
3134 //-----------------------------------------------------------------------------
3136 func TestRESTSubReqRetransmissionV4(t *testing.T) {
3137 CaseBegin("TestRESTSubReqRetransmissionV4")
3139 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3140 Counter{cRestSubReqFromXapp, 3},
3141 Counter{cDuplicateE2SubReq, 2},
3142 Counter{cRestSubRespToXapp, 3},
3143 Counter{cSubReqToE2, 2},
3144 Counter{cSubRespFromE2, 2},
3145 Counter{cRestSubNotifToXapp, 4},
3146 Counter{cRestSubDelReqFromXapp, 1},
3147 Counter{cSubDelReqToE2, 2},
3148 Counter{cSubDelRespFromE2, 2},
3149 Counter{cRestSubDelRespToXapp, 1},
3152 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3154 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3156 <-time.After(100 * time.Millisecond)
3158 // Send modified requst, this time with e2 subscriptions.
3159 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3160 params2.SetSubscriptionID(&restSubId)
3162 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3163 xappConn1.ExpectAnyNotification(t)
3164 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3165 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3166 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3167 assert.Equal(t, e2SubsId, e2SubsId1)
3169 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3171 xappConn1.DecrementRequestCount()
3172 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3173 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3174 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3175 assert.NotEqual(t, e2SubsId2, 0)
3177 <-time.After(100 * time.Millisecond)
3179 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3180 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3181 params.SetSubscriptionID(&restSubId)
3182 xappConn1.ExpectAnyNotification(t)
3183 // Resend the original request again with only one e2 subscription (detail), this time with restsubsid
3184 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3185 assert.Equal(t, restSubId_resend, restSubId_resend2)
3187 e2SubsId1 = xappConn1.WaitAnyRESTNotification(t)
3188 assert.Equal(t, e2SubsId, e2SubsId1)
3190 // Delete both e2 subscriptions
3191 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3192 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3193 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3195 waitSubsCleanup(t, e2SubsId, 10)
3197 //Wait that subs is cleaned
3198 mainCtrl.VerifyCounterValues(t)
3201 //-----------------------------------------------------------------------------
3203 // +-------+ +---------+ +---------+ +---------+
3204 // | xapp | | submgr | | e2term | | rtmgr |
3205 // +-------+ +---------+ +---------+ +---------+
3207 // | RESTSubReq | | |
3208 // |---------------->| | |
3209 // | RESTSubResp | | |
3210 // |<----------------| | |
3211 // | | RouteCreate | |
3212 // | |--------------------------->|
3213 // | | RouteResponse| |
3214 // | |<---------------------------|
3216 // | |------------->| |
3218 // | |<-------------| |
3219 // | RESTNotif1 | | |
3220 // |<----------------| | |
3221 // | RESTSubReq | | |
3222 // | [with RestSUbsId + one additional e2 subDetail]
3223 // |---------------->| | |
3224 // | RESTNotif1 | | |
3225 // | [for initial e2 subDetail] | |
3226 // |<----------------| | |
3227 // | | RouteCreate | |
3228 // | |--------------------------->|
3229 // | | RouteResponse| |
3230 // | |<---------------------------|
3232 // | |------------->| |
3234 // | |<-------------| |
3235 // | RESTNotif1 | | |
3236 // |<----------------| | |
3237 // | RESTSubReq | | |
3238 // | [without RESTsubsId initial request] |
3239 // |---------------->| | |
3240 // | RESTNotif1 | | |
3241 // |<----------------| | |
3242 // | RESTSubDelReq | | |
3243 // |---------------->| | |
3244 // | RESTSubDelResp| | |
3245 // |<----------------| | |
3246 // | | SubDelReq | |
3247 // | |------------->| |
3248 // | | SubDelResp | |
3249 // | |<-------------| |
3250 // | | SubDelReq | |
3251 // | |------------->| |
3252 // | | SubDelResp | |
3253 // | |<-------------| |
3256 //-----------------------------------------------------------------------------
3258 func TestRESTSubReqRetransmissionV5(t *testing.T) {
3259 CaseBegin("TestRESTSubReqRetransmissionV5")
3261 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3262 Counter{cRestSubReqFromXapp, 3},
3263 Counter{cDuplicateE2SubReq, 2},
3264 Counter{cRestSubRespToXapp, 3},
3265 Counter{cSubReqToE2, 2},
3266 Counter{cSubRespFromE2, 2},
3267 Counter{cRestSubNotifToXapp, 4},
3268 Counter{cRestSubDelReqFromXapp, 1},
3269 Counter{cSubDelReqToE2, 2},
3270 Counter{cSubDelRespFromE2, 2},
3271 Counter{cRestSubDelRespToXapp, 1},
3274 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3276 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3278 <-time.After(100 * time.Millisecond)
3280 // Send modified requst, this time with e2 subscriptions.
3281 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3282 params2.SetSubscriptionID(&restSubId)
3284 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3285 xappConn1.ExpectAnyNotification(t)
3286 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3287 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3289 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3290 assert.Equal(t, e2SubsId, e2SubsId1)
3291 // The first E2 subscription returns immediately, manually decrement expected request count for the remaining request handling
3292 xappConn1.DecrementRequestCount()
3294 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3296 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3297 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3298 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3299 assert.NotEqual(t, e2SubsId2, 0)
3301 <-time.After(100 * time.Millisecond)
3303 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3304 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3305 xappConn1.ExpectAnyNotification(t)
3306 // Resend the original request again with only one e2 subscription (detail), WITHOUT restsubsid
3307 // md5sum shall find the original request
3308 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3309 assert.Equal(t, restSubId_resend, restSubId_resend2)
3311 e2SubsId1 = xappConn1.WaitAnyRESTNotification(t)
3312 assert.Equal(t, e2SubsId, e2SubsId1)
3314 // Delete both e2 subscriptions
3315 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3316 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3317 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3319 waitSubsCleanup(t, e2SubsId, 10)
3321 //Wait that subs is cleaned
3322 mainCtrl.VerifyCounterValues(t)
3325 //-----------------------------------------------------------------------------
3327 // +-------+ +---------+ +---------+ +---------+
3328 // | xapp | | submgr | | e2term | | rtmgr |
3329 // +-------+ +---------+ +---------+ +---------+
3331 // | RESTSubReq | | |
3332 // |---------------->| | |
3333 // | RESTSubResp | | |
3334 // |<----------------| | |
3335 // | | RouteCreate | |
3336 // | |--------------------------->|
3337 // | | RouteResponse| |
3338 // | |<---------------------------|
3340 // | |------------->| |
3342 // | |<-------------| |
3343 // | RESTNotif1 | | |
3344 // |<----------------| | |
3345 // | RESTSubReq | | |
3346 // | [with RestSUbsId + one additional e2 subDetail]
3347 // |---------------->| | |
3348 // | RESTNotif1 | | |
3349 // | [for initial e2 subDetail] | |
3350 // |<----------------| | |
3351 // | | RouteCreate | |
3352 // | |--------------------------->|
3353 // | | RouteResponse| |
3354 // | |<---------------------------|
3356 // | |------------->| |
3358 // | |<-------------| |
3359 // | RESTNotif1 | | |
3360 // |<----------------| | |
3361 // | RESTSubDelReq | | |
3362 // |---------------->| | |
3363 // | RESTSubDelResp| | |
3364 // |<----------------| | |
3365 // | | SubDelReq | |
3366 // | |------------->| |
3367 // | | SubDelResp | |
3368 // | |<-------------| |
3369 // | | SubDelReq | |
3370 // | |------------->| |
3371 // | | SubDelResp | |
3372 // | |<-------------| |
3373 // | RESTSubReq | | |
3374 // | [with RESTsubsId initial request] |
3375 // |---------------->| | |
3376 // | RESTSubResp | | |
3377 // |<----------------| | |
3378 // | | RouteCreate | |
3379 // | |--------------------------->|
3380 // | | RouteResponse| |
3381 // | |<---------------------------|
3383 // | |------------->| |
3385 // | |<-------------| |
3386 // | RESTNotif1 | | |
3387 // |<----------------| | |
3390 //-----------------------------------------------------------------------------
3391 func TestRESTSubReqRetransmissionV6(t *testing.T) {
3392 CaseBegin("TestRESTSubReqRetransmissionV6")
3394 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3395 Counter{cRestSubReqFromXapp, 3},
3396 Counter{cDuplicateE2SubReq, 1},
3397 Counter{cRestSubRespToXapp, 3},
3398 Counter{cSubReqToE2, 3},
3399 Counter{cSubRespFromE2, 3},
3400 Counter{cRestSubNotifToXapp, 4},
3401 Counter{cRestSubDelReqFromXapp, 2},
3402 Counter{cSubDelReqToE2, 3},
3403 Counter{cSubDelRespFromE2, 3},
3404 Counter{cRestSubDelRespToXapp, 2},
3407 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3409 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3411 <-time.After(100 * time.Millisecond)
3413 // Send modified requst, this time with e2 subscriptions.
3414 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3415 params2.SetSubscriptionID(&restSubId)
3417 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3418 xappConn1.ExpectAnyNotification(t)
3419 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3420 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3422 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3423 assert.Equal(t, e2SubsId, e2SubsId1)
3425 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3427 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3428 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3429 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3430 assert.NotEqual(t, e2SubsId2, 0)
3432 <-time.After(100 * time.Millisecond)
3434 // Delete both e2 subscriptions
3435 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3436 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3437 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3439 waitSubsCleanup(t, e2SubsId, 10)
3441 // Resend the original request, we shall find it's previous md5sum/restsubs
3442 // but the restsubscription has been already removed. This shall trigger a
3444 restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
3446 <-time.After(100 * time.Millisecond)
3448 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3450 waitSubsCleanup(t, e2SubsId, 10)
3452 //Wait that subs is cleaned
3453 mainCtrl.VerifyCounterValues(t)
3456 func TestRESTSubDelReqRetransmission(t *testing.T) {
3457 CaseBegin("TestRESTSubDelReqRetransmission")
3459 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3460 Counter{cRestSubReqFromXapp, 1},
3461 Counter{cRestSubRespToXapp, 1},
3462 Counter{cSubReqToE2, 1},
3463 Counter{cSubRespFromE2, 1},
3464 Counter{cRestSubNotifToXapp, 1},
3465 Counter{cRestSubDelReqFromXapp, 2},
3466 Counter{cSubDelReqToE2, 1},
3467 Counter{cSubDelRespFromE2, 1},
3468 Counter{cRestSubDelRespToXapp, 2},
3471 var params *teststube2ap.RESTSubsReqParams = nil
3474 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3476 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3479 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3480 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3482 seqBef := mainCtrl.get_msgcounter(t)
3483 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3484 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
3486 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3488 waitSubsCleanup(t, e2SubsId, 10)
3490 mainCtrl.VerifyCounterValues(t)
3493 //-----------------------------------------------------------------------------
3494 // TestRESTSubReqDelReq
3497 // +-------+ +---------+ +---------+
3498 // | xapp | | submgr | | e2term |
3499 // +-------+ +---------+ +---------+
3502 // |---------------->| |
3504 // | RESTSubResp | |
3505 // |<----------------| |
3507 // | |------------->|
3508 // | RESTSubDelReq | |
3509 // |---------------->| |
3510 // | RESTSubDelResp | |
3512 // |<----------------| |
3514 // | |<-------------|
3516 // |<----------------| |
3518 // | [SUBS DELETE] |
3521 //-----------------------------------------------------------------------------
3522 func TestRESTSubReqDelReq(t *testing.T) {
3523 CaseBegin("TestRESTSubReqDelReq")
3525 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3526 Counter{cRestSubReqFromXapp, 1},
3527 Counter{cRestSubRespToXapp, 1},
3528 Counter{cSubReqToE2, 1},
3529 Counter{cSubRespFromE2, 1},
3530 Counter{cRestSubNotifToXapp, 1},
3531 Counter{cRestSubDelReqFromXapp, 2},
3532 Counter{cRestSubDelFailToXapp, 1},
3533 Counter{cSubDelReqToE2, 1},
3534 Counter{cSubDelRespFromE2, 1},
3535 Counter{cRestSubDelRespToXapp, 1},
3538 const subReqCount int = 1
3541 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3542 restSubId := xappConn1.SendRESTSubsReq(t, params)
3544 // Del. This will fail as processing of the subscription
3545 // is still ongoing in submgr. Deletion is not allowed before
3546 // subscription creation has been completed.
3547 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3548 crereq, cremsg := e2termConn1.RecvSubsReq(t)
3549 xappConn1.ExpectRESTNotification(t, restSubId)
3550 e2termConn1.SendSubsResp(t, crereq, cremsg)
3551 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3554 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3556 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3557 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3559 // Wait that subs is cleaned
3560 waitSubsCleanup(t, e2SubsId, 10)
3561 mainCtrl.VerifyCounterValues(t)
3565 func TestRESTSubDelReqCollision(t *testing.T) {
3566 CaseBegin("TestRESTSubDelReqCollision - not relevant for REST API")
3569 func TestRESTSubReqAndSubDelOkTwoParallel(t *testing.T) {
3570 CaseBegin("TestRESTSubReqAndSubDelOkTwoParallel")
3572 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3573 Counter{cRestSubReqFromXapp, 2},
3574 Counter{cRestSubRespToXapp, 2},
3575 Counter{cSubReqToE2, 2},
3576 Counter{cSubRespFromE2, 2},
3577 Counter{cRestSubNotifToXapp, 2},
3578 Counter{cRestSubDelReqFromXapp, 2},
3579 Counter{cSubDelReqToE2, 2},
3580 Counter{cSubDelRespFromE2, 2},
3581 Counter{cRestSubDelRespToXapp, 2},
3585 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3586 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
3587 xapp.Logger.Debug("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
3590 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
3591 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
3592 xapp.Logger.Debug("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
3594 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3595 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3597 //XappConn1 receives both of the responses
3598 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
3601 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
3603 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3605 e2SubsIdA := <-xappConn1.ListedRESTNotifications
3606 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
3607 e2SubsIdB := <-xappConn1.ListedRESTNotifications
3608 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
3611 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
3613 deleteSubscription(t, xappConn2, e2termConn1, &restSubId2)
3615 //Wait that subs is cleaned
3616 mainCtrl.wait_subs_clean(t, e2SubsIdA.E2SubsId, 10)
3617 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
3619 mainCtrl.VerifyCounterValues(t)
3623 func TestRESTSameSubsDiffRan(t *testing.T) {
3624 CaseBegin("TestRESTSameSubsDiffRan")
3626 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3627 Counter{cRestSubReqFromXapp, 2},
3628 Counter{cRestSubRespToXapp, 2},
3629 Counter{cSubReqToE2, 2},
3630 Counter{cSubRespFromE2, 2},
3631 Counter{cRestSubNotifToXapp, 2},
3632 Counter{cRestSubDelReqFromXapp, 2},
3633 Counter{cSubDelReqToE2, 2},
3634 Counter{cSubDelRespFromE2, 2},
3635 Counter{cRestSubDelRespToXapp, 2},
3638 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3639 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
3640 xapp.Logger.Debug("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
3642 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3643 params.SetMeid("RAN_NAME_2")
3644 restSubId2, e2SubsId2 := createSubscription(t, xappConn1, e2termConn1, params)
3645 xapp.Logger.Debug("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
3648 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
3650 deleteSubscription(t, xappConn1, e2termConn1, &restSubId2)
3652 //Wait that subs is cleaned
3653 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
3654 waitSubsCleanup(t, e2SubsId2, 10)
3656 mainCtrl.VerifyCounterValues(t)
3659 func TestRESTSubReqRetryInSubmgr(t *testing.T) {
3660 CaseBegin("TestRESTSubReqRetryInSubmgr start")
3662 // Init counter check
3663 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3664 Counter{cRestSubReqFromXapp, 1},
3665 Counter{cRestSubRespToXapp, 1},
3666 Counter{cSubReqToE2, 1},
3667 Counter{cSubReqTimerExpiry, 1},
3668 Counter{cSubReReqToE2, 1},
3669 Counter{cSubRespFromE2, 1},
3670 Counter{cRestSubNotifToXapp, 1},
3671 Counter{cRestSubDelReqFromXapp, 1},
3672 Counter{cSubDelReqToE2, 1},
3673 Counter{cSubDelRespFromE2, 1},
3674 Counter{cRestSubDelRespToXapp, 1},
3677 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3678 restSubId := xappConn1.SendRESTSubsReq(t, params)
3680 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3682 // Catch the first message and ignore it
3683 crereq, cremsg := e2termConn1.RecvSubsReq(t)
3684 xapp.Logger.Debug("Ignore REST subscriber request for subscriber : %v", restSubId)
3686 // The second request is being handled normally
3687 crereq, cremsg = e2termConn1.RecvSubsReq(t)
3688 xappConn1.ExpectRESTNotification(t, restSubId)
3689 e2termConn1.SendSubsResp(t, crereq, cremsg)
3690 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3692 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3694 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3696 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
3697 //Wait that subs is cleaned
3698 waitSubsCleanup(t, e2SubsId, 10)
3700 mainCtrl.VerifyCounterValues(t)
3704 //-----------------------------------------------------------------------------
3705 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
3708 // +-------+ +---------+ +---------+
3709 // | xapp | | submgr | | e2term |
3710 // +-------+ +---------+ +---------+
3713 // |---------------->| |
3715 // | RESTSubResp | |
3716 // |<----------------| |
3718 // | |------------->|
3722 // | |------------->|
3725 // | |------------->|
3729 // | |------------->|
3733 // | |<-------------|
3736 // |<----------------| |
3738 // | [SUBS DELETE] |
3741 //-----------------------------------------------------------------------------
3743 func TestRESTSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
3744 CaseBegin("TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
3746 // Init counter check
3747 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3748 Counter{cRestSubReqFromXapp, 1},
3749 Counter{cRestSubRespToXapp, 1},
3750 Counter{cSubReqToE2, 1},
3751 Counter{cSubReReqToE2, 1},
3752 Counter{cSubReqTimerExpiry, 2},
3753 Counter{cRestSubFailNotifToXapp, 1},
3754 Counter{cSubDelReqToE2, 1},
3755 Counter{cSubDelRespFromE2, 1},
3757 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3758 restSubId := xappConn1.SendRESTSubsReq(t, params)
3759 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3761 e2termConn1.RecvSubsReq(t)
3762 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3764 e2termConn1.RecvSubsReq(t)
3765 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3767 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3768 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3769 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3770 xappConn1.WaitRESTNotification(t, restSubId)
3772 // Wait that subs is cleaned
3773 waitSubsCleanup(t, delreq.RequestId.InstanceId, 10)
3775 mainCtrl.VerifyCounterValues(t)
3778 func TestREST2eTermNotRespondingToSubReq(t *testing.T) {
3779 CaseBegin("TestREST2eTermNotRespondingToSubReq start")
3781 // Init counter check
3782 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3783 Counter{cRestSubReqFromXapp, 1},
3784 Counter{cRestSubRespToXapp, 1},
3785 Counter{cSubReqToE2, 1},
3786 Counter{cSubReReqToE2, 1},
3787 Counter{cSubReqTimerExpiry, 2},
3788 Counter{cSubDelReReqToE2, 1},
3789 Counter{cRestSubFailNotifToXapp, 1},
3790 Counter{cSubDelReqToE2, 1},
3791 Counter{cSubDelReqTimerExpiry, 2},
3793 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3794 restSubId := xappConn1.SendRESTSubsReq(t, params)
3795 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3797 e2termConn1.RecvSubsReq(t)
3798 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3800 e2termConn1.RecvSubsReq(t)
3801 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3803 e2termConn1.RecvSubsDelReq(t)
3804 xapp.Logger.Debug("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
3806 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3807 e2termConn1.RecvSubsDelReq(t)
3808 xapp.Logger.Debug("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
3810 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3812 waitSubsCleanup(t, e2SubsId, 10)
3814 mainCtrl.VerifyCounterValues(t)
3818 //-----------------------------------------------------------------------------
3819 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
3822 // +-------+ +---------+ +---------+
3823 // | xapp | | submgr | | e2term |
3824 // +-------+ +---------+ +---------+
3827 // |---------------->| |
3829 // | RESTSubResp | |
3830 // |<----------------| |
3832 // | |------------->|
3836 // | |------------->|
3839 // | |------------->|
3843 // | |------------->|
3847 // | |<-------------|
3850 // |<----------------| |
3852 // | [SUBS DELETE] |
3855 //-----------------------------------------------------------------------------
3856 func TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
3857 CaseBegin("TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr start")
3859 // Init counter check
3860 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3861 Counter{cRestSubReqFromXapp, 1},
3862 Counter{cRestSubRespToXapp, 1},
3863 Counter{cSubReqToE2, 1},
3864 Counter{cSubReReqToE2, 1},
3865 Counter{cSubReqTimerExpiry, 2},
3866 Counter{cRestSubFailNotifToXapp, 1},
3867 Counter{cSubDelReqToE2, 1},
3868 Counter{cSubDelReReqToE2, 1},
3869 Counter{cSubDelReqTimerExpiry, 2},
3872 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3873 restSubId := xappConn1.SendRESTSubsReq(t, params)
3874 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
3876 e2termConn1.RecvSubsReq(t)
3877 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
3879 e2termConn1.RecvSubsReq(t)
3880 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
3882 e2termConn1.RecvSubsDelReq(t)
3883 xapp.Logger.Debug("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
3885 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3886 e2termConn1.RecvSubsDelReq(t)
3887 xapp.Logger.Debug("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
3889 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3891 waitSubsCleanup(t, e2SubsId, 10)
3893 mainCtrl.VerifyCounterValues(t)
3896 //-----------------------------------------------------------------------------
3897 // TestRESTSubReqSubFailRespInSubmgr
3900 // +-------+ +---------+ +---------+
3901 // | xapp | | submgr | | e2term |
3902 // +-------+ +---------+ +---------+
3905 // |---------------->| |
3907 // | RESTSubResp | |
3908 // |<----------------| |
3910 // | |------------->|
3913 // | |<-------------|
3917 // |<----------------| |
3919 // | [SUBS DELETE] |
3922 //-----------------------------------------------------------------------------
3923 func TestRESTSubReqSubFailRespInSubmgr(t *testing.T) {
3924 CaseBegin("TestRESTSubReqSubFailRespInSubmgr")
3926 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3927 Counter{cRestSubReqFromXapp, 1},
3928 Counter{cRestSubRespToXapp, 1},
3929 Counter{cSubReqToE2, 1},
3930 Counter{cSubFailFromE2, 1},
3931 Counter{cRestSubFailNotifToXapp, 1},
3932 Counter{cRestSubDelReqFromXapp, 1},
3933 Counter{cRestSubDelRespToXapp, 1},
3936 const subReqCount int = 1
3937 const e2Timeout int64 = 2
3938 const e2RetryCount int64 = 1
3939 const routingNeeded bool = true
3941 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3942 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
3943 restSubId := xappConn1.SendRESTSubsReq(t, params)
3945 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3946 fparams1 := &teststube2ap.E2StubSubsFailParams{}
3947 fparams1.Set(crereq1)
3948 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
3949 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
3951 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3952 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
3954 // REST subscription sill there to be deleted
3955 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3957 // Wait that subs is cleaned
3958 waitSubsCleanup(t, e2SubsId, 10)
3960 mainCtrl.VerifyCounterValues(t)
3964 //-----------------------------------------------------------------------------
3965 // TestRESTSubDelReqRetryInSubmgr
3968 // +-------+ +---------+ +---------+
3969 // | xapp | | submgr | | e2term |
3970 // +-------+ +---------+ +---------+
3972 // | [SUBS CREATE] |
3975 // | RESTSubDelReq | |
3976 // |---------------->| |
3978 // | RESTSubDelResp | |
3979 // |<----------------| |
3981 // | |------------->|
3984 // | |------------->|
3987 // | |<-------------|
3990 //-----------------------------------------------------------------------------
3991 func TestRESTSubDelReqRetryInSubmgr(t *testing.T) {
3992 CaseBegin("TestRESTSubDelReqRetryInSubmgr")
3994 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3995 Counter{cRestSubReqFromXapp, 1},
3996 Counter{cRestSubRespToXapp, 1},
3997 Counter{cSubReqToE2, 1},
3998 Counter{cSubRespFromE2, 1},
3999 Counter{cRestSubNotifToXapp, 1},
4000 Counter{cRestSubDelReqFromXapp, 1},
4001 Counter{cSubDelReqToE2, 1},
4002 Counter{cSubDelReqTimerExpiry, 1},
4003 Counter{cSubDelReReqToE2, 1},
4004 Counter{cSubDelRespFromE2, 1},
4005 Counter{cRestSubDelRespToXapp, 1},
4008 var params *teststube2ap.RESTSubsReqParams = nil
4009 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4012 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4014 // E2t: Receive 1st SubsDelReq
4015 e2termConn1.RecvSubsDelReq(t)
4017 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
4018 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4019 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4021 //Wait that subs is cleaned
4022 waitSubsCleanup(t, e2SubsId, 10)
4024 mainCtrl.VerifyCounterValues(t)
4027 //-----------------------------------------------------------------------------
4028 // TestRESTSubDelReqTwoRetriesNoRespInSubmgr
4031 // +-------+ +---------+ +---------+
4032 // | xapp | | submgr | | e2term |
4033 // +-------+ +---------+ +---------+
4035 // | [SUBS CREATE] |
4038 // | RESTSubDelReq | |
4039 // |---------------->| |
4041 // | RESTSubDelResp | |
4042 // |<----------------| |
4044 // | |------------->|
4047 // | |------------->|
4051 //-----------------------------------------------------------------------------
4052 func TestRESTSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
4053 CaseBegin("TestRESTSubDelReTwoRetriesNoRespInSubmgr")
4055 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4056 Counter{cRestSubReqFromXapp, 1},
4057 Counter{cRestSubRespToXapp, 1},
4058 Counter{cSubReqToE2, 1},
4059 Counter{cSubRespFromE2, 1},
4060 Counter{cRestSubNotifToXapp, 1},
4061 Counter{cRestSubDelReqFromXapp, 1},
4062 Counter{cSubDelReqToE2, 1},
4063 Counter{cSubDelReqTimerExpiry, 1},
4064 Counter{cSubDelReReqToE2, 1},
4065 Counter{cSubDelRespFromE2, 1},
4066 Counter{cRestSubDelRespToXapp, 1},
4070 var params *teststube2ap.RESTSubsReqParams = nil
4071 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4074 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4076 // E2t: Receive 1st SubsDelReq
4077 e2termConn1.RecvSubsDelReq(t)
4079 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
4080 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4081 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4083 //Wait that subs is cleaned
4084 waitSubsCleanup(t, e2SubsId, 10)
4086 mainCtrl.VerifyCounterValues(t)
4089 //-----------------------------------------------------------------------------
4090 // TestRESTSubDelReqSubDelFailRespInSubmgr
4093 // +-------+ +---------+ +---------+
4094 // | xapp | | submgr | | e2term |
4095 // +-------+ +---------+ +---------+
4097 // | [SUBS CREATE] |
4100 // | RESTSubDelReq | |
4101 // |---------------->| |
4103 // | RESTSubDelResp | |
4104 // |<----------------| |
4106 // | |------------->|
4109 // | |<-------------|
4112 //-----------------------------------------------------------------------------
4113 func TestRESTSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
4114 CaseBegin("TestRESTSubDelReqSubDelFailRespInSubmgr")
4116 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4117 Counter{cRestSubReqFromXapp, 1},
4118 Counter{cRestSubRespToXapp, 1},
4119 Counter{cSubReqToE2, 1},
4120 Counter{cSubRespFromE2, 1},
4121 Counter{cRestSubNotifToXapp, 1},
4122 Counter{cRestSubDelReqFromXapp, 1},
4123 Counter{cSubDelReqToE2, 1},
4124 Counter{cSubDelFailFromE2, 1},
4125 Counter{cRestSubDelRespToXapp, 1},
4129 var params *teststube2ap.RESTSubsReqParams = nil
4130 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4133 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4135 // E2t: Send receive SubsDelReq and send SubsDelFail
4136 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4137 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
4139 //Wait that subs is cleaned
4140 waitSubsCleanup(t, e2SubsId, 10)
4142 mainCtrl.VerifyCounterValues(t)
4145 //-----------------------------------------------------------------------------
4146 // TestRESTSubReqAndSubDelOkSameAction
4149 // +-------+ +-------+ +---------+ +---------+
4150 // | xapp2 | | xapp1 | | submgr | | e2term |
4151 // +-------+ +-------+ +---------+ +---------+
4153 // | | RESTSubReq1 | |
4154 // | |---------------->| |
4156 // | | RESTSubResp1 | |
4157 // | |<----------------| |
4160 // | | |------------->|
4162 // | | |<-------------|
4163 // | | RESTNotif1 | |
4164 // | |<----------------| |
4166 // | RESTSubReq2 | |
4167 // |------------------------------>| |
4169 // | RESTSubResp2 | |
4170 // |<------------------------------| |
4172 // | | RESTNotif2 | |
4173 // |<------------------------------| |
4175 // | | RESTSubDelReq1 | |
4176 // | |---------------->| |
4178 // | | RESTSubDelResp1 | |
4179 // | |<----------------| |
4181 // | RESTSubDelReq2 | |
4182 // |------------------------------>| |
4184 // | RESTSubDelResp2 | |
4185 // |<------------------------------| |
4187 // | | | SubDelReq2 |
4188 // | | |------------->|
4190 // | | | SubDelResp2 |
4191 // | | |<-------------|
4194 //-----------------------------------------------------------------------------
4195 func TestRESTSubReqAndSubDelOkSameAction(t *testing.T) {
4196 CaseBegin("TestRESTSubReqAndSubDelOkSameAction")
4198 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4199 Counter{cRestSubReqFromXapp, 2},
4200 Counter{cRestSubRespToXapp, 2},
4201 Counter{cSubReqToE2, 1},
4202 Counter{cSubRespFromE2, 1},
4203 Counter{cRestSubNotifToXapp, 2},
4204 Counter{cMergedSubscriptions, 1},
4205 Counter{cUnmergedSubscriptions, 1},
4206 Counter{cRestSubDelReqFromXapp, 2},
4207 Counter{cSubDelReqToE2, 1},
4208 Counter{cSubDelRespFromE2, 1},
4209 Counter{cRestSubDelRespToXapp, 2},
4213 var params *teststube2ap.RESTSubsReqParams = nil
4216 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4217 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
4220 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4221 params.SetMeid("RAN_NAME_1")
4223 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
4224 xappConn2.ExpectAnyNotification(t)
4225 waiter := rtmgrHttp.AllocNextSleep(10, true)
4226 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4227 waiter.WaitResult(t)
4228 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
4229 e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
4230 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId2)
4232 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
4235 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4238 deleteXapp2Subscription(t, &restSubId2)
4240 //Wait that subs is cleaned
4241 waitSubsCleanup(t, e2SubsId2, 10)
4243 mainCtrl.VerifyCounterValues(t)
4246 //-----------------------------------------------------------------------------
4247 // TestSubReqAndSubDelOkSameActionParallel
4250 // +-------+ +-------+ +---------+ +---------+
4251 // | xapp2 | | xapp1 | | submgr | | e2term |
4252 // +-------+ +-------+ +---------+ +---------+
4257 // | |------------->| |
4260 // | | |------------->|
4262 // |--------------------------->| |
4264 // | | |<-------------|
4266 // | |<-------------| |
4268 // | | |------------->|
4271 // | | |<-------------|
4273 // |<---------------------------| |
4275 // | | SubDelReq 1 | |
4276 // | |------------->| |
4278 // | | SubDelResp 1 | |
4279 // | |<-------------| |
4281 // | SubDelReq 2 | |
4282 // |--------------------------->| |
4284 // | | | SubDelReq 2 |
4285 // | | |------------->|
4287 // | | | SubDelReq 2 |
4288 // | | |------------->|
4290 // | SubDelResp 2 | |
4291 // |<---------------------------| |
4293 func TestRESTSubReqAndSubDelOkSameActionParallel(t *testing.T) {
4294 CaseBegin("TestRESTSubReqAndSubDelOkSameActionParallel")
4296 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4297 Counter{cRestSubReqFromXapp, 2},
4298 Counter{cRestSubRespToXapp, 2},
4299 Counter{cSubReqToE2, 2},
4300 Counter{cSubRespFromE2, 2},
4301 Counter{cRestSubNotifToXapp, 2},
4302 Counter{cRestSubDelReqFromXapp, 2},
4303 Counter{cSubDelReqToE2, 2},
4304 Counter{cSubDelRespFromE2, 2},
4305 Counter{cRestSubDelRespToXapp, 2},
4308 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4309 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4310 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4312 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4313 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4315 xappConn1.ExpectRESTNotification(t, restSubId1)
4316 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4317 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
4319 xappConn2.ExpectRESTNotification(t, restSubId2)
4320 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
4321 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
4322 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4325 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4326 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4327 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4328 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
4331 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4332 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
4333 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
4335 waitSubsCleanup(t, e2SubsId2, 10)
4337 mainCtrl.VerifyCounterValues(t)
4340 //-----------------------------------------------------------------------------
4341 // TestRESTSubReqAndSubDelNoAnswerSameActionParallel
4344 // +-------+ +-------+ +---------+ +---------+
4345 // | xapp2 | | xapp1 | | submgr | | e2term |
4346 // +-------+ +-------+ +---------+ +---------+
4350 // | | RESTSubReq1 | |
4351 // | |---------------->| |
4353 // | | RESTSubResp1 | |
4354 // | |<----------------| |
4356 // | | |------------->|
4357 // | RESTSubReq2 | |
4358 // |------------------------------>| |
4360 // | RESTSubResp2 | |
4361 // |<------------------------------| |
4363 // | | |------------->|
4366 // | | | SubDelReq |
4367 // | | |------------->|
4369 // | | | SubDelResp |
4370 // | | |<-------------|
4371 // | | RESTNotif1 | |
4372 // | | unsuccess | |
4373 // | |<----------------| |
4375 // | | unsuccess | |
4376 // |<------------------------------| |
4378 // | | RESTSubDelReq1 | |
4379 // | |---------------->| |
4381 // | | RESTSubDelResp1 | |
4382 // | |<----------------| |
4384 // | RESTSubDelReq2 | |
4385 // |------------------------------>| |
4387 // | RESTSubDelResp2 | |
4388 // |<------------------------------| |
4390 //-----------------------------------------------------------------------------
4391 func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
4392 CaseBegin("TestRESTSubReqAndSubDelNoAnswerSameActionParallel")
4394 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4395 Counter{cRestSubReqFromXapp, 2},
4396 Counter{cMergedSubscriptions, 1},
4397 Counter{cRestSubRespToXapp, 2},
4398 Counter{cSubReqToE2, 1},
4399 Counter{cSubReqTimerExpiry, 2},
4400 Counter{cSubReReqToE2, 1},
4401 Counter{cRestSubFailNotifToXapp, 2},
4402 Counter{cRestSubDelReqFromXapp, 2},
4403 Counter{cSubDelReqToE2, 1},
4404 Counter{cSubDelRespFromE2, 1},
4405 Counter{cRestSubDelRespToXapp, 2},
4407 const subReqCount int = 1
4410 params1 := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4411 restSubId1 := xappConn1.SendRESTSubsReq(t, params1)
4412 crereq1, _ := e2termConn1.RecvSubsReq(t)
4415 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
4416 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4417 params2.SetMeid("RAN_NAME_1")
4418 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4419 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
4421 //Req1 (retransmitted)
4422 e2termConn1.RecvSubsReq(t)
4424 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4426 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
4427 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4429 e2SubsIdA := <-xappConn1.ListedRESTNotifications
4430 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
4431 e2SubsIdB := <-xappConn1.ListedRESTNotifications
4432 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
4435 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4438 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4440 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId, e2SubsIdB.E2SubsId}, 10)
4442 //Wait that subs is cleaned
4443 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
4445 mainCtrl.VerifyCounterValues(t)
4448 //-----------------------------------------------------------------------------
4449 // TestRESTSubReqAndSubDelNokSameActionParallel
4452 // +-------+ +-------+ +---------+ +---------+
4453 // | xapp2 | | xapp1 | | submgr | | e2term |
4454 // +-------+ +-------+ +---------+ +---------+
4458 // | | RESTSubReq1 | |
4459 // | |---------------->| |
4461 // | | RESTSubResp1 | |
4462 // | |<----------------| |
4464 // | | |------------->|
4465 // | RESTSubReq2 | |
4466 // |------------------------------>| |
4468 // | RESTSubDelResp2 | |
4469 // |<------------------------------| |
4471 // | | |<-------------|
4473 // | | RESTNotif1 | |
4474 // | | unsuccess | |
4475 // | |<----------------| |
4477 // | | unsuccess | |
4478 // |<------------------------------| |
4480 // | | RESTSubDelReq1 | | There is no need for xApp to send delete for failed subscriptions but some xApp might do so.
4481 // | |---------------->| |
4483 // | | RESTSubDelResp1 | |
4484 // | |<----------------| |
4486 // | RESTSubDelReq2 | |
4487 // |------------------------------>| |
4489 // | RESTSubDelResp2 | |
4490 // |<------------------------------| |
4492 //-----------------------------------------------------------------------------
4493 func TestRESTSubReqAndSubDelNokSameActionParallel(t *testing.T) {
4494 CaseBegin("TestRESTSubReqAndSubDelNokSameActionParallel")
4496 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4497 Counter{cRestSubReqFromXapp, 2},
4498 Counter{cMergedSubscriptions, 1},
4499 Counter{cRestSubRespToXapp, 2},
4500 Counter{cSubReqToE2, 1},
4501 Counter{cSubFailFromE2, 1},
4502 Counter{cRestSubFailNotifToXapp, 2},
4503 Counter{cRestSubDelReqFromXapp, 2},
4504 Counter{cRestSubDelRespToXapp, 2},
4507 const subReqCount int = 1
4510 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4511 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4512 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4515 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
4516 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
4517 params2.SetMeid("RAN_NAME_1")
4518 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
4519 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
4521 // E2t: send SubsFail (first)
4522 fparams1 := &teststube2ap.E2StubSubsFailParams{}
4523 fparams1.Set(crereq1)
4524 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
4526 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
4527 e2SubsIdA := <-xappConn1.ListedRESTNotifications
4528 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
4529 e2SubsIdB := <-xappConn1.ListedRESTNotifications
4530 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
4533 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4536 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
4538 //Wait that subs is cleaned
4539 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
4540 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
4542 mainCtrl.VerifyCounterValues(t)
4545 func TestRESTSubReqPolicyAndSubDelOk(t *testing.T) {
4546 CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
4548 // Init counter check
4549 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4550 Counter{cRestSubReqFromXapp, 1},
4551 Counter{cRestSubRespToXapp, 1},
4552 Counter{cSubReqToE2, 1},
4553 Counter{cSubRespFromE2, 1},
4554 Counter{cRestSubNotifToXapp, 1},
4555 Counter{cRestSubDelReqFromXapp, 1},
4556 Counter{cSubDelReqToE2, 1},
4557 Counter{cSubDelRespFromE2, 1},
4558 Counter{cRestSubDelRespToXapp, 1},
4561 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4562 restSubId := xappConn1.SendRESTSubsReq(t, params)
4563 xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
4565 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4566 xappConn1.ExpectRESTNotification(t, restSubId)
4567 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4568 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4569 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
4571 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4572 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4573 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4575 // Wait that subs is cleaned
4576 waitSubsCleanup(t, e2SubsId, 10)
4577 mainCtrl.VerifyCounterValues(t)
4580 //-----------------------------------------------------------------------------
4581 // TestRESTSubReqPolicyChangeAndSubDelOk
4584 // +-------+ +---------+ +---------+
4585 // | xapp | | submgr | | e2term |
4586 // +-------+ +---------+ +---------+
4589 // |---------------->| |
4591 // | RESTSubResp | |
4592 // |<----------------| |
4594 // | |------------->|
4597 // | |<-------------|
4600 // |<----------------| |
4603 // |---------------->| |
4605 // | RESTSubResp | |
4606 // |<----------------| |
4608 // | |------------->|
4611 // | |<-------------|
4614 // |<----------------| |
4616 // | RESTSubDelReq | |
4617 // |---------------->| |
4620 // | |------------->|
4623 // | |<-------------|
4625 // | RESTSubDelResp | |
4626 // |<----------------| |
4628 //-----------------------------------------------------------------------------
4629 func TestRESTSubReqPolicyChangeAndSubDelOk(t *testing.T) {
4630 CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
4632 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4633 Counter{cRestSubReqFromXapp, 2},
4634 Counter{cRestSubRespToXapp, 2},
4635 Counter{cSubReqToE2, 2},
4636 Counter{cSubRespFromE2, 2},
4637 Counter{cRestSubNotifToXapp, 2},
4638 Counter{cRestSubDelReqFromXapp, 1},
4639 Counter{cSubDelReqToE2, 1},
4640 Counter{cSubDelRespFromE2, 1},
4641 Counter{cRestSubDelRespToXapp, 1},
4644 const subReqCount int = 1
4645 const e2Timeout int64 = 1
4646 const e2RetryCount int64 = 0
4647 const routingNeeded bool = true
4650 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4651 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
4652 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4655 // GetRESTSubsReqPolicyParams sets some counters on tc side.
4657 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4658 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
4659 params.SetSubscriptionID(&restSubId)
4660 params.SetTimeToWait("w200ms")
4661 restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
4664 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4666 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4667 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4669 // Wait that subs is cleaned
4670 waitSubsCleanup(t, e2SubsId, 10)
4671 mainCtrl.VerifyCounterValues(t)
4674 //-----------------------------------------------------------------------------
4675 // TestRESTSubReqPolicyChangeNOk
4678 // +-------+ +---------+ +---------+
4679 // | xapp | | submgr | | e2term |
4680 // +-------+ +---------+ +---------+
4683 // |---------------->| |
4685 // | RESTSubResp | |
4686 // |<----------------| |
4688 // | |------------->|
4691 // | |<-------------|
4694 // |<----------------| |
4697 // |---------------->| |
4699 // | RESTSubUpdateFail(400 Bad request)
4701 // | RESTSubDelReq | |
4702 // |---------------->| |
4705 // | |------------->|
4708 // | |<-------------|
4710 // | RESTSubDelResp | |
4711 // |<----------------| |
4713 //-----------------------------------------------------------------------------
4714 func TestRESTSubReqPolicyChangeNOk(t *testing.T) {
4715 CaseBegin("TestRESTSubReqPolicyChangeNOk")
4717 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4718 Counter{cRestSubReqFromXapp, 2},
4719 Counter{cRestSubRespToXapp, 1},
4720 Counter{cSubReqToE2, 1},
4721 Counter{cSubRespFromE2, 1},
4722 Counter{cRestSubNotifToXapp, 1},
4723 Counter{cRestSubFailToXapp, 1},
4724 Counter{cRestSubDelReqFromXapp, 1},
4725 Counter{cSubDelReqToE2, 1},
4726 Counter{cSubDelRespFromE2, 1},
4727 Counter{cRestSubDelRespToXapp, 1},
4731 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4732 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4735 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
4737 restSubIdUpd := strings.ToUpper(restSubId) // This makes RESTSubReq to fail
4738 params.SetSubscriptionID(&restSubIdUpd)
4739 params.SetTimeToWait("w200ms")
4741 restSubId2 := xappConn1.SendRESTSubsReq(t, params)
4742 assert.Equal(t, restSubId2, "")
4745 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4747 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4748 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4750 // Wait that subs is cleaned
4751 waitSubsCleanup(t, e2SubsId, 10)
4752 mainCtrl.VerifyCounterValues(t)
4755 //-----------------------------------------------------------------------------
4756 // TestRESTSubReqAndSubDelOkTwoE2termParallel
4759 // +-------+ +---------+ +---------+ +---------+
4760 // | xapp | | submgr | | e2term1 | | e2term2 |
4761 // +-------+ +---------+ +---------+ +---------+
4765 // | RESTSubReq1 | | |
4766 // |---------------->| | |
4768 // | RESTSubResp1 | | |
4769 // |<----------------| | |
4771 // | |------------->| |
4773 // | RESTSubReq2 | | |
4774 // |---------------->| | |
4776 // | RESTSubResp2 | | |
4777 // |<----------------| | |
4779 // | |---------------------------->|
4782 // | |<-------------| |
4783 // | RESTNotif1 | | |
4784 // |<----------------| | |
4786 // | |<----------------------------|
4787 // | RESTNotif2 | | |
4788 // |<----------------| | |
4790 // | [SUBS 1 DELETE] | |
4792 // | [SUBS 2 DELETE] | |
4795 //-----------------------------------------------------------------------------
4796 func TestRESTSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
4797 CaseBegin("TestRESTSubReqAndSubDelOkTwoE2termParallel")
4799 // Init counter check
4800 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4801 Counter{cRestSubReqFromXapp, 2},
4802 Counter{cRestSubRespToXapp, 2},
4803 Counter{cSubReqToE2, 2},
4804 Counter{cSubRespFromE2, 2},
4805 Counter{cRestSubNotifToXapp, 2},
4806 Counter{cRestSubDelReqFromXapp, 2},
4807 Counter{cSubDelReqToE2, 2},
4808 Counter{cSubDelRespFromE2, 2},
4809 Counter{cRestSubDelRespToXapp, 2},
4812 const subReqCount int = 1
4815 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4816 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4817 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4820 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4821 params.SetMeid("RAN_NAME_11")
4822 // Here we use xappConn2 to simulate sending second request from same xapp as doing it from xappConn1
4823 // would not work as notification would not be received
4824 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4825 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
4828 xappConn1.ExpectRESTNotification(t, restSubId1)
4829 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4830 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
4831 xapp.Logger.Debug("TEST: REST notification received e2SubsId1=%v", e2SubsId1)
4834 xappConn2.ExpectRESTNotification(t, restSubId2)
4835 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
4836 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
4837 xapp.Logger.Debug("TEST: REST notification received e2SubsId2=%v", e2SubsId2)
4840 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
4841 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
4842 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
4844 // Wait that subs is cleaned
4845 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
4848 xappConn1.SendRESTSubsDelReq(t, &restSubId2)
4849 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
4850 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
4852 // Wait that subs is cleaned
4853 waitSubsCleanup(t, e2SubsId2, 10)
4855 mainCtrl.VerifyCounterValues(t)
4858 //-----------------------------------------------------------------------------
4859 // TestRESTSubReqAsn1EncodeFail
4861 // In this case submgr send RICSubscriptionDeleteRequest after encode failure which should not happen!
4863 // +-------+ +---------+ +---------+
4864 // | xapp | | submgr | | e2term |
4865 // +-------+ +---------+ +---------+
4868 // |---------------->| |
4870 // | RESTSubResp | |
4871 // |<----------------| |
4872 // | RESTSubDelReq | |
4873 // |---------------->| |
4874 // | RESTSubDelResp | |
4876 // |<----------------| |
4879 //-----------------------------------------------------------------------------
4880 func TestRESTSubReqAsn1EncodeFail(t *testing.T) {
4881 CaseBegin("TestRESTSubReqAsn1EncodeFail")
4883 xapp.Logger.Debug("Xapp-frame, v0.8.1 sufficient REST API validation")
4887 //-----------------------------------------------------------------------------
4888 // TestRESTSubReqInsertAndSubDelOk
4891 // +-------+ +---------+ +---------+
4892 // | xapp | | submgr | | e2term |
4893 // +-------+ +---------+ +---------+
4896 // |---------------->| |
4898 // | RESTSubResp | |
4899 // |<----------------| |
4902 // | |------------->|
4905 // | |<-------------|
4907 // |<----------------| |
4910 // | RESTSubDelReq | |
4911 // |---------------->| |
4914 // | |------------->|
4917 // | |<-------------|
4919 // | RESTSubDelResp| |
4920 // |<----------------| |
4922 //-----------------------------------------------------------------------------
4923 func TestRESTSubReqInsertAndSubDelOk(t *testing.T) {
4924 CaseBegin("TestRESTInsertSubReqAndSubDelOk")
4926 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4927 Counter{cRestSubReqFromXapp, 1},
4928 Counter{cRestSubRespToXapp, 1},
4929 Counter{cSubReqToE2, 1},
4930 Counter{cSubRespFromE2, 1},
4931 Counter{cRestSubNotifToXapp, 1},
4932 Counter{cRestSubDelReqFromXapp, 1},
4933 Counter{cSubDelReqToE2, 1},
4934 Counter{cSubDelRespFromE2, 1},
4935 Counter{cRestSubDelRespToXapp, 1},
4938 const subReqCount int = 1
4940 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4941 params.SetSubActionTypes("insert")
4944 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4947 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4949 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4950 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4952 // Wait that subs is cleaned
4953 waitSubsCleanup(t, e2SubsId, 10)
4954 mainCtrl.VerifyCounterValues(t)
4957 //-----------------------------------------------------------------------------
4958 // TestRESTSubReqNokAndSubDelOkWithRestartInMiddle
4961 // +-------+ +---------+ +---------+
4962 // | xapp | | submgr | | e2term |
4963 // +-------+ +---------+ +---------+
4966 // |------------->| |
4969 // | |------------->|
4974 // | Submgr restart |
4978 // | |------------->|
4981 // | |<-------------|
4984 //-----------------------------------------------------------------------------
4985 func TestRESTSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
4986 CaseBegin("TestRESTSubReqNokAndSubDelOkWithRestartInMiddle")
4988 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4989 Counter{cRestSubReqFromXapp, 1},
4990 Counter{cRestSubRespToXapp, 1},
4991 Counter{cSubReqToE2, 1},
4992 Counter{cSubDelReqFromXapp, 1},
4993 Counter{cSubDelReqToE2, 1},
4994 Counter{cSubDelRespFromE2, 1},
4995 Counter{cRestSubFailNotifToXapp, 1},
4998 const subReqCount int = 1
5000 // Remove possible existing subscription
5001 mainCtrl.removeExistingSubscriptions(t)
5003 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5006 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
5007 restSubId := xappConn1.SendRESTSubsReq(t, params)
5008 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
5010 e2termConn1.RecvSubsReq(t)
5012 mainCtrl.SetResetTestFlag(t, false)
5014 mainCtrl.SimulateRestart(t)
5015 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
5018 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5019 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5021 xappConn1.TestMsgChanEmpty(t)
5022 xappConn2.TestMsgChanEmpty(t)
5023 e2termConn1.TestMsgChanEmpty(t)
5024 mainCtrl.wait_registry_empty(t, 10)
5026 mainCtrl.VerifyCounterValues(t)
5029 //-----------------------------------------------------------------------------
5030 // TestRESTSubReqAndSubDelOkWithRestartInMiddle
5033 // +-------+ +---------+ +---------+
5034 // | xapp | | submgr | | e2term |
5035 // +-------+ +---------+ +---------+
5038 // |---------------->| |
5040 // | RESTSubResp | |
5041 // |<----------------| |
5043 // | |------------->|
5046 // | |<-------------|
5049 // |<----------------| |
5052 // | Submgr restart |
5054 // | RESTSubDelReq | |
5055 // |---------------->| |
5058 // | |------------->|
5061 // | |<-------------|
5063 // | RESTSubDelResp | |
5064 // |<----------------| |
5066 //-----------------------------------------------------------------------------
5068 func TestRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
5069 CaseBegin("TestRESTSubReqAndSubDelOkWithRestartInMiddle")
5071 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5072 Counter{cRestSubReqFromXapp, 1},
5073 Counter{cRestSubRespToXapp, 1},
5074 Counter{cSubReqToE2, 1},
5075 Counter{cSubRespFromE2, 1},
5076 Counter{cRestSubNotifToXapp, 1},
5077 Counter{cRestSubDelReqFromXapp, 1},
5078 Counter{cSubDelReqToE2, 1},
5079 Counter{cSubDelRespFromE2, 1},
5080 Counter{cRestSubDelRespToXapp, 1},
5082 // Remove possible existing subscription
5083 mainCtrl.removeExistingSubscriptions(t)
5085 var params *teststube2ap.RESTSubsReqParams = nil
5087 // Create subscription
5088 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5089 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
5091 // Check subscription
5092 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
5094 mainCtrl.SimulateRestart(t)
5095 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
5097 // Check subscription
5098 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
5100 // Delete subscription
5101 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
5103 //Wait that subs is cleaned
5104 waitSubsCleanup(t, e2SubsId, 10)
5106 mainCtrl.VerifyCounterValues(t)
5109 //-----------------------------------------------------------------------------
5110 // TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle
5113 // +-------+ +-------+ +---------+ +---------+
5114 // | xapp2 | | xapp1 | | submgr | | e2term |
5115 // +-------+ +-------+ +---------+ +---------+
5117 // | | RESTSubReq1 | |
5118 // | |---------------->| |
5120 // | | RESTSubResp1 | |
5121 // | |<----------------| |
5124 // | | |------------->|
5126 // | | |<-------------|
5127 // | | RESTNotif1 | |
5128 // | |<----------------| |
5130 // | RESTSubReq2 | |
5131 // |------------------------------>| |
5133 // | RESTSubResp2 | |
5134 // |<------------------------------| |
5136 // | | RESTNotif2 | |
5137 // |<------------------------------| |
5139 // | | Submgr restart |
5141 // | | RESTSubDelReq1 | |
5142 // | |---------------->| |
5144 // | | RESTSubDelResp1 | |
5145 // | |<----------------| |
5147 // | | Submgr restart |
5149 // | RESTSubDelReq2 | |
5150 // |------------------------------>| |
5152 // | RESTSubDelResp2 | |
5153 // |<------------------------------| |
5155 // | | | SubDelReq2 |
5156 // | | |------------->|
5158 // | | | SubDelResp2 |
5159 // | | |<-------------|
5162 //-----------------------------------------------------------------------------
5164 func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
5165 CaseBegin("TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle")
5167 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5168 Counter{cRestSubReqFromXapp, 2},
5169 Counter{cRestSubRespToXapp, 2},
5170 Counter{cSubReqToE2, 1},
5171 Counter{cSubRespFromE2, 1},
5172 Counter{cRestSubNotifToXapp, 2},
5173 Counter{cMergedSubscriptions, 1},
5174 Counter{cUnmergedSubscriptions, 1},
5175 Counter{cRestSubDelReqFromXapp, 2},
5176 Counter{cSubDelReqToE2, 1},
5177 Counter{cSubDelRespFromE2, 1},
5178 Counter{cRestSubDelRespToXapp, 2},
5181 // Remove possible existing subscription
5182 mainCtrl.removeExistingSubscriptions(t)
5184 var params *teststube2ap.RESTSubsReqParams = nil
5186 // Create subscription 1
5187 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5188 xapp.Logger.Debug("Send REST subscriber request for subscriber 1 : %v", restSubId1)
5190 // Create subscription 2 with same action
5191 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5192 params.SetMeid("RAN_NAME_1")
5193 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
5194 xappConn2.ExpectAnyNotification(t)
5195 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5196 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5197 e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
5198 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId2)
5200 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
5202 mainCtrl.SimulateRestart(t)
5203 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
5205 // Delete subscription 1, and wait until it has removed the first endpoint
5206 subepcnt := mainCtrl.get_subs_entrypoint_cnt(t, e2SubsId1)
5207 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
5208 mainCtrl.wait_subs_entrypoint_cnt_change(t, e2SubsId1, subepcnt, 10)
5210 mainCtrl.SimulateRestart(t)
5211 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
5212 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13660"})
5214 // Delete subscription 2
5215 deleteXapp2Subscription(t, &restSubId2)
5217 //Wait that subs is cleaned
5218 waitSubsCleanup(t, e2SubsId2, 10)
5220 mainCtrl.VerifyCounterValues(t)
5223 //-----------------------------------------------------------------------------
5224 // TestRESTReportSubReqAndSubDelOk
5227 // +-------+ +---------+ +---------+
5228 // | xapp | | submgr | | e2term |
5229 // +-------+ +---------+ +---------+
5232 // |---------------->| |
5234 // | RESTSubResp | |
5235 // |<----------------| |
5238 // | |------------->|
5241 // | |<-------------|
5243 // |<----------------| |
5245 // | |------------->|
5248 // | |<-------------|
5250 // |<----------------| |
5254 // | RESTSubDelReq | |
5255 // |---------------->| |
5258 // | |------------->|
5261 // | |<-------------|
5263 // | RESTSubDelResp| |
5264 // |<----------------| |
5266 //-----------------------------------------------------------------------------
5268 func TestRESTReportSubReqAndSubDelOk(t *testing.T) {
5269 CaseBegin("TestRESTReportSubReqAndSubDelOk")
5270 const subReqCount int = 1
5272 RESTReportSubReqAndSubDelOk(t, subReqCount, testIndex)
5275 func RESTReportSubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
5276 xapp.Logger.Debug("TEST: TestRESTReportSubReqAndSubDelOk with testIndex %v", testIndex)
5279 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5280 restSubId := xappConn1.SendRESTSubsReq(t, params)
5282 var e2SubsId []uint32
5283 for i := 0; i < subReqCount; i++ {
5284 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5285 xappConn1.ExpectRESTNotification(t, restSubId)
5287 e2termConn1.SendSubsResp(t, crereq, cremsg)
5288 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5289 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
5290 e2SubsId = append(e2SubsId, instanceId)
5291 resp, _ := xapp.Subscription.QuerySubscriptions()
5292 assert.Equal(t, resp[i].SubscriptionID, (int64)(instanceId))
5293 assert.Equal(t, resp[i].Meid, "RAN_NAME_1")
5294 assert.Equal(t, resp[i].ClientEndpoint, []string{"localhost:13560"})
5299 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5301 for i := 0; i < subReqCount; i++ {
5302 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5303 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5306 // Wait that subs is cleaned
5307 for i := 0; i < subReqCount; i++ {
5308 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
5311 xappConn1.TestMsgChanEmpty(t)
5312 e2termConn1.TestMsgChanEmpty(t)
5313 mainCtrl.wait_registry_empty(t, 10)
5317 func TestRESTPolicySubReqAndSubDelOk(t *testing.T) {
5318 CaseBegin("TestRESTPolicySubReqAndSubDelOk")
5322 RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex)
5326 RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex)
5329 func RESTPolicySubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
5330 xapp.Logger.Debug("TEST: TestRESTPolicySubReqAndSubDelOk with testIndex %v", testIndex)
5333 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5334 restSubId := xappConn1.SendRESTSubsReq(t, params)
5336 var e2SubsId []uint32
5337 for i := 0; i < subReqCount; i++ {
5338 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5339 xappConn1.ExpectRESTNotification(t, restSubId)
5340 e2termConn1.SendSubsResp(t, crereq, cremsg)
5341 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5342 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
5343 e2SubsId = append(e2SubsId, instanceId)
5347 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5349 for i := 0; i < subReqCount; i++ {
5350 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5351 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5354 // Wait that subs is cleaned
5355 for i := 0; i < subReqCount; i++ {
5356 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
5358 xappConn1.TestMsgChanEmpty(t)
5359 e2termConn1.TestMsgChanEmpty(t)
5360 mainCtrl.wait_registry_empty(t, 10)
5363 func TestRESTTwoPolicySubReqAndSubDelOk(t *testing.T) {
5365 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5366 Counter{cRestSubReqFromXapp, 1},
5367 Counter{cRestSubRespToXapp, 1},
5368 Counter{cSubReqToE2, 2},
5369 Counter{cSubRespFromE2, 2},
5370 Counter{cRestSubNotifToXapp, 2},
5371 Counter{cRestSubDelReqFromXapp, 1},
5372 Counter{cSubDelReqToE2, 2},
5373 Counter{cSubDelRespFromE2, 2},
5374 Counter{cRestSubDelRespToXapp, 1},
5377 const subReqCount int = 2
5380 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5381 restSubId := xappConn1.SendRESTSubsReq(t, params)
5382 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5384 assert.Equal(t, len(e2SubsIds), 2)
5387 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5388 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5390 xappConn1.TestMsgChanEmpty(t)
5391 e2termConn1.TestMsgChanEmpty(t)
5392 mainCtrl.wait_registry_empty(t, 10)
5394 mainCtrl.VerifyCounterValues(t)
5396 func TestRESTPolicySubReqAndSubDelOkFullAmount(t *testing.T) {
5398 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5399 Counter{cRestSubReqFromXapp, 1},
5400 Counter{cRestSubRespToXapp, 1},
5401 Counter{cSubReqToE2, 19},
5402 Counter{cSubRespFromE2, 19},
5403 Counter{cRestSubNotifToXapp, 19},
5404 Counter{cRestSubDelReqFromXapp, 1},
5405 Counter{cSubDelReqToE2, 19},
5406 Counter{cSubDelRespFromE2, 19},
5407 Counter{cRestSubDelRespToXapp, 1},
5410 const subReqCount int = 19
5412 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5413 restSubId := xappConn1.SendRESTSubsReq(t, params)
5414 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5416 assert.Equal(t, len(e2SubsIds), 19)
5418 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5419 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5421 xappConn1.TestMsgChanEmpty(t)
5422 e2termConn1.TestMsgChanEmpty(t)
5423 mainCtrl.wait_registry_empty(t, 10)
5425 mainCtrl.VerifyCounterValues(t)
5428 func TestRESTTwoReportSubReqAndSubDelOk(t *testing.T) {
5432 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5433 Counter{cRestSubReqFromXapp, 1},
5434 Counter{cRestSubRespToXapp, 1},
5435 Counter{cSubReqToE2, uint64(subReqCount)},
5436 Counter{cSubRespFromE2, uint64(subReqCount)},
5437 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5438 Counter{cRestSubDelReqFromXapp, 1},
5439 Counter{cSubDelReqToE2, uint64(subReqCount)},
5440 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5441 Counter{cRestSubDelRespToXapp, 1},
5445 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5446 restSubId := xappConn1.SendRESTSubsReq(t, params)
5447 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5449 assert.Equal(t, len(e2SubsIds), subReqCount)
5452 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5453 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5455 xappConn1.TestMsgChanEmpty(t)
5456 e2termConn1.TestMsgChanEmpty(t)
5457 mainCtrl.wait_registry_empty(t, 10)
5459 mainCtrl.VerifyCounterValues(t)
5462 func TestRESTTwoReportSubReqAndSubDelOkNoActParams(t *testing.T) {
5466 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5467 Counter{cRestSubReqFromXapp, 1},
5468 Counter{cRestSubRespToXapp, 1},
5469 Counter{cSubReqToE2, uint64(subReqCount)},
5470 Counter{cSubRespFromE2, uint64(subReqCount)},
5471 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5472 Counter{cRestSubDelReqFromXapp, 1},
5473 Counter{cSubDelReqToE2, uint64(subReqCount)},
5474 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5475 Counter{cRestSubDelRespToXapp, 1},
5479 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5480 restSubId := xappConn1.SendRESTSubsReq(t, params)
5481 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5483 assert.Equal(t, len(e2SubsIds), subReqCount)
5486 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5487 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5489 xappConn1.TestMsgChanEmpty(t)
5490 e2termConn1.TestMsgChanEmpty(t)
5491 mainCtrl.wait_registry_empty(t, 10)
5493 mainCtrl.VerifyCounterValues(t)
5496 func TestRESTFullAmountReportSubReqAndSubDelOk(t *testing.T) {
5500 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5501 Counter{cRestSubReqFromXapp, 1},
5502 Counter{cRestSubRespToXapp, 1},
5503 Counter{cSubReqToE2, uint64(subReqCount)},
5504 Counter{cSubRespFromE2, uint64(subReqCount)},
5505 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
5506 Counter{cRestSubDelReqFromXapp, 1},
5507 Counter{cSubDelReqToE2, uint64(subReqCount)},
5508 Counter{cSubDelRespFromE2, uint64(subReqCount)},
5509 Counter{cRestSubDelRespToXapp, 1},
5513 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5514 restSubId := xappConn1.SendRESTSubsReq(t, params)
5515 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
5517 assert.Equal(t, len(e2SubsIds), subReqCount)
5520 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5521 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
5523 xappConn1.TestMsgChanEmpty(t)
5524 e2termConn1.TestMsgChanEmpty(t)
5525 mainCtrl.wait_registry_empty(t, 10)
5527 mainCtrl.VerifyCounterValues(t)
5530 func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(t *testing.T) {
5531 CaseBegin("TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen")
5533 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5534 Counter{cRestSubReqFromXapp, 2},
5535 Counter{cRestSubRespToXapp, 2},
5536 Counter{cSubReqToE2, 2},
5537 Counter{cSubRespFromE2, 2},
5538 Counter{cRestSubNotifToXapp, 2},
5539 Counter{cRestSubDelReqFromXapp, 2},
5540 Counter{cSubDelReqToE2, 2},
5541 Counter{cSubDelRespFromE2, 2},
5542 Counter{cRestSubDelRespToXapp, 2},
5546 var params *teststube2ap.RESTSubsReqParams = nil
5549 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5550 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5552 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5555 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5556 params.SetMeid("RAN_NAME_1")
5557 eventTriggerDefinition := []int64{1234, 1}
5558 params.SetSubEventTriggerDefinition(eventTriggerDefinition)
5560 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5561 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5562 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5563 xappConn2.ExpectRESTNotification(t, restSubId2)
5564 e2termConn1.SendSubsResp(t, crereq, cremsg)
5565 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5567 deleteXapp1Subscription(t, &restSubId1)
5568 deleteXapp2Subscription(t, &restSubId2)
5570 waitSubsCleanup(t, e2SubsId1, 10)
5571 waitSubsCleanup(t, e2SubsId2, 10)
5573 mainCtrl.VerifyCounterValues(t)
5577 func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) {
5578 CaseBegin("TestRESTSubReqReportSameActionDiffActionListLen")
5580 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5581 Counter{cRestSubReqFromXapp, 2},
5582 Counter{cRestSubRespToXapp, 2},
5583 Counter{cSubReqToE2, 2},
5584 Counter{cSubRespFromE2, 2},
5585 Counter{cRestSubNotifToXapp, 2},
5586 Counter{cRestSubDelReqFromXapp, 2},
5587 Counter{cSubDelReqToE2, 2},
5588 Counter{cSubDelRespFromE2, 2},
5589 Counter{cRestSubDelRespToXapp, 2},
5593 var params *teststube2ap.RESTSubsReqParams = nil
5596 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5597 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5599 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5602 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5603 params.SetMeid("RAN_NAME_1")
5605 actionId := int64(1)
5606 actionType := "report"
5607 actionDefinition := []int64{5678, 1}
5608 subsequestActionType := "continue"
5609 timeToWait := "w10ms"
5610 params.AppendActionToActionToBeSetupList(actionId, actionType, actionDefinition, subsequestActionType, timeToWait)
5612 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5613 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5614 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5615 xappConn2.ExpectRESTNotification(t, restSubId2)
5616 e2termConn1.SendSubsResp(t, crereq, cremsg)
5617 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5619 deleteXapp1Subscription(t, &restSubId1)
5620 deleteXapp2Subscription(t, &restSubId2)
5622 waitSubsCleanup(t, e2SubsId1, 10)
5623 waitSubsCleanup(t, e2SubsId2, 10)
5625 mainCtrl.VerifyCounterValues(t)
5629 func TestRESTSubReqReportSameActionDiffActionID(t *testing.T) {
5630 CaseBegin("TestRESTSubReqReportSameActionDiffActionID")
5632 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5633 Counter{cRestSubReqFromXapp, 2},
5634 Counter{cRestSubRespToXapp, 2},
5635 Counter{cSubReqToE2, 2},
5636 Counter{cSubRespFromE2, 2},
5637 Counter{cRestSubNotifToXapp, 2},
5638 Counter{cRestSubDelReqFromXapp, 2},
5639 Counter{cSubDelReqToE2, 2},
5640 Counter{cSubDelRespFromE2, 2},
5641 Counter{cRestSubDelRespToXapp, 2},
5645 var params *teststube2ap.RESTSubsReqParams = nil
5648 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5649 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5651 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5654 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5655 params.SetMeid("RAN_NAME_1")
5656 params.SetSubActionIDs(int64(2))
5658 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5659 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5660 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5661 xappConn2.ExpectRESTNotification(t, restSubId2)
5662 e2termConn1.SendSubsResp(t, crereq, cremsg)
5663 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5665 deleteXapp1Subscription(t, &restSubId1)
5666 deleteXapp2Subscription(t, &restSubId2)
5668 waitSubsCleanup(t, e2SubsId1, 10)
5669 waitSubsCleanup(t, e2SubsId2, 10)
5671 mainCtrl.VerifyCounterValues(t)
5675 func TestRESTSubReqDiffActionType(t *testing.T) {
5676 CaseBegin("TestRESTSubReqDiffActionType")
5678 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5679 Counter{cRestSubReqFromXapp, 2},
5680 Counter{cRestSubRespToXapp, 2},
5681 Counter{cSubReqToE2, 2},
5682 Counter{cSubRespFromE2, 2},
5683 Counter{cRestSubNotifToXapp, 2},
5684 Counter{cRestSubDelReqFromXapp, 2},
5685 Counter{cSubDelReqToE2, 2},
5686 Counter{cSubDelRespFromE2, 2},
5687 Counter{cRestSubDelRespToXapp, 2},
5690 const e2Timeout int64 = 2
5691 const e2RetryCount int64 = 2
5692 const routingNeeded bool = true
5695 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5696 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5699 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5700 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5702 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5705 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5706 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5707 params.SetMeid("RAN_NAME_1")
5709 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5710 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5711 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5712 xappConn2.ExpectRESTNotification(t, restSubId2)
5713 e2termConn1.SendSubsResp(t, crereq, cremsg)
5714 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5716 deleteXapp1Subscription(t, &restSubId1)
5717 deleteXapp2Subscription(t, &restSubId2)
5719 waitSubsCleanup(t, e2SubsId1, 10)
5720 waitSubsCleanup(t, e2SubsId2, 10)
5722 mainCtrl.VerifyCounterValues(t)
5726 func TestRESTSubReqPolicyAndSubDelOkSameAction(t *testing.T) {
5727 CaseBegin("TestRESTSubReqPolicyAndSubDelOkSameAction")
5729 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5730 Counter{cRestSubReqFromXapp, 2},
5731 Counter{cRestSubRespToXapp, 2},
5732 Counter{cSubReqToE2, 2},
5733 Counter{cSubRespFromE2, 2},
5734 Counter{cRestSubNotifToXapp, 2},
5735 Counter{cRestSubDelReqFromXapp, 2},
5736 Counter{cSubDelReqToE2, 2},
5737 Counter{cSubDelRespFromE2, 2},
5738 Counter{cRestSubDelRespToXapp, 2},
5741 const e2Timeout int64 = 2
5742 const e2RetryCount int64 = 2
5743 const routingNeeded bool = true
5746 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5747 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5750 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5751 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5753 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5756 params = xappConn2.GetRESTSubsReqPolicyParams(subReqCount)
5757 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5758 params.SetMeid("RAN_NAME_1")
5760 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5761 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5762 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5763 xappConn2.ExpectRESTNotification(t, restSubId2)
5764 e2termConn1.SendSubsResp(t, crereq, cremsg)
5765 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5767 deleteXapp1Subscription(t, &restSubId1)
5768 deleteXapp2Subscription(t, &restSubId2)
5770 waitSubsCleanup(t, e2SubsId1, 10)
5771 waitSubsCleanup(t, e2SubsId2, 10)
5773 mainCtrl.VerifyCounterValues(t)
5777 func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) {
5778 CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionLen")
5780 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5781 Counter{cRestSubReqFromXapp, 2},
5782 Counter{cRestSubRespToXapp, 2},
5783 Counter{cSubReqToE2, 2},
5784 Counter{cSubRespFromE2, 2},
5785 Counter{cRestSubNotifToXapp, 2},
5786 Counter{cRestSubDelReqFromXapp, 2},
5787 Counter{cSubDelReqToE2, 2},
5788 Counter{cSubDelRespFromE2, 2},
5789 Counter{cRestSubDelRespToXapp, 2},
5793 var params *teststube2ap.RESTSubsReqParams = nil
5796 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5797 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5799 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5802 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5803 params.SetMeid("RAN_NAME_1")
5804 actionDefinition := []int64{5678, 1}
5805 params.SetSubActionDefinition(actionDefinition)
5807 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5808 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5809 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5810 xappConn2.ExpectRESTNotification(t, restSubId2)
5811 e2termConn1.SendSubsResp(t, crereq, cremsg)
5812 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5814 deleteXapp1Subscription(t, &restSubId1)
5815 deleteXapp2Subscription(t, &restSubId2)
5817 waitSubsCleanup(t, e2SubsId1, 10)
5818 waitSubsCleanup(t, e2SubsId2, 10)
5820 mainCtrl.VerifyCounterValues(t)
5824 func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) {
5825 CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionContents")
5827 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5828 Counter{cRestSubReqFromXapp, 2},
5829 Counter{cRestSubRespToXapp, 2},
5830 Counter{cSubReqToE2, 2},
5831 Counter{cSubRespFromE2, 2},
5832 Counter{cRestSubNotifToXapp, 2},
5833 Counter{cRestSubDelReqFromXapp, 2},
5834 Counter{cSubDelReqToE2, 2},
5835 Counter{cSubDelRespFromE2, 2},
5836 Counter{cRestSubDelRespToXapp, 2},
5840 var params *teststube2ap.RESTSubsReqParams = nil
5843 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5844 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5846 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5849 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5850 params.SetMeid("RAN_NAME_1")
5851 actionDefinition := []int64{56782}
5852 params.SetSubActionDefinition(actionDefinition)
5854 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5855 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5856 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5857 xappConn2.ExpectRESTNotification(t, restSubId2)
5858 e2termConn1.SendSubsResp(t, crereq, cremsg)
5859 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5861 deleteXapp1Subscription(t, &restSubId1)
5862 deleteXapp2Subscription(t, &restSubId2)
5864 waitSubsCleanup(t, e2SubsId1, 10)
5865 waitSubsCleanup(t, e2SubsId2, 10)
5867 mainCtrl.VerifyCounterValues(t)
5871 func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) {
5872 CaseBegin("TestRESTSubReqReportSameActionDiffSubsAction")
5874 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5875 Counter{cRestSubReqFromXapp, 2},
5876 Counter{cRestSubRespToXapp, 2},
5877 Counter{cSubReqToE2, 2},
5878 Counter{cSubRespFromE2, 2},
5879 Counter{cRestSubNotifToXapp, 2},
5880 Counter{cRestSubDelReqFromXapp, 2},
5881 Counter{cSubDelReqToE2, 2},
5882 Counter{cSubDelRespFromE2, 2},
5883 Counter{cRestSubDelRespToXapp, 2},
5887 var params *teststube2ap.RESTSubsReqParams = nil
5890 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5891 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
5893 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5896 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5897 params.SetMeid("RAN_NAME_1")
5898 params.SetTimeToWait("w200ms")
5899 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5900 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5901 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5902 xappConn2.ExpectRESTNotification(t, restSubId2)
5903 e2termConn1.SendSubsResp(t, crereq, cremsg)
5904 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5906 deleteXapp1Subscription(t, &restSubId1)
5907 deleteXapp2Subscription(t, &restSubId2)
5909 waitSubsCleanup(t, e2SubsId1, 10)
5910 waitSubsCleanup(t, e2SubsId2, 10)
5912 mainCtrl.VerifyCounterValues(t)
5916 //-----------------------------------------------------------------------------
5917 // TestRESTUnpackSubscriptionResponseDecodeFail
5920 // +-------+ +---------+ +---------+
5921 // | xapp | | submgr | | e2term |
5922 // +-------+ +---------+ +---------+
5925 // |---------------->| |
5927 // | RESTSubResp | |
5928 // |<----------------| |
5931 // | |------------->|
5933 // | | SubResp | ASN.1 decode fails
5934 // | |<-------------|
5937 // | |------------->|
5939 // | | SubFail | Duplicated action
5940 // | |<-------------|
5941 // | RESTNotif (fail)| |
5942 // |<----------------| |
5945 //-----------------------------------------------------------------------------
5947 func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) {
5948 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseDecodeFail")
5949 const subReqCount int = 1
5952 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5953 restSubId := xappConn1.SendRESTSubsReq(t, params)
5955 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5956 // Decode of this response fails which will result resending original request
5957 e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_RESP)
5959 _, cremsg = e2termConn1.RecvSubsReq(t)
5961 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
5963 // Subscription already created in E2 Node.
5964 fparams := &teststube2ap.E2StubSubsFailParams{}
5966 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
5967 e2termConn1.SendSubsFail(t, fparams, cremsg)
5969 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5970 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
5972 // Wait that subs is cleaned
5973 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
5975 xappConn1.TestMsgChanEmpty(t)
5976 e2termConn1.TestMsgChanEmpty(t)
5977 mainCtrl.wait_registry_empty(t, 10)
5980 //-----------------------------------------------------------------------------
5981 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
5984 // +-------+ +---------+ +---------+
5985 // | xapp | | submgr | | e2term |
5986 // +-------+ +---------+ +---------+
5989 // |---------------->| |
5991 // | RESTSubResp | |
5992 // |<----------------| |
5995 // | |------------->|
5997 // | | SubResp | Unknown instanceId
5998 // | |<-------------|
6001 // | |------------->|
6003 // | | SubFail | Duplicated action
6004 // | |<-------------|
6005 // | RESTNotif (fail)| |
6006 // |<----------------| |
6008 // | |------------->|
6011 // | |<-------------|
6013 //-----------------------------------------------------------------------------
6015 func TestRESTUnpackSubscriptionResponseUnknownInstanceId(t *testing.T) {
6016 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseUnknownInstanceId")
6017 const subReqCount int = 1
6020 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6021 restSubId := xappConn1.SendRESTSubsReq(t, params)
6023 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6025 // Unknown instanceId in this response which will result resending original request
6026 orgInstanceId := crereq.RequestId.InstanceId
6027 crereq.RequestId.InstanceId = 0
6028 e2termConn1.SendSubsResp(t, crereq, cremsg)
6030 _, cremsg = e2termConn1.RecvSubsReq(t)
6032 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6034 // Subscription already created in E2 Node.
6035 fparams := &teststube2ap.E2StubSubsFailParams{}
6037 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6038 e2termConn1.SendSubsFail(t, fparams, cremsg)
6040 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6041 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6043 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6044 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6046 // Wait that subs is cleaned
6047 mainCtrl.wait_subs_clean(t, orgInstanceId, 10)
6049 xappConn1.TestMsgChanEmpty(t)
6050 e2termConn1.TestMsgChanEmpty(t)
6051 mainCtrl.wait_registry_empty(t, 10)
6054 //-----------------------------------------------------------------------------
6055 // TestRESTUnpackSubscriptionResponseNoTransaction
6058 // +-------+ +---------+ +---------+
6059 // | xapp | | submgr | | e2term |
6060 // +-------+ +---------+ +---------+
6063 // |---------------->| |
6065 // | RESTSubResp | |
6066 // |<----------------| |
6069 // | |------------->|
6071 // | | SubResp | No transaction for the response
6072 // | |<-------------|
6075 // | |------------->|
6077 // | | SubFail | Duplicated action
6078 // | |<-------------|
6079 // | RESTNotif (fail)| |
6080 // |<----------------| |
6082 // | |------------->|
6085 // | |<-------------|
6088 // | |------------->|
6091 // | |<-------------|
6093 //-----------------------------------------------------------------------------
6094 func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) {
6095 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseNoTransaction")
6096 const subReqCount int = 1
6099 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6100 restSubId := xappConn1.SendRESTSubsReq(t, params)
6102 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6104 mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
6105 // No transaction exist for this response which will result resending original request
6106 e2termConn1.SendSubsResp(t, crereq, cremsg)
6108 _, cremsg = e2termConn1.RecvSubsReq(t)
6110 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6112 // Subscription already created in E2 Node.
6113 fparams := &teststube2ap.E2StubSubsFailParams{}
6115 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6116 e2termConn1.SendSubsFail(t, fparams, cremsg)
6118 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6119 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6121 // Resending happens because there no transaction
6122 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6123 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6125 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6126 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6128 // Wait that subs is cleaned
6129 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6131 xappConn1.TestMsgChanEmpty(t)
6132 e2termConn1.TestMsgChanEmpty(t)
6133 mainCtrl.wait_registry_empty(t, 10)
6137 //-----------------------------------------------------------------------------
6138 // TestRESTUnpackSubscriptionFailureDecodeFail
6141 // +-------+ +---------+ +---------+
6142 // | xapp | | submgr | | e2term |
6143 // +-------+ +---------+ +---------+
6146 // |---------------->| |
6148 // | RESTSubResp | |
6149 // |<----------------| |
6152 // | |------------->|
6154 // | | SubFail | ASN.1 decode fails
6155 // | |<-------------|
6158 // | |------------->|
6160 // | | SubFail | Duplicated action
6161 // | |<-------------|
6162 // | RESTNotif (fail)| |
6163 // |<----------------| |
6166 //-----------------------------------------------------------------------------
6167 func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) {
6168 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureDecodeFail")
6169 const subReqCount int = 1
6172 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6173 restSubId := xappConn1.SendRESTSubsReq(t, params)
6175 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6177 // Decode of this response fails which will result resending original request
6178 e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_FAILURE)
6180 _, cremsg = e2termConn1.RecvSubsReq(t)
6182 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6184 // Subscription already created in E2 Node.
6185 fparams := &teststube2ap.E2StubSubsFailParams{}
6187 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6188 e2termConn1.SendSubsFail(t, fparams, cremsg)
6190 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6191 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6193 // Wait that subs is cleaned
6194 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6196 xappConn1.TestMsgChanEmpty(t)
6197 e2termConn1.TestMsgChanEmpty(t)
6198 mainCtrl.wait_registry_empty(t, 10)
6201 //-----------------------------------------------------------------------------
6202 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
6205 // +-------+ +---------+ +---------+
6206 // | xapp | | submgr | | e2term |
6207 // +-------+ +---------+ +---------+
6210 // |---------------->| |
6212 // | RESTSubResp | |
6213 // |<----------------| |
6216 // | |------------->|
6218 // | | SubFail | Unknown instanceId
6219 // | |<-------------|
6222 // | |------------->|
6224 // | | SubFail | Duplicated action
6225 // | |<-------------|
6226 // | RESTNotif (fail)| |
6227 // |<----------------| |
6229 // | |------------->|
6232 // | |<-------------|
6234 //-----------------------------------------------------------------------------
6235 func TestRESTUnpackSubscriptionFailureUnknownInstanceId(t *testing.T) {
6236 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureUnknownInstanceId")
6237 const subReqCount int = 1
6240 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6241 restSubId := xappConn1.SendRESTSubsReq(t, params)
6243 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6245 // Unknown instanceId in this response which will result resending original request
6246 fparams := &teststube2ap.E2StubSubsFailParams{}
6248 fparams.Fail.RequestId.InstanceId = 0
6249 e2termConn1.SendSubsFail(t, fparams, cremsg)
6251 _, cremsg = e2termConn1.RecvSubsReq(t)
6253 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6255 // Subscription already created in E2 Node.
6256 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6257 e2termConn1.SendSubsFail(t, fparams, cremsg)
6259 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6260 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6262 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6263 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6265 // Wait that subs is cleaned
6266 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6268 xappConn1.TestMsgChanEmpty(t)
6269 e2termConn1.TestMsgChanEmpty(t)
6270 mainCtrl.wait_registry_empty(t, 10)
6273 //-----------------------------------------------------------------------------
6274 // TestRESTUnpackSubscriptionFailureNoTransaction
6277 // +-------+ +---------+ +---------+
6278 // | xapp | | submgr | | e2term |
6279 // +-------+ +---------+ +---------+
6282 // |---------------->| |
6284 // | RESTSubResp | |
6285 // |<----------------| |
6288 // | |------------->|
6290 // | | SubFail | No transaction for the response
6291 // | |<-------------|
6294 // | |------------->|
6296 // | | SubFail | Duplicated action
6297 // | |<-------------|
6298 // | RESTNotif (fail)| |
6299 // |<----------------| |
6301 // | |------------->|
6304 // | |<-------------|
6306 //-----------------------------------------------------------------------------
6307 func TestRESTUnpackSubscriptionFailureNoTransaction(t *testing.T) {
6308 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureNoTransaction")
6309 const subReqCount int = 1
6312 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6313 restSubId := xappConn1.SendRESTSubsReq(t, params)
6315 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6317 mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
6319 // No transaction exist for this response which will result resending original request
6320 fparams := &teststube2ap.E2StubSubsFailParams{}
6322 e2termConn1.SendSubsFail(t, fparams, cremsg)
6324 _, cremsg = e2termConn1.RecvSubsReq(t)
6326 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6328 // Subscription already created in E2 Node.
6329 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
6330 e2termConn1.SendSubsFail(t, fparams, cremsg)
6332 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6333 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6335 // Resending happens because there no transaction
6336 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6337 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6339 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6340 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6342 // Wait that subs is cleaned
6343 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
6345 xappConn1.TestMsgChanEmpty(t)
6346 e2termConn1.TestMsgChanEmpty(t)
6347 mainCtrl.wait_registry_empty(t, 10)
6350 //-----------------------------------------------------------------------------
6351 // TestRESTUnpackSubscriptionDeleteResponseDecodeFail
6354 // +-------+ +---------+ +---------+
6355 // | xapp | | submgr | | e2term |
6356 // +-------+ +---------+ +---------+
6358 // | [SUBS CREATE] |
6361 // | RESTSubDelReq | |
6362 // |---------------->| |
6364 // | RESTSubDelResp | |
6365 // |<----------------| |
6368 // | |------------->|
6370 // | | SubDelResp | ASN.1 decode fails
6371 // | |<-------------|
6374 // | |------------->|
6376 // | | SubDelFail | Subscription does exist any more
6377 // | |<-------------|
6380 //-----------------------------------------------------------------------------
6381 func TestRESTUnpackSubscriptionDeleteResponseDecodeFail(t *testing.T) {
6382 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseDecodeFail")
6385 var params *teststube2ap.RESTSubsReqParams = nil
6386 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6389 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6391 // E2t: Receive 1st SubsDelReq
6392 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6394 // Decode of this response fails which will result resending original request
6395 e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_REQ)
6397 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
6398 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6400 // Subscription does not exist in in E2 Node.
6401 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6403 // Wait that subs is cleaned
6404 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6406 xappConn1.TestMsgChanEmpty(t)
6407 e2termConn1.TestMsgChanEmpty(t)
6408 mainCtrl.wait_registry_empty(t, 10)
6411 //-----------------------------------------------------------------------------
6412 // TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId
6415 // +-------+ +---------+ +---------+
6416 // | xapp | | submgr | | e2term |
6417 // +-------+ +---------+ +---------+
6419 // | [SUBS CREATE] |
6422 // | RESTSubDelReq | |
6423 // |---------------->| |
6425 // | RESTSubDelResp | |
6426 // |<----------------| |
6429 // | |------------->|
6431 // | | SubDelResp | Unknown instanceId
6432 // | |<-------------|
6435 // | |------------->|
6437 // | | SubDelFail | Subscription does exist any more
6438 // | |<-------------|
6440 //-----------------------------------------------------------------------------
6441 func TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId(t *testing.T) {
6442 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId")
6445 var params *teststube2ap.RESTSubsReqParams = nil
6446 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6449 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6451 // E2t: Receive 1st SubsDelReq
6452 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6454 // Unknown instanceId in this response which will result resending original request
6455 delreq.RequestId.InstanceId = 0
6456 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6458 // E2t: Receive 2nd SubsDelReq
6459 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6461 // Subscription does not exist in in E2 Node.
6462 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6464 // Wait that subs is cleaned
6465 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6467 xappConn1.TestMsgChanEmpty(t)
6468 e2termConn1.TestMsgChanEmpty(t)
6469 mainCtrl.wait_registry_empty(t, 10)
6472 //-----------------------------------------------------------------------------
6473 // TestRESTUnpackSubscriptionDeleteResponseNoTransaction
6476 // +-------+ +---------+ +---------+
6477 // | xapp | | submgr | | e2term |
6478 // +-------+ +---------+ +---------+
6480 // | [SUBS CREATE] |
6483 // | RESTSubDelReq | |
6484 // |---------------->| |
6486 // | RESTSubDelResp | |
6487 // |<----------------| |
6490 // | |------------->|
6492 // | | SubDelResp | No transaction for the response
6493 // | |<-------------|
6496 // | |------------->|
6498 // | | SubDelFail | Subscription does exist any more
6499 // | |<-------------|
6501 //-----------------------------------------------------------------------------
6502 func TestRESTUnpackSubscriptionDeleteResponseNoTransaction(t *testing.T) {
6503 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseNoTransaction")
6506 var params *teststube2ap.RESTSubsReqParams = nil
6507 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6510 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6512 // E2t: Receive 1st SubsDelReq
6513 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6515 mainCtrl.MakeTransactionNil(t, e2SubsId)
6517 // No transaction exist for this response which will result resending original request
6518 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6520 // E2t: Receive 2nd SubsDelReq
6521 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6523 // Subscription does not exist in in E2 Node.
6524 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6526 // Wait that subs is cleaned
6527 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6529 xappConn1.TestMsgChanEmpty(t)
6530 e2termConn1.TestMsgChanEmpty(t)
6531 mainCtrl.wait_registry_empty(t, 10)
6534 //-----------------------------------------------------------------------------
6535 // TestRESTUnpackSubscriptionDeleteFailureDecodeFail
6538 // +-------+ +---------+ +---------+
6539 // | xapp | | submgr | | e2term |
6540 // +-------+ +---------+ +---------+
6542 // | [SUBS CREATE] |
6545 // | RESTSubDelReq | |
6546 // |---------------->| |
6548 // | RESTSubDelResp | |
6549 // |<----------------| |
6552 // | |------------->|
6554 // | | SubDelFail | ASN.1 decode fails
6555 // | |<-------------|
6558 // | |------------->|
6560 // | | SubDelFail | Subscription does exist any more
6561 // | |<-------------|
6563 //-----------------------------------------------------------------------------
6564 func TestRESTUnpackSubscriptionDeleteFailureDecodeFail(t *testing.T) {
6565 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteFailureDecodeFail")
6568 var params *teststube2ap.RESTSubsReqParams = nil
6569 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6572 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6574 // E2t: Receive 1st SubsDelReq
6575 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6577 // Decode of this response fails which will result resending original request
6578 e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_FAILURE)
6580 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
6581 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6583 // Subscription does not exist in in E2 Node.
6584 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6586 // Wait that subs is cleaned
6587 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6589 xappConn1.TestMsgChanEmpty(t)
6590 e2termConn1.TestMsgChanEmpty(t)
6591 mainCtrl.wait_registry_empty(t, 10)
6594 //-----------------------------------------------------------------------------
6595 // TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId
6598 // +-------+ +---------+ +---------+
6599 // | xapp | | submgr | | e2term |
6600 // +-------+ +---------+ +---------+
6602 // | [SUBS CREATE] |
6605 // | RESTSubDelReq | |
6606 // |---------------->| |
6608 // | RESTSubDelResp | |
6609 // |<----------------| |
6612 // | |------------->|
6614 // | | SubDelFail | Unknown instanceId
6615 // | |<-------------|
6618 // | |------------->|
6620 // | | SubDelFail | Subscription does exist any more
6621 // | |<-------------|
6623 //-----------------------------------------------------------------------------
6624 func TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId(t *testing.T) {
6625 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId")
6628 var params *teststube2ap.RESTSubsReqParams = nil
6629 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6632 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6634 // E2t: Receive 1st SubsDelReq
6635 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6637 // Unknown instanceId in this response which will result resending original request
6638 delreq.RequestId.InstanceId = 0
6639 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6641 // E2t: Receive 2nd SubsDelReq
6642 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6644 // Subscription does not exist in in E2 Node.
6645 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6647 // Wait that subs is cleaned
6648 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6650 xappConn1.TestMsgChanEmpty(t)
6651 e2termConn1.TestMsgChanEmpty(t)
6652 mainCtrl.wait_registry_empty(t, 10)
6655 //-----------------------------------------------------------------------------
6656 // TestRESTUnpackSubscriptionDeleteFailureNoTransaction
6659 // +-------+ +---------+ +---------+
6660 // | xapp | | submgr | | e2term |
6661 // +-------+ +---------+ +---------+
6663 // | [SUBS CREATE] |
6666 // | RESTSubDelReq | |
6667 // |---------------->| |
6669 // | RESTSubDelResp | |
6670 // |<----------------| |
6673 // | |------------->|
6675 // | | SubDelFail | No transaction for the response
6676 // | |<-------------|
6679 // | |------------->|
6681 // | | SubDelFail | Subscription does exist any more
6682 // | |<-------------|
6684 //-----------------------------------------------------------------------------
6685 func TestRESTUnpackSubscriptionDeleteFailureNoTransaction(t *testing.T) {
6686 xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteFailureNoTransaction")
6689 var params *teststube2ap.RESTSubsReqParams = nil
6690 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6693 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6695 // E2t: Receive 1st SubsDelReq
6696 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6698 mainCtrl.MakeTransactionNil(t, e2SubsId)
6700 // No transaction exist for this response which will result resending original request
6701 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6703 // E2t: Receive 2nd SubsDelReq
6704 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
6706 // Subscription does not exist in in E2 Node.
6707 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
6709 // Wait that subs is cleaned
6710 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
6712 xappConn1.TestMsgChanEmpty(t)
6713 e2termConn1.TestMsgChanEmpty(t)
6714 mainCtrl.wait_registry_empty(t, 10)
6717 //-----------------------------------------------------------------------------
6718 // TestRESTSubReqFailAsn1PackSubReqError
6721 // +-------+ +---------+ +---------+
6722 // | xapp | | submgr | | e2term |
6723 // +-------+ +---------+ +---------+
6726 // |---------------->| |
6728 // | RESTSubResp | |
6729 // |<----------------| |
6731 // | ASN.1 encode fails |
6734 // | |------------->|
6737 // | |<-------------|
6741 // |<----------------| |
6743 // | [SUBS DELETE] |
6746 //-----------------------------------------------------------------------------
6747 func TestRESTSubReqFailAsn1PackSubReqError(t *testing.T) {
6749 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6750 Counter{cRestSubReqFromXapp, 1},
6751 Counter{cRestSubRespToXapp, 1},
6752 Counter{cRestSubFailNotifToXapp, 1},
6755 const subReqCount int = 1
6757 var params *teststube2ap.RESTSubsReqParams = nil
6758 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
6759 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, false)
6762 restSubId := xappConn1.SendRESTSubsReq(t, params)
6763 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
6765 // E2t: Receive SubsDelReq
6766 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
6768 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6769 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
6771 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, true)
6772 // Wait that subs is cleaned
6773 waitSubsCleanup(t, e2SubsId, 10)
6774 mainCtrl.VerifyCounterValues(t)
6777 func TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction(t *testing.T) {
6778 CaseBegin("TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction")
6780 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6781 Counter{cRestSubReqFromXapp, 2},
6782 Counter{cRestSubRespToXapp, 2},
6783 Counter{cSubReqToE2, 2},
6784 Counter{cSubReqTimerExpiry, 1},
6785 Counter{cSubRespFromE2, 1},
6786 Counter{cRestSubNotifToXapp, 1},
6787 Counter{cRestSubFailNotifToXapp, 1},
6788 Counter{cRestSubDelReqFromXapp, 1},
6789 Counter{cSubDelReqToE2, 1},
6790 Counter{cSubDelRespFromE2, 1},
6791 Counter{cRestSubDelRespToXapp, 1},
6794 const e2Timeout int64 = 1
6795 const e2RetryCount int64 = 0
6796 const routingNeeded bool = false
6799 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6800 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
6803 restSubId := xappConn1.SendRESTSubsReq(t, params)
6804 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
6806 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
6807 xappConn1.ExpectRESTNotification(t, restSubId)
6808 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
6809 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6810 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
6813 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6814 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
6815 params.SetSubscriptionID(&restSubId)
6816 params.SetTimeToWait("w200ms")
6817 restSubId = xappConn1.SendRESTSubsReq(t, params)
6818 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
6820 crereq1, cremsg1 = e2termConn1.RecvSubsReq(t)
6821 xappConn1.ExpectRESTNotification(t, restSubId)
6822 // SubsResp is missing, e2SubsId will be 0
6823 zeroE2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6824 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", zeroE2SubsId)
6827 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6828 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6829 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6831 waitSubsCleanup(t, e2SubsId, 10)
6833 mainCtrl.VerifyCounterValues(t)
6836 //-----------------------------------------------------------------------------
6837 // TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle
6840 // +-------+ +---------+ +---------+
6841 // | xapp | | submgr | | e2term |
6842 // +-------+ +---------+ +---------+
6845 // |---------------->| |
6847 // | RESTSubResp | |
6848 // |<----------------| |
6850 // | |------------->|
6853 // | |<-------------|
6856 // |<----------------| |
6859 // |---------------->| |
6861 // | RESTSubResp | |
6862 // |<----------------| |
6864 // | |------------->|
6866 // | Submgr restart |
6868 // | RESTSubDelReq | |
6869 // |---------------->| |
6872 // | |------------->|
6875 // | |<-------------|
6877 // | RESTSubDelResp | |
6878 // |<----------------| |
6880 //-----------------------------------------------------------------------------
6882 func TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
6883 CaseBegin("TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle")
6885 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6886 Counter{cRestSubReqFromXapp, 2},
6887 Counter{cRestSubRespToXapp, 2},
6888 Counter{cSubReqToE2, 2},
6889 Counter{cSubRespFromE2, 1},
6890 Counter{cRestSubNotifToXapp, 1},
6891 Counter{cRestSubFailNotifToXapp, 1},
6892 Counter{cRestSubDelReqFromXapp, 1},
6893 Counter{cSubDelReqToE2, 1},
6894 Counter{cSubDelRespFromE2, 1},
6895 Counter{cRestSubDelRespToXapp, 1},
6898 // Remove possible existing subscription
6899 mainCtrl.removeExistingSubscriptions(t)
6901 const e2Timeout int64 = 1
6902 const e2RetryCount int64 = 0
6903 const routingNeeded bool = false
6906 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6907 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
6908 // Create subscription
6909 restSubId := xappConn1.SendRESTSubsReq(t, params)
6910 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
6912 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
6913 xappConn1.ExpectRESTNotification(t, restSubId)
6914 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
6915 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
6916 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
6918 // Check subscription
6919 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
6922 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6923 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
6924 params.SetSubscriptionID(&restSubId)
6925 params.SetTimeToWait("w200ms")
6926 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
6927 restSubId = xappConn1.SendRESTSubsReq(t, params)
6928 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
6930 crereq1, cremsg1 = e2termConn1.RecvSubsReq(t)
6931 mainCtrl.SetResetTestFlag(t, false)
6933 // SubsResp is missing due to submgr restart
6935 mainCtrl.SimulateRestart(t)
6936 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
6938 // Check subscription
6939 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
6941 // Delete subscription
6942 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6943 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6944 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6946 //Wait that subs is cleaned
6947 waitSubsCleanup(t, e2SubsId, 10)
6949 mainCtrl.VerifyCounterValues(t)
6952 ////////////////////////////////////////////////////////////////////////////////////
6953 // Services for UT cases
6954 ////////////////////////////////////////////////////////////////////////////////////
6955 const subReqCount int = 1
6956 const host string = "localhost"
6958 func createSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, params *teststube2ap.RESTSubsReqParams) (string, uint32) {
6960 params = fromXappConn.GetRESTSubsReqReportParams(subReqCount)
6962 restSubId := fromXappConn.SendRESTSubsReq(t, params)
6963 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
6965 crereq1, cremsg1 := toE2termConn.RecvSubsReq(t)
6966 fromXappConn.ExpectRESTNotification(t, restSubId)
6967 toE2termConn.SendSubsResp(t, crereq1, cremsg1)
6968 e2SubsId := fromXappConn.WaitRESTNotification(t, restSubId)
6969 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
6971 return restSubId, e2SubsId
6974 func createXapp2MergedSubscription(t *testing.T, meid string) (string, uint32) {
6976 params := xappConn2.GetRESTSubsReqReportParams(subReqCount)
6978 params.SetMeid(meid)
6980 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
6981 restSubId := xappConn2.SendRESTSubsReq(t, params)
6982 xappConn2.ExpectRESTNotification(t, restSubId)
6983 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
6984 e2SubsId := xappConn2.WaitRESTNotification(t, restSubId)
6985 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
6987 return restSubId, e2SubsId
6990 func createXapp1PolicySubscription(t *testing.T) (string, uint32) {
6992 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6993 restSubId := xappConn1.SendRESTSubsReq(t, params)
6994 xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
6996 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
6997 xappConn1.ExpectRESTNotification(t, restSubId)
6998 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
6999 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
7000 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
7002 return restSubId, e2SubsId
7005 func createXapp1ReportSubscriptionE2Fail(t *testing.T) (string, uint32) {
7006 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
7007 restSubId := xappConn1.SendRESTSubsReq(t, params)
7009 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
7010 fparams1 := &teststube2ap.E2StubSubsFailParams{}
7011 fparams1.Set(crereq1)
7012 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
7014 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
7015 xappConn1.ExpectRESTNotification(t, restSubId)
7016 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
7017 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
7018 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
7020 return restSubId, e2SubsId
7023 func deleteSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId *string) {
7024 fromXappConn.SendRESTSubsDelReq(t, restSubId)
7025 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
7026 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
7029 func deleteXapp1Subscription(t *testing.T, restSubId *string) {
7030 xappConn1.SendRESTSubsDelReq(t, restSubId)
7031 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7032 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7035 func deleteXapp2Subscription(t *testing.T, restSubId *string) {
7036 xappConn2.SendRESTSubsDelReq(t, restSubId)
7037 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7038 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7041 func queryXappSubscription(t *testing.T, e2SubsId int64, meid string, endpoint []string) {
7042 resp, _ := xapp.Subscription.QuerySubscriptions()
7043 assert.Equal(t, resp[0].SubscriptionID, e2SubsId)
7044 assert.Equal(t, resp[0].Meid, meid)
7045 assert.Equal(t, resp[0].ClientEndpoint, endpoint)
7048 func waitSubsCleanup(t *testing.T, e2SubsId uint32, timeout int) {
7049 //Wait that subs is cleaned
7050 mainCtrl.wait_subs_clean(t, e2SubsId, timeout)
7052 xappConn1.TestMsgChanEmpty(t)
7053 xappConn2.TestMsgChanEmpty(t)
7054 e2termConn1.TestMsgChanEmpty(t)
7055 mainCtrl.wait_registry_empty(t, timeout)
7058 func sendAndReceiveMultipleE2SubReqs(t *testing.T, count int, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId string) []uint32 {
7060 var e2SubsId []uint32
7062 for i := 0; i < count; i++ {
7063 xapp.Logger.Debug("TEST: %d ===================================== BEGIN CRE ============================================", i+1)
7064 crereq, cremsg := toE2termConn.RecvSubsReq(t)
7065 fromXappConn.ExpectRESTNotification(t, restSubId)
7066 toE2termConn.SendSubsResp(t, crereq, cremsg)
7067 instanceId := fromXappConn.WaitRESTNotification(t, restSubId)
7068 e2SubsId = append(e2SubsId, instanceId)
7069 xapp.Logger.Debug("TEST: %v", e2SubsId)
7070 xapp.Logger.Debug("TEST: %d ===================================== END CRE ============================================", i+1)
7071 <-time.After(100 * time.Millisecond)
7076 func sendAndReceiveMultipleE2DelReqs(t *testing.T, e2SubsIds []uint32, toE2termConn *teststube2ap.E2Stub) {
7078 for i := 0; i < len(e2SubsIds); i++ {
7079 xapp.Logger.Debug("TEST: %d ===================================== BEGIN DEL ============================================", i+1)
7080 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
7081 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
7082 <-time.After(1 * time.Second)
7083 xapp.Logger.Debug("TEST: %d ===================================== END DEL ============================================", i+1)
7084 <-time.After(100 * time.Millisecond)
7087 // Wait that subs is cleaned
7088 for i := 0; i < len(e2SubsIds); i++ {
7089 mainCtrl.wait_subs_clean(t, e2SubsIds[i], 10)