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 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
951 resp, _ := xapp.Subscription.QuerySubscriptions()
952 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
953 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
954 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
956 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
957 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
959 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
960 xappConn1.RecvSubsDelResp(t, deltrans)
962 //Wait that subs is cleaned
963 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
965 xappConn1.TestMsgChanEmpty(t)
966 xappConn2.TestMsgChanEmpty(t)
967 e2termConn1.TestMsgChanEmpty(t)
968 mainCtrl.wait_registry_empty(t, 10)
970 mainCtrl.VerifyCounterValues(t)
971 mainCtrl.c.e2ap.SetE2IEOrderCheck(1)
974 //-----------------------------------------------------------------------------
976 //-----------------------------------------------------------------------------
977 // TestSubReqRetransmission
980 // +-------+ +---------+ +---------+
981 // | xapp | | submgr | | e2term |
982 // +-------+ +---------+ +---------+
985 // |------------->| |
988 // | |------------->|
992 // |------------->| |
995 // | |<-------------|
998 // |<-------------| |
1000 // | [SUBS DELETE] |
1003 //-----------------------------------------------------------------------------
1004 func TestSubReqRetransmission(t *testing.T) {
1005 CaseBegin("TestSubReqRetransmission")
1008 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1009 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1011 seqBef := mainCtrl.get_msgcounter(t)
1012 xappConn1.SendSubsReq(t, nil, cretrans) //Retransmitted SubReq
1013 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
1015 // hack as there is no real way to see has message be handled.
1016 // Previuos counter check just tells that is has been received by submgr
1017 // --> artificial delay
1018 <-time.After(1 * time.Second)
1019 e2termConn1.SendSubsResp(t, crereq, cremsg)
1020 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1023 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1024 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1025 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1026 xappConn1.RecvSubsDelResp(t, deltrans)
1028 //Wait that subs is cleaned
1029 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1031 xappConn1.TestMsgChanEmpty(t)
1032 xappConn2.TestMsgChanEmpty(t)
1033 e2termConn1.TestMsgChanEmpty(t)
1034 mainCtrl.wait_registry_empty(t, 10)
1037 //-----------------------------------------------------------------------------
1038 // TestSubDelReqRetransmission
1041 // +-------+ +---------+ +---------+
1042 // | xapp | | submgr | | e2term |
1043 // +-------+ +---------+ +---------+
1045 // | [SUBS CREATE] |
1049 // |------------->| |
1052 // | |------------->|
1057 // |------------->| |
1060 // | |<-------------|
1063 // |<-------------| |
1065 //-----------------------------------------------------------------------------
1066 func TestSubDelReqRetransmission(t *testing.T) {
1067 CaseBegin("TestSubDelReqRetransmission")
1070 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1071 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1072 e2termConn1.SendSubsResp(t, crereq, cremsg)
1073 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1076 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1077 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1079 seqBef := mainCtrl.get_msgcounter(t)
1080 xappConn1.SendSubsDelReq(t, deltrans, e2SubsId) //Retransmitted SubDelReq
1081 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
1083 // hack as there is no real way to see has message be handled.
1084 // Previuos counter check just tells that is has been received by submgr
1085 // --> artificial delay
1086 <-time.After(1 * time.Second)
1088 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1089 xappConn1.RecvSubsDelResp(t, deltrans)
1091 //Wait that subs is cleaned
1092 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1094 xappConn1.TestMsgChanEmpty(t)
1095 xappConn2.TestMsgChanEmpty(t)
1096 e2termConn1.TestMsgChanEmpty(t)
1097 mainCtrl.wait_registry_empty(t, 10)
1100 //-----------------------------------------------------------------------------
1101 // TestSubDelReqCollision
1104 // +-------+ +---------+ +---------+
1105 // | xapp | | submgr | | e2term |
1106 // +-------+ +---------+ +---------+
1108 // | [SUBS CREATE] |
1111 // | SubDelReq 1 | |
1112 // |------------->| |
1114 // | | SubDelReq 1 |
1115 // | |------------->|
1117 // | SubDelReq 2 | |
1120 // |------------->| |
1122 // | | SubDelResp 1 |
1123 // | |<-------------|
1125 // | SubDelResp 1 | |
1126 // |<-------------| |
1128 // | SubDelResp 2 | |
1129 // |<-------------| |
1131 //-----------------------------------------------------------------------------
1133 func TestSubDelReqCollision(t *testing.T) {
1134 CaseBegin("TestSubDelReqCollision")
1137 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1138 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1139 e2termConn1.SendSubsResp(t, crereq, cremsg)
1140 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1143 xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1144 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1146 // Subs Delete colliding
1147 seqBef := mainCtrl.get_msgcounter(t)
1148 deltranscol2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1149 xappConn1.SendSubsDelReq(t, deltranscol2, e2SubsId) //Colliding SubDelReq
1150 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
1152 // hack as there is no real way to see has message be handled.
1153 // Previuos counter check just tells that is has been received by submgr
1154 // --> artificial delay
1155 <-time.After(1 * time.Second)
1157 // Del resp for first and second
1158 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1160 // don't care in which order responses are received
1161 xappConn1.RecvSubsDelResp(t, nil)
1162 xappConn1.RecvSubsDelResp(t, nil)
1164 //Wait that subs is cleaned
1165 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1167 xappConn1.TestMsgChanEmpty(t)
1168 xappConn2.TestMsgChanEmpty(t)
1169 e2termConn1.TestMsgChanEmpty(t)
1170 mainCtrl.wait_registry_empty(t, 10)
1173 //-----------------------------------------------------------------------------
1174 // TestSubReqAndSubDelOkTwoParallel
1177 // +-------+ +-------+ +---------+ +---------+
1178 // | xapp | | xapp | | submgr | | e2term |
1179 // +-------+ +-------+ +---------+ +---------+
1184 // | |------------->| |
1187 // | | |------------->|
1190 // |------------------------>| |
1193 // | | |------------->|
1196 // | | |<-------------|
1198 // | |<-------------| |
1201 // | | |<-------------|
1203 // |<------------------------| |
1205 // | | [SUBS 1 DELETE] |
1207 // | | [SUBS 2 DELETE] |
1210 //-----------------------------------------------------------------------------
1212 func TestSubReqAndSubDelOkTwoParallel(t *testing.T) {
1213 CaseBegin("TestSubReqAndSubDelOkTwoParallel")
1216 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1218 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1219 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1222 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1225 rparams2.Req.EventTriggerDefinition.Data.Length = 1
1226 rparams2.Req.EventTriggerDefinition.Data.Data = make([]uint8, rparams2.Req.EventTriggerDefinition.Data.Length)
1227 rparams2.Req.EventTriggerDefinition.Data.Data[0] = 2
1229 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1230 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
1233 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1234 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1237 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
1238 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1241 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1242 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1243 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1244 xappConn1.RecvSubsDelResp(t, deltrans1)
1245 //Wait that subs is cleaned
1246 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1249 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1250 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1251 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1252 xappConn2.RecvSubsDelResp(t, deltrans2)
1253 //Wait that subs is cleaned
1254 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1256 xappConn1.TestMsgChanEmpty(t)
1257 xappConn2.TestMsgChanEmpty(t)
1258 e2termConn1.TestMsgChanEmpty(t)
1259 mainCtrl.wait_registry_empty(t, 10)
1262 //-----------------------------------------------------------------------------
1263 // TestSameSubsDiffRan
1264 // Same subscription to different RANs
1267 // +-------+ +---------+ +---------+
1268 // | xapp | | submgr | | e2term |
1269 // +-------+ +---------+ +---------+
1274 // |------------->| |
1277 // | |------------->|
1279 // | | SubResp(r1) |
1280 // | |<-------------|
1282 // | SubResp(r1) | |
1283 // |<-------------| |
1286 // |------------->| |
1289 // | |------------->|
1291 // | | SubResp(r2) |
1292 // | |<-------------|
1294 // | SubResp(r2) | |
1295 // |<-------------| |
1297 // | [SUBS r1 DELETE] |
1299 // | [SUBS r2 DELETE] |
1302 //-----------------------------------------------------------------------------
1303 func TestSameSubsDiffRan(t *testing.T) {
1304 CaseBegin("TestSameSubsDiffRan")
1307 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1308 xappConn1.SendSubsReq(t, nil, cretrans1)
1309 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1310 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1311 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1314 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
1315 xappConn1.SendSubsReq(t, nil, cretrans2)
1316 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
1317 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
1318 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
1321 deltrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1322 xappConn1.SendSubsDelReq(t, deltrans1, e2SubsId1)
1323 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1324 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1325 xappConn1.RecvSubsDelResp(t, deltrans1)
1326 //Wait that subs is cleaned
1327 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1330 deltrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
1331 xappConn1.SendSubsDelReq(t, deltrans2, e2SubsId2)
1332 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1333 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1334 xappConn1.RecvSubsDelResp(t, deltrans2)
1335 //Wait that subs is cleaned
1336 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1338 xappConn1.TestMsgChanEmpty(t)
1339 xappConn2.TestMsgChanEmpty(t)
1340 e2termConn1.TestMsgChanEmpty(t)
1341 mainCtrl.wait_registry_empty(t, 10)
1344 //-----------------------------------------------------------------------------
1345 // TestSubReqRetryInSubmgr
1348 // +-------+ +---------+ +---------+
1349 // | xapp | | submgr | | e2term |
1350 // +-------+ +---------+ +---------+
1353 // |------------->| |
1356 // | |------------->|
1360 // | |------------->|
1363 // | |<-------------|
1366 // |<-------------| |
1368 // | [SUBS DELETE] |
1371 //-----------------------------------------------------------------------------
1373 func TestSubReqRetryInSubmgr(t *testing.T) {
1374 CaseBegin("TestSubReqRetryInSubmgr start")
1376 // Init counter check
1377 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1378 Counter{cSubReqFromXapp, 1},
1379 Counter{cSubReqToE2, 1},
1380 Counter{cSubReqTimerExpiry, 1},
1381 Counter{cSubReReqToE2, 1},
1382 Counter{cSubRespFromE2, 1},
1383 Counter{cSubRespToXapp, 1},
1384 Counter{cSubDelReqFromXapp, 1},
1385 Counter{cSubDelReqToE2, 1},
1386 Counter{cSubDelRespFromE2, 1},
1387 Counter{cSubDelRespToXapp, 1},
1390 // Xapp: Send SubsReq
1391 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1393 // E2t: Receive 1st SubsReq
1394 e2termConn1.RecvSubsReq(t)
1396 // E2t: Receive 2nd SubsReq and send SubsResp
1397 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1398 e2termConn1.SendSubsResp(t, crereq, cremsg)
1400 // Xapp: Receive SubsResp
1401 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1403 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1404 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1405 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1406 xappConn1.RecvSubsDelResp(t, deltrans)
1408 // Wait that subs is cleaned
1409 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1411 xappConn1.TestMsgChanEmpty(t)
1412 xappConn2.TestMsgChanEmpty(t)
1413 e2termConn1.TestMsgChanEmpty(t)
1414 mainCtrl.wait_registry_empty(t, 10)
1416 mainCtrl.VerifyCounterValues(t)
1419 //-----------------------------------------------------------------------------
1420 // TestSubReqTwoRetriesNoRespSubDelRespInSubmgr
1423 // +-------+ +---------+ +---------+
1424 // | xapp | | submgr | | e2term |
1425 // +-------+ +---------+ +---------+
1428 // |------------->| |
1431 // | |------------->|
1435 // | |------------->|
1438 // | |------------->|
1441 // | |<-------------|
1444 //-----------------------------------------------------------------------------
1445 func TestSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
1446 CaseBegin("TestSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
1448 // Init counter check
1449 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1450 Counter{cSubReqFromXapp, 1},
1451 Counter{cSubReqToE2, 1},
1452 Counter{cSubReReqToE2, 1},
1453 Counter{cSubReqTimerExpiry, 2},
1454 Counter{cSubDelReqToE2, 1},
1455 Counter{cSubDelRespFromE2, 1},
1458 // Xapp: Send SubsReq
1459 xappConn1.SendSubsReq(t, nil, nil)
1461 // E2t: Receive 1st SubsReq
1462 e2termConn1.RecvSubsReq(t)
1464 // E2t: Receive 2nd SubsReq
1465 e2termConn1.RecvSubsReq(t)
1467 // E2t: Send receive SubsDelReq and send SubsResp
1468 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1469 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1471 // Wait that subs is cleaned
1472 mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 10)
1474 xappConn1.TestMsgChanEmpty(t)
1475 xappConn2.TestMsgChanEmpty(t)
1476 e2termConn1.TestMsgChanEmpty(t)
1477 mainCtrl.wait_registry_empty(t, 10)
1479 mainCtrl.VerifyCounterValues(t)
1482 //-----------------------------------------------------------------------------
1483 // TestSubReqTwoRetriesNoRespAtAllInSubmgr
1486 // +-------+ +---------+ +---------+
1487 // | xapp | | submgr | | e2term |
1488 // +-------+ +---------+ +---------+
1491 // |------------->| |
1494 // | |------------->|
1498 // | |------------->|
1501 // | |------------->|
1505 // | |------------->|
1509 //-----------------------------------------------------------------------------
1511 func TestSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
1512 CaseBegin("TestSubReqTwoRetriesNoRespAtAllInSubmgr start")
1514 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1515 Counter{cSubReqFromXapp, 1},
1516 Counter{cSubReqToE2, 1},
1517 Counter{cSubReReqToE2, 1},
1518 Counter{cSubReqTimerExpiry, 2},
1519 Counter{cSubDelReqToE2, 1},
1520 Counter{cSubDelReReqToE2, 1},
1521 Counter{cSubDelReqTimerExpiry, 2},
1524 // Xapp: Send SubsReq
1525 xappConn1.SendSubsReq(t, nil, nil)
1527 // E2t: Receive 1st SubsReq
1528 e2termConn1.RecvSubsReq(t)
1530 // E2t: Receive 2nd SubsReq
1531 e2termConn1.RecvSubsReq(t)
1533 // E2t: Receive 1st SubsDelReq
1534 e2termConn1.RecvSubsDelReq(t)
1536 // E2t: Receive 2nd SubsDelReq
1537 delreq, _ := e2termConn1.RecvSubsDelReq(t)
1539 // Wait that subs is cleaned
1540 mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 15)
1542 xappConn1.TestMsgChanEmpty(t)
1543 xappConn2.TestMsgChanEmpty(t)
1544 e2termConn1.TestMsgChanEmpty(t)
1545 mainCtrl.wait_registry_empty(t, 10)
1547 mainCtrl.VerifyCounterValues(t)
1550 //-----------------------------------------------------------------------------
1551 // TestSubReqSubFailRespInSubmgr
1554 // +-------+ +---------+ +---------+
1555 // | xapp | | submgr | | e2term |
1556 // +-------+ +---------+ +---------+
1559 // |------------->| |
1562 // | |------------->|
1565 // | |<-------------|
1568 // |<-------------| |
1571 //-----------------------------------------------------------------------------
1573 func TestSubReqSubFailRespInSubmgr(t *testing.T) {
1574 CaseBegin("TestSubReqSubFailRespInSubmgr start")
1576 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1577 Counter{cSubReqFromXapp, 1},
1578 Counter{cSubReqToE2, 1},
1579 Counter{cSubFailFromE2, 1},
1580 Counter{cSubFailToXapp, 1},
1583 // Xapp: Send SubsReq
1584 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1586 // E2t: Receive SubsReq and send SubsFail (first)
1587 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1588 fparams1 := &teststube2ap.E2StubSubsFailParams{}
1589 fparams1.Set(crereq1)
1590 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
1592 // Xapp: Receive SubsFail
1593 e2SubsId := xappConn1.RecvSubsFail(t, cretrans)
1595 // Wait that subs is cleaned
1596 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1598 xappConn1.TestMsgChanEmpty(t)
1599 xappConn2.TestMsgChanEmpty(t)
1600 e2termConn1.TestMsgChanEmpty(t)
1601 mainCtrl.wait_registry_empty(t, 10)
1603 mainCtrl.VerifyCounterValues(t)
1606 //-----------------------------------------------------------------------------
1607 // TestSubReqSubFailRespInSubmgrOutofOrderIEs
1610 // +-------+ +---------+ +---------+
1611 // | xapp | | submgr | | e2term |
1612 // +-------+ +---------+ +---------+
1615 // |------------->| |
1618 // | |------------->|
1620 // | | SubFail | (Out of Order IEs)
1621 // | |<-------------|
1624 // |<-------------| |
1627 //-----------------------------------------------------------------------------
1629 func TestSubReqSubFailRespInSubmgrOutofOrderIEs(t *testing.T) {
1630 CaseBegin("TestSubReqSubFailRespInSubmgrOutofOrderIEs start")
1632 mainCtrl.c.e2ap.SetE2IEOrderCheck(0)
1633 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1634 Counter{cSubReqFromXapp, 1},
1635 Counter{cSubReqToE2, 1},
1636 Counter{cSubFailFromE2, 1},
1637 Counter{cSubFailToXapp, 1},
1640 // Xapp: Send SubsReq
1641 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1643 // E2t: Receive SubsReq and send SubsFail (first)
1644 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1645 fparams1 := &teststube2ap.E2StubSubsFailParams{}
1646 fparams1.Set(crereq1)
1647 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
1649 // Xapp: Receive SubsFail
1650 e2SubsId := xappConn1.RecvSubsFail(t, cretrans)
1652 // Wait that subs is cleaned
1653 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1655 xappConn1.TestMsgChanEmpty(t)
1656 xappConn2.TestMsgChanEmpty(t)
1657 e2termConn1.TestMsgChanEmpty(t)
1658 mainCtrl.wait_registry_empty(t, 10)
1660 mainCtrl.VerifyCounterValues(t)
1661 mainCtrl.c.e2ap.SetE2IEOrderCheck(1)
1664 //-----------------------------------------------------------------------------
1665 // TestSubDelReqRetryInSubmgr
1668 // +-------+ +---------+ +---------+
1669 // | xapp | | submgr | | e2term |
1670 // +-------+ +---------+ +---------+
1672 // | [SUBS CREATE] |
1676 // |------------->| |
1679 // | |------------->|
1682 // | |------------->|
1685 // | |<-------------|
1688 // |<-------------| |
1690 //-----------------------------------------------------------------------------
1692 func TestSubDelReqRetryInSubmgr(t *testing.T) {
1694 CaseBegin("TestSubDelReqRetryInSubmgr start")
1697 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1698 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1699 e2termConn1.SendSubsResp(t, crereq, cremsg)
1700 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1703 // Xapp: Send SubsDelReq
1704 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1706 // E2t: Receive 1st SubsDelReq
1707 e2termConn1.RecvSubsDelReq(t)
1709 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
1710 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1711 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1713 // Xapp: Receive SubsDelResp
1714 xappConn1.RecvSubsDelResp(t, deltrans)
1716 // Wait that subs is cleaned
1717 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1719 xappConn1.TestMsgChanEmpty(t)
1720 xappConn2.TestMsgChanEmpty(t)
1721 e2termConn1.TestMsgChanEmpty(t)
1722 mainCtrl.wait_registry_empty(t, 10)
1725 //-----------------------------------------------------------------------------
1726 // TestSubDelReqTwoRetriesNoRespInSubmgr
1729 // +-------+ +---------+ +---------+
1730 // | xapp | | submgr | | e2term |
1731 // +-------+ +---------+ +---------+
1733 // | [SUBS CREATE] |
1737 // |------------->| |
1740 // | |------------->|
1743 // | |------------->|
1747 // |<-------------| |
1749 //-----------------------------------------------------------------------------
1751 func TestSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
1753 CaseBegin("TestSubDelReTwoRetriesNoRespInSubmgr start")
1756 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1757 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1758 e2termConn1.SendSubsResp(t, crereq, cremsg)
1759 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1762 // Xapp: Send SubsDelReq
1763 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1765 // E2t: Receive 1st SubsDelReq
1766 e2termConn1.RecvSubsDelReq(t)
1768 // E2t: Receive 2nd SubsDelReq
1769 e2termConn1.RecvSubsDelReq(t)
1771 // Xapp: Receive SubsDelResp
1772 xappConn1.RecvSubsDelResp(t, deltrans)
1774 // Wait that subs is cleaned
1775 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1777 xappConn1.TestMsgChanEmpty(t)
1778 xappConn2.TestMsgChanEmpty(t)
1779 e2termConn1.TestMsgChanEmpty(t)
1780 mainCtrl.wait_registry_empty(t, 10)
1783 //-----------------------------------------------------------------------------
1784 // TestSubDelReqSubDelFailRespInSubmgr
1787 // +-------+ +---------+ +---------+
1788 // | xapp | | submgr | | e2term |
1789 // +-------+ +---------+ +---------+
1791 // | [SUBS CREATE] |
1795 // |------------->| |
1798 // | |------------->|
1801 // | |<-------------|
1804 // |<-------------| |
1807 //-----------------------------------------------------------------------------
1809 func TestSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
1810 CaseBegin("TestSubReqSubDelFailRespInSubmgr start")
1812 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1813 Counter{cSubReqFromXapp, 1},
1814 Counter{cSubReqToE2, 1},
1815 Counter{cSubRespFromE2, 1},
1816 Counter{cSubRespToXapp, 1},
1817 Counter{cSubDelReqFromXapp, 1},
1818 Counter{cSubDelReqToE2, 1},
1819 Counter{cSubDelFailFromE2, 1},
1820 Counter{cSubDelRespToXapp, 1},
1824 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1825 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1826 e2termConn1.SendSubsResp(t, crereq, cremsg)
1827 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1829 // Xapp: Send SubsDelReq
1830 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1832 // E2t: Send receive SubsDelReq and send SubsDelFail
1833 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1834 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
1836 // Xapp: Receive SubsDelResp
1837 xappConn1.RecvSubsDelResp(t, deltrans)
1839 // Wait that subs is cleaned
1840 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1842 xappConn1.TestMsgChanEmpty(t)
1843 xappConn2.TestMsgChanEmpty(t)
1844 e2termConn1.TestMsgChanEmpty(t)
1845 mainCtrl.wait_registry_empty(t, 10)
1847 mainCtrl.VerifyCounterValues(t)
1850 //-----------------------------------------------------------------------------
1851 // TestSubDelReqSubDelFailRespInSubmgrOutofOrderIEs
1854 // +-------+ +---------+ +---------+
1855 // | xapp | | submgr | | e2term |
1856 // +-------+ +---------+ +---------+
1858 // | [SUBS CREATE] |
1862 // |------------->| |
1865 // | |------------->|
1867 // | | SubDelFail | (Out of Order IEs)
1868 // | |<-------------|
1871 // |<-------------| |
1874 //-----------------------------------------------------------------------------
1876 func TestSubDelReqSubDelFailRespInSubmgrOutofOrderIEs(t *testing.T) {
1877 CaseBegin("TestSubReqSubDelFailRespInSubmgr start")
1879 mainCtrl.c.e2ap.SetE2IEOrderCheck(0)
1880 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1881 Counter{cSubReqFromXapp, 1},
1882 Counter{cSubReqToE2, 1},
1883 Counter{cSubRespFromE2, 1},
1884 Counter{cSubRespToXapp, 1},
1885 Counter{cSubDelReqFromXapp, 1},
1886 Counter{cSubDelReqToE2, 1},
1887 Counter{cSubDelFailFromE2, 1},
1888 Counter{cSubDelRespToXapp, 1},
1892 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1893 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1894 e2termConn1.SendSubsResp(t, crereq, cremsg)
1895 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1897 // Xapp: Send SubsDelReq
1898 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1900 // E2t: Send receive SubsDelReq and send SubsDelFail
1901 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1902 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
1904 // Xapp: Receive SubsDelResp
1905 xappConn1.RecvSubsDelResp(t, deltrans)
1907 // Wait that subs is cleaned
1908 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1910 xappConn1.TestMsgChanEmpty(t)
1911 xappConn2.TestMsgChanEmpty(t)
1912 e2termConn1.TestMsgChanEmpty(t)
1913 mainCtrl.wait_registry_empty(t, 10)
1915 mainCtrl.VerifyCounterValues(t)
1916 mainCtrl.c.e2ap.SetE2IEOrderCheck(1)
1919 //-----------------------------------------------------------------------------
1920 // TestSubReqAndSubDelOkSameAction
1923 // +-------+ +-------+ +---------+ +---------+
1924 // | xapp2 | | xapp1 | | submgr | | e2term |
1925 // +-------+ +-------+ +---------+ +---------+
1930 // | |------------->| |
1933 // | | |------------->|
1935 // | | |<-------------|
1937 // | |<-------------| |
1940 // |--------------------------->| |
1943 // |<---------------------------| |
1945 // | | SubDelReq 1 | |
1946 // | |------------->| |
1948 // | | SubDelResp 1 | |
1949 // | |<-------------| |
1951 // | SubDelReq 2 | |
1952 // |--------------------------->| |
1954 // | | | SubDelReq 2 |
1955 // | | |------------->|
1957 // | | | SubDelReq 2 |
1958 // | | |------------->|
1960 // | SubDelResp 2 | |
1961 // |<---------------------------| |
1963 //-----------------------------------------------------------------------------
1964 func TestSubReqAndSubDelOkSameAction(t *testing.T) {
1965 CaseBegin("TestSubReqAndSubDelOkSameAction")
1967 // Init counter check
1968 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
1969 Counter{cSubReqFromXapp, 2},
1970 Counter{cSubReqToE2, 1},
1971 Counter{cSubRespFromE2, 1},
1972 Counter{cSubRespToXapp, 2},
1973 Counter{cMergedSubscriptions, 1},
1974 Counter{cUnmergedSubscriptions, 1},
1975 Counter{cSubDelReqFromXapp, 2},
1976 Counter{cSubDelReqToE2, 1},
1977 Counter{cSubDelRespFromE2, 1},
1978 Counter{cSubDelRespToXapp, 2},
1982 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1984 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1985 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1986 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1987 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1990 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1992 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1993 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1995 resp, _ := xapp.Subscription.QuerySubscriptions()
1996 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
1997 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
1998 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
2001 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
2002 xappConn1.RecvSubsDelResp(t, deltrans1)
2005 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
2006 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
2007 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
2008 xappConn2.RecvSubsDelResp(t, deltrans2)
2009 //Wait that subs is cleaned
2010 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
2012 xappConn1.TestMsgChanEmpty(t)
2013 xappConn2.TestMsgChanEmpty(t)
2014 e2termConn1.TestMsgChanEmpty(t)
2015 mainCtrl.wait_registry_empty(t, 10)
2017 mainCtrl.VerifyCounterValues(t)
2020 //-----------------------------------------------------------------------------
2021 // TestSubReqAndSubDelOkSameActionParallel
2024 // +-------+ +-------+ +---------+ +---------+
2025 // | xapp2 | | xapp1 | | submgr | | e2term |
2026 // +-------+ +-------+ +---------+ +---------+
2031 // | |------------->| |
2034 // | | |------------->|
2036 // |--------------------------->| |
2038 // | | |<-------------|
2040 // | |<-------------| |
2043 // |<---------------------------| |
2045 // | | SubDelReq 1 | |
2046 // | |------------->| |
2048 // | | SubDelResp 1 | |
2049 // | |<-------------| |
2051 // | SubDelReq 2 | |
2052 // |--------------------------->| |
2054 // | | | SubDelReq 2 |
2055 // | | |------------->|
2057 // | | | SubDelReq 2 |
2058 // | | |------------->|
2060 // | SubDelResp 2 | |
2061 // |<---------------------------| |
2063 //-----------------------------------------------------------------------------
2064 func TestSubReqAndSubDelOkSameActionParallel(t *testing.T) {
2065 CaseBegin("TestSubReqAndSubDelOkSameActionParallel")
2068 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2070 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
2071 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2074 rparams2 := &teststube2ap.E2StubSubsReqParams{}
2076 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
2079 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2080 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
2083 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
2086 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
2087 xappConn1.RecvSubsDelResp(t, deltrans1)
2090 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
2091 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
2092 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
2093 xappConn2.RecvSubsDelResp(t, deltrans2)
2095 //Wait that subs is cleaned
2096 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
2098 xappConn1.TestMsgChanEmpty(t)
2099 xappConn2.TestMsgChanEmpty(t)
2100 e2termConn1.TestMsgChanEmpty(t)
2101 mainCtrl.wait_registry_empty(t, 10)
2104 //-----------------------------------------------------------------------------
2105 // TestSubReqAndSubDelNokSameActionParallel
2108 // +-------+ +-------+ +---------+ +---------+
2109 // | xapp2 | | xapp1 | | submgr | | e2term |
2110 // +-------+ +-------+ +---------+ +---------+
2115 // | |------------->| |
2118 // | | |------------->|
2120 // |--------------------------->| |
2122 // | | |<-------------|
2125 // | |<-------------| |
2128 // |<---------------------------| |
2130 //-----------------------------------------------------------------------------
2131 func TestSubReqAndSubDelNokSameActionParallel(t *testing.T) {
2132 CaseBegin("TestSubReqAndSubDelNokSameActionParallel")
2135 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2137 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
2139 // E2t: Receive SubsReq (first)
2140 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2143 rparams2 := &teststube2ap.E2StubSubsReqParams{}
2145 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
2146 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
2147 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
2149 // E2t: send SubsFail (first)
2150 fparams1 := &teststube2ap.E2StubSubsFailParams{}
2151 fparams1.Set(crereq1)
2152 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
2155 e2SubsId1 := xappConn1.RecvSubsFail(t, cretrans1)
2157 xappConn2.RecvSubsFail(t, cretrans2)
2159 //Wait that subs is cleaned
2160 mainCtrl.wait_subs_clean(t, e2SubsId1, 15)
2162 xappConn1.TestMsgChanEmpty(t)
2163 xappConn2.TestMsgChanEmpty(t)
2164 e2termConn1.TestMsgChanEmpty(t)
2165 mainCtrl.wait_registry_empty(t, 10)
2168 //-----------------------------------------------------------------------------
2169 // TestSubReqAndSubDelNoAnswerSameActionParallel
2172 // +-------+ +-------+ +---------+ +---------+
2173 // | xapp2 | | xapp1 | | submgr | | e2term |
2174 // +-------+ +-------+ +---------+ +---------+
2179 // | |------------->| |
2182 // | | |------------->|
2184 // |--------------------------->| |
2187 // | | |------------->|
2190 // | | | SubDelReq |
2191 // | | |------------->|
2193 // | | | SubDelResp |
2194 // | | |<-------------|
2196 //-----------------------------------------------------------------------------
2197 func TestSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
2198 CaseBegin("TestSubReqAndSubDelNoAnswerSameActionParallel")
2201 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2203 xappConn1.SendSubsReq(t, rparams1, nil)
2205 crereq1, _ := e2termConn1.RecvSubsReq(t)
2208 rparams2 := &teststube2ap.E2StubSubsReqParams{}
2210 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
2211 xappConn2.SendSubsReq(t, rparams2, nil)
2212 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
2214 //Req1 (retransmitted)
2215 e2termConn1.RecvSubsReq(t)
2217 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
2218 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
2220 //Wait that subs is cleaned
2221 mainCtrl.wait_subs_clean(t, delreq1.RequestId.InstanceId, 10)
2223 xappConn1.TestMsgChanEmpty(t)
2224 xappConn2.TestMsgChanEmpty(t)
2225 e2termConn1.TestMsgChanEmpty(t)
2226 mainCtrl.wait_registry_empty(t, 15)
2229 //----------------------------- Policy cases ---------------------------------
2230 //-----------------------------------------------------------------------------
2231 // TestSubReqPolicyAndSubDelOk
2234 // +-------+ +---------+ +---------+
2235 // | xapp | | submgr | | e2term |
2236 // +-------+ +---------+ +---------+
2239 // |------------->| |
2242 // | |------------->|
2245 // | |<-------------|
2248 // |<-------------| |
2252 // |------------->| |
2255 // | |------------->|
2258 // | |<-------------|
2261 // |<-------------| |
2263 //-----------------------------------------------------------------------------
2264 func TestSubReqPolicyAndSubDelOk(t *testing.T) {
2265 CaseBegin("TestSubReqAndSubDelOk")
2267 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2269 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
2270 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
2272 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2273 e2termConn1.SendSubsResp(t, crereq, cremsg)
2274 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2275 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2276 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2278 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2279 xappConn1.RecvSubsDelResp(t, deltrans)
2281 //Wait that subs is cleaned
2282 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2284 xappConn1.TestMsgChanEmpty(t)
2285 xappConn2.TestMsgChanEmpty(t)
2286 e2termConn1.TestMsgChanEmpty(t)
2287 mainCtrl.wait_registry_empty(t, 10)
2290 //-----------------------------------------------------------------------------
2291 // TestSubReqPolicyChangeAndSubDelOk
2294 // +-------+ +---------+ +---------+
2295 // | xapp | | submgr | | e2term |
2296 // +-------+ +---------+ +---------+
2299 // |------------->| |
2302 // | |------------->|
2305 // | |<-------------|
2308 // |<-------------| |
2311 // |------------->| |
2314 // | |------------->|
2317 // | |<-------------|
2320 // |<-------------| |
2323 // |------------->| |
2326 // | |------------->|
2329 // | |<-------------|
2332 // |<-------------| |
2334 //-----------------------------------------------------------------------------
2336 func TestSubReqPolicyChangeAndSubDelOk(t *testing.T) {
2337 CaseBegin("TestSubReqAndSubDelOk")
2339 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2341 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
2342 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
2344 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2345 e2termConn1.SendSubsResp(t, crereq, cremsg)
2346 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2349 rparams1.Req.RequestId.InstanceId = e2SubsId
2350 rparams1.Req.ActionSetups[0].SubsequentAction.TimetoWait = e2ap.E2AP_TimeToWaitW200ms
2351 xappConn1.SendSubsReq(t, rparams1, cretrans)
2353 crereq, cremsg = e2termConn1.RecvSubsReq(t)
2354 e2termConn1.SendSubsResp(t, crereq, cremsg)
2355 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
2356 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2357 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2359 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2360 xappConn1.RecvSubsDelResp(t, deltrans)
2362 //Wait that subs is cleaned
2363 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2365 xappConn1.TestMsgChanEmpty(t)
2366 xappConn2.TestMsgChanEmpty(t)
2367 e2termConn1.TestMsgChanEmpty(t)
2368 mainCtrl.wait_registry_empty(t, 10)
2371 //-----------------------------------------------------------------------------
2372 // TestSubReqAndSubDelOkTwoE2termParallel
2375 // +-------+ +---------+ +---------+ +---------+
2376 // | xapp | | submgr | | e2term1 | | e2term2 |
2377 // +-------+ +---------+ +---------+ +---------+
2382 // |------------->| | |
2385 // | |------------->| |
2388 // |------------->| | |
2391 // | |---------------------------->|
2394 // | |<-------------| |
2396 // |<-------------| | |
2398 // | |<----------------------------|
2400 // |<-------------| | |
2402 // | [SUBS 1 DELETE] | |
2404 // | [SUBS 2 DELETE] | |
2407 //-----------------------------------------------------------------------------
2408 func TestSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
2409 CaseBegin("TestSubReqAndSubDelOkTwoE2termParallel")
2412 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
2413 xappConn1.SendSubsReq(t, nil, cretrans1)
2414 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2416 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_11")
2417 xappConn1.SendSubsReq(t, nil, cretrans2)
2418 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
2421 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2422 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
2425 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
2426 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
2429 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
2430 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
2431 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
2432 xappConn1.RecvSubsDelResp(t, deltrans1)
2433 //Wait that subs is cleaned
2434 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
2437 deltrans2 := xappConn1.SendSubsDelReq(t, nil, e2SubsId2)
2438 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
2439 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
2440 xappConn1.RecvSubsDelResp(t, deltrans2)
2441 //Wait that subs is cleaned
2442 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
2444 xappConn1.TestMsgChanEmpty(t)
2445 xappConn2.TestMsgChanEmpty(t)
2446 e2termConn1.TestMsgChanEmpty(t)
2447 e2termConn2.TestMsgChanEmpty(t)
2448 mainCtrl.wait_registry_empty(t, 10)
2451 //-----------------------------------------------------------------------------
2452 // TestSubReqInsertAndSubDelOk
2455 // +-------+ +---------+ +---------+
2456 // | xapp | | submgr | | e2term |
2457 // +-------+ +---------+ +---------+
2460 // |------------->| |
2463 // | |------------->|
2466 // | |<-------------|
2469 // |<-------------| |
2473 // |------------->| |
2476 // | |------------->|
2479 // | |<-------------|
2482 // |<-------------| |
2484 //-----------------------------------------------------------------------------
2485 func TestSubReqInsertAndSubDelOk(t *testing.T) {
2486 CaseBegin("TestInsertSubReqAndSubDelOk")
2488 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2490 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypeInsert
2491 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
2493 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2494 e2termConn1.SendSubsResp(t, crereq, cremsg)
2495 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2496 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2497 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2499 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2500 xappConn1.RecvSubsDelResp(t, deltrans)
2502 //Wait that subs is cleaned
2503 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2505 xappConn1.TestMsgChanEmpty(t)
2506 xappConn2.TestMsgChanEmpty(t)
2507 e2termConn1.TestMsgChanEmpty(t)
2508 mainCtrl.wait_registry_empty(t, 10)
2511 //-----------------------------------------------------------------------------
2512 // TestSubReqRetransmissionWithSameSubIdDiffXid
2514 // This case simulates case where xApp restarts and starts sending same
2515 // subscription requests which have already subscribed successfully
2518 // +-------+ +---------+ +---------+
2519 // | xapp | | submgr | | e2term |
2520 // +-------+ +---------+ +---------+
2523 // |------------->| |
2526 // | |------------->|
2529 // | |<-------------|
2532 // |<-------------| |
2534 // | xApp restart | |
2537 // | (retrans with same xApp generated subid but diff xid)
2538 // |------------->| |
2541 // |<-------------| |
2543 // | [SUBS DELETE] |
2546 //-----------------------------------------------------------------------------
2547 func TestSubReqRetransmissionWithSameSubIdDiffXid(t *testing.T) {
2548 CaseBegin("TestSubReqRetransmissionWithSameSubIdDiffXid")
2551 cretrans := xappConn1.SendSubsReq(t, nil, nil)
2552 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2553 e2termConn1.SendSubsResp(t, crereq, cremsg)
2554 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2556 // xApp restart here
2557 // --> artificial delay
2558 <-time.After(1 * time.Second)
2561 cretrans = xappConn1.SendSubsReq(t, nil, nil) //Retransmitted SubReq
2562 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
2565 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2566 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2567 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2568 xappConn1.RecvSubsDelResp(t, deltrans)
2570 //Wait that subs is cleaned
2571 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2573 xappConn1.TestMsgChanEmpty(t)
2574 xappConn2.TestMsgChanEmpty(t)
2575 e2termConn1.TestMsgChanEmpty(t)
2576 mainCtrl.wait_registry_empty(t, 10)
2579 //-----------------------------------------------------------------------------
2580 // TestSubReqNokAndSubDelOkWithRestartInMiddle
2583 // +-------+ +---------+ +---------+
2584 // | xapp | | submgr | | e2term |
2585 // +-------+ +---------+ +---------+
2588 // |------------->| |
2591 // | |------------->|
2596 // | Submgr restart |
2600 // | |------------->|
2603 // | |<-------------|
2606 //-----------------------------------------------------------------------------
2608 func TestSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
2609 CaseBegin("TestSubReqNokAndSubDelOkWithRestartInMiddle")
2611 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
2612 xappConn1.SendSubsReq(t, nil, nil)
2613 e2termConn1.RecvSubsReq(t)
2614 mainCtrl.SetResetTestFlag(t, false)
2616 resp, _ := xapp.Subscription.QuerySubscriptions()
2617 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2618 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2619 e2SubsId := uint32(resp[0].SubscriptionID)
2620 t.Logf("e2SubsId = %v", e2SubsId)
2622 mainCtrl.SimulateRestart(t)
2623 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2625 // Submgr send delete for uncompleted subscription
2626 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2627 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2629 // Wait that subs is cleaned
2630 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2632 xappConn1.TestMsgChanEmpty(t)
2633 xappConn2.TestMsgChanEmpty(t)
2634 e2termConn1.TestMsgChanEmpty(t)
2635 mainCtrl.wait_registry_empty(t, 10)
2638 //-----------------------------------------------------------------------------
2639 // TestSubReqAndSubDelOkWithRestartInMiddle
2642 // +-------+ +---------+ +---------+
2643 // | xapp | | submgr | | e2term |
2644 // +-------+ +---------+ +---------+
2647 // |------------->| |
2650 // | |------------->|
2653 // | |<-------------|
2656 // |<-------------| |
2659 // | Submgr restart |
2662 // |------------->| |
2665 // | |------------->|
2668 // | |<-------------|
2671 // |<-------------| |
2673 //-----------------------------------------------------------------------------
2675 func TestSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
2676 CaseBegin("TestSubReqAndSubDelOkWithRestartInMiddle")
2678 cretrans := xappConn1.SendSubsReq(t, nil, nil)
2679 crereq, cremsg := e2termConn1.RecvSubsReq(t)
2680 e2termConn1.SendSubsResp(t, crereq, cremsg)
2681 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
2683 // Check subscription
2684 resp, _ := xapp.Subscription.QuerySubscriptions()
2685 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
2686 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2687 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
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 // That needs to be completed before successful subscription query is possible
2694 <-time.After(time.Second * 1)
2696 // Check that subscription is restored correctly after restart
2697 resp, _ = xapp.Subscription.QuerySubscriptions()
2698 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
2699 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2700 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560"})
2702 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
2703 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2704 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2705 xappConn1.RecvSubsDelResp(t, deltrans)
2707 //Wait that subs is cleaned
2708 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
2710 xappConn1.TestMsgChanEmpty(t)
2711 xappConn2.TestMsgChanEmpty(t)
2712 e2termConn1.TestMsgChanEmpty(t)
2713 mainCtrl.wait_registry_empty(t, 10)
2716 //-----------------------------------------------------------------------------
2717 // TestSubReqAndSubDelOkSameActionWithRestartsInMiddle
2720 // +-------+ +-------+ +---------+ +---------+
2721 // | xapp2 | | xapp1 | | submgr | | e2term |
2722 // +-------+ +-------+ +---------+ +---------+
2727 // | |------------->| |
2730 // | | |------------->|
2732 // | | |<-------------|
2734 // | |<-------------| |
2737 // | submgr restart |
2742 // |--------------------------->| |
2745 // |<---------------------------| |
2747 // | | SubDelReq 1 | |
2748 // | |------------->| |
2750 // | | SubDelResp 1 | |
2751 // | |<-------------| |
2755 // | submgr restart |
2758 // | SubDelReq 2 | |
2759 // |--------------------------->| |
2761 // | | | SubDelReq 2 |
2762 // | | |------------->|
2764 // | | | SubDelReq 2 |
2765 // | | |------------->|
2767 // | SubDelResp 2 | |
2768 // |<---------------------------| |
2770 //-----------------------------------------------------------------------------
2772 func TestSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
2773 CaseBegin("TestSubReqAndSubDelOkSameActionWithRestartsInMiddle")
2776 rparams1 := &teststube2ap.E2StubSubsReqParams{}
2778 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
2779 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2780 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2781 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
2784 rparams2 := &teststube2ap.E2StubSubsReqParams{}
2786 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
2787 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
2789 // Check subscription
2790 resp, _ := xapp.Subscription.QuerySubscriptions()
2791 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
2792 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2793 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
2795 mainCtrl.SimulateRestart(t)
2796 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2798 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
2799 // That needs to be completed before successful subscription query is possible
2800 <-time.After(time.Second * 1)
2802 // Check that subscription is restored correctly after restart
2803 resp, _ = xapp.Subscription.QuerySubscriptions()
2804 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
2805 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
2806 assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
2809 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
2810 xapp.Logger.Debug("xappConn1.RecvSubsDelResp")
2811 xappConn1.RecvSubsDelResp(t, deltrans1)
2812 xapp.Logger.Debug("xappConn1.RecvSubsDelResp received")
2814 mainCtrl.SimulateRestart(t)
2815 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
2817 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
2818 // Submgr need be ready before successful subscription deletion is possible
2819 <-time.After(time.Second * 1)
2822 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
2823 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
2825 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
2826 xappConn2.RecvSubsDelResp(t, deltrans2)
2828 //Wait that subs is cleaned
2829 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
2831 xappConn1.TestMsgChanEmpty(t)
2832 xappConn2.TestMsgChanEmpty(t)
2833 e2termConn1.TestMsgChanEmpty(t)
2834 mainCtrl.wait_registry_empty(t, 10)
2837 //*****************************************************************************
2838 // REST interface test cases
2839 //*****************************************************************************
2841 //-----------------------------------------------------------------------------
2842 // Test debug GET and POST requests
2845 // +-------+ +---------+
2846 // | user | | submgr |
2847 // +-------+ +---------+
2854 func TestGetSubscriptions(t *testing.T) {
2856 mainCtrl.SendGetRequest(t, "localhost:8088", "/ric/v1/subscriptions")
2859 func TestGetSymptomData(t *testing.T) {
2861 mainCtrl.SendGetRequest(t, "localhost:8080", "/ric/v1/symptomdata")
2864 func TestPostdeleteSubId(t *testing.T) {
2866 mainCtrl.SendPostRequest(t, "localhost:8080", "/ric/v1/test/deletesubid=1")
2869 func TestPostEmptyDb(t *testing.T) {
2871 mainCtrl.SendPostRequest(t, "localhost:8080", "/ric/v1/test/emptydb")
2874 func TestGetRestSubscriptions(t *testing.T) {
2876 mainCtrl.SendGetRequest(t, "localhost:8080", "/ric/v1/restsubscriptions")
2879 //-----------------------------------------------------------------------------
2880 // TestDelAllE2nodeSubsViaDebugIf
2883 // +-------+ +---------+ +---------+ +---------+
2884 // | xapp | | submgr | | e2term | | rtmgr |
2885 // +-------+ +---------+ +---------+ +---------+
2887 // | RESTSubReq | | |
2888 // |---------------->| | |
2889 // | RESTSubResp | | |
2890 // |<----------------| | |
2891 // | | RouteCreate | |
2892 // | |--------------------------->|
2893 // | | RouteResponse| |
2894 // | |<---------------------------|
2896 // | |------------->| |
2898 // | |<-------------| |
2899 // | RESTNotif1 | | |
2900 // |<----------------| | |
2902 // | REST get_all_e2nodes | |
2903 // |---------------->| | |
2905 // |<----------------| | |
2906 // | REST delete_all_e2node_subscriptions | ranName = RAN_NAME_1
2907 // |---------------->| | |
2909 // |<----------------| | |
2910 // | | SubDelReq | |
2911 // | |------------->| |
2912 // | | SubDelResp | |
2913 // | |<-------------| |
2915 // | | RouteDelete | |
2916 // | |--------------------------->|
2917 // | | RouteResponse| |
2918 // | |<---------------------------|
2920 //-----------------------------------------------------------------------------
2922 func TestDelAllE2nodeSubsViaDebugIf(t *testing.T) {
2924 // Init counter check
2925 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
2926 Counter{cRestSubReqFromXapp, 1},
2927 Counter{cRestSubRespToXapp, 1},
2928 Counter{cSubReqToE2, 1},
2929 Counter{cSubRespFromE2, 1},
2930 Counter{cRestSubNotifToXapp, 1},
2931 Counter{cRestSubDelReqFromXapp, 1},
2932 Counter{cSubDelReqToE2, 1},
2933 Counter{cSubDelRespFromE2, 1},
2934 Counter{cRestSubDelRespToXapp, 1},
2937 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
2938 restSubId := xappConn1.SendRESTSubsReq(t, params)
2939 xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
2941 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
2942 xappConn1.ExpectRESTNotification(t, restSubId)
2943 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
2944 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
2945 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
2947 e2nodesJson := mainCtrl.SendGetRequest(t, "localhost:8080", "/ric/v1/get_all_e2nodes")
2949 var e2nodesList []string
2950 err := json.Unmarshal(e2nodesJson, &e2nodesList)
2952 t.Errorf("Unmarshal error: %s", err)
2954 assert.Equal(t, true, mainCtrl.VerifyStringExistInSlice("RAN_NAME_1", e2nodesList))
2956 e2RestSubsJson := mainCtrl.SendGetRequest(t, "localhost:8080", "/ric/v1/get_e2node_rest_subscriptions/RAN_NAME_1") // RAN_NAME_1 = ranName
2957 var e2RestSubsMap map[string]RESTSubscription
2958 err = json.Unmarshal(e2RestSubsJson, &e2RestSubsMap)
2960 t.Errorf("Unmarshal error: %s", err)
2963 if len(e2RestSubsMap) != 1 {
2964 t.Errorf("Incorrect e2RestSubsMap length %v", len(e2RestSubsMap))
2967 // Simulate deletion through REST test and debug interface
2968 mainCtrl.SendDeleteRequest(t, "localhost:8080", "/ric/v1/delete_all_e2node_subscriptions/RAN_NAME_1") // RAN_NAME_1 = ranName
2969 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
2970 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
2972 // Wait that subs is cleaned
2973 waitSubsCleanup(t, e2SubsId, 10)
2974 mainCtrl.VerifyCounterValues(t)
2975 mainCtrl.VerifyAllClean(t)
2978 //-----------------------------------------------------------------------------
2979 // TestDelAllxAppSubsViaDebugIf
2982 // +-------+ +---------+ +---------+ +---------+
2983 // | xapp | | submgr | | e2term | | rtmgr |
2984 // +-------+ +---------+ +---------+ +---------+
2986 // | RESTSubReq | | |
2987 // |---------------->| | |
2988 // | RESTSubResp | | |
2989 // |<----------------| | |
2990 // | | RouteCreate | |
2991 // | |--------------------------->|
2992 // | | RouteResponse| |
2993 // | |<---------------------------|
2995 // | |------------->| |
2997 // | |<-------------| |
2998 // | RESTNotif1 | | |
2999 // |<----------------| | |
3001 // | REST get_all_xapps | |
3002 // |---------------->| | |
3004 // |<----------------| | |
3005 // | REST delete_all_xapp_subscriptions | xappServiceName = localhost
3006 // |---------------->| | |
3008 // |<----------------| | |
3009 // | | SubDelReq | |
3010 // | |------------->| |
3011 // | | SubDelResp | |
3012 // | |<-------------| |
3014 // | | RouteDelete | |
3015 // | |--------------------------->|
3016 // | | RouteResponse| |
3017 // | |<---------------------------|
3019 //-----------------------------------------------------------------------------
3021 func TestDelAllxAppSubsViaDebugIf(t *testing.T) {
3023 // Init counter check
3024 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3025 Counter{cRestSubReqFromXapp, 1},
3026 Counter{cRestSubRespToXapp, 1},
3027 Counter{cSubReqToE2, 1},
3028 Counter{cSubRespFromE2, 1},
3029 Counter{cRestSubNotifToXapp, 1},
3030 Counter{cRestSubDelReqFromXapp, 1},
3031 Counter{cSubDelReqToE2, 1},
3032 Counter{cSubDelRespFromE2, 1},
3033 Counter{cRestSubDelRespToXapp, 1},
3036 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3037 restSubId := xappConn1.SendRESTSubsReq(t, params)
3038 xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
3040 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3041 xappConn1.ExpectRESTNotification(t, restSubId)
3042 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
3043 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3044 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
3046 xappsJson := mainCtrl.SendGetRequest(t, "localhost:8080", "/ric/v1/get_all_xapps")
3048 var xappList []string
3049 err := json.Unmarshal(xappsJson, &xappList)
3051 t.Errorf("Unmarshal error: %s", err)
3053 assert.Equal(t, true, mainCtrl.VerifyStringExistInSlice("localhost", xappList))
3055 // Simulate deletion through REST test and debug interface
3056 mainCtrl.SendDeleteRequest(t, "localhost:8080", "/ric/v1/delete_all_xapp_subscriptions/localhost") // localhost = xappServiceName
3057 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3058 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3060 // Wait that subs is cleaned
3061 waitSubsCleanup(t, e2SubsId, 10)
3062 mainCtrl.VerifyCounterValues(t)
3063 mainCtrl.VerifyAllClean(t)
3066 //-----------------------------------------------------------------------------
3067 // TestDelViaxAppSubsIf
3070 // +-------+ +---------+ +---------+ +---------+
3071 // | xapp | | submgr | | e2term | | rtmgr |
3072 // +-------+ +---------+ +---------+ +---------+
3074 // | RESTSubReq | | |
3075 // |---------------->| | |
3076 // | RESTSubResp | | |
3077 // |<----------------| | |
3078 // | | RouteCreate | |
3079 // | |--------------------------->|
3080 // | | RouteResponse| |
3081 // | |<---------------------------|
3083 // | |------------->| |
3085 // | |<-------------| |
3086 // | RESTNotif1 | | |
3087 // |<----------------| | |
3089 // | REST get_xapp_rest_restsubscriptions |
3090 // |---------------->| | |
3092 // |<----------------| | |
3093 // | RESTSudDel | | |
3094 // |---------------->| | | Via user curl command (port 8088)
3095 // | RESTSudDel | | |
3096 // |<----------------| | |
3097 // | | SubDelReq | |
3098 // | |------------->| |
3099 // | | SubDelResp | |
3100 // | |<-------------| |
3102 // | | RouteDelete | |
3103 // | |--------------------------->|
3104 // | | RouteResponse| |
3105 // | |<---------------------------|
3107 //-----------------------------------------------------------------------------
3109 func TestDelViaxAppSubsIf(t *testing.T) {
3111 // Init counter check
3112 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3113 Counter{cRestSubReqFromXapp, 1},
3114 Counter{cRestSubRespToXapp, 1},
3115 Counter{cSubReqToE2, 1},
3116 Counter{cSubRespFromE2, 1},
3117 Counter{cRestSubNotifToXapp, 1},
3118 Counter{cRestSubDelReqFromXapp, 1},
3119 Counter{cSubDelReqToE2, 1},
3120 Counter{cSubDelRespFromE2, 1},
3121 Counter{cRestSubDelRespToXapp, 1},
3124 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3125 restSubId := xappConn1.SendRESTSubsReq(t, params)
3126 xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
3128 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
3129 xappConn1.ExpectRESTNotification(t, restSubId)
3130 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
3131 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3132 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
3134 restSubsListJson := mainCtrl.SendGetRequest(t, "localhost:8080", "/ric/v1/get_xapp_rest_restsubscriptions/localhost") // localhost = xappServiceName
3136 var restSubsMap map[string]RESTSubscription
3137 err := json.Unmarshal(restSubsListJson, &restSubsMap)
3139 t.Errorf("Unmarshal error: %s", err)
3141 _, ok := restSubsMap[restSubId]
3143 t.Errorf("REST subscription not found. restSubId=%s", restSubId)
3146 var e2Subscriptions []Subscription
3147 e2SubscriptionsJson := mainCtrl.SendGetRequest(t, "localhost:8080", "/ric/v1/get_e2subscriptions/"+restSubId)
3148 err = json.Unmarshal(e2SubscriptionsJson, &e2Subscriptions)
3150 t.Errorf("Unmarshal error: %s", err)
3152 if len(e2Subscriptions) != 1 {
3153 t.Errorf("Incorrect e2Subscriptions length %v", len(e2Subscriptions))
3156 // Simulate deletion through xapp REST test interface
3157 mainCtrl.SendDeleteRequest(t, "localhost:8088", "/ric/v1/subscriptions/"+restSubId)
3158 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3159 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3161 // Wait that subs is cleaned
3162 waitSubsCleanup(t, e2SubsId, 10)
3163 mainCtrl.VerifyCounterValues(t)
3164 mainCtrl.VerifyAllClean(t)
3167 //-----------------------------------------------------------------------------
3168 // TestRESTSubReqAndRouteNok
3171 // +-------+ +---------+ +---------+
3172 // | xapp | | submgr | | rtmgr |
3173 // +-------+ +---------+ +---------+
3176 // |---------------->| |
3178 // | RESTSubResp | |
3179 // |<----------------| |
3180 // | | RouteCreate |
3181 // | |------------->|
3182 // | | RouteCreate |
3184 // | |(Bad request) |
3185 // | |<-------------|
3187 // |<----------------| |
3189 // | [SUBS INT DELETE] |
3191 // | RESTSubDelReq | |
3192 // |---------------->| |
3193 // | RESTSubDelResp | |
3194 // |<----------------| |
3196 //-----------------------------------------------------------------------------
3197 func TestRESTSubReqAndRouteNok(t *testing.T) {
3199 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3200 Counter{cRestSubReqFromXapp, 1},
3201 Counter{cRestSubRespToXapp, 1},
3202 Counter{cRouteCreateFail, 1},
3203 Counter{cRestSubFailNotifToXapp, 1},
3204 Counter{cRestSubDelReqFromXapp, 1},
3205 Counter{cRestSubDelRespToXapp, 1},
3208 const subReqCount int = 1
3210 // Add delay for rtmgt HTTP handling so that HTTP response is received before notify on XAPP side
3211 waiter := rtmgrHttp.AllocNextSleep(50, false)
3212 newSubsId := mainCtrl.get_registry_next_subid(t)
3215 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3216 restSubId := xappConn1.SendRESTSubsReq(t, params)
3217 xappConn1.ExpectRESTNotificationNok(t, restSubId, "failAll")
3218 waiter.WaitResult(t)
3220 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
3221 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
3224 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3226 // Wait that subs is cleaned
3227 mainCtrl.wait_subs_clean(t, newSubsId, 10)
3228 waitSubsCleanup(t, e2SubsId, 10)
3229 mainCtrl.VerifyCounterValues(t)
3230 mainCtrl.VerifyAllClean(t)
3233 //-----------------------------------------------------------------------------
3234 // TestRESTSubReqAndRouteUpdateNok
3236 // stub stub stub stub
3237 // +-------+ +-------+ +---------+ +---------+ +---------+
3238 // | xapp1 | | xapp2 | | submgr | | rtmgr | | e2term |
3239 // +-------+ +-------+ +---------+ +---------+ +---------+
3241 // | RESTSubReq1 | | |
3242 // |------------------------>| | |
3243 // | RESTSubResp2 | | |
3244 // |<------------------------| | |
3246 // | | | RouteCreate | |
3247 // | | |------------->| |
3248 // | | | CreateResp | |
3249 // | | |<-------------| |
3251 // | | |---------------------------->|
3252 // | | | SubResp | |
3253 // | | |<----------------------------|
3254 // | RESTNotif1 | | |
3255 // |<------------------------| | |
3257 // | | RESTSubReq2 | | |
3258 // | |------------>| | |
3259 // | | RESTSubResp2| | |
3260 // | |<------------| | |
3261 // | | | RouteUpdate | |
3262 // | | |------------->| |
3263 // | | | RouteUpdate | |
3264 // | | | status:400 | |
3265 // | | |(Bad request) | |
3266 // | | |<-------------| |
3267 // | | RESTNotif2(unsuccessful) | |
3268 // | |<------------| | |
3270 // | [SUBS INT DELETE] | |
3272 // | RESTSubDelReq1 | | |
3273 // |------------------------>| | |
3274 // | RESTSubDelResp1 | | |
3275 // |<------------------------| | |
3277 // | | | [SUBS DELETE] |
3279 //-----------------------------------------------------------------------------
3280 func TestRESTSubReqAndRouteUpdateNok(t *testing.T) {
3282 //Init counter check
3283 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3284 Counter{cRestSubReqFromXapp, 2},
3285 Counter{cRestSubRespToXapp, 2},
3286 Counter{cSubReqToE2, 1},
3287 Counter{cSubRespFromE2, 1},
3288 Counter{cRestSubNotifToXapp, 1},
3289 Counter{cRestSubFailNotifToXapp, 1},
3290 Counter{cRouteCreateUpdateFail, 1},
3291 Counter{cRestSubDelReqFromXapp, 2},
3292 Counter{cSubDelReqToE2, 1},
3293 Counter{cSubDelRespFromE2, 1},
3294 Counter{cRestSubDelRespToXapp, 2},
3297 var params *teststube2ap.RESTSubsReqParams = nil
3299 // Subs create for xapp1
3300 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3302 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3304 // xapp2 ROUTE creation shall fail with 400 from rtmgr -> submgr
3305 waiter := rtmgrHttp.AllocNextEvent(false)
3306 newSubsId := mainCtrl.get_registry_next_subid(t)
3307 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
3308 params.SetMeid("RAN_NAME_1")
3309 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
3310 xapp.Logger.Debug("Send REST subscriber request for second subscriber : %v", restSubId2)
3311 xappConn2.ExpectRESTNotificationNok(t, restSubId2, "allFail")
3312 waiter.WaitResult(t)
3313 xappConn2.WaitRESTNotification(t, restSubId2)
3315 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3317 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3318 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
3320 mainCtrl.wait_subs_clean(t, newSubsId, 10)
3321 //Wait that subs is cleaned
3322 waitSubsCleanup(t, e2SubsId, 10)
3324 mainCtrl.VerifyCounterValues(t)
3325 mainCtrl.VerifyAllClean(t)
3328 //-----------------------------------------------------------------------------
3329 // TestRESTSubDelReqAndRouteDeleteNok
3332 // +-------+ +---------+ +---------+ +---------+
3333 // | xapp | | submgr | | rtmgr | | e2term |
3334 // +-------+ +---------+ +---------+ +---------+
3336 // | RESTSubReq | | |
3337 // |---------------->| | |
3339 // | RESTSubResp | | |
3340 // |<----------------| | |
3342 // | |---------------------------->|
3344 // | |<----------------------------|
3345 // | RESTNotif | | |
3346 // |<----------------| | |
3349 // | RESTSubDelReq | | |
3350 // |---------------->| | |
3351 // | RESTSubDelResp | | |
3352 // |<----------------| | |
3353 // | | SubSelReq | |
3354 // | |---------------------------->|
3355 // | | SubSelResp | |
3356 // | |<----------------------------|
3357 // | | RouteDelete | |
3358 // | |------------->| |
3359 // | | Routedelete | |
3360 // | | status:400 | |
3361 // | |(Bad request) | |
3362 // | |<-------------| |
3364 //-----------------------------------------------------------------------------
3366 func TestRESTSubDelReqAndRouteDeleteNok(t *testing.T) {
3368 // Init counter check
3369 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3370 Counter{cRestSubReqFromXapp, 1},
3371 Counter{cRestSubRespToXapp, 1},
3372 Counter{cSubReqToE2, 1},
3373 Counter{cSubRespFromE2, 1},
3374 Counter{cRestSubNotifToXapp, 1},
3375 Counter{cRestSubDelReqFromXapp, 1},
3376 Counter{cRouteDeleteFail, 1},
3377 Counter{cSubDelReqToE2, 1},
3378 Counter{cSubDelRespFromE2, 1},
3379 Counter{cRestSubDelRespToXapp, 1},
3382 var params *teststube2ap.RESTSubsReqParams = nil
3385 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3387 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3389 waiter := rtmgrHttp.AllocNextEvent(false)
3390 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3391 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
3392 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
3393 waiter.WaitResult(t)
3395 waitSubsCleanup(t, e2SubsId, 10)
3396 mainCtrl.VerifyCounterValues(t)
3397 mainCtrl.VerifyAllClean(t)
3400 //-----------------------------------------------------------------------------
3401 // TestRESTSubMergeDelAndRouteUpdateNok
3403 // stub stub stub stub
3404 // +-------+ +-------+ +---------+ +---------+ +---------+
3405 // | xapp1 | | xapp2 | | submgr | | rtmgr | | e2term |
3406 // +-------+ +-------+ +---------+ +---------+ +---------+
3408 // | RESTSubReq1 | | |
3409 // |------------------------>| | |
3410 // | RESTSubResp2 | | |
3411 // |<------------------------| | |
3413 // | | | RouteCreate | |
3414 // | | |------------->| |
3415 // | | | CreateResp | |
3416 // | | |<-------------| |
3418 // | | |---------------------------->|
3419 // | | | SubResp | |
3420 // | | |<----------------------------|
3421 // | RESTNotif1 | | |
3422 // |<------------------------| | |
3424 // | | RESTSubReq2 | | |
3425 // | |------------>| | |
3426 // | | RESTSubResp2| | |
3427 // | |<------------| | |
3428 // | | | RouteCreate | |
3429 // | | |------------->| |
3430 // | | | CreateResp | |
3431 // | | |<-------------| |
3433 // | | |---------------------------->|
3434 // | | | SubResp | |
3435 // | | |<----------------------------|
3436 // | | RESTNotif2 | | |
3437 // | |<------------| | |
3439 // | [SUBS INT DELETE] | |
3441 // | RESTSubDelReq1 | | |
3442 // |------------------------>| | |
3443 // | RESTSubDelResp1 | | |
3444 // |<------------------------| | |
3445 // | | | SubDelReq | |
3446 // | | |---------------------------->|
3447 // | | | SubDelResp | |
3448 // | | |<----------------------------|
3449 // | | | RouteUpdate | |
3450 // | | |------------->| |
3451 // | | | RouteUpdate | |
3452 // | | | status:400 | |
3453 // | | |(Bad request) | |
3454 // | | |<-------------| |
3456 // | | RESTSubDelReq2 | |
3457 // | |------------>| | |
3458 // | | RESTSubDelResp2 | |
3459 // | |<------------| | |
3460 // | | | SubDelReq | |
3461 // | | |---------------------------->|
3462 // | | | SubdelResp | |
3463 // | | |<----------------------------|
3464 // | | | RouteDelete | |
3465 // | | |------------->| |
3466 // | | | Deleteresp | |
3467 // | | |<-------------| |
3469 //-----------------------------------------------------------------------------
3471 func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) {
3473 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3474 Counter{cRestSubReqFromXapp, 2},
3475 Counter{cMergedSubscriptions, 1},
3476 Counter{cRestSubRespToXapp, 2},
3477 Counter{cSubReqToE2, 1},
3478 Counter{cSubRespFromE2, 1},
3479 Counter{cRestSubNotifToXapp, 2},
3480 Counter{cRestSubDelReqFromXapp, 2},
3481 Counter{cRouteDeleteUpdateFail, 1},
3482 Counter{cSubDelReqToE2, 1},
3483 Counter{cSubDelRespFromE2, 1},
3484 Counter{cRestSubDelRespToXapp, 2},
3485 Counter{cUnmergedSubscriptions, 1},
3488 var params *teststube2ap.RESTSubsReqParams = nil
3491 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3493 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3494 restSubId2, e2SubsId2 := createXapp2MergedSubscription(t, "RAN_NAME_1")
3496 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
3498 //Del1, this shall fail on rtmgr side
3499 waiter := rtmgrHttp.AllocNextEvent(false)
3500 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3501 waiter.WaitResult(t)
3503 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13660"})
3506 deleteXapp2Subscription(t, &restSubId2)
3508 waitSubsCleanup(t, e2SubsId2, 10)
3509 mainCtrl.VerifyCounterValues(t)
3510 mainCtrl.VerifyAllClean(t)
3513 //-----------------------------------------------------------------------------
3514 // TestRESTSubReqRetransmission
3517 // +-------+ +---------+ +---------+
3518 // | xapp | | submgr | | e2term |
3519 // +-------+ +---------+ +---------+
3521 // | RESTSubReq1 | |
3522 // |---------------->| |
3524 // | RESTSubResp | |
3525 // |<----------------| |
3527 // | |------------->|
3529 // | RESTSubReq2 | |
3531 // |---------------->| |
3532 // | RESTSubResp(201)| |
3533 // |<----------------| |
3536 // | |<-------------|
3538 // |<----------------| |
3540 // | [SUBS DELETE] |
3543 //-----------------------------------------------------------------------------
3545 func TestRESTSubReqRetransmission(t *testing.T) {
3547 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3548 Counter{cRestSubReqFromXapp, 2},
3549 Counter{cRestSubRespToXapp, 2},
3550 Counter{cSubReqToE2, 1},
3551 Counter{cSubRespFromE2, 1},
3552 Counter{cRestSubNotifToXapp, 1},
3553 Counter{cRestSubDelReqFromXapp, 1},
3554 Counter{cSubDelReqToE2, 1},
3555 Counter{cSubDelRespFromE2, 1},
3556 Counter{cRestSubDelRespToXapp, 1},
3558 // Retry/duplicate will get the same way as the first request.
3559 // Contianed duplicate messages from same xapp will not be merged. Here we use xappConn2 to simulate sending
3560 // second request from same xapp as doing it from xappConn1 would not work as notification would not be received
3563 const subReqCount int = 1
3565 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3566 restSubId := xappConn1.SendRESTSubsReq(t, params)
3568 xappConn1.SendRESTSubsReq(t, params)
3569 <-time.After(time.Second * 1)
3571 xappConn1.WaitListedRestNotifications(t, []string{restSubId})
3573 // Depending one goroutine scheduling order, we cannot say for sure which xapp reaches e2term first. Thus
3574 // the order is not significant here.
3575 crereq, cremsg := e2termConn1.RecvSubsReq(t)
3576 e2termConn1.SendSubsResp(t, crereq, cremsg)
3578 e2SubsId := <-xappConn1.ListedRESTNotifications
3580 xapp.Logger.Debug("TEST: XAPP notification received e2SubsId=%v", e2SubsId)
3583 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3584 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
3585 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
3587 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsId.E2SubsId}, 10)
3589 mainCtrl.VerifyCounterValues(t)
3590 mainCtrl.VerifyAllClean(t)
3593 //-----------------------------------------------------------------------------
3595 // +-------+ +---------+ +---------+ +---------+
3596 // | xapp | | submgr | | e2term | | rtmgr |
3597 // +-------+ +---------+ +---------+ +---------+
3599 // | RESTSubReq | | |
3600 // |---------------->| | |
3601 // | RESTSubResp | | |
3602 // |<----------------| | |
3603 // | | RouteCreate | |
3604 // | |--------------------------->|
3605 // | | RouteResponse| |
3606 // | |<---------------------------| // The order of these events may vary
3608 // | |------------->| | // The order of these events may vary
3610 // | |<-------------| |
3611 // | RESTNotif1 | | |
3612 // |<----------------| | |
3613 // | RESTSubReq | | |
3614 // | [RETRANS1] | | |
3615 // |---------------->| | |
3616 // | RESTNotif1 | | |
3617 // |<----------------| | |
3618 // | RESTSubReq | | |
3619 // | [RETRANS2] | | |
3620 // |---------------->| | |
3621 // | RESTNotif1 | | |
3622 // |<----------------| | |
3623 // | RESTSubDelReq | | |
3624 // |---------------->| | |
3625 // | | SubDelReq | |
3626 // | |------------->| |
3627 // | RESTSubDelResp| | |
3628 // |<----------------| | |
3629 // | | SubDelResp | |
3630 // | |<-------------| |
3633 //-----------------------------------------------------------------------------
3635 func TestRESTSubReqRetransmissionV2(t *testing.T) {
3637 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3638 Counter{cRestSubReqFromXapp, 3},
3639 Counter{cDuplicateE2SubReq, 2},
3640 Counter{cRestSubRespToXapp, 3},
3641 Counter{cSubReqToE2, 1},
3642 Counter{cSubRespFromE2, 1},
3643 Counter{cRestSubNotifToXapp, 3},
3644 Counter{cRestSubDelReqFromXapp, 1},
3645 Counter{cSubDelReqToE2, 1},
3646 Counter{cSubDelRespFromE2, 1},
3647 Counter{cRestSubDelRespToXapp, 1},
3650 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3652 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3654 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3656 mainCtrl.WaitOngoingRequestMapEmpty()
3659 restSubId_resend := xappConn1.SendRESTSubsReq(t, params)
3661 assert.Equal(t, restSubId_resend, restSubId)
3663 mainCtrl.WaitOngoingRequestMapEmpty()
3666 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3668 assert.Equal(t, restSubId_resend2, restSubId)
3670 mainCtrl.WaitOngoingRequestMapEmpty()
3672 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3674 waitSubsCleanup(t, e2SubsId, 10)
3675 mainCtrl.VerifyCounterValues(t)
3676 mainCtrl.VerifyAllClean(t)
3679 //-----------------------------------------------------------------------------
3681 // +-------+ +---------+ +---------+ +---------+
3682 // | xapp | | submgr | | e2term | | rtmgr |
3683 // +-------+ +---------+ +---------+ +---------+
3685 // | RESTSubReq | | |
3686 // |---------------->| | |
3687 // | RESTSubResp | | |
3688 // |<----------------| | |
3689 // | | RouteCreate | |
3690 // | |--------------------------->|
3691 // | | RouteResponse| |
3692 // | |<---------------------------| // The order of these events may vary
3694 // | |------------->| | // The order of these events may vary
3696 // | |<-------------| |
3697 // | RESTNotif1 | | |
3698 // |<----------------| | |
3699 // | RESTSubReq | | |
3700 // | [RETRANS, with RESTsubsId] | |
3701 // |---------------->| | |
3702 // | RESTNotif1 | | |
3703 // |<----------------| | |
3704 // | RESTSubReq | | |
3705 // | [RETRANS, without RESTsubsId] | |
3706 // |---------------->| | |
3707 // | RESTNotif1 | | |
3708 // |<----------------| | |
3709 // | RESTSubDelReq | | |
3710 // |---------------->| | |
3711 // | | SubDelReq | |
3712 // | |------------->| |
3713 // | RESTSubDelResp| | |
3714 // |<----------------| | |
3715 // | | SubDelResp | |
3716 // | |<-------------| |
3719 //-----------------------------------------------------------------------------
3720 func TestRESTSubReqRetransmissionV3(t *testing.T) {
3722 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3723 Counter{cRestSubReqFromXapp, 3},
3724 Counter{cDuplicateE2SubReq, 2},
3725 Counter{cRestSubRespToXapp, 3},
3726 Counter{cSubReqToE2, 1},
3727 Counter{cSubRespFromE2, 1},
3728 Counter{cRestSubNotifToXapp, 3},
3729 Counter{cRestSubDelReqFromXapp, 1},
3730 Counter{cSubDelReqToE2, 1},
3731 Counter{cSubDelRespFromE2, 1},
3732 Counter{cRestSubDelRespToXapp, 1},
3735 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3737 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3739 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
3741 mainCtrl.WaitOngoingRequestMapEmpty()
3743 //1.st resend with subscription ID
3744 params.SetSubscriptionID(&restSubId)
3745 restSubId_resend := xappConn1.SendRESTSubsReq(t, params)
3747 assert.Equal(t, restSubId_resend, restSubId)
3749 mainCtrl.WaitOngoingRequestMapEmpty()
3751 //2.nd resend without subscription ID (faking app restart)
3752 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3753 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3755 assert.Equal(t, restSubId_resend2, restSubId)
3757 mainCtrl.WaitOngoingRequestMapEmpty()
3759 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
3761 waitSubsCleanup(t, e2SubsId, 10)
3762 mainCtrl.VerifyCounterValues(t)
3763 mainCtrl.VerifyAllClean(t)
3766 //-----------------------------------------------------------------------------
3768 // +-------+ +---------+ +---------+ +---------+
3769 // | xapp | | submgr | | e2term | | rtmgr |
3770 // +-------+ +---------+ +---------+ +---------+
3772 // | RESTSubReq | | |
3773 // |---------------->| | |
3774 // | RESTSubResp | | |
3775 // |<----------------| | |
3776 // | | RouteCreate | |
3777 // | |--------------------------->|
3778 // | | RouteResponse| |
3779 // | |<---------------------------|
3781 // | |------------->| |
3783 // | |<-------------| |
3784 // | RESTNotif1 | | |
3785 // |<----------------| | |
3786 // | RESTSubReq | | |
3787 // | [with RestSUbsId + one additional e2 subDetail]
3788 // |---------------->| | |
3789 // | RESTNotif1 | | |
3790 // | [for initial e2 subDetail] | |
3791 // |<----------------| | |
3792 // | | RouteCreate | |
3793 // | |--------------------------->|
3794 // | | RouteResponse| |
3795 // | |<---------------------------|
3797 // | |------------->| |
3799 // | |<-------------| |
3800 // | RESTNotif1 | | |
3801 // |<----------------| | |
3802 // | RESTSubReq | | |
3803 // | [with RESTsubsId initial request] |
3804 // |---------------->| | |
3805 // | RESTNotif1 | | |
3806 // |<----------------| | |
3807 // | RESTSubDelReq | | |
3808 // |---------------->| | |
3809 // | RESTSubDelResp| | |
3810 // |<----------------| | |
3811 // | | SubDelReq | |
3812 // | |------------->| |
3813 // | | SubDelResp | |
3814 // | |<-------------| |
3815 // | | SubDelReq | |
3816 // | |------------->| |
3817 // | | SubDelResp | |
3818 // | |<-------------| |
3821 //-----------------------------------------------------------------------------
3823 func TestRESTSubReqRetransmissionV4(t *testing.T) {
3825 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3826 Counter{cRestSubReqFromXapp, 3},
3827 Counter{cDuplicateE2SubReq, 2},
3828 Counter{cRestSubRespToXapp, 3},
3829 Counter{cSubReqToE2, 2},
3830 Counter{cSubRespFromE2, 2},
3831 Counter{cRestSubNotifToXapp, 4},
3832 Counter{cRestSubDelReqFromXapp, 1},
3833 Counter{cSubDelReqToE2, 2},
3834 Counter{cSubDelRespFromE2, 2},
3835 Counter{cRestSubDelRespToXapp, 1},
3838 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3840 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3842 mainCtrl.WaitOngoingRequestMapEmpty()
3844 // Send modified requst, this time with e2 subscriptions.
3845 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3846 params2.SetSubscriptionID(&restSubId)
3848 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3849 xappConn1.ExpectAnyNotification(t)
3850 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3851 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3852 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3853 assert.Equal(t, e2SubsId, e2SubsId1)
3855 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3857 xappConn1.DecrementRequestCount()
3858 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3859 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3860 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3861 assert.NotEqual(t, e2SubsId2, 0)
3863 mainCtrl.WaitOngoingRequestMapEmpty()
3865 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3866 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3867 params.SetSubscriptionID(&restSubId)
3868 xappConn1.ExpectAnyNotification(t)
3869 // Resend the original request again with only one e2 subscription (detail), this time with restsubsid
3870 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3871 assert.Equal(t, restSubId_resend, restSubId_resend2)
3873 e2SubsId1 = xappConn1.WaitAnyRESTNotification(t)
3874 assert.Equal(t, e2SubsId, e2SubsId1)
3876 mainCtrl.WaitOngoingRequestMapEmpty()
3878 // Delete both e2 subscriptions
3879 xappConn1.SendRESTSubsDelReq(t, &restSubId)
3880 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
3881 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
3883 waitSubsCleanup(t, e2SubsId, 10)
3884 mainCtrl.VerifyCounterValues(t)
3885 mainCtrl.VerifyAllClean(t)
3888 //-----------------------------------------------------------------------------
3890 // +-------+ +---------+ +---------+ +---------+
3891 // | xapp | | submgr | | e2term | | rtmgr |
3892 // +-------+ +---------+ +---------+ +---------+
3894 // | RESTSubReq | | |
3895 // |---------------->| | |
3896 // | RESTSubResp | | |
3897 // |<----------------| | |
3898 // | | RouteCreate | |
3899 // | |--------------------------->|
3900 // | | RouteResponse| |
3901 // | |<---------------------------|
3903 // | |------------->| |
3905 // | |<-------------| |
3906 // | RESTNotif1 | | |
3907 // |<----------------| | |
3908 // | RESTSubReq | | |
3909 // | [with RestSUbsId + one additional e2 subDetail]
3910 // |---------------->| | |
3911 // | RESTNotif1 | | |
3912 // | [for initial e2 subDetail] | |
3913 // |<----------------| | |
3914 // | | RouteCreate | |
3915 // | |--------------------------->|
3916 // | | RouteResponse| |
3917 // | |<---------------------------|
3919 // | |------------->| |
3921 // | |<-------------| |
3922 // | RESTNotif1 | | |
3923 // |<----------------| | |
3924 // | RESTSubReq | | |
3925 // | [without RESTsubsId initial request] |
3926 // |---------------->| | |
3927 // | RESTNotif1 | | |
3928 // |<----------------| | |
3929 // | RESTSubDelReq | | |
3930 // |---------------->| | |
3931 // | RESTSubDelResp| | |
3932 // |<----------------| | |
3933 // | | SubDelReq | |
3934 // | |------------->| |
3935 // | | SubDelResp | |
3936 // | |<-------------| |
3937 // | | SubDelReq | |
3938 // | |------------->| |
3939 // | | SubDelResp | |
3940 // | |<-------------| |
3943 //-----------------------------------------------------------------------------
3945 func TestRESTSubReqRetransmissionV5(t *testing.T) {
3947 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
3948 Counter{cRestSubReqFromXapp, 3},
3949 Counter{cDuplicateE2SubReq, 2},
3950 Counter{cRestSubRespToXapp, 3},
3951 Counter{cSubReqToE2, 2},
3952 Counter{cSubRespFromE2, 2},
3953 Counter{cRestSubNotifToXapp, 4},
3954 Counter{cRestSubDelReqFromXapp, 1},
3955 Counter{cSubDelReqToE2, 2},
3956 Counter{cSubDelRespFromE2, 2},
3957 Counter{cRestSubDelRespToXapp, 1},
3960 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
3962 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
3964 mainCtrl.WaitOngoingRequestMapEmpty()
3966 // Send modified request, this time with e2 subscriptions.
3967 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
3968 params2.SetSubscriptionID(&restSubId)
3970 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3971 xappConn1.ExpectAnyNotification(t)
3972 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
3973 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
3975 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
3976 assert.Equal(t, e2SubsId, e2SubsId1)
3977 // The first E2 subscription returns immediately, manually decrement expected request count for the remaining request handling
3978 xappConn1.DecrementRequestCount()
3980 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
3982 xappConn1.ExpectRESTNotification(t, restSubId_resend)
3983 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
3984 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
3985 assert.NotEqual(t, e2SubsId2, 0)
3987 mainCtrl.WaitOngoingRequestMapEmpty()
3989 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
3990 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
3991 xappConn1.ExpectAnyNotification(t)
3992 // Resend the original request again with only one e2 subscription (detail), WITHOUT restsubsid
3993 // md5sum shall find the original request
3994 restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
3995 assert.Equal(t, restSubId_resend, restSubId_resend2)
3997 e2SubsId1 = xappConn1.WaitAnyRESTNotification(t)
3998 assert.Equal(t, e2SubsId, e2SubsId1)
4000 mainCtrl.WaitOngoingRequestMapEmpty()
4002 // Delete both e2 subscriptions
4003 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4004 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
4005 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
4007 waitSubsCleanup(t, e2SubsId, 10)
4008 mainCtrl.VerifyCounterValues(t)
4009 mainCtrl.VerifyAllClean(t)
4012 //-----------------------------------------------------------------------------
4014 // +-------+ +---------+ +---------+ +---------+
4015 // | xapp | | submgr | | e2term | | rtmgr |
4016 // +-------+ +---------+ +---------+ +---------+
4018 // | RESTSubReq | | |
4019 // |---------------->| | |
4020 // | RESTSubResp | | |
4021 // |<----------------| | |
4022 // | | RouteCreate | |
4023 // | |--------------------------->|
4024 // | | RouteResponse| |
4025 // | |<---------------------------|
4027 // | |------------->| |
4029 // | |<-------------| |
4030 // | RESTNotif1 | | |
4031 // |<----------------| | |
4032 // | RESTSubReq | | |
4033 // | [with RestSUbsId + one additional e2 subDetail]
4034 // |---------------->| | |
4035 // | RESTNotif1 | | |
4036 // | [for initial e2 subDetail] | |
4037 // |<----------------| | |
4038 // | | RouteCreate | |
4039 // | |--------------------------->|
4040 // | | RouteResponse| |
4041 // | |<---------------------------|
4043 // | |------------->| |
4045 // | |<-------------| |
4046 // | RESTNotif1 | | |
4047 // |<----------------| | |
4048 // | RESTSubDelReq | | |
4049 // |---------------->| | |
4050 // | RESTSubDelResp| | |
4051 // |<----------------| | |
4052 // | | SubDelReq | |
4053 // | |------------->| |
4054 // | | SubDelResp | |
4055 // | |<-------------| |
4056 // | | SubDelReq | |
4057 // | |------------->| |
4058 // | | SubDelResp | |
4059 // | |<-------------| |
4060 // | RESTSubReq | | |
4061 // | [with RESTsubsId initial request] |
4062 // |---------------->| | |
4063 // | RESTSubResp | | |
4064 // |<----------------| | |
4065 // | | RouteCreate | |
4066 // | |--------------------------->|
4067 // | | RouteResponse| |
4068 // | |<---------------------------|
4070 // | |------------->| |
4072 // | |<-------------| |
4073 // | RESTNotif1 | | |
4074 // |<----------------| | |
4077 //-----------------------------------------------------------------------------
4078 func TestRESTSubReqRetransmissionV6(t *testing.T) {
4080 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4081 Counter{cRestSubReqFromXapp, 3},
4082 Counter{cDuplicateE2SubReq, 1},
4083 Counter{cRestSubRespToXapp, 3},
4084 Counter{cSubReqToE2, 3},
4085 Counter{cSubRespFromE2, 3},
4086 Counter{cRestSubNotifToXapp, 4},
4087 Counter{cRestSubDelReqFromXapp, 2},
4088 Counter{cSubDelReqToE2, 3},
4089 Counter{cSubDelRespFromE2, 3},
4090 Counter{cRestSubDelRespToXapp, 2},
4093 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4095 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4097 mainCtrl.WaitOngoingRequestMapEmpty()
4099 // Send modified requst, this time with e2 subscriptions.
4100 params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
4101 params2.SetSubscriptionID(&restSubId)
4103 xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
4104 xappConn1.ExpectAnyNotification(t)
4105 // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
4106 restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
4108 e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
4109 assert.Equal(t, e2SubsId, e2SubsId1)
4111 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
4113 xappConn1.ExpectRESTNotification(t, restSubId_resend)
4114 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
4115 e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
4116 assert.NotEqual(t, e2SubsId2, 0)
4118 mainCtrl.WaitOngoingRequestMapEmpty()
4120 // Delete both e2 subscriptions
4121 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4122 e2SubsIds := []uint32{e2SubsId, e2SubsId2}
4123 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
4125 waitSubsCleanup(t, e2SubsId, 10)
4127 // Resend the original request, we shall find it's previous md5sum/restsubs
4128 // but the restsubscription has been already removed. This shall trigger a
4130 restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
4132 mainCtrl.WaitOngoingRequestMapEmpty()
4134 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
4136 waitSubsCleanup(t, e2SubsId, 10)
4137 mainCtrl.VerifyCounterValues(t)
4138 mainCtrl.VerifyAllClean(t)
4141 //-----------------------------------------------------------------------------
4142 // TestRESTSubDelReqRetransmission
4145 // +-------+ +---------+ +---------+
4146 // | xapp | | submgr | | e2term |
4147 // +-------+ +---------+ +---------+
4150 // |---------------->| |
4152 // | RESTSubResp | |
4153 // |<----------------| |
4155 // | |------------->|
4157 // | |<-------------|
4159 // |<----------------| |
4161 // | RESTSubDelReq | |
4162 // |---------------->| |
4163 // | RESTSubDelResp | |
4164 // |<----------------| |
4166 // | |------------->|
4167 // | RESTSubDelReq | |
4168 // |---------------->| |
4169 // | RESTSubDelResp | |
4170 // |<----------------| |
4172 // | |<-------------|
4175 //-----------------------------------------------------------------------------
4177 func TestRESTSubDelReqRetransmission(t *testing.T) {
4179 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4180 Counter{cRestSubReqFromXapp, 1},
4181 Counter{cRestSubRespToXapp, 1},
4182 Counter{cSubReqToE2, 1},
4183 Counter{cSubRespFromE2, 1},
4184 Counter{cRestSubNotifToXapp, 1},
4185 Counter{cRestSubDelReqFromXapp, 2},
4186 Counter{cSubDelReqToE2, 1},
4187 Counter{cSubDelRespFromE2, 1},
4188 Counter{cRestSubDelRespToXapp, 2},
4191 var params *teststube2ap.RESTSubsReqParams = nil
4194 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4196 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
4199 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4200 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4203 seqBef := mainCtrl.get_msgcounter(t)
4204 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4205 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
4208 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4210 waitSubsCleanup(t, e2SubsId, 10)
4211 mainCtrl.VerifyCounterValues(t)
4212 mainCtrl.VerifyAllClean(t)
4215 //-----------------------------------------------------------------------------
4216 // TestRESTSubReqDelReq
4219 // +-------+ +---------+ +---------+
4220 // | xapp | | submgr | | e2term |
4221 // +-------+ +---------+ +---------+
4224 // |---------------->| |
4226 // | RESTSubResp | |
4227 // |<----------------| |
4229 // | |------------->|
4230 // | RESTSubDelReq | |
4231 // |---------------->| |
4232 // | RESTSubDelResp | |
4234 // |<----------------| |
4236 // | |<-------------|
4238 // |<----------------| |
4240 // | [SUBS DELETE] |
4243 //-----------------------------------------------------------------------------
4244 func TestRESTSubReqDelReq(t *testing.T) {
4246 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4247 Counter{cRestSubReqFromXapp, 1},
4248 Counter{cRestSubRespToXapp, 1},
4249 Counter{cSubReqToE2, 1},
4250 Counter{cSubRespFromE2, 1},
4251 Counter{cRestSubNotifToXapp, 1},
4252 Counter{cRestSubDelReqFromXapp, 2},
4253 Counter{cRestSubDelFailToXapp, 1},
4254 Counter{cSubDelReqToE2, 1},
4255 Counter{cSubDelRespFromE2, 1},
4256 Counter{cRestSubDelRespToXapp, 1},
4259 const subReqCount int = 1
4262 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4263 restSubId := xappConn1.SendRESTSubsReq(t, params)
4265 // Del. This will fail as processing of the subscription
4266 // is still ongoing in submgr. Deletion is not allowed before
4267 // subscription creation has been completed.
4268 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4269 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4270 xappConn1.ExpectRESTNotification(t, restSubId)
4271 e2termConn1.SendSubsResp(t, crereq, cremsg)
4272 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4275 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4277 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4278 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4280 // Wait that subs is cleaned
4281 waitSubsCleanup(t, e2SubsId, 10)
4282 mainCtrl.VerifyCounterValues(t)
4283 mainCtrl.VerifyAllClean(t)
4286 //-----------------------------------------------------------------------------
4287 // TestRESTSubReqAndSubDelOkTwoParallel
4290 // +-------+ +-------+ +---------+ +---------+
4291 // | xapp2 | | xapp1 | | submgr | | e2term |
4292 // +-------+ +-------+ +---------+ +---------+
4294 // | | RESTSubReq1 | |
4295 // | |------------->| |
4296 // | | RESTSubResp1 | |
4297 // | |<-------------| |
4300 // | | |------------->|
4302 // | RESTSubReq2 | |
4303 // |------------------------>| |
4304 // | RESTSubResp2 | |
4305 // |<------------------------| |
4308 // | | |------------->|
4311 // | | |<-------------|
4312 // | | RESTNotif1 | |
4313 // | |<-------------| |
4316 // | | |<-------------|
4318 // |<------------------------| |
4320 // | | [SUBS 1 DELETE] |
4322 // | | [SUBS 2 DELETE] |
4325 //-----------------------------------------------------------------------------
4327 func TestRESTSubReqAndSubDelOkTwoParallel(t *testing.T) {
4329 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4330 Counter{cRestSubReqFromXapp, 2},
4331 Counter{cRestSubRespToXapp, 2},
4332 Counter{cSubReqToE2, 2},
4333 Counter{cSubRespFromE2, 2},
4334 Counter{cRestSubNotifToXapp, 2},
4335 Counter{cRestSubDelReqFromXapp, 2},
4336 Counter{cSubDelReqToE2, 2},
4337 Counter{cSubDelRespFromE2, 2},
4338 Counter{cRestSubDelRespToXapp, 2},
4342 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4343 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
4344 xapp.Logger.Debug("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
4347 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
4348 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
4349 xapp.Logger.Debug("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
4351 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4352 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
4354 //XappConn1 receives both of the responses
4355 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
4358 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
4360 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
4362 e2SubsIdA := <-xappConn1.ListedRESTNotifications
4363 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
4364 e2SubsIdB := <-xappConn1.ListedRESTNotifications
4365 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
4368 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
4370 deleteSubscription(t, xappConn2, e2termConn1, &restSubId2)
4372 //Wait that subs is cleaned
4373 mainCtrl.wait_subs_clean(t, e2SubsIdA.E2SubsId, 10)
4374 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
4376 mainCtrl.VerifyCounterValues(t)
4377 mainCtrl.VerifyAllClean(t)
4380 //-----------------------------------------------------------------------------
4381 // TestRESTSameSubsDiffRan
4382 // Same subscription to different RANs
4385 // +-------+ +---------+ +---------+
4386 // | xapp | | submgr | | e2term |
4387 // +-------+ +---------+ +---------+
4389 // | RESTSubReq(r1) | |
4390 // |---------------->| |
4391 // | RESTSubResp(r1) | |
4392 // |<----------------| |
4395 // | |------------->|
4397 // | | SubResp(r1) |
4398 // | |<-------------|
4400 // | RESTNotif(r1) | |
4401 // |<----------------| |
4403 // | RESTSubReq(r2) | |
4404 // |---------------->| |
4406 // | RESTSubResp(r2) | |
4407 // |<----------------| |
4409 // | |------------->|
4411 // | | SubResp(r2) |
4412 // | |<-------------|
4414 // | RESTNotif(r2) | |
4415 // |<----------------| |
4417 // | [SUBS r1 DELETE] |
4419 // | [SUBS r2 DELETE] |
4422 //-----------------------------------------------------------------------------
4424 func TestRESTSameSubsDiffRan(t *testing.T) {
4426 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4427 Counter{cRestSubReqFromXapp, 2},
4428 Counter{cRestSubRespToXapp, 2},
4429 Counter{cSubReqToE2, 2},
4430 Counter{cSubRespFromE2, 2},
4431 Counter{cRestSubNotifToXapp, 2},
4432 Counter{cRestSubDelReqFromXapp, 2},
4433 Counter{cSubDelReqToE2, 2},
4434 Counter{cSubDelRespFromE2, 2},
4435 Counter{cRestSubDelRespToXapp, 2},
4438 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4439 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
4440 xapp.Logger.Debug("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
4442 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
4443 params.SetMeid("RAN_NAME_2")
4444 restSubId2, e2SubsId2 := createSubscription(t, xappConn1, e2termConn1, params)
4445 xapp.Logger.Debug("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
4448 deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
4450 deleteSubscription(t, xappConn1, e2termConn1, &restSubId2)
4452 //Wait that subs is cleaned
4453 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
4454 waitSubsCleanup(t, e2SubsId2, 10)
4456 mainCtrl.VerifyCounterValues(t)
4457 mainCtrl.VerifyAllClean(t)
4460 //-----------------------------------------------------------------------------
4461 // TestRESTSubReqRetryInSubmgr
4464 // +-------+ +---------+ +---------+
4465 // | xapp | | submgr | | e2term |
4466 // +-------+ +---------+ +---------+
4469 // |---------------->| |
4470 // | RESTSubResp | |
4471 // |<----------------| |
4473 // | |------------->|
4477 // | |------------->|
4479 // | |<-------------|
4482 // |<----------------| |
4484 // | [SUBS DELETE] |
4487 //-----------------------------------------------------------------------------
4489 func TestRESTSubReqRetryInSubmgr(t *testing.T) {
4491 // Init counter check
4492 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4493 Counter{cRestSubReqFromXapp, 1},
4494 Counter{cRestSubRespToXapp, 1},
4495 Counter{cSubReqToE2, 1},
4496 Counter{cSubReqTimerExpiry, 1},
4497 Counter{cSubReReqToE2, 1},
4498 Counter{cSubRespFromE2, 1},
4499 Counter{cRestSubNotifToXapp, 1},
4500 Counter{cRestSubDelReqFromXapp, 1},
4501 Counter{cSubDelReqToE2, 1},
4502 Counter{cSubDelRespFromE2, 1},
4503 Counter{cRestSubDelRespToXapp, 1},
4506 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4507 restSubId := xappConn1.SendRESTSubsReq(t, params)
4509 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
4511 // Catch the first message and ignore it
4512 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4513 xapp.Logger.Debug("Ignore REST subscriber request for subscriber : %v", restSubId)
4515 // The second request is being handled normally
4516 crereq, cremsg = e2termConn1.RecvSubsReq(t)
4517 xappConn1.ExpectRESTNotification(t, restSubId)
4518 e2termConn1.SendSubsResp(t, crereq, cremsg)
4519 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4521 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
4524 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
4526 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
4527 //Wait that subs is cleaned
4528 waitSubsCleanup(t, e2SubsId, 10)
4530 mainCtrl.VerifyCounterValues(t)
4531 mainCtrl.VerifyAllClean(t)
4534 //-----------------------------------------------------------------------------
4535 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
4538 // +-------+ +---------+ +---------+
4539 // | xapp | | submgr | | e2term |
4540 // +-------+ +---------+ +---------+
4543 // |---------------->| |
4545 // | RESTSubResp | |
4546 // |<----------------| |
4548 // | |------------->|
4552 // | |------------->|
4555 // | |------------->|
4559 // | |------------->|
4563 // | |<-------------|
4566 // |<----------------| |
4568 // | [SUBS DELETE] |
4571 //-----------------------------------------------------------------------------
4573 func TestRESTSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
4575 // Init counter check
4576 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4577 Counter{cRestSubReqFromXapp, 1},
4578 Counter{cRestSubRespToXapp, 1},
4579 Counter{cSubReqToE2, 1},
4580 Counter{cSubReReqToE2, 1},
4581 Counter{cSubReqTimerExpiry, 2},
4582 Counter{cRestSubFailNotifToXapp, 1},
4583 Counter{cSubDelReqToE2, 1},
4584 Counter{cSubDelRespFromE2, 1},
4585 Counter{cRestSubDelReqFromXapp, 1},
4586 Counter{cRestSubDelRespToXapp, 1},
4589 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4590 restSubId := xappConn1.SendRESTSubsReq(t, params)
4591 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
4593 e2termConn1.RecvSubsReq(t)
4594 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
4596 e2termConn1.RecvSubsReq(t)
4597 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
4599 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4600 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
4601 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4602 xappConn1.WaitRESTNotification(t, restSubId)
4604 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4606 // Wait that subs is cleaned
4607 waitSubsCleanup(t, delreq.RequestId.InstanceId, 10)
4608 mainCtrl.VerifyCounterValues(t)
4609 mainCtrl.VerifyAllClean(t)
4612 //-----------------------------------------------------------------------------
4613 // TestREST2eTermNotRespondingToSubReq
4616 // +-------+ +---------+ +---------+
4617 // | xapp | | submgr | | e2term |
4618 // +-------+ +---------+ +---------+
4621 // |---------------->| |
4622 // | RESTSubResp | |
4623 // |<----------------| |
4625 // | |------------->|
4628 // | |------------->|
4631 // | |------------->|
4634 // | |------------->|
4635 // | RESTNotif(Unsuccessful) |
4636 // |<----------------| |
4638 // | RESTSubDelReq | |
4639 // |---------------->| |
4640 // | RESTSubDelResp | |
4641 // |<----------------| |
4644 //-----------------------------------------------------------------------------
4646 func TestREST2eTermNotRespondingToSubReq(t *testing.T) {
4648 // Init counter check
4649 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4650 Counter{cRestSubReqFromXapp, 1},
4651 Counter{cRestSubRespToXapp, 1},
4652 Counter{cSubReqToE2, 1},
4653 Counter{cSubReReqToE2, 1},
4654 Counter{cSubReqTimerExpiry, 2},
4655 Counter{cSubDelReReqToE2, 1},
4656 Counter{cRestSubFailNotifToXapp, 1},
4657 Counter{cSubDelReqToE2, 1},
4658 Counter{cSubDelReqTimerExpiry, 2},
4659 Counter{cRestSubDelReqFromXapp, 1},
4660 Counter{cRestSubDelRespToXapp, 1},
4663 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4664 restSubId := xappConn1.SendRESTSubsReq(t, params)
4665 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
4667 e2termConn1.RecvSubsReq(t)
4668 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
4670 e2termConn1.RecvSubsReq(t)
4671 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
4673 e2termConn1.RecvSubsDelReq(t)
4674 xapp.Logger.Debug("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
4676 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
4677 e2termConn1.RecvSubsDelReq(t)
4678 xapp.Logger.Debug("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
4680 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4682 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4684 waitSubsCleanup(t, e2SubsId, 10)
4685 mainCtrl.VerifyCounterValues(t)
4686 mainCtrl.VerifyAllClean(t)
4689 //-----------------------------------------------------------------------------
4690 // TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr
4693 // +-------+ +---------+ +---------+
4694 // | xapp | | submgr | | e2term |
4695 // +-------+ +---------+ +---------+
4698 // |---------------->| |
4700 // | RESTSubResp | |
4701 // |<----------------| |
4703 // | |------------->|
4707 // | |------------->|
4710 // | |------------->|
4714 // | |------------->|
4718 // | |<-------------|
4721 // |<----------------| |
4723 // | [SUBS DELETE] |
4726 //-----------------------------------------------------------------------------
4727 func TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
4729 // Init counter check
4730 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4731 Counter{cRestSubReqFromXapp, 1},
4732 Counter{cRestSubRespToXapp, 1},
4733 Counter{cSubReqToE2, 1},
4734 Counter{cSubReReqToE2, 1},
4735 Counter{cSubReqTimerExpiry, 2},
4736 Counter{cRestSubFailNotifToXapp, 1},
4737 Counter{cSubDelReqToE2, 1},
4738 Counter{cSubDelReReqToE2, 1},
4739 Counter{cSubDelReqTimerExpiry, 2},
4740 Counter{cRestSubDelReqFromXapp, 1},
4741 Counter{cRestSubDelRespToXapp, 1},
4744 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4745 restSubId := xappConn1.SendRESTSubsReq(t, params)
4746 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
4748 e2termConn1.RecvSubsReq(t)
4749 xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
4751 e2termConn1.RecvSubsReq(t)
4752 xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
4754 e2termConn1.RecvSubsDelReq(t)
4755 xapp.Logger.Debug("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
4757 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
4758 e2termConn1.RecvSubsDelReq(t)
4759 xapp.Logger.Debug("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
4761 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4763 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4765 waitSubsCleanup(t, e2SubsId, 10)
4766 mainCtrl.VerifyCounterValues(t)
4767 mainCtrl.VerifyAllClean(t)
4770 //-----------------------------------------------------------------------------
4771 // TestRESTSubReqSubFailRespInSubmgr
4774 // +-------+ +---------+ +---------+
4775 // | xapp | | submgr | | e2term |
4776 // +-------+ +---------+ +---------+
4779 // |---------------->| |
4781 // | RESTSubResp | |
4782 // |<----------------| |
4784 // | |------------->|
4787 // | |<-------------|
4791 // |<----------------| |
4793 // | [SUBS DELETE] |
4796 //-----------------------------------------------------------------------------
4798 func TestRESTSubReqSubFailRespInSubmgr(t *testing.T) {
4800 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4801 Counter{cRestSubReqFromXapp, 1},
4802 Counter{cRestSubRespToXapp, 1},
4803 Counter{cSubReqToE2, 1},
4804 Counter{cSubFailFromE2, 1},
4805 Counter{cRestSubFailNotifToXapp, 1},
4806 Counter{cRestSubDelReqFromXapp, 1},
4807 Counter{cRestSubDelRespToXapp, 1},
4810 const subReqCount int = 1
4811 const e2Timeout int64 = 2
4812 const e2RetryCount int64 = 1
4813 const routingNeeded bool = true
4815 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4816 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
4817 restSubId := xappConn1.SendRESTSubsReq(t, params)
4819 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
4820 fparams1 := &teststube2ap.E2StubSubsFailParams{}
4821 fparams1.Set(crereq1)
4822 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
4823 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
4825 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4826 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
4828 // REST subscription sill there to be deleted
4829 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4831 // Wait that subs is cleaned
4832 waitSubsCleanup(t, e2SubsId, 10)
4834 mainCtrl.VerifyCounterValues(t)
4835 mainCtrl.VerifyAllClean(t)
4838 //-----------------------------------------------------------------------------
4839 // TestRESTSubReqPartialResp
4842 // +-------+ +---------+ +---------+
4843 // | xapp | | submgr | | e2term |
4844 // +-------+ +---------+ +---------+
4847 // |---------------->| |
4848 // | RESTSubResp | |
4849 // |<----------------| |
4851 // | |------------->|
4852 // | | SubResp | Partially accepted
4853 // | |<-------------|
4856 // |<----------------| |
4858 // | [SUBS DELETE] |
4861 //-----------------------------------------------------------------------------
4863 func TestRESTSubReqPartialResp(t *testing.T) {
4865 // Init counter check
4866 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4867 Counter{cRestSubReqFromXapp, 1},
4868 Counter{cRestSubRespToXapp, 1},
4869 Counter{cSubReqToE2, 1},
4870 Counter{cSubRespFromE2, 1},
4871 Counter{cPartialSubRespFromE2, 1},
4872 Counter{cRestSubNotifToXapp, 1},
4873 Counter{cRestSubDelReqFromXapp, 1},
4874 Counter{cSubDelReqToE2, 1},
4875 Counter{cSubDelRespFromE2, 1},
4876 Counter{cRestSubDelRespToXapp, 1},
4880 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
4882 actionId := int64(2)
4883 actionType := "report"
4884 actionDefinition := []int64{5678, 1}
4885 subsequestActionType := "continue"
4886 timeToWait := "w10ms"
4887 params.AppendActionToActionToBeSetupList(actionId, actionType, actionDefinition, subsequestActionType, timeToWait)
4889 restSubId := xappConn1.SendRESTSubsReq(t, params)
4890 crereq, cremsg := e2termConn1.RecvSubsReq(t)
4891 xappConn1.ExpectRESTNotification(t, restSubId)
4893 actionNotAdmittedItem := e2ap.ActionNotAdmittedItem{}
4894 actionNotAdmittedItem.ActionId = 1
4895 actionNotAdmittedItem.Cause.Content = 1
4896 actionNotAdmittedItem.Cause.Value = 8
4897 actionNotAdmittedList := e2ap.ActionNotAdmittedList{}
4898 actionNotAdmittedList.Items = append(actionNotAdmittedList.Items, actionNotAdmittedItem)
4899 e2termConn1.SendPartialSubsResp(t, crereq, cremsg, actionNotAdmittedList)
4900 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
4902 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
4905 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
4907 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
4908 //Wait that subs is cleaned
4909 waitSubsCleanup(t, e2SubsId, 10)
4911 mainCtrl.VerifyCounterValues(t)
4912 mainCtrl.VerifyAllClean(t)
4915 //-----------------------------------------------------------------------------
4916 // TestRESTSubDelReqRetryInSubmgr
4919 // +-------+ +---------+ +---------+
4920 // | xapp | | submgr | | e2term |
4921 // +-------+ +---------+ +---------+
4923 // | [SUBS CREATE] |
4926 // | RESTSubDelReq | |
4927 // |---------------->| |
4929 // | RESTSubDelResp | |
4930 // |<----------------| |
4932 // | |------------->|
4935 // | |------------->|
4938 // | |<-------------|
4941 //-----------------------------------------------------------------------------
4942 func TestRESTSubDelReqRetryInSubmgr(t *testing.T) {
4944 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
4945 Counter{cRestSubReqFromXapp, 1},
4946 Counter{cRestSubRespToXapp, 1},
4947 Counter{cSubReqToE2, 1},
4948 Counter{cSubRespFromE2, 1},
4949 Counter{cRestSubNotifToXapp, 1},
4950 Counter{cRestSubDelReqFromXapp, 1},
4951 Counter{cSubDelReqToE2, 1},
4952 Counter{cSubDelReqTimerExpiry, 1},
4953 Counter{cSubDelReReqToE2, 1},
4954 Counter{cSubDelRespFromE2, 1},
4955 Counter{cRestSubDelRespToXapp, 1},
4958 var params *teststube2ap.RESTSubsReqParams = nil
4959 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
4962 xappConn1.SendRESTSubsDelReq(t, &restSubId)
4964 // E2t: Receive 1st SubsDelReq
4965 e2termConn1.RecvSubsDelReq(t)
4967 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
4968 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
4969 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
4971 //Wait that subs is cleaned
4972 waitSubsCleanup(t, e2SubsId, 10)
4974 mainCtrl.VerifyCounterValues(t)
4975 mainCtrl.VerifyAllClean(t)
4978 //-----------------------------------------------------------------------------
4979 // TestRESTSubDelReqTwoRetriesNoRespInSubmgr
4982 // +-------+ +---------+ +---------+
4983 // | xapp | | submgr | | e2term |
4984 // +-------+ +---------+ +---------+
4986 // | [SUBS CREATE] |
4989 // | RESTSubDelReq | |
4990 // |---------------->| |
4992 // | RESTSubDelResp | |
4993 // |<----------------| |
4995 // | |------------->|
4998 // | |------------->|
5002 //-----------------------------------------------------------------------------
5004 func TestRESTSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
5006 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5007 Counter{cRestSubReqFromXapp, 1},
5008 Counter{cRestSubRespToXapp, 1},
5009 Counter{cSubReqToE2, 1},
5010 Counter{cSubRespFromE2, 1},
5011 Counter{cRestSubNotifToXapp, 1},
5012 Counter{cRestSubDelReqFromXapp, 1},
5013 Counter{cSubDelReqToE2, 1},
5014 Counter{cSubDelReqTimerExpiry, 1},
5015 Counter{cSubDelReReqToE2, 1},
5016 Counter{cSubDelRespFromE2, 1},
5017 Counter{cRestSubDelRespToXapp, 1},
5021 var params *teststube2ap.RESTSubsReqParams = nil
5022 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5025 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5027 // E2t: Receive 1st SubsDelReq
5028 e2termConn1.RecvSubsDelReq(t)
5030 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
5031 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5032 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5034 //Wait that subs is cleaned
5035 waitSubsCleanup(t, e2SubsId, 10)
5037 mainCtrl.VerifyCounterValues(t)
5038 mainCtrl.VerifyAllClean(t)
5041 //-----------------------------------------------------------------------------
5042 // TestRESTSubDelReqSubDelFailRespInSubmgr
5045 // +-------+ +---------+ +---------+
5046 // | xapp | | submgr | | e2term |
5047 // +-------+ +---------+ +---------+
5049 // | [SUBS CREATE] |
5052 // | RESTSubDelReq | |
5053 // |---------------->| |
5055 // | RESTSubDelResp | |
5056 // |<----------------| |
5058 // | |------------->|
5061 // | |<-------------|
5064 //-----------------------------------------------------------------------------
5066 func TestRESTSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
5068 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5069 Counter{cRestSubReqFromXapp, 1},
5070 Counter{cRestSubRespToXapp, 1},
5071 Counter{cSubReqToE2, 1},
5072 Counter{cSubRespFromE2, 1},
5073 Counter{cRestSubNotifToXapp, 1},
5074 Counter{cRestSubDelReqFromXapp, 1},
5075 Counter{cSubDelReqToE2, 1},
5076 Counter{cSubDelFailFromE2, 1},
5077 Counter{cRestSubDelRespToXapp, 1},
5081 var params *teststube2ap.RESTSubsReqParams = nil
5082 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5085 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5087 // E2t: Send receive SubsDelReq and send SubsDelFail
5088 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5089 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
5091 //Wait that subs is cleaned
5092 waitSubsCleanup(t, e2SubsId, 10)
5094 mainCtrl.VerifyCounterValues(t)
5095 mainCtrl.VerifyAllClean(t)
5098 //-----------------------------------------------------------------------------
5099 // TestRESTSubReqAndSubDelOkSameAction
5102 // +-------+ +-------+ +---------+ +---------+
5103 // | xapp2 | | xapp1 | | submgr | | e2term |
5104 // +-------+ +-------+ +---------+ +---------+
5106 // | | RESTSubReq1 | |
5107 // | |---------------->| |
5109 // | | RESTSubResp1 | |
5110 // | |<----------------| |
5113 // | | |------------->|
5115 // | | |<-------------|
5116 // | | RESTNotif1 | |
5117 // | |<----------------| |
5119 // | RESTSubReq2 | |
5120 // |------------------------------>| |
5122 // | RESTSubResp2 | |
5123 // |<------------------------------| |
5125 // | | RESTNotif2 | |
5126 // |<------------------------------| |
5128 // | | RESTSubDelReq1 | |
5129 // | |---------------->| |
5131 // | | RESTSubDelResp1 | |
5132 // | |<----------------| |
5134 // | RESTSubDelReq2 | |
5135 // |------------------------------>| |
5137 // | RESTSubDelResp2 | |
5138 // |<------------------------------| |
5140 // | | | SubDelReq2 |
5141 // | | |------------->|
5143 // | | | SubDelResp2 |
5144 // | | |<-------------|
5147 //-----------------------------------------------------------------------------
5149 func TestRESTSubReqAndSubDelOkSameAction(t *testing.T) {
5151 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5152 Counter{cRestSubReqFromXapp, 2},
5153 Counter{cRestSubRespToXapp, 2},
5154 Counter{cSubReqToE2, 1},
5155 Counter{cSubRespFromE2, 1},
5156 Counter{cRestSubNotifToXapp, 2},
5157 Counter{cMergedSubscriptions, 1},
5158 Counter{cUnmergedSubscriptions, 1},
5159 Counter{cRestSubDelReqFromXapp, 2},
5160 Counter{cSubDelReqToE2, 1},
5161 Counter{cSubDelRespFromE2, 1},
5162 Counter{cRestSubDelRespToXapp, 2},
5166 var params *teststube2ap.RESTSubsReqParams = nil
5169 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
5170 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
5173 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5174 params.SetMeid("RAN_NAME_1")
5176 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
5177 xappConn2.ExpectAnyNotification(t)
5178 waiter := rtmgrHttp.AllocNextSleep(10, true)
5179 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5180 waiter.WaitResult(t)
5181 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
5182 e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
5183 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId2)
5185 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
5188 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
5191 deleteXapp2Subscription(t, &restSubId2)
5193 //Wait that subs is cleaned
5194 waitSubsCleanup(t, e2SubsId2, 10)
5195 mainCtrl.VerifyCounterValues(t)
5196 mainCtrl.VerifyAllClean(t)
5199 //-----------------------------------------------------------------------------
5200 // TestSubReqAndSubDelOkSameActionParallel
5203 // +-------+ +-------+ +---------+ +---------+
5204 // | xapp2 | | xapp1 | | submgr | | e2term |
5205 // +-------+ +-------+ +---------+ +---------+
5210 // | |------------->| |
5213 // | | |------------->|
5215 // |--------------------------->| |
5217 // | | |<-------------|
5219 // | |<-------------| |
5221 // | | |------------->|
5224 // | | |<-------------|
5226 // |<---------------------------| |
5228 // | | SubDelReq 1 | |
5229 // | |------------->| |
5231 // | | SubDelResp 1 | |
5232 // | |<-------------| |
5234 // | SubDelReq 2 | |
5235 // |--------------------------->| |
5237 // | | | SubDelReq 2 |
5238 // | | |------------->|
5240 // | | | SubDelReq 2 |
5241 // | | |------------->|
5243 // | SubDelResp 2 | |
5244 // |<---------------------------| |
5246 func TestRESTSubReqAndSubDelOkSameActionParallel(t *testing.T) {
5248 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5249 Counter{cRestSubReqFromXapp, 2},
5250 Counter{cRestSubRespToXapp, 2},
5251 Counter{cSubReqToE2, 2},
5252 Counter{cSubRespFromE2, 2},
5253 Counter{cRestSubNotifToXapp, 2},
5254 Counter{cRestSubDelReqFromXapp, 2},
5255 Counter{cSubDelReqToE2, 2},
5256 Counter{cSubDelRespFromE2, 2},
5257 Counter{cRestSubDelRespToXapp, 2},
5260 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5261 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
5262 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
5264 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
5265 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
5267 xappConn1.ExpectRESTNotification(t, restSubId1)
5268 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
5269 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
5271 xappConn2.ExpectRESTNotification(t, restSubId2)
5272 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
5273 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
5274 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5277 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
5278 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
5279 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
5280 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
5283 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
5284 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
5285 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
5287 waitSubsCleanup(t, e2SubsId2, 10)
5288 mainCtrl.VerifyCounterValues(t)
5289 mainCtrl.VerifyAllClean(t)
5292 //-----------------------------------------------------------------------------
5293 // TestRESTSubReqAndSubDelNoAnswerSameActionParallel
5296 // +-------+ +-------+ +---------+ +---------+
5297 // | xapp2 | | xapp1 | | submgr | | e2term |
5298 // +-------+ +-------+ +---------+ +---------+
5302 // | | RESTSubReq1 | |
5303 // | |---------------->| |
5305 // | | RESTSubResp1 | |
5306 // | |<----------------| |
5308 // | | |------------->|
5309 // | RESTSubReq2 | |
5310 // |------------------------------>| |
5312 // | RESTSubResp2 | |
5313 // |<------------------------------| |
5315 // | | |------------->|
5318 // | | | SubDelReq |
5319 // | | |------------->|
5321 // | | | SubDelResp |
5322 // | | |<-------------|
5323 // | | RESTNotif1 | |
5324 // | | unsuccess | |
5325 // | |<----------------| |
5327 // | | unsuccess | |
5328 // |<------------------------------| |
5330 // | | RESTSubDelReq1 | |
5331 // | |---------------->| |
5333 // | | RESTSubDelResp1 | |
5334 // | |<----------------| |
5336 // | RESTSubDelReq2 | |
5337 // |------------------------------>| |
5339 // | RESTSubDelResp2 | |
5340 // |<------------------------------| |
5342 //-----------------------------------------------------------------------------
5344 func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
5346 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5347 Counter{cRestSubReqFromXapp, 2},
5348 Counter{cMergedSubscriptions, 1},
5349 Counter{cRestSubRespToXapp, 2},
5350 Counter{cSubReqToE2, 1},
5351 Counter{cSubReqTimerExpiry, 2},
5352 Counter{cSubReReqToE2, 1},
5353 Counter{cRestSubFailNotifToXapp, 2},
5354 Counter{cUnmergedSubscriptions, 1},
5355 Counter{cRestSubDelReqFromXapp, 2},
5356 Counter{cSubDelReqToE2, 1},
5357 Counter{cSubDelRespFromE2, 1},
5358 Counter{cRestSubDelRespToXapp, 2},
5360 const subReqCount int = 1
5363 params1 := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5364 restSubId1 := xappConn1.SendRESTSubsReq(t, params1)
5365 crereq1, _ := e2termConn1.RecvSubsReq(t)
5368 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
5369 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
5370 params2.SetMeid("RAN_NAME_1")
5371 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
5372 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
5374 //Req1 (retransmitted)
5375 e2termConn1.RecvSubsReq(t)
5377 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
5379 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
5380 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
5382 e2SubsIdA := <-xappConn1.ListedRESTNotifications
5383 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
5384 e2SubsIdB := <-xappConn1.ListedRESTNotifications
5385 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
5388 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
5391 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
5393 mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId, e2SubsIdB.E2SubsId}, 10)
5395 //Wait that subs is cleaned
5396 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
5397 mainCtrl.VerifyCounterValues(t)
5398 mainCtrl.VerifyAllClean(t)
5401 //-----------------------------------------------------------------------------
5402 // TestRESTSubReqAndSubDelNokSameActionParallel
5405 // +-------+ +-------+ +---------+ +---------+
5406 // | xapp2 | | xapp1 | | submgr | | e2term |
5407 // +-------+ +-------+ +---------+ +---------+
5411 // | | RESTSubReq1 | |
5412 // | |---------------->| |
5414 // | | RESTSubResp1 | |
5415 // | |<----------------| |
5417 // | | |------------->|
5418 // | RESTSubReq2 | |
5419 // |------------------------------>| |
5421 // | RESTSubDelResp2 | |
5422 // |<------------------------------| |
5424 // | | |<-------------|
5426 // | | RESTNotif1 | |
5427 // | | unsuccess | |
5428 // | |<----------------| |
5430 // | | unsuccess | |
5431 // |<------------------------------| |
5433 // | | RESTSubDelReq1 | | There is no need for xApp to send delete for failed subscriptions but some xApp might do so.
5434 // | |---------------->| |
5436 // | | RESTSubDelResp1 | |
5437 // | |<----------------| |
5439 // | RESTSubDelReq2 | |
5440 // |------------------------------>| |
5442 // | RESTSubDelResp2 | |
5443 // |<------------------------------| |
5445 //-----------------------------------------------------------------------------
5447 func TestRESTSubReqAndSubDelNokSameActionParallel(t *testing.T) {
5449 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5450 Counter{cRestSubReqFromXapp, 2},
5451 Counter{cMergedSubscriptions, 1},
5452 Counter{cRestSubRespToXapp, 2},
5453 Counter{cSubReqToE2, 1},
5454 Counter{cSubFailFromE2, 1},
5455 Counter{cRestSubFailNotifToXapp, 2},
5456 Counter{cUnmergedSubscriptions, 1},
5457 Counter{cRestSubDelReqFromXapp, 2},
5458 Counter{cRestSubDelRespToXapp, 2},
5461 const subReqCount int = 1
5464 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5465 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
5466 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
5469 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
5470 params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
5471 params2.SetMeid("RAN_NAME_1")
5472 restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
5473 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
5475 // E2t: send SubsFail (first)
5476 fparams1 := &teststube2ap.E2StubSubsFailParams{}
5477 fparams1.Set(crereq1)
5478 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
5480 xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
5481 e2SubsIdA := <-xappConn1.ListedRESTNotifications
5482 xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
5483 e2SubsIdB := <-xappConn1.ListedRESTNotifications
5484 xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
5487 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
5490 xappConn2.SendRESTSubsDelReq(t, &restSubId2)
5492 //Wait that subs is cleaned
5493 waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
5494 waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
5495 mainCtrl.VerifyCounterValues(t)
5496 mainCtrl.VerifyAllClean(t)
5499 //-----------------------------------------------------------------------------
5500 // TestRESTSubReqPolicyAndSubDelOk
5503 // +-------+ +---------+ +---------+
5504 // | xapp | | submgr | | e2term |
5505 // +-------+ +---------+ +---------+
5508 // |--------------->| |
5509 // | RESTSubResp | |
5510 // |<---------------| |
5513 // | |------------->|
5516 // | |<-------------|
5519 // |<---------------| |
5522 // | RESTSubDelReq | |
5523 // |--------------->| |
5524 // | RESTSubDelResp | |
5525 // |<---------------| |
5528 // | |------------->|
5531 // | |<-------------|
5534 //-----------------------------------------------------------------------------
5536 func TestRESTSubReqPolicyAndSubDelOk(t *testing.T) {
5538 // Init counter check
5539 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5540 Counter{cRestSubReqFromXapp, 1},
5541 Counter{cRestSubRespToXapp, 1},
5542 Counter{cSubReqToE2, 1},
5543 Counter{cSubRespFromE2, 1},
5544 Counter{cRestSubNotifToXapp, 1},
5545 Counter{cRestSubDelReqFromXapp, 1},
5546 Counter{cSubDelReqToE2, 1},
5547 Counter{cSubDelRespFromE2, 1},
5548 Counter{cRestSubDelRespToXapp, 1},
5551 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5552 restSubId := xappConn1.SendRESTSubsReq(t, params)
5553 xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
5555 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
5556 xappConn1.ExpectRESTNotification(t, restSubId)
5557 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
5558 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
5559 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
5561 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5562 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5563 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5565 // Wait that subs is cleaned
5566 waitSubsCleanup(t, e2SubsId, 10)
5567 mainCtrl.VerifyCounterValues(t)
5568 mainCtrl.VerifyAllClean(t)
5571 //-----------------------------------------------------------------------------
5572 // TestRESTSubReqPolicyChangeAndSubDelOk
5575 // +-------+ +---------+ +---------+
5576 // | xapp | | submgr | | e2term |
5577 // +-------+ +---------+ +---------+
5580 // |---------------->| |
5582 // | RESTSubResp | |
5583 // |<----------------| |
5585 // | |------------->|
5588 // | |<-------------|
5591 // |<----------------| |
5594 // |---------------->| |
5596 // | RESTSubResp | |
5597 // |<----------------| |
5599 // | |------------->|
5602 // | |<-------------|
5605 // |<----------------| |
5607 // | RESTSubDelReq | |
5608 // |---------------->| |
5611 // | |------------->|
5614 // | |<-------------|
5616 // | RESTSubDelResp | |
5617 // |<----------------| |
5619 //-----------------------------------------------------------------------------
5621 func TestRESTSubReqPolicyChangeAndSubDelOk(t *testing.T) {
5623 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5624 Counter{cRestSubReqFromXapp, 2},
5625 Counter{cRestSubRespToXapp, 2},
5626 Counter{cSubReqToE2, 2},
5627 Counter{cSubRespFromE2, 2},
5628 Counter{cRestSubNotifToXapp, 2},
5629 Counter{cRestSubDelReqFromXapp, 1},
5630 Counter{cSubDelReqToE2, 1},
5631 Counter{cSubDelRespFromE2, 1},
5632 Counter{cRestSubDelRespToXapp, 1},
5635 const subReqCount int = 1
5636 const e2Timeout int64 = 1
5637 const e2RetryCount int64 = 0
5638 const routingNeeded bool = true
5641 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5642 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5643 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5646 // GetRESTSubsReqPolicyParams sets some counters on tc side.
5648 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5649 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5650 params.SetSubscriptionID(&restSubId)
5651 params.SetTimeToWait("w200ms")
5652 restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
5655 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5657 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5658 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5660 // Wait that subs is cleaned
5661 waitSubsCleanup(t, e2SubsId, 10)
5662 mainCtrl.VerifyCounterValues(t)
5663 mainCtrl.VerifyAllClean(t)
5666 //-----------------------------------------------------------------------------
5667 // TestRESTSubReqPolicyChangeNokAndSubDelOk
5670 // +-------+ +---------+ +---------+
5671 // | xapp | | submgr | | e2term |
5672 // +-------+ +---------+ +---------+
5675 // |---------------->| |
5677 // | RESTSubResp | |
5678 // |<----------------| |
5680 // | |------------->|
5683 // | |<-------------|
5686 // |<----------------| |
5689 // |---------------->| |
5691 // | RESTSubResp | |
5692 // |<----------------| |
5694 // | |------------->|
5697 // | |<-------------|
5700 // |<----------------| |
5702 // | RESTSubDelReq | |
5703 // |---------------->| |
5706 // | |------------->|
5709 // | |<-------------|
5711 // | RESTSubDelResp | |
5712 // |<----------------| |
5714 //-----------------------------------------------------------------------------
5716 func TestRESTSubReqPolicyChangeNokAndSubDelOk(t *testing.T) {
5718 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5719 Counter{cRestSubReqFromXapp, 2},
5720 Counter{cRestSubRespToXapp, 2},
5721 Counter{cSubReqToE2, 2},
5722 Counter{cSubRespFromE2, 1},
5723 Counter{cSubFailFromE2, 1},
5724 Counter{cRestSubNotifToXapp, 1},
5725 Counter{cRestSubFailNotifToXapp, 1},
5726 Counter{cRestSubDelReqFromXapp, 1},
5727 Counter{cSubDelReqToE2, 1},
5728 Counter{cSubDelRespFromE2, 1},
5729 Counter{cRestSubDelRespToXapp, 1},
5732 const subReqCount int = 1
5733 const e2Timeout int64 = 1
5734 const e2RetryCount int64 = 0
5735 const routingNeeded bool = false
5738 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5739 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5740 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5741 fmt.Printf("restSubId: %v", restSubId)
5744 // GetRESTSubsReqPolicyParams sets some counters on tc side.
5745 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5746 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
5747 params.SetSubscriptionID(&restSubId)
5748 params.SetTimeToWait("w200ms")
5750 restSubId = xappConn1.SendRESTSubsReq(t, params)
5751 fmt.Printf("restSubId: %v", restSubId)
5753 crereq, cremsg := e2termConn1.RecvSubsReq(t)
5754 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
5756 // Gnb sends RICSubscriptionFailure
5757 fparams := &teststube2ap.E2StubSubsFailParams{}
5759 fparams.SetCauseVal(0, 1, 5) // CauseRIC / function-resource-limit
5760 e2termConn1.SendSubsFail(t, fparams, cremsg)
5762 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
5763 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
5766 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5768 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5769 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5771 // Wait that subs is cleaned
5772 waitSubsCleanup(t, e2SubsId, 10)
5773 mainCtrl.VerifyCounterValues(t)
5774 mainCtrl.VerifyAllClean(t)
5777 //-----------------------------------------------------------------------------
5778 // TestRESTSubReqPolicyChangeNOk
5781 // +-------+ +---------+ +---------+
5782 // | xapp | | submgr | | e2term |
5783 // +-------+ +---------+ +---------+
5786 // |---------------->| |
5788 // | RESTSubResp | |
5789 // |<----------------| |
5791 // | |------------->|
5794 // | |<-------------|
5797 // |<----------------| |
5800 // |---------------->| |
5802 // | RESTSubUpdateFail(400 Bad request)
5804 // | RESTSubDelReq | |
5805 // |---------------->| |
5808 // | |------------->|
5811 // | |<-------------|
5813 // | RESTSubDelResp | |
5814 // |<----------------| |
5816 //-----------------------------------------------------------------------------
5818 func TestRESTSubReqPolicyChangeNOk(t *testing.T) {
5820 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5821 Counter{cRestSubReqFromXapp, 2},
5822 Counter{cRestSubRespToXapp, 1},
5823 Counter{cSubReqToE2, 1},
5824 Counter{cSubRespFromE2, 1},
5825 Counter{cRestSubNotifToXapp, 1},
5826 Counter{cRestSubFailToXapp, 1},
5827 Counter{cRestSubDelReqFromXapp, 1},
5828 Counter{cSubDelReqToE2, 1},
5829 Counter{cSubDelRespFromE2, 1},
5830 Counter{cRestSubDelRespToXapp, 1},
5834 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5835 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
5838 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
5840 restSubIdUpd := strings.ToUpper(restSubId) // This makes RESTSubReq to fail
5841 params.SetSubscriptionID(&restSubIdUpd)
5842 params.SetTimeToWait("w200ms")
5844 restSubId2 := xappConn1.SendRESTSubsReq(t, params)
5845 assert.Equal(t, restSubId2, "")
5848 xappConn1.SendRESTSubsDelReq(t, &restSubId)
5850 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
5851 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
5853 // Wait that subs is cleaned
5854 waitSubsCleanup(t, e2SubsId, 10)
5855 mainCtrl.VerifyCounterValues(t)
5856 mainCtrl.VerifyAllClean(t)
5859 //-----------------------------------------------------------------------------
5860 // TestRESTSubReqAndSubDelOkTwoE2termParallel
5863 // +-------+ +---------+ +---------+ +---------+
5864 // | xapp | | submgr | | e2term1 | | e2term2 |
5865 // +-------+ +---------+ +---------+ +---------+
5869 // | RESTSubReq1 | | |
5870 // |---------------->| | |
5872 // | RESTSubResp1 | | |
5873 // |<----------------| | |
5875 // | |------------->| |
5877 // | RESTSubReq2 | | |
5878 // |---------------->| | |
5880 // | RESTSubResp2 | | |
5881 // |<----------------| | |
5883 // | |---------------------------->|
5886 // | |<-------------| |
5887 // | RESTNotif1 | | |
5888 // |<----------------| | |
5890 // | |<----------------------------|
5891 // | RESTNotif2 | | |
5892 // |<----------------| | |
5894 // | [SUBS 1 DELETE] | |
5896 // | [SUBS 2 DELETE] | |
5899 //-----------------------------------------------------------------------------
5901 func TestRESTSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
5903 // Init counter check
5904 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
5905 Counter{cRestSubReqFromXapp, 2},
5906 Counter{cRestSubRespToXapp, 2},
5907 Counter{cSubReqToE2, 2},
5908 Counter{cSubRespFromE2, 2},
5909 Counter{cRestSubNotifToXapp, 2},
5910 Counter{cRestSubDelReqFromXapp, 2},
5911 Counter{cSubDelReqToE2, 2},
5912 Counter{cSubDelRespFromE2, 2},
5913 Counter{cRestSubDelRespToXapp, 2},
5916 const subReqCount int = 1
5919 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
5920 restSubId1 := xappConn1.SendRESTSubsReq(t, params)
5921 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
5924 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
5925 params.SetMeid("RAN_NAME_11")
5926 // Here we use xappConn2 to simulate sending second request from same xapp as doing it from xappConn1
5927 // would not work as notification would not be received
5928 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
5929 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
5932 xappConn1.ExpectRESTNotification(t, restSubId1)
5933 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
5934 e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
5935 xapp.Logger.Debug("TEST: REST notification received e2SubsId1=%v", e2SubsId1)
5938 xappConn2.ExpectRESTNotification(t, restSubId2)
5939 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
5940 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
5941 xapp.Logger.Debug("TEST: REST notification received e2SubsId2=%v", e2SubsId2)
5944 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
5945 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
5946 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
5948 // Wait that subs is cleaned
5949 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
5952 xappConn1.SendRESTSubsDelReq(t, &restSubId2)
5953 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
5954 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
5956 // Wait that subs is cleaned
5957 waitSubsCleanup(t, e2SubsId2, 10)
5959 mainCtrl.VerifyCounterValues(t)
5960 mainCtrl.VerifyAllClean(t)
5963 //-----------------------------------------------------------------------------
5964 // TestRESTSubReqInsertAndSubDelOk
5967 // +-------+ +---------+ +---------+
5968 // | xapp | | submgr | | e2term |
5969 // +-------+ +---------+ +---------+
5972 // |---------------->| |
5974 // | RESTSubResp | |
5975 // |<----------------| |
5978 // | |------------->|
5981 // | |<-------------|
5983 // |<----------------| |
5986 // | RESTSubDelReq | |
5987 // |---------------->| |
5990 // | |------------->|
5993 // | |<-------------|
5995 // | RESTSubDelResp| |
5996 // |<----------------| |
5998 //-----------------------------------------------------------------------------
6000 func TestRESTSubReqInsertAndSubDelOk(t *testing.T) {
6002 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6003 Counter{cRestSubReqFromXapp, 1},
6004 Counter{cRestSubRespToXapp, 1},
6005 Counter{cSubReqToE2, 1},
6006 Counter{cSubRespFromE2, 1},
6007 Counter{cRestSubNotifToXapp, 1},
6008 Counter{cRestSubDelReqFromXapp, 1},
6009 Counter{cSubDelReqToE2, 1},
6010 Counter{cSubDelRespFromE2, 1},
6011 Counter{cRestSubDelRespToXapp, 1},
6014 const subReqCount int = 1
6016 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6017 params.SetSubActionTypes("insert")
6020 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6023 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6025 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6026 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6028 // Wait that subs is cleaned
6029 waitSubsCleanup(t, e2SubsId, 10)
6030 mainCtrl.VerifyCounterValues(t)
6031 mainCtrl.VerifyAllClean(t)
6034 //-----------------------------------------------------------------------------
6035 // TestRESTSubReqNokAndSubDelOkWithRestartInMiddle
6038 // +-------+ +---------+ +---------+
6039 // | xapp | | submgr | | e2term |
6040 // +-------+ +---------+ +---------+
6043 // |------------->| |
6045 // | RESTSubResp | |
6046 // |<-------------| |
6048 // | |------------->|
6053 // | Submgr restart |
6057 // | |------------->|
6060 // | |<-------------|
6064 // |<-------------| |
6066 // | RESTSubDelReq| |
6067 // |------------->| |
6069 // |RESTSubDelResp| |
6070 // |<-------------| |
6072 //-----------------------------------------------------------------------------
6074 func TestRESTSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
6076 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6077 Counter{cRestSubReqFromXapp, 1},
6078 Counter{cRestSubRespToXapp, 1},
6079 Counter{cSubReqToE2, 1},
6080 Counter{cSubDelReqFromXapp, 1},
6081 Counter{cSubDelReqToE2, 1},
6082 Counter{cSubDelRespFromE2, 1},
6083 Counter{cRestSubDelReqFromXapp, 1},
6084 Counter{cRestSubDelRespToXapp, 1},
6087 const subReqCount int = 1
6089 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6092 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
6093 restSubId := xappConn1.SendRESTSubsReq(t, params)
6094 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
6096 e2termConn1.RecvSubsReq(t)
6098 mainCtrl.SetResetTestFlag(t, false)
6100 mainCtrl.SimulateRestart(t)
6101 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
6103 // Deleletion of uncompleted subscription
6104 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6105 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6108 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6110 xappConn1.TestMsgChanEmpty(t)
6111 e2termConn1.TestMsgChanEmpty(t)
6112 mainCtrl.wait_registry_empty(t, 10)
6114 mainCtrl.VerifyCounterValues(t)
6115 mainCtrl.VerifyAllClean(t)
6118 //-----------------------------------------------------------------------------
6119 // TestRESTSubReqAndSubDelOkWithRestartInMiddle
6122 // +-------+ +---------+ +---------+
6123 // | xapp | | submgr | | e2term |
6124 // +-------+ +---------+ +---------+
6127 // |---------------->| |
6129 // | RESTSubResp | |
6130 // |<----------------| |
6132 // | |------------->|
6135 // | |<-------------|
6138 // |<----------------| |
6141 // | Submgr restart |
6143 // | RESTSubDelReq | |
6144 // |---------------->| |
6147 // | |------------->|
6150 // | |<-------------|
6152 // | RESTSubDelResp | |
6153 // |<----------------| |
6155 //-----------------------------------------------------------------------------
6157 func TestRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
6159 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6160 Counter{cRestSubReqFromXapp, 1},
6161 Counter{cRestSubRespToXapp, 1},
6162 Counter{cSubReqToE2, 1},
6163 Counter{cSubRespFromE2, 1},
6164 Counter{cRestSubNotifToXapp, 1},
6165 Counter{cRestSubDelReqFromXapp, 1},
6166 Counter{cSubDelReqToE2, 1},
6167 Counter{cSubDelRespFromE2, 1},
6168 Counter{cRestSubDelRespToXapp, 1},
6171 // Create subscription
6172 var params *teststube2ap.RESTSubsReqParams = nil
6173 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
6174 xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
6176 // Check subscription
6177 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
6179 mainCtrl.SimulateRestart(t)
6180 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
6182 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
6183 // That needs to be completed before successful subscription query is possible
6184 <-time.After(time.Second * 1)
6186 // Check subscription
6187 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
6189 // Delete subscription
6190 deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
6192 //Wait that subs is cleaned
6193 waitSubsCleanup(t, e2SubsId, 10)
6195 mainCtrl.VerifyCounterValues(t)
6196 mainCtrl.VerifyAllClean(t)
6199 //-----------------------------------------------------------------------------
6200 // TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle
6203 // +-------+ +-------+ +---------+ +---------+
6204 // | xapp2 | | xapp1 | | submgr | | e2term |
6205 // +-------+ +-------+ +---------+ +---------+
6207 // | | RESTSubReq1 | |
6208 // | |---------------->| |
6210 // | | RESTSubResp1 | |
6211 // | |<----------------| |
6214 // | | |------------->|
6216 // | | |<-------------|
6217 // | | RESTNotif1 | |
6218 // | |<----------------| |
6220 // | RESTSubReq2 | |
6221 // |------------------------------>| |
6223 // | RESTSubResp2 | |
6224 // |<------------------------------| |
6226 // | | RESTNotif2 | |
6227 // |<------------------------------| |
6229 // | | Submgr restart |
6231 // | | RESTSubDelReq1 | |
6232 // | |---------------->| |
6234 // | | RESTSubDelResp1 | |
6235 // | |<----------------| |
6237 // | | Submgr restart |
6239 // | RESTSubDelReq2 | |
6240 // |------------------------------>| |
6242 // | RESTSubDelResp2 | |
6243 // |<------------------------------| |
6245 // | | | SubDelReq2 |
6246 // | | |------------->|
6248 // | | | SubDelResp2 |
6249 // | | |<-------------|
6252 //-----------------------------------------------------------------------------
6253 func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
6255 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6256 Counter{cRestSubReqFromXapp, 2},
6257 Counter{cRestSubRespToXapp, 2},
6258 Counter{cSubReqToE2, 1},
6259 Counter{cSubRespFromE2, 1},
6260 Counter{cRestSubNotifToXapp, 2},
6261 Counter{cMergedSubscriptions, 1},
6262 Counter{cUnmergedSubscriptions, 1},
6263 Counter{cRestSubDelReqFromXapp, 2},
6264 Counter{cSubDelReqToE2, 1},
6265 Counter{cSubDelRespFromE2, 1},
6266 Counter{cRestSubDelRespToXapp, 2},
6269 // Create subscription 1
6270 var params *teststube2ap.RESTSubsReqParams = nil
6271 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
6272 xapp.Logger.Debug("Send REST subscriber request for subscriber 1 : %v", restSubId1)
6274 // Create subscription 2 with same action
6275 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
6276 params.SetMeid("RAN_NAME_1")
6277 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
6278 xappConn2.ExpectAnyNotification(t)
6279 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
6280 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
6281 e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
6282 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId2)
6284 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
6286 mainCtrl.SimulateRestart(t)
6287 xapp.Logger.Debug("mainCtrl.SimulateRestart done 1")
6289 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
6290 // That needs to be completed before successful subscription delete is possible
6291 <-time.After(time.Second * 1)
6293 // Delete subscription 1, and wait until it has removed the first endpoint
6294 xappConn1.SendRESTSubsDelReq(t, &restSubId1)
6295 mainCtrl.WaitRESTSubscriptionDelete(restSubId1)
6296 // Above wait does not work correctly anymore as this delay makes this test case work
6298 mainCtrl.SimulateRestart(t)
6299 xapp.Logger.Debug("mainCtrl.SimulateRestart done 2")
6301 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
6302 // That needs to be completed before successful subscription query is possible
6303 <-time.After(time.Second * 1)
6305 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13660"})
6307 // Delete subscription 2
6308 deleteXapp2Subscription(t, &restSubId2)
6310 //Wait that subs is cleaned
6311 waitSubsCleanup(t, e2SubsId2, 10)
6313 mainCtrl.VerifyCounterValues(t)
6314 mainCtrl.VerifyAllClean(t)
6317 //-----------------------------------------------------------------------------
6318 // TestRESTReportSubReqAndSubDelOk
6321 // +-------+ +---------+ +---------+
6322 // | xapp | | submgr | | e2term |
6323 // +-------+ +---------+ +---------+
6326 // |---------------->| |
6328 // | RESTSubResp | |
6329 // |<----------------| |
6332 // | |------------->|
6335 // | |<-------------|
6337 // |<----------------| |
6338 // | | SubReq | // Only one request sent in the teat case
6339 // | |------------->|
6342 // | |<-------------|
6344 // |<----------------| |
6348 // | RESTSubDelReq | |
6349 // |---------------->| |
6351 // | RESTSubDelResp| |
6352 // |<----------------| |
6354 // | |------------->|
6357 // | |<-------------|
6360 //-----------------------------------------------------------------------------
6362 func TestRESTReportSubReqAndSubDelOk(t *testing.T) {
6363 const subReqCount int = 1
6365 RESTReportSubReqAndSubDelOk(t, subReqCount, testIndex)
6368 func RESTReportSubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
6369 xapp.Logger.Debug("TEST: TestRESTReportSubReqAndSubDelOk with testIndex %v", testIndex)
6371 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6372 Counter{cRestSubReqFromXapp, 1},
6373 Counter{cRestSubRespToXapp, 1},
6374 Counter{cSubReqToE2, uint64(subReqCount)},
6375 Counter{cSubRespFromE2, uint64(subReqCount)},
6376 Counter{cRestSubNotifToXapp, 1},
6377 Counter{cRestSubDelReqFromXapp, 1},
6378 Counter{cRestSubDelRespToXapp, 1},
6379 Counter{cSubDelReqToE2, uint64(subReqCount)},
6380 Counter{cSubDelRespFromE2, uint64(subReqCount)},
6384 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6385 restSubId := xappConn1.SendRESTSubsReq(t, params)
6387 var e2SubsId []uint32
6388 for i := 0; i < subReqCount; i++ {
6389 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6390 xappConn1.ExpectRESTNotification(t, restSubId)
6392 e2termConn1.SendSubsResp(t, crereq, cremsg)
6393 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
6394 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
6395 e2SubsId = append(e2SubsId, instanceId)
6396 resp, _ := xapp.Subscription.QuerySubscriptions()
6397 assert.Equal(t, resp[i].SubscriptionID, (int64)(instanceId))
6398 assert.Equal(t, resp[i].Meid, "RAN_NAME_1")
6399 assert.Equal(t, resp[i].ClientEndpoint, []string{"localhost:13560"})
6404 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6406 for i := 0; i < subReqCount; i++ {
6407 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
6408 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
6411 // Wait that subs is cleaned
6412 for i := 0; i < subReqCount; i++ {
6413 mainCtrl.wait_subs_clean(t, e2SubsId[i], 10)
6416 xappConn1.TestMsgChanEmpty(t)
6417 e2termConn1.TestMsgChanEmpty(t)
6418 mainCtrl.wait_registry_empty(t, 10)
6419 mainCtrl.VerifyAllClean(t)
6420 mainCtrl.VerifyCounterValues(t)
6423 //-----------------------------------------------------------------------------
6424 // TestRESTTwoPolicySubReqAndSubDelOk
6427 // +-------+ +---------+ +---------+
6428 // | xapp | | submgr | | e2term |
6429 // +-------+ +---------+ +---------+
6432 // |---------------->| |
6434 // | RESTSubResp | |
6435 // |<----------------| |
6438 // | |------------->|
6441 // | |<-------------|
6443 // |<----------------| |
6445 // | |------------->|
6448 // | |<-------------|
6450 // |<----------------| |
6452 // | RESTSubDelReq | |
6453 // |---------------->| |
6455 // | RESTSubDelResp| |
6456 // |<----------------| |
6458 // | |------------->|
6461 // | |<-------------|
6464 // | |------------->|
6467 // | |<-------------|
6470 //-----------------------------------------------------------------------------
6472 func TestRESTTwoPolicySubReqAndSubDelOk(t *testing.T) {
6474 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6475 Counter{cRestSubReqFromXapp, 1},
6476 Counter{cRestSubRespToXapp, 1},
6477 Counter{cSubReqToE2, 2},
6478 Counter{cSubRespFromE2, 2},
6479 Counter{cRestSubNotifToXapp, 2},
6480 Counter{cRestSubDelReqFromXapp, 1},
6481 Counter{cSubDelReqToE2, 2},
6482 Counter{cSubDelRespFromE2, 2},
6483 Counter{cRestSubDelRespToXapp, 1},
6486 const subReqCount int = 2
6489 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6490 restSubId := xappConn1.SendRESTSubsReq(t, params)
6491 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
6493 assert.Equal(t, len(e2SubsIds), 2)
6496 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6497 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
6499 xappConn1.TestMsgChanEmpty(t)
6500 e2termConn1.TestMsgChanEmpty(t)
6501 mainCtrl.wait_registry_empty(t, 10)
6503 mainCtrl.VerifyCounterValues(t)
6504 mainCtrl.VerifyAllClean(t)
6507 //-----------------------------------------------------------------------------
6508 // TestRESTPolicySubReqAndSubDelOk19E2Subs
6511 // +-------+ +---------+ +---------+
6512 // | xapp | | submgr | | e2term |
6513 // +-------+ +---------+ +---------+
6516 // |---------------->| |
6518 // | RESTSubResp | |
6519 // |<----------------| |
6522 // | |------------->|
6523 // | | | E2 subscription x 19
6525 // | |<-------------|
6527 // |<----------------| |
6529 // | RESTSubDelReq | |
6530 // |---------------->| |
6532 // | RESTSubDelResp| |
6533 // |<----------------| |
6534 // | | SubDelReq | ------
6535 // | |------------->|
6536 // | | | E2 subscription delete x 19
6538 // | |<-------------|
6542 //-----------------------------------------------------------------------------
6544 func TestRESTPolicySubReqAndSubDelOk19E2Subs(t *testing.T) {
6546 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6547 Counter{cRestSubReqFromXapp, 1},
6548 Counter{cRestSubRespToXapp, 1},
6549 Counter{cSubReqToE2, 19},
6550 Counter{cSubRespFromE2, 19},
6551 Counter{cRestSubNotifToXapp, 19},
6552 Counter{cRestSubDelReqFromXapp, 1},
6553 Counter{cSubDelReqToE2, 19},
6554 Counter{cSubDelRespFromE2, 19},
6555 Counter{cRestSubDelRespToXapp, 1},
6558 const subReqCount int = 19
6560 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
6561 restSubId := xappConn1.SendRESTSubsReq(t, params)
6562 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
6564 assert.Equal(t, len(e2SubsIds), 19)
6566 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6567 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
6569 xappConn1.TestMsgChanEmpty(t)
6570 e2termConn1.TestMsgChanEmpty(t)
6571 mainCtrl.wait_registry_empty(t, 10)
6573 mainCtrl.VerifyCounterValues(t)
6574 mainCtrl.VerifyAllClean(t)
6577 //-----------------------------------------------------------------------------
6578 // TestRESTTwoPolicySubReqAndSubDelOk
6581 // +-------+ +---------+ +---------+
6582 // | xapp | | submgr | | e2term |
6583 // +-------+ +---------+ +---------+
6586 // |---------------->| |
6588 // | RESTSubResp | |
6589 // |<----------------| |
6592 // | |------------->|
6595 // | |<-------------|
6597 // |<----------------| |
6599 // | |------------->|
6602 // | |<-------------|
6604 // |<----------------| |
6606 // | RESTSubDelReq | |
6607 // |---------------->| |
6609 // | RESTSubDelResp| |
6610 // |<----------------| |
6612 // | |------------->|
6615 // | |<-------------|
6618 // | |------------->|
6621 // | |<-------------|
6624 //-----------------------------------------------------------------------------
6626 func TestRESTTwoReportSubReqAndSubDelOk(t *testing.T) {
6630 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6631 Counter{cRestSubReqFromXapp, 1},
6632 Counter{cRestSubRespToXapp, 1},
6633 Counter{cSubReqToE2, uint64(subReqCount)},
6634 Counter{cSubRespFromE2, uint64(subReqCount)},
6635 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
6636 Counter{cRestSubDelReqFromXapp, 1},
6637 Counter{cSubDelReqToE2, uint64(subReqCount)},
6638 Counter{cSubDelRespFromE2, uint64(subReqCount)},
6639 Counter{cRestSubDelRespToXapp, 1},
6643 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6644 restSubId := xappConn1.SendRESTSubsReq(t, params)
6645 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
6647 assert.Equal(t, len(e2SubsIds), subReqCount)
6650 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6651 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
6653 xappConn1.TestMsgChanEmpty(t)
6654 e2termConn1.TestMsgChanEmpty(t)
6655 mainCtrl.wait_registry_empty(t, 10)
6657 mainCtrl.VerifyCounterValues(t)
6658 mainCtrl.VerifyAllClean(t)
6661 //-----------------------------------------------------------------------------
6662 // TestRESTTwoReportSubReqAndSubDelOkNoActParams
6665 // +-------+ +---------+ +---------+
6666 // | xapp | | submgr | | e2term |
6667 // +-------+ +---------+ +---------+
6670 // |---------------->| |
6672 // | RESTSubResp | |
6673 // |<----------------| |
6676 // | |------------->|
6679 // | |<-------------|
6681 // |<----------------| |
6683 // | |------------->|
6686 // | |<-------------|
6688 // |<----------------| |
6690 // | RESTSubDelReq | |
6691 // |---------------->| |
6693 // | RESTSubDelResp| |
6694 // |<----------------| |
6696 // | |------------->|
6699 // | |<-------------|
6702 // | |------------->|
6705 // | |<-------------|
6708 //-----------------------------------------------------------------------------
6710 func TestRESTTwoReportSubReqAndSubDelOkNoActParams(t *testing.T) {
6714 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6715 Counter{cRestSubReqFromXapp, 1},
6716 Counter{cRestSubRespToXapp, 1},
6717 Counter{cSubReqToE2, uint64(subReqCount)},
6718 Counter{cSubRespFromE2, uint64(subReqCount)},
6719 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
6720 Counter{cRestSubDelReqFromXapp, 1},
6721 Counter{cSubDelReqToE2, uint64(subReqCount)},
6722 Counter{cSubDelRespFromE2, uint64(subReqCount)},
6723 Counter{cRestSubDelRespToXapp, 1},
6727 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6728 restSubId := xappConn1.SendRESTSubsReq(t, params)
6729 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
6731 assert.Equal(t, len(e2SubsIds), subReqCount)
6734 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6735 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
6737 xappConn1.TestMsgChanEmpty(t)
6738 e2termConn1.TestMsgChanEmpty(t)
6739 mainCtrl.wait_registry_empty(t, 10)
6741 mainCtrl.VerifyCounterValues(t)
6742 mainCtrl.VerifyAllClean(t)
6745 //-----------------------------------------------------------------------------
6746 // TestRESTReportSubReqAndSubDelOk19E2Subs
6749 // +-------+ +---------+ +---------+
6750 // | xapp | | submgr | | e2term |
6751 // +-------+ +---------+ +---------+
6754 // |---------------->| |
6756 // | RESTSubResp | |
6757 // |<----------------| |
6760 // | |------------->|
6761 // | | | E2 subscription x 19
6763 // | |<-------------|
6765 // |<----------------| |
6767 // | RESTSubDelReq | |
6768 // |---------------->| |
6770 // | RESTSubDelResp| |
6771 // |<----------------| |
6772 // | | SubDelReq | ------
6773 // | |------------->|
6774 // | | | E2 subscription delete x 19
6776 // | |<-------------|
6780 //-----------------------------------------------------------------------------
6782 func TestRESTReportSubReqAndSubDelOk19E2Subs(t *testing.T) {
6786 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6787 Counter{cRestSubReqFromXapp, 1},
6788 Counter{cRestSubRespToXapp, 1},
6789 Counter{cSubReqToE2, uint64(subReqCount)},
6790 Counter{cSubRespFromE2, uint64(subReqCount)},
6791 Counter{cRestSubNotifToXapp, uint64(subReqCount)},
6792 Counter{cRestSubDelReqFromXapp, 1},
6793 Counter{cSubDelReqToE2, uint64(subReqCount)},
6794 Counter{cSubDelRespFromE2, uint64(subReqCount)},
6795 Counter{cRestSubDelRespToXapp, 1},
6799 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
6800 restSubId := xappConn1.SendRESTSubsReq(t, params)
6801 e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
6803 assert.Equal(t, len(e2SubsIds), subReqCount)
6806 xappConn1.SendRESTSubsDelReq(t, &restSubId)
6807 sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
6809 xappConn1.TestMsgChanEmpty(t)
6810 e2termConn1.TestMsgChanEmpty(t)
6811 mainCtrl.wait_registry_empty(t, 10)
6813 mainCtrl.VerifyCounterValues(t)
6814 mainCtrl.VerifyAllClean(t)
6817 //-----------------------------------------------------------------------------
6818 // TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen
6821 // +-------+ +-------+ +---------+ +---------+
6822 // | xapp2 | | xapp1 | | submgr | | e2term |
6823 // +-------+ +-------+ +---------+ +---------+
6825 // | | RESTSubReq1 | |
6826 // | |------------->| |
6827 // | | RESTSubResp1 | |
6828 // | |<-------------| |
6831 // | | |------------->|
6833 // | RESTSubReq2 | |
6834 // |------------------------>| |
6835 // | RESTSubResp2 | |
6836 // |<------------------------| |
6839 // | | |------------->|
6842 // | | |<-------------|
6843 // | | RESTNotif1 | |
6844 // | |<-------------| |
6847 // | | |<-------------|
6849 // |<------------------------| |
6851 // | | [SUBS 1 DELETE] |
6853 // | | [SUBS 2 DELETE] |
6856 //-----------------------------------------------------------------------------
6858 func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(t *testing.T) {
6860 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6861 Counter{cRestSubReqFromXapp, 2},
6862 Counter{cRestSubRespToXapp, 2},
6863 Counter{cSubReqToE2, 2},
6864 Counter{cSubRespFromE2, 2},
6865 Counter{cRestSubNotifToXapp, 2},
6866 Counter{cRestSubDelReqFromXapp, 2},
6867 Counter{cSubDelReqToE2, 2},
6868 Counter{cSubDelRespFromE2, 2},
6869 Counter{cRestSubDelRespToXapp, 2},
6873 var params *teststube2ap.RESTSubsReqParams = nil
6876 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
6877 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
6879 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
6882 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
6883 params.SetMeid("RAN_NAME_1")
6884 eventTriggerDefinition := []int64{1234, 1}
6885 params.SetSubEventTriggerDefinition(eventTriggerDefinition)
6887 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
6888 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
6889 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6890 xappConn2.ExpectRESTNotification(t, restSubId2)
6891 e2termConn1.SendSubsResp(t, crereq, cremsg)
6892 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
6894 deleteXapp1Subscription(t, &restSubId1)
6895 deleteXapp2Subscription(t, &restSubId2)
6897 waitSubsCleanup(t, e2SubsId1, 10)
6898 waitSubsCleanup(t, e2SubsId2, 10)
6900 mainCtrl.VerifyCounterValues(t)
6901 mainCtrl.VerifyAllClean(t)
6904 //-----------------------------------------------------------------------------
6905 // TestRESTSubReqReportSameActionDiffActionListLen
6908 // +-------+ +-------+ +---------+ +---------+
6909 // | xapp2 | | xapp1 | | submgr | | e2term |
6910 // +-------+ +-------+ +---------+ +---------+
6912 // | | RESTSubReq1 | |
6913 // | |------------->| |
6914 // | | RESTSubResp1 | |
6915 // | |<-------------| |
6918 // | | |------------->|
6920 // | RESTSubReq2 | |
6921 // |------------------------>| |
6922 // | RESTSubResp2 | |
6923 // |<------------------------| |
6926 // | | |------------->|
6929 // | | |<-------------|
6930 // | | RESTNotif1 | |
6931 // | |<-------------| |
6934 // | | |<-------------|
6936 // |<------------------------| |
6938 // | | [SUBS 1 DELETE] |
6940 // | | [SUBS 2 DELETE] |
6943 //-----------------------------------------------------------------------------
6945 func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) {
6947 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
6948 Counter{cRestSubReqFromXapp, 2},
6949 Counter{cRestSubRespToXapp, 2},
6950 Counter{cSubReqToE2, 2},
6951 Counter{cSubRespFromE2, 2},
6952 Counter{cRestSubNotifToXapp, 2},
6953 Counter{cRestSubDelReqFromXapp, 2},
6954 Counter{cSubDelReqToE2, 2},
6955 Counter{cSubDelRespFromE2, 2},
6956 Counter{cRestSubDelRespToXapp, 2},
6960 var params *teststube2ap.RESTSubsReqParams = nil
6963 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
6964 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
6966 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
6969 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
6970 params.SetMeid("RAN_NAME_1")
6972 actionId := int64(1)
6973 actionType := "report"
6974 actionDefinition := []int64{5678, 1}
6975 subsequestActionType := "continue"
6976 timeToWait := "w10ms"
6977 params.AppendActionToActionToBeSetupList(actionId, actionType, actionDefinition, subsequestActionType, timeToWait)
6979 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
6980 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
6981 crereq, cremsg := e2termConn1.RecvSubsReq(t)
6982 xappConn2.ExpectRESTNotification(t, restSubId2)
6983 e2termConn1.SendSubsResp(t, crereq, cremsg)
6984 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
6986 deleteXapp1Subscription(t, &restSubId1)
6987 deleteXapp2Subscription(t, &restSubId2)
6989 waitSubsCleanup(t, e2SubsId1, 10)
6990 waitSubsCleanup(t, e2SubsId2, 10)
6992 mainCtrl.VerifyCounterValues(t)
6993 mainCtrl.VerifyAllClean(t)
6996 //-----------------------------------------------------------------------------
6997 // TestRESTSubReqReportSameActionDiffActionID
7000 // +-------+ +-------+ +---------+ +---------+
7001 // | xapp2 | | xapp1 | | submgr | | e2term |
7002 // +-------+ +-------+ +---------+ +---------+
7004 // | | RESTSubReq1 | |
7005 // | |------------->| |
7006 // | | RESTSubResp1 | |
7007 // | |<-------------| |
7010 // | | |------------->|
7012 // | RESTSubReq2 | |
7013 // |------------------------>| |
7014 // | RESTSubResp2 | |
7015 // |<------------------------| |
7018 // | | |------------->|
7021 // | | |<-------------|
7022 // | | RESTNotif1 | |
7023 // | |<-------------| |
7026 // | | |<-------------|
7028 // |<------------------------| |
7030 // | | [SUBS 1 DELETE] |
7032 // | | [SUBS 2 DELETE] |
7035 //-----------------------------------------------------------------------------
7037 func TestRESTSubReqReportSameActionDiffActionID(t *testing.T) {
7039 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7040 Counter{cRestSubReqFromXapp, 2},
7041 Counter{cRestSubRespToXapp, 2},
7042 Counter{cSubReqToE2, 2},
7043 Counter{cSubRespFromE2, 2},
7044 Counter{cRestSubNotifToXapp, 2},
7045 Counter{cRestSubDelReqFromXapp, 2},
7046 Counter{cSubDelReqToE2, 2},
7047 Counter{cSubDelRespFromE2, 2},
7048 Counter{cRestSubDelRespToXapp, 2},
7052 var params *teststube2ap.RESTSubsReqParams = nil
7055 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
7056 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
7058 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
7061 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
7062 params.SetMeid("RAN_NAME_1")
7063 params.SetSubActionIDs(int64(2))
7065 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
7066 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
7067 crereq, cremsg := e2termConn1.RecvSubsReq(t)
7068 xappConn2.ExpectRESTNotification(t, restSubId2)
7069 e2termConn1.SendSubsResp(t, crereq, cremsg)
7070 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
7072 deleteXapp1Subscription(t, &restSubId1)
7073 deleteXapp2Subscription(t, &restSubId2)
7075 waitSubsCleanup(t, e2SubsId1, 10)
7076 waitSubsCleanup(t, e2SubsId2, 10)
7078 mainCtrl.VerifyCounterValues(t)
7079 mainCtrl.VerifyAllClean(t)
7082 //-----------------------------------------------------------------------------
7083 // TestRESTSubReqDiffActionType
7086 // +-------+ +-------+ +---------+ +---------+
7087 // | xapp2 | | xapp1 | | submgr | | e2term |
7088 // +-------+ +-------+ +---------+ +---------+
7090 // | | RESTSubReq1 | |
7091 // | |------------->| |
7092 // | | RESTSubResp1 | |
7093 // | |<-------------| |
7096 // | | |------------->|
7098 // | RESTSubReq2 | |
7099 // |------------------------>| |
7100 // | RESTSubResp2 | |
7101 // |<------------------------| |
7104 // | | |------------->|
7107 // | | |<-------------|
7108 // | | RESTNotif1 | |
7109 // | |<-------------| |
7112 // | | |<-------------|
7114 // |<------------------------| |
7116 // | | [SUBS 1 DELETE] |
7118 // | | [SUBS 2 DELETE] |
7121 //-----------------------------------------------------------------------------
7123 func TestRESTSubReqDiffActionType(t *testing.T) {
7125 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7126 Counter{cRestSubReqFromXapp, 2},
7127 Counter{cRestSubRespToXapp, 2},
7128 Counter{cSubReqToE2, 2},
7129 Counter{cSubRespFromE2, 2},
7130 Counter{cRestSubNotifToXapp, 2},
7131 Counter{cRestSubDelReqFromXapp, 2},
7132 Counter{cSubDelReqToE2, 2},
7133 Counter{cSubDelRespFromE2, 2},
7134 Counter{cRestSubDelRespToXapp, 2},
7137 const e2Timeout int64 = 2
7138 const e2RetryCount int64 = 2
7139 const routingNeeded bool = true
7142 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
7143 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
7146 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
7147 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
7149 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
7152 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
7153 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
7154 params.SetMeid("RAN_NAME_1")
7156 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
7157 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
7158 crereq, cremsg := e2termConn1.RecvSubsReq(t)
7159 xappConn2.ExpectRESTNotification(t, restSubId2)
7160 e2termConn1.SendSubsResp(t, crereq, cremsg)
7161 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
7163 deleteXapp1Subscription(t, &restSubId1)
7164 deleteXapp2Subscription(t, &restSubId2)
7166 waitSubsCleanup(t, e2SubsId1, 10)
7167 waitSubsCleanup(t, e2SubsId2, 10)
7169 mainCtrl.VerifyCounterValues(t)
7170 mainCtrl.VerifyAllClean(t)
7173 //-----------------------------------------------------------------------------
7174 // TestRESTSubReqPolicyAndSubDelOkSameAction
7177 // +-------+ +-------+ +---------+ +---------+
7178 // | xapp2 | | xapp1 | | submgr | | e2term |
7179 // +-------+ +-------+ +---------+ +---------+
7181 // | | RESTSubReq1 | |
7182 // | |------------->| |
7183 // | | RESTSubResp1 | |
7184 // | |<-------------| |
7187 // | | |------------->|
7189 // | RESTSubReq2 | |
7190 // |------------------------>| |
7191 // | RESTSubResp2 | |
7192 // |<------------------------| |
7195 // | | |------------->|
7198 // | | |<-------------|
7199 // | | RESTNotif1 | |
7200 // | |<-------------| |
7203 // | | |<-------------|
7205 // |<------------------------| |
7207 // | | [SUBS 1 DELETE] |
7209 // | | [SUBS 2 DELETE] |
7212 //-----------------------------------------------------------------------------
7214 func TestRESTSubReqPolicyAndSubDelOkSameAction(t *testing.T) {
7216 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7217 Counter{cRestSubReqFromXapp, 2},
7218 Counter{cRestSubRespToXapp, 2},
7219 Counter{cSubReqToE2, 2},
7220 Counter{cSubRespFromE2, 2},
7221 Counter{cRestSubNotifToXapp, 2},
7222 Counter{cRestSubDelReqFromXapp, 2},
7223 Counter{cSubDelReqToE2, 2},
7224 Counter{cSubDelRespFromE2, 2},
7225 Counter{cRestSubDelRespToXapp, 2},
7228 const e2Timeout int64 = 2
7229 const e2RetryCount int64 = 2
7230 const routingNeeded bool = true
7233 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
7234 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
7237 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
7238 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
7240 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
7243 params = xappConn2.GetRESTSubsReqPolicyParams(subReqCount)
7244 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
7245 params.SetMeid("RAN_NAME_1")
7247 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
7248 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
7249 crereq, cremsg := e2termConn1.RecvSubsReq(t)
7250 xappConn2.ExpectRESTNotification(t, restSubId2)
7251 e2termConn1.SendSubsResp(t, crereq, cremsg)
7252 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
7254 deleteXapp1Subscription(t, &restSubId1)
7255 deleteXapp2Subscription(t, &restSubId2)
7257 waitSubsCleanup(t, e2SubsId1, 10)
7258 waitSubsCleanup(t, e2SubsId2, 10)
7260 mainCtrl.VerifyCounterValues(t)
7261 mainCtrl.VerifyAllClean(t)
7264 //-----------------------------------------------------------------------------
7265 // TestRESTSubReqReportSameActionDiffActionDefinitionLen
7268 // +-------+ +-------+ +---------+ +---------+
7269 // | xapp2 | | xapp1 | | submgr | | e2term |
7270 // +-------+ +-------+ +---------+ +---------+
7272 // | | RESTSubReq1 | |
7273 // | |------------->| |
7274 // | | RESTSubResp1 | |
7275 // | |<-------------| |
7278 // | | |------------->|
7280 // | RESTSubReq2 | |
7281 // |------------------------>| |
7282 // | RESTSubResp2 | |
7283 // |<------------------------| |
7286 // | | |------------->|
7289 // | | |<-------------|
7290 // | | RESTNotif1 | |
7291 // | |<-------------| |
7294 // | | |<-------------|
7296 // |<------------------------| |
7298 // | | [SUBS 1 DELETE] |
7300 // | | [SUBS 2 DELETE] |
7303 //-----------------------------------------------------------------------------
7305 func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) {
7307 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7308 Counter{cRestSubReqFromXapp, 2},
7309 Counter{cRestSubRespToXapp, 2},
7310 Counter{cSubReqToE2, 2},
7311 Counter{cSubRespFromE2, 2},
7312 Counter{cRestSubNotifToXapp, 2},
7313 Counter{cRestSubDelReqFromXapp, 2},
7314 Counter{cSubDelReqToE2, 2},
7315 Counter{cSubDelRespFromE2, 2},
7316 Counter{cRestSubDelRespToXapp, 2},
7320 var params *teststube2ap.RESTSubsReqParams = nil
7323 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
7324 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
7326 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
7329 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
7330 params.SetMeid("RAN_NAME_1")
7331 actionDefinition := []int64{5678, 1}
7332 params.SetSubActionDefinition(actionDefinition)
7334 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
7335 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
7336 crereq, cremsg := e2termConn1.RecvSubsReq(t)
7337 xappConn2.ExpectRESTNotification(t, restSubId2)
7338 e2termConn1.SendSubsResp(t, crereq, cremsg)
7339 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
7341 deleteXapp1Subscription(t, &restSubId1)
7342 deleteXapp2Subscription(t, &restSubId2)
7344 waitSubsCleanup(t, e2SubsId1, 10)
7345 waitSubsCleanup(t, e2SubsId2, 10)
7347 mainCtrl.VerifyCounterValues(t)
7348 mainCtrl.VerifyAllClean(t)
7351 //-----------------------------------------------------------------------------
7352 // TestRESTSubReqReportSameActionDiffActionDefinitionContents
7355 // +-------+ +-------+ +---------+ +---------+
7356 // | xapp2 | | xapp1 | | submgr | | e2term |
7357 // +-------+ +-------+ +---------+ +---------+
7359 // | | RESTSubReq1 | |
7360 // | |------------->| |
7361 // | | RESTSubResp1 | |
7362 // | |<-------------| |
7365 // | | |------------->|
7367 // | RESTSubReq2 | |
7368 // |------------------------>| |
7369 // | RESTSubResp2 | |
7370 // |<------------------------| |
7373 // | | |------------->|
7376 // | | |<-------------|
7377 // | | RESTNotif1 | |
7378 // | |<-------------| |
7381 // | | |<-------------|
7383 // |<------------------------| |
7385 // | | [SUBS 1 DELETE] |
7387 // | | [SUBS 2 DELETE] |
7390 //-----------------------------------------------------------------------------
7392 func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) {
7394 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7395 Counter{cRestSubReqFromXapp, 2},
7396 Counter{cRestSubRespToXapp, 2},
7397 Counter{cSubReqToE2, 2},
7398 Counter{cSubRespFromE2, 2},
7399 Counter{cRestSubNotifToXapp, 2},
7400 Counter{cRestSubDelReqFromXapp, 2},
7401 Counter{cSubDelReqToE2, 2},
7402 Counter{cSubDelRespFromE2, 2},
7403 Counter{cRestSubDelRespToXapp, 2},
7407 var params *teststube2ap.RESTSubsReqParams = nil
7410 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
7411 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
7413 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
7416 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
7417 params.SetMeid("RAN_NAME_1")
7418 actionDefinition := []int64{56782}
7419 params.SetSubActionDefinition(actionDefinition)
7421 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
7422 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
7423 crereq, cremsg := e2termConn1.RecvSubsReq(t)
7424 xappConn2.ExpectRESTNotification(t, restSubId2)
7425 e2termConn1.SendSubsResp(t, crereq, cremsg)
7426 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
7428 deleteXapp1Subscription(t, &restSubId1)
7429 deleteXapp2Subscription(t, &restSubId2)
7431 waitSubsCleanup(t, e2SubsId1, 10)
7432 waitSubsCleanup(t, e2SubsId2, 10)
7434 mainCtrl.VerifyCounterValues(t)
7435 mainCtrl.VerifyAllClean(t)
7438 //-----------------------------------------------------------------------------
7439 // TestRESTSubReqReportSameActionDiffSubsAction
7442 // +-------+ +-------+ +---------+ +---------+
7443 // | xapp2 | | xapp1 | | submgr | | e2term |
7444 // +-------+ +-------+ +---------+ +---------+
7446 // | | RESTSubReq1 | |
7447 // | |------------->| |
7448 // | | RESTSubResp1 | |
7449 // | |<-------------| |
7452 // | | |------------->|
7454 // | RESTSubReq2 | |
7455 // |------------------------>| |
7456 // | RESTSubResp2 | |
7457 // |<------------------------| |
7460 // | | |------------->|
7463 // | | |<-------------|
7464 // | | RESTNotif1 | |
7465 // | |<-------------| |
7468 // | | |<-------------|
7470 // |<------------------------| |
7472 // | | [SUBS 1 DELETE] |
7474 // | | [SUBS 2 DELETE] |
7477 //-----------------------------------------------------------------------------
7479 func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) {
7481 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7482 Counter{cRestSubReqFromXapp, 2},
7483 Counter{cRestSubRespToXapp, 2},
7484 Counter{cSubReqToE2, 2},
7485 Counter{cSubRespFromE2, 2},
7486 Counter{cRestSubNotifToXapp, 2},
7487 Counter{cRestSubDelReqFromXapp, 2},
7488 Counter{cSubDelReqToE2, 2},
7489 Counter{cSubDelRespFromE2, 2},
7490 Counter{cRestSubDelRespToXapp, 2},
7494 var params *teststube2ap.RESTSubsReqParams = nil
7497 restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
7498 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
7500 queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
7503 params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
7504 params.SetMeid("RAN_NAME_1")
7505 params.SetTimeToWait("w200ms")
7506 restSubId2 := xappConn2.SendRESTSubsReq(t, params)
7507 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
7508 crereq, cremsg := e2termConn1.RecvSubsReq(t)
7509 xappConn2.ExpectRESTNotification(t, restSubId2)
7510 e2termConn1.SendSubsResp(t, crereq, cremsg)
7511 e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
7513 deleteXapp1Subscription(t, &restSubId1)
7514 deleteXapp2Subscription(t, &restSubId2)
7516 waitSubsCleanup(t, e2SubsId1, 10)
7517 waitSubsCleanup(t, e2SubsId2, 10)
7519 mainCtrl.VerifyCounterValues(t)
7520 mainCtrl.VerifyAllClean(t)
7523 //-----------------------------------------------------------------------------
7524 // TestRESTUnpackSubscriptionResponseDecodeFail
7527 // +-------+ +---------+ +---------+
7528 // | xapp | | submgr | | e2term |
7529 // +-------+ +---------+ +---------+
7532 // |---------------->| |
7534 // | RESTSubResp | |
7535 // |<----------------| |
7538 // | |------------->|
7540 // | | SubResp | ASN.1 decode fails
7541 // | |<-------------| Decode failed. More data needed. This will result timer expiry and resending
7544 // | |------------->|
7546 // | | SubFail | Duplicated action
7547 // | |<-------------|
7548 // | RESTNotif (fail)| |
7549 // |<----------------| |
7551 // | [SUBS DELETE] |
7554 //-----------------------------------------------------------------------------
7556 func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) {
7558 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7559 Counter{cRestSubReqFromXapp, 1},
7560 Counter{cRestSubRespToXapp, 1},
7561 Counter{cSubReqToE2, 1},
7562 Counter{cSubReqTimerExpiry, 1},
7563 Counter{cSubReReqToE2, 1},
7564 Counter{cSubRespFromE2, 1},
7565 Counter{cSubFailFromE2, 1},
7566 Counter{cRestSubFailNotifToXapp, 1},
7567 Counter{cRestSubDelReqFromXapp, 1},
7568 Counter{cRestSubDelRespToXapp, 1},
7571 const subReqCount int = 1
7574 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
7575 restSubId := xappConn1.SendRESTSubsReq(t, params)
7577 crereq, cremsg := e2termConn1.RecvSubsReq(t)
7578 // Decode of this response fails which will result resending original request
7579 e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_RESP)
7581 _, cremsg = e2termConn1.RecvSubsReq(t)
7583 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
7585 // Subscription already created in E2 Node.
7586 fparams := &teststube2ap.E2StubSubsFailParams{}
7588 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
7589 e2termConn1.SendSubsFail(t, fparams, cremsg)
7591 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
7592 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
7594 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7596 // Wait that subs is cleaned
7597 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
7599 xappConn1.TestMsgChanEmpty(t)
7600 e2termConn1.TestMsgChanEmpty(t)
7601 mainCtrl.wait_registry_empty(t, 10)
7602 mainCtrl.VerifyAllClean(t)
7603 mainCtrl.VerifyCounterValues(t)
7606 //-----------------------------------------------------------------------------
7607 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
7610 // +-------+ +---------+ +---------+
7611 // | xapp | | submgr | | e2term |
7612 // +-------+ +---------+ +---------+
7615 // |---------------->| |
7617 // | RESTSubResp | |
7618 // |<----------------| |
7621 // | |------------->|
7623 // | | SubResp | Unknown instanceId
7624 // | |<-------------| No valid subscription found with subIds [0]
7627 // | |------------->|
7629 // | | SubFail | Duplicated action
7630 // | |<-------------| No valid subscription found with subIds [0]
7631 // | RESTNotif (fail)| |
7632 // |<----------------| |
7634 // | |------------->|
7637 // | |<-------------|
7639 // | [SUBS DELETE] |
7642 //-----------------------------------------------------------------------------
7644 func TestRESTUnpackSubscriptionResponseUnknownInstanceId(t *testing.T) {
7646 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7647 Counter{cRestSubReqFromXapp, 1},
7648 Counter{cRestSubRespToXapp, 1},
7649 Counter{cSubReqToE2, 1},
7650 Counter{cSubReqTimerExpiry, 2},
7651 Counter{cSubReReqToE2, 1},
7652 Counter{cSubRespFromE2, 1},
7653 Counter{cSubFailFromE2, 1},
7654 Counter{cRestSubFailNotifToXapp, 1},
7655 Counter{cRestSubDelReqFromXapp, 1},
7656 Counter{cRestSubDelRespToXapp, 1},
7657 Counter{cSubDelReqToE2, 1},
7658 Counter{cSubDelRespFromE2, 1},
7661 const subReqCount int = 1
7664 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
7665 restSubId := xappConn1.SendRESTSubsReq(t, params)
7667 crereq, cremsg := e2termConn1.RecvSubsReq(t)
7669 // Unknown instanceId 0 in this response which will result resending original request
7670 orgInstanceId := crereq.RequestId.InstanceId
7671 crereq.RequestId.InstanceId = 0
7672 e2termConn1.SendSubsResp(t, crereq, cremsg)
7674 _, cremsg = e2termConn1.RecvSubsReq(t)
7676 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
7678 // Subscription already created in E2 Node. E2 Node responds with failure but there is also same unknown instanceId 0
7679 fparams := &teststube2ap.E2StubSubsFailParams{}
7681 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
7682 e2termConn1.SendSubsFail(t, fparams, cremsg)
7684 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7685 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7687 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
7688 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
7690 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7692 // Wait that subs is cleaned
7693 mainCtrl.wait_subs_clean(t, orgInstanceId, 10)
7695 xappConn1.TestMsgChanEmpty(t)
7696 e2termConn1.TestMsgChanEmpty(t)
7697 mainCtrl.wait_registry_empty(t, 10)
7698 mainCtrl.VerifyAllClean(t)
7699 mainCtrl.VerifyCounterValues(t)
7702 //-----------------------------------------------------------------------------
7703 // TestRESTUnpackSubscriptionResponseNoTransaction
7706 // +-------+ +---------+ +---------+
7707 // | xapp | | submgr | | e2term |
7708 // +-------+ +---------+ +---------+
7711 // |---------------->| |
7713 // | RESTSubResp | |
7714 // |<----------------| |
7717 // | |------------->|
7719 // | | SubResp | No transaction for the response
7720 // | |<-------------| Ongoing transaction not found. This will result timer expiry and resending
7723 // | |------------->|
7725 // | | SubFail | Duplicated action
7726 // | |<-------------|Ongoing transaction not found. This will result timer expiry and sending delete
7727 // | RESTNotif (fail)| |
7728 // |<----------------| |
7730 // | |------------->|
7733 // | |<-------------| Ongoing transaction not found. This will result timer expiry and resending
7736 // | |------------->|
7739 // | |<-------------| Ongoing transaction not found.
7741 // | [SUBS DELETE] |
7744 //-----------------------------------------------------------------------------
7746 func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) {
7748 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7749 Counter{cRestSubReqFromXapp, 1},
7750 Counter{cRestSubRespToXapp, 1},
7751 Counter{cSubReqToE2, 1},
7752 Counter{cSubReqTimerExpiry, 2},
7753 Counter{cSubReReqToE2, 1},
7754 Counter{cSubRespFromE2, 1},
7755 Counter{cSubFailFromE2, 1},
7756 Counter{cRestSubFailNotifToXapp, 1},
7757 Counter{cRestSubDelReqFromXapp, 1},
7758 Counter{cRestSubDelRespToXapp, 1},
7759 Counter{cSubDelReqToE2, 1},
7760 Counter{cSubDelReqTimerExpiry, 2},
7761 Counter{cSubDelReReqToE2, 1},
7762 Counter{cSubDelRespFromE2, 2},
7765 const subReqCount int = 1
7768 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
7769 restSubId := xappConn1.SendRESTSubsReq(t, params)
7771 crereq, cremsg := e2termConn1.RecvSubsReq(t)
7773 mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
7774 // No transaction exist for this response which will result resending original request
7775 e2termConn1.SendSubsResp(t, crereq, cremsg)
7777 _, cremsg = e2termConn1.RecvSubsReq(t)
7779 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
7781 // Subscription already created in E2 Node.
7782 fparams := &teststube2ap.E2StubSubsFailParams{}
7784 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
7785 e2termConn1.SendSubsFail(t, fparams, cremsg)
7787 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7788 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7790 // Resending happens because there no transaction
7791 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
7792 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7794 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
7795 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
7797 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7799 // Wait that subs is cleaned
7800 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
7802 xappConn1.TestMsgChanEmpty(t)
7803 e2termConn1.TestMsgChanEmpty(t)
7804 mainCtrl.wait_registry_empty(t, 10)
7805 mainCtrl.VerifyAllClean(t)
7806 mainCtrl.VerifyCounterValues(t)
7809 //-----------------------------------------------------------------------------
7810 // TestRESTUnpackSubscriptionFailureDecodeFail
7813 // +-------+ +---------+ +---------+
7814 // | xapp | | submgr | | e2term |
7815 // +-------+ +---------+ +---------+
7818 // |---------------->| |
7820 // | RESTSubResp | |
7821 // |<----------------| |
7824 // | |------------->|
7826 // | | SubFail | ASN.1 decode fails
7827 // | |<-------------| Decode failed. More data needed. This will result timer expiry and resending
7830 // | |------------->|
7832 // | | SubFail | Duplicated action
7833 // | |<-------------|
7834 // | RESTNotif (fail)| |
7835 // |<----------------| |
7837 // | [SUBS DELETE] |
7840 //-----------------------------------------------------------------------------
7842 func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) {
7844 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7845 Counter{cRestSubReqFromXapp, 1},
7846 Counter{cRestSubRespToXapp, 1},
7847 Counter{cSubReqToE2, 1},
7848 Counter{cSubReqTimerExpiry, 1},
7849 Counter{cSubReReqToE2, 1},
7850 Counter{cSubFailFromE2, 2},
7851 Counter{cRestSubFailNotifToXapp, 1},
7852 Counter{cRestSubDelReqFromXapp, 1},
7853 Counter{cRestSubDelRespToXapp, 1},
7856 const subReqCount int = 1
7859 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
7860 restSubId := xappConn1.SendRESTSubsReq(t, params)
7862 crereq, cremsg := e2termConn1.RecvSubsReq(t)
7864 // Decode of this response fails which will result resending original request
7865 e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_FAILURE)
7867 _, cremsg = e2termConn1.RecvSubsReq(t)
7869 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
7871 // Subscription already created in E2 Node.
7872 fparams := &teststube2ap.E2StubSubsFailParams{}
7874 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
7875 e2termConn1.SendSubsFail(t, fparams, cremsg)
7877 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
7878 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
7880 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7882 // Wait that subs is cleaned
7883 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
7885 xappConn1.TestMsgChanEmpty(t)
7886 e2termConn1.TestMsgChanEmpty(t)
7887 mainCtrl.wait_registry_empty(t, 10)
7888 mainCtrl.VerifyAllClean(t)
7889 mainCtrl.VerifyCounterValues(t)
7892 //-----------------------------------------------------------------------------
7893 // TestRESTUnpackSubscriptionResponseUnknownInstanceId
7896 // +-------+ +---------+ +---------+
7897 // | xapp | | submgr | | e2term |
7898 // +-------+ +---------+ +---------+
7901 // |---------------->| |
7903 // | RESTSubResp | |
7904 // |<----------------| |
7907 // | |------------->|
7909 // | | SubFail | Unknown instanceId
7910 // | |<-------------| No valid subscription found with subIds [0]. This will result timer expiry and resending
7913 // | |------------->|
7915 // | | SubFail | Duplicated action
7916 // | |<-------------|No valid subscription found with subIds [0]. This will result timer expiry and sending delete
7917 // | RESTNotif (fail)| |
7918 // |<----------------| |
7920 // | |------------->|
7923 // | |<-------------|
7925 // | [SUBS DELETE] |
7928 //-----------------------------------------------------------------------------
7929 func TestRESTUnpackSubscriptionFailureUnknownInstanceId(t *testing.T) {
7931 const subReqCount int = 1
7933 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
7934 Counter{cRestSubReqFromXapp, 1},
7935 Counter{cRestSubRespToXapp, 1},
7936 Counter{cSubReqToE2, 1},
7937 Counter{cSubReqTimerExpiry, 2},
7938 Counter{cSubReReqToE2, 1},
7939 Counter{cSubFailFromE2, 2},
7940 Counter{cRestSubFailNotifToXapp, 1},
7941 Counter{cRestSubDelReqFromXapp, 1},
7942 Counter{cRestSubDelRespToXapp, 1},
7943 Counter{cSubDelReqToE2, 1},
7944 Counter{cSubDelRespFromE2, 1},
7948 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
7949 restSubId := xappConn1.SendRESTSubsReq(t, params)
7951 crereq, cremsg := e2termConn1.RecvSubsReq(t)
7953 // Unknown instanceId 0 in this response which will result resending original request
7954 fparams := &teststube2ap.E2StubSubsFailParams{}
7956 fparams.Fail.RequestId.InstanceId = 0
7957 e2termConn1.SendSubsFail(t, fparams, cremsg)
7959 _, cremsg = e2termConn1.RecvSubsReq(t)
7961 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
7963 // Subscription already created in E2 Node. E2 Node responds with failure but there is also same unknown instanceId 0
7964 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
7965 e2termConn1.SendSubsFail(t, fparams, cremsg)
7967 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
7968 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
7970 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
7971 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
7973 xappConn1.SendRESTSubsDelReq(t, &restSubId)
7975 // Wait that subs is cleaned
7976 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
7978 xappConn1.TestMsgChanEmpty(t)
7979 e2termConn1.TestMsgChanEmpty(t)
7980 mainCtrl.wait_registry_empty(t, 10)
7981 mainCtrl.VerifyAllClean(t)
7982 mainCtrl.VerifyCounterValues(t)
7985 //-----------------------------------------------------------------------------
7986 // TestRESTUnpackSubscriptionFailureNoTransaction
7989 // +-------+ +---------+ +---------+
7990 // | xapp | | submgr | | e2term |
7991 // +-------+ +---------+ +---------+
7994 // |---------------->| |
7996 // | RESTSubResp | |
7997 // |<----------------| |
8000 // | |------------->|
8002 // | | SubFail | No transaction for the response
8003 // | |<-------------| Ongoing transaction not found. This will result timer expiry and resending
8006 // | |------------->|
8008 // | | SubFail | Duplicated action
8009 // | |<-------------| Ongoing transaction not found. This will result timer expiry and sending delete
8010 // | RESTNotif (fail)| |
8011 // |<----------------| |
8013 // | |------------->|
8016 // | |<-------------| Ongoing transaction not found. This will result timer expiry and resending
8019 // | |------------->|
8022 // | |<-------------| Ongoing transaction not found.
8024 // | [SUBS DELETE] |
8027 //-----------------------------------------------------------------------------
8029 func TestRESTUnpackSubscriptionFailureNoTransaction(t *testing.T) {
8031 const subReqCount int = 1
8033 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
8034 Counter{cRestSubReqFromXapp, 1},
8035 Counter{cRestSubRespToXapp, 1},
8036 Counter{cSubReqToE2, 1},
8037 Counter{cSubReqTimerExpiry, 2},
8038 Counter{cSubReReqToE2, 1},
8039 Counter{cSubFailFromE2, 2},
8040 Counter{cRestSubFailNotifToXapp, 1},
8041 Counter{cRestSubDelReqFromXapp, 1},
8042 Counter{cRestSubDelRespToXapp, 1},
8043 Counter{cSubDelReqToE2, 1},
8044 Counter{cSubDelReqTimerExpiry, 2},
8045 Counter{cSubDelReReqToE2, 1},
8046 Counter{cSubDelRespFromE2, 2},
8050 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
8051 restSubId := xappConn1.SendRESTSubsReq(t, params)
8053 crereq, cremsg := e2termConn1.RecvSubsReq(t)
8055 mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
8057 // No transaction exist for this response which will result resending original request
8058 fparams := &teststube2ap.E2StubSubsFailParams{}
8060 e2termConn1.SendSubsFail(t, fparams, cremsg)
8062 _, cremsg = e2termConn1.RecvSubsReq(t)
8064 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
8066 // Subscription already created in E2 Node.
8067 fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
8068 e2termConn1.SendSubsFail(t, fparams, cremsg)
8070 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
8071 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
8073 // Resending happens because there no transaction
8074 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
8075 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
8077 instanceId := xappConn1.WaitRESTNotification(t, restSubId)
8078 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
8080 xappConn1.SendRESTSubsDelReq(t, &restSubId)
8082 // Wait that subs is cleaned
8083 mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
8085 xappConn1.TestMsgChanEmpty(t)
8086 e2termConn1.TestMsgChanEmpty(t)
8087 mainCtrl.wait_registry_empty(t, 10)
8088 mainCtrl.VerifyAllClean(t)
8089 mainCtrl.VerifyCounterValues(t)
8092 //-----------------------------------------------------------------------------
8093 // TestRESTUnpackSubscriptionDeleteResponseDecodeFail
8096 // +-------+ +---------+ +---------+
8097 // | xapp | | submgr | | e2term |
8098 // +-------+ +---------+ +---------+
8100 // | [SUBS CREATE] |
8103 // | RESTSubDelReq | |
8104 // |---------------->| |
8106 // | RESTSubDelResp | |
8107 // |<----------------| |
8110 // | |------------->|
8112 // | | SubDelResp | ASN.1 decode fails.
8113 // | |<-------------| Decode failed. More data needed. This will result timer expiry and resending
8116 // | |------------->|
8118 // | | SubDelFail | Subscription does exist any more in E2 node
8119 // | |<-------------|
8121 // | [SUBS DELETE] |
8124 //-----------------------------------------------------------------------------
8126 func TestRESTUnpackSubscriptionDeleteResponseDecodeFail(t *testing.T) {
8128 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
8129 Counter{cRestSubReqFromXapp, 1},
8130 Counter{cRestSubRespToXapp, 1},
8131 Counter{cSubReqToE2, 1},
8132 Counter{cSubRespFromE2, 1},
8133 Counter{cRestSubNotifToXapp, 1},
8134 Counter{cRestSubDelReqFromXapp, 1},
8135 Counter{cRestSubDelRespToXapp, 1},
8136 Counter{cSubDelReqToE2, 1},
8137 Counter{cSubDelReqTimerExpiry, 1},
8138 Counter{cSubDelReReqToE2, 1},
8139 Counter{cSubDelFailFromE2, 1},
8140 Counter{cSubDelRespFromE2, 1},
8144 var params *teststube2ap.RESTSubsReqParams = nil
8145 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
8148 xappConn1.SendRESTSubsDelReq(t, &restSubId)
8150 // E2t: Receive 1st SubsDelReq
8151 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
8153 // Decode of this response fails which will result resending original request
8154 e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_RESP)
8156 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
8157 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
8159 // Subscription does not exist in in E2 Node.
8160 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
8162 // Wait that subs is cleaned
8163 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
8165 xappConn1.TestMsgChanEmpty(t)
8166 e2termConn1.TestMsgChanEmpty(t)
8167 mainCtrl.wait_registry_empty(t, 10)
8168 mainCtrl.VerifyAllClean(t)
8169 mainCtrl.VerifyCounterValues(t)
8172 //-----------------------------------------------------------------------------
8173 // TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId
8176 // +-------+ +---------+ +---------+
8177 // | xapp | | submgr | | e2term |
8178 // +-------+ +---------+ +---------+
8180 // | [SUBS CREATE] |
8183 // | RESTSubDelReq | |
8184 // |---------------->| |
8186 // | RESTSubDelResp | |
8187 // |<----------------| |
8190 // | |------------->|
8192 // | | SubDelResp | Unknown instanceId
8193 // | |<-------------| No valid subscription found with subIds [0]. This will result timer expiry and resending
8196 // | |------------->|
8198 // | | SubDelFail | Subscription does exist any more in E2 node
8199 // | |<-------------|
8201 // | [SUBS DELETE] |
8203 //-----------------------------------------------------------------------------
8205 func TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId(t *testing.T) {
8207 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
8208 Counter{cRestSubReqFromXapp, 1},
8209 Counter{cRestSubRespToXapp, 1},
8210 Counter{cSubReqToE2, 1},
8211 Counter{cSubRespFromE2, 1},
8212 Counter{cRestSubNotifToXapp, 1},
8213 Counter{cRestSubDelReqFromXapp, 1},
8214 Counter{cRestSubDelRespToXapp, 1},
8215 Counter{cSubDelReqToE2, 1},
8216 Counter{cSubDelReqTimerExpiry, 1},
8217 Counter{cSubDelReReqToE2, 1},
8218 Counter{cSubDelRespFromE2, 1},
8219 Counter{cSubDelFailFromE2, 1},
8223 var params *teststube2ap.RESTSubsReqParams = nil
8224 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
8227 xappConn1.SendRESTSubsDelReq(t, &restSubId)
8229 // E2t: Receive 1st SubsDelReq
8230 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
8232 // Unknown instanceId in this response which will result resending original request
8233 delreq.RequestId.InstanceId = 0
8234 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
8236 // E2t: Receive 2nd SubsDelReq
8237 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
8239 // Subscription does not exist in in E2 Node.
8240 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
8242 // Wait that subs is cleaned
8243 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
8245 xappConn1.TestMsgChanEmpty(t)
8246 e2termConn1.TestMsgChanEmpty(t)
8247 mainCtrl.wait_registry_empty(t, 10)
8248 mainCtrl.VerifyAllClean(t)
8249 mainCtrl.VerifyCounterValues(t)
8252 //-----------------------------------------------------------------------------
8253 // TestRESTUnpackSubscriptionDeleteResponseNoTransaction
8256 // +-------+ +---------+ +---------+
8257 // | xapp | | submgr | | e2term |
8258 // +-------+ +---------+ +---------+
8260 // | [SUBS CREATE] |
8263 // | RESTSubDelReq | |
8264 // |---------------->| |
8266 // | RESTSubDelResp | |
8267 // |<----------------| |
8270 // | |------------->|
8272 // | | SubDelResp | No transaction for the response
8273 // | |<-------------| Ongoing transaction not found. This will result timer expiry and resending
8276 // | |------------->|
8278 // | | SubDelFail | Subscription does exist any more in E2 node
8279 // | |<-------------| Ongoing transaction not found. This will result timer expiry
8281 // | [SUBS DELETE] |
8283 //-----------------------------------------------------------------------------
8285 func TestRESTUnpackSubscriptionDeleteResponseNoTransaction(t *testing.T) {
8287 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
8288 Counter{cRestSubReqFromXapp, 1},
8289 Counter{cRestSubRespToXapp, 1},
8290 Counter{cSubReqToE2, 1},
8291 Counter{cSubRespFromE2, 1},
8292 Counter{cRestSubNotifToXapp, 1},
8293 Counter{cRestSubDelReqFromXapp, 1},
8294 Counter{cRestSubDelRespToXapp, 1},
8295 Counter{cSubDelReqToE2, 1},
8296 Counter{cSubDelReqTimerExpiry, 2},
8297 Counter{cSubDelReReqToE2, 1},
8298 Counter{cSubDelRespFromE2, 1},
8299 Counter{cSubDelFailFromE2, 1},
8303 var params *teststube2ap.RESTSubsReqParams = nil
8304 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
8307 xappConn1.SendRESTSubsDelReq(t, &restSubId)
8309 // E2t: Receive 1st SubsDelReq
8310 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
8312 mainCtrl.MakeTransactionNil(t, e2SubsId)
8314 // No transaction exist for this response which will result resending original request
8315 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
8317 // E2t: Receive 2nd SubsDelReq
8318 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
8320 // Subscription does not exist in in E2 Node.
8321 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
8323 // Wait that subs is cleaned
8324 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
8326 xappConn1.TestMsgChanEmpty(t)
8327 e2termConn1.TestMsgChanEmpty(t)
8328 mainCtrl.wait_registry_empty(t, 10)
8329 mainCtrl.VerifyAllClean(t)
8330 mainCtrl.VerifyCounterValues(t)
8333 //-----------------------------------------------------------------------------
8334 // TestRESTUnpackSubscriptionDeleteFailureDecodeFail
8337 // +-------+ +---------+ +---------+
8338 // | xapp | | submgr | | e2term |
8339 // +-------+ +---------+ +---------+
8341 // | [SUBS CREATE] |
8344 // | RESTSubDelReq | |
8345 // |---------------->| |
8347 // | RESTSubDelResp | |
8348 // |<----------------| |
8351 // | |------------->|
8353 // | | SubDelFail | ASN.1 decode fails
8354 // | |<-------------| Decode failed. More data needed. This will result timer expiry and resending
8357 // | |------------->|
8359 // | | SubDelFail | Subscription does exist any more in E2 node
8360 // | |<-------------|
8362 // | [SUBS DELETE] |
8364 //-----------------------------------------------------------------------------
8366 func TestRESTUnpackSubscriptionDeleteFailureDecodeFail(t *testing.T) {
8368 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
8369 Counter{cRestSubReqFromXapp, 1},
8370 Counter{cRestSubRespToXapp, 1},
8371 Counter{cSubReqToE2, 1},
8372 Counter{cSubRespFromE2, 1},
8373 Counter{cRestSubNotifToXapp, 1},
8374 Counter{cRestSubDelReqFromXapp, 1},
8375 Counter{cRestSubDelRespToXapp, 1},
8376 Counter{cSubDelReqToE2, 1},
8377 Counter{cSubDelReqTimerExpiry, 1},
8378 Counter{cSubDelReReqToE2, 1},
8379 Counter{cSubDelFailFromE2, 2},
8383 var params *teststube2ap.RESTSubsReqParams = nil
8384 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
8387 xappConn1.SendRESTSubsDelReq(t, &restSubId)
8389 // E2t: Receive 1st SubsDelReq
8390 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
8392 // Decode of this response fails which will result resending original request
8393 e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_FAILURE)
8395 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
8396 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
8398 // Subscription does not exist in in E2 Node.
8399 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
8401 // Wait that subs is cleaned
8402 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
8404 xappConn1.TestMsgChanEmpty(t)
8405 e2termConn1.TestMsgChanEmpty(t)
8406 mainCtrl.wait_registry_empty(t, 10)
8407 mainCtrl.VerifyAllClean(t)
8408 mainCtrl.VerifyCounterValues(t)
8411 //-----------------------------------------------------------------------------
8412 // TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId
8415 // +-------+ +---------+ +---------+
8416 // | xapp | | submgr | | e2term |
8417 // +-------+ +---------+ +---------+
8419 // | [SUBS CREATE] |
8422 // | RESTSubDelReq | |
8423 // |---------------->| |
8425 // | RESTSubDelResp | |
8426 // |<----------------| |
8429 // | |------------->|
8431 // | | SubDelFail | Unknown instanceId
8432 // | |<-------------| No valid subscription found with subIds [0]. This will result timer expiry and resending
8435 // | |------------->|
8437 // | | SubDelFail | Subscription does exist any more in E2 node
8438 // | |<-------------| No valid subscription found with subIds [0].
8440 // | [SUBS DELETE] |
8442 //-----------------------------------------------------------------------------
8444 func TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId(t *testing.T) {
8446 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
8447 Counter{cRestSubReqFromXapp, 1},
8448 Counter{cRestSubRespToXapp, 1},
8449 Counter{cSubReqToE2, 1},
8450 Counter{cSubRespFromE2, 1},
8451 Counter{cRestSubNotifToXapp, 1},
8452 Counter{cRestSubDelReqFromXapp, 1},
8453 Counter{cRestSubDelRespToXapp, 1},
8454 Counter{cSubDelReqToE2, 1},
8455 Counter{cSubDelReqTimerExpiry, 1},
8456 Counter{cSubDelReReqToE2, 1},
8457 Counter{cSubDelFailFromE2, 2},
8461 var params *teststube2ap.RESTSubsReqParams = nil
8462 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
8465 xappConn1.SendRESTSubsDelReq(t, &restSubId)
8467 // E2t: Receive 1st SubsDelReq
8468 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
8470 // Unknown instanceId 0 in this response which will result resending original request
8471 delreq.RequestId.InstanceId = 0
8472 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
8474 // E2t: Receive 2nd SubsDelReq
8475 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
8477 // Subscription does not exist in in E2 Node. E2 Node responds with failure but there is also same unknown instanceId 0
8478 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
8480 // Wait that subs is cleaned
8481 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
8483 xappConn1.TestMsgChanEmpty(t)
8484 e2termConn1.TestMsgChanEmpty(t)
8485 mainCtrl.wait_registry_empty(t, 10)
8486 mainCtrl.VerifyAllClean(t)
8487 mainCtrl.VerifyCounterValues(t)
8490 //-----------------------------------------------------------------------------
8491 // TestRESTUnpackSubscriptionDeleteFailureNoTransaction
8494 // +-------+ +---------+ +---------+
8495 // | xapp | | submgr | | e2term |
8496 // +-------+ +---------+ +---------+
8498 // | [SUBS CREATE] |
8501 // | RESTSubDelReq | |
8502 // |---------------->| |
8504 // | RESTSubDelResp | |
8505 // |<----------------| |
8508 // | |------------->|
8510 // | | SubDelFail | No transaction for the response
8511 // | |<-------------| Ongoing transaction not found. This will result timer expiry and resending
8514 // | |------------->|
8516 // | | SubDelFail | Subscription does exist any more in E2 node
8517 // | |<-------------| Ongoing transaction not found. This will result timer expiry
8519 // | [SUBS DELETE] |
8521 //-----------------------------------------------------------------------------
8523 func TestRESTUnpackSubscriptionDeleteFailureNoTransaction(t *testing.T) {
8525 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
8526 Counter{cRestSubReqFromXapp, 1},
8527 Counter{cRestSubRespToXapp, 1},
8528 Counter{cSubReqToE2, 1},
8529 Counter{cSubRespFromE2, 1},
8530 Counter{cRestSubNotifToXapp, 1},
8531 Counter{cRestSubDelReqFromXapp, 1},
8532 Counter{cRestSubDelRespToXapp, 1},
8533 Counter{cSubDelReqToE2, 1},
8534 Counter{cSubDelReqTimerExpiry, 2},
8535 Counter{cSubDelReReqToE2, 1},
8536 Counter{cSubDelFailFromE2, 2},
8540 var params *teststube2ap.RESTSubsReqParams = nil
8541 restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
8544 xappConn1.SendRESTSubsDelReq(t, &restSubId)
8546 // E2t: Receive 1st SubsDelReq
8547 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
8549 mainCtrl.MakeTransactionNil(t, e2SubsId)
8551 // No transaction exist for this response which will result resending original request
8552 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
8554 // E2t: Receive 2nd SubsDelReq
8555 delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
8557 // Subscription does not exist in in E2 Node.
8558 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
8560 // Wait that subs is cleaned
8561 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
8563 xappConn1.TestMsgChanEmpty(t)
8564 e2termConn1.TestMsgChanEmpty(t)
8565 mainCtrl.wait_registry_empty(t, 10)
8566 mainCtrl.VerifyAllClean(t)
8567 mainCtrl.VerifyCounterValues(t)
8570 //-----------------------------------------------------------------------------
8571 // TestRESTSubReqFailAsn1PackSubReqError
8574 // +-------+ +---------+ +---------+
8575 // | xapp | | submgr | | e2term |
8576 // +-------+ +---------+ +---------+
8579 // |---------------->| |
8581 // | RESTSubResp | |
8582 // |<----------------| |
8584 // | ASN.1 encode fails |
8587 // | |------------->|
8590 // | |<-------------|
8594 // |<----------------| |
8596 // | [SUBS DELETE] |
8599 //-----------------------------------------------------------------------------
8601 func TestRESTSubReqFailAsn1PackSubReqError(t *testing.T) {
8603 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
8604 Counter{cRestSubReqFromXapp, 1},
8605 Counter{cRestSubRespToXapp, 1},
8606 Counter{cRestSubFailNotifToXapp, 1},
8607 Counter{cRestSubDelReqFromXapp, 1},
8608 Counter{cRestSubDelRespToXapp, 1},
8611 const subReqCount int = 1
8613 var params *teststube2ap.RESTSubsReqParams = nil
8614 params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
8615 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, false)
8618 restSubId := xappConn1.SendRESTSubsReq(t, params)
8619 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
8621 // E2t: Receive SubsDelReq
8622 xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
8624 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
8625 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
8627 e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, true)
8629 xappConn1.SendRESTSubsDelReq(t, &restSubId)
8631 // Wait that subs is cleaned
8632 waitSubsCleanup(t, e2SubsId, 10)
8633 mainCtrl.VerifyAllClean(t)
8634 mainCtrl.VerifyCounterValues(t)
8637 //-----------------------------------------------------------------------------
8638 // TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction
8641 // +-------+ +---------+ +---------+
8642 // | xapp | | submgr | | e2term |
8643 // +-------+ +---------+ +---------+
8646 // |---------------->| |
8648 // | RESTSubResp | |
8649 // |<----------------| |
8651 // | |------------->|
8654 // | |<-------------|
8657 // |<----------------| |
8659 // | RESTSubReq | | Policy modification
8660 // |---------------->| |
8662 // | RESTSubResp | |
8663 // |<----------------| |
8665 // | |------------->|
8668 // | RESTNotif(Unsuccessful) | E2 timeout
8669 // |<----------------| |
8671 // | RESTSubDelReq | |
8672 // |---------------->| |
8675 // | |------------->|
8678 // | |<-------------|
8680 // | RESTSubDelResp | |
8681 // |<----------------| |
8683 //-----------------------------------------------------------------------------
8685 func TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction(t *testing.T) {
8687 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
8688 Counter{cRestSubReqFromXapp, 2},
8689 Counter{cRestSubRespToXapp, 2},
8690 Counter{cSubReqToE2, 2},
8691 Counter{cSubReqTimerExpiry, 1},
8692 Counter{cSubRespFromE2, 1},
8693 Counter{cRestSubNotifToXapp, 1},
8694 Counter{cRestSubFailNotifToXapp, 1},
8695 Counter{cRestSubDelReqFromXapp, 1},
8696 Counter{cSubDelReqToE2, 1},
8697 Counter{cSubDelRespFromE2, 1},
8698 Counter{cRestSubDelRespToXapp, 1},
8701 const e2Timeout int64 = 1
8702 const e2RetryCount int64 = 0
8703 const routingNeeded bool = false
8706 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
8707 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
8710 restSubId := xappConn1.SendRESTSubsReq(t, params)
8711 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
8713 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
8714 xappConn1.ExpectRESTNotification(t, restSubId)
8715 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
8716 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
8717 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
8720 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
8721 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
8722 params.SetSubscriptionID(&restSubId)
8723 params.SetTimeToWait("w200ms")
8724 restSubId = xappConn1.SendRESTSubsReq(t, params)
8725 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
8727 crereq1, cremsg1 = e2termConn1.RecvSubsReq(t)
8728 xappConn1.ExpectRESTNotification(t, restSubId)
8729 // SubsResp is missing, e2SubsId will be 0
8730 zeroE2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
8731 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", zeroE2SubsId)
8734 xappConn1.SendRESTSubsDelReq(t, &restSubId)
8735 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
8736 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
8738 waitSubsCleanup(t, e2SubsId, 10)
8739 mainCtrl.VerifyAllClean(t)
8740 mainCtrl.VerifyCounterValues(t)
8743 //-----------------------------------------------------------------------------
8744 // TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle
8747 // +-------+ +---------+ +---------+
8748 // | xapp | | submgr | | e2term |
8749 // +-------+ +---------+ +---------+
8752 // |---------------->| |
8754 // | RESTSubResp | |
8755 // |<----------------| |
8757 // | |------------->|
8760 // | |<-------------|
8763 // |<----------------| |
8766 // |---------------->| |
8768 // | RESTSubResp | |
8769 // |<----------------| |
8771 // | |------------->|
8773 // | Submgr restart |
8775 // | RESTSubDelReq | |
8776 // |---------------->| |
8779 // | |------------->|
8782 // | |<-------------|
8784 // | RESTSubDelResp | |
8785 // |<----------------| |
8787 //-----------------------------------------------------------------------------
8789 func TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
8791 mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
8792 Counter{cRestSubReqFromXapp, 2},
8793 Counter{cRestSubRespToXapp, 2},
8794 Counter{cSubReqToE2, 2},
8795 Counter{cSubRespFromE2, 1},
8796 Counter{cRestSubNotifToXapp, 1},
8797 Counter{cRestSubDelReqFromXapp, 1},
8798 Counter{cSubDelReqToE2, 1},
8799 Counter{cSubDelRespFromE2, 1},
8800 Counter{cRestSubDelRespToXapp, 1},
8803 const e2Timeout int64 = 1
8804 const e2RetryCount int64 = 0
8805 const routingNeeded bool = false
8808 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
8809 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
8810 // Create subscription
8811 restSubId := xappConn1.SendRESTSubsReq(t, params)
8812 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
8814 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
8815 xappConn1.ExpectRESTNotification(t, restSubId)
8816 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
8817 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
8818 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
8820 // Check subscription
8821 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
8824 params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
8825 params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
8826 params.SetSubscriptionID(&restSubId)
8827 params.SetTimeToWait("w200ms")
8828 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
8829 restSubId = xappConn1.SendRESTSubsReq(t, params)
8830 xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
8832 crereq1, cremsg1 = e2termConn1.RecvSubsReq(t)
8833 mainCtrl.SetResetTestFlag(t, false)
8835 // SubsResp is missing due to submgr restart
8837 mainCtrl.SimulateRestart(t)
8838 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
8840 // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
8841 // That needs to be completed before successful subscription query is possible
8842 <-time.After(time.Second * 1)
8844 // Check subscription
8845 queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
8847 // Delete subscription
8848 xappConn1.SendRESTSubsDelReq(t, &restSubId)
8849 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
8850 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
8852 //Wait that subs is cleaned
8853 waitSubsCleanup(t, e2SubsId, 10)
8855 mainCtrl.VerifyCounterValues(t)
8856 mainCtrl.VerifyAllClean(t)
8859 ////////////////////////////////////////////////////////////////////////////////////
8860 // Services for UT cases
8861 ////////////////////////////////////////////////////////////////////////////////////
8862 const subReqCount int = 1
8863 const host string = "localhost"
8865 func createSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, params *teststube2ap.RESTSubsReqParams) (string, uint32) {
8867 params = fromXappConn.GetRESTSubsReqReportParams(subReqCount)
8869 restSubId := fromXappConn.SendRESTSubsReq(t, params)
8870 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
8872 crereq1, cremsg1 := toE2termConn.RecvSubsReq(t)
8873 fromXappConn.ExpectRESTNotification(t, restSubId)
8874 toE2termConn.SendSubsResp(t, crereq1, cremsg1)
8875 e2SubsId := fromXappConn.WaitRESTNotification(t, restSubId)
8876 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
8878 return restSubId, e2SubsId
8881 func createXapp2MergedSubscription(t *testing.T, meid string) (string, uint32) {
8883 params := xappConn2.GetRESTSubsReqReportParams(subReqCount)
8885 params.SetMeid(meid)
8887 xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
8888 restSubId := xappConn2.SendRESTSubsReq(t, params)
8889 xappConn2.ExpectRESTNotification(t, restSubId)
8890 xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
8891 e2SubsId := xappConn2.WaitRESTNotification(t, restSubId)
8892 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
8894 return restSubId, e2SubsId
8897 func createXapp1PolicySubscription(t *testing.T) (string, uint32) {
8899 params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
8900 restSubId := xappConn1.SendRESTSubsReq(t, params)
8901 xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
8903 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
8904 xappConn1.ExpectRESTNotification(t, restSubId)
8905 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
8906 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
8907 xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
8909 return restSubId, e2SubsId
8912 func createXapp1ReportSubscriptionE2Fail(t *testing.T) (string, uint32) {
8913 params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
8914 restSubId := xappConn1.SendRESTSubsReq(t, params)
8916 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
8917 fparams1 := &teststube2ap.E2StubSubsFailParams{}
8918 fparams1.Set(crereq1)
8919 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
8921 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
8922 xappConn1.ExpectRESTNotification(t, restSubId)
8923 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
8924 e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
8925 xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
8927 return restSubId, e2SubsId
8930 func deleteSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId *string) {
8931 fromXappConn.SendRESTSubsDelReq(t, restSubId)
8932 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
8933 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
8936 func deleteXapp1Subscription(t *testing.T, restSubId *string) {
8937 xappConn1.SendRESTSubsDelReq(t, restSubId)
8938 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
8939 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
8942 func deleteXapp2Subscription(t *testing.T, restSubId *string) {
8943 xappConn2.SendRESTSubsDelReq(t, restSubId)
8944 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
8945 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
8948 func queryXappSubscription(t *testing.T, e2SubsId int64, meid string, endpoint []string) {
8949 resp, _ := xapp.Subscription.QuerySubscriptions()
8950 assert.Equal(t, e2SubsId, resp[0].SubscriptionID)
8951 assert.Equal(t, meid, resp[0].Meid)
8952 assert.Equal(t, endpoint, resp[0].ClientEndpoint)
8955 func waitSubsCleanup(t *testing.T, e2SubsId uint32, timeout int) {
8956 //Wait that subs is cleaned
8957 mainCtrl.wait_subs_clean(t, e2SubsId, timeout)
8959 xappConn1.TestMsgChanEmpty(t)
8960 xappConn2.TestMsgChanEmpty(t)
8961 e2termConn1.TestMsgChanEmpty(t)
8962 mainCtrl.wait_registry_empty(t, timeout)
8965 func sendAndReceiveMultipleE2SubReqs(t *testing.T, count int, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, restSubId string) []uint32 {
8967 var e2SubsId []uint32
8969 for i := 0; i < count; i++ {
8970 xapp.Logger.Debug("TEST: %d ===================================== BEGIN CRE ============================================", i+1)
8971 crereq, cremsg := toE2termConn.RecvSubsReq(t)
8972 fromXappConn.ExpectRESTNotification(t, restSubId)
8973 toE2termConn.SendSubsResp(t, crereq, cremsg)
8974 instanceId := fromXappConn.WaitRESTNotification(t, restSubId)
8975 e2SubsId = append(e2SubsId, instanceId)
8976 xapp.Logger.Debug("TEST: %v", e2SubsId)
8977 xapp.Logger.Debug("TEST: %d ===================================== END CRE ============================================", i+1)
8978 <-time.After(100 * time.Millisecond)
8983 func sendAndReceiveMultipleE2DelReqs(t *testing.T, e2SubsIds []uint32, toE2termConn *teststube2ap.E2Stub) {
8985 for i := 0; i < len(e2SubsIds); i++ {
8986 xapp.Logger.Debug("TEST: %d ===================================== BEGIN DEL ============================================", i+1)
8987 delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
8988 toE2termConn.SendSubsDelResp(t, delreq, delmsg)
8989 <-time.After(1 * time.Second)
8990 xapp.Logger.Debug("TEST: %d ===================================== END DEL ============================================", i+1)
8991 <-time.After(100 * time.Millisecond)
8994 // Wait that subs is cleaned
8995 for i := 0; i < len(e2SubsIds); i++ {
8996 mainCtrl.wait_subs_clean(t, e2SubsIds[i], 10)