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 ==================================================================================
29 "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap"
30 "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap_wrapper"
31 "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
32 "gerrit.o-ran-sc.org/r/ric-plt/submgr/pkg/teststube2ap"
33 "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
34 "github.com/stretchr/testify/assert"
37 // In below test cases there is done only one retry for E2 messages
38 // In Helm chart retry count is currently 2 By default. Retry count
39 // used in test cases is defined in submgr-config.yaml file.
41 func TestSuiteSetup(t *testing.T) {
42 // The effect of this call shall endure though the UT suite!
43 // If this causes any issues, the previous interface can be restored
45 // SetPackerIf(e2ap_wrapper.NewAsn1E2APPacker())
47 mainCtrl.InitAllCounterMap()
48 SetPackerIf(e2ap_wrapper.NewUtAsn1E2APPacker())
49 mainCtrl.c.restDuplicateCtrl.Init()
52 func TestRanStatusChangeViaSDLNotification(t *testing.T) {
54 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
55 Counter{cE2StateChangedToUp, 3},
58 // Current UT test cases use these ran names
59 xappRnibMock.CreateGnb("RAN_NAME_1", entities.ConnectionStatus_DISCONNECTED)
60 xappRnibMock.CreateGnb("RAN_NAME_11", entities.ConnectionStatus_DISCONNECTED)
61 xappRnibMock.CreateGnb("RAN_NAME_2", entities.ConnectionStatus_DISCONNECTED)
63 mainCtrl.c.e2IfState.ReadE2ConfigurationFromRnib()
64 mainCtrl.c.e2IfState.SubscribeChannels()
66 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
67 mainCtrl.SetE2State(t, "RAN_NAME_2_CONNECTED")
68 mainCtrl.SetE2State(t, "RAN_NAME_11_CONNECTED")
70 mainCtrl.VerifyCounterValues(t)
73 //-----------------------------------------------------------------------------
74 // TestRESTSubReqAfterE2ConnBreak
77 // +-------+ +---------+ +---------+
78 // | xapp | | submgr | | e2term |
79 // +-------+ +---------+ +---------+
81 // | [E2 Conn. DOWN] |
84 // |---------------->| |
86 // |<----------------| |
89 //-----------------------------------------------------------------------------
91 func TestRESTSubReqAfterE2ConnBreak(t *testing.T) {
93 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
94 Counter{cRestSubReqFromXapp, 1},
95 Counter{cRestReqRejDueE2Down, 1},
96 Counter{cE2StateChangedToDown, 1},
97 Counter{cE2StateChangedToUp, 1},
100 // E2 disconnect after E2term has received response
101 mainCtrl.SetE2State(t, "RAN_NAME_1_DISCONNECTED")
103 const subReqCount int = 1
104 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
105 xappConn1.SendRESTSubsReq(t, params)
107 // Restore E2 connection for following test cases
108 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
110 mainCtrl.VerifyAllClean(t)
111 mainCtrl.VerifyCounterValues(t)
114 //-----------------------------------------------------------------------------
115 // TestRESTSubReqE2ConnBreak
118 // +-------+ +---------+ +---------+
119 // | xapp | | submgr | | e2term |
120 // +-------+ +---------+ +---------+
123 // |---------------->| |
125 // |<----------------| |
127 // | |------------->|
129 // | |<-------------|
131 // | [E2 Conn. DOWN] |
132 // | [Int. SUBS DELETE] |
134 // | RESTNotif(unsuccessful) |
135 // |<----------------| |
139 //-----------------------------------------------------------------------------
140 func TestRESTSubReqE2ConnBreak(t *testing.T) {
142 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
143 Counter{cRestSubReqFromXapp, 1},
144 Counter{cRestSubRespToXapp, 1},
145 Counter{cSubReqToE2, 1},
146 Counter{cSubRespFromE2, 1},
147 Counter{cRestSubFailNotifToXapp, 1},
148 Counter{cE2StateChangedToDown, 1},
149 Counter{cE2StateChangedToUp, 1},
153 const subReqCount int = 1
154 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
155 restSubId := xappConn1.SendRESTSubsReq(t, params)
157 crereq, cremsg := e2termConn1.RecvSubsReq(t)
158 xappConn1.ExpectRESTNotification(t, restSubId)
160 // E2 disconnect after E2term has received response
161 mainCtrl.SetE2State(t, "RAN_NAME_1_DISCONNECTED")
163 e2termConn1.SendSubsResp(t, crereq, cremsg)
164 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
166 <-time.After(time.Second * 1)
167 assert.Equal(t, 0, len(mainCtrl.c.registry.register))
168 assert.Equal(t, 0, len(mainCtrl.c.registry.restSubscriptions))
170 subIds, register, err := mainCtrl.c.ReadAllSubscriptionsFromSdl()
172 xapp.Logger.Error("%v", err)
174 assert.Equal(t, 65534, len(subIds)) // range 1-65535 , FFFF = 65535
175 assert.Equal(t, 0, len(register))
178 restSubscriptions, err := mainCtrl.c.ReadAllRESTSubscriptionsFromSdl()
180 xapp.Logger.Error("%v", err)
182 assert.Equal(t, 0, len(restSubscriptions))
185 // Restore E2 connection for following test cases
186 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
188 // Wait that subs is cleaned
189 waitSubsCleanup(t, e2SubsId, 10)
190 mainCtrl.VerifyCounterValues(t)
191 mainCtrl.VerifyAllClean(t)
194 //-----------------------------------------------------------------------------
195 // TestRESTSubscriptionDeleteAfterE2ConnectionBreak
198 // +-------+ +---------+ +---------+
199 // | xapp | | submgr | | e2term |
200 // +-------+ +---------+ +---------+
204 // | [E2 Conn. DOWN] |
206 // | RESTSubDelReq | |
207 // |---------------->| |
209 // | RESTSubDelResp | |
210 // |<----------------| |
212 // | [No valid subscription found] |
215 //-----------------------------------------------------------------------------
216 func TestRESTSubscriptionDeleteAfterE2ConnectionBreak(t *testing.T) {
217 xapp.Logger.Debug("TEST: TestRESTSubscriptionDeleteAfterE2ConnectionBreak")
219 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
220 Counter{cRestSubReqFromXapp, 1},
221 Counter{cRestSubRespToXapp, 1},
222 Counter{cSubReqToE2, 1},
223 Counter{cSubRespFromE2, 1},
224 Counter{cRestSubNotifToXapp, 1},
225 Counter{cRestSubDelReqFromXapp, 1},
226 Counter{cRestSubDelRespToXapp, 1},
227 Counter{cE2StateChangedToDown, 1},
228 Counter{cE2StateChangedToUp, 1},
232 var params *teststube2ap.RESTSubsReqParams = nil
233 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
235 // E2 disconnect after E2term has received response
236 mainCtrl.SetE2State(t, "RAN_NAME_1_DISCONNECTED")
239 xappConn1.SendRESTSubsDelReq(t, &restSubId)
241 <-time.After(time.Second * 1)
242 assert.Equal(t, 0, len(mainCtrl.c.registry.register))
243 assert.Equal(t, 0, len(mainCtrl.c.registry.restSubscriptions))
245 subIds, register, err := mainCtrl.c.ReadAllSubscriptionsFromSdl()
247 xapp.Logger.Error("%v", err)
249 assert.Equal(t, 65534, len(subIds)) // range 1-65535 , FFFF = 65535
250 assert.Equal(t, 0, len(register))
253 restSubscriptions, err := mainCtrl.c.ReadAllRESTSubscriptionsFromSdl()
255 xapp.Logger.Error("%v", err)
257 assert.Equal(t, 0, len(restSubscriptions))
260 // Restore E2 connection for following test cases
261 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
263 // Wait that subs is cleaned
264 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
266 xappConn1.TestMsgChanEmpty(t)
267 e2termConn1.TestMsgChanEmpty(t)
268 mainCtrl.wait_registry_empty(t, 10)
269 mainCtrl.VerifyCounterValues(t)
270 mainCtrl.VerifyAllClean(t)
273 //-----------------------------------------------------------------------------
274 // TestRESTOtherE2ConnectionChanges
278 // +-------+ +---------+ +---------+
279 // | xapp | | submgr | | e2term |
280 // +-------+ +---------+ +---------+
284 // | [E2 CONNECTED_SETUP_FAILED] |
285 // | [E2 CONNECTING] |
286 // | [E2 SHUTTING_DOWN] |
287 // | [E2 SHUT_DOWN] |
292 //-----------------------------------------------------------------------------
293 func TestRESTOtherE2ConnectionChanges(t *testing.T) {
294 xapp.Logger.Debug("TEST: TestRESTOtherE2ConnectionChanges")
296 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
297 Counter{cRestSubReqFromXapp, 1},
298 Counter{cRestSubRespToXapp, 1},
299 Counter{cSubReqToE2, 1},
300 Counter{cSubRespFromE2, 1},
301 Counter{cRestSubNotifToXapp, 1},
302 Counter{cRestSubDelReqFromXapp, 1},
303 Counter{cSubDelReqToE2, 1},
304 Counter{cSubDelRespFromE2, 1},
305 Counter{cRestSubDelRespToXapp, 1},
306 Counter{cE2StateChangedToUp, 1},
310 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
311 restSubId := xappConn1.SendRESTSubsReq(t, params)
313 crereq, cremsg := e2termConn1.RecvSubsReq(t)
314 xappConn1.ExpectRESTNotification(t, restSubId)
315 e2termConn1.SendSubsResp(t, crereq, cremsg)
316 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
318 // Submgr should not react to any other connection state changes than CONNECTED and DISCONNECTED
319 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED_SETUP_FAILED")
320 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTING")
321 mainCtrl.SetE2State(t, "RAN_NAME_1_SHUTTING_DOWN")
322 mainCtrl.SetE2State(t, "RAN_NAME_1_SHUT_DOWN")
325 xappConn1.SendRESTSubsDelReq(t, &restSubId)
326 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
327 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
329 // Restore E2 connection for following test cases
330 mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
332 // Wait that subs is cleaned
333 waitSubsCleanup(t, e2SubsId, 10)
334 mainCtrl.VerifyCounterValues(t)
335 mainCtrl.VerifyAllClean(t)
338 //-----------------------------------------------------------------------------
339 // TestRESTSubReqAndDeleteOkWithE2apUtWrapper
342 // +-------+ +---------+ +---------+ +---------+
343 // | xapp | | submgr | | e2term | | rtmgr |
344 // +-------+ +---------+ +---------+ +---------+
346 // | RESTSubReq | | |
347 // |---------------->| | |
348 // | | RouteCreate | |
349 // | |--------------------------->| // The order of these events may vary
351 // | RESTSubResp | | | // The order of these events may vary
352 // |<----------------| | |
353 // | | RouteResponse| |
354 // | |<---------------------------| // The order of these events may vary
357 // | |------------->| | // The order of these events may vary
360 // | |<-------------| |
361 // | RESTNotif1 | | |
362 // |<----------------| | |
364 // | RESTSubDelReq | | |
365 // |---------------->| | |
367 // | |------------->| |
369 // | RESTSubDelResp| | |
370 // |<----------------| | |
372 // | | SubDelResp | |
373 // | |<-------------| |
377 //-----------------------------------------------------------------------------
378 func TestRESTSubReqAndDeleteOkWithE2apUtWrapper(t *testing.T) {
380 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil)
382 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
384 waitSubsCleanup(t, e2SubsId, 10)
385 mainCtrl.VerifyAllClean(t)
388 //-----------------------------------------------------------------------------
389 // TestRESTSubReqAndE1apDeleteReqPackingError
392 // +-------+ +---------+ +---------+ +---------+
393 // | xapp | | submgr | | e2term | | rtmgr |
394 // +-------+ +---------+ +---------+ +---------+
396 // | RESTSubReq | | |
397 // |---------------->| | |
398 // | | RouteCreate | |
399 // | |--------------------------->| // The order of these events may vary
401 // | RESTSubResp | | | // The order of these events may vary
402 // |<----------------| | |
403 // | | RouteResponse| |
404 // | |<---------------------------| // The order of these events may vary
407 // | |------------->| | // The order of these events may vary
410 // | |<-------------| |
411 // | RESTNotif1 | | |
412 // |<----------------| | |
414 // | RESTSubDelReq | | |
415 // |---------------->| | |
417 // | RESTSubDelResp| | |
418 // |<----------------| | |
422 //-----------------------------------------------------------------------------
423 func TestRESTSubReqAndE1apDeleteReqPackingError(t *testing.T) {
425 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil)
427 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_REQ, false)
428 xappConn1.SendRESTSubsDelReq(t, &restSubId)
429 defer e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_REQ, true)
431 waitSubsCleanup(t, e2SubsId, 10)
432 mainCtrl.VerifyAllClean(t)
435 //-----------------------------------------------------------------------------
436 // TestRESTSubReqAndE2APDeleteRespUnpackingError
439 // +-------+ +---------+ +---------+ +---------+
440 // | xapp | | submgr | | e2term | | rtmgr |
441 // +-------+ +---------+ +---------+ +---------+
443 // | RESTSubReq | | |
444 // |---------------->| | |
445 // | | RouteCreate | |
446 // | |--------------------------->| // The order of these events may vary
448 // | RESTSubResp | | | // The order of these events may vary
449 // |<----------------| | |
450 // | | RouteResponse| |
451 // | |<---------------------------| // The order of these events may vary
454 // | |------------->| | // The order of these events may vary
457 // | |<-------------| |
458 // | RESTNotif1 | | |
459 // |<----------------| | |
461 // | RESTSubDelReq | | |
462 // |---------------->| | |
464 // | |------------->| |
466 // | RESTSubDelResp| | |
467 // |<----------------| | | // The order of these events may vary
469 // | | SubDelResp | |
470 // | |<-------------| | // 1.st NOK
473 // | |------------->| |
475 // | | SubDelResp | |
476 // | |<-------------| | // 2.nd NOK
478 //-----------------------------------------------------------------------------
480 func TestRESTSubReqAndE2APDeleteRespUnpackingError(t *testing.T) {
482 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil)
484 xappConn1.SendRESTSubsDelReq(t, &restSubId)
485 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_RESP, false)
486 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
487 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
489 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
490 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
492 defer e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_RESP, true)
494 waitSubsCleanup(t, e2SubsId, 10)
495 mainCtrl.VerifyAllClean(t)
498 //-----------------------------------------------------------------------------
499 // TestSubReqAndRouteNok
502 // +-------+ +---------+ +---------+
503 // | xapp | | submgr | | rtmgr |
504 // +-------+ +---------+ +---------+
507 // |------------->| |
510 // | |------------->|
514 // | |<-------------|
516 // | [SUBS INT DELETE] |
519 //-----------------------------------------------------------------------------
521 func TestSubReqAndRouteNok(t *testing.T) {
522 CaseBegin("TestSubReqAndRouteNok")
524 // Init counter check
525 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
526 Counter{cSubReqFromXapp, 1},
527 Counter{cRouteCreateFail, 1},
530 waiter := rtmgrHttp.AllocNextEvent(false)
531 newSubsId := mainCtrl.get_registry_next_subid(t)
532 xappConn1.SendSubsReq(t, nil, nil)
535 //Wait that subs is cleaned
536 mainCtrl.wait_subs_clean(t, newSubsId, 10)
538 xappConn1.TestMsgChanEmpty(t)
539 xappConn2.TestMsgChanEmpty(t)
540 e2termConn1.TestMsgChanEmpty(t)
541 mainCtrl.wait_registry_empty(t, 10)
543 <-time.After(1 * time.Second)
544 mainCtrl.VerifyCounterValues(t)
547 //-----------------------------------------------------------------------------
548 // TestSubReqAndRouteUpdateNok
551 // +-------+ +-------+ +---------+ +---------+
552 // | xapp2 | | xapp1 | | submgr | | rtmgr |
553 // +-------+ +-------+ +---------+ +---------+
555 // | [SUBS CREATE] | |
559 // | SubReq (mergeable) | |
560 // |--------------------------->| | |
562 // | | | RouteUpdate |
563 // | | |------------->|
565 // | | | RouteUpdate |
566 // | | | status:400 |
567 // | | |<-------------|
569 // | [SUBS INT DELETE] | |
572 // | [SUBS DELETE] | |
575 func TestSubReqAndRouteUpdateNok(t *testing.T) {
576 CaseBegin("TestSubReqAndRouteUpdateNok")
578 // Init counter check
579 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
580 Counter{cSubReqFromXapp, 2},
581 Counter{cSubReqToE2, 1},
582 Counter{cSubRespFromE2, 1},
583 Counter{cSubRespToXapp, 1},
584 Counter{cRouteCreateUpdateFail, 1},
585 Counter{cSubDelReqFromXapp, 1},
586 Counter{cSubDelReqToE2, 1},
587 Counter{cSubDelRespFromE2, 1},
588 Counter{cSubDelRespToXapp, 1},
591 cretrans := xappConn1.SendSubsReq(t, nil, nil)
592 crereq, cremsg := e2termConn1.RecvSubsReq(t)
593 e2termConn1.SendSubsResp(t, crereq, cremsg)
594 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
596 resp, _ := xapp.Subscription.QuerySubscriptions()
597 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
598 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
599 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
601 waiter := rtmgrHttp.AllocNextEvent(false)
602 newSubsId := mainCtrl.get_registry_next_subid(t)
603 xappConn2.SendSubsReq(t, nil, nil)
606 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
607 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
609 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
610 xappConn1.RecvSubsDelResp(t, deltrans)
612 //Wait that subs is cleaned
613 mainCtrl.wait_subs_clean(t, newSubsId, 10)
614 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
616 xappConn1.TestMsgChanEmpty(t)
617 xappConn2.TestMsgChanEmpty(t)
618 e2termConn1.TestMsgChanEmpty(t)
619 mainCtrl.wait_registry_empty(t, 10)
621 mainCtrl.VerifyCounterValues(t)
624 //-----------------------------------------------------------------------------
625 // TestSubDelReqAndRouteDeleteNok
628 // +-------+ +---------+ +---------+ +---------+
629 // | xapp | | submgr | | e2term | | rtmgr |
630 // +-------+ +---------+ +---------+ +---------+
632 // | [SUBS CREATE] | |
637 // |------------->| | |
639 // | |------------->| |
641 // | |<-------------| |
643 // |<-------------| | |
644 // | | RouteDelete | |
645 // | |---------------------------->|
647 // | | RouteDelete | |
648 // | | status:400 | |
649 // | |<----------------------------|
651 func TestSubDelReqAndRouteDeleteNok(t *testing.T) {
652 CaseBegin("TestSubDelReqAndRouteDeleteNok")
654 // Init counter check
655 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
656 Counter{cSubReqFromXapp, 1},
657 Counter{cSubReqToE2, 1},
658 Counter{cSubRespFromE2, 1},
659 Counter{cSubRespToXapp, 1},
660 Counter{cSubDelReqFromXapp, 1},
661 Counter{cRouteDeleteFail, 1},
662 Counter{cSubDelReqToE2, 1},
663 Counter{cSubDelRespFromE2, 1},
664 Counter{cSubDelRespToXapp, 1},
667 cretrans := xappConn1.SendSubsReq(t, nil, nil)
668 crereq, cremsg := e2termConn1.RecvSubsReq(t)
669 e2termConn1.SendSubsResp(t, crereq, cremsg)
670 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
672 resp, _ := xapp.Subscription.QuerySubscriptions()
673 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
674 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
675 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
677 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
678 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
680 waiter := rtmgrHttp.AllocNextEvent(false)
681 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
684 xappConn1.RecvSubsDelResp(t, deltrans)
686 //Wait that subs is cleaned
687 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
689 xappConn1.TestMsgChanEmpty(t)
690 xappConn2.TestMsgChanEmpty(t)
691 e2termConn1.TestMsgChanEmpty(t)
692 mainCtrl.wait_registry_empty(t, 10)
693 mainCtrl.VerifyCounterValues(t)
696 //-----------------------------------------------------------------------------
697 // TestSubMergeDelAndRouteUpdateNok
699 // +-------+ +-------+ +---------+ +---------+
700 // | xapp2 | | xapp1 | | submgr | | e2term |
701 // +-------+ +-------+ +---------+ +---------+
706 // | |------------->| |
709 // | | |------------->|
711 // | | |<-------------|
713 // | |<-------------| |
716 // |--------------------------->| |
719 // |<---------------------------| |
721 // | | SubDelReq 1 | |
722 // | |------------->| |
723 // | | | RouteUpdate |
724 // | | |-----> rtmgr |
726 // | | | RouteUpdate |
727 // | | | status:400 |
728 // | | |<----- rtmgr |
730 // | | SubDelResp 1 | |
731 // | |<-------------| |
734 // |--------------------------->| |
736 // | | | SubDelReq 2 |
737 // | | |------------->|
739 // | | | SubDelReq 2 |
740 // | | |------------->|
742 // | SubDelResp 2 | |
743 // |<---------------------------| |
745 //-----------------------------------------------------------------------------
746 func TestSubMergeDelAndRouteUpdateNok(t *testing.T) {
747 CaseBegin("TestSubMergeDelAndRouteUpdateNok")
749 // Init counter check
750 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
751 Counter{cSubReqFromXapp, 2},
752 Counter{cMergedSubscriptions, 1},
753 Counter{cSubReqToE2, 1},
754 Counter{cSubRespFromE2, 1},
755 Counter{cSubRespToXapp, 2},
756 Counter{cSubDelReqFromXapp, 2},
757 Counter{cRouteDeleteUpdateFail, 1},
758 Counter{cSubDelReqToE2, 1},
759 Counter{cSubDelRespFromE2, 1},
760 Counter{cSubDelRespToXapp, 2},
761 Counter{cUnmergedSubscriptions, 1},
765 rparams1 := &teststube2ap.E2StubSubsReqParams{}
767 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
768 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
769 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
770 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
773 rparams2 := &teststube2ap.E2StubSubsReqParams{}
775 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
776 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
778 resp, _ := xapp.Subscription.QuerySubscriptions()
779 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
780 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
781 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
784 waiter := rtmgrHttp.AllocNextEvent(false)
785 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
788 xappConn1.RecvSubsDelResp(t, deltrans1)
791 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
792 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
793 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
794 xappConn2.RecvSubsDelResp(t, deltrans2)
795 //Wait that subs is cleaned
796 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
798 xappConn1.TestMsgChanEmpty(t)
799 xappConn2.TestMsgChanEmpty(t)
800 e2termConn1.TestMsgChanEmpty(t)
801 mainCtrl.wait_registry_empty(t, 10)
803 mainCtrl.VerifyCounterValues(t)
806 //-----------------------------------------------------------------------------
808 //-----------------------------------------------------------------------------
809 // TestSubReqAndSubDelOk
812 // +-------+ +---------+ +---------+
813 // | xapp | | submgr | | e2term |
814 // +-------+ +---------+ +---------+
817 // |------------->| |
820 // | |------------->|
823 // | |<-------------|
826 // |<-------------| |
830 // |------------->| |
833 // | |------------->|
836 // | |<-------------|
839 // |<-------------| |
841 //-----------------------------------------------------------------------------
842 func TestSubReqAndSubDelOk(t *testing.T) {
843 CaseBegin("TestSubReqAndSubDelOk")
845 // Init counter check
846 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
847 Counter{cSubReqFromXapp, 1},
848 Counter{cSubReqToE2, 1},
849 Counter{cSubRespFromE2, 1},
850 Counter{cSubRespToXapp, 1},
851 Counter{cSubDelReqFromXapp, 1},
852 Counter{cSubDelReqToE2, 1},
853 Counter{cSubDelRespFromE2, 1},
854 Counter{cSubDelRespToXapp, 1},
857 cretrans := xappConn1.SendSubsReq(t, nil, nil)
858 crereq, cremsg := e2termConn1.RecvSubsReq(t)
859 e2termConn1.SendSubsResp(t, crereq, cremsg)
860 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
862 resp, _ := xapp.Subscription.QuerySubscriptions()
863 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
864 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
865 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
867 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
868 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
870 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
871 xappConn1.RecvSubsDelResp(t, deltrans)
873 //Wait that subs is cleaned
874 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
876 xappConn1.TestMsgChanEmpty(t)
877 xappConn2.TestMsgChanEmpty(t)
878 e2termConn1.TestMsgChanEmpty(t)
879 mainCtrl.wait_registry_empty(t, 10)
881 mainCtrl.VerifyCounterValues(t)
884 //-----------------------------------------------------------------------------
886 //-----------------------------------------------------------------------------
887 // TestSubReqAndSubDelOkOutofOrderIEs
890 // +-------+ +---------+ +---------+
891 // | xapp | | submgr | | e2term |
892 // +-------+ +---------+ +---------+
895 // |------------->| |
898 // | |------------->|
900 // | | SubResp | (Out of Order IEs)
901 // | |<-------------|
904 // |<-------------| |
908 // |------------->| |
911 // | |------------->|
914 // | |<-------------|
917 // |<-------------| |
919 //-----------------------------------------------------------------------------
921 func TestSubReqAndSubDelOkOutofOrderIEs(t *testing.T) {
922 CaseBegin("TestSubReqAndSubDelOkOutofOrderIEs")
924 mainCtrl.c.e2ap.SetE2IEOrderCheck(0)
925 // Init counter check
926 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
927 Counter{cSubReqFromXapp, 1},
928 Counter{cSubReqToE2, 1},
929 Counter{cSubRespFromE2, 1},
930 Counter{cSubRespToXapp, 1},
931 Counter{cSubDelReqFromXapp, 1},
932 Counter{cSubDelReqToE2, 1},
933 Counter{cSubDelRespFromE2, 1},
934 Counter{cSubDelRespToXapp, 1},
937 cretrans := xappConn1.SendSubsReq(t, nil, nil)
939 t.Logf("Could not send SubsReq")
942 crereq, cremsg := e2termConn1.RecvSubsReq(t)
943 if crereq == nil || cremsg == nil {
944 t.Logf("Could not recieve SubsReq")
948 e2termConn1.SendSubsResp(t, crereq, cremsg)
950 mainCtrl.c.e2ap.SetE2IEOrderCheck(0)
952 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
953 resp, _ := xapp.Subscription.QuerySubscriptions()
954 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
955 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
956 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
958 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
959 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
961 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
962 xappConn1.RecvSubsDelResp(t, deltrans)
964 //Wait that subs is cleaned
965 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
967 xappConn1.TestMsgChanEmpty(t)
968 xappConn2.TestMsgChanEmpty(t)
969 e2termConn1.TestMsgChanEmpty(t)
970 mainCtrl.wait_registry_empty(t, 10)
972 mainCtrl.VerifyCounterValues(t)
973 mainCtrl.c.e2ap.SetE2IEOrderCheck(1)
976 //-----------------------------------------------------------------------------
978 //-----------------------------------------------------------------------------
979 // TestSubReqRetransmission
982 // +-------+ +---------+ +---------+
983 // | xapp | | submgr | | e2term |
984 // +-------+ +---------+ +---------+
987 // |------------->| |
990 // | |------------->|
994 // |------------->| |
997 // | |<-------------|
1000 // |<-------------| |
1002 // | [SUBS DELETE] |
1005 //-----------------------------------------------------------------------------
1006 func TestSubReqRetransmission(t *testing.T) {
1007 CaseBegin("TestSubReqRetransmission")
1010 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1011 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1013 seqBef := mainCtrl.get_msgcounter(t)
1014 xappConn1.SendSubsReq(t, nil, cretrans) //Retransmitted SubReq
1015 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
1017 // hack as there is no real way to see has message be handled.
1018 // Previuos counter check just tells that is has been received by submgr
1019 // --> artificial delay
1020 <-time.After(1 * time.Second)
1021 e2termConn1.SendSubsResp(t, crereq, cremsg)
1022 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1025 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1026 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1027 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1028 xappConn1.RecvSubsDelResp(t, deltrans)
1030 //Wait that subs is cleaned
1031 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1033 xappConn1.TestMsgChanEmpty(t)
1034 xappConn2.TestMsgChanEmpty(t)
1035 e2termConn1.TestMsgChanEmpty(t)
1036 mainCtrl.wait_registry_empty(t, 10)
1039 //-----------------------------------------------------------------------------
1040 // TestSubDelReqRetransmission
1043 // +-------+ +---------+ +---------+
1044 // | xapp | | submgr | | e2term |
1045 // +-------+ +---------+ +---------+
1047 // | [SUBS CREATE] |
1051 // |------------->| |
1054 // | |------------->|
1059 // |------------->| |
1062 // | |<-------------|
1065 // |<-------------| |
1067 //-----------------------------------------------------------------------------
1068 func TestSubDelReqRetransmission(t *testing.T) {
1069 CaseBegin("TestSubDelReqRetransmission")
1072 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1073 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1074 e2termConn1.SendSubsResp(t, crereq, cremsg)
1075 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1078 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1079 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1081 seqBef := mainCtrl.get_msgcounter(t)
1082 xappConn1.SendSubsDelReq(t, deltrans, e2SubsId) //Retransmitted SubDelReq
1083 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
1085 // hack as there is no real way to see has message be handled.
1086 // Previuos counter check just tells that is has been received by submgr
1087 // --> artificial delay
1088 <-time.After(1 * time.Second)
1090 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1091 xappConn1.RecvSubsDelResp(t, deltrans)
1093 //Wait that subs is cleaned
1094 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1096 xappConn1.TestMsgChanEmpty(t)
1097 xappConn2.TestMsgChanEmpty(t)
1098 e2termConn1.TestMsgChanEmpty(t)
1099 mainCtrl.wait_registry_empty(t, 10)
1102 //-----------------------------------------------------------------------------
1103 // TestSubDelReqCollision
1106 // +-------+ +---------+ +---------+
1107 // | xapp | | submgr | | e2term |
1108 // +-------+ +---------+ +---------+
1110 // | [SUBS CREATE] |
1113 // | SubDelReq 1 | |
1114 // |------------->| |
1116 // | | SubDelReq 1 |
1117 // | |------------->|
1119 // | SubDelReq 2 | |
1122 // |------------->| |
1124 // | | SubDelResp 1 |
1125 // | |<-------------|
1127 // | SubDelResp 1 | |
1128 // |<-------------| |
1130 // | SubDelResp 2 | |
1131 // |<-------------| |
1133 //-----------------------------------------------------------------------------
1135 func TestSubDelReqCollision(t *testing.T) {
1136 CaseBegin("TestSubDelReqCollision")
1139 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1140 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1141 e2termConn1.SendSubsResp(t, crereq, cremsg)
1142 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1145 xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1146 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1148 // Subs Delete colliding
1149 seqBef := mainCtrl.get_msgcounter(t)
1150 deltranscol2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1151 xappConn1.SendSubsDelReq(t, deltranscol2, e2SubsId) //Colliding SubDelReq
1152 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
1154 // hack as there is no real way to see has message be handled.
1155 // Previuos counter check just tells that is has been received by submgr
1156 // --> artificial delay
1157 <-time.After(1 * time.Second)
1159 // Del resp for first and second
1160 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1162 // don't care in which order responses are received
1163 xappConn1.RecvSubsDelResp(t, nil)
1164 xappConn1.RecvSubsDelResp(t, nil)
1166 //Wait that subs is cleaned
1167 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1169 xappConn1.TestMsgChanEmpty(t)
1170 xappConn2.TestMsgChanEmpty(t)
1171 e2termConn1.TestMsgChanEmpty(t)
1172 mainCtrl.wait_registry_empty(t, 10)
1175 //-----------------------------------------------------------------------------
1176 // TestSubReqAndSubDelOkTwoParallel
1179 // +-------+ +-------+ +---------+ +---------+
1180 // | xapp | | xapp | | submgr | | e2term |
1181 // +-------+ +-------+ +---------+ +---------+
1186 // | |------------->| |
1189 // | | |------------->|
1192 // |------------------------>| |
1195 // | | |------------->|
1198 // | | |<-------------|
1200 // | |<-------------| |
1203 // | | |<-------------|
1205 // |<------------------------| |
1207 // | | [SUBS 1 DELETE] |
1209 // | | [SUBS 2 DELETE] |
1212 //-----------------------------------------------------------------------------
1214 func TestSubReqAndSubDelOkTwoParallel(t *testing.T) {
1215 CaseBegin("TestSubReqAndSubDelOkTwoParallel")
1218 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1220 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1221 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1224 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1227 rparams2.Req.EventTriggerDefinition.Data.Length = 1
1228 rparams2.Req.EventTriggerDefinition.Data.Data = make([]uint8, rparams2.Req.EventTriggerDefinition.Data.Length)
1229 rparams2.Req.EventTriggerDefinition.Data.Data[0] = 2
1231 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1232 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
1235 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1236 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1239 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
1240 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1243 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1244 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1245 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1246 xappConn1.RecvSubsDelResp(t, deltrans1)
1247 //Wait that subs is cleaned
1248 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1251 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1252 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1253 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1254 xappConn2.RecvSubsDelResp(t, deltrans2)
1255 //Wait that subs is cleaned
1256 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1258 xappConn1.TestMsgChanEmpty(t)
1259 xappConn2.TestMsgChanEmpty(t)
1260 e2termConn1.TestMsgChanEmpty(t)
1261 mainCtrl.wait_registry_empty(t, 10)
1264 //-----------------------------------------------------------------------------
1265 // TestSameSubsDiffRan
1266 // Same subscription to different RANs
1269 // +-------+ +---------+ +---------+
1270 // | xapp | | submgr | | e2term |
1271 // +-------+ +---------+ +---------+
1276 // |------------->| |
1279 // | |------------->|
1281 // | | SubResp(r1) |
1282 // | |<-------------|
1284 // | SubResp(r1) | |
1285 // |<-------------| |
1288 // |------------->| |
1291 // | |------------->|
1293 // | | SubResp(r2) |
1294 // | |<-------------|
1296 // | SubResp(r2) | |
1297 // |<-------------| |
1299 // | [SUBS r1 DELETE] |
1301 // | [SUBS r2 DELETE] |
1304 //-----------------------------------------------------------------------------
1305 func TestSameSubsDiffRan(t *testing.T) {
1306 CaseBegin("TestSameSubsDiffRan")
1309 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1310 xappConn1.SendSubsReq(t, nil, cretrans1)
1311 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1312 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1313 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1316 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
1317 xappConn1.SendSubsReq(t, nil, cretrans2)
1318 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
1319 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
1320 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
1323 deltrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1324 xappConn1.SendSubsDelReq(t, deltrans1, e2SubsId1)
1325 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1326 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1327 xappConn1.RecvSubsDelResp(t, deltrans1)
1328 //Wait that subs is cleaned
1329 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1332 deltrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
1333 xappConn1.SendSubsDelReq(t, deltrans2, e2SubsId2)
1334 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1335 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1336 xappConn1.RecvSubsDelResp(t, deltrans2)
1337 //Wait that subs is cleaned
1338 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1340 xappConn1.TestMsgChanEmpty(t)
1341 xappConn2.TestMsgChanEmpty(t)
1342 e2termConn1.TestMsgChanEmpty(t)
1343 mainCtrl.wait_registry_empty(t, 10)
1346 //-----------------------------------------------------------------------------
1347 // TestSubReqRetryInSubmgr
1350 // +-------+ +---------+ +---------+
1351 // | xapp | | submgr | | e2term |
1352 // +-------+ +---------+ +---------+
1355 // |------------->| |
1358 // | |------------->|
1362 // | |------------->|
1365 // | |<-------------|
1368 // |<-------------| |
1370 // | [SUBS DELETE] |
1373 //-----------------------------------------------------------------------------
1375 func TestSubReqRetryInSubmgr(t *testing.T) {
1376 CaseBegin("TestSubReqRetryInSubmgr start")
1378 // Init counter check
1379 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1380 Counter{cSubReqFromXapp, 1},
1381 Counter{cSubReqToE2, 1},
1382 Counter{cSubReqTimerExpiry, 1},
1383 Counter{cSubReReqToE2, 1},
1384 Counter{cSubRespFromE2, 1},
1385 Counter{cSubRespToXapp, 1},
1386 Counter{cSubDelReqFromXapp, 1},
1387 Counter{cSubDelReqToE2, 1},
1388 Counter{cSubDelRespFromE2, 1},
1389 Counter{cSubDelRespToXapp, 1},
1392 // Xapp: Send SubsReq
1393 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1395 // E2t: Receive 1st SubsReq
1396 e2termConn1.RecvSubsReq(t)
1398 // E2t: Receive 2nd SubsReq and send SubsResp
1399 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1400 e2termConn1.SendSubsResp(t, crereq, cremsg)
1402 // Xapp: Receive SubsResp
1403 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1405 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1406 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1407 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1408 xappConn1.RecvSubsDelResp(t, deltrans)
1410 // Wait that subs is cleaned
1411 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1413 xappConn1.TestMsgChanEmpty(t)
1414 xappConn2.TestMsgChanEmpty(t)
1415 e2termConn1.TestMsgChanEmpty(t)
1416 mainCtrl.wait_registry_empty(t, 10)
1418 mainCtrl.VerifyCounterValues(t)
1421 //-----------------------------------------------------------------------------
1422 // TestSubReqTwoRetriesNoRespSubDelRespInSubmgr
1425 // +-------+ +---------+ +---------+
1426 // | xapp | | submgr | | e2term |
1427 // +-------+ +---------+ +---------+
1430 // |------------->| |
1433 // | |------------->|
1437 // | |------------->|
1440 // | |------------->|
1443 // | |<-------------|
1446 //-----------------------------------------------------------------------------
1447 func TestSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
1448 CaseBegin("TestSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
1450 // Init counter check
1451 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1452 Counter{cSubReqFromXapp, 1},
1453 Counter{cSubReqToE2, 1},
1454 Counter{cSubReReqToE2, 1},
1455 Counter{cSubReqTimerExpiry, 2},
1456 Counter{cSubDelReqToE2, 1},
1457 Counter{cSubDelRespFromE2, 1},
1460 // Xapp: Send SubsReq
1461 xappConn1.SendSubsReq(t, nil, nil)
1463 // E2t: Receive 1st SubsReq
1464 e2termConn1.RecvSubsReq(t)
1466 // E2t: Receive 2nd SubsReq
1467 e2termConn1.RecvSubsReq(t)
1469 // E2t: Send receive SubsDelReq and send SubsResp
1470 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1471 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1473 // Wait that subs is cleaned
1474 mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 10)
1476 xappConn1.TestMsgChanEmpty(t)
1477 xappConn2.TestMsgChanEmpty(t)
1478 e2termConn1.TestMsgChanEmpty(t)
1479 mainCtrl.wait_registry_empty(t, 10)
1481 mainCtrl.VerifyCounterValues(t)
1484 //-----------------------------------------------------------------------------
1485 // TestSubReqTwoRetriesNoRespAtAllInSubmgr
1488 // +-------+ +---------+ +---------+
1489 // | xapp | | submgr | | e2term |
1490 // +-------+ +---------+ +---------+
1493 // |------------->| |
1496 // | |------------->|
1500 // | |------------->|
1503 // | |------------->|
1507 // | |------------->|
1511 //-----------------------------------------------------------------------------
1513 func TestSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
1514 CaseBegin("TestSubReqTwoRetriesNoRespAtAllInSubmgr start")
1516 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1517 Counter{cSubReqFromXapp, 1},
1518 Counter{cSubReqToE2, 1},
1519 Counter{cSubReReqToE2, 1},
1520 Counter{cSubReqTimerExpiry, 2},
1521 Counter{cSubDelReqToE2, 1},
1522 Counter{cSubDelReReqToE2, 1},
1523 Counter{cSubDelReqTimerExpiry, 2},
1526 // Xapp: Send SubsReq
1527 xappConn1.SendSubsReq(t, nil, nil)
1529 // E2t: Receive 1st SubsReq
1530 e2termConn1.RecvSubsReq(t)
1532 // E2t: Receive 2nd SubsReq
1533 e2termConn1.RecvSubsReq(t)
1535 // E2t: Receive 1st SubsDelReq
1536 e2termConn1.RecvSubsDelReq(t)
1538 // E2t: Receive 2nd SubsDelReq
1539 delreq, _ := e2termConn1.RecvSubsDelReq(t)
1541 // Wait that subs is cleaned
1542 mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 15)
1544 xappConn1.TestMsgChanEmpty(t)
1545 xappConn2.TestMsgChanEmpty(t)
1546 e2termConn1.TestMsgChanEmpty(t)
1547 mainCtrl.wait_registry_empty(t, 10)
1549 mainCtrl.VerifyCounterValues(t)
1552 //-----------------------------------------------------------------------------
1553 // TestSubReqSubFailRespInSubmgr
1556 // +-------+ +---------+ +---------+
1557 // | xapp | | submgr | | e2term |
1558 // +-------+ +---------+ +---------+
1561 // |------------->| |
1564 // | |------------->|
1567 // | |<-------------|
1570 // |<-------------| |
1573 //-----------------------------------------------------------------------------
1575 func TestSubReqSubFailRespInSubmgr(t *testing.T) {
1576 CaseBegin("TestSubReqSubFailRespInSubmgr start")
1578 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1579 Counter{cSubReqFromXapp, 1},
1580 Counter{cSubReqToE2, 1},
1581 Counter{cSubFailFromE2, 1},
1582 Counter{cSubFailToXapp, 1},
1585 // Xapp: Send SubsReq
1586 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1588 // E2t: Receive SubsReq and send SubsFail (first)
1589 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1590 fparams1 := &teststube2ap.E2StubSubsFailParams{}
1591 fparams1.Set(crereq1)
1592 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
1594 // Xapp: Receive SubsFail
1595 e2SubsId := xappConn1.RecvSubsFail(t, cretrans)
1597 // Wait that subs is cleaned
1598 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1600 xappConn1.TestMsgChanEmpty(t)
1601 xappConn2.TestMsgChanEmpty(t)
1602 e2termConn1.TestMsgChanEmpty(t)
1603 mainCtrl.wait_registry_empty(t, 10)
1605 mainCtrl.VerifyCounterValues(t)
1608 //-----------------------------------------------------------------------------
1609 // TestSubDelReqRetryInSubmgr
1612 // +-------+ +---------+ +---------+
1613 // | xapp | | submgr | | e2term |
1614 // +-------+ +---------+ +---------+
1616 // | [SUBS CREATE] |
1620 // |------------->| |
1623 // | |------------->|
1626 // | |------------->|
1629 // | |<-------------|
1632 // |<-------------| |
1634 //-----------------------------------------------------------------------------
1636 func TestSubDelReqRetryInSubmgr(t *testing.T) {
1638 CaseBegin("TestSubDelReqRetryInSubmgr start")
1641 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1642 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1643 e2termConn1.SendSubsResp(t, crereq, cremsg)
1644 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1647 // Xapp: Send SubsDelReq
1648 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1650 // E2t: Receive 1st SubsDelReq
1651 e2termConn1.RecvSubsDelReq(t)
1653 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
1654 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1655 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1657 // Xapp: Receive SubsDelResp
1658 xappConn1.RecvSubsDelResp(t, deltrans)
1660 // Wait that subs is cleaned
1661 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1663 xappConn1.TestMsgChanEmpty(t)
1664 xappConn2.TestMsgChanEmpty(t)
1665 e2termConn1.TestMsgChanEmpty(t)
1666 mainCtrl.wait_registry_empty(t, 10)
1669 //-----------------------------------------------------------------------------
1670 // TestSubDelReqTwoRetriesNoRespInSubmgr
1673 // +-------+ +---------+ +---------+
1674 // | xapp | | submgr | | e2term |
1675 // +-------+ +---------+ +---------+
1677 // | [SUBS CREATE] |
1681 // |------------->| |
1684 // | |------------->|
1687 // | |------------->|
1691 // |<-------------| |
1693 //-----------------------------------------------------------------------------
1695 func TestSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
1697 CaseBegin("TestSubDelReTwoRetriesNoRespInSubmgr start")
1700 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1701 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1702 e2termConn1.SendSubsResp(t, crereq, cremsg)
1703 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1706 // Xapp: Send SubsDelReq
1707 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1709 // E2t: Receive 1st SubsDelReq
1710 e2termConn1.RecvSubsDelReq(t)
1712 // E2t: Receive 2nd SubsDelReq
1713 e2termConn1.RecvSubsDelReq(t)
1715 // Xapp: Receive SubsDelResp
1716 xappConn1.RecvSubsDelResp(t, deltrans)
1718 // Wait that subs is cleaned
1719 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1721 xappConn1.TestMsgChanEmpty(t)
1722 xappConn2.TestMsgChanEmpty(t)
1723 e2termConn1.TestMsgChanEmpty(t)
1724 mainCtrl.wait_registry_empty(t, 10)
1727 //-----------------------------------------------------------------------------
1728 // TestSubDelReqSubDelFailRespInSubmgr
1731 // +-------+ +---------+ +---------+
1732 // | xapp | | submgr | | e2term |
1733 // +-------+ +---------+ +---------+
1735 // | [SUBS CREATE] |
1739 // |------------->| |
1742 // | |------------->|
1745 // | |<-------------|
1748 // |<-------------| |
1751 //-----------------------------------------------------------------------------
1753 func TestSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
1754 CaseBegin("TestSubReqSubDelFailRespInSubmgr start")
1756 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1757 Counter{cSubReqFromXapp, 1},
1758 Counter{cSubReqToE2, 1},
1759 Counter{cSubRespFromE2, 1},
1760 Counter{cSubRespToXapp, 1},
1761 Counter{cSubDelReqFromXapp, 1},
1762 Counter{cSubDelReqToE2, 1},
1763 Counter{cSubDelFailFromE2, 1},
1764 Counter{cSubDelRespToXapp, 1},
1768 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1769 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1770 e2termConn1.SendSubsResp(t, crereq, cremsg)
1771 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1773 // Xapp: Send SubsDelReq
1774 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1776 // E2t: Send receive SubsDelReq and send SubsDelFail
1777 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1778 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
1780 // Xapp: Receive SubsDelResp
1781 xappConn1.RecvSubsDelResp(t, deltrans)
1783 // Wait that subs is cleaned
1784 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1786 xappConn1.TestMsgChanEmpty(t)
1787 xappConn2.TestMsgChanEmpty(t)
1788 e2termConn1.TestMsgChanEmpty(t)
1789 mainCtrl.wait_registry_empty(t, 10)
1791 mainCtrl.VerifyCounterValues(t)
1794 //-----------------------------------------------------------------------------
1795 // TestSubReqAndSubDelOkSameAction
1798 // +-------+ +-------+ +---------+ +---------+
1799 // | xapp2 | | xapp1 | | submgr | | e2term |
1800 // +-------+ +-------+ +---------+ +---------+
1805 // | |------------->| |
1808 // | | |------------->|
1810 // | | |<-------------|
1812 // | |<-------------| |
1815 // |--------------------------->| |
1818 // |<---------------------------| |
1820 // | | SubDelReq 1 | |
1821 // | |------------->| |
1823 // | | SubDelResp 1 | |
1824 // | |<-------------| |
1826 // | SubDelReq 2 | |
1827 // |--------------------------->| |
1829 // | | | SubDelReq 2 |
1830 // | | |------------->|
1832 // | | | SubDelReq 2 |
1833 // | | |------------->|
1835 // | SubDelResp 2 | |
1836 // |<---------------------------| |
1838 //-----------------------------------------------------------------------------
1839 func TestSubReqAndSubDelOkSameAction(t *testing.T) {
1840 CaseBegin("TestSubReqAndSubDelOkSameAction")
1842 // Init counter check
1843 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1844 Counter{cSubReqFromXapp, 2},
1845 Counter{cSubReqToE2, 1},
1846 Counter{cSubRespFromE2, 1},
1847 Counter{cSubRespToXapp, 2},
1848 Counter{cMergedSubscriptions, 1},
1849 Counter{cUnmergedSubscriptions, 1},
1850 Counter{cSubDelReqFromXapp, 2},
1851 Counter{cSubDelReqToE2, 1},
1852 Counter{cSubDelRespFromE2, 1},
1853 Counter{cSubDelRespToXapp, 2},
1857 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1859 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1860 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1861 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1862 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1865 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1867 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1868 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1870 resp, _ := xapp.Subscription.QuerySubscriptions()
1871 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
1872 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
1873 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
1876 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1877 xappConn1.RecvSubsDelResp(t, deltrans1)
1880 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1881 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1882 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1883 xappConn2.RecvSubsDelResp(t, deltrans2)
1884 //Wait that subs is cleaned
1885 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1887 xappConn1.TestMsgChanEmpty(t)
1888 xappConn2.TestMsgChanEmpty(t)
1889 e2termConn1.TestMsgChanEmpty(t)
1890 mainCtrl.wait_registry_empty(t, 10)
1892 mainCtrl.VerifyCounterValues(t)
1895 //-----------------------------------------------------------------------------
1896 // TestSubReqAndSubDelOkSameActionParallel
1899 // +-------+ +-------+ +---------+ +---------+
1900 // | xapp2 | | xapp1 | | submgr | | e2term |
1901 // +-------+ +-------+ +---------+ +---------+
1906 // | |------------->| |
1909 // | | |------------->|
1911 // |--------------------------->| |
1913 // | | |<-------------|
1915 // | |<-------------| |
1918 // |<---------------------------| |
1920 // | | SubDelReq 1 | |
1921 // | |------------->| |
1923 // | | SubDelResp 1 | |
1924 // | |<-------------| |
1926 // | SubDelReq 2 | |
1927 // |--------------------------->| |
1929 // | | | SubDelReq 2 |
1930 // | | |------------->|
1932 // | | | SubDelReq 2 |
1933 // | | |------------->|
1935 // | SubDelResp 2 | |
1936 // |<---------------------------| |
1938 //-----------------------------------------------------------------------------
1939 func TestSubReqAndSubDelOkSameActionParallel(t *testing.T) {
1940 CaseBegin("TestSubReqAndSubDelOkSameActionParallel")
1943 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1945 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1946 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1949 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1951 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1954 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1955 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1958 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1961 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1962 xappConn1.RecvSubsDelResp(t, deltrans1)
1965 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1966 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1967 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1968 xappConn2.RecvSubsDelResp(t, deltrans2)
1970 //Wait that subs is cleaned
1971 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1973 xappConn1.TestMsgChanEmpty(t)
1974 xappConn2.TestMsgChanEmpty(t)
1975 e2termConn1.TestMsgChanEmpty(t)
1976 mainCtrl.wait_registry_empty(t, 10)
1979 //-----------------------------------------------------------------------------
1980 // TestSubReqAndSubDelNokSameActionParallel
1983 // +-------+ +-------+ +---------+ +---------+
1984 // | xapp2 | | xapp1 | | submgr | | e2term |
1985 // +-------+ +-------+ +---------+ +---------+
1990 // | |------------->| |
1993 // | | |------------->|
1995 // |--------------------------->| |
1997 // | | |<-------------|
2000 // | |<-------------| |
2003 // |<---------------------------| |
2005 //-----------------------------------------------------------------------------
2006 func TestSubReqAndSubDelNokSameActionParallel(t *testing.T) {
2007 CaseBegin("TestSubReqAndSubDelNokSameActionParallel")
2010 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2012 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
2014 // E2t: Receive SubsReq (first)
2015 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2018 rparams2 := &teststube2ap.E2StubSubsReqParams{}
2020 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
2021 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
2022 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
2024 // E2t: send SubsFail (first)
2025 fparams1 := &teststube2ap.E2StubSubsFailParams{}
2026 fparams1.Set(crereq1)
2027 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
2030 e2SubsId1 := xappConn1.RecvSubsFail(t, cretrans1)
2032 xappConn2.RecvSubsFail(t, cretrans2)
2034 //Wait that subs is cleaned
2035 mainCtrl.wait_subs_clean(t, e2SubsId1, 15)
2037 xappConn1.TestMsgChanEmpty(t)
2038 xappConn2.TestMsgChanEmpty(t)
2039 e2termConn1.TestMsgChanEmpty(t)
2040 mainCtrl.wait_registry_empty(t, 10)
2043 //-----------------------------------------------------------------------------
2044 // TestSubReqAndSubDelNoAnswerSameActionParallel
2047 // +-------+ +-------+ +---------+ +---------+
2048 // | xapp2 | | xapp1 | | submgr | | e2term |
2049 // +-------+ +-------+ +---------+ +---------+
2054 // | |------------->| |
2057 // | | |------------->|
2059 // |--------------------------->| |
2062 // | | |------------->|
2065 // | | | SubDelReq |
2066 // | | |------------->|
2068 // | | | SubDelResp |
2069 // | | |<-------------|
2071 //-----------------------------------------------------------------------------
2072 func TestSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
2073 CaseBegin("TestSubReqAndSubDelNoAnswerSameActionParallel")
2076 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2078 xappConn1.SendSubsReq(t, rparams1, nil)
2080 crereq1, _ := e2termConn1.RecvSubsReq(t)
2083 rparams2 := &teststube2ap.E2StubSubsReqParams{}
2085 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
2086 xappConn2.SendSubsReq(t, rparams2, nil)
2087 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
2089 //Req1 (retransmitted)
2090 e2termConn1.RecvSubsReq(t)
2092 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
2093 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
2095 //Wait that subs is cleaned
2096 mainCtrl.wait_subs_clean(t, delreq1.RequestId.InstanceId, 10)
2098 xappConn1.TestMsgChanEmpty(t)
2099 xappConn2.TestMsgChanEmpty(t)
2100 e2termConn1.TestMsgChanEmpty(t)
2101 mainCtrl.wait_registry_empty(t, 15)
2104 //----------------------------- Policy cases ---------------------------------
2105 //-----------------------------------------------------------------------------
2106 // TestSubReqPolicyAndSubDelOk
2109 // +-------+ +---------+ +---------+
2110 // | xapp | | submgr | | e2term |
2111 // +-------+ +---------+ +---------+
2114 // |------------->| |
2117 // | |------------->|
2120 // | |<-------------|
2123 // |<-------------| |
2127 // |------------->| |
2130 // | |------------->|
2133 // | |<-------------|
2136 // |<-------------| |
2138 //-----------------------------------------------------------------------------
2139 func TestSubReqPolicyAndSubDelOk(t *testing.T) {
2140 CaseBegin("TestSubReqAndSubDelOk")
2142 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2144 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
2145 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
2147 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2148 e2termConn1.SendSubsResp(t, crereq, cremsg)
2149 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2150 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2151 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2153 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2154 xappConn1.RecvSubsDelResp(t, deltrans)
2156 //Wait that subs is cleaned
2157 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2159 xappConn1.TestMsgChanEmpty(t)
2160 xappConn2.TestMsgChanEmpty(t)
2161 e2termConn1.TestMsgChanEmpty(t)
2162 mainCtrl.wait_registry_empty(t, 10)
2165 //-----------------------------------------------------------------------------
2166 // TestSubReqPolicyChangeAndSubDelOk
2169 // +-------+ +---------+ +---------+
2170 // | xapp | | submgr | | e2term |
2171 // +-------+ +---------+ +---------+
2174 // |------------->| |
2177 // | |------------->|
2180 // | |<-------------|
2183 // |<-------------| |
2186 // |------------->| |
2189 // | |------------->|
2192 // | |<-------------|
2195 // |<-------------| |
2198 // |------------->| |
2201 // | |------------->|
2204 // | |<-------------|
2207 // |<-------------| |
2209 //-----------------------------------------------------------------------------
2211 func TestSubReqPolicyChangeAndSubDelOk(t *testing.T) {
2212 CaseBegin("TestSubReqAndSubDelOk")
2214 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2216 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
2217 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
2219 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2220 e2termConn1.SendSubsResp(t, crereq, cremsg)
2221 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2224 rparams1.Req.RequestId.InstanceId = e2SubsId
2225 rparams1.Req.ActionSetups[0].SubsequentAction.TimetoWait = e2ap.E2AP_TimeToWaitW200ms
2226 xappConn1.SendSubsReq(t, rparams1, cretrans)
2228 crereq, cremsg = e2termConn1.RecvSubsReq(t)
2229 e2termConn1.SendSubsResp(t, crereq, cremsg)
2230 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
2231 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2232 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2234 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2235 xappConn1.RecvSubsDelResp(t, deltrans)
2237 //Wait that subs is cleaned
2238 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2240 xappConn1.TestMsgChanEmpty(t)
2241 xappConn2.TestMsgChanEmpty(t)
2242 e2termConn1.TestMsgChanEmpty(t)
2243 mainCtrl.wait_registry_empty(t, 10)
2246 //-----------------------------------------------------------------------------
2247 // TestSubReqAndSubDelOkTwoE2termParallel
2250 // +-------+ +---------+ +---------+ +---------+
2251 // | xapp | | submgr | | e2term1 | | e2term2 |
2252 // +-------+ +---------+ +---------+ +---------+
2257 // |------------->| | |
2260 // | |------------->| |
2263 // |------------->| | |
2266 // | |---------------------------->|
2269 // | |<-------------| |
2271 // |<-------------| | |
2273 // | |<----------------------------|
2275 // |<-------------| | |
2277 // | [SUBS 1 DELETE] | |
2279 // | [SUBS 2 DELETE] | |
2282 //-----------------------------------------------------------------------------
2283 func TestSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
2284 CaseBegin("TestSubReqAndSubDelOkTwoE2termParallel")
2287 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
2288 xappConn1.SendSubsReq(t, nil, cretrans1)
2289 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2291 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_11")
2292 xappConn1.SendSubsReq(t, nil, cretrans2)
2293 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
2296 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2297 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
2300 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
2301 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
2304 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
2305 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
2306 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
2307 xappConn1.RecvSubsDelResp(t, deltrans1)
2308 //Wait that subs is cleaned
2309 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
2312 deltrans2 := xappConn1.SendSubsDelReq(t, nil, e2SubsId2)
2313 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
2314 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
2315 xappConn1.RecvSubsDelResp(t, deltrans2)
2316 //Wait that subs is cleaned
2317 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
2319 xappConn1.TestMsgChanEmpty(t)
2320 xappConn2.TestMsgChanEmpty(t)
2321 e2termConn1.TestMsgChanEmpty(t)
2322 e2termConn2.TestMsgChanEmpty(t)
2323 mainCtrl.wait_registry_empty(t, 10)
2326 //-----------------------------------------------------------------------------
2327 // TestSubReqInsertAndSubDelOk
2330 // +-------+ +---------+ +---------+
2331 // | xapp | | submgr | | e2term |
2332 // +-------+ +---------+ +---------+
2335 // |------------->| |
2338 // | |------------->|
2341 // | |<-------------|
2344 // |<-------------| |
2348 // |------------->| |
2351 // | |------------->|
2354 // | |<-------------|
2357 // |<-------------| |
2359 //-----------------------------------------------------------------------------
2360 func TestSubReqInsertAndSubDelOk(t *testing.T) {
2361 CaseBegin("TestInsertSubReqAndSubDelOk")
2363 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2365 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypeInsert
2366 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
2368 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2369 e2termConn1.SendSubsResp(t, crereq, cremsg)
2370 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2371 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2372 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2374 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2375 xappConn1.RecvSubsDelResp(t, deltrans)
2377 //Wait that subs is cleaned
2378 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2380 xappConn1.TestMsgChanEmpty(t)
2381 xappConn2.TestMsgChanEmpty(t)
2382 e2termConn1.TestMsgChanEmpty(t)
2383 mainCtrl.wait_registry_empty(t, 10)
2386 //-----------------------------------------------------------------------------
2387 // TestSubReqRetransmissionWithSameSubIdDiffXid
2389 // This case simulates case where xApp restarts and starts sending same
2390 // subscription requests which have already subscribed successfully
2393 // +-------+ +---------+ +---------+
2394 // | xapp | | submgr | | e2term |
2395 // +-------+ +---------+ +---------+
2398 // |------------->| |
2401 // | |------------->|
2404 // | |<-------------|
2407 // |<-------------| |
2409 // | xApp restart | |
2412 // | (retrans with same xApp generated subid but diff xid)
2413 // |------------->| |
2416 // |<-------------| |
2418 // | [SUBS DELETE] |
2421 //-----------------------------------------------------------------------------
2422 func TestSubReqRetransmissionWithSameSubIdDiffXid(t *testing.T) {
2423 CaseBegin("TestSubReqRetransmissionWithSameSubIdDiffXid")
2426 cretrans := xappConn1.SendSubsReq(t, nil, nil)
2427 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2428 e2termConn1.SendSubsResp(t, crereq, cremsg)
2429 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2431 // xApp restart here
2432 // --> artificial delay
2433 <-time.After(1 * time.Second)
2436 cretrans = xappConn1.SendSubsReq(t, nil, nil) //Retransmitted SubReq
2437 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
2440 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2441 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2442 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2443 xappConn1.RecvSubsDelResp(t, deltrans)
2445 //Wait that subs is cleaned
2446 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2448 xappConn1.TestMsgChanEmpty(t)
2449 xappConn2.TestMsgChanEmpty(t)
2450 e2termConn1.TestMsgChanEmpty(t)
2451 mainCtrl.wait_registry_empty(t, 10)
2454 //-----------------------------------------------------------------------------
2455 // TestSubReqNokAndSubDelOkWithRestartInMiddle
2458 // +-------+ +---------+ +---------+
2459 // | xapp | | submgr | | e2term |
2460 // +-------+ +---------+ +---------+
2463 // |------------->| |
2466 // | |------------->|
2471 // | Submgr restart |
2475 // | |------------->|
2478 // | |<-------------|
2481 //-----------------------------------------------------------------------------
2483 func TestSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
2484 CaseBegin("TestSubReqNokAndSubDelOkWithRestartInMiddle")
2486 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
2487 xappConn1.SendSubsReq(t, nil, nil)
2488 e2termConn1.RecvSubsReq(t)
2489 mainCtrl.SetResetTestFlag(t, false)
2491 resp, _ := xapp.Subscription.QuerySubscriptions()
2492 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2493 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2494 e2SubsId := uint32(resp[0].SubscriptionID)
2495 t.Logf("e2SubsId = %v", e2SubsId)
2497 mainCtrl.SimulateRestart(t)
2498 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2500 // Submgr send delete for uncompleted subscription
2501 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2502 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2504 // Wait that subs is cleaned
2505 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2507 xappConn1.TestMsgChanEmpty(t)
2508 xappConn2.TestMsgChanEmpty(t)
2509 e2termConn1.TestMsgChanEmpty(t)
2510 mainCtrl.wait_registry_empty(t, 10)
2513 //-----------------------------------------------------------------------------
2514 // TestSubReqAndSubDelOkWithRestartInMiddle
2517 // +-------+ +---------+ +---------+
2518 // | xapp | | submgr | | e2term |
2519 // +-------+ +---------+ +---------+
2522 // |------------->| |
2525 // | |------------->|
2528 // | |<-------------|
2531 // |<-------------| |
2534 // | Submgr restart |
2537 // |------------->| |
2540 // | |------------->|
2543 // | |<-------------|
2546 // |<-------------| |
2548 //-----------------------------------------------------------------------------
2550 func TestSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
2551 CaseBegin("TestSubReqAndSubDelOkWithRestartInMiddle")
2553 cretrans := xappConn1.SendSubsReq(t, nil, nil)
2554 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2555 e2termConn1.SendSubsResp(t, crereq, cremsg)
2556 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2558 // Check subscription
2559 resp, _ := xapp.Subscription.QuerySubscriptions()
2560 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
2561 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2562 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2564 mainCtrl.SimulateRestart(t)
2565 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2567 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
2568 // That needs to be completed before successful subscription query is possible
2569 <-time.After(time.Second * 1)
2571 // Check that subscription is restored correctly after restart
2572 resp, _ = xapp.Subscription.QuerySubscriptions()
2573 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
2574 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2575 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2577 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2578 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2579 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2580 xappConn1.RecvSubsDelResp(t, deltrans)
2582 //Wait that subs is cleaned
2583 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2585 xappConn1.TestMsgChanEmpty(t)
2586 xappConn2.TestMsgChanEmpty(t)
2587 e2termConn1.TestMsgChanEmpty(t)
2588 mainCtrl.wait_registry_empty(t, 10)
2591 //-----------------------------------------------------------------------------
2592 // TestSubReqAndSubDelOkSameActionWithRestartsInMiddle
2595 // +-------+ +-------+ +---------+ +---------+
2596 // | xapp2 | | xapp1 | | submgr | | e2term |
2597 // +-------+ +-------+ +---------+ +---------+
2602 // | |------------->| |
2605 // | | |------------->|
2607 // | | |<-------------|
2609 // | |<-------------| |
2612 // | submgr restart |
2617 // |--------------------------->| |
2620 // |<---------------------------| |
2622 // | | SubDelReq 1 | |
2623 // | |------------->| |
2625 // | | SubDelResp 1 | |
2626 // | |<-------------| |
2630 // | submgr restart |
2633 // | SubDelReq 2 | |
2634 // |--------------------------->| |
2636 // | | | SubDelReq 2 |
2637 // | | |------------->|
2639 // | | | SubDelReq 2 |
2640 // | | |------------->|
2642 // | SubDelResp 2 | |
2643 // |<---------------------------| |
2645 //-----------------------------------------------------------------------------
2647 func TestSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
2648 CaseBegin("TestSubReqAndSubDelOkSameActionWithRestartsInMiddle")
2651 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2653 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
2654 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2655 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2656 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
2659 rparams2 := &teststube2ap.E2StubSubsReqParams{}
2661 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
2662 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
2664 // Check subscription
2665 resp, _ := xapp.Subscription.QuerySubscriptions()
2666 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
2667 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2668 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
2670 mainCtrl.SimulateRestart(t)
2671 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2673 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
2674 // That needs to be completed before successful subscription query is possible
2675 <-time.After(time.Second * 1)
2677 // Check that subscription is restored correctly after restart
2678 resp, _ = xapp.Subscription.QuerySubscriptions()
2679 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
2680 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2681 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
2684 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
2685 xapp.Logger.Debug("xappConn1.RecvSubsDelResp")
2686 xappConn1.RecvSubsDelResp(t, deltrans1)
2687 xapp.Logger.Debug("xappConn1.RecvSubsDelResp received")
2689 mainCtrl.SimulateRestart(t)
2690 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2692 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
2693 // Submgr need be ready before successful subscription deletion is possible
2694 <-time.After(time.Second * 1)
2697 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
2698 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
2700 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
2701 xappConn2.RecvSubsDelResp(t, deltrans2)
2703 //Wait that subs is cleaned
2704 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
2706 xappConn1.TestMsgChanEmpty(t)
2707 xappConn2.TestMsgChanEmpty(t)
2708 e2termConn1.TestMsgChanEmpty(t)
2709 mainCtrl.wait_registry_empty(t, 10)
2712 //*****************************************************************************
2713 // REST interface test cases
2714 //*****************************************************************************
2716 //-----------------------------------------------------------------------------
2717 // Test debug GET and POST requests
2720 // +-------+ +---------+
2721 // | user | | submgr |
2722 // +-------+ +---------+
2729 func TestGetSubscriptions(t *testing.T) {
2731 mainCtrl.SendGetRequest(t, "localhost:8088", "/ric/v1/subscriptions")
2734 func TestGetSymptomData(t *testing.T) {
2736 mainCtrl.SendGetRequest(t, "localhost:8080", "/ric/v1/symptomdata")
2739 func TestPostdeleteSubId(t *testing.T) {
2741 mainCtrl.SendPostRequest(t, "localhost:8080", "/ric/v1/test/deletesubid=1")
2744 func TestPostEmptyDb(t *testing.T) {
2746 mainCtrl.SendPostRequest(t, "localhost:8080", "/ric/v1/test/emptydb")
2749 func TestGetRestSubscriptions(t *testing.T) {
2751 mainCtrl.SendGetRequest(t, "localhost:8080", "/ric/v1/restsubscriptions")
2754 //-----------------------------------------------------------------------------
2755 // TestDelAllE2nodeSubsViaDebugIf
2758 // +-------+ +---------+ +---------+ +---------+
2759 // | xapp | | submgr | | e2term | | rtmgr |
2760 // +-------+ +---------+ +---------+ +---------+
2762 // | RESTSubReq | | |
2763 // |---------------->| | |
2764 // | RESTSubResp | | |
2765 // |<----------------| | |
2766 // | | RouteCreate | |
2767 // | |--------------------------->|
2768 // | | RouteResponse| |
2769 // | |<---------------------------|
2771 // | |------------->| |
2773 // | |<-------------| |
2774 // | RESTNotif1 | | |
2775 // |<----------------| | |
2777 // | REST get_all_e2nodes | |
2778 // |---------------->| | |
2780 // |<----------------| | |
2781 // | REST delete_all_e2node_subscriptions | ranName = RAN_NAME_1
2782 // |---------------->| | |
2784 // |<----------------| | |
2785 // | | SubDelReq | |
2786 // | |------------->| |
2787 // | | SubDelResp | |
2788 // | |<-------------| |
2790 // | | RouteDelete | |
2791 // | |--------------------------->|
2792 // | | RouteResponse| |
2793 // | |<---------------------------|
2795 //-----------------------------------------------------------------------------
2797 func TestDelAllE2nodeSubsViaDebugIf(t *testing.T) {
2799 // Init counter check
2800 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2801 Counter{cRestSubReqFromXapp, 1},
2802 Counter{cRestSubRespToXapp, 1},
2803 Counter{cSubReqToE2, 1},
2804 Counter{cSubRespFromE2, 1},
2805 Counter{cRestSubNotifToXapp, 1},
2806 Counter{cRestSubDelReqFromXapp, 1},
2807 Counter{cSubDelReqToE2, 1},
2808 Counter{cSubDelRespFromE2, 1},
2809 Counter{cRestSubDelRespToXapp, 1},
2812 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2813 restSubId := xappConn1.SendRESTSubsReq(t, params)
2814 xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
2816 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2817 xappConn1.ExpectRESTNotification(t, restSubId)
2818 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2819 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2820 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
2822 e2nodesJson := mainCtrl.SendGetRequest(t, "localhost:8080", "/ric/v1/get_all_e2nodes")
2824 var e2nodesList []string
2825 err := json.Unmarshal(e2nodesJson, &e2nodesList)
2827 t.Errorf("Unmarshal error: %s", err)
2829 assert.Equal(t, true, mainCtrl.VerifyStringExistInSlice("RAN_NAME_1", e2nodesList))
2831 e2RestSubsJson := mainCtrl.SendGetRequest(t, "localhost:8080", "/ric/v1/get_e2node_rest_subscriptions/RAN_NAME_1") // RAN_NAME_1 = ranName
2832 var e2RestSubsMap map[string]RESTSubscription
2833 err = json.Unmarshal(e2RestSubsJson, &e2RestSubsMap)
2835 t.Errorf("Unmarshal error: %s", err)
2838 if len(e2RestSubsMap) != 1 {
2839 t.Errorf("Incorrect e2RestSubsMap length %v", len(e2RestSubsMap))
2842 // Simulate deletion through REST test and debug interface
2843 mainCtrl.SendDeleteRequest(t, "localhost:8080", "/ric/v1/delete_all_e2node_subscriptions/RAN_NAME_1") // RAN_NAME_1 = ranName
2844 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2845 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2847 // Wait that subs is cleaned
2848 waitSubsCleanup(t, e2SubsId, 10)
2849 mainCtrl.VerifyCounterValues(t)
2850 mainCtrl.VerifyAllClean(t)
2853 //-----------------------------------------------------------------------------
2854 // TestDelAllxAppSubsViaDebugIf
2857 // +-------+ +---------+ +---------+ +---------+
2858 // | xapp | | submgr | | e2term | | rtmgr |
2859 // +-------+ +---------+ +---------+ +---------+
2861 // | RESTSubReq | | |
2862 // |---------------->| | |
2863 // | RESTSubResp | | |
2864 // |<----------------| | |
2865 // | | RouteCreate | |
2866 // | |--------------------------->|
2867 // | | RouteResponse| |
2868 // | |<---------------------------|
2870 // | |------------->| |
2872 // | |<-------------| |
2873 // | RESTNotif1 | | |
2874 // |<----------------| | |
2876 // | REST get_all_xapps | |
2877 // |---------------->| | |
2879 // |<----------------| | |
2880 // | REST delete_all_xapp_subscriptions | xappServiceName = localhost
2881 // |---------------->| | |
2883 // |<----------------| | |
2884 // | | SubDelReq | |
2885 // | |------------->| |
2886 // | | SubDelResp | |
2887 // | |<-------------| |
2889 // | | RouteDelete | |
2890 // | |--------------------------->|
2891 // | | RouteResponse| |
2892 // | |<---------------------------|
2894 //-----------------------------------------------------------------------------
2896 func TestDelAllxAppSubsViaDebugIf(t *testing.T) {
2898 // Init counter check
2899 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2900 Counter{cRestSubReqFromXapp, 1},
2901 Counter{cRestSubRespToXapp, 1},
2902 Counter{cSubReqToE2, 1},
2903 Counter{cSubRespFromE2, 1},
2904 Counter{cRestSubNotifToXapp, 1},
2905 Counter{cRestSubDelReqFromXapp, 1},
2906 Counter{cSubDelReqToE2, 1},
2907 Counter{cSubDelRespFromE2, 1},
2908 Counter{cRestSubDelRespToXapp, 1},
2911 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2912 restSubId := xappConn1.SendRESTSubsReq(t, params)
2913 xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
2915 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2916 xappConn1.ExpectRESTNotification(t, restSubId)
2917 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2918 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2919 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
2921 xappsJson := mainCtrl.SendGetRequest(t, "localhost:8080", "/ric/v1/get_all_xapps")
2923 var xappList []string
2924 err := json.Unmarshal(xappsJson, &xappList)
2926 t.Errorf("Unmarshal error: %s", err)
2928 assert.Equal(t, true, mainCtrl.VerifyStringExistInSlice("localhost", xappList))
2930 // Simulate deletion through REST test and debug interface
2931 mainCtrl.SendDeleteRequest(t, "localhost:8080", "/ric/v1/delete_all_xapp_subscriptions/localhost") // localhost = xappServiceName
2932 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2933 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2935 // Wait that subs is cleaned
2936 waitSubsCleanup(t, e2SubsId, 10)
2937 mainCtrl.VerifyCounterValues(t)
2938 mainCtrl.VerifyAllClean(t)
2941 //-----------------------------------------------------------------------------
2942 // TestDelViaxAppSubsIf
2945 // +-------+ +---------+ +---------+ +---------+
2946 // | xapp | | submgr | | e2term | | rtmgr |
2947 // +-------+ +---------+ +---------+ +---------+
2949 // | RESTSubReq | | |
2950 // |---------------->| | |
2951 // | RESTSubResp | | |
2952 // |<----------------| | |
2953 // | | RouteCreate | |
2954 // | |--------------------------->|
2955 // | | RouteResponse| |
2956 // | |<---------------------------|
2958 // | |------------->| |
2960 // | |<-------------| |
2961 // | RESTNotif1 | | |
2962 // |<----------------| | |
2964 // | REST get_xapp_rest_restsubscriptions |
2965 // |---------------->| | |
2967 // |<----------------| | |
2968 // | RESTSudDel | | |
2969 // |---------------->| | | Via user curl command (port 8088)
2970 // | RESTSudDel | | |
2971 // |<----------------| | |
2972 // | | SubDelReq | |
2973 // | |------------->| |
2974 // | | SubDelResp | |
2975 // | |<-------------| |
2977 // | | RouteDelete | |
2978 // | |--------------------------->|
2979 // | | RouteResponse| |
2980 // | |<---------------------------|
2982 //-----------------------------------------------------------------------------
2984 func TestDelViaxAppSubsIf(t *testing.T) {
2986 // Init counter check
2987 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2988 Counter{cRestSubReqFromXapp, 1},
2989 Counter{cRestSubRespToXapp, 1},
2990 Counter{cSubReqToE2, 1},
2991 Counter{cSubRespFromE2, 1},
2992 Counter{cRestSubNotifToXapp, 1},
2993 Counter{cRestSubDelReqFromXapp, 1},
2994 Counter{cSubDelReqToE2, 1},
2995 Counter{cSubDelRespFromE2, 1},
2996 Counter{cRestSubDelRespToXapp, 1},
2999 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3000 restSubId := xappConn1.SendRESTSubsReq(t, params)
3001 xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
3003 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3004 xappConn1.ExpectRESTNotification(t, restSubId)
3005 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
3006 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3007 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
3009 restSubsListJson := mainCtrl.SendGetRequest(t, "localhost:8080", "/ric/v1/get_xapp_rest_restsubscriptions/localhost") // localhost = xappServiceName
3011 var restSubsMap map[string]RESTSubscription
3012 err := json.Unmarshal(restSubsListJson, &restSubsMap)
3014 t.Errorf("Unmarshal error: %s", err)
3016 _, ok := restSubsMap[restSubId]
3018 t.Errorf("REST subscription not found. restSubId=%s", restSubId)
3021 var e2Subscriptions []Subscription
3022 e2SubscriptionsJson := mainCtrl.SendGetRequest(t, "localhost:8080", "/ric/v1/get_e2subscriptions/"+restSubId)
3023 err = json.Unmarshal(e2SubscriptionsJson, &e2Subscriptions)
3025 t.Errorf("Unmarshal error: %s", err)
3027 if len(e2Subscriptions) != 1 {
3028 t.Errorf("Incorrect e2Subscriptions length %v", len(e2Subscriptions))
3031 // Simulate deletion through xapp REST test interface
3032 mainCtrl.SendDeleteRequest(t, "localhost:8088", "/ric/v1/subscriptions/"+restSubId)
3033 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3034 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3036 // Wait that subs is cleaned
3037 waitSubsCleanup(t, e2SubsId, 10)
3038 mainCtrl.VerifyCounterValues(t)
3039 mainCtrl.VerifyAllClean(t)
3042 //-----------------------------------------------------------------------------
3043 // TestRESTSubReqAndRouteNok
3046 // +-------+ +---------+ +---------+
3047 // | xapp | | submgr | | rtmgr |
3048 // +-------+ +---------+ +---------+
3051 // |---------------->| |
3053 // | RESTSubResp | |
3054 // |<----------------| |
3055 // | | RouteCreate |
3056 // | |------------->|
3057 // | | RouteCreate |
3059 // | |(Bad request) |
3060 // | |<-------------|
3062 // |<----------------| |
3064 // | [SUBS INT DELETE] |
3066 // | RESTSubDelReq | |
3067 // |---------------->| |
3068 // | RESTSubDelResp | |
3069 // |<----------------| |
3071 //-----------------------------------------------------------------------------
3072 func TestRESTSubReqAndRouteNok(t *testing.T) {
3074 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3075 Counter{cRestSubReqFromXapp, 1},
3076 Counter{cRestSubRespToXapp, 1},
3077 Counter{cRouteCreateFail, 1},
3078 Counter{cRestSubFailNotifToXapp, 1},
3079 Counter{cRestSubDelReqFromXapp, 1},
3080 Counter{cRestSubDelRespToXapp, 1},
3083 const subReqCount int = 1
3085 // Add delay for rtmgt HTTP handling so that HTTP response is received before notify on XAPP side
3086 waiter := rtmgrHttp.AllocNextSleep(50, false)
3087 newSubsId := mainCtrl.get_registry_next_subid(t)
3090 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3091 restSubId := xappConn1.SendRESTSubsReq(t, params)
3092 xappConn1.ExpectRESTNotificationNok(t, restSubId, "failAll")
3093 waiter.WaitResult(t)
3095 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3096 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
3099 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3101 // Wait that subs is cleaned
3102 mainCtrl.wait_subs_clean(t, newSubsId, 10)
3103 waitSubsCleanup(t, e2SubsId, 10)
3104 mainCtrl.VerifyCounterValues(t)
3105 mainCtrl.VerifyAllClean(t)
3108 //-----------------------------------------------------------------------------
3109 // TestRESTSubReqAndRouteUpdateNok
3111 // stub stub stub stub
3112 // +-------+ +-------+ +---------+ +---------+ +---------+
3113 // | xapp1 | | xapp2 | | submgr | | rtmgr | | e2term |
3114 // +-------+ +-------+ +---------+ +---------+ +---------+
3116 // | RESTSubReq1 | | |
3117 // |------------------------>| | |
3118 // | RESTSubResp2 | | |
3119 // |<------------------------| | |
3121 // | | | RouteCreate | |
3122 // | | |------------->| |
3123 // | | | CreateResp | |
3124 // | | |<-------------| |
3126 // | | |---------------------------->|
3127 // | | | SubResp | |
3128 // | | |<----------------------------|
3129 // | RESTNotif1 | | |
3130 // |<------------------------| | |
3132 // | | RESTSubReq2 | | |
3133 // | |------------>| | |
3134 // | | RESTSubResp2| | |
3135 // | |<------------| | |
3136 // | | | RouteUpdate | |
3137 // | | |------------->| |
3138 // | | | RouteUpdate | |
3139 // | | | status:400 | |
3140 // | | |(Bad request) | |
3141 // | | |<-------------| |
3142 // | | RESTNotif2(unsuccessful) | |
3143 // | |<------------| | |
3145 // | [SUBS INT DELETE] | |
3147 // | RESTSubDelReq1 | | |
3148 // |------------------------>| | |
3149 // | RESTSubDelResp1 | | |
3150 // |<------------------------| | |
3152 // | | | [SUBS DELETE] |
3154 //-----------------------------------------------------------------------------
3155 func TestRESTSubReqAndRouteUpdateNok(t *testing.T) {
3157 //Init counter check
3158 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3159 Counter{cRestSubReqFromXapp, 2},
3160 Counter{cRestSubRespToXapp, 2},
3161 Counter{cSubReqToE2, 1},
3162 Counter{cSubRespFromE2, 1},
3163 Counter{cRestSubNotifToXapp, 1},
3164 Counter{cRestSubFailNotifToXapp, 1},
3165 Counter{cRouteCreateUpdateFail, 1},
3166 Counter{cRestSubDelReqFromXapp, 2},
3167 Counter{cSubDelReqToE2, 1},
3168 Counter{cSubDelRespFromE2, 1},
3169 Counter{cRestSubDelRespToXapp, 2},
3172 var params *teststube2ap.RESTSubsReqParams = nil
3174 // Subs create for xapp1
3175 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3177 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3179 // xapp2 ROUTE creation shall fail with 400 from rtmgr -> submgr
3180 waiter := rtmgrHttp.AllocNextEvent(false)
3181 newSubsId := mainCtrl.get_registry_next_subid(t)
3182 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
3183 params.SetMeid("RAN_NAME_1")
3184 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
3185 xapp.Logger.Debug("Send REST subscriber request for second subscriber : %v", restSubId2)
3186 xappConn2.ExpectRESTNotificationNok(t, restSubId2, "allFail")
3187 waiter.WaitResult(t)
3188 xappConn2.WaitRESTNotification(t, restSubId2)
3190 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3192 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3193 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
3195 mainCtrl.wait_subs_clean(t, newSubsId, 10)
3196 //Wait that subs is cleaned
3197 waitSubsCleanup(t, e2SubsId, 10)
3199 mainCtrl.VerifyCounterValues(t)
3200 mainCtrl.VerifyAllClean(t)
3203 //-----------------------------------------------------------------------------
3204 // TestRESTSubDelReqAndRouteDeleteNok
3207 // +-------+ +---------+ +---------+ +---------+
3208 // | xapp | | submgr | | rtmgr | | e2term |
3209 // +-------+ +---------+ +---------+ +---------+
3211 // | RESTSubReq | | |
3212 // |---------------->| | |
3214 // | RESTSubResp | | |
3215 // |<----------------| | |
3217 // | |---------------------------->|
3219 // | |<----------------------------|
3220 // | RESTNotif | | |
3221 // |<----------------| | |
3224 // | RESTSubDelReq | | |
3225 // |---------------->| | |
3226 // | RESTSubDelResp | | |
3227 // |<----------------| | |
3228 // | | SubSelReq | |
3229 // | |---------------------------->|
3230 // | | SubSelResp | |
3231 // | |<----------------------------|
3232 // | | RouteDelete | |
3233 // | |------------->| |
3234 // | | Routedelete | |
3235 // | | status:400 | |
3236 // | |(Bad request) | |
3237 // | |<-------------| |
3239 //-----------------------------------------------------------------------------
3241 func TestRESTSubDelReqAndRouteDeleteNok(t *testing.T) {
3243 // Init counter check
3244 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3245 Counter{cRestSubReqFromXapp, 1},
3246 Counter{cRestSubRespToXapp, 1},
3247 Counter{cSubReqToE2, 1},
3248 Counter{cSubRespFromE2, 1},
3249 Counter{cRestSubNotifToXapp, 1},
3250 Counter{cRestSubDelReqFromXapp, 1},
3251 Counter{cRouteDeleteFail, 1},
3252 Counter{cSubDelReqToE2, 1},
3253 Counter{cSubDelRespFromE2, 1},
3254 Counter{cRestSubDelRespToXapp, 1},
3257 var params *teststube2ap.RESTSubsReqParams = nil
3260 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3262 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3264 waiter := rtmgrHttp.AllocNextEvent(false)
3265 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3266 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3267 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3268 waiter.WaitResult(t)
3270 waitSubsCleanup(t, e2SubsId, 10)
3271 mainCtrl.VerifyCounterValues(t)
3272 mainCtrl.VerifyAllClean(t)
3275 //-----------------------------------------------------------------------------
3276 // TestRESTSubMergeDelAndRouteUpdateNok
3278 // stub stub stub stub
3279 // +-------+ +-------+ +---------+ +---------+ +---------+
3280 // | xapp1 | | xapp2 | | submgr | | rtmgr | | e2term |
3281 // +-------+ +-------+ +---------+ +---------+ +---------+
3283 // | RESTSubReq1 | | |
3284 // |------------------------>| | |
3285 // | RESTSubResp2 | | |
3286 // |<------------------------| | |
3288 // | | | RouteCreate | |
3289 // | | |------------->| |
3290 // | | | CreateResp | |
3291 // | | |<-------------| |
3293 // | | |---------------------------->|
3294 // | | | SubResp | |
3295 // | | |<----------------------------|
3296 // | RESTNotif1 | | |
3297 // |<------------------------| | |
3299 // | | RESTSubReq2 | | |
3300 // | |------------>| | |
3301 // | | RESTSubResp2| | |
3302 // | |<------------| | |
3303 // | | | RouteCreate | |
3304 // | | |------------->| |
3305 // | | | CreateResp | |
3306 // | | |<-------------| |
3308 // | | |---------------------------->|
3309 // | | | SubResp | |
3310 // | | |<----------------------------|
3311 // | | RESTNotif2 | | |
3312 // | |<------------| | |
3314 // | [SUBS INT DELETE] | |
3316 // | RESTSubDelReq1 | | |
3317 // |------------------------>| | |
3318 // | RESTSubDelResp1 | | |
3319 // |<------------------------| | |
3320 // | | | SubDelReq | |
3321 // | | |---------------------------->|
3322 // | | | SubDelResp | |
3323 // | | |<----------------------------|
3324 // | | | RouteUpdate | |
3325 // | | |------------->| |
3326 // | | | RouteUpdate | |
3327 // | | | status:400 | |
3328 // | | |(Bad request) | |
3329 // | | |<-------------| |
3331 // | | RESTSubDelReq2 | |
3332 // | |------------>| | |
3333 // | | RESTSubDelResp2 | |
3334 // | |<------------| | |
3335 // | | | SubDelReq | |
3336 // | | |---------------------------->|
3337 // | | | SubdelResp | |
3338 // | | |<----------------------------|
3339 // | | | RouteDelete | |
3340 // | | |------------->| |
3341 // | | | Deleteresp | |
3342 // | | |<-------------| |
3344 //-----------------------------------------------------------------------------
3346 func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) {
3348 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3349 Counter{cRestSubReqFromXapp, 2},
3350 Counter{cMergedSubscriptions, 1},
3351 Counter{cRestSubRespToXapp, 2},
3352 Counter{cSubReqToE2, 1},
3353 Counter{cSubRespFromE2, 1},
3354 Counter{cRestSubNotifToXapp, 2},
3355 Counter{cRestSubDelReqFromXapp, 2},
3356 Counter{cRouteDeleteUpdateFail, 1},
3357 Counter{cSubDelReqToE2, 1},
3358 Counter{cSubDelRespFromE2, 1},
3359 Counter{cRestSubDelRespToXapp, 2},
3360 Counter{cUnmergedSubscriptions, 1},
3363 var params *teststube2ap.RESTSubsReqParams = nil
3366 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3368 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3369 restSubId2, e2SubsId2 := createXapp2MergedSubscription(t, "RAN_NAME_1")
3371 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
3373 //Del1, this shall fail on rtmgr side
3374 waiter := rtmgrHttp.AllocNextEvent(false)
3375 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3376 waiter.WaitResult(t)
3378 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13660"})
3381 deleteXapp2Subscription(t, &restSubId2)
3383 waitSubsCleanup(t, e2SubsId2, 10)
3384 mainCtrl.VerifyCounterValues(t)
3385 mainCtrl.VerifyAllClean(t)
3388 //-----------------------------------------------------------------------------
3389 // TestRESTSubReqRetransmission
3392 // +-------+ +---------+ +---------+
3393 // | xapp | | submgr | | e2term |
3394 // +-------+ +---------+ +---------+
3396 // | RESTSubReq1 | |
3397 // |---------------->| |
3399 // | RESTSubResp | |
3400 // |<----------------| |
3402 // | |------------->|
3404 // | RESTSubReq2 | |
3406 // |---------------->| |
3407 // | RESTSubResp(201)| |
3408 // |<----------------| |
3411 // | |<-------------|
3413 // |<----------------| |
3415 // | [SUBS DELETE] |
3418 //-----------------------------------------------------------------------------
3420 func TestRESTSubReqRetransmission(t *testing.T) {
3422 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3423 Counter{cRestSubReqFromXapp, 2},
3424 Counter{cRestSubRespToXapp, 2},
3425 Counter{cSubReqToE2, 1},
3426 Counter{cSubRespFromE2, 1},
3427 Counter{cRestSubNotifToXapp, 1},
3428 Counter{cRestSubDelReqFromXapp, 1},
3429 Counter{cSubDelReqToE2, 1},
3430 Counter{cSubDelRespFromE2, 1},
3431 Counter{cRestSubDelRespToXapp, 1},
3433 // Retry/duplicate will get the same way as the first request.
3434 // Contianed duplicate messages from same xapp will not be merged. Here we use xappConn2 to simulate sending
3435 // second request from same xapp as doing it from xappConn1 would not work as notification would not be received
3438 const subReqCount int = 1
3440 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3441 restSubId := xappConn1.SendRESTSubsReq(t, params)
3443 xappConn1.SendRESTSubsReq(t, params)
3444 <-time.After(time.Second * 1)
3446 xappConn1.WaitListedRestNotifications(t, []string{restSubId})
3448 // Depending one goroutine scheduling order, we cannot say for sure which xapp reaches e2term first. Thus
3449 // the order is not significant here.
3450 crereq, cremsg := e2termConn1.RecvSubsReq(t)
3451 e2termConn1.SendSubsResp(t, crereq, cremsg)
3453 e2SubsId := <-xappConn1.ListedRESTNotifications
3455 xapp.Logger.Debug("TEST: XAPP notification received e2SubsId=%v", e2SubsId)
3458 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3459 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
3460 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
3462 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsId.E2SubsId}, 10)
3464 mainCtrl.VerifyCounterValues(t)
3465 mainCtrl.VerifyAllClean(t)
3468 //-----------------------------------------------------------------------------
3470 // +-------+ +---------+ +---------+ +---------+
3471 // | xapp | | submgr | | e2term | | rtmgr |
3472 // +-------+ +---------+ +---------+ +---------+
3474 // | RESTSubReq | | |
3475 // |---------------->| | |
3476 // | RESTSubResp | | |
3477 // |<----------------| | |
3478 // | | RouteCreate | |
3479 // | |--------------------------->|
3480 // | | RouteResponse| |
3481 // | |<---------------------------| // The order of these events may vary
3483 // | |------------->| | // The order of these events may vary
3485 // | |<-------------| |
3486 // | RESTNotif1 | | |
3487 // |<----------------| | |
3488 // | RESTSubReq | | |
3489 // | [RETRANS1] | | |
3490 // |---------------->| | |
3491 // | RESTNotif1 | | |
3492 // |<----------------| | |
3493 // | RESTSubReq | | |
3494 // | [RETRANS2] | | |
3495 // |---------------->| | |
3496 // | RESTNotif1 | | |
3497 // |<----------------| | |
3498 // | RESTSubDelReq | | |
3499 // |---------------->| | |
3500 // | | SubDelReq | |
3501 // | |------------->| |
3502 // | RESTSubDelResp| | |
3503 // |<----------------| | |
3504 // | | SubDelResp | |
3505 // | |<-------------| |
3508 //-----------------------------------------------------------------------------
3510 func TestRESTSubReqRetransmissionV2(t *testing.T) {
3512 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3513 Counter{cRestSubReqFromXapp, 3},
3514 Counter{cDuplicateE2SubReq, 2},
3515 Counter{cRestSubRespToXapp, 3},
3516 Counter{cSubReqToE2, 1},
3517 Counter{cSubRespFromE2, 1},
3518 Counter{cRestSubNotifToXapp, 3},
3519 Counter{cRestSubDelReqFromXapp, 1},
3520 Counter{cSubDelReqToE2, 1},
3521 Counter{cSubDelRespFromE2, 1},
3522 Counter{cRestSubDelRespToXapp, 1},
3525 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3527 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3529 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3531 mainCtrl.WaitOngoingRequestMapEmpty()
3534 restSubId_resend := xappConn1.SendRESTSubsReq(t, params)
3536 assert.Equal(t, restSubId_resend, restSubId)
3538 mainCtrl.WaitOngoingRequestMapEmpty()
3541 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3543 assert.Equal(t, restSubId_resend2, restSubId)
3545 mainCtrl.WaitOngoingRequestMapEmpty()
3547 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3549 waitSubsCleanup(t, e2SubsId, 10)
3550 mainCtrl.VerifyCounterValues(t)
3551 mainCtrl.VerifyAllClean(t)
3554 //-----------------------------------------------------------------------------
3556 // +-------+ +---------+ +---------+ +---------+
3557 // | xapp | | submgr | | e2term | | rtmgr |
3558 // +-------+ +---------+ +---------+ +---------+
3560 // | RESTSubReq | | |
3561 // |---------------->| | |
3562 // | RESTSubResp | | |
3563 // |<----------------| | |
3564 // | | RouteCreate | |
3565 // | |--------------------------->|
3566 // | | RouteResponse| |
3567 // | |<---------------------------| // The order of these events may vary
3569 // | |------------->| | // The order of these events may vary
3571 // | |<-------------| |
3572 // | RESTNotif1 | | |
3573 // |<----------------| | |
3574 // | RESTSubReq | | |
3575 // | [RETRANS, with RESTsubsId] | |
3576 // |---------------->| | |
3577 // | RESTNotif1 | | |
3578 // |<----------------| | |
3579 // | RESTSubReq | | |
3580 // | [RETRANS, without RESTsubsId] | |
3581 // |---------------->| | |
3582 // | RESTNotif1 | | |
3583 // |<----------------| | |
3584 // | RESTSubDelReq | | |
3585 // |---------------->| | |
3586 // | | SubDelReq | |
3587 // | |------------->| |
3588 // | RESTSubDelResp| | |
3589 // |<----------------| | |
3590 // | | SubDelResp | |
3591 // | |<-------------| |
3594 //-----------------------------------------------------------------------------
3595 func TestRESTSubReqRetransmissionV3(t *testing.T) {
3597 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3598 Counter{cRestSubReqFromXapp, 3},
3599 Counter{cDuplicateE2SubReq, 2},
3600 Counter{cRestSubRespToXapp, 3},
3601 Counter{cSubReqToE2, 1},
3602 Counter{cSubRespFromE2, 1},
3603 Counter{cRestSubNotifToXapp, 3},
3604 Counter{cRestSubDelReqFromXapp, 1},
3605 Counter{cSubDelReqToE2, 1},
3606 Counter{cSubDelRespFromE2, 1},
3607 Counter{cRestSubDelRespToXapp, 1},
3610 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3612 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3614 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3616 mainCtrl.WaitOngoingRequestMapEmpty()
3618 //1.st resend with subscription ID
3619 params.SetSubscriptionID(&restSubId)
3620 restSubId_resend := xappConn1.SendRESTSubsReq(t, params)
3622 assert.Equal(t, restSubId_resend, restSubId)
3624 mainCtrl.WaitOngoingRequestMapEmpty()
3626 //2.nd resend without subscription ID (faking app restart)
3627 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3628 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3630 assert.Equal(t, restSubId_resend2, restSubId)
3632 mainCtrl.WaitOngoingRequestMapEmpty()
3634 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3636 waitSubsCleanup(t, e2SubsId, 10)
3637 mainCtrl.VerifyCounterValues(t)
3638 mainCtrl.VerifyAllClean(t)
3641 //-----------------------------------------------------------------------------
3643 // +-------+ +---------+ +---------+ +---------+
3644 // | xapp | | submgr | | e2term | | rtmgr |
3645 // +-------+ +---------+ +---------+ +---------+
3647 // | RESTSubReq | | |
3648 // |---------------->| | |
3649 // | RESTSubResp | | |
3650 // |<----------------| | |
3651 // | | RouteCreate | |
3652 // | |--------------------------->|
3653 // | | RouteResponse| |
3654 // | |<---------------------------|
3656 // | |------------->| |
3658 // | |<-------------| |
3659 // | RESTNotif1 | | |
3660 // |<----------------| | |
3661 // | RESTSubReq | | |
3662 // | [with RestSUbsId + one additional e2 subDetail]
3663 // |---------------->| | |
3664 // | RESTNotif1 | | |
3665 // | [for initial e2 subDetail] | |
3666 // |<----------------| | |
3667 // | | RouteCreate | |
3668 // | |--------------------------->|
3669 // | | RouteResponse| |
3670 // | |<---------------------------|
3672 // | |------------->| |
3674 // | |<-------------| |
3675 // | RESTNotif1 | | |
3676 // |<----------------| | |
3677 // | RESTSubReq | | |
3678 // | [with RESTsubsId initial request] |
3679 // |---------------->| | |
3680 // | RESTNotif1 | | |
3681 // |<----------------| | |
3682 // | RESTSubDelReq | | |
3683 // |---------------->| | |
3684 // | RESTSubDelResp| | |
3685 // |<----------------| | |
3686 // | | SubDelReq | |
3687 // | |------------->| |
3688 // | | SubDelResp | |
3689 // | |<-------------| |
3690 // | | SubDelReq | |
3691 // | |------------->| |
3692 // | | SubDelResp | |
3693 // | |<-------------| |
3696 //-----------------------------------------------------------------------------
3698 func TestRESTSubReqRetransmissionV4(t *testing.T) {
3700 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3701 Counter{cRestSubReqFromXapp, 3},
3702 Counter{cDuplicateE2SubReq, 2},
3703 Counter{cRestSubRespToXapp, 3},
3704 Counter{cSubReqToE2, 2},
3705 Counter{cSubRespFromE2, 2},
3706 Counter{cRestSubNotifToXapp, 4},
3707 Counter{cRestSubDelReqFromXapp, 1},
3708 Counter{cSubDelReqToE2, 2},
3709 Counter{cSubDelRespFromE2, 2},
3710 Counter{cRestSubDelRespToXapp, 1},
3713 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3715 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3717 mainCtrl.WaitOngoingRequestMapEmpty()
3719 // Send modified requst, this time with e2 subscriptions.
3720 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3721 params2.SetSubscriptionID(&restSubId)
3723 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3724 xappConn1.ExpectAnyNotification(t)
3725 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3726 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3727 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3728 assert.Equal(t, e2SubsId, e2SubsId1)
3730 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3732 xappConn1.DecrementRequestCount()
3733 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3734 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3735 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3736 assert.NotEqual(t, e2SubsId2, 0)
3738 mainCtrl.WaitOngoingRequestMapEmpty()
3740 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3741 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3742 params.SetSubscriptionID(&restSubId)
3743 xappConn1.ExpectAnyNotification(t)
3744 // Resend the original request again with only one e2 subscription (detail), this time with restsubsid
3745 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3746 assert.Equal(t, restSubId_resend, restSubId_resend2)
3748 e2SubsId1 = xappConn1.WaitAnyRESTNotification(t)
3749 assert.Equal(t, e2SubsId, e2SubsId1)
3751 mainCtrl.WaitOngoingRequestMapEmpty()
3753 // Delete both e2 subscriptions
3754 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3755 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3756 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3758 waitSubsCleanup(t, e2SubsId, 10)
3759 mainCtrl.VerifyCounterValues(t)
3760 mainCtrl.VerifyAllClean(t)
3763 //-----------------------------------------------------------------------------
3765 // +-------+ +---------+ +---------+ +---------+
3766 // | xapp | | submgr | | e2term | | rtmgr |
3767 // +-------+ +---------+ +---------+ +---------+
3769 // | RESTSubReq | | |
3770 // |---------------->| | |
3771 // | RESTSubResp | | |
3772 // |<----------------| | |
3773 // | | RouteCreate | |
3774 // | |--------------------------->|
3775 // | | RouteResponse| |
3776 // | |<---------------------------|
3778 // | |------------->| |
3780 // | |<-------------| |
3781 // | RESTNotif1 | | |
3782 // |<----------------| | |
3783 // | RESTSubReq | | |
3784 // | [with RestSUbsId + one additional e2 subDetail]
3785 // |---------------->| | |
3786 // | RESTNotif1 | | |
3787 // | [for initial e2 subDetail] | |
3788 // |<----------------| | |
3789 // | | RouteCreate | |
3790 // | |--------------------------->|
3791 // | | RouteResponse| |
3792 // | |<---------------------------|
3794 // | |------------->| |
3796 // | |<-------------| |
3797 // | RESTNotif1 | | |
3798 // |<----------------| | |
3799 // | RESTSubReq | | |
3800 // | [without RESTsubsId initial request] |
3801 // |---------------->| | |
3802 // | RESTNotif1 | | |
3803 // |<----------------| | |
3804 // | RESTSubDelReq | | |
3805 // |---------------->| | |
3806 // | RESTSubDelResp| | |
3807 // |<----------------| | |
3808 // | | SubDelReq | |
3809 // | |------------->| |
3810 // | | SubDelResp | |
3811 // | |<-------------| |
3812 // | | SubDelReq | |
3813 // | |------------->| |
3814 // | | SubDelResp | |
3815 // | |<-------------| |
3818 //-----------------------------------------------------------------------------
3820 func TestRESTSubReqRetransmissionV5(t *testing.T) {
3822 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3823 Counter{cRestSubReqFromXapp, 3},
3824 Counter{cDuplicateE2SubReq, 2},
3825 Counter{cRestSubRespToXapp, 3},
3826 Counter{cSubReqToE2, 2},
3827 Counter{cSubRespFromE2, 2},
3828 Counter{cRestSubNotifToXapp, 4},
3829 Counter{cRestSubDelReqFromXapp, 1},
3830 Counter{cSubDelReqToE2, 2},
3831 Counter{cSubDelRespFromE2, 2},
3832 Counter{cRestSubDelRespToXapp, 1},
3835 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3837 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3839 mainCtrl.WaitOngoingRequestMapEmpty()
3841 // Send modified request, this time with e2 subscriptions.
3842 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3843 params2.SetSubscriptionID(&restSubId)
3845 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3846 xappConn1.ExpectAnyNotification(t)
3847 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3848 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3850 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3851 assert.Equal(t, e2SubsId, e2SubsId1)
3852 // The first E2 subscription returns immediately, manually decrement expected request count for the remaining request handling
3853 xappConn1.DecrementRequestCount()
3855 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3857 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3858 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3859 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3860 assert.NotEqual(t, e2SubsId2, 0)
3862 mainCtrl.WaitOngoingRequestMapEmpty()
3864 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3865 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3866 xappConn1.ExpectAnyNotification(t)
3867 // Resend the original request again with only one e2 subscription (detail), WITHOUT restsubsid
3868 // md5sum shall find the original request
3869 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3870 assert.Equal(t, restSubId_resend, restSubId_resend2)
3872 e2SubsId1 = xappConn1.WaitAnyRESTNotification(t)
3873 assert.Equal(t, e2SubsId, e2SubsId1)
3875 mainCtrl.WaitOngoingRequestMapEmpty()
3877 // Delete both e2 subscriptions
3878 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3879 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3880 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3882 waitSubsCleanup(t, e2SubsId, 10)
3883 mainCtrl.VerifyCounterValues(t)
3884 mainCtrl.VerifyAllClean(t)
3887 //-----------------------------------------------------------------------------
3889 // +-------+ +---------+ +---------+ +---------+
3890 // | xapp | | submgr | | e2term | | rtmgr |
3891 // +-------+ +---------+ +---------+ +---------+
3893 // | RESTSubReq | | |
3894 // |---------------->| | |
3895 // | RESTSubResp | | |
3896 // |<----------------| | |
3897 // | | RouteCreate | |
3898 // | |--------------------------->|
3899 // | | RouteResponse| |
3900 // | |<---------------------------|
3902 // | |------------->| |
3904 // | |<-------------| |
3905 // | RESTNotif1 | | |
3906 // |<----------------| | |
3907 // | RESTSubReq | | |
3908 // | [with RestSUbsId + one additional e2 subDetail]
3909 // |---------------->| | |
3910 // | RESTNotif1 | | |
3911 // | [for initial e2 subDetail] | |
3912 // |<----------------| | |
3913 // | | RouteCreate | |
3914 // | |--------------------------->|
3915 // | | RouteResponse| |
3916 // | |<---------------------------|
3918 // | |------------->| |
3920 // | |<-------------| |
3921 // | RESTNotif1 | | |
3922 // |<----------------| | |
3923 // | RESTSubDelReq | | |
3924 // |---------------->| | |
3925 // | RESTSubDelResp| | |
3926 // |<----------------| | |
3927 // | | SubDelReq | |
3928 // | |------------->| |
3929 // | | SubDelResp | |
3930 // | |<-------------| |
3931 // | | SubDelReq | |
3932 // | |------------->| |
3933 // | | SubDelResp | |
3934 // | |<-------------| |
3935 // | RESTSubReq | | |
3936 // | [with RESTsubsId initial request] |
3937 // |---------------->| | |
3938 // | RESTSubResp | | |
3939 // |<----------------| | |
3940 // | | RouteCreate | |
3941 // | |--------------------------->|
3942 // | | RouteResponse| |
3943 // | |<---------------------------|
3945 // | |------------->| |
3947 // | |<-------------| |
3948 // | RESTNotif1 | | |
3949 // |<----------------| | |
3952 //-----------------------------------------------------------------------------
3953 func TestRESTSubReqRetransmissionV6(t *testing.T) {
3955 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3956 Counter{cRestSubReqFromXapp, 3},
3957 Counter{cDuplicateE2SubReq, 1},
3958 Counter{cRestSubRespToXapp, 3},
3959 Counter{cSubReqToE2, 3},
3960 Counter{cSubRespFromE2, 3},
3961 Counter{cRestSubNotifToXapp, 4},
3962 Counter{cRestSubDelReqFromXapp, 2},
3963 Counter{cSubDelReqToE2, 3},
3964 Counter{cSubDelRespFromE2, 3},
3965 Counter{cRestSubDelRespToXapp, 2},
3968 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3970 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3972 mainCtrl.WaitOngoingRequestMapEmpty()
3974 // Send modified requst, this time with e2 subscriptions.
3975 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3976 params2.SetSubscriptionID(&restSubId)
3978 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3979 xappConn1.ExpectAnyNotification(t)
3980 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3981 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3983 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3984 assert.Equal(t, e2SubsId, e2SubsId1)
3986 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3988 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3989 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3990 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3991 assert.NotEqual(t, e2SubsId2, 0)
3993 mainCtrl.WaitOngoingRequestMapEmpty()
3995 // Delete both e2 subscriptions
3996 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3997 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3998 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
4000 waitSubsCleanup(t, e2SubsId, 10)
4002 // Resend the original request, we shall find it's previous md5sum/restsubs
4003 // but the restsubscription has been already removed. This shall trigger a
4005 restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
4007 mainCtrl.WaitOngoingRequestMapEmpty()
4009 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
4011 waitSubsCleanup(t, e2SubsId, 10)
4012 mainCtrl.VerifyCounterValues(t)
4013 mainCtrl.VerifyAllClean(t)
4016 //-----------------------------------------------------------------------------
4017 // TestRESTSubDelReqRetransmission
4020 // +-------+ +---------+ +---------+
4021 // | xapp | | submgr | | e2term |
4022 // +-------+ +---------+ +---------+
4025 // |---------------->| |
4027 // | RESTSubResp | |
4028 // |<----------------| |
4030 // | |------------->|
4032 // | |<-------------|
4034 // |<----------------| |
4036 // | RESTSubDelReq | |
4037 // |---------------->| |
4038 // | RESTSubDelResp | |
4039 // |<----------------| |
4041 // | |------------->|
4042 // | RESTSubDelReq | |
4043 // |---------------->| |
4044 // | RESTSubDelResp | |
4045 // |<----------------| |
4047 // | |<-------------|
4050 //-----------------------------------------------------------------------------
4052 func TestRESTSubDelReqRetransmission(t *testing.T) {
4054 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4055 Counter{cRestSubReqFromXapp, 1},
4056 Counter{cRestSubRespToXapp, 1},
4057 Counter{cSubReqToE2, 1},
4058 Counter{cSubRespFromE2, 1},
4059 Counter{cRestSubNotifToXapp, 1},
4060 Counter{cRestSubDelReqFromXapp, 2},
4061 Counter{cSubDelReqToE2, 1},
4062 Counter{cSubDelRespFromE2, 1},
4063 Counter{cRestSubDelRespToXapp, 2},
4066 var params *teststube2ap.RESTSubsReqParams = nil
4069 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4071 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
4074 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4075 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4078 seqBef := mainCtrl.get_msgcounter(t)
4079 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4080 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
4083 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4085 waitSubsCleanup(t, e2SubsId, 10)
4086 mainCtrl.VerifyCounterValues(t)
4087 mainCtrl.VerifyAllClean(t)
4090 //-----------------------------------------------------------------------------
4091 // TestRESTSubReqDelReq
4094 // +-------+ +---------+ +---------+
4095 // | xapp | | submgr | | e2term |
4096 // +-------+ +---------+ +---------+
4099 // |---------------->| |
4101 // | RESTSubResp | |
4102 // |<----------------| |
4104 // | |------------->|
4105 // | RESTSubDelReq | |
4106 // |---------------->| |
4107 // | RESTSubDelResp | |
4109 // |<----------------| |
4111 // | |<-------------|
4113 // |<----------------| |
4115 // | [SUBS DELETE] |
4118 //-----------------------------------------------------------------------------
4119 func TestRESTSubReqDelReq(t *testing.T) {
4121 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4122 Counter{cRestSubReqFromXapp, 1},
4123 Counter{cRestSubRespToXapp, 1},
4124 Counter{cSubReqToE2, 1},
4125 Counter{cSubRespFromE2, 1},
4126 Counter{cRestSubNotifToXapp, 1},
4127 Counter{cRestSubDelReqFromXapp, 2},
4128 Counter{cRestSubDelFailToXapp, 1},
4129 Counter{cSubDelReqToE2, 1},
4130 Counter{cSubDelRespFromE2, 1},
4131 Counter{cRestSubDelRespToXapp, 1},
4134 const subReqCount int = 1
4137 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4138 restSubId := xappConn1.SendRESTSubsReq(t, params)
4140 // Del. This will fail as processing of the subscription
4141 // is still ongoing in submgr. Deletion is not allowed before
4142 // subscription creation has been completed.
4143 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4144 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4145 xappConn1.ExpectRESTNotification(t, restSubId)
4146 e2termConn1.SendSubsResp(t, crereq, cremsg)
4147 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4150 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4152 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4153 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4155 // Wait that subs is cleaned
4156 waitSubsCleanup(t, e2SubsId, 10)
4157 mainCtrl.VerifyCounterValues(t)
4158 mainCtrl.VerifyAllClean(t)
4161 //-----------------------------------------------------------------------------
4162 // TestRESTSubReqAndSubDelOkTwoParallel
4165 // +-------+ +-------+ +---------+ +---------+
4166 // | xapp2 | | xapp1 | | submgr | | e2term |
4167 // +-------+ +-------+ +---------+ +---------+
4169 // | | RESTSubReq1 | |
4170 // | |------------->| |
4171 // | | RESTSubResp1 | |
4172 // | |<-------------| |
4175 // | | |------------->|
4177 // | RESTSubReq2 | |
4178 // |------------------------>| |
4179 // | RESTSubResp2 | |
4180 // |<------------------------| |
4183 // | | |------------->|
4186 // | | |<-------------|
4187 // | | RESTNotif1 | |
4188 // | |<-------------| |
4191 // | | |<-------------|
4193 // |<------------------------| |
4195 // | | [SUBS 1 DELETE] |
4197 // | | [SUBS 2 DELETE] |
4200 //-----------------------------------------------------------------------------
4202 func TestRESTSubReqAndSubDelOkTwoParallel(t *testing.T) {
4204 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4205 Counter{cRestSubReqFromXapp, 2},
4206 Counter{cRestSubRespToXapp, 2},
4207 Counter{cSubReqToE2, 2},
4208 Counter{cSubRespFromE2, 2},
4209 Counter{cRestSubNotifToXapp, 2},
4210 Counter{cRestSubDelReqFromXapp, 2},
4211 Counter{cSubDelReqToE2, 2},
4212 Counter{cSubDelRespFromE2, 2},
4213 Counter{cRestSubDelRespToXapp, 2},
4217 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4218 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4219 xapp.Logger.Debug("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
4222 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4223 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4224 xapp.Logger.Debug("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
4226 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4227 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
4229 //XappConn1 receives both of the responses
4230 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
4233 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4235 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
4237 e2SubsIdA := <-xappConn1.ListedRESTNotifications
4238 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
4239 e2SubsIdB := <-xappConn1.ListedRESTNotifications
4240 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
4243 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
4245 deleteSubscription(t, xappConn2, e2termConn1, &restSubId2)
4247 //Wait that subs is cleaned
4248 mainCtrl.wait_subs_clean(t, e2SubsIdA.E2SubsId, 10)
4249 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
4251 mainCtrl.VerifyCounterValues(t)
4252 mainCtrl.VerifyAllClean(t)
4255 //-----------------------------------------------------------------------------
4256 // TestRESTSameSubsDiffRan
4257 // Same subscription to different RANs
4260 // +-------+ +---------+ +---------+
4261 // | xapp | | submgr | | e2term |
4262 // +-------+ +---------+ +---------+
4264 // | RESTSubReq(r1) | |
4265 // |---------------->| |
4266 // | RESTSubResp(r1) | |
4267 // |<----------------| |
4270 // | |------------->|
4272 // | | SubResp(r1) |
4273 // | |<-------------|
4275 // | RESTNotif(r1) | |
4276 // |<----------------| |
4278 // | RESTSubReq(r2) | |
4279 // |---------------->| |
4281 // | RESTSubResp(r2) | |
4282 // |<----------------| |
4284 // | |------------->|
4286 // | | SubResp(r2) |
4287 // | |<-------------|
4289 // | RESTNotif(r2) | |
4290 // |<----------------| |
4292 // | [SUBS r1 DELETE] |
4294 // | [SUBS r2 DELETE] |
4297 //-----------------------------------------------------------------------------
4299 func TestRESTSameSubsDiffRan(t *testing.T) {
4301 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4302 Counter{cRestSubReqFromXapp, 2},
4303 Counter{cRestSubRespToXapp, 2},
4304 Counter{cSubReqToE2, 2},
4305 Counter{cSubRespFromE2, 2},
4306 Counter{cRestSubNotifToXapp, 2},
4307 Counter{cRestSubDelReqFromXapp, 2},
4308 Counter{cSubDelReqToE2, 2},
4309 Counter{cSubDelRespFromE2, 2},
4310 Counter{cRestSubDelRespToXapp, 2},
4313 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4314 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4315 xapp.Logger.Debug("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
4317 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
4318 params.SetMeid("RAN_NAME_2")
4319 restSubId2, e2SubsId2 := createSubscription(t, xappConn1, e2termConn1, params)
4320 xapp.Logger.Debug("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
4323 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
4325 deleteSubscription(t, xappConn1, e2termConn1, &restSubId2)
4327 //Wait that subs is cleaned
4328 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
4329 waitSubsCleanup(t, e2SubsId2, 10)
4331 mainCtrl.VerifyCounterValues(t)
4332 mainCtrl.VerifyAllClean(t)
4335 //-----------------------------------------------------------------------------
4336 // TestRESTSubReqRetryInSubmgr
4339 // +-------+ +---------+ +---------+
4340 // | xapp | | submgr | | e2term |
4341 // +-------+ +---------+ +---------+
4344 // |---------------->| |
4345 // | RESTSubResp | |
4346 // |<----------------| |
4348 // | |------------->|
4352 // | |------------->|
4354 // | |<-------------|
4357 // |<----------------| |
4359 // | [SUBS DELETE] |
4362 //-----------------------------------------------------------------------------
4364 func TestRESTSubReqRetryInSubmgr(t *testing.T) {
4366 // Init counter check
4367 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4368 Counter{cRestSubReqFromXapp, 1},
4369 Counter{cRestSubRespToXapp, 1},
4370 Counter{cSubReqToE2, 1},
4371 Counter{cSubReqTimerExpiry, 1},
4372 Counter{cSubReReqToE2, 1},
4373 Counter{cSubRespFromE2, 1},
4374 Counter{cRestSubNotifToXapp, 1},
4375 Counter{cRestSubDelReqFromXapp, 1},
4376 Counter{cSubDelReqToE2, 1},
4377 Counter{cSubDelRespFromE2, 1},
4378 Counter{cRestSubDelRespToXapp, 1},
4381 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4382 restSubId := xappConn1.SendRESTSubsReq(t, params)
4384 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
4386 // Catch the first message and ignore it
4387 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4388 xapp.Logger.Debug("Ignore REST subscriber request for subscriber : %v", restSubId)
4390 // The second request is being handled normally
4391 crereq, cremsg = e2termConn1.RecvSubsReq(t)
4392 xappConn1.ExpectRESTNotification(t, restSubId)
4393 e2termConn1.SendSubsResp(t, crereq, cremsg)
4394 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4396 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
4399 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
4401 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
4402 //Wait that subs is cleaned
4403 waitSubsCleanup(t, e2SubsId, 10)
4405 mainCtrl.VerifyCounterValues(t)
4406 mainCtrl.VerifyAllClean(t)
4409 //-----------------------------------------------------------------------------
4410 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
4413 // +-------+ +---------+ +---------+
4414 // | xapp | | submgr | | e2term |
4415 // +-------+ +---------+ +---------+
4418 // |---------------->| |
4420 // | RESTSubResp | |
4421 // |<----------------| |
4423 // | |------------->|
4427 // | |------------->|
4430 // | |------------->|
4434 // | |------------->|
4438 // | |<-------------|
4441 // |<----------------| |
4443 // | [SUBS DELETE] |
4446 //-----------------------------------------------------------------------------
4448 func TestRESTSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
4450 // Init counter check
4451 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4452 Counter{cRestSubReqFromXapp, 1},
4453 Counter{cRestSubRespToXapp, 1},
4454 Counter{cSubReqToE2, 1},
4455 Counter{cSubReReqToE2, 1},
4456 Counter{cSubReqTimerExpiry, 2},
4457 Counter{cRestSubFailNotifToXapp, 1},
4458 Counter{cSubDelReqToE2, 1},
4459 Counter{cSubDelRespFromE2, 1},
4460 Counter{cRestSubDelReqFromXapp, 1},
4461 Counter{cRestSubDelRespToXapp, 1},
4464 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4465 restSubId := xappConn1.SendRESTSubsReq(t, params)
4466 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
4468 e2termConn1.RecvSubsReq(t)
4469 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
4471 e2termConn1.RecvSubsReq(t)
4472 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
4474 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4475 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
4476 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4477 xappConn1.WaitRESTNotification(t, restSubId)
4479 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4481 // Wait that subs is cleaned
4482 waitSubsCleanup(t, delreq.RequestId.InstanceId, 10)
4483 mainCtrl.VerifyCounterValues(t)
4484 mainCtrl.VerifyAllClean(t)
4487 //-----------------------------------------------------------------------------
4488 // TestREST2eTermNotRespondingToSubReq
4491 // +-------+ +---------+ +---------+
4492 // | xapp | | submgr | | e2term |
4493 // +-------+ +---------+ +---------+
4496 // |---------------->| |
4497 // | RESTSubResp | |
4498 // |<----------------| |
4500 // | |------------->|
4503 // | |------------->|
4506 // | |------------->|
4509 // | |------------->|
4510 // | RESTNotif(Unsuccessful) |
4511 // |<----------------| |
4513 // | RESTSubDelReq | |
4514 // |---------------->| |
4515 // | RESTSubDelResp | |
4516 // |<----------------| |
4519 //-----------------------------------------------------------------------------
4521 func TestREST2eTermNotRespondingToSubReq(t *testing.T) {
4523 // Init counter check
4524 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4525 Counter{cRestSubReqFromXapp, 1},
4526 Counter{cRestSubRespToXapp, 1},
4527 Counter{cSubReqToE2, 1},
4528 Counter{cSubReReqToE2, 1},
4529 Counter{cSubReqTimerExpiry, 2},
4530 Counter{cSubDelReReqToE2, 1},
4531 Counter{cRestSubFailNotifToXapp, 1},
4532 Counter{cSubDelReqToE2, 1},
4533 Counter{cSubDelReqTimerExpiry, 2},
4534 Counter{cRestSubDelReqFromXapp, 1},
4535 Counter{cRestSubDelRespToXapp, 1},
4538 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4539 restSubId := xappConn1.SendRESTSubsReq(t, params)
4540 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
4542 e2termConn1.RecvSubsReq(t)
4543 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
4545 e2termConn1.RecvSubsReq(t)
4546 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
4548 e2termConn1.RecvSubsDelReq(t)
4549 xapp.Logger.Debug("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
4551 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
4552 e2termConn1.RecvSubsDelReq(t)
4553 xapp.Logger.Debug("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
4555 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4557 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4559 waitSubsCleanup(t, e2SubsId, 10)
4560 mainCtrl.VerifyCounterValues(t)
4561 mainCtrl.VerifyAllClean(t)
4564 //-----------------------------------------------------------------------------
4565 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
4568 // +-------+ +---------+ +---------+
4569 // | xapp | | submgr | | e2term |
4570 // +-------+ +---------+ +---------+
4573 // |---------------->| |
4575 // | RESTSubResp | |
4576 // |<----------------| |
4578 // | |------------->|
4582 // | |------------->|
4585 // | |------------->|
4589 // | |------------->|
4593 // | |<-------------|
4596 // |<----------------| |
4598 // | [SUBS DELETE] |
4601 //-----------------------------------------------------------------------------
4602 func TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
4604 // Init counter check
4605 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4606 Counter{cRestSubReqFromXapp, 1},
4607 Counter{cRestSubRespToXapp, 1},
4608 Counter{cSubReqToE2, 1},
4609 Counter{cSubReReqToE2, 1},
4610 Counter{cSubReqTimerExpiry, 2},
4611 Counter{cRestSubFailNotifToXapp, 1},
4612 Counter{cSubDelReqToE2, 1},
4613 Counter{cSubDelReReqToE2, 1},
4614 Counter{cSubDelReqTimerExpiry, 2},
4615 Counter{cRestSubDelReqFromXapp, 1},
4616 Counter{cRestSubDelRespToXapp, 1},
4619 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4620 restSubId := xappConn1.SendRESTSubsReq(t, params)
4621 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
4623 e2termConn1.RecvSubsReq(t)
4624 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
4626 e2termConn1.RecvSubsReq(t)
4627 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
4629 e2termConn1.RecvSubsDelReq(t)
4630 xapp.Logger.Debug("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
4632 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
4633 e2termConn1.RecvSubsDelReq(t)
4634 xapp.Logger.Debug("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
4636 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4638 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4640 waitSubsCleanup(t, e2SubsId, 10)
4641 mainCtrl.VerifyCounterValues(t)
4642 mainCtrl.VerifyAllClean(t)
4645 //-----------------------------------------------------------------------------
4646 // TestRESTSubReqSubFailRespInSubmgr
4649 // +-------+ +---------+ +---------+
4650 // | xapp | | submgr | | e2term |
4651 // +-------+ +---------+ +---------+
4654 // |---------------->| |
4656 // | RESTSubResp | |
4657 // |<----------------| |
4659 // | |------------->|
4662 // | |<-------------|
4666 // |<----------------| |
4668 // | [SUBS DELETE] |
4671 //-----------------------------------------------------------------------------
4673 func TestRESTSubReqSubFailRespInSubmgr(t *testing.T) {
4675 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4676 Counter{cRestSubReqFromXapp, 1},
4677 Counter{cRestSubRespToXapp, 1},
4678 Counter{cSubReqToE2, 1},
4679 Counter{cSubFailFromE2, 1},
4680 Counter{cRestSubFailNotifToXapp, 1},
4681 Counter{cRestSubDelReqFromXapp, 1},
4682 Counter{cRestSubDelRespToXapp, 1},
4685 const subReqCount int = 1
4686 const e2Timeout int64 = 2
4687 const e2RetryCount int64 = 1
4688 const routingNeeded bool = true
4690 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4691 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
4692 restSubId := xappConn1.SendRESTSubsReq(t, params)
4694 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4695 fparams1 := &teststube2ap.E2StubSubsFailParams{}
4696 fparams1.Set(crereq1)
4697 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
4698 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
4700 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4701 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
4703 // REST subscription sill there to be deleted
4704 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4706 // Wait that subs is cleaned
4707 waitSubsCleanup(t, e2SubsId, 10)
4709 mainCtrl.VerifyCounterValues(t)
4710 mainCtrl.VerifyAllClean(t)
4713 //-----------------------------------------------------------------------------
4714 // TestRESTSubReqPartialResp
4717 // +-------+ +---------+ +---------+
4718 // | xapp | | submgr | | e2term |
4719 // +-------+ +---------+ +---------+
4722 // |---------------->| |
4723 // | RESTSubResp | |
4724 // |<----------------| |
4726 // | |------------->|
4727 // | | SubResp | Partially accepted
4728 // | |<-------------|
4731 // |<----------------| |
4733 // | [SUBS DELETE] |
4736 //-----------------------------------------------------------------------------
4738 func TestRESTSubReqPartialResp(t *testing.T) {
4740 // Init counter check
4741 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4742 Counter{cRestSubReqFromXapp, 1},
4743 Counter{cRestSubRespToXapp, 1},
4744 Counter{cSubReqToE2, 1},
4745 Counter{cSubRespFromE2, 1},
4746 Counter{cPartialSubRespFromE2, 1},
4747 Counter{cRestSubNotifToXapp, 1},
4748 Counter{cRestSubDelReqFromXapp, 1},
4749 Counter{cSubDelReqToE2, 1},
4750 Counter{cSubDelRespFromE2, 1},
4751 Counter{cRestSubDelRespToXapp, 1},
4755 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4757 actionId := int64(2)
4758 actionType := "report"
4759 actionDefinition := []int64{5678, 1}
4760 subsequestActionType := "continue"
4761 timeToWait := "w10ms"
4762 params.AppendActionToActionToBeSetupList(actionId, actionType, actionDefinition, subsequestActionType, timeToWait)
4764 restSubId := xappConn1.SendRESTSubsReq(t, params)
4765 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4766 xappConn1.ExpectRESTNotification(t, restSubId)
4768 actionNotAdmittedItem := e2ap.ActionNotAdmittedItem{}
4769 actionNotAdmittedItem.ActionId = 1
4770 actionNotAdmittedItem.Cause.Content = 1
4771 actionNotAdmittedItem.Cause.Value = 8
4772 actionNotAdmittedList := e2ap.ActionNotAdmittedList{}
4773 actionNotAdmittedList.Items = append(actionNotAdmittedList.Items, actionNotAdmittedItem)
4774 e2termConn1.SendPartialSubsResp(t, crereq, cremsg, actionNotAdmittedList)
4775 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4777 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
4780 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
4782 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
4783 //Wait that subs is cleaned
4784 waitSubsCleanup(t, e2SubsId, 10)
4786 mainCtrl.VerifyCounterValues(t)
4787 mainCtrl.VerifyAllClean(t)
4790 //-----------------------------------------------------------------------------
4791 // TestRESTSubDelReqRetryInSubmgr
4794 // +-------+ +---------+ +---------+
4795 // | xapp | | submgr | | e2term |
4796 // +-------+ +---------+ +---------+
4798 // | [SUBS CREATE] |
4801 // | RESTSubDelReq | |
4802 // |---------------->| |
4804 // | RESTSubDelResp | |
4805 // |<----------------| |
4807 // | |------------->|
4810 // | |------------->|
4813 // | |<-------------|
4816 //-----------------------------------------------------------------------------
4817 func TestRESTSubDelReqRetryInSubmgr(t *testing.T) {
4819 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4820 Counter{cRestSubReqFromXapp, 1},
4821 Counter{cRestSubRespToXapp, 1},
4822 Counter{cSubReqToE2, 1},
4823 Counter{cSubRespFromE2, 1},
4824 Counter{cRestSubNotifToXapp, 1},
4825 Counter{cRestSubDelReqFromXapp, 1},
4826 Counter{cSubDelReqToE2, 1},
4827 Counter{cSubDelReqTimerExpiry, 1},
4828 Counter{cSubDelReReqToE2, 1},
4829 Counter{cSubDelRespFromE2, 1},
4830 Counter{cRestSubDelRespToXapp, 1},
4833 var params *teststube2ap.RESTSubsReqParams = nil
4834 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4837 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4839 // E2t: Receive 1st SubsDelReq
4840 e2termConn1.RecvSubsDelReq(t)
4842 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
4843 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4844 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4846 //Wait that subs is cleaned
4847 waitSubsCleanup(t, e2SubsId, 10)
4849 mainCtrl.VerifyCounterValues(t)
4850 mainCtrl.VerifyAllClean(t)
4853 //-----------------------------------------------------------------------------
4854 // TestRESTSubDelReqTwoRetriesNoRespInSubmgr
4857 // +-------+ +---------+ +---------+
4858 // | xapp | | submgr | | e2term |
4859 // +-------+ +---------+ +---------+
4861 // | [SUBS CREATE] |
4864 // | RESTSubDelReq | |
4865 // |---------------->| |
4867 // | RESTSubDelResp | |
4868 // |<----------------| |
4870 // | |------------->|
4873 // | |------------->|
4877 //-----------------------------------------------------------------------------
4879 func TestRESTSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
4881 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4882 Counter{cRestSubReqFromXapp, 1},
4883 Counter{cRestSubRespToXapp, 1},
4884 Counter{cSubReqToE2, 1},
4885 Counter{cSubRespFromE2, 1},
4886 Counter{cRestSubNotifToXapp, 1},
4887 Counter{cRestSubDelReqFromXapp, 1},
4888 Counter{cSubDelReqToE2, 1},
4889 Counter{cSubDelReqTimerExpiry, 1},
4890 Counter{cSubDelReReqToE2, 1},
4891 Counter{cSubDelRespFromE2, 1},
4892 Counter{cRestSubDelRespToXapp, 1},
4896 var params *teststube2ap.RESTSubsReqParams = nil
4897 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4900 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4902 // E2t: Receive 1st SubsDelReq
4903 e2termConn1.RecvSubsDelReq(t)
4905 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
4906 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4907 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4909 //Wait that subs is cleaned
4910 waitSubsCleanup(t, e2SubsId, 10)
4912 mainCtrl.VerifyCounterValues(t)
4913 mainCtrl.VerifyAllClean(t)
4916 //-----------------------------------------------------------------------------
4917 // TestRESTSubDelReqSubDelFailRespInSubmgr
4920 // +-------+ +---------+ +---------+
4921 // | xapp | | submgr | | e2term |
4922 // +-------+ +---------+ +---------+
4924 // | [SUBS CREATE] |
4927 // | RESTSubDelReq | |
4928 // |---------------->| |
4930 // | RESTSubDelResp | |
4931 // |<----------------| |
4933 // | |------------->|
4936 // | |<-------------|
4939 //-----------------------------------------------------------------------------
4941 func TestRESTSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
4943 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4944 Counter{cRestSubReqFromXapp, 1},
4945 Counter{cRestSubRespToXapp, 1},
4946 Counter{cSubReqToE2, 1},
4947 Counter{cSubRespFromE2, 1},
4948 Counter{cRestSubNotifToXapp, 1},
4949 Counter{cRestSubDelReqFromXapp, 1},
4950 Counter{cSubDelReqToE2, 1},
4951 Counter{cSubDelFailFromE2, 1},
4952 Counter{cRestSubDelRespToXapp, 1},
4956 var params *teststube2ap.RESTSubsReqParams = nil
4957 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4960 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4962 // E2t: Send receive SubsDelReq and send SubsDelFail
4963 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4964 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
4966 //Wait that subs is cleaned
4967 waitSubsCleanup(t, e2SubsId, 10)
4969 mainCtrl.VerifyCounterValues(t)
4970 mainCtrl.VerifyAllClean(t)
4973 //-----------------------------------------------------------------------------
4974 // TestRESTSubReqAndSubDelOkSameAction
4977 // +-------+ +-------+ +---------+ +---------+
4978 // | xapp2 | | xapp1 | | submgr | | e2term |
4979 // +-------+ +-------+ +---------+ +---------+
4981 // | | RESTSubReq1 | |
4982 // | |---------------->| |
4984 // | | RESTSubResp1 | |
4985 // | |<----------------| |
4988 // | | |------------->|
4990 // | | |<-------------|
4991 // | | RESTNotif1 | |
4992 // | |<----------------| |
4994 // | RESTSubReq2 | |
4995 // |------------------------------>| |
4997 // | RESTSubResp2 | |
4998 // |<------------------------------| |
5000 // | | RESTNotif2 | |
5001 // |<------------------------------| |
5003 // | | RESTSubDelReq1 | |
5004 // | |---------------->| |
5006 // | | RESTSubDelResp1 | |
5007 // | |<----------------| |
5009 // | RESTSubDelReq2 | |
5010 // |------------------------------>| |
5012 // | RESTSubDelResp2 | |
5013 // |<------------------------------| |
5015 // | | | SubDelReq2 |
5016 // | | |------------->|
5018 // | | | SubDelResp2 |
5019 // | | |<-------------|
5022 //-----------------------------------------------------------------------------
5024 func TestRESTSubReqAndSubDelOkSameAction(t *testing.T) {
5026 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5027 Counter{cRestSubReqFromXapp, 2},
5028 Counter{cRestSubRespToXapp, 2},
5029 Counter{cSubReqToE2, 1},
5030 Counter{cSubRespFromE2, 1},
5031 Counter{cRestSubNotifToXapp, 2},
5032 Counter{cMergedSubscriptions, 1},
5033 Counter{cUnmergedSubscriptions, 1},
5034 Counter{cRestSubDelReqFromXapp, 2},
5035 Counter{cSubDelReqToE2, 1},
5036 Counter{cSubDelRespFromE2, 1},
5037 Counter{cRestSubDelRespToXapp, 2},
5041 var params *teststube2ap.RESTSubsReqParams = nil
5044 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5045 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5048 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5049 params.SetMeid("RAN_NAME_1")
5051 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
5052 xappConn2.ExpectAnyNotification(t)
5053 waiter := rtmgrHttp.AllocNextSleep(10, true)
5054 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5055 waiter.WaitResult(t)
5056 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5057 e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
5058 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId2)
5060 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
5063 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
5066 deleteXapp2Subscription(t, &restSubId2)
5068 //Wait that subs is cleaned
5069 waitSubsCleanup(t, e2SubsId2, 10)
5070 mainCtrl.VerifyCounterValues(t)
5071 mainCtrl.VerifyAllClean(t)
5074 //-----------------------------------------------------------------------------
5075 // TestSubReqAndSubDelOkSameActionParallel
5078 // +-------+ +-------+ +---------+ +---------+
5079 // | xapp2 | | xapp1 | | submgr | | e2term |
5080 // +-------+ +-------+ +---------+ +---------+
5085 // | |------------->| |
5088 // | | |------------->|
5090 // |--------------------------->| |
5092 // | | |<-------------|
5094 // | |<-------------| |
5096 // | | |------------->|
5099 // | | |<-------------|
5101 // |<---------------------------| |
5103 // | | SubDelReq 1 | |
5104 // | |------------->| |
5106 // | | SubDelResp 1 | |
5107 // | |<-------------| |
5109 // | SubDelReq 2 | |
5110 // |--------------------------->| |
5112 // | | | SubDelReq 2 |
5113 // | | |------------->|
5115 // | | | SubDelReq 2 |
5116 // | | |------------->|
5118 // | SubDelResp 2 | |
5119 // |<---------------------------| |
5121 func TestRESTSubReqAndSubDelOkSameActionParallel(t *testing.T) {
5123 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5124 Counter{cRestSubReqFromXapp, 2},
5125 Counter{cRestSubRespToXapp, 2},
5126 Counter{cSubReqToE2, 2},
5127 Counter{cSubRespFromE2, 2},
5128 Counter{cRestSubNotifToXapp, 2},
5129 Counter{cRestSubDelReqFromXapp, 2},
5130 Counter{cSubDelReqToE2, 2},
5131 Counter{cSubDelRespFromE2, 2},
5132 Counter{cRestSubDelRespToXapp, 2},
5135 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5136 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
5137 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
5139 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
5140 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
5142 xappConn1.ExpectRESTNotification(t, restSubId1)
5143 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
5144 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
5146 xappConn2.ExpectRESTNotification(t, restSubId2)
5147 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
5148 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
5149 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5152 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
5153 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
5154 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
5155 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
5158 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
5159 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
5160 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
5162 waitSubsCleanup(t, e2SubsId2, 10)
5163 mainCtrl.VerifyCounterValues(t)
5164 mainCtrl.VerifyAllClean(t)
5167 //-----------------------------------------------------------------------------
5168 // TestRESTSubReqAndSubDelNoAnswerSameActionParallel
5171 // +-------+ +-------+ +---------+ +---------+
5172 // | xapp2 | | xapp1 | | submgr | | e2term |
5173 // +-------+ +-------+ +---------+ +---------+
5177 // | | RESTSubReq1 | |
5178 // | |---------------->| |
5180 // | | RESTSubResp1 | |
5181 // | |<----------------| |
5183 // | | |------------->|
5184 // | RESTSubReq2 | |
5185 // |------------------------------>| |
5187 // | RESTSubResp2 | |
5188 // |<------------------------------| |
5190 // | | |------------->|
5193 // | | | SubDelReq |
5194 // | | |------------->|
5196 // | | | SubDelResp |
5197 // | | |<-------------|
5198 // | | RESTNotif1 | |
5199 // | | unsuccess | |
5200 // | |<----------------| |
5202 // | | unsuccess | |
5203 // |<------------------------------| |
5205 // | | RESTSubDelReq1 | |
5206 // | |---------------->| |
5208 // | | RESTSubDelResp1 | |
5209 // | |<----------------| |
5211 // | RESTSubDelReq2 | |
5212 // |------------------------------>| |
5214 // | RESTSubDelResp2 | |
5215 // |<------------------------------| |
5217 //-----------------------------------------------------------------------------
5219 func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
5221 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5222 Counter{cRestSubReqFromXapp, 2},
5223 Counter{cMergedSubscriptions, 1},
5224 Counter{cRestSubRespToXapp, 2},
5225 Counter{cSubReqToE2, 1},
5226 Counter{cSubReqTimerExpiry, 2},
5227 Counter{cSubReReqToE2, 1},
5228 Counter{cRestSubFailNotifToXapp, 2},
5229 Counter{cUnmergedSubscriptions, 1},
5230 Counter{cRestSubDelReqFromXapp, 2},
5231 Counter{cSubDelReqToE2, 1},
5232 Counter{cSubDelRespFromE2, 1},
5233 Counter{cRestSubDelRespToXapp, 2},
5235 const subReqCount int = 1
5238 params1 := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5239 restSubId1 := xappConn1.SendRESTSubsReq(t, params1)
5240 crereq1, _ := e2termConn1.RecvSubsReq(t)
5243 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
5244 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
5245 params2.SetMeid("RAN_NAME_1")
5246 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
5247 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
5249 //Req1 (retransmitted)
5250 e2termConn1.RecvSubsReq(t)
5252 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
5254 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
5255 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
5257 e2SubsIdA := <-xappConn1.ListedRESTNotifications
5258 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
5259 e2SubsIdB := <-xappConn1.ListedRESTNotifications
5260 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
5263 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
5266 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
5268 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId, e2SubsIdB.E2SubsId}, 10)
5270 //Wait that subs is cleaned
5271 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
5272 mainCtrl.VerifyCounterValues(t)
5273 mainCtrl.VerifyAllClean(t)
5276 //-----------------------------------------------------------------------------
5277 // TestRESTSubReqAndSubDelNokSameActionParallel
5280 // +-------+ +-------+ +---------+ +---------+
5281 // | xapp2 | | xapp1 | | submgr | | e2term |
5282 // +-------+ +-------+ +---------+ +---------+
5286 // | | RESTSubReq1 | |
5287 // | |---------------->| |
5289 // | | RESTSubResp1 | |
5290 // | |<----------------| |
5292 // | | |------------->|
5293 // | RESTSubReq2 | |
5294 // |------------------------------>| |
5296 // | RESTSubDelResp2 | |
5297 // |<------------------------------| |
5299 // | | |<-------------|
5301 // | | RESTNotif1 | |
5302 // | | unsuccess | |
5303 // | |<----------------| |
5305 // | | unsuccess | |
5306 // |<------------------------------| |
5308 // | | RESTSubDelReq1 | | There is no need for xApp to send delete for failed subscriptions but some xApp might do so.
5309 // | |---------------->| |
5311 // | | RESTSubDelResp1 | |
5312 // | |<----------------| |
5314 // | RESTSubDelReq2 | |
5315 // |------------------------------>| |
5317 // | RESTSubDelResp2 | |
5318 // |<------------------------------| |
5320 //-----------------------------------------------------------------------------
5322 func TestRESTSubReqAndSubDelNokSameActionParallel(t *testing.T) {
5324 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5325 Counter{cRestSubReqFromXapp, 2},
5326 Counter{cMergedSubscriptions, 1},
5327 Counter{cRestSubRespToXapp, 2},
5328 Counter{cSubReqToE2, 1},
5329 Counter{cSubFailFromE2, 1},
5330 Counter{cRestSubFailNotifToXapp, 2},
5331 Counter{cUnmergedSubscriptions, 1},
5332 Counter{cRestSubDelReqFromXapp, 2},
5333 Counter{cRestSubDelRespToXapp, 2},
5336 const subReqCount int = 1
5339 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5340 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
5341 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
5344 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
5345 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
5346 params2.SetMeid("RAN_NAME_1")
5347 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
5348 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
5350 // E2t: send SubsFail (first)
5351 fparams1 := &teststube2ap.E2StubSubsFailParams{}
5352 fparams1.Set(crereq1)
5353 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
5355 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
5356 e2SubsIdA := <-xappConn1.ListedRESTNotifications
5357 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
5358 e2SubsIdB := <-xappConn1.ListedRESTNotifications
5359 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
5362 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
5365 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
5367 //Wait that subs is cleaned
5368 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
5369 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
5370 mainCtrl.VerifyCounterValues(t)
5371 mainCtrl.VerifyAllClean(t)
5374 //-----------------------------------------------------------------------------
5375 // TestRESTSubReqPolicyAndSubDelOk
5378 // +-------+ +---------+ +---------+
5379 // | xapp | | submgr | | e2term |
5380 // +-------+ +---------+ +---------+
5383 // |--------------->| |
5384 // | RESTSubResp | |
5385 // |<---------------| |
5388 // | |------------->|
5391 // | |<-------------|
5394 // |<---------------| |
5397 // | RESTSubDelReq | |
5398 // |--------------->| |
5399 // | RESTSubDelResp | |
5400 // |<---------------| |
5403 // | |------------->|
5406 // | |<-------------|
5409 //-----------------------------------------------------------------------------
5411 func TestRESTSubReqPolicyAndSubDelOk(t *testing.T) {
5413 // Init counter check
5414 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5415 Counter{cRestSubReqFromXapp, 1},
5416 Counter{cRestSubRespToXapp, 1},
5417 Counter{cSubReqToE2, 1},
5418 Counter{cSubRespFromE2, 1},
5419 Counter{cRestSubNotifToXapp, 1},
5420 Counter{cRestSubDelReqFromXapp, 1},
5421 Counter{cSubDelReqToE2, 1},
5422 Counter{cSubDelRespFromE2, 1},
5423 Counter{cRestSubDelRespToXapp, 1},
5426 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5427 restSubId := xappConn1.SendRESTSubsReq(t, params)
5428 xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
5430 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
5431 xappConn1.ExpectRESTNotification(t, restSubId)
5432 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
5433 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
5434 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
5436 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5437 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5438 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5440 // Wait that subs is cleaned
5441 waitSubsCleanup(t, e2SubsId, 10)
5442 mainCtrl.VerifyCounterValues(t)
5443 mainCtrl.VerifyAllClean(t)
5446 //-----------------------------------------------------------------------------
5447 // TestRESTSubReqPolicyChangeAndSubDelOk
5450 // +-------+ +---------+ +---------+
5451 // | xapp | | submgr | | e2term |
5452 // +-------+ +---------+ +---------+
5455 // |---------------->| |
5457 // | RESTSubResp | |
5458 // |<----------------| |
5460 // | |------------->|
5463 // | |<-------------|
5466 // |<----------------| |
5469 // |---------------->| |
5471 // | RESTSubResp | |
5472 // |<----------------| |
5474 // | |------------->|
5477 // | |<-------------|
5480 // |<----------------| |
5482 // | RESTSubDelReq | |
5483 // |---------------->| |
5486 // | |------------->|
5489 // | |<-------------|
5491 // | RESTSubDelResp | |
5492 // |<----------------| |
5494 //-----------------------------------------------------------------------------
5496 func TestRESTSubReqPolicyChangeAndSubDelOk(t *testing.T) {
5498 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5499 Counter{cRestSubReqFromXapp, 2},
5500 Counter{cRestSubRespToXapp, 2},
5501 Counter{cSubReqToE2, 2},
5502 Counter{cSubRespFromE2, 2},
5503 Counter{cRestSubNotifToXapp, 2},
5504 Counter{cRestSubDelReqFromXapp, 1},
5505 Counter{cSubDelReqToE2, 1},
5506 Counter{cSubDelRespFromE2, 1},
5507 Counter{cRestSubDelRespToXapp, 1},
5510 const subReqCount int = 1
5511 const e2Timeout int64 = 1
5512 const e2RetryCount int64 = 0
5513 const routingNeeded bool = true
5516 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5517 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5518 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5521 // GetRESTSubsReqPolicyParams sets some counters on tc side.
5523 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5524 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5525 params.SetSubscriptionID(&restSubId)
5526 params.SetTimeToWait("w200ms")
5527 restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
5530 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5532 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5533 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5535 // Wait that subs is cleaned
5536 waitSubsCleanup(t, e2SubsId, 10)
5537 mainCtrl.VerifyCounterValues(t)
5538 mainCtrl.VerifyAllClean(t)
5541 //-----------------------------------------------------------------------------
5542 // TestRESTSubReqPolicyChangeNokAndSubDelOk
5545 // +-------+ +---------+ +---------+
5546 // | xapp | | submgr | | e2term |
5547 // +-------+ +---------+ +---------+
5550 // |---------------->| |
5552 // | RESTSubResp | |
5553 // |<----------------| |
5555 // | |------------->|
5558 // | |<-------------|
5561 // |<----------------| |
5564 // |---------------->| |
5566 // | RESTSubResp | |
5567 // |<----------------| |
5569 // | |------------->|
5572 // | |<-------------|
5575 // |<----------------| |
5577 // | RESTSubDelReq | |
5578 // |---------------->| |
5581 // | |------------->|
5584 // | |<-------------|
5586 // | RESTSubDelResp | |
5587 // |<----------------| |
5589 //-----------------------------------------------------------------------------
5591 func TestRESTSubReqPolicyChangeNokAndSubDelOk(t *testing.T) {
5593 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5594 Counter{cRestSubReqFromXapp, 2},
5595 Counter{cRestSubRespToXapp, 2},
5596 Counter{cSubReqToE2, 2},
5597 Counter{cSubRespFromE2, 1},
5598 Counter{cSubFailFromE2, 1},
5599 Counter{cRestSubNotifToXapp, 1},
5600 Counter{cRestSubFailNotifToXapp, 1},
5601 Counter{cRestSubDelReqFromXapp, 1},
5602 Counter{cSubDelReqToE2, 1},
5603 Counter{cSubDelRespFromE2, 1},
5604 Counter{cRestSubDelRespToXapp, 1},
5607 const subReqCount int = 1
5608 const e2Timeout int64 = 1
5609 const e2RetryCount int64 = 0
5610 const routingNeeded bool = false
5613 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5614 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5615 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5616 fmt.Printf("restSubId: %v", restSubId)
5619 // GetRESTSubsReqPolicyParams sets some counters on tc side.
5620 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5621 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5622 params.SetSubscriptionID(&restSubId)
5623 params.SetTimeToWait("w200ms")
5625 restSubId = xappConn1.SendRESTSubsReq(t, params)
5626 fmt.Printf("restSubId: %v", restSubId)
5628 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5629 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
5631 // Gnb sends RICSubscriptionFailure
5632 fparams := &teststube2ap.E2StubSubsFailParams{}
5634 fparams.SetCauseVal(0, 1, 5) // CauseRIC / function-resource-limit
5635 e2termConn1.SendSubsFail(t, fparams, cremsg)
5637 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5638 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
5641 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5643 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5644 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5646 // Wait that subs is cleaned
5647 waitSubsCleanup(t, e2SubsId, 10)
5648 mainCtrl.VerifyCounterValues(t)
5649 mainCtrl.VerifyAllClean(t)
5652 //-----------------------------------------------------------------------------
5653 // TestRESTSubReqPolicyChangeNOk
5656 // +-------+ +---------+ +---------+
5657 // | xapp | | submgr | | e2term |
5658 // +-------+ +---------+ +---------+
5661 // |---------------->| |
5663 // | RESTSubResp | |
5664 // |<----------------| |
5666 // | |------------->|
5669 // | |<-------------|
5672 // |<----------------| |
5675 // |---------------->| |
5677 // | RESTSubUpdateFail(400 Bad request)
5679 // | RESTSubDelReq | |
5680 // |---------------->| |
5683 // | |------------->|
5686 // | |<-------------|
5688 // | RESTSubDelResp | |
5689 // |<----------------| |
5691 //-----------------------------------------------------------------------------
5693 func TestRESTSubReqPolicyChangeNOk(t *testing.T) {
5695 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5696 Counter{cRestSubReqFromXapp, 2},
5697 Counter{cRestSubRespToXapp, 1},
5698 Counter{cSubReqToE2, 1},
5699 Counter{cSubRespFromE2, 1},
5700 Counter{cRestSubNotifToXapp, 1},
5701 Counter{cRestSubFailToXapp, 1},
5702 Counter{cRestSubDelReqFromXapp, 1},
5703 Counter{cSubDelReqToE2, 1},
5704 Counter{cSubDelRespFromE2, 1},
5705 Counter{cRestSubDelRespToXapp, 1},
5709 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5710 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5713 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5715 restSubIdUpd := strings.ToUpper(restSubId) // This makes RESTSubReq to fail
5716 params.SetSubscriptionID(&restSubIdUpd)
5717 params.SetTimeToWait("w200ms")
5719 restSubId2 := xappConn1.SendRESTSubsReq(t, params)
5720 assert.Equal(t, restSubId2, "")
5723 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5725 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5726 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5728 // Wait that subs is cleaned
5729 waitSubsCleanup(t, e2SubsId, 10)
5730 mainCtrl.VerifyCounterValues(t)
5731 mainCtrl.VerifyAllClean(t)
5734 //-----------------------------------------------------------------------------
5735 // TestRESTSubReqAndSubDelOkTwoE2termParallel
5738 // +-------+ +---------+ +---------+ +---------+
5739 // | xapp | | submgr | | e2term1 | | e2term2 |
5740 // +-------+ +---------+ +---------+ +---------+
5744 // | RESTSubReq1 | | |
5745 // |---------------->| | |
5747 // | RESTSubResp1 | | |
5748 // |<----------------| | |
5750 // | |------------->| |
5752 // | RESTSubReq2 | | |
5753 // |---------------->| | |
5755 // | RESTSubResp2 | | |
5756 // |<----------------| | |
5758 // | |---------------------------->|
5761 // | |<-------------| |
5762 // | RESTNotif1 | | |
5763 // |<----------------| | |
5765 // | |<----------------------------|
5766 // | RESTNotif2 | | |
5767 // |<----------------| | |
5769 // | [SUBS 1 DELETE] | |
5771 // | [SUBS 2 DELETE] | |
5774 //-----------------------------------------------------------------------------
5776 func TestRESTSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
5778 // Init counter check
5779 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5780 Counter{cRestSubReqFromXapp, 2},
5781 Counter{cRestSubRespToXapp, 2},
5782 Counter{cSubReqToE2, 2},
5783 Counter{cSubRespFromE2, 2},
5784 Counter{cRestSubNotifToXapp, 2},
5785 Counter{cRestSubDelReqFromXapp, 2},
5786 Counter{cSubDelReqToE2, 2},
5787 Counter{cSubDelRespFromE2, 2},
5788 Counter{cRestSubDelRespToXapp, 2},
5791 const subReqCount int = 1
5794 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5795 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
5796 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
5799 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5800 params.SetMeid("RAN_NAME_11")
5801 // Here we use xappConn2 to simulate sending second request from same xapp as doing it from xappConn1
5802 // would not work as notification would not be received
5803 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5804 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
5807 xappConn1.ExpectRESTNotification(t, restSubId1)
5808 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
5809 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
5810 xapp.Logger.Debug("TEST: REST notification received e2SubsId1=%v", e2SubsId1)
5813 xappConn2.ExpectRESTNotification(t, restSubId2)
5814 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
5815 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5816 xapp.Logger.Debug("TEST: REST notification received e2SubsId2=%v", e2SubsId2)
5819 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
5820 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
5821 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
5823 // Wait that subs is cleaned
5824 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
5827 xappConn1.SendRESTSubsDelReq(t, &restSubId2)
5828 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
5829 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
5831 // Wait that subs is cleaned
5832 waitSubsCleanup(t, e2SubsId2, 10)
5834 mainCtrl.VerifyCounterValues(t)
5835 mainCtrl.VerifyAllClean(t)
5838 //-----------------------------------------------------------------------------
5839 // TestRESTSubReqInsertAndSubDelOk
5842 // +-------+ +---------+ +---------+
5843 // | xapp | | submgr | | e2term |
5844 // +-------+ +---------+ +---------+
5847 // |---------------->| |
5849 // | RESTSubResp | |
5850 // |<----------------| |
5853 // | |------------->|
5856 // | |<-------------|
5858 // |<----------------| |
5861 // | RESTSubDelReq | |
5862 // |---------------->| |
5865 // | |------------->|
5868 // | |<-------------|
5870 // | RESTSubDelResp| |
5871 // |<----------------| |
5873 //-----------------------------------------------------------------------------
5875 func TestRESTSubReqInsertAndSubDelOk(t *testing.T) {
5877 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5878 Counter{cRestSubReqFromXapp, 1},
5879 Counter{cRestSubRespToXapp, 1},
5880 Counter{cSubReqToE2, 1},
5881 Counter{cSubRespFromE2, 1},
5882 Counter{cRestSubNotifToXapp, 1},
5883 Counter{cRestSubDelReqFromXapp, 1},
5884 Counter{cSubDelReqToE2, 1},
5885 Counter{cSubDelRespFromE2, 1},
5886 Counter{cRestSubDelRespToXapp, 1},
5889 const subReqCount int = 1
5891 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5892 params.SetSubActionTypes("insert")
5895 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5898 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5900 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5901 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5903 // Wait that subs is cleaned
5904 waitSubsCleanup(t, e2SubsId, 10)
5905 mainCtrl.VerifyCounterValues(t)
5906 mainCtrl.VerifyAllClean(t)
5909 //-----------------------------------------------------------------------------
5910 // TestRESTSubReqNokAndSubDelOkWithRestartInMiddle
5913 // +-------+ +---------+ +---------+
5914 // | xapp | | submgr | | e2term |
5915 // +-------+ +---------+ +---------+
5918 // |------------->| |
5920 // | RESTSubResp | |
5921 // |<-------------| |
5923 // | |------------->|
5928 // | Submgr restart |
5932 // | |------------->|
5935 // | |<-------------|
5939 // |<-------------| |
5941 // | RESTSubDelReq| |
5942 // |------------->| |
5944 // |RESTSubDelResp| |
5945 // |<-------------| |
5947 //-----------------------------------------------------------------------------
5949 func TestRESTSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
5951 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5952 Counter{cRestSubReqFromXapp, 1},
5953 Counter{cRestSubRespToXapp, 1},
5954 Counter{cSubReqToE2, 1},
5955 Counter{cSubDelReqFromXapp, 1},
5956 Counter{cSubDelReqToE2, 1},
5957 Counter{cSubDelRespFromE2, 1},
5958 Counter{cRestSubDelReqFromXapp, 1},
5959 Counter{cRestSubDelRespToXapp, 1},
5962 const subReqCount int = 1
5964 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5967 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
5968 restSubId := xappConn1.SendRESTSubsReq(t, params)
5969 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
5971 e2termConn1.RecvSubsReq(t)
5973 mainCtrl.SetResetTestFlag(t, false)
5975 mainCtrl.SimulateRestart(t)
5976 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
5978 // Deleletion of uncompleted subscription
5979 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5980 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5983 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5985 xappConn1.TestMsgChanEmpty(t)
5986 e2termConn1.TestMsgChanEmpty(t)
5987 mainCtrl.wait_registry_empty(t, 10)
5989 mainCtrl.VerifyCounterValues(t)
5990 mainCtrl.VerifyAllClean(t)
5993 //-----------------------------------------------------------------------------
5994 // TestRESTSubReqAndSubDelOkWithRestartInMiddle
5997 // +-------+ +---------+ +---------+
5998 // | xapp | | submgr | | e2term |
5999 // +-------+ +---------+ +---------+
6002 // |---------------->| |
6004 // | RESTSubResp | |
6005 // |<----------------| |
6007 // | |------------->|
6010 // | |<-------------|
6013 // |<----------------| |
6016 // | Submgr restart |
6018 // | RESTSubDelReq | |
6019 // |---------------->| |
6022 // | |------------->|
6025 // | |<-------------|
6027 // | RESTSubDelResp | |
6028 // |<----------------| |
6030 //-----------------------------------------------------------------------------
6032 func TestRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
6034 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6035 Counter{cRestSubReqFromXapp, 1},
6036 Counter{cRestSubRespToXapp, 1},
6037 Counter{cSubReqToE2, 1},
6038 Counter{cSubRespFromE2, 1},
6039 Counter{cRestSubNotifToXapp, 1},
6040 Counter{cRestSubDelReqFromXapp, 1},
6041 Counter{cSubDelReqToE2, 1},
6042 Counter{cSubDelRespFromE2, 1},
6043 Counter{cRestSubDelRespToXapp, 1},
6046 // Create subscription
6047 var params *teststube2ap.RESTSubsReqParams = nil
6048 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6049 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
6051 // Check subscription
6052 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
6054 mainCtrl.SimulateRestart(t)
6055 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
6057 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
6058 // That needs to be completed before successful subscription query is possible
6059 <-time.After(time.Second * 1)
6061 // Check subscription
6062 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
6064 // Delete subscription
6065 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
6067 //Wait that subs is cleaned
6068 waitSubsCleanup(t, e2SubsId, 10)
6070 mainCtrl.VerifyCounterValues(t)
6071 mainCtrl.VerifyAllClean(t)
6074 //-----------------------------------------------------------------------------
6075 // TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle
6078 // +-------+ +-------+ +---------+ +---------+
6079 // | xapp2 | | xapp1 | | submgr | | e2term |
6080 // +-------+ +-------+ +---------+ +---------+
6082 // | | RESTSubReq1 | |
6083 // | |---------------->| |
6085 // | | RESTSubResp1 | |
6086 // | |<----------------| |
6089 // | | |------------->|
6091 // | | |<-------------|
6092 // | | RESTNotif1 | |
6093 // | |<----------------| |
6095 // | RESTSubReq2 | |
6096 // |------------------------------>| |
6098 // | RESTSubResp2 | |
6099 // |<------------------------------| |
6101 // | | RESTNotif2 | |
6102 // |<------------------------------| |
6104 // | | Submgr restart |
6106 // | | RESTSubDelReq1 | |
6107 // | |---------------->| |
6109 // | | RESTSubDelResp1 | |
6110 // | |<----------------| |
6112 // | | Submgr restart |
6114 // | RESTSubDelReq2 | |
6115 // |------------------------------>| |
6117 // | RESTSubDelResp2 | |
6118 // |<------------------------------| |
6120 // | | | SubDelReq2 |
6121 // | | |------------->|
6123 // | | | SubDelResp2 |
6124 // | | |<-------------|
6127 //-----------------------------------------------------------------------------
6128 func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
6130 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6131 Counter{cRestSubReqFromXapp, 2},
6132 Counter{cRestSubRespToXapp, 2},
6133 Counter{cSubReqToE2, 1},
6134 Counter{cSubRespFromE2, 1},
6135 Counter{cRestSubNotifToXapp, 2},
6136 Counter{cMergedSubscriptions, 1},
6137 Counter{cUnmergedSubscriptions, 1},
6138 Counter{cRestSubDelReqFromXapp, 2},
6139 Counter{cSubDelReqToE2, 1},
6140 Counter{cSubDelRespFromE2, 1},
6141 Counter{cRestSubDelRespToXapp, 2},
6144 // Create subscription 1
6145 var params *teststube2ap.RESTSubsReqParams = nil
6146 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
6147 xapp.Logger.Debug("Send REST subscriber request for subscriber 1 : %v", restSubId1)
6149 // Create subscription 2 with same action
6150 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
6151 params.SetMeid("RAN_NAME_1")
6152 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
6153 xappConn2.ExpectAnyNotification(t)
6154 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
6155 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
6156 e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
6157 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId2)
6159 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
6161 mainCtrl.SimulateRestart(t)
6162 xapp.Logger.Debug("mainCtrl.SimulateRestart done 1")
6164 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
6165 // That needs to be completed before successful subscription delete is possible
6166 <-time.After(time.Second * 1)
6168 // Delete subscription 1, and wait until it has removed the first endpoint
6169 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
6170 mainCtrl.WaitRESTSubscriptionDelete(restSubId1)
6171 // Above wait does not work correctly anymore as this delay makes this test case work
6173 mainCtrl.SimulateRestart(t)
6174 xapp.Logger.Debug("mainCtrl.SimulateRestart done 2")
6176 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
6177 // That needs to be completed before successful subscription query is possible
6178 <-time.After(time.Second * 1)
6180 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13660"})
6182 // Delete subscription 2
6183 deleteXapp2Subscription(t, &restSubId2)
6185 //Wait that subs is cleaned
6186 waitSubsCleanup(t, e2SubsId2, 10)
6188 mainCtrl.VerifyCounterValues(t)
6189 mainCtrl.VerifyAllClean(t)
6192 //-----------------------------------------------------------------------------
6193 // TestRESTReportSubReqAndSubDelOk
6196 // +-------+ +---------+ +---------+
6197 // | xapp | | submgr | | e2term |
6198 // +-------+ +---------+ +---------+
6201 // |---------------->| |
6203 // | RESTSubResp | |
6204 // |<----------------| |
6207 // | |------------->|
6210 // | |<-------------|
6212 // |<----------------| |
6213 // | | SubReq | // Only one request sent in the teat case
6214 // | |------------->|
6217 // | |<-------------|
6219 // |<----------------| |
6223 // | RESTSubDelReq | |
6224 // |---------------->| |
6226 // | RESTSubDelResp| |
6227 // |<----------------| |
6229 // | |------------->|
6232 // | |<-------------|
6235 //-----------------------------------------------------------------------------
6237 func TestRESTReportSubReqAndSubDelOk(t *testing.T) {
6238 const subReqCount int = 1
6240 RESTReportSubReqAndSubDelOk(t, subReqCount, testIndex)
6243 func RESTReportSubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
6244 xapp.Logger.Debug("TEST: TestRESTReportSubReqAndSubDelOk with testIndex %v", testIndex)
6246 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6247 Counter{cRestSubReqFromXapp, 1},
6248 Counter{cRestSubRespToXapp, 1},
6249 Counter{cSubReqToE2, uint64(subReqCount)},
6250 Counter{cSubRespFromE2, uint64(subReqCount)},
6251 Counter{cRestSubNotifToXapp, 1},
6252 Counter{cRestSubDelReqFromXapp, 1},
6253 Counter{cRestSubDelRespToXapp, 1},
6254 Counter{cSubDelReqToE2, uint64(subReqCount)},
6255 Counter{cSubDelRespFromE2, uint64(subReqCount)},
6259 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6260 restSubId := xappConn1.SendRESTSubsReq(t, params)
6262 var e2SubsId []uint32
6263 for i := 0; i < subReqCount; i++ {
6264 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6265 xappConn1.ExpectRESTNotification(t, restSubId)
6267 e2termConn1.SendSubsResp(t, crereq, cremsg)
6268 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6269 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6270 e2SubsId = append(e2SubsId, instanceId)
6271 resp, _ := xapp.Subscription.QuerySubscriptions()
6272 assert.Equal(t, resp[i].SubscriptionID, (int64)(instanceId))
6273 assert.Equal(t, resp[i].Meid, "RAN_NAME_1")
6274 assert.Equal(t, resp[i].ClientEndpoint, []string{"localhost:13560"})
6279 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6281 for i := 0; i < subReqCount; i++ {
6282 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6283 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6286 // Wait that subs is cleaned
6287 for i := 0; i < subReqCount; i++ {
6288 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
6291 xappConn1.TestMsgChanEmpty(t)
6292 e2termConn1.TestMsgChanEmpty(t)
6293 mainCtrl.wait_registry_empty(t, 10)
6294 mainCtrl.VerifyAllClean(t)
6295 mainCtrl.VerifyCounterValues(t)
6298 //-----------------------------------------------------------------------------
6299 // TestRESTTwoPolicySubReqAndSubDelOk
6302 // +-------+ +---------+ +---------+
6303 // | xapp | | submgr | | e2term |
6304 // +-------+ +---------+ +---------+
6307 // |---------------->| |
6309 // | RESTSubResp | |
6310 // |<----------------| |
6313 // | |------------->|
6316 // | |<-------------|
6318 // |<----------------| |
6320 // | |------------->|
6323 // | |<-------------|
6325 // |<----------------| |
6327 // | RESTSubDelReq | |
6328 // |---------------->| |
6330 // | RESTSubDelResp| |
6331 // |<----------------| |
6333 // | |------------->|
6336 // | |<-------------|
6339 // | |------------->|
6342 // | |<-------------|
6345 //-----------------------------------------------------------------------------
6347 func TestRESTTwoPolicySubReqAndSubDelOk(t *testing.T) {
6349 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6350 Counter{cRestSubReqFromXapp, 1},
6351 Counter{cRestSubRespToXapp, 1},
6352 Counter{cSubReqToE2, 2},
6353 Counter{cSubRespFromE2, 2},
6354 Counter{cRestSubNotifToXapp, 2},
6355 Counter{cRestSubDelReqFromXapp, 1},
6356 Counter{cSubDelReqToE2, 2},
6357 Counter{cSubDelRespFromE2, 2},
6358 Counter{cRestSubDelRespToXapp, 1},
6361 const subReqCount int = 2
6364 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6365 restSubId := xappConn1.SendRESTSubsReq(t, params)
6366 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
6368 assert.Equal(t, len(e2SubsIds), 2)
6371 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6372 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
6374 xappConn1.TestMsgChanEmpty(t)
6375 e2termConn1.TestMsgChanEmpty(t)
6376 mainCtrl.wait_registry_empty(t, 10)
6378 mainCtrl.VerifyCounterValues(t)
6379 mainCtrl.VerifyAllClean(t)
6382 //-----------------------------------------------------------------------------
6383 // TestRESTPolicySubReqAndSubDelOk19E2Subs
6386 // +-------+ +---------+ +---------+
6387 // | xapp | | submgr | | e2term |
6388 // +-------+ +---------+ +---------+
6391 // |---------------->| |
6393 // | RESTSubResp | |
6394 // |<----------------| |
6397 // | |------------->|
6398 // | | | E2 subscription x 19
6400 // | |<-------------|
6402 // |<----------------| |
6404 // | RESTSubDelReq | |
6405 // |---------------->| |
6407 // | RESTSubDelResp| |
6408 // |<----------------| |
6409 // | | SubDelReq | ------
6410 // | |------------->|
6411 // | | | E2 subscription delete x 19
6413 // | |<-------------|
6417 //-----------------------------------------------------------------------------
6419 func TestRESTPolicySubReqAndSubDelOk19E2Subs(t *testing.T) {
6421 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6422 Counter{cRestSubReqFromXapp, 1},
6423 Counter{cRestSubRespToXapp, 1},
6424 Counter{cSubReqToE2, 19},
6425 Counter{cSubRespFromE2, 19},
6426 Counter{cRestSubNotifToXapp, 19},
6427 Counter{cRestSubDelReqFromXapp, 1},
6428 Counter{cSubDelReqToE2, 19},
6429 Counter{cSubDelRespFromE2, 19},
6430 Counter{cRestSubDelRespToXapp, 1},
6433 const subReqCount int = 19
6435 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6436 restSubId := xappConn1.SendRESTSubsReq(t, params)
6437 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
6439 assert.Equal(t, len(e2SubsIds), 19)
6441 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6442 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
6444 xappConn1.TestMsgChanEmpty(t)
6445 e2termConn1.TestMsgChanEmpty(t)
6446 mainCtrl.wait_registry_empty(t, 10)
6448 mainCtrl.VerifyCounterValues(t)
6449 mainCtrl.VerifyAllClean(t)
6452 //-----------------------------------------------------------------------------
6453 // TestRESTTwoPolicySubReqAndSubDelOk
6456 // +-------+ +---------+ +---------+
6457 // | xapp | | submgr | | e2term |
6458 // +-------+ +---------+ +---------+
6461 // |---------------->| |
6463 // | RESTSubResp | |
6464 // |<----------------| |
6467 // | |------------->|
6470 // | |<-------------|
6472 // |<----------------| |
6474 // | |------------->|
6477 // | |<-------------|
6479 // |<----------------| |
6481 // | RESTSubDelReq | |
6482 // |---------------->| |
6484 // | RESTSubDelResp| |
6485 // |<----------------| |
6487 // | |------------->|
6490 // | |<-------------|
6493 // | |------------->|
6496 // | |<-------------|
6499 //-----------------------------------------------------------------------------
6501 func TestRESTTwoReportSubReqAndSubDelOk(t *testing.T) {
6505 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6506 Counter{cRestSubReqFromXapp, 1},
6507 Counter{cRestSubRespToXapp, 1},
6508 Counter{cSubReqToE2, uint64(subReqCount)},
6509 Counter{cSubRespFromE2, uint64(subReqCount)},
6510 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
6511 Counter{cRestSubDelReqFromXapp, 1},
6512 Counter{cSubDelReqToE2, uint64(subReqCount)},
6513 Counter{cSubDelRespFromE2, uint64(subReqCount)},
6514 Counter{cRestSubDelRespToXapp, 1},
6518 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6519 restSubId := xappConn1.SendRESTSubsReq(t, params)
6520 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
6522 assert.Equal(t, len(e2SubsIds), subReqCount)
6525 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6526 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
6528 xappConn1.TestMsgChanEmpty(t)
6529 e2termConn1.TestMsgChanEmpty(t)
6530 mainCtrl.wait_registry_empty(t, 10)
6532 mainCtrl.VerifyCounterValues(t)
6533 mainCtrl.VerifyAllClean(t)
6536 //-----------------------------------------------------------------------------
6537 // TestRESTTwoReportSubReqAndSubDelOkNoActParams
6540 // +-------+ +---------+ +---------+
6541 // | xapp | | submgr | | e2term |
6542 // +-------+ +---------+ +---------+
6545 // |---------------->| |
6547 // | RESTSubResp | |
6548 // |<----------------| |
6551 // | |------------->|
6554 // | |<-------------|
6556 // |<----------------| |
6558 // | |------------->|
6561 // | |<-------------|
6563 // |<----------------| |
6565 // | RESTSubDelReq | |
6566 // |---------------->| |
6568 // | RESTSubDelResp| |
6569 // |<----------------| |
6571 // | |------------->|
6574 // | |<-------------|
6577 // | |------------->|
6580 // | |<-------------|
6583 //-----------------------------------------------------------------------------
6585 func TestRESTTwoReportSubReqAndSubDelOkNoActParams(t *testing.T) {
6589 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6590 Counter{cRestSubReqFromXapp, 1},
6591 Counter{cRestSubRespToXapp, 1},
6592 Counter{cSubReqToE2, uint64(subReqCount)},
6593 Counter{cSubRespFromE2, uint64(subReqCount)},
6594 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
6595 Counter{cRestSubDelReqFromXapp, 1},
6596 Counter{cSubDelReqToE2, uint64(subReqCount)},
6597 Counter{cSubDelRespFromE2, uint64(subReqCount)},
6598 Counter{cRestSubDelRespToXapp, 1},
6602 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6603 restSubId := xappConn1.SendRESTSubsReq(t, params)
6604 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
6606 assert.Equal(t, len(e2SubsIds), subReqCount)
6609 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6610 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
6612 xappConn1.TestMsgChanEmpty(t)
6613 e2termConn1.TestMsgChanEmpty(t)
6614 mainCtrl.wait_registry_empty(t, 10)
6616 mainCtrl.VerifyCounterValues(t)
6617 mainCtrl.VerifyAllClean(t)
6620 //-----------------------------------------------------------------------------
6621 // TestRESTReportSubReqAndSubDelOk19E2Subs
6624 // +-------+ +---------+ +---------+
6625 // | xapp | | submgr | | e2term |
6626 // +-------+ +---------+ +---------+
6629 // |---------------->| |
6631 // | RESTSubResp | |
6632 // |<----------------| |
6635 // | |------------->|
6636 // | | | E2 subscription x 19
6638 // | |<-------------|
6640 // |<----------------| |
6642 // | RESTSubDelReq | |
6643 // |---------------->| |
6645 // | RESTSubDelResp| |
6646 // |<----------------| |
6647 // | | SubDelReq | ------
6648 // | |------------->|
6649 // | | | E2 subscription delete x 19
6651 // | |<-------------|
6655 //-----------------------------------------------------------------------------
6657 func TestRESTReportSubReqAndSubDelOk19E2Subs(t *testing.T) {
6661 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6662 Counter{cRestSubReqFromXapp, 1},
6663 Counter{cRestSubRespToXapp, 1},
6664 Counter{cSubReqToE2, uint64(subReqCount)},
6665 Counter{cSubRespFromE2, uint64(subReqCount)},
6666 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
6667 Counter{cRestSubDelReqFromXapp, 1},
6668 Counter{cSubDelReqToE2, uint64(subReqCount)},
6669 Counter{cSubDelRespFromE2, uint64(subReqCount)},
6670 Counter{cRestSubDelRespToXapp, 1},
6674 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6675 restSubId := xappConn1.SendRESTSubsReq(t, params)
6676 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
6678 assert.Equal(t, len(e2SubsIds), subReqCount)
6681 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6682 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
6684 xappConn1.TestMsgChanEmpty(t)
6685 e2termConn1.TestMsgChanEmpty(t)
6686 mainCtrl.wait_registry_empty(t, 10)
6688 mainCtrl.VerifyCounterValues(t)
6689 mainCtrl.VerifyAllClean(t)
6692 //-----------------------------------------------------------------------------
6693 // TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen
6696 // +-------+ +-------+ +---------+ +---------+
6697 // | xapp2 | | xapp1 | | submgr | | e2term |
6698 // +-------+ +-------+ +---------+ +---------+
6700 // | | RESTSubReq1 | |
6701 // | |------------->| |
6702 // | | RESTSubResp1 | |
6703 // | |<-------------| |
6706 // | | |------------->|
6708 // | RESTSubReq2 | |
6709 // |------------------------>| |
6710 // | RESTSubResp2 | |
6711 // |<------------------------| |
6714 // | | |------------->|
6717 // | | |<-------------|
6718 // | | RESTNotif1 | |
6719 // | |<-------------| |
6722 // | | |<-------------|
6724 // |<------------------------| |
6726 // | | [SUBS 1 DELETE] |
6728 // | | [SUBS 2 DELETE] |
6731 //-----------------------------------------------------------------------------
6733 func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(t *testing.T) {
6735 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6736 Counter{cRestSubReqFromXapp, 2},
6737 Counter{cRestSubRespToXapp, 2},
6738 Counter{cSubReqToE2, 2},
6739 Counter{cSubRespFromE2, 2},
6740 Counter{cRestSubNotifToXapp, 2},
6741 Counter{cRestSubDelReqFromXapp, 2},
6742 Counter{cSubDelReqToE2, 2},
6743 Counter{cSubDelRespFromE2, 2},
6744 Counter{cRestSubDelRespToXapp, 2},
6748 var params *teststube2ap.RESTSubsReqParams = nil
6751 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
6752 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
6754 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
6757 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
6758 params.SetMeid("RAN_NAME_1")
6759 eventTriggerDefinition := []int64{1234, 1}
6760 params.SetSubEventTriggerDefinition(eventTriggerDefinition)
6762 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
6763 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
6764 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6765 xappConn2.ExpectRESTNotification(t, restSubId2)
6766 e2termConn1.SendSubsResp(t, crereq, cremsg)
6767 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
6769 deleteXapp1Subscription(t, &restSubId1)
6770 deleteXapp2Subscription(t, &restSubId2)
6772 waitSubsCleanup(t, e2SubsId1, 10)
6773 waitSubsCleanup(t, e2SubsId2, 10)
6775 mainCtrl.VerifyCounterValues(t)
6776 mainCtrl.VerifyAllClean(t)
6779 //-----------------------------------------------------------------------------
6780 // TestRESTSubReqReportSameActionDiffActionListLen
6783 // +-------+ +-------+ +---------+ +---------+
6784 // | xapp2 | | xapp1 | | submgr | | e2term |
6785 // +-------+ +-------+ +---------+ +---------+
6787 // | | RESTSubReq1 | |
6788 // | |------------->| |
6789 // | | RESTSubResp1 | |
6790 // | |<-------------| |
6793 // | | |------------->|
6795 // | RESTSubReq2 | |
6796 // |------------------------>| |
6797 // | RESTSubResp2 | |
6798 // |<------------------------| |
6801 // | | |------------->|
6804 // | | |<-------------|
6805 // | | RESTNotif1 | |
6806 // | |<-------------| |
6809 // | | |<-------------|
6811 // |<------------------------| |
6813 // | | [SUBS 1 DELETE] |
6815 // | | [SUBS 2 DELETE] |
6818 //-----------------------------------------------------------------------------
6820 func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) {
6822 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6823 Counter{cRestSubReqFromXapp, 2},
6824 Counter{cRestSubRespToXapp, 2},
6825 Counter{cSubReqToE2, 2},
6826 Counter{cSubRespFromE2, 2},
6827 Counter{cRestSubNotifToXapp, 2},
6828 Counter{cRestSubDelReqFromXapp, 2},
6829 Counter{cSubDelReqToE2, 2},
6830 Counter{cSubDelRespFromE2, 2},
6831 Counter{cRestSubDelRespToXapp, 2},
6835 var params *teststube2ap.RESTSubsReqParams = nil
6838 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
6839 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
6841 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
6844 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
6845 params.SetMeid("RAN_NAME_1")
6847 actionId := int64(1)
6848 actionType := "report"
6849 actionDefinition := []int64{5678, 1}
6850 subsequestActionType := "continue"
6851 timeToWait := "w10ms"
6852 params.AppendActionToActionToBeSetupList(actionId, actionType, actionDefinition, subsequestActionType, timeToWait)
6854 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
6855 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
6856 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6857 xappConn2.ExpectRESTNotification(t, restSubId2)
6858 e2termConn1.SendSubsResp(t, crereq, cremsg)
6859 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
6861 deleteXapp1Subscription(t, &restSubId1)
6862 deleteXapp2Subscription(t, &restSubId2)
6864 waitSubsCleanup(t, e2SubsId1, 10)
6865 waitSubsCleanup(t, e2SubsId2, 10)
6867 mainCtrl.VerifyCounterValues(t)
6868 mainCtrl.VerifyAllClean(t)
6871 //-----------------------------------------------------------------------------
6872 // TestRESTSubReqReportSameActionDiffActionID
6875 // +-------+ +-------+ +---------+ +---------+
6876 // | xapp2 | | xapp1 | | submgr | | e2term |
6877 // +-------+ +-------+ +---------+ +---------+
6879 // | | RESTSubReq1 | |
6880 // | |------------->| |
6881 // | | RESTSubResp1 | |
6882 // | |<-------------| |
6885 // | | |------------->|
6887 // | RESTSubReq2 | |
6888 // |------------------------>| |
6889 // | RESTSubResp2 | |
6890 // |<------------------------| |
6893 // | | |------------->|
6896 // | | |<-------------|
6897 // | | RESTNotif1 | |
6898 // | |<-------------| |
6901 // | | |<-------------|
6903 // |<------------------------| |
6905 // | | [SUBS 1 DELETE] |
6907 // | | [SUBS 2 DELETE] |
6910 //-----------------------------------------------------------------------------
6912 func TestRESTSubReqReportSameActionDiffActionID(t *testing.T) {
6914 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6915 Counter{cRestSubReqFromXapp, 2},
6916 Counter{cRestSubRespToXapp, 2},
6917 Counter{cSubReqToE2, 2},
6918 Counter{cSubRespFromE2, 2},
6919 Counter{cRestSubNotifToXapp, 2},
6920 Counter{cRestSubDelReqFromXapp, 2},
6921 Counter{cSubDelReqToE2, 2},
6922 Counter{cSubDelRespFromE2, 2},
6923 Counter{cRestSubDelRespToXapp, 2},
6927 var params *teststube2ap.RESTSubsReqParams = nil
6930 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
6931 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
6933 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
6936 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
6937 params.SetMeid("RAN_NAME_1")
6938 params.SetSubActionIDs(int64(2))
6940 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
6941 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
6942 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6943 xappConn2.ExpectRESTNotification(t, restSubId2)
6944 e2termConn1.SendSubsResp(t, crereq, cremsg)
6945 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
6947 deleteXapp1Subscription(t, &restSubId1)
6948 deleteXapp2Subscription(t, &restSubId2)
6950 waitSubsCleanup(t, e2SubsId1, 10)
6951 waitSubsCleanup(t, e2SubsId2, 10)
6953 mainCtrl.VerifyCounterValues(t)
6954 mainCtrl.VerifyAllClean(t)
6957 //-----------------------------------------------------------------------------
6958 // TestRESTSubReqDiffActionType
6961 // +-------+ +-------+ +---------+ +---------+
6962 // | xapp2 | | xapp1 | | submgr | | e2term |
6963 // +-------+ +-------+ +---------+ +---------+
6965 // | | RESTSubReq1 | |
6966 // | |------------->| |
6967 // | | RESTSubResp1 | |
6968 // | |<-------------| |
6971 // | | |------------->|
6973 // | RESTSubReq2 | |
6974 // |------------------------>| |
6975 // | RESTSubResp2 | |
6976 // |<------------------------| |
6979 // | | |------------->|
6982 // | | |<-------------|
6983 // | | RESTNotif1 | |
6984 // | |<-------------| |
6987 // | | |<-------------|
6989 // |<------------------------| |
6991 // | | [SUBS 1 DELETE] |
6993 // | | [SUBS 2 DELETE] |
6996 //-----------------------------------------------------------------------------
6998 func TestRESTSubReqDiffActionType(t *testing.T) {
7000 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7001 Counter{cRestSubReqFromXapp, 2},
7002 Counter{cRestSubRespToXapp, 2},
7003 Counter{cSubReqToE2, 2},
7004 Counter{cSubRespFromE2, 2},
7005 Counter{cRestSubNotifToXapp, 2},
7006 Counter{cRestSubDelReqFromXapp, 2},
7007 Counter{cSubDelReqToE2, 2},
7008 Counter{cSubDelRespFromE2, 2},
7009 Counter{cRestSubDelRespToXapp, 2},
7012 const e2Timeout int64 = 2
7013 const e2RetryCount int64 = 2
7014 const routingNeeded bool = true
7017 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
7018 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
7021 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
7022 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
7024 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
7027 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
7028 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
7029 params.SetMeid("RAN_NAME_1")
7031 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
7032 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
7033 crereq, cremsg := e2termConn1.RecvSubsReq(t)
7034 xappConn2.ExpectRESTNotification(t, restSubId2)
7035 e2termConn1.SendSubsResp(t, crereq, cremsg)
7036 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
7038 deleteXapp1Subscription(t, &restSubId1)
7039 deleteXapp2Subscription(t, &restSubId2)
7041 waitSubsCleanup(t, e2SubsId1, 10)
7042 waitSubsCleanup(t, e2SubsId2, 10)
7044 mainCtrl.VerifyCounterValues(t)
7045 mainCtrl.VerifyAllClean(t)
7048 //-----------------------------------------------------------------------------
7049 // TestRESTSubReqPolicyAndSubDelOkSameAction
7052 // +-------+ +-------+ +---------+ +---------+
7053 // | xapp2 | | xapp1 | | submgr | | e2term |
7054 // +-------+ +-------+ +---------+ +---------+
7056 // | | RESTSubReq1 | |
7057 // | |------------->| |
7058 // | | RESTSubResp1 | |
7059 // | |<-------------| |
7062 // | | |------------->|
7064 // | RESTSubReq2 | |
7065 // |------------------------>| |
7066 // | RESTSubResp2 | |
7067 // |<------------------------| |
7070 // | | |------------->|
7073 // | | |<-------------|
7074 // | | RESTNotif1 | |
7075 // | |<-------------| |
7078 // | | |<-------------|
7080 // |<------------------------| |
7082 // | | [SUBS 1 DELETE] |
7084 // | | [SUBS 2 DELETE] |
7087 //-----------------------------------------------------------------------------
7089 func TestRESTSubReqPolicyAndSubDelOkSameAction(t *testing.T) {
7091 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7092 Counter{cRestSubReqFromXapp, 2},
7093 Counter{cRestSubRespToXapp, 2},
7094 Counter{cSubReqToE2, 2},
7095 Counter{cSubRespFromE2, 2},
7096 Counter{cRestSubNotifToXapp, 2},
7097 Counter{cRestSubDelReqFromXapp, 2},
7098 Counter{cSubDelReqToE2, 2},
7099 Counter{cSubDelRespFromE2, 2},
7100 Counter{cRestSubDelRespToXapp, 2},
7103 const e2Timeout int64 = 2
7104 const e2RetryCount int64 = 2
7105 const routingNeeded bool = true
7108 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
7109 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
7112 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
7113 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
7115 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
7118 params = xappConn2.GetRESTSubsReqPolicyParams(subReqCount)
7119 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
7120 params.SetMeid("RAN_NAME_1")
7122 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
7123 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
7124 crereq, cremsg := e2termConn1.RecvSubsReq(t)
7125 xappConn2.ExpectRESTNotification(t, restSubId2)
7126 e2termConn1.SendSubsResp(t, crereq, cremsg)
7127 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
7129 deleteXapp1Subscription(t, &restSubId1)
7130 deleteXapp2Subscription(t, &restSubId2)
7132 waitSubsCleanup(t, e2SubsId1, 10)
7133 waitSubsCleanup(t, e2SubsId2, 10)
7135 mainCtrl.VerifyCounterValues(t)
7136 mainCtrl.VerifyAllClean(t)
7139 //-----------------------------------------------------------------------------
7140 // TestRESTSubReqReportSameActionDiffActionDefinitionLen
7143 // +-------+ +-------+ +---------+ +---------+
7144 // | xapp2 | | xapp1 | | submgr | | e2term |
7145 // +-------+ +-------+ +---------+ +---------+
7147 // | | RESTSubReq1 | |
7148 // | |------------->| |
7149 // | | RESTSubResp1 | |
7150 // | |<-------------| |
7153 // | | |------------->|
7155 // | RESTSubReq2 | |
7156 // |------------------------>| |
7157 // | RESTSubResp2 | |
7158 // |<------------------------| |
7161 // | | |------------->|
7164 // | | |<-------------|
7165 // | | RESTNotif1 | |
7166 // | |<-------------| |
7169 // | | |<-------------|
7171 // |<------------------------| |
7173 // | | [SUBS 1 DELETE] |
7175 // | | [SUBS 2 DELETE] |
7178 //-----------------------------------------------------------------------------
7180 func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) {
7182 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7183 Counter{cRestSubReqFromXapp, 2},
7184 Counter{cRestSubRespToXapp, 2},
7185 Counter{cSubReqToE2, 2},
7186 Counter{cSubRespFromE2, 2},
7187 Counter{cRestSubNotifToXapp, 2},
7188 Counter{cRestSubDelReqFromXapp, 2},
7189 Counter{cSubDelReqToE2, 2},
7190 Counter{cSubDelRespFromE2, 2},
7191 Counter{cRestSubDelRespToXapp, 2},
7195 var params *teststube2ap.RESTSubsReqParams = nil
7198 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
7199 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
7201 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
7204 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
7205 params.SetMeid("RAN_NAME_1")
7206 actionDefinition := []int64{5678, 1}
7207 params.SetSubActionDefinition(actionDefinition)
7209 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
7210 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
7211 crereq, cremsg := e2termConn1.RecvSubsReq(t)
7212 xappConn2.ExpectRESTNotification(t, restSubId2)
7213 e2termConn1.SendSubsResp(t, crereq, cremsg)
7214 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
7216 deleteXapp1Subscription(t, &restSubId1)
7217 deleteXapp2Subscription(t, &restSubId2)
7219 waitSubsCleanup(t, e2SubsId1, 10)
7220 waitSubsCleanup(t, e2SubsId2, 10)
7222 mainCtrl.VerifyCounterValues(t)
7223 mainCtrl.VerifyAllClean(t)
7226 //-----------------------------------------------------------------------------
7227 // TestRESTSubReqReportSameActionDiffActionDefinitionContents
7230 // +-------+ +-------+ +---------+ +---------+
7231 // | xapp2 | | xapp1 | | submgr | | e2term |
7232 // +-------+ +-------+ +---------+ +---------+
7234 // | | RESTSubReq1 | |
7235 // | |------------->| |
7236 // | | RESTSubResp1 | |
7237 // | |<-------------| |
7240 // | | |------------->|
7242 // | RESTSubReq2 | |
7243 // |------------------------>| |
7244 // | RESTSubResp2 | |
7245 // |<------------------------| |
7248 // | | |------------->|
7251 // | | |<-------------|
7252 // | | RESTNotif1 | |
7253 // | |<-------------| |
7256 // | | |<-------------|
7258 // |<------------------------| |
7260 // | | [SUBS 1 DELETE] |
7262 // | | [SUBS 2 DELETE] |
7265 //-----------------------------------------------------------------------------
7267 func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) {
7269 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7270 Counter{cRestSubReqFromXapp, 2},
7271 Counter{cRestSubRespToXapp, 2},
7272 Counter{cSubReqToE2, 2},
7273 Counter{cSubRespFromE2, 2},
7274 Counter{cRestSubNotifToXapp, 2},
7275 Counter{cRestSubDelReqFromXapp, 2},
7276 Counter{cSubDelReqToE2, 2},
7277 Counter{cSubDelRespFromE2, 2},
7278 Counter{cRestSubDelRespToXapp, 2},
7282 var params *teststube2ap.RESTSubsReqParams = nil
7285 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
7286 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
7288 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
7291 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
7292 params.SetMeid("RAN_NAME_1")
7293 actionDefinition := []int64{56782}
7294 params.SetSubActionDefinition(actionDefinition)
7296 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
7297 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
7298 crereq, cremsg := e2termConn1.RecvSubsReq(t)
7299 xappConn2.ExpectRESTNotification(t, restSubId2)
7300 e2termConn1.SendSubsResp(t, crereq, cremsg)
7301 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
7303 deleteXapp1Subscription(t, &restSubId1)
7304 deleteXapp2Subscription(t, &restSubId2)
7306 waitSubsCleanup(t, e2SubsId1, 10)
7307 waitSubsCleanup(t, e2SubsId2, 10)
7309 mainCtrl.VerifyCounterValues(t)
7310 mainCtrl.VerifyAllClean(t)
7313 //-----------------------------------------------------------------------------
7314 // TestRESTSubReqReportSameActionDiffSubsAction
7317 // +-------+ +-------+ +---------+ +---------+
7318 // | xapp2 | | xapp1 | | submgr | | e2term |
7319 // +-------+ +-------+ +---------+ +---------+
7321 // | | RESTSubReq1 | |
7322 // | |------------->| |
7323 // | | RESTSubResp1 | |
7324 // | |<-------------| |
7327 // | | |------------->|
7329 // | RESTSubReq2 | |
7330 // |------------------------>| |
7331 // | RESTSubResp2 | |
7332 // |<------------------------| |
7335 // | | |------------->|
7338 // | | |<-------------|
7339 // | | RESTNotif1 | |
7340 // | |<-------------| |
7343 // | | |<-------------|
7345 // |<------------------------| |
7347 // | | [SUBS 1 DELETE] |
7349 // | | [SUBS 2 DELETE] |
7352 //-----------------------------------------------------------------------------
7354 func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) {
7356 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7357 Counter{cRestSubReqFromXapp, 2},
7358 Counter{cRestSubRespToXapp, 2},
7359 Counter{cSubReqToE2, 2},
7360 Counter{cSubRespFromE2, 2},
7361 Counter{cRestSubNotifToXapp, 2},
7362 Counter{cRestSubDelReqFromXapp, 2},
7363 Counter{cSubDelReqToE2, 2},
7364 Counter{cSubDelRespFromE2, 2},
7365 Counter{cRestSubDelRespToXapp, 2},
7369 var params *teststube2ap.RESTSubsReqParams = nil
7372 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
7373 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
7375 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
7378 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
7379 params.SetMeid("RAN_NAME_1")
7380 params.SetTimeToWait("w200ms")
7381 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
7382 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
7383 crereq, cremsg := e2termConn1.RecvSubsReq(t)
7384 xappConn2.ExpectRESTNotification(t, restSubId2)
7385 e2termConn1.SendSubsResp(t, crereq, cremsg)
7386 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
7388 deleteXapp1Subscription(t, &restSubId1)
7389 deleteXapp2Subscription(t, &restSubId2)
7391 waitSubsCleanup(t, e2SubsId1, 10)
7392 waitSubsCleanup(t, e2SubsId2, 10)
7394 mainCtrl.VerifyCounterValues(t)
7395 mainCtrl.VerifyAllClean(t)
7398 //-----------------------------------------------------------------------------
7399 // TestRESTUnpackSubscriptionResponseDecodeFail
7402 // +-------+ +---------+ +---------+
7403 // | xapp | | submgr | | e2term |
7404 // +-------+ +---------+ +---------+
7407 // |---------------->| |
7409 // | RESTSubResp | |
7410 // |<----------------| |
7413 // | |------------->|
7415 // | | SubResp | ASN.1 decode fails
7416 // | |<-------------| Decode failed. More data needed. This will result timer expiry and resending
7419 // | |------------->|
7421 // | | SubFail | Duplicated action
7422 // | |<-------------|
7423 // | RESTNotif (fail)| |
7424 // |<----------------| |
7426 // | [SUBS DELETE] |
7429 //-----------------------------------------------------------------------------
7431 func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) {
7433 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7434 Counter{cRestSubReqFromXapp, 1},
7435 Counter{cRestSubRespToXapp, 1},
7436 Counter{cSubReqToE2, 1},
7437 Counter{cSubReqTimerExpiry, 1},
7438 Counter{cSubReReqToE2, 1},
7439 Counter{cSubRespFromE2, 1},
7440 Counter{cSubFailFromE2, 1},
7441 Counter{cRestSubFailNotifToXapp, 1},
7442 Counter{cRestSubDelReqFromXapp, 1},
7443 Counter{cRestSubDelRespToXapp, 1},
7446 const subReqCount int = 1
7449 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
7450 restSubId := xappConn1.SendRESTSubsReq(t, params)
7452 crereq, cremsg := e2termConn1.RecvSubsReq(t)
7453 // Decode of this response fails which will result resending original request
7454 e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_RESP)
7456 _, cremsg = e2termConn1.RecvSubsReq(t)
7458 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
7460 // Subscription already created in E2 Node.
7461 fparams := &teststube2ap.E2StubSubsFailParams{}
7463 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
7464 e2termConn1.SendSubsFail(t, fparams, cremsg)
7466 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
7467 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
7469 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7471 // Wait that subs is cleaned
7472 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
7474 xappConn1.TestMsgChanEmpty(t)
7475 e2termConn1.TestMsgChanEmpty(t)
7476 mainCtrl.wait_registry_empty(t, 10)
7477 mainCtrl.VerifyAllClean(t)
7478 mainCtrl.VerifyCounterValues(t)
7481 //-----------------------------------------------------------------------------
7482 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
7485 // +-------+ +---------+ +---------+
7486 // | xapp | | submgr | | e2term |
7487 // +-------+ +---------+ +---------+
7490 // |---------------->| |
7492 // | RESTSubResp | |
7493 // |<----------------| |
7496 // | |------------->|
7498 // | | SubResp | Unknown instanceId
7499 // | |<-------------| No valid subscription found with subIds [0]
7502 // | |------------->|
7504 // | | SubFail | Duplicated action
7505 // | |<-------------| No valid subscription found with subIds [0]
7506 // | RESTNotif (fail)| |
7507 // |<----------------| |
7509 // | |------------->|
7512 // | |<-------------|
7514 // | [SUBS DELETE] |
7517 //-----------------------------------------------------------------------------
7519 func TestRESTUnpackSubscriptionResponseUnknownInstanceId(t *testing.T) {
7521 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7522 Counter{cRestSubReqFromXapp, 1},
7523 Counter{cRestSubRespToXapp, 1},
7524 Counter{cSubReqToE2, 1},
7525 Counter{cSubReqTimerExpiry, 2},
7526 Counter{cSubReReqToE2, 1},
7527 Counter{cSubRespFromE2, 1},
7528 Counter{cSubFailFromE2, 1},
7529 Counter{cRestSubFailNotifToXapp, 1},
7530 Counter{cRestSubDelReqFromXapp, 1},
7531 Counter{cRestSubDelRespToXapp, 1},
7532 Counter{cSubDelReqToE2, 1},
7533 Counter{cSubDelRespFromE2, 1},
7536 const subReqCount int = 1
7539 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
7540 restSubId := xappConn1.SendRESTSubsReq(t, params)
7542 crereq, cremsg := e2termConn1.RecvSubsReq(t)
7544 // Unknown instanceId 0 in this response which will result resending original request
7545 orgInstanceId := crereq.RequestId.InstanceId
7546 crereq.RequestId.InstanceId = 0
7547 e2termConn1.SendSubsResp(t, crereq, cremsg)
7549 _, cremsg = e2termConn1.RecvSubsReq(t)
7551 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
7553 // Subscription already created in E2 Node. E2 Node responds with failure but there is also same unknown instanceId 0
7554 fparams := &teststube2ap.E2StubSubsFailParams{}
7556 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
7557 e2termConn1.SendSubsFail(t, fparams, cremsg)
7559 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7560 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7562 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
7563 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
7565 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7567 // Wait that subs is cleaned
7568 mainCtrl.wait_subs_clean(t, orgInstanceId, 10)
7570 xappConn1.TestMsgChanEmpty(t)
7571 e2termConn1.TestMsgChanEmpty(t)
7572 mainCtrl.wait_registry_empty(t, 10)
7573 mainCtrl.VerifyAllClean(t)
7574 mainCtrl.VerifyCounterValues(t)
7577 //-----------------------------------------------------------------------------
7578 // TestRESTUnpackSubscriptionResponseNoTransaction
7581 // +-------+ +---------+ +---------+
7582 // | xapp | | submgr | | e2term |
7583 // +-------+ +---------+ +---------+
7586 // |---------------->| |
7588 // | RESTSubResp | |
7589 // |<----------------| |
7592 // | |------------->|
7594 // | | SubResp | No transaction for the response
7595 // | |<-------------| Ongoing transaction not found. This will result timer expiry and resending
7598 // | |------------->|
7600 // | | SubFail | Duplicated action
7601 // | |<-------------|Ongoing transaction not found. This will result timer expiry and sending delete
7602 // | RESTNotif (fail)| |
7603 // |<----------------| |
7605 // | |------------->|
7608 // | |<-------------| Ongoing transaction not found. This will result timer expiry and resending
7611 // | |------------->|
7614 // | |<-------------| Ongoing transaction not found.
7616 // | [SUBS DELETE] |
7619 //-----------------------------------------------------------------------------
7621 func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) {
7623 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7624 Counter{cRestSubReqFromXapp, 1},
7625 Counter{cRestSubRespToXapp, 1},
7626 Counter{cSubReqToE2, 1},
7627 Counter{cSubReqTimerExpiry, 2},
7628 Counter{cSubReReqToE2, 1},
7629 Counter{cSubRespFromE2, 1},
7630 Counter{cSubFailFromE2, 1},
7631 Counter{cRestSubFailNotifToXapp, 1},
7632 Counter{cRestSubDelReqFromXapp, 1},
7633 Counter{cRestSubDelRespToXapp, 1},
7634 Counter{cSubDelReqToE2, 1},
7635 Counter{cSubDelReqTimerExpiry, 2},
7636 Counter{cSubDelReReqToE2, 1},
7637 Counter{cSubDelRespFromE2, 2},
7640 const subReqCount int = 1
7643 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
7644 restSubId := xappConn1.SendRESTSubsReq(t, params)
7646 crereq, cremsg := e2termConn1.RecvSubsReq(t)
7648 mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
7649 // No transaction exist for this response which will result resending original request
7650 e2termConn1.SendSubsResp(t, crereq, cremsg)
7652 _, cremsg = e2termConn1.RecvSubsReq(t)
7654 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
7656 // Subscription already created in E2 Node.
7657 fparams := &teststube2ap.E2StubSubsFailParams{}
7659 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
7660 e2termConn1.SendSubsFail(t, fparams, cremsg)
7662 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7663 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7665 // Resending happens because there no transaction
7666 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
7667 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7669 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
7670 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
7672 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7674 // Wait that subs is cleaned
7675 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
7677 xappConn1.TestMsgChanEmpty(t)
7678 e2termConn1.TestMsgChanEmpty(t)
7679 mainCtrl.wait_registry_empty(t, 10)
7680 mainCtrl.VerifyAllClean(t)
7681 mainCtrl.VerifyCounterValues(t)
7684 //-----------------------------------------------------------------------------
7685 // TestRESTUnpackSubscriptionFailureDecodeFail
7688 // +-------+ +---------+ +---------+
7689 // | xapp | | submgr | | e2term |
7690 // +-------+ +---------+ +---------+
7693 // |---------------->| |
7695 // | RESTSubResp | |
7696 // |<----------------| |
7699 // | |------------->|
7701 // | | SubFail | ASN.1 decode fails
7702 // | |<-------------| Decode failed. More data needed. This will result timer expiry and resending
7705 // | |------------->|
7707 // | | SubFail | Duplicated action
7708 // | |<-------------|
7709 // | RESTNotif (fail)| |
7710 // |<----------------| |
7712 // | [SUBS DELETE] |
7715 //-----------------------------------------------------------------------------
7717 func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) {
7719 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7720 Counter{cRestSubReqFromXapp, 1},
7721 Counter{cRestSubRespToXapp, 1},
7722 Counter{cSubReqToE2, 1},
7723 Counter{cSubReqTimerExpiry, 1},
7724 Counter{cSubReReqToE2, 1},
7725 Counter{cSubFailFromE2, 2},
7726 Counter{cRestSubFailNotifToXapp, 1},
7727 Counter{cRestSubDelReqFromXapp, 1},
7728 Counter{cRestSubDelRespToXapp, 1},
7731 const subReqCount int = 1
7734 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
7735 restSubId := xappConn1.SendRESTSubsReq(t, params)
7737 crereq, cremsg := e2termConn1.RecvSubsReq(t)
7739 // Decode of this response fails which will result resending original request
7740 e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_FAILURE)
7742 _, cremsg = e2termConn1.RecvSubsReq(t)
7744 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
7746 // Subscription already created in E2 Node.
7747 fparams := &teststube2ap.E2StubSubsFailParams{}
7749 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
7750 e2termConn1.SendSubsFail(t, fparams, cremsg)
7752 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
7753 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
7755 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7757 // Wait that subs is cleaned
7758 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
7760 xappConn1.TestMsgChanEmpty(t)
7761 e2termConn1.TestMsgChanEmpty(t)
7762 mainCtrl.wait_registry_empty(t, 10)
7763 mainCtrl.VerifyAllClean(t)
7764 mainCtrl.VerifyCounterValues(t)
7767 //-----------------------------------------------------------------------------
7768 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
7771 // +-------+ +---------+ +---------+
7772 // | xapp | | submgr | | e2term |
7773 // +-------+ +---------+ +---------+
7776 // |---------------->| |
7778 // | RESTSubResp | |
7779 // |<----------------| |
7782 // | |------------->|
7784 // | | SubFail | Unknown instanceId
7785 // | |<-------------| No valid subscription found with subIds [0]. This will result timer expiry and resending
7788 // | |------------->|
7790 // | | SubFail | Duplicated action
7791 // | |<-------------|No valid subscription found with subIds [0]. This will result timer expiry and sending delete
7792 // | RESTNotif (fail)| |
7793 // |<----------------| |
7795 // | |------------->|
7798 // | |<-------------|
7800 // | [SUBS DELETE] |
7803 //-----------------------------------------------------------------------------
7804 func TestRESTUnpackSubscriptionFailureUnknownInstanceId(t *testing.T) {
7806 const subReqCount int = 1
7808 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7809 Counter{cRestSubReqFromXapp, 1},
7810 Counter{cRestSubRespToXapp, 1},
7811 Counter{cSubReqToE2, 1},
7812 Counter{cSubReqTimerExpiry, 2},
7813 Counter{cSubReReqToE2, 1},
7814 Counter{cSubFailFromE2, 2},
7815 Counter{cRestSubFailNotifToXapp, 1},
7816 Counter{cRestSubDelReqFromXapp, 1},
7817 Counter{cRestSubDelRespToXapp, 1},
7818 Counter{cSubDelReqToE2, 1},
7819 Counter{cSubDelRespFromE2, 1},
7823 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
7824 restSubId := xappConn1.SendRESTSubsReq(t, params)
7826 crereq, cremsg := e2termConn1.RecvSubsReq(t)
7828 // Unknown instanceId 0 in this response which will result resending original request
7829 fparams := &teststube2ap.E2StubSubsFailParams{}
7831 fparams.Fail.RequestId.InstanceId = 0
7832 e2termConn1.SendSubsFail(t, fparams, cremsg)
7834 _, cremsg = e2termConn1.RecvSubsReq(t)
7836 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
7838 // Subscription already created in E2 Node. E2 Node responds with failure but there is also same unknown instanceId 0
7839 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
7840 e2termConn1.SendSubsFail(t, fparams, cremsg)
7842 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7843 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7845 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
7846 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
7848 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7850 // Wait that subs is cleaned
7851 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
7853 xappConn1.TestMsgChanEmpty(t)
7854 e2termConn1.TestMsgChanEmpty(t)
7855 mainCtrl.wait_registry_empty(t, 10)
7856 mainCtrl.VerifyAllClean(t)
7857 mainCtrl.VerifyCounterValues(t)
7860 //-----------------------------------------------------------------------------
7861 // TestRESTUnpackSubscriptionFailureNoTransaction
7864 // +-------+ +---------+ +---------+
7865 // | xapp | | submgr | | e2term |
7866 // +-------+ +---------+ +---------+
7869 // |---------------->| |
7871 // | RESTSubResp | |
7872 // |<----------------| |
7875 // | |------------->|
7877 // | | SubFail | No transaction for the response
7878 // | |<-------------| Ongoing transaction not found. This will result timer expiry and resending
7881 // | |------------->|
7883 // | | SubFail | Duplicated action
7884 // | |<-------------| Ongoing transaction not found. This will result timer expiry and sending delete
7885 // | RESTNotif (fail)| |
7886 // |<----------------| |
7888 // | |------------->|
7891 // | |<-------------| Ongoing transaction not found. This will result timer expiry and resending
7894 // | |------------->|
7897 // | |<-------------| Ongoing transaction not found.
7899 // | [SUBS DELETE] |
7902 //-----------------------------------------------------------------------------
7904 func TestRESTUnpackSubscriptionFailureNoTransaction(t *testing.T) {
7906 const subReqCount int = 1
7908 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7909 Counter{cRestSubReqFromXapp, 1},
7910 Counter{cRestSubRespToXapp, 1},
7911 Counter{cSubReqToE2, 1},
7912 Counter{cSubReqTimerExpiry, 2},
7913 Counter{cSubReReqToE2, 1},
7914 Counter{cSubFailFromE2, 2},
7915 Counter{cRestSubFailNotifToXapp, 1},
7916 Counter{cRestSubDelReqFromXapp, 1},
7917 Counter{cRestSubDelRespToXapp, 1},
7918 Counter{cSubDelReqToE2, 1},
7919 Counter{cSubDelReqTimerExpiry, 2},
7920 Counter{cSubDelReReqToE2, 1},
7921 Counter{cSubDelRespFromE2, 2},
7925 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
7926 restSubId := xappConn1.SendRESTSubsReq(t, params)
7928 crereq, cremsg := e2termConn1.RecvSubsReq(t)
7930 mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
7932 // No transaction exist for this response which will result resending original request
7933 fparams := &teststube2ap.E2StubSubsFailParams{}
7935 e2termConn1.SendSubsFail(t, fparams, cremsg)
7937 _, cremsg = e2termConn1.RecvSubsReq(t)
7939 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
7941 // Subscription already created in E2 Node.
7942 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
7943 e2termConn1.SendSubsFail(t, fparams, cremsg)
7945 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7946 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7948 // Resending happens because there no transaction
7949 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
7950 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7952 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
7953 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
7955 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7957 // Wait that subs is cleaned
7958 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
7960 xappConn1.TestMsgChanEmpty(t)
7961 e2termConn1.TestMsgChanEmpty(t)
7962 mainCtrl.wait_registry_empty(t, 10)
7963 mainCtrl.VerifyAllClean(t)
7964 mainCtrl.VerifyCounterValues(t)
7967 //-----------------------------------------------------------------------------
7968 // TestRESTUnpackSubscriptionDeleteResponseDecodeFail
7971 // +-------+ +---------+ +---------+
7972 // | xapp | | submgr | | e2term |
7973 // +-------+ +---------+ +---------+
7975 // | [SUBS CREATE] |
7978 // | RESTSubDelReq | |
7979 // |---------------->| |
7981 // | RESTSubDelResp | |
7982 // |<----------------| |
7985 // | |------------->|
7987 // | | SubDelResp | ASN.1 decode fails.
7988 // | |<-------------| Decode failed. More data needed. This will result timer expiry and resending
7991 // | |------------->|
7993 // | | SubDelFail | Subscription does exist any more in E2 node
7994 // | |<-------------|
7996 // | [SUBS DELETE] |
7999 //-----------------------------------------------------------------------------
8001 func TestRESTUnpackSubscriptionDeleteResponseDecodeFail(t *testing.T) {
8003 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
8004 Counter{cRestSubReqFromXapp, 1},
8005 Counter{cRestSubRespToXapp, 1},
8006 Counter{cSubReqToE2, 1},
8007 Counter{cSubRespFromE2, 1},
8008 Counter{cRestSubNotifToXapp, 1},
8009 Counter{cRestSubDelReqFromXapp, 1},
8010 Counter{cRestSubDelRespToXapp, 1},
8011 Counter{cSubDelReqToE2, 1},
8012 Counter{cSubDelReqTimerExpiry, 1},
8013 Counter{cSubDelReReqToE2, 1},
8014 Counter{cSubDelFailFromE2, 1},
8015 Counter{cSubDelRespFromE2, 1},
8019 var params *teststube2ap.RESTSubsReqParams = nil
8020 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
8023 xappConn1.SendRESTSubsDelReq(t, &restSubId)
8025 // E2t: Receive 1st SubsDelReq
8026 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
8028 // Decode of this response fails which will result resending original request
8029 e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_RESP)
8031 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
8032 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
8034 // Subscription does not exist in in E2 Node.
8035 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
8037 // Wait that subs is cleaned
8038 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
8040 xappConn1.TestMsgChanEmpty(t)
8041 e2termConn1.TestMsgChanEmpty(t)
8042 mainCtrl.wait_registry_empty(t, 10)
8043 mainCtrl.VerifyAllClean(t)
8044 mainCtrl.VerifyCounterValues(t)
8047 //-----------------------------------------------------------------------------
8048 // TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId
8051 // +-------+ +---------+ +---------+
8052 // | xapp | | submgr | | e2term |
8053 // +-------+ +---------+ +---------+
8055 // | [SUBS CREATE] |
8058 // | RESTSubDelReq | |
8059 // |---------------->| |
8061 // | RESTSubDelResp | |
8062 // |<----------------| |
8065 // | |------------->|
8067 // | | SubDelResp | Unknown instanceId
8068 // | |<-------------| No valid subscription found with subIds [0]. This will result timer expiry and resending
8071 // | |------------->|
8073 // | | SubDelFail | Subscription does exist any more in E2 node
8074 // | |<-------------|
8076 // | [SUBS DELETE] |
8078 //-----------------------------------------------------------------------------
8080 func TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId(t *testing.T) {
8082 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
8083 Counter{cRestSubReqFromXapp, 1},
8084 Counter{cRestSubRespToXapp, 1},
8085 Counter{cSubReqToE2, 1},
8086 Counter{cSubRespFromE2, 1},
8087 Counter{cRestSubNotifToXapp, 1},
8088 Counter{cRestSubDelReqFromXapp, 1},
8089 Counter{cRestSubDelRespToXapp, 1},
8090 Counter{cSubDelReqToE2, 1},
8091 Counter{cSubDelReqTimerExpiry, 1},
8092 Counter{cSubDelReReqToE2, 1},
8093 Counter{cSubDelRespFromE2, 1},
8094 Counter{cSubDelFailFromE2, 1},
8098 var params *teststube2ap.RESTSubsReqParams = nil
8099 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
8102 xappConn1.SendRESTSubsDelReq(t, &restSubId)
8104 // E2t: Receive 1st SubsDelReq
8105 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
8107 // Unknown instanceId in this response which will result resending original request
8108 delreq.RequestId.InstanceId = 0
8109 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
8111 // E2t: Receive 2nd SubsDelReq
8112 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
8114 // Subscription does not exist in in E2 Node.
8115 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
8117 // Wait that subs is cleaned
8118 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
8120 xappConn1.TestMsgChanEmpty(t)
8121 e2termConn1.TestMsgChanEmpty(t)
8122 mainCtrl.wait_registry_empty(t, 10)
8123 mainCtrl.VerifyAllClean(t)
8124 mainCtrl.VerifyCounterValues(t)
8127 //-----------------------------------------------------------------------------
8128 // TestRESTUnpackSubscriptionDeleteResponseNoTransaction
8131 // +-------+ +---------+ +---------+
8132 // | xapp | | submgr | | e2term |
8133 // +-------+ +---------+ +---------+
8135 // | [SUBS CREATE] |
8138 // | RESTSubDelReq | |
8139 // |---------------->| |
8141 // | RESTSubDelResp | |
8142 // |<----------------| |
8145 // | |------------->|
8147 // | | SubDelResp | No transaction for the response
8148 // | |<-------------| Ongoing transaction not found. This will result timer expiry and resending
8151 // | |------------->|
8153 // | | SubDelFail | Subscription does exist any more in E2 node
8154 // | |<-------------| Ongoing transaction not found. This will result timer expiry
8156 // | [SUBS DELETE] |
8158 //-----------------------------------------------------------------------------
8160 func TestRESTUnpackSubscriptionDeleteResponseNoTransaction(t *testing.T) {
8162 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
8163 Counter{cRestSubReqFromXapp, 1},
8164 Counter{cRestSubRespToXapp, 1},
8165 Counter{cSubReqToE2, 1},
8166 Counter{cSubRespFromE2, 1},
8167 Counter{cRestSubNotifToXapp, 1},
8168 Counter{cRestSubDelReqFromXapp, 1},
8169 Counter{cRestSubDelRespToXapp, 1},
8170 Counter{cSubDelReqToE2, 1},
8171 Counter{cSubDelReqTimerExpiry, 2},
8172 Counter{cSubDelReReqToE2, 1},
8173 Counter{cSubDelRespFromE2, 1},
8174 Counter{cSubDelFailFromE2, 1},
8178 var params *teststube2ap.RESTSubsReqParams = nil
8179 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
8182 xappConn1.SendRESTSubsDelReq(t, &restSubId)
8184 // E2t: Receive 1st SubsDelReq
8185 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
8187 mainCtrl.MakeTransactionNil(t, e2SubsId)
8189 // No transaction exist for this response which will result resending original request
8190 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
8192 // E2t: Receive 2nd SubsDelReq
8193 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
8195 // Subscription does not exist in in E2 Node.
8196 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
8198 // Wait that subs is cleaned
8199 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
8201 xappConn1.TestMsgChanEmpty(t)
8202 e2termConn1.TestMsgChanEmpty(t)
8203 mainCtrl.wait_registry_empty(t, 10)
8204 mainCtrl.VerifyAllClean(t)
8205 mainCtrl.VerifyCounterValues(t)
8208 //-----------------------------------------------------------------------------
8209 // TestRESTUnpackSubscriptionDeleteFailureDecodeFail
8212 // +-------+ +---------+ +---------+
8213 // | xapp | | submgr | | e2term |
8214 // +-------+ +---------+ +---------+
8216 // | [SUBS CREATE] |
8219 // | RESTSubDelReq | |
8220 // |---------------->| |
8222 // | RESTSubDelResp | |
8223 // |<----------------| |
8226 // | |------------->|
8228 // | | SubDelFail | ASN.1 decode fails
8229 // | |<-------------| Decode failed. More data needed. This will result timer expiry and resending
8232 // | |------------->|
8234 // | | SubDelFail | Subscription does exist any more in E2 node
8235 // | |<-------------|
8237 // | [SUBS DELETE] |
8239 //-----------------------------------------------------------------------------
8241 func TestRESTUnpackSubscriptionDeleteFailureDecodeFail(t *testing.T) {
8243 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
8244 Counter{cRestSubReqFromXapp, 1},
8245 Counter{cRestSubRespToXapp, 1},
8246 Counter{cSubReqToE2, 1},
8247 Counter{cSubRespFromE2, 1},
8248 Counter{cRestSubNotifToXapp, 1},
8249 Counter{cRestSubDelReqFromXapp, 1},
8250 Counter{cRestSubDelRespToXapp, 1},
8251 Counter{cSubDelReqToE2, 1},
8252 Counter{cSubDelReqTimerExpiry, 1},
8253 Counter{cSubDelReReqToE2, 1},
8254 Counter{cSubDelFailFromE2, 2},
8258 var params *teststube2ap.RESTSubsReqParams = nil
8259 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
8262 xappConn1.SendRESTSubsDelReq(t, &restSubId)
8264 // E2t: Receive 1st SubsDelReq
8265 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
8267 // Decode of this response fails which will result resending original request
8268 e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_FAILURE)
8270 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
8271 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
8273 // Subscription does not exist in in E2 Node.
8274 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
8276 // Wait that subs is cleaned
8277 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
8279 xappConn1.TestMsgChanEmpty(t)
8280 e2termConn1.TestMsgChanEmpty(t)
8281 mainCtrl.wait_registry_empty(t, 10)
8282 mainCtrl.VerifyAllClean(t)
8283 mainCtrl.VerifyCounterValues(t)
8286 //-----------------------------------------------------------------------------
8287 // TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId
8290 // +-------+ +---------+ +---------+
8291 // | xapp | | submgr | | e2term |
8292 // +-------+ +---------+ +---------+
8294 // | [SUBS CREATE] |
8297 // | RESTSubDelReq | |
8298 // |---------------->| |
8300 // | RESTSubDelResp | |
8301 // |<----------------| |
8304 // | |------------->|
8306 // | | SubDelFail | Unknown instanceId
8307 // | |<-------------| No valid subscription found with subIds [0]. This will result timer expiry and resending
8310 // | |------------->|
8312 // | | SubDelFail | Subscription does exist any more in E2 node
8313 // | |<-------------| No valid subscription found with subIds [0].
8315 // | [SUBS DELETE] |
8317 //-----------------------------------------------------------------------------
8319 func TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId(t *testing.T) {
8321 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
8322 Counter{cRestSubReqFromXapp, 1},
8323 Counter{cRestSubRespToXapp, 1},
8324 Counter{cSubReqToE2, 1},
8325 Counter{cSubRespFromE2, 1},
8326 Counter{cRestSubNotifToXapp, 1},
8327 Counter{cRestSubDelReqFromXapp, 1},
8328 Counter{cRestSubDelRespToXapp, 1},
8329 Counter{cSubDelReqToE2, 1},
8330 Counter{cSubDelReqTimerExpiry, 1},
8331 Counter{cSubDelReReqToE2, 1},
8332 Counter{cSubDelFailFromE2, 2},
8336 var params *teststube2ap.RESTSubsReqParams = nil
8337 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
8340 xappConn1.SendRESTSubsDelReq(t, &restSubId)
8342 // E2t: Receive 1st SubsDelReq
8343 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
8345 // Unknown instanceId 0 in this response which will result resending original request
8346 delreq.RequestId.InstanceId = 0
8347 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
8349 // E2t: Receive 2nd SubsDelReq
8350 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
8352 // Subscription does not exist in in E2 Node. E2 Node responds with failure but there is also same unknown instanceId 0
8353 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
8355 // Wait that subs is cleaned
8356 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
8358 xappConn1.TestMsgChanEmpty(t)
8359 e2termConn1.TestMsgChanEmpty(t)
8360 mainCtrl.wait_registry_empty(t, 10)
8361 mainCtrl.VerifyAllClean(t)
8362 mainCtrl.VerifyCounterValues(t)
8365 //-----------------------------------------------------------------------------
8366 // TestRESTUnpackSubscriptionDeleteFailureNoTransaction
8369 // +-------+ +---------+ +---------+
8370 // | xapp | | submgr | | e2term |
8371 // +-------+ +---------+ +---------+
8373 // | [SUBS CREATE] |
8376 // | RESTSubDelReq | |
8377 // |---------------->| |
8379 // | RESTSubDelResp | |
8380 // |<----------------| |
8383 // | |------------->|
8385 // | | SubDelFail | No transaction for the response
8386 // | |<-------------| Ongoing transaction not found. This will result timer expiry and resending
8389 // | |------------->|
8391 // | | SubDelFail | Subscription does exist any more in E2 node
8392 // | |<-------------| Ongoing transaction not found. This will result timer expiry
8394 // | [SUBS DELETE] |
8396 //-----------------------------------------------------------------------------
8398 func TestRESTUnpackSubscriptionDeleteFailureNoTransaction(t *testing.T) {
8400 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
8401 Counter{cRestSubReqFromXapp, 1},
8402 Counter{cRestSubRespToXapp, 1},
8403 Counter{cSubReqToE2, 1},
8404 Counter{cSubRespFromE2, 1},
8405 Counter{cRestSubNotifToXapp, 1},
8406 Counter{cRestSubDelReqFromXapp, 1},
8407 Counter{cRestSubDelRespToXapp, 1},
8408 Counter{cSubDelReqToE2, 1},
8409 Counter{cSubDelReqTimerExpiry, 2},
8410 Counter{cSubDelReReqToE2, 1},
8411 Counter{cSubDelFailFromE2, 2},
8415 var params *teststube2ap.RESTSubsReqParams = nil
8416 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
8419 xappConn1.SendRESTSubsDelReq(t, &restSubId)
8421 // E2t: Receive 1st SubsDelReq
8422 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
8424 mainCtrl.MakeTransactionNil(t, e2SubsId)
8426 // No transaction exist for this response which will result resending original request
8427 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
8429 // E2t: Receive 2nd SubsDelReq
8430 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
8432 // Subscription does not exist in in E2 Node.
8433 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
8435 // Wait that subs is cleaned
8436 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
8438 xappConn1.TestMsgChanEmpty(t)
8439 e2termConn1.TestMsgChanEmpty(t)
8440 mainCtrl.wait_registry_empty(t, 10)
8441 mainCtrl.VerifyAllClean(t)
8442 mainCtrl.VerifyCounterValues(t)
8445 //-----------------------------------------------------------------------------
8446 // TestRESTSubReqFailAsn1PackSubReqError
8449 // +-------+ +---------+ +---------+
8450 // | xapp | | submgr | | e2term |
8451 // +-------+ +---------+ +---------+
8454 // |---------------->| |
8456 // | RESTSubResp | |
8457 // |<----------------| |
8459 // | ASN.1 encode fails |
8462 // | |------------->|
8465 // | |<-------------|
8469 // |<----------------| |
8471 // | [SUBS DELETE] |
8474 //-----------------------------------------------------------------------------
8476 func TestRESTSubReqFailAsn1PackSubReqError(t *testing.T) {
8478 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
8479 Counter{cRestSubReqFromXapp, 1},
8480 Counter{cRestSubRespToXapp, 1},
8481 Counter{cRestSubFailNotifToXapp, 1},
8482 Counter{cRestSubDelReqFromXapp, 1},
8483 Counter{cRestSubDelRespToXapp, 1},
8486 const subReqCount int = 1
8488 var params *teststube2ap.RESTSubsReqParams = nil
8489 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
8490 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, false)
8493 restSubId := xappConn1.SendRESTSubsReq(t, params)
8494 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
8496 // E2t: Receive SubsDelReq
8497 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
8499 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
8500 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
8502 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, true)
8504 xappConn1.SendRESTSubsDelReq(t, &restSubId)
8506 // Wait that subs is cleaned
8507 waitSubsCleanup(t, e2SubsId, 10)
8508 mainCtrl.VerifyAllClean(t)
8509 mainCtrl.VerifyCounterValues(t)
8512 //-----------------------------------------------------------------------------
8513 // TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction
8516 // +-------+ +---------+ +---------+
8517 // | xapp | | submgr | | e2term |
8518 // +-------+ +---------+ +---------+
8521 // |---------------->| |
8523 // | RESTSubResp | |
8524 // |<----------------| |
8526 // | |------------->|
8529 // | |<-------------|
8532 // |<----------------| |
8534 // | RESTSubReq | | Policy modification
8535 // |---------------->| |
8537 // | RESTSubResp | |
8538 // |<----------------| |
8540 // | |------------->|
8543 // | RESTNotif(Unsuccessful) | E2 timeout
8544 // |<----------------| |
8546 // | RESTSubDelReq | |
8547 // |---------------->| |
8550 // | |------------->|
8553 // | |<-------------|
8555 // | RESTSubDelResp | |
8556 // |<----------------| |
8558 //-----------------------------------------------------------------------------
8560 func TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction(t *testing.T) {
8562 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
8563 Counter{cRestSubReqFromXapp, 2},
8564 Counter{cRestSubRespToXapp, 2},
8565 Counter{cSubReqToE2, 2},
8566 Counter{cSubReqTimerExpiry, 1},
8567 Counter{cSubRespFromE2, 1},
8568 Counter{cRestSubNotifToXapp, 1},
8569 Counter{cRestSubFailNotifToXapp, 1},
8570 Counter{cRestSubDelReqFromXapp, 1},
8571 Counter{cSubDelReqToE2, 1},
8572 Counter{cSubDelRespFromE2, 1},
8573 Counter{cRestSubDelRespToXapp, 1},
8576 const e2Timeout int64 = 1
8577 const e2RetryCount int64 = 0
8578 const routingNeeded bool = false
8581 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
8582 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
8585 restSubId := xappConn1.SendRESTSubsReq(t, params)
8586 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
8588 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
8589 xappConn1.ExpectRESTNotification(t, restSubId)
8590 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
8591 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
8592 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
8595 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
8596 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
8597 params.SetSubscriptionID(&restSubId)
8598 params.SetTimeToWait("w200ms")
8599 restSubId = xappConn1.SendRESTSubsReq(t, params)
8600 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
8602 crereq1, cremsg1 = e2termConn1.RecvSubsReq(t)
8603 xappConn1.ExpectRESTNotification(t, restSubId)
8604 // SubsResp is missing, e2SubsId will be 0
8605 zeroE2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
8606 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", zeroE2SubsId)
8609 xappConn1.SendRESTSubsDelReq(t, &restSubId)
8610 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
8611 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
8613 waitSubsCleanup(t, e2SubsId, 10)
8614 mainCtrl.VerifyAllClean(t)
8615 mainCtrl.VerifyCounterValues(t)
8618 //-----------------------------------------------------------------------------
8619 // TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle
8622 // +-------+ +---------+ +---------+
8623 // | xapp | | submgr | | e2term |
8624 // +-------+ +---------+ +---------+
8627 // |---------------->| |
8629 // | RESTSubResp | |
8630 // |<----------------| |
8632 // | |------------->|
8635 // | |<-------------|
8638 // |<----------------| |
8641 // |---------------->| |
8643 // | RESTSubResp | |
8644 // |<----------------| |
8646 // | |------------->|
8648 // | Submgr restart |
8650 // | RESTSubDelReq | |
8651 // |---------------->| |
8654 // | |------------->|
8657 // | |<-------------|
8659 // | RESTSubDelResp | |
8660 // |<----------------| |
8662 //-----------------------------------------------------------------------------
8664 func TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
8666 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
8667 Counter{cRestSubReqFromXapp, 2},
8668 Counter{cRestSubRespToXapp, 2},
8669 Counter{cSubReqToE2, 2},
8670 Counter{cSubRespFromE2, 1},
8671 Counter{cRestSubNotifToXapp, 1},
8672 Counter{cRestSubDelReqFromXapp, 1},
8673 Counter{cSubDelReqToE2, 1},
8674 Counter{cSubDelRespFromE2, 1},
8675 Counter{cRestSubDelRespToXapp, 1},
8678 const e2Timeout int64 = 1
8679 const e2RetryCount int64 = 0
8680 const routingNeeded bool = false
8683 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
8684 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
8685 // Create subscription
8686 restSubId := xappConn1.SendRESTSubsReq(t, params)
8687 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
8689 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
8690 xappConn1.ExpectRESTNotification(t, restSubId)
8691 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
8692 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
8693 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
8695 // Check subscription
8696 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
8699 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
8700 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
8701 params.SetSubscriptionID(&restSubId)
8702 params.SetTimeToWait("w200ms")
8703 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
8704 restSubId = xappConn1.SendRESTSubsReq(t, params)
8705 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
8707 crereq1, cremsg1 = e2termConn1.RecvSubsReq(t)
8708 mainCtrl.SetResetTestFlag(t, false)
8710 // SubsResp is missing due to submgr restart
8712 mainCtrl.SimulateRestart(t)
8713 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
8715 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
8716 // That needs to be completed before successful subscription query is possible
8717 <-time.After(time.Second * 1)
8719 // Check subscription
8720 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
8722 // Delete subscription
8723 xappConn1.SendRESTSubsDelReq(t, &restSubId)
8724 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
8725 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
8727 //Wait that subs is cleaned
8728 waitSubsCleanup(t, e2SubsId, 10)
8730 mainCtrl.VerifyCounterValues(t)
8731 mainCtrl.VerifyAllClean(t)
8734 ////////////////////////////////////////////////////////////////////////////////////
8735 // Services for UT cases
8736 ////////////////////////////////////////////////////////////////////////////////////
8737 const subReqCount int = 1
8738 const host string = "localhost"
8740 func createSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, params *teststube2ap.RESTSubsReqParams) (string, uint32) {
8742 params = fromXappConn.GetRESTSubsReqReportParams(subReqCount)
8744 restSubId := fromXappConn.SendRESTSubsReq(t, params)
8745 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
8747 crereq1, cremsg1 := toE2termConn.RecvSubsReq(t)
8748 fromXappConn.ExpectRESTNotification(t, restSubId)
8749 toE2termConn.SendSubsResp(t, crereq1, cremsg1)
8750 e2SubsId := fromXappConn.WaitRESTNotification(t, restSubId)
8751 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
8753 return restSubId, e2SubsId
8756 func createXapp2MergedSubscription(t *testing.T, meid string) (string, uint32) {
8758 params := xappConn2.GetRESTSubsReqReportParams(subReqCount)
8760 params.SetMeid(meid)
8762 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
8763 restSubId := xappConn2.SendRESTSubsReq(t, params)
8764 xappConn2.ExpectRESTNotification(t, restSubId)
8765 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
8766 e2SubsId := xappConn2.WaitRESTNotification(t, restSubId)
8767 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
8769 return restSubId, e2SubsId
8772 func createXapp1PolicySubscription(t *testing.T) (string, uint32) {
8774 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
8775 restSubId := xappConn1.SendRESTSubsReq(t, params)
8776 xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
8778 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
8779 xappConn1.ExpectRESTNotification(t, restSubId)
8780 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
8781 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
8782 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
8784 return restSubId, e2SubsId
8787 func createXapp1ReportSubscriptionE2Fail(t *testing.T) (string, uint32) {
8788 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
8789 restSubId := xappConn1.SendRESTSubsReq(t, params)
8791 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
8792 fparams1 := &teststube2ap.E2StubSubsFailParams{}
8793 fparams1.Set(crereq1)
8794 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
8796 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
8797 xappConn1.ExpectRESTNotification(t, restSubId)
8798 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
8799 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
8800 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
8802 return restSubId, e2SubsId
8805 func deleteSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId *string) {
8806 fromXappConn.SendRESTSubsDelReq(t, restSubId)
8807 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
8808 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
8811 func deleteXapp1Subscription(t *testing.T, restSubId *string) {
8812 xappConn1.SendRESTSubsDelReq(t, restSubId)
8813 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
8814 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
8817 func deleteXapp2Subscription(t *testing.T, restSubId *string) {
8818 xappConn2.SendRESTSubsDelReq(t, restSubId)
8819 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
8820 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
8823 func queryXappSubscription(t *testing.T, e2SubsId int64, meid string, endpoint []string) {
8824 resp, _ := xapp.Subscription.QuerySubscriptions()
8825 assert.Equal(t, e2SubsId, resp[0].SubscriptionID)
8826 assert.Equal(t, meid, resp[0].Meid)
8827 assert.Equal(t, endpoint, resp[0].ClientEndpoint)
8830 func waitSubsCleanup(t *testing.T, e2SubsId uint32, timeout int) {
8831 //Wait that subs is cleaned
8832 mainCtrl.wait_subs_clean(t, e2SubsId, timeout)
8834 xappConn1.TestMsgChanEmpty(t)
8835 xappConn2.TestMsgChanEmpty(t)
8836 e2termConn1.TestMsgChanEmpty(t)
8837 mainCtrl.wait_registry_empty(t, timeout)
8840 func sendAndReceiveMultipleE2SubReqs(t *testing.T, count int, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId string) []uint32 {
8842 var e2SubsId []uint32
8844 for i := 0; i < count; i++ {
8845 xapp.Logger.Debug("TEST: %d ===================================== BEGIN CRE ============================================", i+1)
8846 crereq, cremsg := toE2termConn.RecvSubsReq(t)
8847 fromXappConn.ExpectRESTNotification(t, restSubId)
8848 toE2termConn.SendSubsResp(t, crereq, cremsg)
8849 instanceId := fromXappConn.WaitRESTNotification(t, restSubId)
8850 e2SubsId = append(e2SubsId, instanceId)
8851 xapp.Logger.Debug("TEST: %v", e2SubsId)
8852 xapp.Logger.Debug("TEST: %d ===================================== END CRE ============================================", i+1)
8853 <-time.After(100 * time.Millisecond)
8858 func sendAndReceiveMultipleE2DelReqs(t *testing.T, e2SubsIds []uint32, toE2termConn *teststube2ap.E2Stub) {
8860 for i := 0; i < len(e2SubsIds); i++ {
8861 xapp.Logger.Debug("TEST: %d ===================================== BEGIN DEL ============================================", i+1)
8862 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
8863 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
8864 <-time.After(1 * time.Second)
8865 xapp.Logger.Debug("TEST: %d ===================================== END DEL ============================================", i+1)
8866 <-time.After(100 * time.Millisecond)
8869 // Wait that subs is cleaned
8870 for i := 0; i < len(e2SubsIds); i++ {
8871 mainCtrl.wait_subs_clean(t, e2SubsIds[i], 10)