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 // | |<-------------|
682 // |<-------------| |
685 //-----------------------------------------------------------------------------
687 func TestSubReqSubFailRespInSubmgr(t *testing.T) {
689 CaseBegin("TestSubReqSubFailRespInSubmgr start")
691 // Xapp: Send SubsReq
692 cretrans := xappConn1.SendSubsReq(t, nil, nil)
694 // E2t: Receive SubsReq and send SubsFail (first)
695 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
696 fparams1 := &teststube2ap.E2StubSubsFailParams{}
697 fparams1.Set(crereq1)
698 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
700 // E2t: Receive SubsDelReq and send SubsDelResp (internal first)
701 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
702 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
704 // Xapp: Receive SubsFail
705 e2SubsId := xappConn1.RecvSubsFail(t, cretrans)
707 // Wait that subs is cleaned
708 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
710 xappConn1.TestMsgChanEmpty(t)
711 xappConn2.TestMsgChanEmpty(t)
712 e2termConn1.TestMsgChanEmpty(t)
713 mainCtrl.wait_registry_empty(t, 10)
716 //-----------------------------------------------------------------------------
717 // TestSubReqSubFailRespInSubmgrWithDuplicate
720 // +-------+ +---------+ +---------+
721 // | xapp | | submgr | | e2term |
722 // +-------+ +---------+ +---------+
725 // |------------->| |
728 // | |------------->|
731 // | |<-------------|
734 // | |------------->|
737 // | |<-------------|
740 // | |------------->|
743 // | |<-------------|
746 // |<-------------| |
751 //-----------------------------------------------------------------------------
753 func TestSubReqSubFailRespInSubmgrWithDuplicate(t *testing.T) {
755 CaseBegin("TestSubReqSubFailRespInSubmgrWithDuplicate start")
757 // Xapp: Send SubsReq
758 cretrans := xappConn1.SendSubsReq(t, nil, nil)
760 // E2t: Receive SubsReq and send SubsFail (first)
761 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
762 fparams1 := &teststube2ap.E2StubSubsFailParams{}
763 fparams1.Set(crereq1)
764 fparams1.SetCauseVal(-1, 5, 3)
765 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
767 // E2t: Receive SubsDelReq and send SubsDelResp (internal)
768 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
769 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
771 // E2t: Receive SubsReq and send SubsResp (second)
772 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
773 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
775 // XAPP: Receive SubsResp
776 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
779 deltrans2 := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
780 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
781 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
782 xappConn1.RecvSubsDelResp(t, deltrans2)
784 // Wait that subs is cleaned
785 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
787 xappConn1.TestMsgChanEmpty(t)
788 xappConn2.TestMsgChanEmpty(t)
789 e2termConn1.TestMsgChanEmpty(t)
790 mainCtrl.wait_registry_empty(t, 10)
793 //-----------------------------------------------------------------------------
794 // TestSubReqSubFailRespInSubmgrWithDuplicateFail
797 // +-------+ +---------+ +---------+
798 // | xapp | | submgr | | e2term |
799 // +-------+ +---------+ +---------+
802 // |------------->| |
805 // | |------------->|
808 // | |<-------------|
811 // | |------------->|
814 // | |<-------------|
817 // | |------------->|
820 // | |<-------------|
823 // | |------------->|
826 // | |<-------------|
828 // |<-------------| |
831 //-----------------------------------------------------------------------------
833 func TestSubReqSubFailRespInSubmgrWithDuplicateFail(t *testing.T) {
835 CaseBegin("TestSubReqSubFailRespInSubmgrWithDuplicateFail start")
837 // Xapp: Send SubsReq
838 cretrans := xappConn1.SendSubsReq(t, nil, nil)
840 // E2t: Receive SubsReq and send SubsFail (first)
841 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
842 fparams1 := &teststube2ap.E2StubSubsFailParams{}
843 fparams1.Set(crereq1)
844 fparams1.SetCauseVal(-1, 5, 3)
845 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
847 // E2t: Receive SubsDelReq and send SubsDelResp (internal first)
848 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
849 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
851 // E2t: Receive SubsReq and send SubsFail (second)
852 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
853 fparams2 := &teststube2ap.E2StubSubsFailParams{}
854 fparams2.Set(crereq2)
855 fparams2.SetCauseVal(-1, 5, 3)
856 e2termConn1.SendSubsFail(t, fparams2, cremsg2)
858 // E2t: Receive SubsDelReq and send SubsDelResp (internal second)
859 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
860 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
862 // Xapp: Receive SubsFail
863 e2SubsId := xappConn1.RecvSubsFail(t, cretrans)
865 // Wait that subs is cleaned
866 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
868 xappConn1.TestMsgChanEmpty(t)
869 xappConn2.TestMsgChanEmpty(t)
870 e2termConn1.TestMsgChanEmpty(t)
871 mainCtrl.wait_registry_empty(t, 10)
874 //-----------------------------------------------------------------------------
875 // TestSubDelReqRetryInSubmgr
878 // +-------+ +---------+ +---------+
879 // | xapp | | submgr | | e2term |
880 // +-------+ +---------+ +---------+
886 // |------------->| |
889 // | |------------->|
892 // | |------------->|
895 // | |<-------------|
898 // |<-------------| |
900 //-----------------------------------------------------------------------------
902 func TestSubDelReqRetryInSubmgr(t *testing.T) {
904 CaseBegin("TestSubDelReqRetryInSubmgr start")
907 cretrans := xappConn1.SendSubsReq(t, nil, nil)
908 crereq, cremsg := e2termConn1.RecvSubsReq(t)
909 e2termConn1.SendSubsResp(t, crereq, cremsg)
910 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
913 // Xapp: Send SubsDelReq
914 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
916 // E2t: Receive 1st SubsDelReq
917 e2termConn1.RecvSubsDelReq(t)
919 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
920 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
921 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
923 // Xapp: Receive SubsDelResp
924 xappConn1.RecvSubsDelResp(t, deltrans)
926 // Wait that subs is cleaned
927 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
929 xappConn1.TestMsgChanEmpty(t)
930 xappConn2.TestMsgChanEmpty(t)
931 e2termConn1.TestMsgChanEmpty(t)
932 mainCtrl.wait_registry_empty(t, 10)
935 //-----------------------------------------------------------------------------
936 // TestSubDelReqTwoRetriesNoRespInSubmgr
939 // +-------+ +---------+ +---------+
940 // | xapp | | submgr | | e2term |
941 // +-------+ +---------+ +---------+
947 // |------------->| |
950 // | |------------->|
953 // | |------------->|
957 // |<-------------| |
959 //-----------------------------------------------------------------------------
961 func TestSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
963 CaseBegin("TestSubDelReTwoRetriesNoRespInSubmgr start")
966 cretrans := xappConn1.SendSubsReq(t, nil, nil)
967 crereq, cremsg := e2termConn1.RecvSubsReq(t)
968 e2termConn1.SendSubsResp(t, crereq, cremsg)
969 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
972 // Xapp: Send SubsDelReq
973 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
975 // E2t: Receive 1st SubsDelReq
976 e2termConn1.RecvSubsDelReq(t)
978 // E2t: Receive 2nd SubsDelReq
979 e2termConn1.RecvSubsDelReq(t)
981 // Xapp: Receive SubsDelResp
982 xappConn1.RecvSubsDelResp(t, deltrans)
984 // Wait that subs is cleaned
985 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
987 xappConn1.TestMsgChanEmpty(t)
988 xappConn2.TestMsgChanEmpty(t)
989 e2termConn1.TestMsgChanEmpty(t)
990 mainCtrl.wait_registry_empty(t, 10)
993 //-----------------------------------------------------------------------------
994 // TestSubDelReqSubDelFailRespInSubmgr
997 // +-------+ +---------+ +---------+
998 // | xapp | | submgr | | e2term |
999 // +-------+ +---------+ +---------+
1001 // | [SUBS CREATE] |
1005 // |------------->| |
1008 // | |------------->|
1011 // | |<-------------|
1014 // |<-------------| |
1017 //-----------------------------------------------------------------------------
1019 func TestSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
1021 CaseBegin("TestSubReqSubDelFailRespInSubmgr start")
1024 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1025 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1026 e2termConn1.SendSubsResp(t, crereq, cremsg)
1027 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1029 // Xapp: Send SubsDelReq
1030 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1032 // E2t: Send receive SubsDelReq and send SubsDelFail
1033 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1034 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
1036 // Xapp: Receive SubsDelResp
1037 xappConn1.RecvSubsDelResp(t, deltrans)
1039 // Wait that subs is cleaned
1040 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1042 xappConn1.TestMsgChanEmpty(t)
1043 xappConn2.TestMsgChanEmpty(t)
1044 e2termConn1.TestMsgChanEmpty(t)
1045 mainCtrl.wait_registry_empty(t, 10)
1048 //-----------------------------------------------------------------------------
1049 // TestSubReqAndSubDelOkSameAction
1052 // +-------+ +-------+ +---------+ +---------+
1053 // | xapp2 | | xapp1 | | submgr | | e2term |
1054 // +-------+ +-------+ +---------+ +---------+
1059 // | |------------->| |
1062 // | | |------------->|
1064 // | | |<-------------|
1066 // | |<-------------| |
1069 // |--------------------------->| |
1072 // |<---------------------------| |
1074 // | | SubDelReq 1 | |
1075 // | |------------->| |
1077 // | | SubDelResp 1 | |
1078 // | |<-------------| |
1080 // | SubDelReq 2 | |
1081 // |--------------------------->| |
1083 // | | | SubDelReq 2 |
1084 // | | |------------->|
1086 // | | | SubDelReq 2 |
1087 // | | |------------->|
1089 // | SubDelResp 2 | |
1090 // |<---------------------------| |
1092 //-----------------------------------------------------------------------------
1093 func TestSubReqAndSubDelOkSameAction(t *testing.T) {
1094 CaseBegin("TestSubReqAndSubDelOkSameAction")
1097 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1099 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1100 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1101 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1102 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1105 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1107 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1108 //crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
1109 //e2termConn1.SendSubsResp(t, crereq2, cremsg2)
1110 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1112 resp, _ := xapp.Subscription.QuerySubscriptions()
1113 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
1114 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
1115 assert.Equal(t, resp[0].Endpoint, []string{"localhost:13560", "localhost:13660"})
1118 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1119 //e2termConn1.RecvSubsDelReq(t)
1120 //e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1121 xappConn1.RecvSubsDelResp(t, deltrans1)
1122 //Wait that subs is cleaned
1123 //mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1126 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1127 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1128 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1129 xappConn2.RecvSubsDelResp(t, deltrans2)
1130 //Wait that subs is cleaned
1131 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1133 xappConn1.TestMsgChanEmpty(t)
1134 xappConn2.TestMsgChanEmpty(t)
1135 e2termConn1.TestMsgChanEmpty(t)
1136 mainCtrl.wait_registry_empty(t, 10)
1139 //-----------------------------------------------------------------------------
1140 // TestSubReqAndSubDelOkSameActionParallel
1143 // +-------+ +-------+ +---------+ +---------+
1144 // | xapp2 | | xapp1 | | submgr | | e2term |
1145 // +-------+ +-------+ +---------+ +---------+
1150 // | |------------->| |
1153 // | | |------------->|
1155 // |--------------------------->| |
1157 // | | |<-------------|
1159 // | |<-------------| |
1162 // |<---------------------------| |
1164 // | | SubDelReq 1 | |
1165 // | |------------->| |
1167 // | | SubDelResp 1 | |
1168 // | |<-------------| |
1170 // | SubDelReq 2 | |
1171 // |--------------------------->| |
1173 // | | | SubDelReq 2 |
1174 // | | |------------->|
1176 // | | | SubDelReq 2 |
1177 // | | |------------->|
1179 // | SubDelResp 2 | |
1180 // |<---------------------------| |
1182 //-----------------------------------------------------------------------------
1183 func TestSubReqAndSubDelOkSameActionParallel(t *testing.T) {
1184 CaseBegin("TestSubReqAndSubDelOkSameActionParallel")
1187 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1189 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1190 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1193 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1195 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1198 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1199 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1202 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1205 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1206 xappConn1.RecvSubsDelResp(t, deltrans1)
1209 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1210 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1211 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1212 xappConn2.RecvSubsDelResp(t, deltrans2)
1214 //Wait that subs is cleaned
1215 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1217 xappConn1.TestMsgChanEmpty(t)
1218 xappConn2.TestMsgChanEmpty(t)
1219 e2termConn1.TestMsgChanEmpty(t)
1220 mainCtrl.wait_registry_empty(t, 10)
1223 //-----------------------------------------------------------------------------
1224 // TestSubReqAndSubDelNokSameActionParallel
1227 // +-------+ +-------+ +---------+ +---------+
1228 // | xapp2 | | xapp1 | | submgr | | e2term |
1229 // +-------+ +-------+ +---------+ +---------+
1234 // | |------------->| |
1237 // | | |------------->|
1239 // |--------------------------->| |
1241 // | | |<-------------|
1243 // | | | SubDelReq |
1244 // | | |------------->|
1245 // | | | SubDelResp |
1246 // | | |<-------------|
1249 // | |<-------------| |
1252 // |<---------------------------| |
1254 //-----------------------------------------------------------------------------
1255 func TestSubReqAndSubDelNokSameActionParallel(t *testing.T) {
1256 CaseBegin("TestSubReqAndSubDelNokSameActionParallel")
1259 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1261 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1263 // E2t: Receive SubsReq (first)
1264 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1267 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1269 seqBef2 := mainCtrl.get_msgcounter(t)
1270 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1271 mainCtrl.wait_msgcounter_change(t, seqBef2, 10)
1273 // E2t: send SubsFail (first)
1274 fparams1 := &teststube2ap.E2StubSubsFailParams{}
1275 fparams1.Set(crereq1)
1276 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
1278 // E2t: internal delete
1279 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1280 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1283 e2SubsId1 := xappConn1.RecvSubsFail(t, cretrans1)
1285 xappConn2.RecvSubsFail(t, cretrans2)
1287 //Wait that subs is cleaned
1288 mainCtrl.wait_subs_clean(t, e2SubsId1, 15)
1290 xappConn1.TestMsgChanEmpty(t)
1291 xappConn2.TestMsgChanEmpty(t)
1292 e2termConn1.TestMsgChanEmpty(t)
1293 mainCtrl.wait_registry_empty(t, 10)
1296 //-----------------------------------------------------------------------------
1297 // TestSubReqAndSubDelNoAnswerSameActionParallel
1300 // +-------+ +-------+ +---------+ +---------+
1301 // | xapp2 | | xapp1 | | submgr | | e2term |
1302 // +-------+ +-------+ +---------+ +---------+
1307 // | |------------->| |
1310 // | | |------------->|
1312 // |--------------------------->| |
1315 // | | |------------->|
1318 // | | | SubDelReq |
1319 // | | |------------->|
1321 // | | | SubDelResp |
1322 // | | |<-------------|
1324 //-----------------------------------------------------------------------------
1325 func TestSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
1326 CaseBegin("TestSubReqAndSubDelNoAnswerSameActionParallel")
1329 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1331 xappConn1.SendSubsReq(t, rparams1, nil)
1333 e2termConn1.RecvSubsReq(t)
1336 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1338 seqBef2 := mainCtrl.get_msgcounter(t)
1339 xappConn2.SendSubsReq(t, rparams2, nil)
1340 mainCtrl.wait_msgcounter_change(t, seqBef2, 10)
1342 //Req1 (retransmitted)
1343 e2termConn1.RecvSubsReq(t)
1345 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1346 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1348 //Wait that subs is cleaned
1349 mainCtrl.wait_subs_clean(t, delreq1.RequestId.Seq, 10)
1351 xappConn1.TestMsgChanEmpty(t)
1352 xappConn2.TestMsgChanEmpty(t)
1353 e2termConn1.TestMsgChanEmpty(t)
1354 mainCtrl.wait_registry_empty(t, 15)
1357 //----------------------------- Policy cases ---------------------------------
1358 //-----------------------------------------------------------------------------
1359 // TestSubReqPolicyAndSubDelOk
1362 // +-------+ +---------+ +---------+
1363 // | xapp | | submgr | | e2term |
1364 // +-------+ +---------+ +---------+
1367 // |------------->| |
1370 // | |------------->|
1373 // | |<-------------|
1376 // |<-------------| |
1380 // |------------->| |
1383 // | |------------->|
1386 // | |<-------------|
1389 // |<-------------| |
1391 //-----------------------------------------------------------------------------
1392 func TestSubReqPolicyAndSubDelOk(t *testing.T) {
1393 CaseBegin("TestSubReqAndSubDelOk")
1395 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1397 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
1398 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1400 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1401 e2termConn1.SendSubsResp(t, crereq, cremsg)
1402 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1403 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1404 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1406 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1407 xappConn1.RecvSubsDelResp(t, deltrans)
1409 //Wait that subs is cleaned
1410 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1412 xappConn1.TestMsgChanEmpty(t)
1413 xappConn2.TestMsgChanEmpty(t)
1414 e2termConn1.TestMsgChanEmpty(t)
1415 mainCtrl.wait_registry_empty(t, 10)
1418 //-----------------------------------------------------------------------------
1419 // TestSubReqPolicyChangeAndSubDelOk
1422 // +-------+ +---------+ +---------+
1423 // | xapp | | submgr | | e2term |
1424 // +-------+ +---------+ +---------+
1427 // |------------->| |
1430 // | |------------->|
1433 // | |<-------------|
1436 // |<-------------| |
1439 // |------------->| |
1442 // | |------------->|
1445 // | |<-------------|
1448 // |<-------------| |
1451 // |------------->| |
1454 // | |------------->|
1457 // | |<-------------|
1460 // |<-------------| |
1462 //-----------------------------------------------------------------------------
1464 func TestSubReqPolicyChangeAndSubDelOk(t *testing.T) {
1465 CaseBegin("TestSubReqAndSubDelOk")
1467 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1469 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
1470 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1472 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1473 e2termConn1.SendSubsResp(t, crereq, cremsg)
1474 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1477 rparams1.Req.RequestId.Seq = e2SubsId
1478 rparams1.Req.ActionSetups[0].SubsequentAction.TimetoWait = e2ap.E2AP_TimeToWaitW200ms
1479 xappConn1.SendSubsReq(t, rparams1, cretrans)
1481 crereq, cremsg = e2termConn1.RecvSubsReq(t)
1482 e2termConn1.SendSubsResp(t, crereq, cremsg)
1483 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
1484 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1485 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1487 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1488 xappConn1.RecvSubsDelResp(t, deltrans)
1490 //Wait that subs is cleaned
1491 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1493 xappConn1.TestMsgChanEmpty(t)
1494 xappConn2.TestMsgChanEmpty(t)
1495 e2termConn1.TestMsgChanEmpty(t)
1496 mainCtrl.wait_registry_empty(t, 10)
1499 //-----------------------------------------------------------------------------
1500 // TestSubReqAndSubDelOkTwoE2termParallel
1503 // +-------+ +---------+ +---------+ +---------+
1504 // | xapp | | submgr | | e2term1 | | e2term2 |
1505 // +-------+ +---------+ +---------+ +---------+
1510 // |------------->| | |
1513 // | |------------->| |
1516 // |------------->| | |
1519 // | |---------------------------->|
1522 // | |<-------------| |
1524 // |<-------------| | |
1526 // | |<----------------------------|
1528 // |<-------------| | |
1530 // | [SUBS 1 DELETE] | |
1532 // | [SUBS 2 DELETE] | |
1535 //-----------------------------------------------------------------------------
1536 func TestSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
1537 CaseBegin("TestSubReqAndSubDelOkTwoE2termParallel")
1540 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1541 xappConn1.SendSubsReq(t, nil, cretrans1)
1542 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1544 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_11")
1545 xappConn1.SendSubsReq(t, nil, cretrans2)
1546 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
1549 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1550 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1553 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
1554 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
1557 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1558 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1559 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1560 xappConn1.RecvSubsDelResp(t, deltrans1)
1561 //Wait that subs is cleaned
1562 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1565 deltrans2 := xappConn1.SendSubsDelReq(t, nil, e2SubsId2)
1566 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
1567 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
1568 xappConn1.RecvSubsDelResp(t, deltrans2)
1569 //Wait that subs is cleaned
1570 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1572 xappConn1.TestMsgChanEmpty(t)
1573 xappConn2.TestMsgChanEmpty(t)
1574 e2termConn1.TestMsgChanEmpty(t)
1575 e2termConn2.TestMsgChanEmpty(t)
1576 mainCtrl.wait_registry_empty(t, 10)