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 ==================================================================================
23 "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap"
24 "gerrit.o-ran-sc.org/r/ric-plt/submgr/pkg/teststube2ap"
28 //-----------------------------------------------------------------------------
29 // TestSubReqAndRouteNok
32 // +-------+ +---------+ +---------+
33 // | xapp | | submgr | | rtmgr |
34 // +-------+ +---------+ +---------+
46 // | [SUBS INT DELETE] |
49 //-----------------------------------------------------------------------------
51 func TestSubReqAndRouteNok(t *testing.T) {
52 CaseBegin("TestSubReqAndRouteNok")
54 waiter := rtmgrHttp.AllocNextEvent(false)
55 newSubsId := mainCtrl.get_subid(t)
56 xappConn1.SendSubsReq(t, nil, nil)
59 //Wait that subs is cleaned
60 mainCtrl.wait_subs_clean(t, newSubsId, 10)
62 xappConn1.TestMsgChanEmpty(t)
63 xappConn2.TestMsgChanEmpty(t)
64 e2termConn.TestMsgChanEmpty(t)
65 mainCtrl.wait_registry_empty(t, 10)
68 //-----------------------------------------------------------------------------
69 // TestSubReqAndSubDelOk
72 // +-------+ +---------+ +---------+
73 // | xapp | | submgr | | e2term |
74 // +-------+ +---------+ +---------+
101 //-----------------------------------------------------------------------------
102 func TestSubReqAndSubDelOk(t *testing.T) {
103 CaseBegin("TestSubReqAndSubDelOk")
105 waiter := rtmgrHttp.AllocNextEvent(true)
106 cretrans := xappConn1.SendSubsReq(t, nil, nil)
109 crereq, cremsg := e2termConn.RecvSubsReq(t)
110 e2termConn.SendSubsResp(t, crereq, cremsg)
111 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
112 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
113 delreq, delmsg := e2termConn.RecvSubsDelReq(t)
115 waiter = rtmgrHttp.AllocNextEvent(true)
116 e2termConn.SendSubsDelResp(t, delreq, delmsg)
117 xappConn1.RecvSubsDelResp(t, deltrans)
120 //Wait that subs is cleaned
121 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
123 xappConn1.TestMsgChanEmpty(t)
124 xappConn2.TestMsgChanEmpty(t)
125 e2termConn.TestMsgChanEmpty(t)
126 mainCtrl.wait_registry_empty(t, 10)
129 //-----------------------------------------------------------------------------
130 // TestSubReqRetransmission
133 // +-------+ +---------+ +---------+
134 // | xapp | | submgr | | e2term |
135 // +-------+ +---------+ +---------+
138 // |------------->| |
141 // | |------------->|
145 // |------------->| |
148 // | |<-------------|
151 // |<-------------| |
156 //-----------------------------------------------------------------------------
157 func TestSubReqRetransmission(t *testing.T) {
158 CaseBegin("TestSubReqRetransmission")
161 cretrans := xappConn1.SendSubsReq(t, nil, nil)
162 crereq, cremsg := e2termConn.RecvSubsReq(t)
164 seqBef := mainCtrl.get_msgcounter(t)
165 xappConn1.SendSubsReq(t, nil, cretrans) //Retransmitted SubReq
166 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
168 e2termConn.SendSubsResp(t, crereq, cremsg)
169 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
172 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
173 delreq, delmsg := e2termConn.RecvSubsDelReq(t)
174 e2termConn.SendSubsDelResp(t, delreq, delmsg)
175 xappConn1.RecvSubsDelResp(t, deltrans)
177 //Wait that subs is cleaned
178 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
180 xappConn1.TestMsgChanEmpty(t)
181 xappConn2.TestMsgChanEmpty(t)
182 e2termConn.TestMsgChanEmpty(t)
183 mainCtrl.wait_registry_empty(t, 10)
186 //-----------------------------------------------------------------------------
187 // TestSubDelReqRetransmission
190 // +-------+ +---------+ +---------+
191 // | xapp | | submgr | | e2term |
192 // +-------+ +---------+ +---------+
198 // |------------->| |
201 // | |------------->|
206 // |------------->| |
209 // | |<-------------|
212 // |<-------------| |
214 //-----------------------------------------------------------------------------
215 func TestSubDelReqRetransmission(t *testing.T) {
216 CaseBegin("TestSubDelReqRetransmission")
219 cretrans := xappConn1.SendSubsReq(t, nil, nil)
220 crereq, cremsg := e2termConn.RecvSubsReq(t)
221 e2termConn.SendSubsResp(t, crereq, cremsg)
222 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
225 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
226 delreq, delmsg := e2termConn.RecvSubsDelReq(t)
228 seqBef := mainCtrl.get_msgcounter(t)
229 xappConn1.SendSubsDelReq(t, deltrans, e2SubsId) //Retransmitted SubDelReq
230 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
232 e2termConn.SendSubsDelResp(t, delreq, delmsg)
233 xappConn1.RecvSubsDelResp(t, deltrans)
235 //Wait that subs is cleaned
236 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
238 xappConn1.TestMsgChanEmpty(t)
239 xappConn2.TestMsgChanEmpty(t)
240 e2termConn.TestMsgChanEmpty(t)
241 mainCtrl.wait_registry_empty(t, 10)
244 //-----------------------------------------------------------------------------
245 // TestSubDelReqCollision
248 // +-------+ +---------+ +---------+
249 // | xapp | | submgr | | e2term |
250 // +-------+ +---------+ +---------+
256 // |------------->| |
259 // | |------------->|
264 // |------------->| |
266 // | | SubDelResp 1 |
267 // | |<-------------|
269 // | SubDelResp 1 | |
270 // |<-------------| |
272 // | SubDelResp 2 | |
273 // |<-------------| |
275 //-----------------------------------------------------------------------------
277 func TestSubDelReqCollision(t *testing.T) {
278 CaseBegin("TestSubDelReqCollision")
281 cretrans := xappConn1.SendSubsReq(t, nil, nil)
282 crereq, cremsg := e2termConn.RecvSubsReq(t)
283 e2termConn.SendSubsResp(t, crereq, cremsg)
284 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
287 xappConn1.SendSubsDelReq(t, nil, e2SubsId)
288 delreq1, delmsg1 := e2termConn.RecvSubsDelReq(t)
290 // Subs Delete colliding
291 seqBef := mainCtrl.get_msgcounter(t)
292 deltranscol2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
293 xappConn1.SendSubsDelReq(t, deltranscol2, e2SubsId) //Colliding SubDelReq
294 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
296 // Del resp for first and second
297 e2termConn.SendSubsDelResp(t, delreq1, delmsg1)
299 // don't care in which order responses are received
300 xappConn1.RecvSubsDelResp(t, nil)
301 xappConn1.RecvSubsDelResp(t, nil)
303 //Wait that subs is cleaned
304 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
306 xappConn1.TestMsgChanEmpty(t)
307 xappConn2.TestMsgChanEmpty(t)
308 e2termConn.TestMsgChanEmpty(t)
309 mainCtrl.wait_registry_empty(t, 10)
312 //-----------------------------------------------------------------------------
313 // TestSubReqAndSubDelOkTwoParallel
316 // +-------+ +---------+ +---------+
317 // | xapp | | submgr | | e2term |
318 // +-------+ +---------+ +---------+
323 // |------------->| |
326 // | |------------->|
329 // |------------->| |
332 // | |------------->|
335 // | |<-------------|
337 // | |<-------------|
340 // |<-------------| |
342 // |<-------------| |
344 // | [SUBS 1 DELETE] |
346 // | [SUBS 2 DELETE] |
349 //-----------------------------------------------------------------------------
350 func TestSubReqAndSubDelOkTwoParallel(t *testing.T) {
351 CaseBegin("TestSubReqAndSubDelOkTwoParallel")
354 rparams1 := &teststube2ap.E2StubSubsReqParams{}
356 rparams1.Req.EventTriggerDefinition.ProcedureCode = 5
357 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
358 crereq1, cremsg1 := e2termConn.RecvSubsReq(t)
361 rparams2 := &teststube2ap.E2StubSubsReqParams{}
363 rparams2.Req.EventTriggerDefinition.ProcedureCode = 28
364 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
365 crereq2, cremsg2 := e2termConn.RecvSubsReq(t)
368 e2termConn.SendSubsResp(t, crereq1, cremsg1)
369 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
372 e2termConn.SendSubsResp(t, crereq2, cremsg2)
373 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
376 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
377 delreq1, delmsg1 := e2termConn.RecvSubsDelReq(t)
378 e2termConn.SendSubsDelResp(t, delreq1, delmsg1)
379 xappConn1.RecvSubsDelResp(t, deltrans1)
380 //Wait that subs is cleaned
381 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
384 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
385 delreq2, delmsg2 := e2termConn.RecvSubsDelReq(t)
386 e2termConn.SendSubsDelResp(t, delreq2, delmsg2)
387 xappConn2.RecvSubsDelResp(t, deltrans2)
388 //Wait that subs is cleaned
389 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
391 xappConn1.TestMsgChanEmpty(t)
392 xappConn2.TestMsgChanEmpty(t)
393 e2termConn.TestMsgChanEmpty(t)
394 mainCtrl.wait_registry_empty(t, 10)
397 //-----------------------------------------------------------------------------
398 // TestSameSubsDiffRan
399 // Same subscription to different RANs
402 // +-------+ +---------+ +---------+
403 // | xapp | | submgr | | e2term |
404 // +-------+ +---------+ +---------+
409 // |------------->| |
412 // | |------------->|
415 // | |<-------------|
418 // |<-------------| |
421 // |------------->| |
424 // | |------------->|
427 // | |<-------------|
430 // |<-------------| |
432 // | [SUBS r1 DELETE] |
434 // | [SUBS r2 DELETE] |
437 //-----------------------------------------------------------------------------
438 func TestSameSubsDiffRan(t *testing.T) {
439 CaseBegin("TestSameSubsDiffRan")
442 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
443 xappConn1.SendSubsReq(t, nil, cretrans1)
444 crereq1, cremsg1 := e2termConn.RecvSubsReq(t)
445 e2termConn.SendSubsResp(t, crereq1, cremsg1)
446 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
449 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
450 xappConn1.SendSubsReq(t, nil, cretrans2)
451 crereq2, cremsg2 := e2termConn.RecvSubsReq(t)
452 e2termConn.SendSubsResp(t, crereq2, cremsg2)
453 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
456 deltrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
457 xappConn1.SendSubsDelReq(t, deltrans1, e2SubsId1)
458 delreq1, delmsg1 := e2termConn.RecvSubsDelReq(t)
459 e2termConn.SendSubsDelResp(t, delreq1, delmsg1)
460 xappConn1.RecvSubsDelResp(t, deltrans1)
461 //Wait that subs is cleaned
462 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
465 deltrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
466 xappConn1.SendSubsDelReq(t, deltrans2, e2SubsId2)
467 delreq2, delmsg2 := e2termConn.RecvSubsDelReq(t)
468 e2termConn.SendSubsDelResp(t, delreq2, delmsg2)
469 xappConn1.RecvSubsDelResp(t, deltrans2)
470 //Wait that subs is cleaned
471 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
473 xappConn1.TestMsgChanEmpty(t)
474 xappConn2.TestMsgChanEmpty(t)
475 e2termConn.TestMsgChanEmpty(t)
476 mainCtrl.wait_registry_empty(t, 10)
479 //-----------------------------------------------------------------------------
480 // TestSubReqRetryInSubmgr
483 // +-------+ +---------+ +---------+
484 // | xapp | | submgr | | e2term |
485 // +-------+ +---------+ +---------+
488 // |------------->| |
491 // | |------------->|
495 // | |------------->|
498 // | |<-------------|
501 // |<-------------| |
506 //-----------------------------------------------------------------------------
508 func TestSubReqRetryInSubmgr(t *testing.T) {
510 CaseBegin("TestSubReqRetryInSubmgr start")
512 // Xapp: Send SubsReq
513 cretrans := xappConn1.SendSubsReq(t, nil, nil)
515 // E2t: Receive 1st SubsReq
516 e2termConn.RecvSubsReq(t)
518 // E2t: Receive 2nd SubsReq and send SubsResp
519 crereq, cremsg := e2termConn.RecvSubsReq(t)
520 e2termConn.SendSubsResp(t, crereq, cremsg)
522 // Xapp: Receive SubsResp
523 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
525 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
526 delreq, delmsg := e2termConn.RecvSubsDelReq(t)
527 e2termConn.SendSubsDelResp(t, delreq, delmsg)
528 xappConn1.RecvSubsDelResp(t, deltrans)
530 // Wait that subs is cleaned
531 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
533 xappConn1.TestMsgChanEmpty(t)
534 xappConn2.TestMsgChanEmpty(t)
535 e2termConn.TestMsgChanEmpty(t)
536 mainCtrl.wait_registry_empty(t, 10)
539 //-----------------------------------------------------------------------------
540 // TestSubReqTwoRetriesNoRespSubDelRespInSubmgr
543 // +-------+ +---------+ +---------+
544 // | xapp | | submgr | | e2term |
545 // +-------+ +---------+ +---------+
548 // |------------->| |
551 // | |------------->|
555 // | |------------->|
558 // | |------------->|
562 // | |------------->|
566 // | |<-------------|
569 //-----------------------------------------------------------------------------
571 func TestSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
573 CaseBegin("TestSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
575 // Xapp: Send SubsReq
576 xappConn1.SendSubsReq(t, nil, nil)
578 // E2t: Receive 1st SubsReq
579 e2termConn.RecvSubsReq(t)
581 // E2t: Receive 2nd SubsReq
582 e2termConn.RecvSubsReq(t)
584 // E2t: Send receive SubsDelReq and send SubsResp
585 delreq, delmsg := e2termConn.RecvSubsDelReq(t)
586 e2termConn.SendSubsDelResp(t, delreq, delmsg)
588 // Wait that subs is cleaned
589 mainCtrl.wait_subs_clean(t, delreq.RequestId.Seq, 10)
591 xappConn1.TestMsgChanEmpty(t)
592 xappConn2.TestMsgChanEmpty(t)
593 e2termConn.TestMsgChanEmpty(t)
594 mainCtrl.wait_registry_empty(t, 10)
597 //-----------------------------------------------------------------------------
598 // TestSubReqTwoRetriesNoRespAtAllInSubmgr
601 // +-------+ +---------+ +---------+
602 // | xapp | | submgr | | e2term |
603 // +-------+ +---------+ +---------+
606 // |------------->| |
609 // | |------------->|
613 // | |------------->|
616 // | |------------->|
620 // | |------------->|
624 //-----------------------------------------------------------------------------
626 func TestSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
628 CaseBegin("TestSubReqTwoRetriesNoRespAtAllInSubmgr start")
630 // Xapp: Send SubsReq
631 xappConn1.SendSubsReq(t, nil, nil)
633 // E2t: Receive 1st SubsReq
634 e2termConn.RecvSubsReq(t)
636 // E2t: Receive 2nd SubsReq
637 e2termConn.RecvSubsReq(t)
639 // E2t: Receive 1st SubsDelReq
640 e2termConn.RecvSubsDelReq(t)
642 // E2t: Receive 2nd SubsDelReq
643 delreq, _ := e2termConn.RecvSubsDelReq(t)
645 // Wait that subs is cleaned
646 mainCtrl.wait_subs_clean(t, delreq.RequestId.Seq, 15)
648 xappConn1.TestMsgChanEmpty(t)
649 xappConn2.TestMsgChanEmpty(t)
650 e2termConn.TestMsgChanEmpty(t)
651 mainCtrl.wait_registry_empty(t, 10)
654 //-----------------------------------------------------------------------------
655 // TestSubReqSubFailRespInSubmgr
658 // +-------+ +---------+ +---------+
659 // | xapp | | submgr | | e2term |
660 // +-------+ +---------+ +---------+
663 // |------------->| |
666 // | |------------->|
669 // | |<-------------|
672 // |<-------------| |
675 //-----------------------------------------------------------------------------
677 func TestSubReqSubFailRespInSubmgr(t *testing.T) {
679 CaseBegin("TestSubReqSubFailRespInSubmgr start")
681 // Xapp: Send SubsReq
682 cretrans := xappConn1.SendSubsReq(t, nil, nil)
684 // E2t: Receive SubsReq and send SubsFail
685 crereq, cremsg := e2termConn.RecvSubsReq(t)
686 fparams := &teststube2ap.E2StubSubsFailParams{}
688 e2termConn.SendSubsFail(t, fparams, cremsg)
690 // Xapp: Receive SubsFail
691 e2SubsId := xappConn1.RecvSubsFail(t, cretrans)
693 // Wait that subs is cleaned
694 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
696 xappConn1.TestMsgChanEmpty(t)
697 xappConn2.TestMsgChanEmpty(t)
698 e2termConn.TestMsgChanEmpty(t)
699 mainCtrl.wait_registry_empty(t, 10)
702 //-----------------------------------------------------------------------------
703 // TestSubDelReqRetryInSubmgr
706 // +-------+ +---------+ +---------+
707 // | xapp | | submgr | | e2term |
708 // +-------+ +---------+ +---------+
714 // |------------->| |
717 // | |------------->|
720 // | |------------->|
723 // | |<-------------|
726 // |<-------------| |
728 //-----------------------------------------------------------------------------
730 func TestSubDelReqRetryInSubmgr(t *testing.T) {
732 CaseBegin("TestSubDelReqRetryInSubmgr start")
735 cretrans := xappConn1.SendSubsReq(t, nil, nil)
736 crereq, cremsg := e2termConn.RecvSubsReq(t)
737 e2termConn.SendSubsResp(t, crereq, cremsg)
738 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
741 // Xapp: Send SubsDelReq
742 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
744 // E2t: Receive 1st SubsDelReq
745 e2termConn.RecvSubsDelReq(t)
747 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
748 delreq, delmsg := e2termConn.RecvSubsDelReq(t)
749 e2termConn.SendSubsDelResp(t, delreq, delmsg)
751 // Xapp: Receive SubsDelResp
752 xappConn1.RecvSubsDelResp(t, deltrans)
754 // Wait that subs is cleaned
755 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
757 xappConn1.TestMsgChanEmpty(t)
758 xappConn2.TestMsgChanEmpty(t)
759 e2termConn.TestMsgChanEmpty(t)
760 mainCtrl.wait_registry_empty(t, 10)
763 //-----------------------------------------------------------------------------
764 // TestSubDelReqTwoRetriesNoRespInSubmgr
767 // +-------+ +---------+ +---------+
768 // | xapp | | submgr | | e2term |
769 // +-------+ +---------+ +---------+
775 // |------------->| |
778 // | |------------->|
781 // | |------------->|
785 // |<-------------| |
787 //-----------------------------------------------------------------------------
789 func TestSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
791 CaseBegin("TestSubDelReTwoRetriesNoRespInSubmgr start")
794 cretrans := xappConn1.SendSubsReq(t, nil, nil)
795 crereq, cremsg := e2termConn.RecvSubsReq(t)
796 e2termConn.SendSubsResp(t, crereq, cremsg)
797 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
800 // Xapp: Send SubsDelReq
801 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
803 // E2t: Receive 1st SubsDelReq
804 e2termConn.RecvSubsDelReq(t)
806 // E2t: Receive 2nd SubsDelReq
807 e2termConn.RecvSubsDelReq(t)
809 // Xapp: Receive SubsDelResp
810 xappConn1.RecvSubsDelResp(t, deltrans)
812 // Wait that subs is cleaned
813 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
815 xappConn1.TestMsgChanEmpty(t)
816 xappConn2.TestMsgChanEmpty(t)
817 e2termConn.TestMsgChanEmpty(t)
818 mainCtrl.wait_registry_empty(t, 10)
821 //-----------------------------------------------------------------------------
822 // TestSubDelReqSubDelFailRespInSubmgr
825 // +-------+ +---------+ +---------+
826 // | xapp | | submgr | | e2term |
827 // +-------+ +---------+ +---------+
833 // |------------->| |
836 // | |------------->|
839 // | |<-------------|
842 // |<-------------| |
845 //-----------------------------------------------------------------------------
847 func TestSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
849 CaseBegin("TestSubReqSubDelFailRespInSubmgr start")
852 cretrans := xappConn1.SendSubsReq(t, nil, nil)
853 crereq, cremsg := e2termConn.RecvSubsReq(t)
854 e2termConn.SendSubsResp(t, crereq, cremsg)
855 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
857 // Xapp: Send SubsDelReq
858 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
860 // E2t: Send receive SubsDelReq and send SubsDelFail
861 delreq, delmsg := e2termConn.RecvSubsDelReq(t)
862 e2termConn.SendSubsDelFail(t, delreq, delmsg)
864 // Xapp: Receive SubsDelResp
865 xappConn1.RecvSubsDelResp(t, deltrans)
867 // Wait that subs is cleaned
868 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
870 xappConn1.TestMsgChanEmpty(t)
871 xappConn2.TestMsgChanEmpty(t)
872 e2termConn.TestMsgChanEmpty(t)
873 mainCtrl.wait_registry_empty(t, 10)
876 //-----------------------------------------------------------------------------
877 // TestSubReqAndSubDelOkSameAction
880 // +-------+ +---------+ +---------+
881 // | xapp | | submgr | | e2term |
882 // +-------+ +---------+ +---------+
887 // |------------->| |
890 // | |------------->|
892 // | |<-------------|
894 // |<-------------| |
897 // |------------->| |
900 // |<-------------| |
903 // |------------->| |
905 // | SubDelResp 1 | |
906 // |<-------------| |
909 // |------------->| |
912 // | |------------->|
915 // | |------------->|
917 // | SubDelResp 2 | |
918 // |<-------------| |
920 //-----------------------------------------------------------------------------
921 func TestSubReqAndSubDelOkSameAction(t *testing.T) {
922 CaseBegin("TestSubReqAndSubDelOkSameAction")
925 rparams1 := &teststube2ap.E2StubSubsReqParams{}
927 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
928 crereq1, cremsg1 := e2termConn.RecvSubsReq(t)
929 e2termConn.SendSubsResp(t, crereq1, cremsg1)
930 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
933 rparams2 := &teststube2ap.E2StubSubsReqParams{}
935 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
936 //crereq2, cremsg2 := e2termConn.RecvSubsReq(t)
937 //e2termConn.SendSubsResp(t, crereq2, cremsg2)
938 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
941 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
942 //e2termConn.RecvSubsDelReq(t)
943 //e2termConn.SendSubsDelResp(t, delreq1, delmsg1)
944 xappConn1.RecvSubsDelResp(t, deltrans1)
945 //Wait that subs is cleaned
946 //mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
949 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
950 delreq2, delmsg2 := e2termConn.RecvSubsDelReq(t)
951 e2termConn.SendSubsDelResp(t, delreq2, delmsg2)
952 xappConn2.RecvSubsDelResp(t, deltrans2)
953 //Wait that subs is cleaned
954 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
956 xappConn1.TestMsgChanEmpty(t)
957 xappConn2.TestMsgChanEmpty(t)
958 e2termConn.TestMsgChanEmpty(t)
959 mainCtrl.wait_registry_empty(t, 10)
962 //-----------------------------------------------------------------------------
963 // TestSubReqAndSubDelOkSameActionParallel
966 // +-------+ +---------+ +---------+
967 // | xapp | | submgr | | e2term |
968 // +-------+ +---------+ +---------+
973 // |------------->| |
976 // | |------------->|
978 // |------------->| |
980 // | |<-------------|
982 // |<-------------| |
985 // |<-------------| |
988 // |------------->| |
990 // | SubDelResp 1 | |
991 // |<-------------| |
994 // |------------->| |
997 // | |------------->|
1000 // | |------------->|
1002 // | SubDelResp 2 | |
1003 // |<-------------| |
1005 //-----------------------------------------------------------------------------
1006 func TestSubReqAndSubDelOkSameActionParallel(t *testing.T) {
1007 CaseBegin("TestSubReqAndSubDelOkSameActionParallel")
1010 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1012 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1013 crereq1, cremsg1 := e2termConn.RecvSubsReq(t)
1016 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1018 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1021 e2termConn.SendSubsResp(t, crereq1, cremsg1)
1022 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1025 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1028 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1029 xappConn1.RecvSubsDelResp(t, deltrans1)
1032 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1033 delreq2, delmsg2 := e2termConn.RecvSubsDelReq(t)
1034 e2termConn.SendSubsDelResp(t, delreq2, delmsg2)
1035 xappConn2.RecvSubsDelResp(t, deltrans2)
1037 //Wait that subs is cleaned
1038 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1040 xappConn1.TestMsgChanEmpty(t)
1041 xappConn2.TestMsgChanEmpty(t)
1042 e2termConn.TestMsgChanEmpty(t)
1043 mainCtrl.wait_registry_empty(t, 10)
1046 //-----------------------------------------------------------------------------
1047 // TestSubReqAndSubDelNokSameActionParallel
1050 // +-------+ +---------+ +---------+
1051 // | xapp | | submgr | | e2term |
1052 // +-------+ +---------+ +---------+
1057 // |------------->| |
1060 // | |------------->|
1062 // |------------->| |
1064 // | |<-------------|
1066 // |<-------------| |
1069 // |<-------------| |
1071 //-----------------------------------------------------------------------------
1072 func TestSubReqAndSubDelNokSameActionParallel(t *testing.T) {
1073 CaseBegin("TestSubReqAndSubDelNokSameActionParallel")
1076 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1078 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1079 crereq1, cremsg1 := e2termConn.RecvSubsReq(t)
1082 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1084 seqBef2 := mainCtrl.get_msgcounter(t)
1085 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1086 mainCtrl.wait_msgcounter_change(t, seqBef2, 10)
1089 fparams := &teststube2ap.E2StubSubsFailParams{}
1090 fparams.Set(crereq1)
1091 e2termConn.SendSubsFail(t, fparams, cremsg1)
1094 e2SubsId1 := xappConn1.RecvSubsFail(t, cretrans1)
1096 xappConn2.RecvSubsFail(t, cretrans2)
1098 //Wait that subs is cleaned
1099 mainCtrl.wait_subs_clean(t, e2SubsId1, 15)
1101 xappConn1.TestMsgChanEmpty(t)
1102 xappConn2.TestMsgChanEmpty(t)
1103 e2termConn.TestMsgChanEmpty(t)
1104 mainCtrl.wait_registry_empty(t, 10)
1107 //-----------------------------------------------------------------------------
1108 // TestSubReqAndSubDelNoAnswerSameActionParallel
1111 // +-------+ +---------+ +---------+
1112 // | xapp | | submgr | | e2term |
1113 // +-------+ +---------+ +---------+
1118 // |------------->| |
1121 // | |------------->|
1123 // |------------->| |
1126 // | |------------->|
1130 // | |------------->|
1133 // | |<-------------|
1135 //-----------------------------------------------------------------------------
1136 func TestSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
1137 CaseBegin("TestSubReqAndSubDelNoAnswerSameActionParallel")
1140 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1142 xappConn1.SendSubsReq(t, rparams1, nil)
1144 e2termConn.RecvSubsReq(t)
1147 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1149 seqBef2 := mainCtrl.get_msgcounter(t)
1150 xappConn2.SendSubsReq(t, rparams2, nil)
1151 mainCtrl.wait_msgcounter_change(t, seqBef2, 10)
1153 //Req1 (retransmitted)
1154 e2termConn.RecvSubsReq(t)
1156 delreq1, delmsg1 := e2termConn.RecvSubsDelReq(t)
1157 e2termConn.SendSubsDelResp(t, delreq1, delmsg1)
1159 //Wait that subs is cleaned
1160 mainCtrl.wait_subs_clean(t, delreq1.RequestId.Seq, 10)
1162 xappConn1.TestMsgChanEmpty(t)
1163 xappConn2.TestMsgChanEmpty(t)
1164 e2termConn.TestMsgChanEmpty(t)
1165 mainCtrl.wait_registry_empty(t, 15)
1168 //----------------------------- Policy cases ---------------------------------
1169 //-----------------------------------------------------------------------------
1170 // TestSubReqPolicyAndSubDelOk
1173 // +-------+ +---------+ +---------+
1174 // | xapp | | submgr | | e2term |
1175 // +-------+ +---------+ +---------+
1178 // |------------->| |
1181 // | |------------->|
1184 // | |<-------------|
1187 // |<-------------| |
1191 // |------------->| |
1194 // | |------------->|
1197 // | |<-------------|
1200 // |<-------------| |
1202 //-----------------------------------------------------------------------------
1203 func TestSubReqPolicyAndSubDelOk(t *testing.T) {
1204 CaseBegin("TestSubReqAndSubDelOk")
1206 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1208 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
1209 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1211 crereq, cremsg := e2termConn.RecvSubsReq(t)
1212 e2termConn.SendSubsResp(t, crereq, cremsg)
1213 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1214 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1215 delreq, delmsg := e2termConn.RecvSubsDelReq(t)
1217 e2termConn.SendSubsDelResp(t, delreq, delmsg)
1218 xappConn1.RecvSubsDelResp(t, deltrans)
1220 //Wait that subs is cleaned
1221 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1223 xappConn1.TestMsgChanEmpty(t)
1224 xappConn2.TestMsgChanEmpty(t)
1225 e2termConn.TestMsgChanEmpty(t)
1226 mainCtrl.wait_registry_empty(t, 10)
1229 //-----------------------------------------------------------------------------
1230 // TestSubReqPolicyChangeAndSubDelOk
1233 // +-------+ +---------+ +---------+
1234 // | xapp | | submgr | | e2term |
1235 // +-------+ +---------+ +---------+
1238 // |------------->| |
1241 // | |------------->|
1244 // | |<-------------|
1247 // |<-------------| |
1250 // |------------->| |
1253 // | |------------->|
1256 // | |<-------------|
1259 // |<-------------| |
1262 // |------------->| |
1265 // | |------------->|
1268 // | |<-------------|
1271 // |<-------------| |
1273 //-----------------------------------------------------------------------------
1275 func TestSubReqPolicyChangeAndSubDelOk(t *testing.T) {
1276 CaseBegin("TestSubReqAndSubDelOk")
1278 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1280 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
1281 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1283 crereq, cremsg := e2termConn.RecvSubsReq(t)
1284 e2termConn.SendSubsResp(t, crereq, cremsg)
1285 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1288 rparams1.Req.RequestId.Seq = e2SubsId
1289 rparams1.Req.ActionSetups[0].SubsequentAction.TimetoWait = e2ap.E2AP_TimeToWaitW200ms
1290 xappConn1.SendSubsReq(t, rparams1, cretrans)
1292 crereq, cremsg = e2termConn.RecvSubsReq(t)
1293 e2termConn.SendSubsResp(t, crereq, cremsg)
1294 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
1295 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1296 delreq, delmsg := e2termConn.RecvSubsDelReq(t)
1298 e2termConn.SendSubsDelResp(t, delreq, delmsg)
1299 xappConn1.RecvSubsDelResp(t, deltrans)
1301 //Wait that subs is cleaned
1302 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1304 xappConn1.TestMsgChanEmpty(t)
1305 xappConn2.TestMsgChanEmpty(t)
1306 e2termConn.TestMsgChanEmpty(t)
1307 mainCtrl.wait_registry_empty(t, 10)