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"
31 //-----------------------------------------------------------------------------
32 // TestSubReqAndRouteNok
35 // +-------+ +---------+ +---------+
36 // | xapp | | submgr | | rtmgr |
37 // +-------+ +---------+ +---------+
49 // | [SUBS INT DELETE] |
52 //-----------------------------------------------------------------------------
54 func TestSubReqAndRouteNok(t *testing.T) {
55 CaseBegin("TestSubReqAndRouteNok")
57 waiter := rtmgrHttp.AllocNextEvent(false)
58 newSubsId := mainCtrl.get_registry_next_subid(t)
59 xappConn1.SendSubsReq(t, nil, nil)
62 //Wait that subs is cleaned
63 mainCtrl.wait_subs_clean(t, newSubsId, 10)
65 xappConn1.TestMsgChanEmpty(t)
66 xappConn2.TestMsgChanEmpty(t)
67 e2termConn1.TestMsgChanEmpty(t)
68 mainCtrl.wait_registry_empty(t, 10)
71 //-----------------------------------------------------------------------------
72 // TestSubReqAndSubDelOk
75 // +-------+ +---------+ +---------+
76 // | xapp | | submgr | | e2term |
77 // +-------+ +---------+ +---------+
102 // |<-------------| |
104 //-----------------------------------------------------------------------------
105 func TestSubReqAndSubDelOk(t *testing.T) {
106 CaseBegin("TestSubReqAndSubDelOk")
108 cretrans := xappConn1.SendSubsReq(t, nil, nil)
110 crereq, cremsg := e2termConn1.RecvSubsReq(t)
111 e2termConn1.SendSubsResp(t, crereq, cremsg)
112 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
114 resp, _ := xapp.Subscription.QuerySubscriptions()
115 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
116 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
117 assert.Equal(t, resp[0].Endpoint, []string{"localhost:13560"})
119 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
120 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
122 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
123 xappConn1.RecvSubsDelResp(t, deltrans)
125 //Wait that subs is cleaned
126 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
128 xappConn1.TestMsgChanEmpty(t)
129 xappConn2.TestMsgChanEmpty(t)
130 e2termConn1.TestMsgChanEmpty(t)
131 mainCtrl.wait_registry_empty(t, 10)
134 //-----------------------------------------------------------------------------
135 // TestSubReqRetransmission
138 // +-------+ +---------+ +---------+
139 // | xapp | | submgr | | e2term |
140 // +-------+ +---------+ +---------+
143 // |------------->| |
146 // | |------------->|
150 // |------------->| |
153 // | |<-------------|
156 // |<-------------| |
161 //-----------------------------------------------------------------------------
162 func TestSubReqRetransmission(t *testing.T) {
163 CaseBegin("TestSubReqRetransmission")
166 cretrans := xappConn1.SendSubsReq(t, nil, nil)
167 crereq, cremsg := e2termConn1.RecvSubsReq(t)
169 seqBef := mainCtrl.get_msgcounter(t)
170 xappConn1.SendSubsReq(t, nil, cretrans) //Retransmitted SubReq
171 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
173 // hack as there is no real way to see has message be handled.
174 // Previuos counter check just tells that is has been received by submgr
175 // --> artificial delay
176 <-time.After(1 * time.Second)
177 e2termConn1.SendSubsResp(t, crereq, cremsg)
178 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
181 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
182 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
183 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
184 xappConn1.RecvSubsDelResp(t, deltrans)
186 //Wait that subs is cleaned
187 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
189 xappConn1.TestMsgChanEmpty(t)
190 xappConn2.TestMsgChanEmpty(t)
191 e2termConn1.TestMsgChanEmpty(t)
192 mainCtrl.wait_registry_empty(t, 10)
195 //-----------------------------------------------------------------------------
196 // TestSubDelReqRetransmission
199 // +-------+ +---------+ +---------+
200 // | xapp | | submgr | | e2term |
201 // +-------+ +---------+ +---------+
207 // |------------->| |
210 // | |------------->|
215 // |------------->| |
218 // | |<-------------|
221 // |<-------------| |
223 //-----------------------------------------------------------------------------
224 func TestSubDelReqRetransmission(t *testing.T) {
225 CaseBegin("TestSubDelReqRetransmission")
228 cretrans := xappConn1.SendSubsReq(t, nil, nil)
229 crereq, cremsg := e2termConn1.RecvSubsReq(t)
230 e2termConn1.SendSubsResp(t, crereq, cremsg)
231 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
234 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
235 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
237 seqBef := mainCtrl.get_msgcounter(t)
238 xappConn1.SendSubsDelReq(t, deltrans, e2SubsId) //Retransmitted SubDelReq
239 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
241 // hack as there is no real way to see has message be handled.
242 // Previuos counter check just tells that is has been received by submgr
243 // --> artificial delay
244 <-time.After(1 * time.Second)
246 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
247 xappConn1.RecvSubsDelResp(t, deltrans)
249 //Wait that subs is cleaned
250 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
252 xappConn1.TestMsgChanEmpty(t)
253 xappConn2.TestMsgChanEmpty(t)
254 e2termConn1.TestMsgChanEmpty(t)
255 mainCtrl.wait_registry_empty(t, 10)
258 //-----------------------------------------------------------------------------
259 // TestSubDelReqCollision
262 // +-------+ +---------+ +---------+
263 // | xapp | | submgr | | e2term |
264 // +-------+ +---------+ +---------+
270 // |------------->| |
273 // | |------------->|
278 // |------------->| |
280 // | | SubDelResp 1 |
281 // | |<-------------|
283 // | SubDelResp 1 | |
284 // |<-------------| |
286 // | SubDelResp 2 | |
287 // |<-------------| |
289 //-----------------------------------------------------------------------------
291 func TestSubDelReqCollision(t *testing.T) {
292 CaseBegin("TestSubDelReqCollision")
295 cretrans := xappConn1.SendSubsReq(t, nil, nil)
296 crereq, cremsg := e2termConn1.RecvSubsReq(t)
297 e2termConn1.SendSubsResp(t, crereq, cremsg)
298 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
301 xappConn1.SendSubsDelReq(t, nil, e2SubsId)
302 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
304 // Subs Delete colliding
305 seqBef := mainCtrl.get_msgcounter(t)
306 deltranscol2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
307 xappConn1.SendSubsDelReq(t, deltranscol2, e2SubsId) //Colliding SubDelReq
308 mainCtrl.wait_msgcounter_change(t, seqBef, 10)
310 // hack as there is no real way to see has message be handled.
311 // Previuos counter check just tells that is has been received by submgr
312 // --> artificial delay
313 <-time.After(1 * time.Second)
315 // Del resp for first and second
316 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
318 // don't care in which order responses are received
319 xappConn1.RecvSubsDelResp(t, nil)
320 xappConn1.RecvSubsDelResp(t, nil)
322 //Wait that subs is cleaned
323 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
325 xappConn1.TestMsgChanEmpty(t)
326 xappConn2.TestMsgChanEmpty(t)
327 e2termConn1.TestMsgChanEmpty(t)
328 mainCtrl.wait_registry_empty(t, 10)
331 //-----------------------------------------------------------------------------
332 // TestSubReqAndSubDelOkTwoParallel
335 // +-------+ +-------+ +---------+ +---------+
336 // | xapp | | xapp | | submgr | | e2term |
337 // +-------+ +-------+ +---------+ +---------+
342 // | |------------->| |
345 // | | |------------->|
348 // |------------------------>| |
351 // | | |------------->|
354 // | | |<-------------|
356 // | |<-------------| |
359 // | | |<-------------|
361 // |<------------------------| |
363 // | | [SUBS 1 DELETE] |
365 // | | [SUBS 2 DELETE] |
368 //-----------------------------------------------------------------------------
369 func TestSubReqAndSubDelOkTwoParallel(t *testing.T) {
370 CaseBegin("TestSubReqAndSubDelOkTwoParallel")
373 rparams1 := &teststube2ap.E2StubSubsReqParams{}
375 rparams1.Req.EventTriggerDefinition.ProcedureCode = 5
376 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
377 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
380 rparams2 := &teststube2ap.E2StubSubsReqParams{}
382 rparams2.Req.EventTriggerDefinition.ProcedureCode = 28
383 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
384 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
387 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
388 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
391 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
392 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
395 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
396 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
397 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
398 xappConn1.RecvSubsDelResp(t, deltrans1)
399 //Wait that subs is cleaned
400 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
403 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
404 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
405 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
406 xappConn2.RecvSubsDelResp(t, deltrans2)
407 //Wait that subs is cleaned
408 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
410 xappConn1.TestMsgChanEmpty(t)
411 xappConn2.TestMsgChanEmpty(t)
412 e2termConn1.TestMsgChanEmpty(t)
413 mainCtrl.wait_registry_empty(t, 10)
416 //-----------------------------------------------------------------------------
417 // TestSameSubsDiffRan
418 // Same subscription to different RANs
421 // +-------+ +---------+ +---------+
422 // | xapp | | submgr | | e2term |
423 // +-------+ +---------+ +---------+
428 // |------------->| |
431 // | |------------->|
434 // | |<-------------|
437 // |<-------------| |
440 // |------------->| |
443 // | |------------->|
446 // | |<-------------|
449 // |<-------------| |
451 // | [SUBS r1 DELETE] |
453 // | [SUBS r2 DELETE] |
456 //-----------------------------------------------------------------------------
457 func TestSameSubsDiffRan(t *testing.T) {
458 CaseBegin("TestSameSubsDiffRan")
461 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
462 xappConn1.SendSubsReq(t, nil, cretrans1)
463 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
464 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
465 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
468 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
469 xappConn1.SendSubsReq(t, nil, cretrans2)
470 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
471 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
472 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
475 deltrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
476 xappConn1.SendSubsDelReq(t, deltrans1, e2SubsId1)
477 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
478 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
479 xappConn1.RecvSubsDelResp(t, deltrans1)
480 //Wait that subs is cleaned
481 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
484 deltrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
485 xappConn1.SendSubsDelReq(t, deltrans2, e2SubsId2)
486 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
487 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
488 xappConn1.RecvSubsDelResp(t, deltrans2)
489 //Wait that subs is cleaned
490 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
492 xappConn1.TestMsgChanEmpty(t)
493 xappConn2.TestMsgChanEmpty(t)
494 e2termConn1.TestMsgChanEmpty(t)
495 mainCtrl.wait_registry_empty(t, 10)
498 //-----------------------------------------------------------------------------
499 // TestSubReqRetryInSubmgr
502 // +-------+ +---------+ +---------+
503 // | xapp | | submgr | | e2term |
504 // +-------+ +---------+ +---------+
507 // |------------->| |
510 // | |------------->|
514 // | |------------->|
517 // | |<-------------|
520 // |<-------------| |
525 //-----------------------------------------------------------------------------
527 func TestSubReqRetryInSubmgr(t *testing.T) {
529 CaseBegin("TestSubReqRetryInSubmgr start")
531 // Xapp: Send SubsReq
532 cretrans := xappConn1.SendSubsReq(t, nil, nil)
534 // E2t: Receive 1st SubsReq
535 e2termConn1.RecvSubsReq(t)
537 // E2t: Receive 2nd SubsReq and send SubsResp
538 crereq, cremsg := e2termConn1.RecvSubsReq(t)
539 e2termConn1.SendSubsResp(t, crereq, cremsg)
541 // Xapp: Receive SubsResp
542 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
544 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
545 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
546 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
547 xappConn1.RecvSubsDelResp(t, deltrans)
549 // Wait that subs is cleaned
550 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
552 xappConn1.TestMsgChanEmpty(t)
553 xappConn2.TestMsgChanEmpty(t)
554 e2termConn1.TestMsgChanEmpty(t)
555 mainCtrl.wait_registry_empty(t, 10)
558 //-----------------------------------------------------------------------------
559 // TestSubReqTwoRetriesNoRespSubDelRespInSubmgr
562 // +-------+ +---------+ +---------+
563 // | xapp | | submgr | | e2term |
564 // +-------+ +---------+ +---------+
567 // |------------->| |
570 // | |------------->|
574 // | |------------->|
577 // | |------------->|
581 // | |------------->|
585 // | |<-------------|
588 //-----------------------------------------------------------------------------
590 func TestSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
592 CaseBegin("TestSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
594 // Xapp: Send SubsReq
595 xappConn1.SendSubsReq(t, nil, nil)
597 // E2t: Receive 1st SubsReq
598 e2termConn1.RecvSubsReq(t)
600 // E2t: Receive 2nd SubsReq
601 e2termConn1.RecvSubsReq(t)
603 // E2t: Send receive SubsDelReq and send SubsResp
604 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
605 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
607 // Wait that subs is cleaned
608 mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 10)
610 xappConn1.TestMsgChanEmpty(t)
611 xappConn2.TestMsgChanEmpty(t)
612 e2termConn1.TestMsgChanEmpty(t)
613 mainCtrl.wait_registry_empty(t, 10)
616 //-----------------------------------------------------------------------------
617 // TestSubReqTwoRetriesNoRespAtAllInSubmgr
620 // +-------+ +---------+ +---------+
621 // | xapp | | submgr | | e2term |
622 // +-------+ +---------+ +---------+
625 // |------------->| |
628 // | |------------->|
632 // | |------------->|
635 // | |------------->|
639 // | |------------->|
643 //-----------------------------------------------------------------------------
645 func TestSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
647 CaseBegin("TestSubReqTwoRetriesNoRespAtAllInSubmgr start")
649 // Xapp: Send SubsReq
650 xappConn1.SendSubsReq(t, nil, nil)
652 // E2t: Receive 1st SubsReq
653 e2termConn1.RecvSubsReq(t)
655 // E2t: Receive 2nd SubsReq
656 e2termConn1.RecvSubsReq(t)
658 // E2t: Receive 1st SubsDelReq
659 e2termConn1.RecvSubsDelReq(t)
661 // E2t: Receive 2nd SubsDelReq
662 delreq, _ := e2termConn1.RecvSubsDelReq(t)
664 // Wait that subs is cleaned
665 mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 15)
667 xappConn1.TestMsgChanEmpty(t)
668 xappConn2.TestMsgChanEmpty(t)
669 e2termConn1.TestMsgChanEmpty(t)
670 mainCtrl.wait_registry_empty(t, 10)
673 //-----------------------------------------------------------------------------
674 // TestSubReqSubFailRespInSubmgr
677 // +-------+ +---------+ +---------+
678 // | xapp | | submgr | | e2term |
679 // +-------+ +---------+ +---------+
682 // |------------->| |
685 // | |------------->|
688 // | |<-------------|
691 // | |------------->|
694 // | |<-------------|
697 // |<-------------| |
700 //-----------------------------------------------------------------------------
702 func TestSubReqSubFailRespInSubmgr(t *testing.T) {
704 CaseBegin("TestSubReqSubFailRespInSubmgr start")
706 // Xapp: Send SubsReq
707 cretrans := xappConn1.SendSubsReq(t, nil, nil)
709 // E2t: Receive SubsReq and send SubsFail (first)
710 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
711 fparams1 := &teststube2ap.E2StubSubsFailParams{}
712 fparams1.Set(crereq1)
713 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
715 // E2t: Receive SubsDelReq and send SubsDelResp (internal first)
716 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
717 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
719 // Xapp: Receive SubsFail
720 e2SubsId := xappConn1.RecvSubsFail(t, cretrans)
722 // Wait that subs is cleaned
723 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
725 xappConn1.TestMsgChanEmpty(t)
726 xappConn2.TestMsgChanEmpty(t)
727 e2termConn1.TestMsgChanEmpty(t)
728 mainCtrl.wait_registry_empty(t, 10)
731 //-----------------------------------------------------------------------------
732 // TestSubReqSubFailRespInSubmgrWithDuplicate
735 // +-------+ +---------+ +---------+
736 // | xapp | | submgr | | e2term |
737 // +-------+ +---------+ +---------+
740 // |------------->| |
743 // | |------------->|
746 // | |<-------------|
749 // | |------------->|
752 // | |<-------------|
755 // | |------------->|
758 // | |<-------------|
761 // |<-------------| |
766 //-----------------------------------------------------------------------------
768 func TestSubReqSubFailRespInSubmgrWithDuplicate(t *testing.T) {
770 CaseBegin("TestSubReqSubFailRespInSubmgrWithDuplicate start")
772 // Xapp: Send SubsReq
773 cretrans := xappConn1.SendSubsReq(t, nil, nil)
775 // E2t: Receive SubsReq and send SubsFail (first)
776 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
777 fparams1 := &teststube2ap.E2StubSubsFailParams{}
778 fparams1.Set(crereq1)
779 fparams1.SetCauseVal(-1, 5, 3)
780 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
782 // E2t: Receive SubsDelReq and send SubsDelResp (internal)
783 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
784 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
786 // E2t: Receive SubsReq and send SubsResp (second)
787 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
788 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
790 // XAPP: Receive SubsResp
791 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
794 deltrans2 := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
795 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
796 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
797 xappConn1.RecvSubsDelResp(t, deltrans2)
799 // Wait that subs is cleaned
800 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
802 xappConn1.TestMsgChanEmpty(t)
803 xappConn2.TestMsgChanEmpty(t)
804 e2termConn1.TestMsgChanEmpty(t)
805 mainCtrl.wait_registry_empty(t, 10)
808 //-----------------------------------------------------------------------------
809 // TestSubReqSubFailRespInSubmgrWithDuplicateFail
812 // +-------+ +---------+ +---------+
813 // | xapp | | submgr | | e2term |
814 // +-------+ +---------+ +---------+
817 // |------------->| |
820 // | |------------->|
823 // | |<-------------|
826 // | |------------->|
829 // | |<-------------|
832 // | |------------->|
835 // | |<-------------|
838 // | |------------->|
841 // | |<-------------|
843 // |<-------------| |
846 //-----------------------------------------------------------------------------
848 func TestSubReqSubFailRespInSubmgrWithDuplicateFail(t *testing.T) {
850 CaseBegin("TestSubReqSubFailRespInSubmgrWithDuplicateFail start")
852 // Xapp: Send SubsReq
853 cretrans := xappConn1.SendSubsReq(t, nil, nil)
855 // E2t: Receive SubsReq and send SubsFail (first)
856 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
857 fparams1 := &teststube2ap.E2StubSubsFailParams{}
858 fparams1.Set(crereq1)
859 fparams1.SetCauseVal(-1, 5, 3)
860 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
862 // E2t: Receive SubsDelReq and send SubsDelResp (internal first)
863 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
864 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
866 // E2t: Receive SubsReq and send SubsFail (second)
867 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
868 fparams2 := &teststube2ap.E2StubSubsFailParams{}
869 fparams2.Set(crereq2)
870 fparams2.SetCauseVal(-1, 5, 3)
871 e2termConn1.SendSubsFail(t, fparams2, cremsg2)
873 // E2t: Receive SubsDelReq and send SubsDelResp (internal second)
874 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
875 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
877 // Xapp: Receive SubsFail
878 e2SubsId := xappConn1.RecvSubsFail(t, cretrans)
880 // Wait that subs is cleaned
881 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
883 xappConn1.TestMsgChanEmpty(t)
884 xappConn2.TestMsgChanEmpty(t)
885 e2termConn1.TestMsgChanEmpty(t)
886 mainCtrl.wait_registry_empty(t, 10)
889 //-----------------------------------------------------------------------------
890 // TestSubDelReqRetryInSubmgr
893 // +-------+ +---------+ +---------+
894 // | xapp | | submgr | | e2term |
895 // +-------+ +---------+ +---------+
901 // |------------->| |
904 // | |------------->|
907 // | |------------->|
910 // | |<-------------|
913 // |<-------------| |
915 //-----------------------------------------------------------------------------
917 func TestSubDelReqRetryInSubmgr(t *testing.T) {
919 CaseBegin("TestSubDelReqRetryInSubmgr start")
922 cretrans := xappConn1.SendSubsReq(t, nil, nil)
923 crereq, cremsg := e2termConn1.RecvSubsReq(t)
924 e2termConn1.SendSubsResp(t, crereq, cremsg)
925 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
928 // Xapp: Send SubsDelReq
929 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
931 // E2t: Receive 1st SubsDelReq
932 e2termConn1.RecvSubsDelReq(t)
934 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
935 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
936 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
938 // Xapp: Receive SubsDelResp
939 xappConn1.RecvSubsDelResp(t, deltrans)
941 // Wait that subs is cleaned
942 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
944 xappConn1.TestMsgChanEmpty(t)
945 xappConn2.TestMsgChanEmpty(t)
946 e2termConn1.TestMsgChanEmpty(t)
947 mainCtrl.wait_registry_empty(t, 10)
950 //-----------------------------------------------------------------------------
951 // TestSubDelReqTwoRetriesNoRespInSubmgr
954 // +-------+ +---------+ +---------+
955 // | xapp | | submgr | | e2term |
956 // +-------+ +---------+ +---------+
962 // |------------->| |
965 // | |------------->|
968 // | |------------->|
972 // |<-------------| |
974 //-----------------------------------------------------------------------------
976 func TestSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
978 CaseBegin("TestSubDelReTwoRetriesNoRespInSubmgr start")
981 cretrans := xappConn1.SendSubsReq(t, nil, nil)
982 crereq, cremsg := e2termConn1.RecvSubsReq(t)
983 e2termConn1.SendSubsResp(t, crereq, cremsg)
984 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
987 // Xapp: Send SubsDelReq
988 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
990 // E2t: Receive 1st SubsDelReq
991 e2termConn1.RecvSubsDelReq(t)
993 // E2t: Receive 2nd SubsDelReq
994 e2termConn1.RecvSubsDelReq(t)
996 // Xapp: Receive SubsDelResp
997 xappConn1.RecvSubsDelResp(t, deltrans)
999 // Wait that subs is cleaned
1000 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1002 xappConn1.TestMsgChanEmpty(t)
1003 xappConn2.TestMsgChanEmpty(t)
1004 e2termConn1.TestMsgChanEmpty(t)
1005 mainCtrl.wait_registry_empty(t, 10)
1008 //-----------------------------------------------------------------------------
1009 // TestSubDelReqSubDelFailRespInSubmgr
1012 // +-------+ +---------+ +---------+
1013 // | xapp | | submgr | | e2term |
1014 // +-------+ +---------+ +---------+
1016 // | [SUBS CREATE] |
1020 // |------------->| |
1023 // | |------------->|
1026 // | |<-------------|
1029 // |<-------------| |
1032 //-----------------------------------------------------------------------------
1034 func TestSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
1036 CaseBegin("TestSubReqSubDelFailRespInSubmgr start")
1039 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1040 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1041 e2termConn1.SendSubsResp(t, crereq, cremsg)
1042 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1044 // Xapp: Send SubsDelReq
1045 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1047 // E2t: Send receive SubsDelReq and send SubsDelFail
1048 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1049 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
1051 // Xapp: Receive SubsDelResp
1052 xappConn1.RecvSubsDelResp(t, deltrans)
1054 // Wait that subs is cleaned
1055 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1057 xappConn1.TestMsgChanEmpty(t)
1058 xappConn2.TestMsgChanEmpty(t)
1059 e2termConn1.TestMsgChanEmpty(t)
1060 mainCtrl.wait_registry_empty(t, 10)
1063 //-----------------------------------------------------------------------------
1064 // TestSubReqAndSubDelOkSameAction
1067 // +-------+ +-------+ +---------+ +---------+
1068 // | xapp2 | | xapp1 | | submgr | | e2term |
1069 // +-------+ +-------+ +---------+ +---------+
1074 // | |------------->| |
1077 // | | |------------->|
1079 // | | |<-------------|
1081 // | |<-------------| |
1084 // |--------------------------->| |
1087 // |<---------------------------| |
1089 // | | SubDelReq 1 | |
1090 // | |------------->| |
1092 // | | SubDelResp 1 | |
1093 // | |<-------------| |
1095 // | SubDelReq 2 | |
1096 // |--------------------------->| |
1098 // | | | SubDelReq 2 |
1099 // | | |------------->|
1101 // | | | SubDelReq 2 |
1102 // | | |------------->|
1104 // | SubDelResp 2 | |
1105 // |<---------------------------| |
1107 //-----------------------------------------------------------------------------
1108 func TestSubReqAndSubDelOkSameAction(t *testing.T) {
1109 CaseBegin("TestSubReqAndSubDelOkSameAction")
1112 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1114 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1115 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1116 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1117 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1120 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1122 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1123 //crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
1124 //e2termConn1.SendSubsResp(t, crereq2, cremsg2)
1125 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1127 resp, _ := xapp.Subscription.QuerySubscriptions()
1128 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
1129 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
1130 assert.Equal(t, resp[0].Endpoint, []string{"localhost:13560", "localhost:13660"})
1133 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1134 //e2termConn1.RecvSubsDelReq(t)
1135 //e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1136 xappConn1.RecvSubsDelResp(t, deltrans1)
1137 //Wait that subs is cleaned
1138 //mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1141 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1142 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1143 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1144 xappConn2.RecvSubsDelResp(t, deltrans2)
1145 //Wait that subs is cleaned
1146 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1148 xappConn1.TestMsgChanEmpty(t)
1149 xappConn2.TestMsgChanEmpty(t)
1150 e2termConn1.TestMsgChanEmpty(t)
1151 mainCtrl.wait_registry_empty(t, 10)
1154 //-----------------------------------------------------------------------------
1155 // TestSubReqAndSubDelOkSameActionParallel
1158 // +-------+ +-------+ +---------+ +---------+
1159 // | xapp2 | | xapp1 | | submgr | | e2term |
1160 // +-------+ +-------+ +---------+ +---------+
1165 // | |------------->| |
1168 // | | |------------->|
1170 // |--------------------------->| |
1172 // | | |<-------------|
1174 // | |<-------------| |
1177 // |<---------------------------| |
1179 // | | SubDelReq 1 | |
1180 // | |------------->| |
1182 // | | SubDelResp 1 | |
1183 // | |<-------------| |
1185 // | SubDelReq 2 | |
1186 // |--------------------------->| |
1188 // | | | SubDelReq 2 |
1189 // | | |------------->|
1191 // | | | SubDelReq 2 |
1192 // | | |------------->|
1194 // | SubDelResp 2 | |
1195 // |<---------------------------| |
1197 //-----------------------------------------------------------------------------
1198 func TestSubReqAndSubDelOkSameActionParallel(t *testing.T) {
1199 CaseBegin("TestSubReqAndSubDelOkSameActionParallel")
1202 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1204 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1205 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1208 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1210 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1213 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1214 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1217 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1220 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1221 xappConn1.RecvSubsDelResp(t, deltrans1)
1224 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1225 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1226 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1227 xappConn2.RecvSubsDelResp(t, deltrans2)
1229 //Wait that subs is cleaned
1230 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1232 xappConn1.TestMsgChanEmpty(t)
1233 xappConn2.TestMsgChanEmpty(t)
1234 e2termConn1.TestMsgChanEmpty(t)
1235 mainCtrl.wait_registry_empty(t, 10)
1238 //-----------------------------------------------------------------------------
1239 // TestSubReqAndSubDelNokSameActionParallel
1242 // +-------+ +-------+ +---------+ +---------+
1243 // | xapp2 | | xapp1 | | submgr | | e2term |
1244 // +-------+ +-------+ +---------+ +---------+
1249 // | |------------->| |
1252 // | | |------------->|
1254 // |--------------------------->| |
1256 // | | |<-------------|
1258 // | | | SubDelReq |
1259 // | | |------------->|
1260 // | | | SubDelResp |
1261 // | | |<-------------|
1264 // | |<-------------| |
1267 // |<---------------------------| |
1269 //-----------------------------------------------------------------------------
1270 func TestSubReqAndSubDelNokSameActionParallel(t *testing.T) {
1271 CaseBegin("TestSubReqAndSubDelNokSameActionParallel")
1274 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1276 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1278 // E2t: Receive SubsReq (first)
1279 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1282 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1284 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
1285 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1286 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
1288 // E2t: send SubsFail (first)
1289 fparams1 := &teststube2ap.E2StubSubsFailParams{}
1290 fparams1.Set(crereq1)
1291 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
1293 // E2t: internal delete
1294 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1295 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1298 e2SubsId1 := xappConn1.RecvSubsFail(t, cretrans1)
1300 xappConn2.RecvSubsFail(t, cretrans2)
1302 //Wait that subs is cleaned
1303 mainCtrl.wait_subs_clean(t, e2SubsId1, 15)
1305 xappConn1.TestMsgChanEmpty(t)
1306 xappConn2.TestMsgChanEmpty(t)
1307 e2termConn1.TestMsgChanEmpty(t)
1308 mainCtrl.wait_registry_empty(t, 10)
1311 //-----------------------------------------------------------------------------
1312 // TestSubReqAndSubDelNoAnswerSameActionParallel
1315 // +-------+ +-------+ +---------+ +---------+
1316 // | xapp2 | | xapp1 | | submgr | | e2term |
1317 // +-------+ +-------+ +---------+ +---------+
1322 // | |------------->| |
1325 // | | |------------->|
1327 // |--------------------------->| |
1330 // | | |------------->|
1333 // | | | SubDelReq |
1334 // | | |------------->|
1336 // | | | SubDelResp |
1337 // | | |<-------------|
1339 //-----------------------------------------------------------------------------
1340 func TestSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
1341 CaseBegin("TestSubReqAndSubDelNoAnswerSameActionParallel")
1344 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1346 xappConn1.SendSubsReq(t, rparams1, nil)
1348 crereq1, _ := e2termConn1.RecvSubsReq(t)
1351 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1353 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
1354 xappConn2.SendSubsReq(t, rparams2, nil)
1355 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
1357 //Req1 (retransmitted)
1358 e2termConn1.RecvSubsReq(t)
1360 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1361 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1363 //Wait that subs is cleaned
1364 mainCtrl.wait_subs_clean(t, delreq1.RequestId.InstanceId, 10)
1366 xappConn1.TestMsgChanEmpty(t)
1367 xappConn2.TestMsgChanEmpty(t)
1368 e2termConn1.TestMsgChanEmpty(t)
1369 mainCtrl.wait_registry_empty(t, 15)
1372 //----------------------------- Policy cases ---------------------------------
1373 //-----------------------------------------------------------------------------
1374 // TestSubReqPolicyAndSubDelOk
1377 // +-------+ +---------+ +---------+
1378 // | xapp | | submgr | | e2term |
1379 // +-------+ +---------+ +---------+
1382 // |------------->| |
1385 // | |------------->|
1388 // | |<-------------|
1391 // |<-------------| |
1395 // |------------->| |
1398 // | |------------->|
1401 // | |<-------------|
1404 // |<-------------| |
1406 //-----------------------------------------------------------------------------
1407 func TestSubReqPolicyAndSubDelOk(t *testing.T) {
1408 CaseBegin("TestSubReqAndSubDelOk")
1410 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1412 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
1413 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1415 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1416 e2termConn1.SendSubsResp(t, crereq, cremsg)
1417 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1418 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1419 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1421 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1422 xappConn1.RecvSubsDelResp(t, deltrans)
1424 //Wait that subs is cleaned
1425 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1427 xappConn1.TestMsgChanEmpty(t)
1428 xappConn2.TestMsgChanEmpty(t)
1429 e2termConn1.TestMsgChanEmpty(t)
1430 mainCtrl.wait_registry_empty(t, 10)
1433 //-----------------------------------------------------------------------------
1434 // TestSubReqPolicyChangeAndSubDelOk
1437 // +-------+ +---------+ +---------+
1438 // | xapp | | submgr | | e2term |
1439 // +-------+ +---------+ +---------+
1442 // |------------->| |
1445 // | |------------->|
1448 // | |<-------------|
1451 // |<-------------| |
1454 // |------------->| |
1457 // | |------------->|
1460 // | |<-------------|
1463 // |<-------------| |
1466 // |------------->| |
1469 // | |------------->|
1472 // | |<-------------|
1475 // |<-------------| |
1477 //-----------------------------------------------------------------------------
1479 func TestSubReqPolicyChangeAndSubDelOk(t *testing.T) {
1480 CaseBegin("TestSubReqAndSubDelOk")
1482 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1484 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
1485 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1487 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1488 e2termConn1.SendSubsResp(t, crereq, cremsg)
1489 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1492 rparams1.Req.RequestId.InstanceId = e2SubsId
1493 rparams1.Req.ActionSetups[0].SubsequentAction.TimetoWait = e2ap.E2AP_TimeToWaitW200ms
1494 xappConn1.SendSubsReq(t, rparams1, cretrans)
1496 crereq, cremsg = e2termConn1.RecvSubsReq(t)
1497 e2termConn1.SendSubsResp(t, crereq, cremsg)
1498 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
1499 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1500 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1502 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1503 xappConn1.RecvSubsDelResp(t, deltrans)
1505 //Wait that subs is cleaned
1506 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1508 xappConn1.TestMsgChanEmpty(t)
1509 xappConn2.TestMsgChanEmpty(t)
1510 e2termConn1.TestMsgChanEmpty(t)
1511 mainCtrl.wait_registry_empty(t, 10)
1514 //-----------------------------------------------------------------------------
1515 // TestSubReqAndSubDelOkTwoE2termParallel
1518 // +-------+ +---------+ +---------+ +---------+
1519 // | xapp | | submgr | | e2term1 | | e2term2 |
1520 // +-------+ +---------+ +---------+ +---------+
1525 // |------------->| | |
1528 // | |------------->| |
1531 // |------------->| | |
1534 // | |---------------------------->|
1537 // | |<-------------| |
1539 // |<-------------| | |
1541 // | |<----------------------------|
1543 // |<-------------| | |
1545 // | [SUBS 1 DELETE] | |
1547 // | [SUBS 2 DELETE] | |
1550 //-----------------------------------------------------------------------------
1551 func TestSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
1552 CaseBegin("TestSubReqAndSubDelOkTwoE2termParallel")
1555 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1556 xappConn1.SendSubsReq(t, nil, cretrans1)
1557 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1559 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_11")
1560 xappConn1.SendSubsReq(t, nil, cretrans2)
1561 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
1564 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1565 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1568 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
1569 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
1572 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1573 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1574 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1575 xappConn1.RecvSubsDelResp(t, deltrans1)
1576 //Wait that subs is cleaned
1577 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1580 deltrans2 := xappConn1.SendSubsDelReq(t, nil, e2SubsId2)
1581 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
1582 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
1583 xappConn1.RecvSubsDelResp(t, deltrans2)
1584 //Wait that subs is cleaned
1585 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1587 xappConn1.TestMsgChanEmpty(t)
1588 xappConn2.TestMsgChanEmpty(t)
1589 e2termConn1.TestMsgChanEmpty(t)
1590 e2termConn2.TestMsgChanEmpty(t)
1591 mainCtrl.wait_registry_empty(t, 10)