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 // TestSubDelReqRetryInSubmgr
738 // +-------+ +---------+ +---------+
739 // | xapp | | submgr | | e2term |
740 // +-------+ +---------+ +---------+
746 // |------------->| |
749 // | |------------->|
752 // | |------------->|
755 // | |<-------------|
758 // |<-------------| |
760 //-----------------------------------------------------------------------------
762 func TestSubDelReqRetryInSubmgr(t *testing.T) {
764 CaseBegin("TestSubDelReqRetryInSubmgr start")
767 cretrans := xappConn1.SendSubsReq(t, nil, nil)
768 crereq, cremsg := e2termConn1.RecvSubsReq(t)
769 e2termConn1.SendSubsResp(t, crereq, cremsg)
770 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
773 // Xapp: Send SubsDelReq
774 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
776 // E2t: Receive 1st SubsDelReq
777 e2termConn1.RecvSubsDelReq(t)
779 // E2t: Receive 2nd SubsDelReq and send SubsDelResp
780 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
781 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
783 // Xapp: Receive SubsDelResp
784 xappConn1.RecvSubsDelResp(t, deltrans)
786 // Wait that subs is cleaned
787 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
789 xappConn1.TestMsgChanEmpty(t)
790 xappConn2.TestMsgChanEmpty(t)
791 e2termConn1.TestMsgChanEmpty(t)
792 mainCtrl.wait_registry_empty(t, 10)
795 //-----------------------------------------------------------------------------
796 // TestSubDelReqTwoRetriesNoRespInSubmgr
799 // +-------+ +---------+ +---------+
800 // | xapp | | submgr | | e2term |
801 // +-------+ +---------+ +---------+
807 // |------------->| |
810 // | |------------->|
813 // | |------------->|
817 // |<-------------| |
819 //-----------------------------------------------------------------------------
821 func TestSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
823 CaseBegin("TestSubDelReTwoRetriesNoRespInSubmgr start")
826 cretrans := xappConn1.SendSubsReq(t, nil, nil)
827 crereq, cremsg := e2termConn1.RecvSubsReq(t)
828 e2termConn1.SendSubsResp(t, crereq, cremsg)
829 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
832 // Xapp: Send SubsDelReq
833 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
835 // E2t: Receive 1st SubsDelReq
836 e2termConn1.RecvSubsDelReq(t)
838 // E2t: Receive 2nd SubsDelReq
839 e2termConn1.RecvSubsDelReq(t)
841 // Xapp: Receive SubsDelResp
842 xappConn1.RecvSubsDelResp(t, deltrans)
844 // Wait that subs is cleaned
845 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
847 xappConn1.TestMsgChanEmpty(t)
848 xappConn2.TestMsgChanEmpty(t)
849 e2termConn1.TestMsgChanEmpty(t)
850 mainCtrl.wait_registry_empty(t, 10)
853 //-----------------------------------------------------------------------------
854 // TestSubDelReqSubDelFailRespInSubmgr
857 // +-------+ +---------+ +---------+
858 // | xapp | | submgr | | e2term |
859 // +-------+ +---------+ +---------+
865 // |------------->| |
868 // | |------------->|
871 // | |<-------------|
874 // |<-------------| |
877 //-----------------------------------------------------------------------------
879 func TestSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
881 CaseBegin("TestSubReqSubDelFailRespInSubmgr start")
884 cretrans := xappConn1.SendSubsReq(t, nil, nil)
885 crereq, cremsg := e2termConn1.RecvSubsReq(t)
886 e2termConn1.SendSubsResp(t, crereq, cremsg)
887 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
889 // Xapp: Send SubsDelReq
890 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
892 // E2t: Send receive SubsDelReq and send SubsDelFail
893 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
894 e2termConn1.SendSubsDelFail(t, delreq, delmsg)
896 // Xapp: Receive SubsDelResp
897 xappConn1.RecvSubsDelResp(t, deltrans)
899 // Wait that subs is cleaned
900 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
902 xappConn1.TestMsgChanEmpty(t)
903 xappConn2.TestMsgChanEmpty(t)
904 e2termConn1.TestMsgChanEmpty(t)
905 mainCtrl.wait_registry_empty(t, 10)
908 //-----------------------------------------------------------------------------
909 // TestSubReqAndSubDelOkSameAction
912 // +-------+ +-------+ +---------+ +---------+
913 // | xapp2 | | xapp1 | | submgr | | e2term |
914 // +-------+ +-------+ +---------+ +---------+
919 // | |------------->| |
922 // | | |------------->|
924 // | | |<-------------|
926 // | |<-------------| |
929 // |--------------------------->| |
932 // |<---------------------------| |
934 // | | SubDelReq 1 | |
935 // | |------------->| |
937 // | | SubDelResp 1 | |
938 // | |<-------------| |
941 // |--------------------------->| |
943 // | | | SubDelReq 2 |
944 // | | |------------->|
946 // | | | SubDelReq 2 |
947 // | | |------------->|
949 // | SubDelResp 2 | |
950 // |<---------------------------| |
952 //-----------------------------------------------------------------------------
953 func TestSubReqAndSubDelOkSameAction(t *testing.T) {
954 CaseBegin("TestSubReqAndSubDelOkSameAction")
957 rparams1 := &teststube2ap.E2StubSubsReqParams{}
959 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
960 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
961 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
962 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
965 rparams2 := &teststube2ap.E2StubSubsReqParams{}
967 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
968 //crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
969 //e2termConn1.SendSubsResp(t, crereq2, cremsg2)
970 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
972 resp, _ := xapp.Subscription.QuerySubscriptions()
973 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
974 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
975 assert.Equal(t, resp[0].Endpoint, []string{"localhost:13560", "localhost:13660"})
978 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
979 //e2termConn1.RecvSubsDelReq(t)
980 //e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
981 xappConn1.RecvSubsDelResp(t, deltrans1)
982 //Wait that subs is cleaned
983 //mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
986 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
987 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
988 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
989 xappConn2.RecvSubsDelResp(t, deltrans2)
990 //Wait that subs is cleaned
991 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
993 xappConn1.TestMsgChanEmpty(t)
994 xappConn2.TestMsgChanEmpty(t)
995 e2termConn1.TestMsgChanEmpty(t)
996 mainCtrl.wait_registry_empty(t, 10)
999 //-----------------------------------------------------------------------------
1000 // TestSubReqAndSubDelOkSameActionParallel
1003 // +-------+ +-------+ +---------+ +---------+
1004 // | xapp2 | | xapp1 | | submgr | | e2term |
1005 // +-------+ +-------+ +---------+ +---------+
1010 // | |------------->| |
1013 // | | |------------->|
1015 // |--------------------------->| |
1017 // | | |<-------------|
1019 // | |<-------------| |
1022 // |<---------------------------| |
1024 // | | SubDelReq 1 | |
1025 // | |------------->| |
1027 // | | SubDelResp 1 | |
1028 // | |<-------------| |
1030 // | SubDelReq 2 | |
1031 // |--------------------------->| |
1033 // | | | SubDelReq 2 |
1034 // | | |------------->|
1036 // | | | SubDelReq 2 |
1037 // | | |------------->|
1039 // | SubDelResp 2 | |
1040 // |<---------------------------| |
1042 //-----------------------------------------------------------------------------
1043 func TestSubReqAndSubDelOkSameActionParallel(t *testing.T) {
1044 CaseBegin("TestSubReqAndSubDelOkSameActionParallel")
1047 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1049 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1050 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1053 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1055 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1058 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1059 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1062 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1065 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1066 xappConn1.RecvSubsDelResp(t, deltrans1)
1069 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1070 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1071 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1072 xappConn2.RecvSubsDelResp(t, deltrans2)
1074 //Wait that subs is cleaned
1075 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1077 xappConn1.TestMsgChanEmpty(t)
1078 xappConn2.TestMsgChanEmpty(t)
1079 e2termConn1.TestMsgChanEmpty(t)
1080 mainCtrl.wait_registry_empty(t, 10)
1083 //-----------------------------------------------------------------------------
1084 // TestSubReqAndSubDelNokSameActionParallel
1087 // +-------+ +-------+ +---------+ +---------+
1088 // | xapp2 | | xapp1 | | submgr | | e2term |
1089 // +-------+ +-------+ +---------+ +---------+
1094 // | |------------->| |
1097 // | | |------------->|
1099 // |--------------------------->| |
1101 // | | |<-------------|
1103 // | | | SubDelReq |
1104 // | | |------------->|
1105 // | | | SubDelResp |
1106 // | | |<-------------|
1109 // | |<-------------| |
1112 // |<---------------------------| |
1114 //-----------------------------------------------------------------------------
1115 func TestSubReqAndSubDelNokSameActionParallel(t *testing.T) {
1116 CaseBegin("TestSubReqAndSubDelNokSameActionParallel")
1119 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1121 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1123 // E2t: Receive SubsReq (first)
1124 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1127 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1129 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
1130 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1131 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
1133 // E2t: send SubsFail (first)
1134 fparams1 := &teststube2ap.E2StubSubsFailParams{}
1135 fparams1.Set(crereq1)
1136 e2termConn1.SendSubsFail(t, fparams1, cremsg1)
1138 // E2t: internal delete
1139 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1140 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1143 e2SubsId1 := xappConn1.RecvSubsFail(t, cretrans1)
1145 xappConn2.RecvSubsFail(t, cretrans2)
1147 //Wait that subs is cleaned
1148 mainCtrl.wait_subs_clean(t, e2SubsId1, 15)
1150 xappConn1.TestMsgChanEmpty(t)
1151 xappConn2.TestMsgChanEmpty(t)
1152 e2termConn1.TestMsgChanEmpty(t)
1153 mainCtrl.wait_registry_empty(t, 10)
1156 //-----------------------------------------------------------------------------
1157 // TestSubReqAndSubDelNoAnswerSameActionParallel
1160 // +-------+ +-------+ +---------+ +---------+
1161 // | xapp2 | | xapp1 | | submgr | | e2term |
1162 // +-------+ +-------+ +---------+ +---------+
1167 // | |------------->| |
1170 // | | |------------->|
1172 // |--------------------------->| |
1175 // | | |------------->|
1178 // | | | SubDelReq |
1179 // | | |------------->|
1181 // | | | SubDelResp |
1182 // | | |<-------------|
1184 //-----------------------------------------------------------------------------
1185 func TestSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
1186 CaseBegin("TestSubReqAndSubDelNoAnswerSameActionParallel")
1189 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1191 xappConn1.SendSubsReq(t, rparams1, nil)
1193 crereq1, _ := e2termConn1.RecvSubsReq(t)
1196 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1198 subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
1199 xappConn2.SendSubsReq(t, rparams2, nil)
1200 mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
1202 //Req1 (retransmitted)
1203 e2termConn1.RecvSubsReq(t)
1205 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1206 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1208 //Wait that subs is cleaned
1209 mainCtrl.wait_subs_clean(t, delreq1.RequestId.InstanceId, 10)
1211 xappConn1.TestMsgChanEmpty(t)
1212 xappConn2.TestMsgChanEmpty(t)
1213 e2termConn1.TestMsgChanEmpty(t)
1214 mainCtrl.wait_registry_empty(t, 15)
1217 //----------------------------- Policy cases ---------------------------------
1218 //-----------------------------------------------------------------------------
1219 // TestSubReqPolicyAndSubDelOk
1222 // +-------+ +---------+ +---------+
1223 // | xapp | | submgr | | e2term |
1224 // +-------+ +---------+ +---------+
1227 // |------------->| |
1230 // | |------------->|
1233 // | |<-------------|
1236 // |<-------------| |
1240 // |------------->| |
1243 // | |------------->|
1246 // | |<-------------|
1249 // |<-------------| |
1251 //-----------------------------------------------------------------------------
1252 func TestSubReqPolicyAndSubDelOk(t *testing.T) {
1253 CaseBegin("TestSubReqAndSubDelOk")
1255 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1257 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
1258 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1260 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1261 e2termConn1.SendSubsResp(t, crereq, cremsg)
1262 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1263 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1264 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1266 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1267 xappConn1.RecvSubsDelResp(t, deltrans)
1269 //Wait that subs is cleaned
1270 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1272 xappConn1.TestMsgChanEmpty(t)
1273 xappConn2.TestMsgChanEmpty(t)
1274 e2termConn1.TestMsgChanEmpty(t)
1275 mainCtrl.wait_registry_empty(t, 10)
1278 //-----------------------------------------------------------------------------
1279 // TestSubReqPolicyChangeAndSubDelOk
1282 // +-------+ +---------+ +---------+
1283 // | xapp | | submgr | | e2term |
1284 // +-------+ +---------+ +---------+
1287 // |------------->| |
1290 // | |------------->|
1293 // | |<-------------|
1296 // |<-------------| |
1299 // |------------->| |
1302 // | |------------->|
1305 // | |<-------------|
1308 // |<-------------| |
1311 // |------------->| |
1314 // | |------------->|
1317 // | |<-------------|
1320 // |<-------------| |
1322 //-----------------------------------------------------------------------------
1324 func TestSubReqPolicyChangeAndSubDelOk(t *testing.T) {
1325 CaseBegin("TestSubReqAndSubDelOk")
1327 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1329 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypePolicy
1330 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
1332 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1333 e2termConn1.SendSubsResp(t, crereq, cremsg)
1334 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1337 rparams1.Req.RequestId.InstanceId = e2SubsId
1338 rparams1.Req.ActionSetups[0].SubsequentAction.TimetoWait = e2ap.E2AP_TimeToWaitW200ms
1339 xappConn1.SendSubsReq(t, rparams1, cretrans)
1341 crereq, cremsg = e2termConn1.RecvSubsReq(t)
1342 e2termConn1.SendSubsResp(t, crereq, cremsg)
1343 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
1344 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1345 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1347 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1348 xappConn1.RecvSubsDelResp(t, deltrans)
1350 //Wait that subs is cleaned
1351 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1353 xappConn1.TestMsgChanEmpty(t)
1354 xappConn2.TestMsgChanEmpty(t)
1355 e2termConn1.TestMsgChanEmpty(t)
1356 mainCtrl.wait_registry_empty(t, 10)
1359 //-----------------------------------------------------------------------------
1360 // TestSubReqAndSubDelOkTwoE2termParallel
1363 // +-------+ +---------+ +---------+ +---------+
1364 // | xapp | | submgr | | e2term1 | | e2term2 |
1365 // +-------+ +---------+ +---------+ +---------+
1370 // |------------->| | |
1373 // | |------------->| |
1376 // |------------->| | |
1379 // | |---------------------------->|
1382 // | |<-------------| |
1384 // |<-------------| | |
1386 // | |<----------------------------|
1388 // |<-------------| | |
1390 // | [SUBS 1 DELETE] | |
1392 // | [SUBS 2 DELETE] | |
1395 //-----------------------------------------------------------------------------
1396 func TestSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
1397 CaseBegin("TestSubReqAndSubDelOkTwoE2termParallel")
1400 cretrans1 := xappConn1.NewRmrTransactionId("", "RAN_NAME_1")
1401 xappConn1.SendSubsReq(t, nil, cretrans1)
1402 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1404 cretrans2 := xappConn1.NewRmrTransactionId("", "RAN_NAME_11")
1405 xappConn1.SendSubsReq(t, nil, cretrans2)
1406 crereq2, cremsg2 := e2termConn2.RecvSubsReq(t)
1409 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1410 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1413 e2termConn2.SendSubsResp(t, crereq2, cremsg2)
1414 e2SubsId2 := xappConn1.RecvSubsResp(t, cretrans2)
1417 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1418 delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
1419 e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
1420 xappConn1.RecvSubsDelResp(t, deltrans1)
1421 //Wait that subs is cleaned
1422 mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
1425 deltrans2 := xappConn1.SendSubsDelReq(t, nil, e2SubsId2)
1426 delreq2, delmsg2 := e2termConn2.RecvSubsDelReq(t)
1427 e2termConn2.SendSubsDelResp(t, delreq2, delmsg2)
1428 xappConn1.RecvSubsDelResp(t, deltrans2)
1429 //Wait that subs is cleaned
1430 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1432 xappConn1.TestMsgChanEmpty(t)
1433 xappConn2.TestMsgChanEmpty(t)
1434 e2termConn1.TestMsgChanEmpty(t)
1435 e2termConn2.TestMsgChanEmpty(t)
1436 mainCtrl.wait_registry_empty(t, 10)
1439 //-----------------------------------------------------------------------------
1440 // TestSubReqInsertAndSubDelOk
1443 // +-------+ +---------+ +---------+
1444 // | xapp | | submgr | | e2term |
1445 // +-------+ +---------+ +---------+
1448 // |------------->| |
1451 // | |------------->|
1454 // | |<-------------|
1457 // |<-------------| |
1461 // |------------->| |
1464 // | |------------->|
1467 // | |<-------------|
1470 // |<-------------| |
1472 //-----------------------------------------------------------------------------
1473 func TestSubReqInsertAndSubDelOk(t *testing.T) {
1474 CaseBegin("TestInsertSubReqAndSubDelOk")
1476 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1478 rparams1.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypeInsert
1479 cretrans := xappConn1.SendSubsReq(t, rparams1, nil)
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 // TestSubReqRetransmissionWithSameSubIdDiffXid
1502 // This case simulates case where xApp restarts and starts sending same
1503 // subscription requests which have already subscribed successfully
1506 // +-------+ +---------+ +---------+
1507 // | xapp | | submgr | | e2term |
1508 // +-------+ +---------+ +---------+
1511 // |------------->| |
1514 // | |------------->|
1517 // | |<-------------|
1520 // |<-------------| |
1522 // | xApp restart | |
1525 // | (retrans with same xApp generated subid but diff xid)
1526 // |------------->| |
1529 // |<-------------| |
1531 // | [SUBS DELETE] |
1534 //-----------------------------------------------------------------------------
1535 func TestSubReqRetransmissionWithSameSubIdDiffXid(t *testing.T) {
1536 CaseBegin("TestSubReqRetransmissionWithSameSubIdDiffXid")
1539 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1540 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1541 e2termConn1.SendSubsResp(t, crereq, cremsg)
1542 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1544 // xApp restart here
1545 // --> artificial delay
1546 <-time.After(1 * time.Second)
1549 cretrans = xappConn1.SendSubsReq(t, nil, nil) //Retransmitted SubReq
1550 e2SubsId = xappConn1.RecvSubsResp(t, cretrans)
1553 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1554 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1555 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1556 xappConn1.RecvSubsDelResp(t, deltrans)
1558 //Wait that subs is cleaned
1559 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1561 xappConn1.TestMsgChanEmpty(t)
1562 xappConn2.TestMsgChanEmpty(t)
1563 e2termConn1.TestMsgChanEmpty(t)
1564 mainCtrl.wait_registry_empty(t, 10)
1567 //-----------------------------------------------------------------------------
1568 // TestSubReqNokAndSubDelOkWithRestartInMiddle
1571 // +-------+ +---------+ +---------+
1572 // | xapp | | submgr | | e2term |
1573 // +-------+ +---------+ +---------+
1576 // |------------->| |
1579 // | |------------->|
1584 // | Submgr restart |
1588 // | |------------->|
1591 // | |<-------------|
1594 //-----------------------------------------------------------------------------
1596 func TestSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
1597 CaseBegin("TestSubReqNokAndSubDelOkWithRestartInMiddle")
1599 // Remove possible existing subscrition
1600 mainCtrl.removeExistingSubscriptions(t)
1602 mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
1603 xappConn1.SendSubsReq(t, nil, nil)
1604 e2termConn1.RecvSubsReq(t)
1605 mainCtrl.SetResetTestFlag(t, false)
1607 resp, _ := xapp.Subscription.QuerySubscriptions()
1608 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
1609 assert.Equal(t, resp[0].Endpoint, []string{"localhost:13560"})
1610 e2SubsId := uint32(resp[0].SubscriptionID)
1611 t.Logf("e2SubsId = %v", e2SubsId)
1613 mainCtrl.SimulateRestart(t) // This will trigger sending of SubDelReq
1615 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1616 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1618 // Wait that subs is cleaned
1619 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1621 xappConn1.TestMsgChanEmpty(t)
1622 xappConn2.TestMsgChanEmpty(t)
1623 e2termConn1.TestMsgChanEmpty(t)
1624 mainCtrl.wait_registry_empty(t, 10)
1627 //-----------------------------------------------------------------------------
1628 // TestSubReqAndSubDelOkWithRestartInMiddle
1631 // +-------+ +---------+ +---------+
1632 // | xapp | | submgr | | e2term |
1633 // +-------+ +---------+ +---------+
1636 // |------------->| |
1639 // | |------------->|
1642 // | |<-------------|
1645 // |<-------------| |
1648 // | Submgr restart |
1651 // |------------->| |
1654 // | |------------->|
1657 // | |<-------------|
1660 // |<-------------| |
1662 //-----------------------------------------------------------------------------
1664 func TestSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
1665 CaseBegin("TestSubReqAndSubDelOkWithRestartInMiddle")
1667 cretrans := xappConn1.SendSubsReq(t, nil, nil)
1668 crereq, cremsg := e2termConn1.RecvSubsReq(t)
1669 e2termConn1.SendSubsResp(t, crereq, cremsg)
1670 e2SubsId := xappConn1.RecvSubsResp(t, cretrans)
1672 // Check subscription
1673 resp, _ := xapp.Subscription.QuerySubscriptions()
1674 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
1675 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
1676 assert.Equal(t, resp[0].Endpoint, []string{"localhost:13560"})
1678 mainCtrl.SimulateRestart(t)
1680 // Check that subscription is restored correctly after restart
1681 resp, _ = xapp.Subscription.QuerySubscriptions()
1682 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
1683 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
1684 assert.Equal(t, resp[0].Endpoint, []string{"localhost:13560"})
1686 deltrans := xappConn1.SendSubsDelReq(t, nil, e2SubsId)
1687 delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
1688 e2termConn1.SendSubsDelResp(t, delreq, delmsg)
1689 xappConn1.RecvSubsDelResp(t, deltrans)
1691 //Wait that subs is cleaned
1692 mainCtrl.wait_subs_clean(t, e2SubsId, 10)
1694 xappConn1.TestMsgChanEmpty(t)
1695 xappConn2.TestMsgChanEmpty(t)
1696 e2termConn1.TestMsgChanEmpty(t)
1697 mainCtrl.wait_registry_empty(t, 10)
1700 //-----------------------------------------------------------------------------
1701 // TestSubReqAndSubDelOkSameActionWithRestartsInMiddle
1704 // +-------+ +-------+ +---------+ +---------+
1705 // | xapp2 | | xapp1 | | submgr | | e2term |
1706 // +-------+ +-------+ +---------+ +---------+
1711 // | |------------->| |
1714 // | | |------------->|
1716 // | | |<-------------|
1718 // | |<-------------| |
1721 // | submgr restart |
1726 // |--------------------------->| |
1729 // |<---------------------------| |
1731 // | | SubDelReq 1 | |
1732 // | |------------->| |
1734 // | | SubDelResp 1 | |
1735 // | |<-------------| |
1739 // | submgr restart |
1742 // | SubDelReq 2 | |
1743 // |--------------------------->| |
1745 // | | | SubDelReq 2 |
1746 // | | |------------->|
1748 // | | | SubDelReq 2 |
1749 // | | |------------->|
1751 // | SubDelResp 2 | |
1752 // |<---------------------------| |
1754 //-----------------------------------------------------------------------------
1756 func TestSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
1757 CaseBegin("TestSubReqAndSubDelOkSameActionWithRestartsInMiddle")
1760 rparams1 := &teststube2ap.E2StubSubsReqParams{}
1762 cretrans1 := xappConn1.SendSubsReq(t, rparams1, nil)
1763 crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
1764 e2termConn1.SendSubsResp(t, crereq1, cremsg1)
1765 e2SubsId1 := xappConn1.RecvSubsResp(t, cretrans1)
1768 rparams2 := &teststube2ap.E2StubSubsReqParams{}
1770 cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
1771 e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
1773 // Check subscription
1774 resp, _ := xapp.Subscription.QuerySubscriptions() ////////////////////////////////
1775 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
1776 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
1777 assert.Equal(t, resp[0].Endpoint, []string{"localhost:13560", "localhost:13660"})
1779 mainCtrl.SimulateRestart(t)
1781 // Check that subscription is restored correctly after restart
1782 resp, _ = xapp.Subscription.QuerySubscriptions()
1783 assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
1784 assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
1785 assert.Equal(t, resp[0].Endpoint, []string{"localhost:13560", "localhost:13660"})
1788 deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
1789 xapp.Logger.Debug("xappConn1.RecvSubsDelResp")
1790 xappConn1.RecvSubsDelResp(t, deltrans1)
1791 xapp.Logger.Debug("xappConn1.RecvSubsDelResp received")
1793 mainCtrl.SimulateRestart(t)
1794 xapp.Logger.Debug("mainCtrl.SimulateRestart done")
1797 deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
1798 delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
1800 e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
1801 xappConn2.RecvSubsDelResp(t, deltrans2)
1803 //Wait that subs is cleaned
1804 mainCtrl.wait_subs_clean(t, e2SubsId2, 10)
1806 xappConn1.TestMsgChanEmpty(t)
1807 xappConn2.TestMsgChanEmpty(t)
1808 e2termConn1.TestMsgChanEmpty(t)
1809 mainCtrl.wait_registry_empty(t, 10)