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"
25 "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
26 "github.com/stretchr/testify/assert"
30 //-----------------------------------------------------------------------------
31 // TestSubReqAndRouteNok
34 // +-------+ +---------+ +---------+
35 // | xapp | | submgr | | rtmgr |
36 // +-------+ +---------+ +---------+
48 // | [SUBS INT DELETE] |
51 //-----------------------------------------------------------------------------
53 func TestSubReqAndRouteNok(t *testing.T) {
54 CaseBegin("TestSubReqAndRouteNok")
56 waiter := rtmgrHttp.AllocNextEvent(false)
57 newSubsId := mainCtrl.get_subid(t)
58 xappConn1.SendSubsReq(t, nil, nil)
61 //Wait that subs is cleaned
62 mainCtrl.wait_subs_clean(t, newSubsId, 10)
64 xappConn1.TestMsgChanEmpty(t)
65 xappConn2.TestMsgChanEmpty(t)
66 e2termConn1.TestMsgChanEmpty(t)
67 mainCtrl.wait_registry_empty(t, 10)
70 //-----------------------------------------------------------------------------
71 // TestSubReqAndSubDelOk
74 // +-------+ +---------+ +---------+
75 // | xapp | | submgr | | e2term |
76 // +-------+ +---------+ +---------+
101 // |<-------------| |
103 //-----------------------------------------------------------------------------
104 func TestSubReqAndSubDelOk(t *testing.T) {
105 CaseBegin("TestSubReqAndSubDelOk")
107 cretrans := xappConn1.SendSubsReq(t, nil, nil)
109 crereq, cremsg := e2termConn1.RecvSubsReq(t)
110 e2termConn1.SendSubsResp(t, crereq, cremsg)
111 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
113 resp, _ := xapp.Subscription.QuerySubscriptions()
114 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
115 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
116 assert.Equal(t, resp[0].Endpoint, []string{"localhost:13560"})
118 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
119 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
121 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
122 xappConn1.RecvSubsDelResp(t, deltrans)
124 //Wait that subs is cleaned
125 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
127 xappConn1.TestMsgChanEmpty(t)
128 xappConn2.TestMsgChanEmpty(t)
129 e2termConn1.TestMsgChanEmpty(t)
130 mainCtrl.wait_registry_empty(t, 10)
133 //-----------------------------------------------------------------------------
134 // TestSubReqRetransmission
137 // +-------+ +---------+ +---------+
138 // | xapp | | submgr | | e2term |
139 // +-------+ +---------+ +---------+
142 // |------------->| |
145 // | |------------->|
149 // |------------->| |
152 // | |<-------------|
155 // |<-------------| |
160 //-----------------------------------------------------------------------------
161 func TestSubReqRetransmission(t *testing.T) {
162 CaseBegin("TestSubReqRetransmission")
165 cretrans := xappConn1.SendSubsReq(t, nil, nil)
166 crereq, cremsg := e2termConn1.RecvSubsReq(t)
168 seqBef := mainCtrl.get_msgcounter(t)
169 xappConn1.SendSubsReq(t, nil, cretrans) //Retransmitted SubReq
170 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
172 e2termConn1.SendSubsResp(t, crereq, cremsg)
173 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
176 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
177 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
178 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
179 xappConn1.RecvSubsDelResp(t, deltrans)
181 //Wait that subs is cleaned
182 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
184 xappConn1.TestMsgChanEmpty(t)
185 xappConn2.TestMsgChanEmpty(t)
186 e2termConn1.TestMsgChanEmpty(t)
187 mainCtrl.wait_registry_empty(t, 10)
190 //-----------------------------------------------------------------------------
191 // TestSubDelReqRetransmission
194 // +-------+ +---------+ +---------+
195 // | xapp | | submgr | | e2term |
196 // +-------+ +---------+ +---------+
202 // |------------->| |
205 // | |------------->|
210 // |------------->| |
213 // | |<-------------|
216 // |<-------------| |
218 //-----------------------------------------------------------------------------
219 func TestSubDelReqRetransmission(t *testing.T) {
220 CaseBegin("TestSubDelReqRetransmission")
223 cretrans := xappConn1.SendSubsReq(t, nil, nil)
224 crereq, cremsg := e2termConn1.RecvSubsReq(t)
225 e2termConn1.SendSubsResp(t, crereq, cremsg)
226 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
229 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
230 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
232 seqBef := mainCtrl.get_msgcounter(t)
233 xappConn1.SendSubsDelReq(t, deltrans, e2SubsId) //Retransmitted SubDelReq
234 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
236 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
237 xappConn1.RecvSubsDelResp(t, deltrans)
239 //Wait that subs is cleaned
240 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
242 xappConn1.TestMsgChanEmpty(t)
243 xappConn2.TestMsgChanEmpty(t)
244 e2termConn1.TestMsgChanEmpty(t)
245 mainCtrl.wait_registry_empty(t, 10)
248 //-----------------------------------------------------------------------------
249 // TestSubDelReqCollision
252 // +-------+ +---------+ +---------+
253 // | xapp | | submgr | | e2term |
254 // +-------+ +---------+ +---------+
260 // |------------->| |
263 // | |------------->|
268 // |------------->| |
270 // | | SubDelResp 1 |
271 // | |<-------------|
273 // | SubDelResp 1 | |
274 // |<-------------| |
276 // | SubDelResp 2 | |
277 // |<-------------| |
279 //-----------------------------------------------------------------------------
281 func TestSubDelReqCollision(t *testing.T) {
282 CaseBegin("TestSubDelReqCollision")
285 cretrans := xappConn1.SendSubsReq(t, nil, nil)
286 crereq, cremsg := e2termConn1.RecvSubsReq(t)
287 e2termConn1.SendSubsResp(t, crereq, cremsg)
288 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
291 xappConn1.SendSubsDelReq(t, nil, e2SubsId)
292 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
294 // Subs Delete colliding
295 seqBef := mainCtrl.get_msgcounter(t)
296 deltranscol2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
297 xappConn1.SendSubsDelReq(t, deltranscol2, e2SubsId) //Colliding SubDelReq
298 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
300 // Del resp for first and second
301 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
303 // don't care in which order responses are received
304 xappConn1.RecvSubsDelResp(t, nil)
305 xappConn1.RecvSubsDelResp(t, nil)
307 //Wait that subs is cleaned
308 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
310 xappConn1.TestMsgChanEmpty(t)
311 xappConn2.TestMsgChanEmpty(t)
312 e2termConn1.TestMsgChanEmpty(t)
313 mainCtrl.wait_registry_empty(t, 10)
316 //-----------------------------------------------------------------------------
317 // TestSubReqAndSubDelOkTwoParallel
320 // +-------+ +-------+ +---------+ +---------+
321 // | xapp | | xapp | | submgr | | e2term |
322 // +-------+ +-------+ +---------+ +---------+
327 // | |------------->| |
330 // | | |------------->|
333 // |------------------------>| |
336 // | | |------------->|
339 // | | |<-------------|
341 // | |<-------------| |
344 // | | |<-------------|
346 // |<------------------------| |
348 // | | [SUBS 1 DELETE] |
350 // | | [SUBS 2 DELETE] |
353 //-----------------------------------------------------------------------------
354 func TestSubReqAndSubDelOkTwoParallel(t *testing.T) {
355 CaseBegin("TestSubReqAndSubDelOkTwoParallel")
358 rparams1 := &teststube2ap.E2StubSubsReqParams{}
360 rparams1.Req.EventTriggerDefinition.ProcedureCode = 5
361 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
362 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
365 rparams2 := &teststube2ap.E2StubSubsReqParams{}
367 rparams2.Req.EventTriggerDefinition.ProcedureCode = 28
368 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
369 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
372 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
373 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
376 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
377 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
380 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
381 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
382 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
383 xappConn1.RecvSubsDelResp(t, deltrans1)
384 //Wait that subs is cleaned
385 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
388 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
389 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
390 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
391 xappConn2.RecvSubsDelResp(t, deltrans2)
392 //Wait that subs is cleaned
393 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
395 xappConn1.TestMsgChanEmpty(t)
396 xappConn2.TestMsgChanEmpty(t)
397 e2termConn1.TestMsgChanEmpty(t)
398 mainCtrl.wait_registry_empty(t, 10)
401 //-----------------------------------------------------------------------------
402 // TestSameSubsDiffRan
403 // Same subscription to different RANs
406 // +-------+ +---------+ +---------+
407 // | xapp | | submgr | | e2term |
408 // +-------+ +---------+ +---------+
413 // |------------->| |
416 // | |------------->|
419 // | |<-------------|
422 // |<-------------| |
425 // |------------->| |
428 // | |------------->|
431 // | |<-------------|
434 // |<-------------| |
436 // | [SUBS r1 DELETE] |
438 // | [SUBS r2 DELETE] |
441 //-----------------------------------------------------------------------------
442 func TestSameSubsDiffRan(t *testing.T) {
443 CaseBegin("TestSameSubsDiffRan")
446 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
447 xappConn1.SendSubsReq(t, nil, cretrans1)
448 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
449 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
450 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
453 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
454 xappConn1.SendSubsReq(t, nil, cretrans2)
455 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
456 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
457 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
460 deltrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
461 xappConn1.SendSubsDelReq(t, deltrans1, e2SubsId1)
462 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
463 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
464 xappConn1.RecvSubsDelResp(t, deltrans1)
465 //Wait that subs is cleaned
466 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
469 deltrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
470 xappConn1.SendSubsDelReq(t, deltrans2, e2SubsId2)
471 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
472 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
473 xappConn1.RecvSubsDelResp(t, deltrans2)
474 //Wait that subs is cleaned
475 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
477 xappConn1.TestMsgChanEmpty(t)
478 xappConn2.TestMsgChanEmpty(t)
479 e2termConn1.TestMsgChanEmpty(t)
480 mainCtrl.wait_registry_empty(t, 10)
483 //-----------------------------------------------------------------------------
484 // TestSubReqRetryInSubmgr
487 // +-------+ +---------+ +---------+
488 // | xapp | | submgr | | e2term |
489 // +-------+ +---------+ +---------+
492 // |------------->| |
495 // | |------------->|
499 // | |------------->|
502 // | |<-------------|
505 // |<-------------| |
510 //-----------------------------------------------------------------------------
512 func TestSubReqRetryInSubmgr(t *testing.T) {
514 CaseBegin("TestSubReqRetryInSubmgr start")
516 // Xapp: Send SubsReq
517 cretrans := xappConn1.SendSubsReq(t, nil, nil)
519 // E2t: Receive 1st SubsReq
520 e2termConn1.RecvSubsReq(t)
522 // E2t: Receive 2nd SubsReq and send SubsResp
523 crereq, cremsg := e2termConn1.RecvSubsReq(t)
524 e2termConn1.SendSubsResp(t, crereq, cremsg)
526 // Xapp: Receive SubsResp
527 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
529 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
530 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
531 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
532 xappConn1.RecvSubsDelResp(t, deltrans)
534 // Wait that subs is cleaned
535 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
537 xappConn1.TestMsgChanEmpty(t)
538 xappConn2.TestMsgChanEmpty(t)
539 e2termConn1.TestMsgChanEmpty(t)
540 mainCtrl.wait_registry_empty(t, 10)
543 //-----------------------------------------------------------------------------
544 // TestSubReqTwoRetriesNoRespSubDelRespInSubmgr
547 // +-------+ +---------+ +---------+
548 // | xapp | | submgr | | e2term |
549 // +-------+ +---------+ +---------+
552 // |------------->| |
555 // | |------------->|
559 // | |------------->|
562 // | |------------->|
566 // | |------------->|
570 // | |<-------------|
573 //-----------------------------------------------------------------------------
575 func TestSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
577 CaseBegin("TestSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
579 // Xapp: Send SubsReq
580 xappConn1.SendSubsReq(t, nil, nil)
582 // E2t: Receive 1st SubsReq
583 e2termConn1.RecvSubsReq(t)
585 // E2t: Receive 2nd SubsReq
586 e2termConn1.RecvSubsReq(t)
588 // E2t: Send receive SubsDelReq and send SubsResp
589 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
590 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
592 // Wait that subs is cleaned
593 mainCtrl.wait_subs_clean(t, delreq.RequestId.Seq, 10)
595 xappConn1.TestMsgChanEmpty(t)
596 xappConn2.TestMsgChanEmpty(t)
597 e2termConn1.TestMsgChanEmpty(t)
598 mainCtrl.wait_registry_empty(t, 10)
601 //-----------------------------------------------------------------------------
602 // TestSubReqTwoRetriesNoRespAtAllInSubmgr
605 // +-------+ +---------+ +---------+
606 // | xapp | | submgr | | e2term |
607 // +-------+ +---------+ +---------+
610 // |------------->| |
613 // | |------------->|
617 // | |------------->|
620 // | |------------->|
624 // | |------------->|
628 //-----------------------------------------------------------------------------
630 func TestSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
632 CaseBegin("TestSubReqTwoRetriesNoRespAtAllInSubmgr start")
634 // Xapp: Send SubsReq
635 xappConn1.SendSubsReq(t, nil, nil)
637 // E2t: Receive 1st SubsReq
638 e2termConn1.RecvSubsReq(t)
640 // E2t: Receive 2nd SubsReq
641 e2termConn1.RecvSubsReq(t)
643 // E2t: Receive 1st SubsDelReq
644 e2termConn1.RecvSubsDelReq(t)
646 // E2t: Receive 2nd SubsDelReq
647 delreq, _ := e2termConn1.RecvSubsDelReq(t)
649 // Wait that subs is cleaned
650 mainCtrl.wait_subs_clean(t, delreq.RequestId.Seq, 15)
652 xappConn1.TestMsgChanEmpty(t)
653 xappConn2.TestMsgChanEmpty(t)
654 e2termConn1.TestMsgChanEmpty(t)
655 mainCtrl.wait_registry_empty(t, 10)
658 //-----------------------------------------------------------------------------
659 // TestSubReqSubFailRespInSubmgr
662 // +-------+ +---------+ +---------+
663 // | xapp | | submgr | | e2term |
664 // +-------+ +---------+ +---------+
667 // |------------->| |
670 // | |------------->|
673 // | |<-------------|
676 // |<-------------| |
679 //-----------------------------------------------------------------------------
681 func TestSubReqSubFailRespInSubmgr(t *testing.T) {
683 CaseBegin("TestSubReqSubFailRespInSubmgr start")
685 // Xapp: Send SubsReq
686 cretrans := xappConn1.SendSubsReq(t, nil, nil)
688 // E2t: Receive SubsReq and send SubsFail
689 crereq, cremsg := e2termConn1.RecvSubsReq(t)
690 fparams := &teststube2ap.E2StubSubsFailParams{}
692 e2termConn1.SendSubsFail(t, fparams, cremsg)
694 // Xapp: Receive SubsFail
695 e2SubsId := xappConn1.RecvSubsFail(t, cretrans)
697 // Wait that subs is cleaned
698 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
700 xappConn1.TestMsgChanEmpty(t)
701 xappConn2.TestMsgChanEmpty(t)
702 e2termConn1.TestMsgChanEmpty(t)
703 mainCtrl.wait_registry_empty(t, 10)
706 //-----------------------------------------------------------------------------
707 // TestSubDelReqRetryInSubmgr
710 // +-------+ +---------+ +---------+
711 // | xapp | | submgr | | e2term |
712 // +-------+ +---------+ +---------+
718 // |------------->| |
721 // | |------------->|
724 // | |------------->|
727 // | |<-------------|
730 // |<-------------| |
732 //-----------------------------------------------------------------------------
734 func TestSubDelReqRetryInSubmgr(t *testing.T) {
736 CaseBegin("TestSubDelReqRetryInSubmgr start")
739 cretrans := xappConn1.SendSubsReq(t, nil, nil)
740 crereq, cremsg := e2termConn1.RecvSubsReq(t)
741 e2termConn1.SendSubsResp(t, crereq, cremsg)
742 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
745 // Xapp: Send SubsDelReq
746 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
748 // E2t: Receive 1st SubsDelReq
749 e2termConn1.RecvSubsDelReq(t)
751 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
752 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
753 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
755 // Xapp: Receive SubsDelResp
756 xappConn1.RecvSubsDelResp(t, deltrans)
758 // Wait that subs is cleaned
759 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
761 xappConn1.TestMsgChanEmpty(t)
762 xappConn2.TestMsgChanEmpty(t)
763 e2termConn1.TestMsgChanEmpty(t)
764 mainCtrl.wait_registry_empty(t, 10)
767 //-----------------------------------------------------------------------------
768 // TestSubDelReqTwoRetriesNoRespInSubmgr
771 // +-------+ +---------+ +---------+
772 // | xapp | | submgr | | e2term |
773 // +-------+ +---------+ +---------+
779 // |------------->| |
782 // | |------------->|
785 // | |------------->|
789 // |<-------------| |
791 //-----------------------------------------------------------------------------
793 func TestSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
795 CaseBegin("TestSubDelReTwoRetriesNoRespInSubmgr start")
798 cretrans := xappConn1.SendSubsReq(t, nil, nil)
799 crereq, cremsg := e2termConn1.RecvSubsReq(t)
800 e2termConn1.SendSubsResp(t, crereq, cremsg)
801 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
804 // Xapp: Send SubsDelReq
805 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
807 // E2t: Receive 1st SubsDelReq
808 e2termConn1.RecvSubsDelReq(t)
810 // E2t: Receive 2nd SubsDelReq
811 e2termConn1.RecvSubsDelReq(t)
813 // Xapp: Receive SubsDelResp
814 xappConn1.RecvSubsDelResp(t, deltrans)
816 // Wait that subs is cleaned
817 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
819 xappConn1.TestMsgChanEmpty(t)
820 xappConn2.TestMsgChanEmpty(t)
821 e2termConn1.TestMsgChanEmpty(t)
822 mainCtrl.wait_registry_empty(t, 10)
825 //-----------------------------------------------------------------------------
826 // TestSubDelReqSubDelFailRespInSubmgr
829 // +-------+ +---------+ +---------+
830 // | xapp | | submgr | | e2term |
831 // +-------+ +---------+ +---------+
837 // |------------->| |
840 // | |------------->|
843 // | |<-------------|
846 // |<-------------| |
849 //-----------------------------------------------------------------------------
851 func TestSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
853 CaseBegin("TestSubReqSubDelFailRespInSubmgr start")
856 cretrans := xappConn1.SendSubsReq(t, nil, nil)
857 crereq, cremsg := e2termConn1.RecvSubsReq(t)
858 e2termConn1.SendSubsResp(t, crereq, cremsg)
859 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
861 // Xapp: Send SubsDelReq
862 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
864 // E2t: Send receive SubsDelReq and send SubsDelFail
865 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
866 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
868 // Xapp: Receive SubsDelResp
869 xappConn1.RecvSubsDelResp(t, deltrans)
871 // Wait that subs is cleaned
872 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
874 xappConn1.TestMsgChanEmpty(t)
875 xappConn2.TestMsgChanEmpty(t)
876 e2termConn1.TestMsgChanEmpty(t)
877 mainCtrl.wait_registry_empty(t, 10)
880 //-----------------------------------------------------------------------------
881 // TestSubReqAndSubDelOkSameAction
884 // +-------+ +-------+ +---------+ +---------+
885 // | xapp2 | | xapp1 | | submgr | | e2term |
886 // +-------+ +-------+ +---------+ +---------+
891 // | |------------->| |
894 // | | |------------->|
896 // | | |<-------------|
898 // | |<-------------| |
901 // |--------------------------->| |
904 // |<---------------------------| |
906 // | | SubDelReq 1 | |
907 // | |------------->| |
909 // | | SubDelResp 1 | |
910 // | |<-------------| |
913 // |--------------------------->| |
915 // | | | SubDelReq 2 |
916 // | | |------------->|
918 // | | | SubDelReq 2 |
919 // | | |------------->|
921 // | SubDelResp 2 | |
922 // |<---------------------------| |
924 //-----------------------------------------------------------------------------
925 func TestSubReqAndSubDelOkSameAction(t *testing.T) {
926 CaseBegin("TestSubReqAndSubDelOkSameAction")
929 rparams1 := &teststube2ap.E2StubSubsReqParams{}
931 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
932 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
933 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
934 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
937 rparams2 := &teststube2ap.E2StubSubsReqParams{}
939 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
940 //crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
941 //e2termConn1.SendSubsResp(t, crereq2, cremsg2)
942 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
944 resp, _ := xapp.Subscription.QuerySubscriptions()
945 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
946 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
947 assert.Equal(t, resp[0].Endpoint, []string{"localhost:13560", "localhost:13660"})
950 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
951 //e2termConn1.RecvSubsDelReq(t)
952 //e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
953 xappConn1.RecvSubsDelResp(t, deltrans1)
954 //Wait that subs is cleaned
955 //mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
958 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
959 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
960 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
961 xappConn2.RecvSubsDelResp(t, deltrans2)
962 //Wait that subs is cleaned
963 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
965 xappConn1.TestMsgChanEmpty(t)
966 xappConn2.TestMsgChanEmpty(t)
967 e2termConn1.TestMsgChanEmpty(t)
968 mainCtrl.wait_registry_empty(t, 10)
971 //-----------------------------------------------------------------------------
972 // TestSubReqAndSubDelOkSameActionParallel
975 // +-------+ +-------+ +---------+ +---------+
976 // | xapp2 | | xapp1 | | submgr | | e2term |
977 // +-------+ +-------+ +---------+ +---------+
982 // | |------------->| |
985 // | | |------------->|
987 // |--------------------------->| |
989 // | | |<-------------|
991 // | |<-------------| |
994 // |<---------------------------| |
996 // | | SubDelReq 1 | |
997 // | |------------->| |
999 // | | SubDelResp 1 | |
1000 // | |<-------------| |
1002 // | SubDelReq 2 | |
1003 // |--------------------------->| |
1005 // | | | SubDelReq 2 |
1006 // | | |------------->|
1008 // | | | SubDelReq 2 |
1009 // | | |------------->|
1011 // | SubDelResp 2 | |
1012 // |<---------------------------| |
1014 //-----------------------------------------------------------------------------
1015 func TestSubReqAndSubDelOkSameActionParallel(t *testing.T) {
1016 CaseBegin("TestSubReqAndSubDelOkSameActionParallel")
1019 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1021 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1022 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1025 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1027 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1030 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1031 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1034 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1037 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1038 xappConn1.RecvSubsDelResp(t, deltrans1)
1041 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1042 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1043 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1044 xappConn2.RecvSubsDelResp(t, deltrans2)
1046 //Wait that subs is cleaned
1047 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1049 xappConn1.TestMsgChanEmpty(t)
1050 xappConn2.TestMsgChanEmpty(t)
1051 e2termConn1.TestMsgChanEmpty(t)
1052 mainCtrl.wait_registry_empty(t, 10)
1055 //-----------------------------------------------------------------------------
1056 // TestSubReqAndSubDelNokSameActionParallel
1059 // +-------+ +-------+ +---------+ +---------+
1060 // | xapp2 | | xapp1 | | submgr | | e2term |
1061 // +-------+ +-------+ +---------+ +---------+
1066 // | |------------->| |
1069 // | | |------------->|
1071 // |--------------------------->| |
1073 // | | |<-------------|
1075 // | |<-------------| |
1078 // |<---------------------------| |
1080 //-----------------------------------------------------------------------------
1081 func TestSubReqAndSubDelNokSameActionParallel(t *testing.T) {
1082 CaseBegin("TestSubReqAndSubDelNokSameActionParallel")
1085 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1087 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1088 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1091 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1093 seqBef2 := mainCtrl.get_msgcounter(t)
1094 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1095 mainCtrl.wait_msgcounter_change(t, seqBef2, 10)
1098 fparams := &teststube2ap.E2StubSubsFailParams{}
1099 fparams.Set(crereq1)
1100 e2termConn1.SendSubsFail(t, fparams, cremsg1)
1103 e2SubsId1 := xappConn1.RecvSubsFail(t, cretrans1)
1105 xappConn2.RecvSubsFail(t, cretrans2)
1107 //Wait that subs is cleaned
1108 mainCtrl.wait_subs_clean(t, e2SubsId1, 15)
1110 xappConn1.TestMsgChanEmpty(t)
1111 xappConn2.TestMsgChanEmpty(t)
1112 e2termConn1.TestMsgChanEmpty(t)
1113 mainCtrl.wait_registry_empty(t, 10)
1116 //-----------------------------------------------------------------------------
1117 // TestSubReqAndSubDelNoAnswerSameActionParallel
1120 // +-------+ +-------+ +---------+ +---------+
1121 // | xapp2 | | xapp1 | | submgr | | e2term |
1122 // +-------+ +-------+ +---------+ +---------+
1127 // | |------------->| |
1130 // | | |------------->|
1132 // |--------------------------->| |
1135 // | | |------------->|
1138 // | | | SubDelReq |
1139 // | | |------------->|
1141 // | | | SubDelResp |
1142 // | | |<-------------|
1144 //-----------------------------------------------------------------------------
1145 func TestSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
1146 CaseBegin("TestSubReqAndSubDelNoAnswerSameActionParallel")
1149 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1151 xappConn1.SendSubsReq(t, rparams1, nil)
1153 e2termConn1.RecvSubsReq(t)
1156 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1158 seqBef2 := mainCtrl.get_msgcounter(t)
1159 xappConn2.SendSubsReq(t, rparams2, nil)
1160 mainCtrl.wait_msgcounter_change(t, seqBef2, 10)
1162 //Req1 (retransmitted)
1163 e2termConn1.RecvSubsReq(t)
1165 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1166 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1168 //Wait that subs is cleaned
1169 mainCtrl.wait_subs_clean(t, delreq1.RequestId.Seq, 10)
1171 xappConn1.TestMsgChanEmpty(t)
1172 xappConn2.TestMsgChanEmpty(t)
1173 e2termConn1.TestMsgChanEmpty(t)
1174 mainCtrl.wait_registry_empty(t, 15)
1177 //----------------------------- Policy cases ---------------------------------
1178 //-----------------------------------------------------------------------------
1179 // TestSubReqPolicyAndSubDelOk
1182 // +-------+ +---------+ +---------+
1183 // | xapp | | submgr | | e2term |
1184 // +-------+ +---------+ +---------+
1187 // |------------->| |
1190 // | |------------->|
1193 // | |<-------------|
1196 // |<-------------| |
1200 // |------------->| |
1203 // | |------------->|
1206 // | |<-------------|
1209 // |<-------------| |
1211 //-----------------------------------------------------------------------------
1212 func TestSubReqPolicyAndSubDelOk(t *testing.T) {
1213 CaseBegin("TestSubReqAndSubDelOk")
1215 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1217 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
1218 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1220 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1221 e2termConn1.SendSubsResp(t, crereq, cremsg)
1222 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1223 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1224 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1226 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1227 xappConn1.RecvSubsDelResp(t, deltrans)
1229 //Wait that subs is cleaned
1230 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1232 xappConn1.TestMsgChanEmpty(t)
1233 xappConn2.TestMsgChanEmpty(t)
1234 e2termConn1.TestMsgChanEmpty(t)
1235 mainCtrl.wait_registry_empty(t, 10)
1238 //-----------------------------------------------------------------------------
1239 // TestSubReqPolicyChangeAndSubDelOk
1242 // +-------+ +---------+ +---------+
1243 // | xapp | | submgr | | e2term |
1244 // +-------+ +---------+ +---------+
1247 // |------------->| |
1250 // | |------------->|
1253 // | |<-------------|
1256 // |<-------------| |
1259 // |------------->| |
1262 // | |------------->|
1265 // | |<-------------|
1268 // |<-------------| |
1271 // |------------->| |
1274 // | |------------->|
1277 // | |<-------------|
1280 // |<-------------| |
1282 //-----------------------------------------------------------------------------
1284 func TestSubReqPolicyChangeAndSubDelOk(t *testing.T) {
1285 CaseBegin("TestSubReqAndSubDelOk")
1287 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1289 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
1290 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1292 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1293 e2termConn1.SendSubsResp(t, crereq, cremsg)
1294 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1297 rparams1.Req.RequestId.Seq = e2SubsId
1298 rparams1.Req.ActionSetups[0].SubsequentAction.TimetoWait = e2ap.E2AP_TimeToWaitW200ms
1299 xappConn1.SendSubsReq(t, rparams1, cretrans)
1301 crereq, cremsg = e2termConn1.RecvSubsReq(t)
1302 e2termConn1.SendSubsResp(t, crereq, cremsg)
1303 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
1304 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1305 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1307 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1308 xappConn1.RecvSubsDelResp(t, deltrans)
1310 //Wait that subs is cleaned
1311 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1313 xappConn1.TestMsgChanEmpty(t)
1314 xappConn2.TestMsgChanEmpty(t)
1315 e2termConn1.TestMsgChanEmpty(t)
1316 mainCtrl.wait_registry_empty(t, 10)
1319 //-----------------------------------------------------------------------------
1320 // TestSubReqAndSubDelOkTwoE2termParallel
1323 // +-------+ +---------+ +---------+ +---------+
1324 // | xapp | | submgr | | e2term1 | | e2term2 |
1325 // +-------+ +---------+ +---------+ +---------+
1330 // |------------->| | |
1333 // | |------------->| |
1336 // |------------->| | |
1339 // | |---------------------------->|
1342 // | |<-------------| |
1344 // |<-------------| | |
1346 // | |<----------------------------|
1348 // |<-------------| | |
1350 // | [SUBS 1 DELETE] | |
1352 // | [SUBS 2 DELETE] | |
1355 //-----------------------------------------------------------------------------
1356 func TestSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
1357 CaseBegin("TestSubReqAndSubDelOkTwoE2termParallel")
1360 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1361 xappConn1.SendSubsReq(t, nil, cretrans1)
1362 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1364 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_11")
1365 xappConn1.SendSubsReq(t, nil, cretrans2)
1366 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
1369 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1370 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1373 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
1374 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
1377 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1378 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1379 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1380 xappConn1.RecvSubsDelResp(t, deltrans1)
1381 //Wait that subs is cleaned
1382 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1385 deltrans2 := xappConn1.SendSubsDelReq(t, nil, e2SubsId2)
1386 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
1387 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
1388 xappConn1.RecvSubsDelResp(t, deltrans2)
1389 //Wait that subs is cleaned
1390 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1392 xappConn1.TestMsgChanEmpty(t)
1393 xappConn2.TestMsgChanEmpty(t)
1394 e2termConn1.TestMsgChanEmpty(t)
1395 e2termConn2.TestMsgChanEmpty(t)
1396 mainCtrl.wait_registry_empty(t, 10)