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 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
376 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
379 rparams2 := &teststube2ap.E2StubSubsReqParams{}
382 rparams2.Req.EventTriggerDefinition.Data.Length = 1
383 rparams2.Req.EventTriggerDefinition.Data.Data = make([]uint8, rparams2.Req.EventTriggerDefinition.Data.Length)
384 rparams2.Req.EventTriggerDefinition.Data.Data[0] = 2
386 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
387 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
390 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
391 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
394 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
395 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
398 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
399 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
400 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
401 xappConn1.RecvSubsDelResp(t, deltrans1)
402 //Wait that subs is cleaned
403 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
406 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
407 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
408 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
409 xappConn2.RecvSubsDelResp(t, deltrans2)
410 //Wait that subs is cleaned
411 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
413 xappConn1.TestMsgChanEmpty(t)
414 xappConn2.TestMsgChanEmpty(t)
415 e2termConn1.TestMsgChanEmpty(t)
416 mainCtrl.wait_registry_empty(t, 10)
419 //-----------------------------------------------------------------------------
420 // TestSameSubsDiffRan
421 // Same subscription to different RANs
424 // +-------+ +---------+ +---------+
425 // | xapp | | submgr | | e2term |
426 // +-------+ +---------+ +---------+
431 // |------------->| |
434 // | |------------->|
437 // | |<-------------|
440 // |<-------------| |
443 // |------------->| |
446 // | |------------->|
449 // | |<-------------|
452 // |<-------------| |
454 // | [SUBS r1 DELETE] |
456 // | [SUBS r2 DELETE] |
459 //-----------------------------------------------------------------------------
460 func TestSameSubsDiffRan(t *testing.T) {
461 CaseBegin("TestSameSubsDiffRan")
464 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
465 xappConn1.SendSubsReq(t, nil, cretrans1)
466 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
467 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
468 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
471 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
472 xappConn1.SendSubsReq(t, nil, cretrans2)
473 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
474 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
475 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
478 deltrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
479 xappConn1.SendSubsDelReq(t, deltrans1, e2SubsId1)
480 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
481 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
482 xappConn1.RecvSubsDelResp(t, deltrans1)
483 //Wait that subs is cleaned
484 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
487 deltrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_2")
488 xappConn1.SendSubsDelReq(t, deltrans2, e2SubsId2)
489 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
490 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
491 xappConn1.RecvSubsDelResp(t, deltrans2)
492 //Wait that subs is cleaned
493 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
495 xappConn1.TestMsgChanEmpty(t)
496 xappConn2.TestMsgChanEmpty(t)
497 e2termConn1.TestMsgChanEmpty(t)
498 mainCtrl.wait_registry_empty(t, 10)
501 //-----------------------------------------------------------------------------
502 // TestSubReqRetryInSubmgr
505 // +-------+ +---------+ +---------+
506 // | xapp | | submgr | | e2term |
507 // +-------+ +---------+ +---------+
510 // |------------->| |
513 // | |------------->|
517 // | |------------->|
520 // | |<-------------|
523 // |<-------------| |
528 //-----------------------------------------------------------------------------
530 func TestSubReqRetryInSubmgr(t *testing.T) {
532 CaseBegin("TestSubReqRetryInSubmgr start")
534 // Xapp: Send SubsReq
535 cretrans := xappConn1.SendSubsReq(t, nil, nil)
537 // E2t: Receive 1st SubsReq
538 e2termConn1.RecvSubsReq(t)
540 // E2t: Receive 2nd SubsReq and send SubsResp
541 crereq, cremsg := e2termConn1.RecvSubsReq(t)
542 e2termConn1.SendSubsResp(t, crereq, cremsg)
544 // Xapp: Receive SubsResp
545 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
547 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
548 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
549 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
550 xappConn1.RecvSubsDelResp(t, deltrans)
552 // Wait that subs is cleaned
553 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
555 xappConn1.TestMsgChanEmpty(t)
556 xappConn2.TestMsgChanEmpty(t)
557 e2termConn1.TestMsgChanEmpty(t)
558 mainCtrl.wait_registry_empty(t, 10)
561 //-----------------------------------------------------------------------------
562 // TestSubReqTwoRetriesNoRespSubDelRespInSubmgr
565 // +-------+ +---------+ +---------+
566 // | xapp | | submgr | | e2term |
567 // +-------+ +---------+ +---------+
570 // |------------->| |
573 // | |------------->|
577 // | |------------->|
580 // | |------------->|
584 // | |------------->|
588 // | |<-------------|
591 //-----------------------------------------------------------------------------
593 func TestSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
595 CaseBegin("TestSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
597 // Xapp: Send SubsReq
598 xappConn1.SendSubsReq(t, nil, nil)
600 // E2t: Receive 1st SubsReq
601 e2termConn1.RecvSubsReq(t)
603 // E2t: Receive 2nd SubsReq
604 e2termConn1.RecvSubsReq(t)
606 // E2t: Send receive SubsDelReq and send SubsResp
607 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
608 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
610 // Wait that subs is cleaned
611 mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 10)
613 xappConn1.TestMsgChanEmpty(t)
614 xappConn2.TestMsgChanEmpty(t)
615 e2termConn1.TestMsgChanEmpty(t)
616 mainCtrl.wait_registry_empty(t, 10)
619 //-----------------------------------------------------------------------------
620 // TestSubReqTwoRetriesNoRespAtAllInSubmgr
623 // +-------+ +---------+ +---------+
624 // | xapp | | submgr | | e2term |
625 // +-------+ +---------+ +---------+
628 // |------------->| |
631 // | |------------->|
635 // | |------------->|
638 // | |------------->|
642 // | |------------->|
646 //-----------------------------------------------------------------------------
648 func TestSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
650 CaseBegin("TestSubReqTwoRetriesNoRespAtAllInSubmgr start")
652 // Xapp: Send SubsReq
653 xappConn1.SendSubsReq(t, nil, nil)
655 // E2t: Receive 1st SubsReq
656 e2termConn1.RecvSubsReq(t)
658 // E2t: Receive 2nd SubsReq
659 e2termConn1.RecvSubsReq(t)
661 // E2t: Receive 1st SubsDelReq
662 e2termConn1.RecvSubsDelReq(t)
664 // E2t: Receive 2nd SubsDelReq
665 delreq, _ := e2termConn1.RecvSubsDelReq(t)
667 // Wait that subs is cleaned
668 mainCtrl.wait_subs_clean(t, delreq.RequestId.InstanceId, 15)
670 xappConn1.TestMsgChanEmpty(t)
671 xappConn2.TestMsgChanEmpty(t)
672 e2termConn1.TestMsgChanEmpty(t)
673 mainCtrl.wait_registry_empty(t, 10)
676 //-----------------------------------------------------------------------------
677 // TestSubReqSubFailRespInSubmgr
680 // +-------+ +---------+ +---------+
681 // | xapp | | submgr | | e2term |
682 // +-------+ +---------+ +---------+
685 // |------------->| |
688 // | |------------->|
691 // | |<-------------|
694 // | |------------->|
697 // | |<-------------|
700 // |<-------------| |
703 //-----------------------------------------------------------------------------
705 func TestSubReqSubFailRespInSubmgr(t *testing.T) {
707 CaseBegin("TestSubReqSubFailRespInSubmgr start")
709 // Xapp: Send SubsReq
710 cretrans := xappConn1.SendSubsReq(t, nil, nil)
712 // E2t: Receive SubsReq and send SubsFail (first)
713 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
714 fparams1 := &teststube2ap.E2StubSubsFailParams{}
715 fparams1.Set(crereq1)
716 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
718 // E2t: Receive SubsDelReq and send SubsDelResp (internal first)
719 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
720 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
722 // Xapp: Receive SubsFail
723 e2SubsId := xappConn1.RecvSubsFail(t, cretrans)
725 // Wait that subs is cleaned
726 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
728 xappConn1.TestMsgChanEmpty(t)
729 xappConn2.TestMsgChanEmpty(t)
730 e2termConn1.TestMsgChanEmpty(t)
731 mainCtrl.wait_registry_empty(t, 10)
734 //-----------------------------------------------------------------------------
735 // TestSubReqSubFailRespInSubmgrWithDuplicate
738 // +-------+ +---------+ +---------+
739 // | xapp | | submgr | | e2term |
740 // +-------+ +---------+ +---------+
743 // |------------->| |
746 // | |------------->|
749 // | |<-------------|
752 // | |------------->|
755 // | |<-------------|
758 // | |------------->|
761 // | |<-------------|
764 // |<-------------| |
769 //-----------------------------------------------------------------------------
771 func TestSubReqSubFailRespInSubmgrWithDuplicate(t *testing.T) {
773 CaseBegin("TestSubReqSubFailRespInSubmgrWithDuplicate start")
775 // Xapp: Send SubsReq
776 cretrans := xappConn1.SendSubsReq(t, nil, nil)
778 // E2t: Receive SubsReq and send SubsFail (first)
779 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
780 fparams1 := &teststube2ap.E2StubSubsFailParams{}
781 fparams1.Set(crereq1)
782 fparams1.SetCauseVal(-1, 5, 3)
783 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
785 // E2t: Receive SubsDelReq and send SubsDelResp (internal)
786 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
787 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
789 // E2t: Receive SubsReq and send SubsResp (second)
790 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
791 e2termConn1.SendSubsResp(t, crereq2, cremsg2)
793 // XAPP: Receive SubsResp
794 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
797 deltrans2 := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
798 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
799 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
800 xappConn1.RecvSubsDelResp(t, deltrans2)
802 // Wait that subs is cleaned
803 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
805 xappConn1.TestMsgChanEmpty(t)
806 xappConn2.TestMsgChanEmpty(t)
807 e2termConn1.TestMsgChanEmpty(t)
808 mainCtrl.wait_registry_empty(t, 10)
811 //-----------------------------------------------------------------------------
812 // TestSubReqSubFailRespInSubmgrWithDuplicateFail
815 // +-------+ +---------+ +---------+
816 // | xapp | | submgr | | e2term |
817 // +-------+ +---------+ +---------+
820 // |------------->| |
823 // | |------------->|
826 // | |<-------------|
829 // | |------------->|
832 // | |<-------------|
835 // | |------------->|
838 // | |<-------------|
841 // | |------------->|
844 // | |<-------------|
846 // |<-------------| |
849 //-----------------------------------------------------------------------------
851 func TestSubReqSubFailRespInSubmgrWithDuplicateFail(t *testing.T) {
853 CaseBegin("TestSubReqSubFailRespInSubmgrWithDuplicateFail start")
855 // Xapp: Send SubsReq
856 cretrans := xappConn1.SendSubsReq(t, nil, nil)
858 // E2t: Receive SubsReq and send SubsFail (first)
859 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
860 fparams1 := &teststube2ap.E2StubSubsFailParams{}
861 fparams1.Set(crereq1)
862 fparams1.SetCauseVal(-1, 5, 3)
863 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
865 // E2t: Receive SubsDelReq and send SubsDelResp (internal first)
866 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
867 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
869 // E2t: Receive SubsReq and send SubsFail (second)
870 crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
871 fparams2 := &teststube2ap.E2StubSubsFailParams{}
872 fparams2.Set(crereq2)
873 fparams2.SetCauseVal(-1, 5, 3)
874 e2termConn1.SendSubsFail(t, fparams2, cremsg2)
876 // E2t: Receive SubsDelReq and send SubsDelResp (internal second)
877 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
878 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
880 // Xapp: Receive SubsFail
881 e2SubsId := xappConn1.RecvSubsFail(t, cretrans)
883 // Wait that subs is cleaned
884 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
886 xappConn1.TestMsgChanEmpty(t)
887 xappConn2.TestMsgChanEmpty(t)
888 e2termConn1.TestMsgChanEmpty(t)
889 mainCtrl.wait_registry_empty(t, 10)
892 //-----------------------------------------------------------------------------
893 // TestSubDelReqRetryInSubmgr
896 // +-------+ +---------+ +---------+
897 // | xapp | | submgr | | e2term |
898 // +-------+ +---------+ +---------+
904 // |------------->| |
907 // | |------------->|
910 // | |------------->|
913 // | |<-------------|
916 // |<-------------| |
918 //-----------------------------------------------------------------------------
920 func TestSubDelReqRetryInSubmgr(t *testing.T) {
922 CaseBegin("TestSubDelReqRetryInSubmgr start")
925 cretrans := xappConn1.SendSubsReq(t, nil, nil)
926 crereq, cremsg := e2termConn1.RecvSubsReq(t)
927 e2termConn1.SendSubsResp(t, crereq, cremsg)
928 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
931 // Xapp: Send SubsDelReq
932 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
934 // E2t: Receive 1st SubsDelReq
935 e2termConn1.RecvSubsDelReq(t)
937 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
938 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
939 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
941 // Xapp: Receive SubsDelResp
942 xappConn1.RecvSubsDelResp(t, deltrans)
944 // Wait that subs is cleaned
945 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
947 xappConn1.TestMsgChanEmpty(t)
948 xappConn2.TestMsgChanEmpty(t)
949 e2termConn1.TestMsgChanEmpty(t)
950 mainCtrl.wait_registry_empty(t, 10)
953 //-----------------------------------------------------------------------------
954 // TestSubDelReqTwoRetriesNoRespInSubmgr
957 // +-------+ +---------+ +---------+
958 // | xapp | | submgr | | e2term |
959 // +-------+ +---------+ +---------+
965 // |------------->| |
968 // | |------------->|
971 // | |------------->|
975 // |<-------------| |
977 //-----------------------------------------------------------------------------
979 func TestSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
981 CaseBegin("TestSubDelReTwoRetriesNoRespInSubmgr start")
984 cretrans := xappConn1.SendSubsReq(t, nil, nil)
985 crereq, cremsg := e2termConn1.RecvSubsReq(t)
986 e2termConn1.SendSubsResp(t, crereq, cremsg)
987 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
990 // Xapp: Send SubsDelReq
991 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
993 // E2t: Receive 1st SubsDelReq
994 e2termConn1.RecvSubsDelReq(t)
996 // E2t: Receive 2nd SubsDelReq
997 e2termConn1.RecvSubsDelReq(t)
999 // Xapp: Receive SubsDelResp
1000 xappConn1.RecvSubsDelResp(t, deltrans)
1002 // Wait that subs is cleaned
1003 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1005 xappConn1.TestMsgChanEmpty(t)
1006 xappConn2.TestMsgChanEmpty(t)
1007 e2termConn1.TestMsgChanEmpty(t)
1008 mainCtrl.wait_registry_empty(t, 10)
1011 //-----------------------------------------------------------------------------
1012 // TestSubDelReqSubDelFailRespInSubmgr
1015 // +-------+ +---------+ +---------+
1016 // | xapp | | submgr | | e2term |
1017 // +-------+ +---------+ +---------+
1019 // | [SUBS CREATE] |
1023 // |------------->| |
1026 // | |------------->|
1029 // | |<-------------|
1032 // |<-------------| |
1035 //-----------------------------------------------------------------------------
1037 func TestSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
1039 CaseBegin("TestSubReqSubDelFailRespInSubmgr start")
1042 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1043 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1044 e2termConn1.SendSubsResp(t, crereq, cremsg)
1045 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1047 // Xapp: Send SubsDelReq
1048 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1050 // E2t: Send receive SubsDelReq and send SubsDelFail
1051 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1052 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
1054 // Xapp: Receive SubsDelResp
1055 xappConn1.RecvSubsDelResp(t, deltrans)
1057 // Wait that subs is cleaned
1058 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1060 xappConn1.TestMsgChanEmpty(t)
1061 xappConn2.TestMsgChanEmpty(t)
1062 e2termConn1.TestMsgChanEmpty(t)
1063 mainCtrl.wait_registry_empty(t, 10)
1066 //-----------------------------------------------------------------------------
1067 // TestSubReqAndSubDelOkSameAction
1070 // +-------+ +-------+ +---------+ +---------+
1071 // | xapp2 | | xapp1 | | submgr | | e2term |
1072 // +-------+ +-------+ +---------+ +---------+
1077 // | |------------->| |
1080 // | | |------------->|
1082 // | | |<-------------|
1084 // | |<-------------| |
1087 // |--------------------------->| |
1090 // |<---------------------------| |
1092 // | | SubDelReq 1 | |
1093 // | |------------->| |
1095 // | | SubDelResp 1 | |
1096 // | |<-------------| |
1098 // | SubDelReq 2 | |
1099 // |--------------------------->| |
1101 // | | | SubDelReq 2 |
1102 // | | |------------->|
1104 // | | | SubDelReq 2 |
1105 // | | |------------->|
1107 // | SubDelResp 2 | |
1108 // |<---------------------------| |
1110 //-----------------------------------------------------------------------------
1111 func TestSubReqAndSubDelOkSameAction(t *testing.T) {
1112 CaseBegin("TestSubReqAndSubDelOkSameAction")
1115 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1117 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1118 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1119 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1120 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1123 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1125 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1126 //crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
1127 //e2termConn1.SendSubsResp(t, crereq2, cremsg2)
1128 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1130 resp, _ := xapp.Subscription.QuerySubscriptions()
1131 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
1132 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
1133 assert.Equal(t, resp[0].Endpoint, []string{"localhost:13560", "localhost:13660"})
1136 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1137 //e2termConn1.RecvSubsDelReq(t)
1138 //e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1139 xappConn1.RecvSubsDelResp(t, deltrans1)
1140 //Wait that subs is cleaned
1141 //mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1144 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1145 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1146 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1147 xappConn2.RecvSubsDelResp(t, deltrans2)
1148 //Wait that subs is cleaned
1149 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1151 xappConn1.TestMsgChanEmpty(t)
1152 xappConn2.TestMsgChanEmpty(t)
1153 e2termConn1.TestMsgChanEmpty(t)
1154 mainCtrl.wait_registry_empty(t, 10)
1157 //-----------------------------------------------------------------------------
1158 // TestSubReqAndSubDelOkSameActionParallel
1161 // +-------+ +-------+ +---------+ +---------+
1162 // | xapp2 | | xapp1 | | submgr | | e2term |
1163 // +-------+ +-------+ +---------+ +---------+
1168 // | |------------->| |
1171 // | | |------------->|
1173 // |--------------------------->| |
1175 // | | |<-------------|
1177 // | |<-------------| |
1180 // |<---------------------------| |
1182 // | | SubDelReq 1 | |
1183 // | |------------->| |
1185 // | | SubDelResp 1 | |
1186 // | |<-------------| |
1188 // | SubDelReq 2 | |
1189 // |--------------------------->| |
1191 // | | | SubDelReq 2 |
1192 // | | |------------->|
1194 // | | | SubDelReq 2 |
1195 // | | |------------->|
1197 // | SubDelResp 2 | |
1198 // |<---------------------------| |
1200 //-----------------------------------------------------------------------------
1201 func TestSubReqAndSubDelOkSameActionParallel(t *testing.T) {
1202 CaseBegin("TestSubReqAndSubDelOkSameActionParallel")
1205 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1207 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1208 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1211 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1213 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1216 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1217 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1220 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1223 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1224 xappConn1.RecvSubsDelResp(t, deltrans1)
1227 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1228 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1229 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1230 xappConn2.RecvSubsDelResp(t, deltrans2)
1232 //Wait that subs is cleaned
1233 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1235 xappConn1.TestMsgChanEmpty(t)
1236 xappConn2.TestMsgChanEmpty(t)
1237 e2termConn1.TestMsgChanEmpty(t)
1238 mainCtrl.wait_registry_empty(t, 10)
1241 //-----------------------------------------------------------------------------
1242 // TestSubReqAndSubDelNokSameActionParallel
1245 // +-------+ +-------+ +---------+ +---------+
1246 // | xapp2 | | xapp1 | | submgr | | e2term |
1247 // +-------+ +-------+ +---------+ +---------+
1252 // | |------------->| |
1255 // | | |------------->|
1257 // |--------------------------->| |
1259 // | | |<-------------|
1261 // | | | SubDelReq |
1262 // | | |------------->|
1263 // | | | SubDelResp |
1264 // | | |<-------------|
1267 // | |<-------------| |
1270 // |<---------------------------| |
1272 //-----------------------------------------------------------------------------
1273 func TestSubReqAndSubDelNokSameActionParallel(t *testing.T) {
1274 CaseBegin("TestSubReqAndSubDelNokSameActionParallel")
1277 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1279 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1281 // E2t: Receive SubsReq (first)
1282 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1285 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1287 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
1288 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1289 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
1291 // E2t: send SubsFail (first)
1292 fparams1 := &teststube2ap.E2StubSubsFailParams{}
1293 fparams1.Set(crereq1)
1294 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
1296 // E2t: internal delete
1297 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1298 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1301 e2SubsId1 := xappConn1.RecvSubsFail(t, cretrans1)
1303 xappConn2.RecvSubsFail(t, cretrans2)
1305 //Wait that subs is cleaned
1306 mainCtrl.wait_subs_clean(t, e2SubsId1, 15)
1308 xappConn1.TestMsgChanEmpty(t)
1309 xappConn2.TestMsgChanEmpty(t)
1310 e2termConn1.TestMsgChanEmpty(t)
1311 mainCtrl.wait_registry_empty(t, 10)
1314 //-----------------------------------------------------------------------------
1315 // TestSubReqAndSubDelNoAnswerSameActionParallel
1318 // +-------+ +-------+ +---------+ +---------+
1319 // | xapp2 | | xapp1 | | submgr | | e2term |
1320 // +-------+ +-------+ +---------+ +---------+
1325 // | |------------->| |
1328 // | | |------------->|
1330 // |--------------------------->| |
1333 // | | |------------->|
1336 // | | | SubDelReq |
1337 // | | |------------->|
1339 // | | | SubDelResp |
1340 // | | |<-------------|
1342 //-----------------------------------------------------------------------------
1343 func TestSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
1344 CaseBegin("TestSubReqAndSubDelNoAnswerSameActionParallel")
1347 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1349 xappConn1.SendSubsReq(t, rparams1, nil)
1351 crereq1, _ := e2termConn1.RecvSubsReq(t)
1354 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1356 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
1357 xappConn2.SendSubsReq(t, rparams2, nil)
1358 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
1360 //Req1 (retransmitted)
1361 e2termConn1.RecvSubsReq(t)
1363 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1364 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1366 //Wait that subs is cleaned
1367 mainCtrl.wait_subs_clean(t, delreq1.RequestId.InstanceId, 10)
1369 xappConn1.TestMsgChanEmpty(t)
1370 xappConn2.TestMsgChanEmpty(t)
1371 e2termConn1.TestMsgChanEmpty(t)
1372 mainCtrl.wait_registry_empty(t, 15)
1375 //----------------------------- Policy cases ---------------------------------
1376 //-----------------------------------------------------------------------------
1377 // TestSubReqPolicyAndSubDelOk
1380 // +-------+ +---------+ +---------+
1381 // | xapp | | submgr | | e2term |
1382 // +-------+ +---------+ +---------+
1385 // |------------->| |
1388 // | |------------->|
1391 // | |<-------------|
1394 // |<-------------| |
1398 // |------------->| |
1401 // | |------------->|
1404 // | |<-------------|
1407 // |<-------------| |
1409 //-----------------------------------------------------------------------------
1410 func TestSubReqPolicyAndSubDelOk(t *testing.T) {
1411 CaseBegin("TestSubReqAndSubDelOk")
1413 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1415 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
1416 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1418 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1419 e2termConn1.SendSubsResp(t, crereq, cremsg)
1420 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1421 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1422 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1424 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1425 xappConn1.RecvSubsDelResp(t, deltrans)
1427 //Wait that subs is cleaned
1428 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1430 xappConn1.TestMsgChanEmpty(t)
1431 xappConn2.TestMsgChanEmpty(t)
1432 e2termConn1.TestMsgChanEmpty(t)
1433 mainCtrl.wait_registry_empty(t, 10)
1436 //-----------------------------------------------------------------------------
1437 // TestSubReqPolicyChangeAndSubDelOk
1440 // +-------+ +---------+ +---------+
1441 // | xapp | | submgr | | e2term |
1442 // +-------+ +---------+ +---------+
1445 // |------------->| |
1448 // | |------------->|
1451 // | |<-------------|
1454 // |<-------------| |
1457 // |------------->| |
1460 // | |------------->|
1463 // | |<-------------|
1466 // |<-------------| |
1469 // |------------->| |
1472 // | |------------->|
1475 // | |<-------------|
1478 // |<-------------| |
1480 //-----------------------------------------------------------------------------
1482 func TestSubReqPolicyChangeAndSubDelOk(t *testing.T) {
1483 CaseBegin("TestSubReqAndSubDelOk")
1485 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1487 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
1488 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1490 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1491 e2termConn1.SendSubsResp(t, crereq, cremsg)
1492 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1495 rparams1.Req.RequestId.InstanceId = e2SubsId
1496 rparams1.Req.ActionSetups[0].SubsequentAction.TimetoWait = e2ap.E2AP_TimeToWaitW200ms
1497 xappConn1.SendSubsReq(t, rparams1, cretrans)
1499 crereq, cremsg = e2termConn1.RecvSubsReq(t)
1500 e2termConn1.SendSubsResp(t, crereq, cremsg)
1501 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
1502 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1503 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1505 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1506 xappConn1.RecvSubsDelResp(t, deltrans)
1508 //Wait that subs is cleaned
1509 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1511 xappConn1.TestMsgChanEmpty(t)
1512 xappConn2.TestMsgChanEmpty(t)
1513 e2termConn1.TestMsgChanEmpty(t)
1514 mainCtrl.wait_registry_empty(t, 10)
1517 //-----------------------------------------------------------------------------
1518 // TestSubReqAndSubDelOkTwoE2termParallel
1521 // +-------+ +---------+ +---------+ +---------+
1522 // | xapp | | submgr | | e2term1 | | e2term2 |
1523 // +-------+ +---------+ +---------+ +---------+
1528 // |------------->| | |
1531 // | |------------->| |
1534 // |------------->| | |
1537 // | |---------------------------->|
1540 // | |<-------------| |
1542 // |<-------------| | |
1544 // | |<----------------------------|
1546 // |<-------------| | |
1548 // | [SUBS 1 DELETE] | |
1550 // | [SUBS 2 DELETE] | |
1553 //-----------------------------------------------------------------------------
1554 func TestSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
1555 CaseBegin("TestSubReqAndSubDelOkTwoE2termParallel")
1558 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1559 xappConn1.SendSubsReq(t, nil, cretrans1)
1560 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1562 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_11")
1563 xappConn1.SendSubsReq(t, nil, cretrans2)
1564 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
1567 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1568 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1571 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
1572 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
1575 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1576 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1577 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1578 xappConn1.RecvSubsDelResp(t, deltrans1)
1579 //Wait that subs is cleaned
1580 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1583 deltrans2 := xappConn1.SendSubsDelReq(t, nil, e2SubsId2)
1584 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
1585 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
1586 xappConn1.RecvSubsDelResp(t, deltrans2)
1587 //Wait that subs is cleaned
1588 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1590 xappConn1.TestMsgChanEmpty(t)
1591 xappConn2.TestMsgChanEmpty(t)
1592 e2termConn1.TestMsgChanEmpty(t)
1593 e2termConn2.TestMsgChanEmpty(t)
1594 mainCtrl.wait_registry_empty(t, 10)
1597 //-----------------------------------------------------------------------------
1598 // TestSubReqInsertAndSubDelOk
1601 // +-------+ +---------+ +---------+
1602 // | xapp | | submgr | | e2term |
1603 // +-------+ +---------+ +---------+
1606 // |------------->| |
1609 // | |------------->|
1612 // | |<-------------|
1615 // |<-------------| |
1619 // |------------->| |
1622 // | |------------->|
1625 // | |<-------------|
1628 // |<-------------| |
1630 //-----------------------------------------------------------------------------
1631 func TestSubReqInsertAndSubDelOk(t *testing.T) {
1632 CaseBegin("TestInsertSubReqAndSubDelOk")
1634 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1636 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypeInsert
1637 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1639 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1640 e2termConn1.SendSubsResp(t, crereq, cremsg)
1641 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1642 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1643 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1645 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1646 xappConn1.RecvSubsDelResp(t, deltrans)
1648 //Wait that subs is cleaned
1649 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1651 xappConn1.TestMsgChanEmpty(t)
1652 xappConn2.TestMsgChanEmpty(t)
1653 e2termConn1.TestMsgChanEmpty(t)
1654 mainCtrl.wait_registry_empty(t, 10)
1657 //-----------------------------------------------------------------------------
1658 // TestSubReqRetransmissionWithSameSubIdDiffXid
1660 // This case simulates case where xApp restarts and starts sending same
1661 // subscription requests which have already subscribed successfully
1664 // +-------+ +---------+ +---------+
1665 // | xapp | | submgr | | e2term |
1666 // +-------+ +---------+ +---------+
1669 // |------------->| |
1672 // | |------------->|
1675 // | |<-------------|
1678 // |<-------------| |
1680 // | xApp restart | |
1683 // | (retrans with same xApp generated subid but diff xid)
1684 // |------------->| |
1687 // |<-------------| |
1689 // | [SUBS DELETE] |
1692 //-----------------------------------------------------------------------------
1693 func TestSubReqRetransmissionWithSameSubIdDiffXid(t *testing.T) {
1694 CaseBegin("TestSubReqRetransmissionWithSameSubIdDiffXid")
1697 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1698 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1699 e2termConn1.SendSubsResp(t, crereq, cremsg)
1700 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1702 // xApp restart here
1703 // --> artificial delay
1704 <-time.After(1 * time.Second)
1707 cretrans = xappConn1.SendSubsReq(t, nil, nil) //Retransmitted SubReq
1708 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
1711 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1712 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1713 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1714 xappConn1.RecvSubsDelResp(t, deltrans)
1716 //Wait that subs is cleaned
1717 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1719 xappConn1.TestMsgChanEmpty(t)
1720 xappConn2.TestMsgChanEmpty(t)
1721 e2termConn1.TestMsgChanEmpty(t)
1722 mainCtrl.wait_registry_empty(t, 10)